#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(double *);
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 double_stencil27(unsigned int size) {
  int i, j, k, iter;
  int n = size - 2;
  double fac = 1.0 / 26;
  double *a0 = (double *)malloc(sizeof(double) * size * size * size);
  double *a1 = (double *)malloc(sizeof(double) * size * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "27-point Double 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] =
            (double)rand() / (double)(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, "Double Precision Stencil - 27 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<double_stencil27>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x18(%rbp)
movsd  0xe44(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x3,%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    $0x3,%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 <double_stencil27+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1223 <double_stencil27+0x83>
lea    0xdf2(%rip),%rdi
call   1060 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12b5 <double_stencil27+0x115>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12a2 <double_stencil27+0x102>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    128f <double_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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1250 <double_stencil27+0xb0>
jmp    1294 <double_stencil27+0xf4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123d <double_stencil27+0x9d>
jmp    12a7 <double_stencil27+0x107>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    122a <double_stencil27+0x8a>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    137b <double_stencil27+0x1db>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1368 <double_stencil27+0x1c8>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1355 <double_stencil27+0x1b5>
mov    $0x0,%al
call   10c0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x2cd8(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xceb(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12ec <double_stencil27+0x14c>
jmp    135a <double_stencil27+0x1ba>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12d4 <double_stencil27+0x134>
jmp    136d <double_stencil27+0x1cd>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12bc <double_stencil27+0x11c>
mov    $0x0,%al
call   10a0 <rapl_init@plt>
mov    $0x0,%al
call   1070 <rapl_start@plt>
mov    0x2c50(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1050 <clock_gettime@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    195c <double_stencil27+0x7bc>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1889 <double_stencil27+0x6e9>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1876 <double_stencil27+0x6d6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1863 <double_stencil27+0x6c3>
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
movsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%xmm0
mulsd  -0x20(%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13e3 <double_stencil27+0x243>
jmp    1868 <double_stencil27+0x6c8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13cb <double_stencil27+0x22b>
jmp    187b <double_stencil27+0x6db>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b3 <double_stencil27+0x213>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1949 <double_stencil27+0x7a9>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1936 <double_stencil27+0x796>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1923 <double_stencil27+0x783>
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
movsd  (%rax,%rcx,8),%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    18c0 <double_stencil27+0x720>
jmp    1928 <double_stencil27+0x788>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18a8 <double_stencil27+0x708>
jmp    193b <double_stencil27+0x79b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1890 <double_stencil27+0x6f0>
jmp    194e <double_stencil27+0x7ae>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13a2 <double_stencil27+0x202>
mov    0x267d(%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    0x6cb(%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):
<double_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    $0x3,%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 <double_stencil27+0x4f>
test   %rax,%rax
jne    11fb <double_stencil27+0x5b>
lea    0xe3e(%rip),%rdi
call   1050 <puts@plt>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
xor    %ecx,%ecx
mov    0x30(%rsp),%r8
mov    %r8d,%esi
test   %r8d,%r8d
mov    %r13,0x48(%rsp)
mov    %rsi,0x38(%rsp)
je     14f8 <double_stencil27+0x358>
lea    -0x1(%rsi),%r14
mov    %esi,%r12d
and    $0xfffffffc,%r12d
lea    -0x4(%r12),%r11
mov    %r11,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r15d
and    $0x3,%r15d
and    %rax,%rdx
mov    %rdx,0x18(%rsp)
mov    %esi,%r9d
and    $0x3,%r9d
mov    $0x8,%r10d
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1296 <double_stencil27+0xf6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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     142c <double_stencil27+0x28c>
mov    %rcx,0x28(%rsp)
imul   %ecx,%r13d
mov    %rax,%rcx
xor    %edi,%edi
mov    %rax,0x20(%rsp)
mov    %r10d,0x10(%rsp)
jmp    12be <double_stencil27+0x11e>
add    $0x1,%edi
add    %r8d,%r10d
add    %rsi,%rcx
cmp    %r8d,%edi
je     1270 <double_stencil27+0xd0>
cmp    $0x4,%r8d
jae    1300 <double_stencil27+0x160>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rsi,%rax
test   %r9,%r9
je     1330 <double_stencil27+0x190>
mov    %r9,%rsi
mov    0x8(%rsp),%rbx
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%edx
movq   $0x0,(%rbx,%rdx,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
jne    12e0 <double_stencil27+0x140>
jmp    1335 <double_stencil27+0x195>
nopw   0x0(%rax,%rax,1)
mov    %edi,%eax
imul   %r8d,%eax
add    %r13d,%eax
add    %r14d,%eax
jb     12c4 <double_stencil27+0x124>
mov    %r14,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12c6 <double_stencil27+0x126>
cmp    $0xc,%r11
jae    138d <double_stencil27+0x1ed>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
jmp    13e9 <double_stencil27+0x249>
xchg   %ax,%ax
mov    0x8(%rsp),%rbx
cmp    $0x3,%rax
mov    0x38(%rsp),%rsi
jb     12b0 <double_stencil27+0x110>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rbp,1),%rax
mov    %eax,%edx
movq   $0x0,(%rbx,%rdx,8)
lea    0x1(%rax),%edx
movq   $0x0,(%rbx,%rdx,8)
lea    0x2(%rax),%edx
movq   $0x0,(%rbx,%rdx,8)
add    $0x3,%eax
movq   $0x0,(%rbx,%rax,8)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    1350 <double_stencil27+0x1b0>
jmp    12b0 <double_stencil27+0x110>
mov    0x18(%rsp),%rax
mov    %r10d,%r8d
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
nopl   0x0(%rax)
lea    -0x8(%r8),%esi
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm0,0x10(%rdx,%rsi,8)
lea    -0x4(%r8),%esi
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm0,0x10(%rdx,%rsi,8)
mov    %r8d,%esi
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm0,0x10(%rdx,%rsi,8)
lea    0x4(%r8),%esi
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm0,0x10(%rdx,%rsi,8)
add    $0x10,%rbp
add    $0x10,%r8d
add    $0xfffffffffffffffc,%rax
jne    13a0 <double_stencil27+0x200>
test   %r15,%r15
mov    0x30(%rsp),%r8
je     1416 <double_stencil27+0x276>
add    %ecx,%ebp
mov    %r15,%rax
nopl   0x0(%rax,%rax,1)
mov    %ebp,%esi
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm0,0x10(%rdx,%rsi,8)
add    $0x4,%ebp
add    $0xffffffffffffffff,%rax
jne    1400 <double_stencil27+0x260>
mov    %r12,%rbp
mov    0x38(%rsp),%rsi
cmp    %rsi,%r12
je     12b0 <double_stencil27+0x110>
jmp    12c6 <double_stencil27+0x126>
lea    -0x1(%r8),%ebx
cmp    $0x2,%ebx
setge  %al
jl     1506 <double_stencil27+0x366>
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    0x2b84(%rip),%r15
mov    %ebx,0x18(%rsp)
mov    0x8(%rsp),%rbp
nopl   (%rax)
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  0xb61(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq (%r15),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    %ebx,%eax
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%ebx
add    $0xffffffffffffffff,%r13
jne    1490 <double_stencil27+0x2f0>
add    $0x1,%r12d
add    0x30(%rsp),%r14d
mov    0x18(%rsp),%ebx
cmp    %ebx,%r12d
jne    1480 <double_stencil27+0x2e0>
mov    0x40(%rsp),%eax
add    $0x1,%eax
mov    0x48(%rsp),%r13
mov    0x20(%rsp),%r14d
add    %r13d,%r14d
cmp    %ebx,%eax
jne    1470 <double_stencil27+0x2d0>
jmp    150d <double_stencil27+0x36d>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0xffffffff,%ebx
jmp    150d <double_stencil27+0x36d>
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    0x2abc(%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    -0x8(%rbx,%rsi,8),%r9
mov    0x50(%rsp),%rdi
lea    -0x8(%rdi,%rsi,8),%rcx
lea    -0x5(%rsi),%rax
mov    %rax,0x128(%rsp)
mov    %rax,%rdx
shr    $0x2,%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    $0xfffffffffffffffc,%rax
mov    %rax,0x118(%rsp)
add    $0x1,%rax
mov    %rax,0x110(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
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    $0x5,%eax
mov    %eax,0x70(%rsp)
movsd  0x9da(%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    1674 <double_stencil27+0x4d4>
xchg   %ax,%ax
mov    0xb8(%rsp),%rbp
add    $0x1,%ebp
cmp    $0x64,%ebp
je     1bd5 <double_stencil27+0xa35>
mov    %rbp,0xb8(%rsp)
cmpb   $0x0,0x28(%rsp)
je     1660 <double_stencil27+0x4c0>
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
movsd  (%rbx,%rax,8),%xmm1
lea    (%rsi,%rbp,1),%rax
lea    0x1(%rax),%esi
addsd  (%rbx,%rsi,8),%xmm1
mov    0x18(%rsp),%rdx
lea    (%rdx,%rbp,1),%r9
lea    0x1(%r9),%esi
addsd  (%rbx,%rsi,8),%xmm1
lea    (%r11,%rbp,1),%r14
lea    0x1(%r14),%esi
addsd  (%rbx,%rsi,8),%xmm1
lea    (%r10,%rbp,1),%rsi
lea    0x1(%rsi),%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r8,%r10
lea    (%r8,%rbp,1),%r8
lea    0x1(%r8),%edx
addsd  (%rbx,%rdx,8),%xmm1
lea    0x0(%r13,%rbp,1),%r12
lea    0x1(%r12),%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%r13
lea    0x1(%r13),%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %edi,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %eax,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r9d,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r14d,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %esi,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r8d,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r12d,%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    %r13d,%edx
addsd  (%rbx,%rdx,8),%xmm1
add    $0x2,%edi
addsd  (%rbx,%rdi,8),%xmm1
mov    0x50(%rsp),%r15
add    $0x2,%eax
addsd  (%rbx,%rax,8),%xmm1
add    $0x2,%r9d
addsd  (%rbx,%r9,8),%xmm1
mov    0x18(%rsp),%rdi
add    $0x2,%r14d
addsd  (%rbx,%r14,8),%xmm1
add    $0x2,%esi
addsd  (%rbx,%rsi,8),%xmm1
mov    0x148(%rsp),%rsi
add    $0x2,%r8d
addsd  (%rbx,%r8,8),%xmm1
mov    %r10,%r8
mov    0x20(%rsp),%r10
add    $0x2,%r12d
addsd  (%rbx,%r12,8),%xmm1
add    $0x2,%r13d
addsd  (%rbx,%r13,8),%xmm1
mov    0x140(%rsp),%r11
mov    0x150(%rsp),%r13
mov    0x40(%rsp),%r12
lea    (%r12,%rbp,1),%rax
mov    %eax,%edx
addsd  (%rbx,%rdx,8),%xmm1
lea    0x2(%rax),%edx
addsd  (%rbx,%rdx,8),%xmm1
mov    0x138(%rsp),%rdx
mulsd  %xmm0,%xmm1
add    $0x1,%eax
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rbp
mov    %rdx,%rax
add    %rbp,%rax
jne    1780 <double_stencil27+0x5e0>
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    1740 <double_stencil27+0x5a0>
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    16d0 <double_stencil27+0x530>
cmpb   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r8
mov    0x88(%rsp),%r11
mov    %r14,%rdi
mov    0x8(%rsp),%rbx
je     1660 <double_stencil27+0x4c0>
mov    $0x1,%eax
xor    %esi,%esi
mov    0x80(%rsp),%rbp
mov    0x70(%rsp),%r9d
jmp    19fb <double_stencil27+0x85b>
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     1660 <double_stencil27+0x4c0>
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    1a45 <double_stencil27+0x8a5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10d
add    $0x1,%r14d
add    %r8d,%r9d
add    0x38(%rsp),%rsi
cmp    %ecx,%r10d
je     19d0 <double_stencil27+0x830>
mov    $0x1,%ebp
cmp    $0x4,%r11
jb     1b40 <double_stencil27+0x9a0>
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    1b40 <double_stencil27+0x9a0>
cmpq   $0x4,0x128(%rsp)
jae    1a9e <double_stencil27+0x8fe>
xor    %eax,%eax
mov    0x50(%rsp),%r8
jmp    1aee <double_stencil27+0x94e>
mov    0x108(%rsp),%rdx
mov    %r9d,%ebp
xor    %eax,%eax
mov    0x50(%rsp),%r8
lea    -0x4(%rbp),%edi
movups (%r8,%rdi,8),%xmm1
movups 0x10(%r8,%rdi,8),%xmm2
movups %xmm1,(%rbx,%rdi,8)
movups %xmm2,0x10(%rbx,%rdi,8)
mov    %ebp,%edi
movupd (%r8,%rdi,8),%xmm1
movupd 0x10(%r8,%rdi,8),%xmm2
movupd %xmm1,(%rbx,%rdi,8)
movupd %xmm2,0x10(%rbx,%rdi,8)
add    $0x8,%rax
add    $0x8,%ebp
add    $0xfffffffffffffffe,%rdx
jne    1ab0 <double_stencil27+0x910>
testb  $0x1,0x120(%rsp)
01
mov    %r8,%rdi
mov    0x30(%rsp),%r8
je     1b23 <double_stencil27+0x983>
lea    (%r10,%r12,1),%edx
imul   %r8d,%edx
or     $0x1,%eax
add    %edx,%eax
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
movupd %xmm1,(%rbx,%rax,8)
movupd %xmm2,0x10(%rbx,%rax,8)
mov    0x110(%rsp),%rbp
cmp    0x118(%rsp),%r11
je     1a30 <double_stencil27+0x890>
nopl   0x0(%rax)
mov    %ecx,%edx
sub    %ebp,%edx
mov    %rbp,%rax
not    %rax
add    %rcx,%rax
mov    %rdi,%rcx
and    $0x3,%rdx
je     1b77 <double_stencil27+0x9d7>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rbp,1),%edi
movsd  (%rcx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1b60 <double_stencil27+0x9c0>
cmp    $0x3,%rax
mov    %rcx,%rdi
mov    0x58(%rsp),%rcx
jb     1a30 <double_stencil27+0x890>
nopl   0x0(%rax)
lea    (%rsi,%rbp,1),%rax
mov    %eax,%edx
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
lea    0x1(%rax),%edx
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
lea    0x2(%rax),%edx
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x3,%eax
movsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1b90 <double_stencil27+0x9f0>
jmp    1a30 <double_stencil27+0x890>
mov    %rdi,%rbp
mov    0x2401(%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    0x408(%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 Double 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"Double Precision Stencil - 27 point\00"
define void @double_stencil27(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
%9 = alloca double*
%10 = alloca double*
%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 double 0x3FA3B13B13B13B14, double* %8
%15 = load i32, i32* %2
%16 = zext i32 %15 to i64
%17 = mul i64 8, %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 double*
store double* %26, double** %9
%27 = load i32, i32* %2
%28 = zext i32 %27 to i64
%29 = mul i64 8, %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 double*
store double* %38, double** %10
%39 = load double*, double** %9
%40 = icmp eq double* %39, null
br i1 %40, label %44, label %41
41: ; preds = %1
%42 = load double*, double** %10
%43 = icmp eq double* %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 double*, double** %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 double, double* %62, i64 %74
store double 0.000000e+00, double* %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 = %134, %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 %137
93: ; preds = %88
store i32 1, i32* %4
br label %94
94: ; preds = %130, %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 %133
99: ; preds = %94
store i32 1, i32* %5
br label %100
100: ; preds = %126, %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 %129
105: ; preds = %100
%106 = call i64 (...) @rand()
%107 = sitofp i64 %106 to double
%108 = load i64, i64* @RAND_MAX
%109 = sitofp i64 %108 to double
%110 = fadd double 1.000000e+00, %109
%111 = fdiv double %107, %110
%112 = load double*, double** %9
%113 = load i32, i32* %3
%114 = load i32, i32* %2
%115 = mul i32 %113, %114
%116 = load i32, i32* %2
%117 = mul i32 %115, %116
%118 = load i32, i32* %4
%119 = load i32, i32* %2
%120 = mul i32 %118, %119
%121 = add i32 %117, %120
%122 = load i32, i32* %5
%123 = add i32 %121, %122
%124 = zext i32 %123 to i64
%125 = getelementptr inbounds double, double* %112, i64 %124
store double %111, double* %125
br label %126
126: ; preds = %105
%127 = load i32, i32* %5
%128 = add nsw i32 %127, 1
store i32 %128, i32* %5
br label %100
129: ; preds = %100
br label %130
130: ; preds = %129
%131 = load i32, i32* %4
%132 = add nsw i32 %131, 1
store i32 %132, i32* %4
br label %94
133: ; preds = %94
br label %134
134: ; preds = %133
%135 = load i32, i32* %3
%136 = add nsw i32 %135, 1
store i32 %136, i32* %3
br label %88
137: ; preds = %88
%138 = call i32 (...) @rapl_init()
%139 = call i32 (...) @rapl_start()
%140 = load i32, i32* @CLOCK_MONOTONIC_RAW
%141 = call i32 @clock_gettime(i32 %140, %struct.timespec* %11)
store i32 0, i32* %6
br label %142
142: ; preds = %720, %137
%143 = load i32, i32* %6
%144 = icmp slt i32 %143, 100
br i1 %144, label %145, label %723
145: ; preds = %142
store i32 1, i32* %3
br label %146
146: ; preds = %657, %145
%147 = load i32, i32* %3
%148 = load i32, i32* %7
%149 = add nsw i32 %148, 1
%150 = icmp slt i32 %147, %149
br i1 %150, label %151, label %660
151: ; preds = %146
store i32 1, i32* %4
br label %152
152: ; preds = %653, %151
%153 = load i32, i32* %4
%154 = load i32, i32* %7
%155 = add nsw i32 %154, 1
%156 = icmp slt i32 %153, %155
br i1 %156, label %157, label %656
157: ; preds = %152
store i32 1, i32* %5
br label %158
158: ; preds = %649, %157
%159 = load i32, i32* %5
%160 = load i32, i32* %7
%161 = add nsw i32 %160, 1
%162 = icmp slt i32 %159, %161
br i1 %162, label %163, label %652
163: ; preds = %158
%164 = load double*, double** %9
%165 = load i32, i32* %3
%166 = load i32, i32* %2
%167 = mul i32 %165, %166
%168 = load i32, i32* %2
%169 = mul i32 %167, %168
%170 = load i32, i32* %4
%171 = sub nsw i32 %170, 1
%172 = load i32, i32* %2
%173 = mul i32 %171, %172
%174 = add i32 %169, %173
%175 = load i32, i32* %5
%176 = add i32 %174, %175
%177 = zext i32 %176 to i64
%178 = getelementptr inbounds double, double* %164, i64 %177
%179 = load double, double* %178
%180 = load double*, double** %9
%181 = load i32, i32* %3
%182 = load i32, i32* %2
%183 = mul i32 %181, %182
%184 = load i32, i32* %2
%185 = mul i32 %183, %184
%186 = load i32, i32* %4
%187 = add nsw i32 %186, 1
%188 = load i32, i32* %2
%189 = mul i32 %187, %188
%190 = add i32 %185, %189
%191 = load i32, i32* %5
%192 = add i32 %190, %191
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds double, double* %180, i64 %193
%195 = load double, double* %194
%196 = fadd double %179, %195
%197 = load double*, double** %9
%198 = load i32, i32* %3
%199 = sub nsw i32 %198, 1
%200 = load i32, i32* %2
%201 = mul i32 %199, %200
%202 = load i32, i32* %2
%203 = mul i32 %201, %202
%204 = load i32, i32* %4
%205 = load i32, i32* %2
%206 = mul i32 %204, %205
%207 = add i32 %203, %206
%208 = load i32, i32* %5
%209 = add i32 %207, %208
%210 = zext i32 %209 to i64
%211 = getelementptr inbounds double, double* %197, i64 %210
%212 = load double, double* %211
%213 = fadd double %196, %212
%214 = load double*, double** %9
%215 = load i32, i32* %3
%216 = add nsw i32 %215, 1
%217 = load i32, i32* %2
%218 = mul i32 %216, %217
%219 = load i32, i32* %2
%220 = mul i32 %218, %219
%221 = load i32, i32* %4
%222 = load i32, i32* %2
%223 = mul i32 %221, %222
%224 = add i32 %220, %223
%225 = load i32, i32* %5
%226 = add i32 %224, %225
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds double, double* %214, i64 %227
%229 = load double, double* %228
%230 = fadd double %213, %229
%231 = load double*, double** %9
%232 = load i32, i32* %3
%233 = sub nsw i32 %232, 1
%234 = load i32, i32* %2
%235 = mul i32 %233, %234
%236 = load i32, i32* %2
%237 = mul i32 %235, %236
%238 = load i32, i32* %4
%239 = sub nsw i32 %238, 1
%240 = load i32, i32* %2
%241 = mul i32 %239, %240
%242 = add i32 %237, %241
%243 = load i32, i32* %5
%244 = add i32 %242, %243
%245 = zext i32 %244 to i64
%246 = getelementptr inbounds double, double* %231, i64 %245
%247 = load double, double* %246
%248 = fadd double %230, %247
%249 = load double*, double** %9
%250 = load i32, i32* %3
%251 = sub nsw i32 %250, 1
%252 = load i32, i32* %2
%253 = mul i32 %251, %252
%254 = load i32, i32* %2
%255 = mul i32 %253, %254
%256 = load i32, i32* %4
%257 = add nsw i32 %256, 1
%258 = load i32, i32* %2
%259 = mul i32 %257, %258
%260 = add i32 %255, %259
%261 = load i32, i32* %5
%262 = add i32 %260, %261
%263 = zext i32 %262 to i64
%264 = getelementptr inbounds double, double* %249, i64 %263
%265 = load double, double* %264
%266 = fadd double %248, %265
%267 = load double*, double** %9
%268 = load i32, i32* %3
%269 = add nsw i32 %268, 1
%270 = load i32, i32* %2
%271 = mul i32 %269, %270
%272 = load i32, i32* %2
%273 = mul i32 %271, %272
%274 = load i32, i32* %4
%275 = sub nsw i32 %274, 1
%276 = load i32, i32* %2
%277 = mul i32 %275, %276
%278 = add i32 %273, %277
%279 = load i32, i32* %5
%280 = add i32 %278, %279
%281 = zext i32 %280 to i64
%282 = getelementptr inbounds double, double* %267, i64 %281
%283 = load double, double* %282
%284 = fadd double %266, %283
%285 = load double*, double** %9
%286 = load i32, i32* %3
%287 = add nsw i32 %286, 1
%288 = load i32, i32* %2
%289 = mul i32 %287, %288
%290 = load i32, i32* %2
%291 = mul i32 %289, %290
%292 = load i32, i32* %4
%293 = add nsw i32 %292, 1
%294 = load i32, i32* %2
%295 = mul i32 %293, %294
%296 = add i32 %291, %295
%297 = load i32, i32* %5
%298 = add i32 %296, %297
%299 = zext i32 %298 to i64
%300 = getelementptr inbounds double, double* %285, i64 %299
%301 = load double, double* %300
%302 = fadd double %284, %301
%303 = load double*, double** %9
%304 = load i32, i32* %3
%305 = load i32, i32* %2
%306 = mul i32 %304, %305
%307 = load i32, i32* %2
%308 = mul i32 %306, %307
%309 = load i32, i32* %4
%310 = sub nsw i32 %309, 1
%311 = load i32, i32* %2
%312 = mul i32 %310, %311
%313 = add i32 %308, %312
%314 = load i32, i32* %5
%315 = sub nsw i32 %314, 1
%316 = add i32 %313, %315
%317 = zext i32 %316 to i64
%318 = getelementptr inbounds double, double* %303, i64 %317
%319 = load double, double* %318
%320 = fadd double %302, %319
%321 = load double*, double** %9
%322 = load i32, i32* %3
%323 = load i32, i32* %2
%324 = mul i32 %322, %323
%325 = load i32, i32* %2
%326 = mul i32 %324, %325
%327 = load i32, i32* %4
%328 = add nsw i32 %327, 1
%329 = load i32, i32* %2
%330 = mul i32 %328, %329
%331 = add i32 %326, %330
%332 = load i32, i32* %5
%333 = sub nsw i32 %332, 1
%334 = add i32 %331, %333
%335 = zext i32 %334 to i64
%336 = getelementptr inbounds double, double* %321, i64 %335
%337 = load double, double* %336
%338 = fadd double %320, %337
%339 = load double*, double** %9
%340 = load i32, i32* %3
%341 = sub nsw i32 %340, 1
%342 = load i32, i32* %2
%343 = mul i32 %341, %342
%344 = load i32, i32* %2
%345 = mul i32 %343, %344
%346 = load i32, i32* %4
%347 = load i32, i32* %2
%348 = mul i32 %346, %347
%349 = add i32 %345, %348
%350 = load i32, i32* %5
%351 = sub nsw i32 %350, 1
%352 = add i32 %349, %351
%353 = zext i32 %352 to i64
%354 = getelementptr inbounds double, double* %339, i64 %353
%355 = load double, double* %354
%356 = fadd double %338, %355
%357 = load double*, double** %9
%358 = load i32, i32* %3
%359 = add nsw i32 %358, 1
%360 = load i32, i32* %2
%361 = mul i32 %359, %360
%362 = load i32, i32* %2
%363 = mul i32 %361, %362
%364 = load i32, i32* %4
%365 = load i32, i32* %2
%366 = mul i32 %364, %365
%367 = add i32 %363, %366
%368 = load i32, i32* %5
%369 = sub nsw i32 %368, 1
%370 = add i32 %367, %369
%371 = zext i32 %370 to i64
%372 = getelementptr inbounds double, double* %357, i64 %371
%373 = load double, double* %372
%374 = fadd double %356, %373
%375 = load double*, double** %9
%376 = load i32, i32* %3
%377 = sub nsw i32 %376, 1
%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 = sub nsw i32 %387, 1
%389 = add i32 %386, %388
%390 = zext i32 %389 to i64
%391 = getelementptr inbounds double, double* %375, i64 %390
%392 = load double, double* %391
%393 = fadd double %374, %392
%394 = load double*, double** %9
%395 = load i32, i32* %3
%396 = sub nsw i32 %395, 1
%397 = load i32, i32* %2
%398 = mul i32 %396, %397
%399 = load i32, i32* %2
%400 = mul i32 %398, %399
%401 = load i32, i32* %4
%402 = add nsw i32 %401, 1
%403 = load i32, i32* %2
%404 = mul i32 %402, %403
%405 = add i32 %400, %404
%406 = load i32, i32* %5
%407 = sub nsw i32 %406, 1
%408 = add i32 %405, %407
%409 = zext i32 %408 to i64
%410 = getelementptr inbounds double, double* %394, i64 %409
%411 = load double, double* %410
%412 = fadd double %393, %411
%413 = load double*, double** %9
%414 = load i32, i32* %3
%415 = add nsw i32 %414, 1
%416 = load i32, i32* %2
%417 = mul i32 %415, %416
%418 = load i32, i32* %2
%419 = mul i32 %417, %418
%420 = load i32, i32* %4
%421 = sub nsw i32 %420, 1
%422 = load i32, i32* %2
%423 = mul i32 %421, %422
%424 = add i32 %419, %423
%425 = load i32, i32* %5
%426 = sub nsw i32 %425, 1
%427 = add i32 %424, %426
%428 = zext i32 %427 to i64
%429 = getelementptr inbounds double, double* %413, i64 %428
%430 = load double, double* %429
%431 = fadd double %412, %430
%432 = load double*, double** %9
%433 = load i32, i32* %3
%434 = add nsw i32 %433, 1
%435 = load i32, i32* %2
%436 = mul i32 %434, %435
%437 = load i32, i32* %2
%438 = mul i32 %436, %437
%439 = load i32, i32* %4
%440 = add nsw i32 %439, 1
%441 = load i32, i32* %2
%442 = mul i32 %440, %441
%443 = add i32 %438, %442
%444 = load i32, i32* %5
%445 = sub nsw i32 %444, 1
%446 = add i32 %443, %445
%447 = zext i32 %446 to i64
%448 = getelementptr inbounds double, double* %432, i64 %447
%449 = load double, double* %448
%450 = fadd double %431, %449
%451 = load double*, double** %9
%452 = load i32, i32* %3
%453 = load i32, i32* %2
%454 = mul i32 %452, %453
%455 = load i32, i32* %2
%456 = mul i32 %454, %455
%457 = load i32, i32* %4
%458 = sub nsw i32 %457, 1
%459 = load i32, i32* %2
%460 = mul i32 %458, %459
%461 = add i32 %456, %460
%462 = load i32, i32* %5
%463 = add nsw i32 %462, 1
%464 = add i32 %461, %463
%465 = zext i32 %464 to i64
%466 = getelementptr inbounds double, double* %451, i64 %465
%467 = load double, double* %466
%468 = fadd double %450, %467
%469 = load double*, double** %9
%470 = load i32, i32* %3
%471 = load i32, i32* %2
%472 = mul i32 %470, %471
%473 = load i32, i32* %2
%474 = mul i32 %472, %473
%475 = load i32, i32* %4
%476 = add nsw i32 %475, 1
%477 = load i32, i32* %2
%478 = mul i32 %476, %477
%479 = add i32 %474, %478
%480 = load i32, i32* %5
%481 = add nsw i32 %480, 1
%482 = add i32 %479, %481
%483 = zext i32 %482 to i64
%484 = getelementptr inbounds double, double* %469, i64 %483
%485 = load double, double* %484
%486 = fadd double %468, %485
%487 = load double*, double** %9
%488 = load i32, i32* %3
%489 = sub nsw i32 %488, 1
%490 = load i32, i32* %2
%491 = mul i32 %489, %490
%492 = load i32, i32* %2
%493 = mul i32 %491, %492
%494 = load i32, i32* %4
%495 = load i32, i32* %2
%496 = mul i32 %494, %495
%497 = add i32 %493, %496
%498 = load i32, i32* %5
%499 = add nsw i32 %498, 1
%500 = add i32 %497, %499
%501 = zext i32 %500 to i64
%502 = getelementptr inbounds double, double* %487, i64 %501
%503 = load double, double* %502
%504 = fadd double %486, %503
%505 = load double*, double** %9
%506 = load i32, i32* %3
%507 = add nsw i32 %506, 1
%508 = load i32, i32* %2
%509 = mul i32 %507, %508
%510 = load i32, i32* %2
%511 = mul i32 %509, %510
%512 = load i32, i32* %4
%513 = load i32, i32* %2
%514 = mul i32 %512, %513
%515 = add i32 %511, %514
%516 = load i32, i32* %5
%517 = add nsw i32 %516, 1
%518 = add i32 %515, %517
%519 = zext i32 %518 to i64
%520 = getelementptr inbounds double, double* %505, i64 %519
%521 = load double, double* %520
%522 = fadd double %504, %521
%523 = load double*, double** %9
%524 = load i32, i32* %3
%525 = sub nsw i32 %524, 1
%526 = load i32, i32* %2
%527 = mul i32 %525, %526
%528 = load i32, i32* %2
%529 = mul i32 %527, %528
%530 = load i32, i32* %4
%531 = sub nsw i32 %530, 1
%532 = load i32, i32* %2
%533 = mul i32 %531, %532
%534 = add i32 %529, %533
%535 = load i32, i32* %5
%536 = add nsw i32 %535, 1
%537 = add i32 %534, %536
%538 = zext i32 %537 to i64
%539 = getelementptr inbounds double, double* %523, i64 %538
%540 = load double, double* %539
%541 = fadd double %522, %540
%542 = load double*, double** %9
%543 = load i32, i32* %3
%544 = sub nsw i32 %543, 1
%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 = add nsw i32 %549, 1
%551 = load i32, i32* %2
%552 = mul i32 %550, %551
%553 = add i32 %548, %552
%554 = load i32, i32* %5
%555 = add nsw i32 %554, 1
%556 = add i32 %553, %555
%557 = zext i32 %556 to i64
%558 = getelementptr inbounds double, double* %542, i64 %557
%559 = load double, double* %558
%560 = fadd double %541, %559
%561 = load double*, double** %9
%562 = load i32, i32* %3
%563 = add nsw i32 %562, 1
%564 = load i32, i32* %2
%565 = mul i32 %563, %564
%566 = load i32, i32* %2
%567 = mul i32 %565, %566
%568 = load i32, i32* %4
%569 = sub nsw i32 %568, 1
%570 = load i32, i32* %2
%571 = mul i32 %569, %570
%572 = add i32 %567, %571
%573 = load i32, i32* %5
%574 = add nsw i32 %573, 1
%575 = add i32 %572, %574
%576 = zext i32 %575 to i64
%577 = getelementptr inbounds double, double* %561, i64 %576
%578 = load double, double* %577
%579 = fadd double %560, %578
%580 = load double*, double** %9
%581 = load i32, i32* %3
%582 = add nsw i32 %581, 1
%583 = load i32, i32* %2
%584 = mul i32 %582, %583
%585 = load i32, i32* %2
%586 = mul i32 %584, %585
%587 = load i32, i32* %4
%588 = add nsw i32 %587, 1
%589 = load i32, i32* %2
%590 = mul i32 %588, %589
%591 = add i32 %586, %590
%592 = load i32, i32* %5
%593 = add nsw i32 %592, 1
%594 = add i32 %591, %593
%595 = zext i32 %594 to i64
%596 = getelementptr inbounds double, double* %580, i64 %595
%597 = load double, double* %596
%598 = fadd double %579, %597
%599 = load double*, double** %9
%600 = load i32, i32* %3
%601 = load i32, i32* %2
%602 = mul i32 %600, %601
%603 = load i32, i32* %2
%604 = mul i32 %602, %603
%605 = load i32, i32* %4
%606 = load i32, i32* %2
%607 = mul i32 %605, %606
%608 = add i32 %604, %607
%609 = load i32, i32* %5
%610 = sub nsw i32 %609, 1
%611 = add i32 %608, %610
%612 = zext i32 %611 to i64
%613 = getelementptr inbounds double, double* %599, i64 %612
%614 = load double, double* %613
%615 = fadd double %598, %614
%616 = load double*, double** %9
%617 = load i32, i32* %3
%618 = load i32, i32* %2
%619 = mul i32 %617, %618
%620 = load i32, i32* %2
%621 = mul i32 %619, %620
%622 = load i32, i32* %4
%623 = load i32, i32* %2
%624 = mul i32 %622, %623
%625 = add i32 %621, %624
%626 = load i32, i32* %5
%627 = add nsw i32 %626, 1
%628 = add i32 %625, %627
%629 = zext i32 %628 to i64
%630 = getelementptr inbounds double, double* %616, i64 %629
%631 = load double, double* %630
%632 = fadd double %615, %631
%633 = load double, double* %8
%634 = fmul double %632, %633
%635 = load double*, double** %10
%636 = load i32, i32* %3
%637 = load i32, i32* %2
%638 = mul i32 %636, %637
%639 = load i32, i32* %2
%640 = mul i32 %638, %639
%641 = load i32, i32* %4
%642 = load i32, i32* %2
%643 = mul i32 %641, %642
%644 = add i32 %640, %643
%645 = load i32, i32* %5
%646 = add i32 %644, %645
%647 = zext i32 %646 to i64
%648 = getelementptr inbounds double, double* %635, i64 %647
store double %634, double* %648
br label %649
649: ; preds = %163
%650 = load i32, i32* %5
%651 = add nsw i32 %650, 1
store i32 %651, i32* %5
br label %158
652: ; preds = %158
br label %653
653: ; preds = %652
%654 = load i32, i32* %4
%655 = add nsw i32 %654, 1
store i32 %655, i32* %4
br label %152
656: ; preds = %152
br label %657
657: ; preds = %656
%658 = load i32, i32* %3
%659 = add nsw i32 %658, 1
store i32 %659, i32* %3
br label %146
660: ; preds = %146
store i32 1, i32* %3
br label %661
661: ; preds = %716, %660
%662 = load i32, i32* %3
%663 = load i32, i32* %7
%664 = add nsw i32 %663, 1
%665 = icmp slt i32 %662, %664
br i1 %665, label %666, label %719
666: ; preds = %661
store i32 1, i32* %4
br label %667
667: ; preds = %712, %666
%668 = load i32, i32* %4
%669 = load i32, i32* %7
%670 = add nsw i32 %669, 1
%671 = icmp slt i32 %668, %670
br i1 %671, label %672, label %715
672: ; preds = %667
store i32 1, i32* %5
br label %673
673: ; preds = %708, %672
%674 = load i32, i32* %5
%675 = load i32, i32* %7
%676 = add nsw i32 %675, 1
%677 = icmp slt i32 %674, %676
br i1 %677, label %678, label %711
678: ; preds = %673
%679 = load double*, double** %10
%680 = load i32, i32* %3
%681 = load i32, i32* %2
%682 = mul i32 %680, %681
%683 = load i32, i32* %2
%684 = mul i32 %682, %683
%685 = load i32, i32* %4
%686 = load i32, i32* %2
%687 = mul i32 %685, %686
%688 = add i32 %684, %687
%689 = load i32, i32* %5
%690 = add i32 %688, %689
%691 = zext i32 %690 to i64
%692 = getelementptr inbounds double, double* %679, i64 %691
%693 = load double, double* %692
%694 = load double*, double** %9
%695 = load i32, i32* %3
%696 = load i32, i32* %2
%697 = mul i32 %695, %696
%698 = load i32, i32* %2
%699 = mul i32 %697, %698
%700 = load i32, i32* %4
%701 = load i32, i32* %2
%702 = mul i32 %700, %701
%703 = add i32 %699, %702
%704 = load i32, i32* %5
%705 = add i32 %703, %704
%706 = zext i32 %705 to i64
%707 = getelementptr inbounds double, double* %694, i64 %706
store double %693, double* %707
br label %708
708: ; preds = %678
%709 = load i32, i32* %5
%710 = add nsw i32 %709, 1
store i32 %710, i32* %5
br label %673
711: ; preds = %673
br label %712
712: ; preds = %711
%713 = load i32, i32* %4
%714 = add nsw i32 %713, 1
store i32 %714, i32* %4
br label %667
715: ; preds = %667
br label %716
716: ; preds = %715
%717 = load i32, i32* %3
%718 = add nsw i32 %717, 1
store i32 %718, i32* %3
br label %661
719: ; preds = %661
br label %720
720: ; preds = %719
%721 = load i32, i32* %6
%722 = add nsw i32 %721, 1
store i32 %722, i32* %6
br label %142
723: ; preds = %142
%724 = load i32, i32* @CLOCK_MONOTONIC_RAW
%725 = call i32 @clock_gettime(i32 %724, %struct.timespec* %12)
%726 = call i32 (...) @rapl_end()
%727 = call i32 (...) @rapl_deinit()
%728 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%729 = load i32, i32* %728
%730 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%731 = load i32, i32* %730
%732 = call i32 @elapsed_time_hr(i32 %729, i32 %731, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
%733 = load double*, double** %9
%734 = call i32 @free(double* %733)
%735 = load double*, double** %10
%736 = call i32 @free(double* %735)
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"Double Precision Stencil - 27 point\00"
@str = [67 x i8] c"27-point Double Precision Stencil Error: Unable to allocate memory\00"
define void @double_stencil27(i32 %0) {
%2 = alloca %struct.timespec
%3 = alloca %struct.timespec
%4 = mul i32 %0, %0
%5 = shl i32 %4, 3
%6 = mul i32 %5, %0
%7 = tail call i64 @malloc(i32 %6)
%8 = inttoptr i64 %7 to double*
%9 = tail call i64 @malloc(i32 %6)
%10 = inttoptr i64 %9 to double*
%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 %185, 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, 4294967292
%25 = add nsw i64 %24, -4
%26 = lshr exact i64 %25, 2
%27 = add nuw nsw i64 %26, 1
%28 = icmp ult i32 %0, 4
%29 = trunc i64 %22 to i32
%30 = icmp ugt i64 %22, 4294967295
%31 = and i64 %21, 4294967292
%32 = and i64 %27, 3
%33 = icmp ult i64 %25, 12
%34 = and i64 %27, 9223372036854775804
%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 %185
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 double, double* %8, i64 %64
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %66
%67 = getelementptr inbounds double, double* %65, i64 2
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %68
%69 = trunc i64 %60 to i32
%70 = or i32 %69, 4
%71 = add i32 %51, %70
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds double, double* %8, i64 %72
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %74
%75 = getelementptr inbounds double, double* %73, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %76
%77 = trunc i64 %60 to i32
%78 = or i32 %77, 8
%79 = add i32 %51, %78
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds double, double* %8, i64 %80
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %82
%83 = getelementptr inbounds double, double* %81, i64 2
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %84
%85 = trunc i64 %60 to i32
%86 = or i32 %85, 12
%87 = add i32 %51, %86
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds double, double* %8, i64 %88
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %90
%91 = getelementptr inbounds double, double* %89, i64 2
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %92
%93 = add nuw i64 %60, 16
%94 = add nuw 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 double, double* %8, i64 %103
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %105
%106 = getelementptr inbounds double, double* %104, i64 2
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %107
%108 = add nuw i64 %99, 4
%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 double, double* %8, i64 %121
store double 0.000000e+00, double* %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 double, double* %8, i64 %133
store double 0.000000e+00, double* %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 double, double* %8, i64 %138
store double 0.000000e+00, double* %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 double, double* %8, i64 %143
store double 0.000000e+00, double* %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 double, double* %8, i64 %148
store double 0.000000e+00, double* %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 = %182, %46
%159 = phi i32 [ 1, %46 ], [ %183, %182 ]
%160 = mul i32 %159, %0
br label %161
161: ; preds = %179, %158
%162 = phi i32 [ 1, %158 ], [ %180, %179 ]
%163 = add i32 %162, %160
%164 = mul i32 %163, %0
br label %165
165: ; preds = %161, %165
%166 = phi i64 [ 1, %161 ], [ %177, %165 ]
%167 = tail call i64 (...) @rand()
%168 = sitofp i64 %167 to double
%169 = load i64, i64* @RAND_MAX
%170 = sitofp i64 %169 to double
%171 = fadd double %170, 1.000000e+00
%172 = fdiv double %168, %171
%173 = trunc i64 %166 to i32
%174 = add i32 %164, %173
%175 = zext i32 %174 to i64
%176 = getelementptr inbounds double, double* %8, i64 %175
store double %172, double* %176
%177 = add nuw nsw i64 %166, 1
%178 = icmp eq i64 %177, %47
br i1 %178, label %179, label %165
179: ; preds = %165
%180 = add nuw nsw i32 %162, 1
%181 = icmp eq i32 %180, %44
br i1 %181, label %182, label %161
182: ; preds = %179
%183 = add nuw nsw i32 %159, 1
%184 = icmp eq i32 %183, %44
br i1 %184, label %185, label %158
185: ; preds = %182, %16, %43
%186 = phi i1 [ false, %43 ], [ false, %16 ], [ %45, %182 ]
%187 = phi i32 [ %44, %43 ], [ -1, %16 ], [ %44, %182 ]
%188 = tail call i32 (...) @rapl_init()
%189 = tail call i32 (...) @rapl_start()
%190 = load i32, i32* @CLOCK_MONOTONIC_RAW
%191 = call i32 @clock_gettime(i32 %190, %struct.timespec* %2)
%192 = zext i32 %187 to i64
%193 = zext i32 %187 to i64
%194 = add nsw i64 %192, -2
%195 = add i32 %0, 1
%196 = mul i32 %195, %0
%197 = add i32 %196, 1
%198 = mul i32 %0, %0
%199 = add nsw i64 %192, -1
%200 = getelementptr double, double* %8, i64 %199
%201 = getelementptr double, double* %10, i64 %199
%202 = add nsw i64 %192, -1
%203 = add nsw i64 %192, -5
%204 = lshr i64 %203, 2
%205 = add nuw nsw i64 %204, 1
%206 = icmp ult i64 %202, 4
%207 = trunc i64 %194 to i32
%208 = icmp ugt i64 %194, 4294967295
%209 = icmp ugt double* %201, %8
%210 = icmp ugt double* %200, %10
%211 = and i1 %209, %210
%212 = and i64 %202, -4
%213 = or i64 %212, 1
%214 = and i64 %205, 1
%215 = icmp ult i64 %203, 4
%216 = and i64 %205, 9223372036854775806
%217 = icmp eq i64 %214, 0
%218 = icmp eq i64 %202, %212
br label %219
219: ; preds = %185, %522
%220 = phi i32 [ 0, %185 ], [ %523, %522 ]
br i1 %186, label %222, label %522
221: ; preds = %388
br i1 %186, label %390, label %522
222: ; preds = %219, %388
%223 = phi i32 [ %227, %388 ], [ 1, %219 ]
%224 = mul i32 %4, %223
%225 = add nsw i32 %223, -1
%226 = mul i32 %4, %225
%227 = add nuw nsw i32 %223, 1
%228 = mul i32 %4, %227
br label %229
229: ; preds = %386, %222
%230 = phi i32 [ 1, %222 ], [ %234, %386 ]
%231 = add nsw i32 %230, -1
%232 = mul i32 %231, %0
%233 = add i32 %232, %224
%234 = add nuw nsw i32 %230, 1
%235 = mul i32 %234, %0
%236 = add i32 %235, %224
%237 = mul i32 %230, %0
%238 = add i32 %237, %226
%239 = add i32 %237, %228
%240 = add i32 %232, %226
%241 = add i32 %235, %226
%242 = add i32 %232, %228
%243 = add i32 %235, %228
%244 = add i32 %237, %224
br label %245
245: ; preds = %229, %245
%246 = phi i64 [ 1, %229 ], [ %329, %245 ]
%247 = trunc i64 %246 to i32
%248 = add i32 %233, %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds double, double* %8, i64 %249
%251 = load double, double* %250
%252 = add i32 %236, %247
%253 = zext i32 %252 to i64
%254 = getelementptr inbounds double, double* %8, i64 %253
%255 = load double, double* %254
%256 = fadd double %251, %255
%257 = add i32 %238, %247
%258 = zext i32 %257 to i64
%259 = getelementptr inbounds double, double* %8, i64 %258
%260 = load double, double* %259
%261 = fadd double %256, %260
%262 = add i32 %239, %247
%263 = zext i32 %262 to i64
%264 = getelementptr inbounds double, double* %8, i64 %263
%265 = load double, double* %264
%266 = fadd double %261, %265
%267 = add i32 %240, %247
%268 = zext i32 %267 to i64
%269 = getelementptr inbounds double, double* %8, i64 %268
%270 = load double, double* %269
%271 = fadd double %266, %270
%272 = add i32 %241, %247
%273 = zext i32 %272 to i64
%274 = getelementptr inbounds double, double* %8, i64 %273
%275 = load double, double* %274
%276 = fadd double %271, %275
%277 = add i32 %242, %247
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds double, double* %8, i64 %278
%280 = load double, double* %279
%281 = fadd double %276, %280
%282 = add i32 %243, %247
%283 = zext i32 %282 to i64
%284 = getelementptr inbounds double, double* %8, i64 %283
%285 = load double, double* %284
%286 = fadd double %281, %285
%287 = trunc i64 %246 to i32
%288 = add i32 %287, -1
%289 = add i32 %288, %233
%290 = zext i32 %289 to i64
%291 = getelementptr inbounds double, double* %8, i64 %290
%292 = load double, double* %291
%293 = fadd double %286, %292
%294 = add i32 %288, %236
%295 = zext i32 %294 to i64
%296 = getelementptr inbounds double, double* %8, i64 %295
%297 = load double, double* %296
%298 = fadd double %293, %297
%299 = add i32 %288, %238
%300 = zext i32 %299 to i64
%301 = getelementptr inbounds double, double* %8, i64 %300
%302 = load double, double* %301
%303 = fadd double %298, %302
%304 = add i32 %288, %239
%305 = zext i32 %304 to i64
%306 = getelementptr inbounds double, double* %8, i64 %305
%307 = load double, double* %306
%308 = fadd double %303, %307
%309 = add i32 %288, %240
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds double, double* %8, i64 %310
%312 = load double, double* %311
%313 = fadd double %308, %312
%314 = add i32 %288, %241
%315 = zext i32 %314 to i64
%316 = getelementptr inbounds double, double* %8, i64 %315
%317 = load double, double* %316
%318 = fadd double %313, %317
%319 = add i32 %288, %242
%320 = zext i32 %319 to i64
%321 = getelementptr inbounds double, double* %8, i64 %320
%322 = load double, double* %321
%323 = fadd double %318, %322
%324 = add i32 %288, %243
%325 = zext i32 %324 to i64
%326 = getelementptr inbounds double, double* %8, i64 %325
%327 = load double, double* %326
%328 = fadd double %323, %327
%329 = add nuw nsw i64 %246, 1
%330 = trunc i64 %329 to i32
%331 = add i32 %233, %330
%332 = zext i32 %331 to i64
%333 = getelementptr inbounds double, double* %8, i64 %332
%334 = load double, double* %333
%335 = fadd double %328, %334
%336 = add i32 %236, %330
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds double, double* %8, i64 %337
%339 = load double, double* %338
%340 = fadd double %335, %339
%341 = add i32 %238, %330
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds double, double* %8, i64 %342
%344 = load double, double* %343
%345 = fadd double %340, %344
%346 = add i32 %239, %330
%347 = zext i32 %346 to i64
%348 = getelementptr inbounds double, double* %8, i64 %347
%349 = load double, double* %348
%350 = fadd double %345, %349
%351 = add i32 %240, %330
%352 = zext i32 %351 to i64
%353 = getelementptr inbounds double, double* %8, i64 %352
%354 = load double, double* %353
%355 = fadd double %350, %354
%356 = add i32 %241, %330
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds double, double* %8, i64 %357
%359 = load double, double* %358
%360 = fadd double %355, %359
%361 = add i32 %242, %330
%362 = zext i32 %361 to i64
%363 = getelementptr inbounds double, double* %8, i64 %362
%364 = load double, double* %363
%365 = fadd double %360, %364
%366 = add i32 %243, %330
%367 = zext i32 %366 to i64
%368 = getelementptr inbounds double, double* %8, i64 %367
%369 = load double, double* %368
%370 = fadd double %365, %369
%371 = add i32 %288, %244
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds double, double* %8, i64 %372
%374 = load double, double* %373
%375 = fadd double %370, %374
%376 = add i32 %244, %330
%377 = zext i32 %376 to i64
%378 = getelementptr inbounds double, double* %8, i64 %377
%379 = load double, double* %378
%380 = fadd double %375, %379
%381 = fmul double %380, 0x3FA3B13B13B13B14
%382 = add i32 %244, %247
%383 = zext i32 %382 to i64
%384 = getelementptr inbounds double, double* %10, i64 %383
store double %381, double* %384
%385 = icmp eq i64 %329, %192
br i1 %385, label %386, label %245
386: ; preds = %245
%387 = icmp eq i32 %234, %187
br i1 %387, label %388, label %229
388: ; preds = %386
%389 = icmp eq i32 %227, %187
br i1 %389, label %221, label %222
390: ; preds = %221, %518
%391 = phi i32 [ %521, %518 ], [ 0, %221 ]
%392 = phi i32 [ %519, %518 ], [ 1, %221 ]
%393 = mul i32 %198, %391
%394 = add i32 %197, %393
%395 = mul i32 %392, %0
br label %396
396: ; preds = %514, %390
%397 = phi i32 [ %517, %514 ], [ 0, %390 ]
%398 = phi i32 [ %515, %514 ], [ 1, %390 ]
%399 = add i32 %398, %395
%400 = mul i32 %399, %0
br i1 %206, label %461, label %401
401: ; preds = %396
%402 = mul i32 %397, %0
%403 = add i32 %394, %402
%404 = xor i32 %403, -1
%405 = icmp ult i32 %404, %207
%406 = or i1 %405, %208
%407 = select i1 %406, i1 true, i1 %211
br i1 %407, label %461, label %408
408: ; preds = %401
br i1 %215, label %443, label %409
409: ; preds = %408, %409
%410 = phi i64 [ %440, %409 ], [ 0, %408 ]
%411 = phi i64 [ %441, %409 ], [ 0, %408 ]
%412 = trunc i64 %410 to i32
%413 = or i32 %412, 1
%414 = add i32 %400, %413
%415 = zext i32 %414 to i64
%416 = getelementptr inbounds double, double* %10, i64 %415
%417 = bitcast double* %416 to <2 x double>*
%418 = load <2 x double>, <2 x double>* %417
%419 = getelementptr inbounds double, double* %416, i64 2
%420 = bitcast double* %419 to <2 x double>*
%421 = load <2 x double>, <2 x double>* %420
%422 = getelementptr inbounds double, double* %8, i64 %415
%423 = bitcast double* %422 to <2 x double>*
store <2 x double> %418, <2 x double>* %423
%424 = getelementptr inbounds double, double* %422, i64 2
%425 = bitcast double* %424 to <2 x double>*
store <2 x double> %421, <2 x double>* %425
%426 = trunc i64 %410 to i32
%427 = or i32 %426, 5
%428 = add i32 %400, %427
%429 = zext i32 %428 to i64
%430 = getelementptr inbounds double, double* %10, i64 %429
%431 = bitcast double* %430 to <2 x double>*
%432 = load <2 x double>, <2 x double>* %431
%433 = getelementptr inbounds double, double* %430, i64 2
%434 = bitcast double* %433 to <2 x double>*
%435 = load <2 x double>, <2 x double>* %434
%436 = getelementptr inbounds double, double* %8, i64 %429
%437 = bitcast double* %436 to <2 x double>*
store <2 x double> %432, <2 x double>* %437
%438 = getelementptr inbounds double, double* %436, i64 2
%439 = bitcast double* %438 to <2 x double>*
store <2 x double> %435, <2 x double>* %439
%440 = add nuw i64 %410, 8
%441 = add i64 %411, 2
%442 = icmp eq i64 %441, %216
br i1 %442, label %443, label %409
443: ; preds = %409, %408
%444 = phi i64 [ 0, %408 ], [ %440, %409 ]
br i1 %217, label %460, label %445
445: ; preds = %443
%446 = trunc i64 %444 to i32
%447 = or i32 %446, 1
%448 = add i32 %400, %447
%449 = zext i32 %448 to i64
%450 = getelementptr inbounds double, double* %10, i64 %449
%451 = bitcast double* %450 to <2 x double>*
%452 = load <2 x double>, <2 x double>* %451
%453 = getelementptr inbounds double, double* %450, i64 2
%454 = bitcast double* %453 to <2 x double>*
%455 = load <2 x double>, <2 x double>* %454
%456 = getelementptr inbounds double, double* %8, i64 %449
%457 = bitcast double* %456 to <2 x double>*
store <2 x double> %452, <2 x double>* %457
%458 = getelementptr inbounds double, double* %456, i64 2
%459 = bitcast double* %458 to <2 x double>*
store <2 x double> %455, <2 x double>* %459
br label %460
460: ; preds = %443, %445
br i1 %218, label %514, label %461
461: ; preds = %401, %396, %460
%462 = phi i64 [ 1, %401 ], [ 1, %396 ], [ %213, %460 ]
%463 = sub nsw i64 %192, %462
%464 = xor i64 %462, -1
%465 = add nsw i64 %464, %192
%466 = and i64 %463, 3
%467 = icmp eq i64 %466, 0
br i1 %467, label %480, label %468
468: ; preds = %461, %468
%469 = phi i64 [ %477, %468 ], [ %462, %461 ]
%470 = phi i64 [ %478, %468 ], [ 0, %461 ]
%471 = trunc i64 %469 to i32
%472 = add i32 %400, %471
%473 = zext i32 %472 to i64
%474 = getelementptr inbounds double, double* %10, i64 %473
%475 = load double, double* %474
%476 = getelementptr inbounds double, double* %8, i64 %473
store double %475, double* %476
%477 = add nuw nsw i64 %469, 1
%478 = add i64 %470, 1
%479 = icmp eq i64 %478, %466
br i1 %479, label %480, label %468
480: ; preds = %468, %461
%481 = phi i64 [ %462, %461 ], [ %477, %468 ]
%482 = icmp ult i64 %465, 3
br i1 %482, label %514, label %483
483: ; preds = %480, %483
%484 = phi i64 [ %512, %483 ], [ %481, %480 ]
%485 = trunc i64 %484 to i32
%486 = add i32 %400, %485
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds double, double* %10, i64 %487
%489 = load double, double* %488
%490 = getelementptr inbounds double, double* %8, i64 %487
store double %489, double* %490
%491 = trunc i64 %484 to i32
%492 = add i32 %491, 1
%493 = add i32 %400, %492
%494 = zext i32 %493 to i64
%495 = getelementptr inbounds double, double* %10, i64 %494
%496 = load double, double* %495
%497 = getelementptr inbounds double, double* %8, i64 %494
store double %496, double* %497
%498 = trunc i64 %484 to i32
%499 = add i32 %498, 2
%500 = add i32 %400, %499
%501 = zext i32 %500 to i64
%502 = getelementptr inbounds double, double* %10, i64 %501
%503 = load double, double* %502
%504 = getelementptr inbounds double, double* %8, i64 %501
store double %503, double* %504
%505 = trunc i64 %484 to i32
%506 = add i32 %505, 3
%507 = add i32 %400, %506
%508 = zext i32 %507 to i64
%509 = getelementptr inbounds double, double* %10, i64 %508
%510 = load double, double* %509
%511 = getelementptr inbounds double, double* %8, i64 %508
store double %510, double* %511
%512 = add nuw nsw i64 %484, 4
%513 = icmp eq i64 %512, %193
br i1 %513, label %514, label %483
514: ; preds = %480, %483, %460
%515 = add nuw nsw i32 %398, 1
%516 = icmp eq i32 %515, %187
%517 = add i32 %397, 1
br i1 %516, label %518, label %396
518: ; preds = %514
%519 = add nuw nsw i32 %392, 1
%520 = icmp eq i32 %519, %187
%521 = add i32 %391, 1
br i1 %520, label %522, label %390
522: ; preds = %518, %219, %221
%523 = add nuw nsw i32 %220, 1
%524 = icmp eq i32 %523, 100
br i1 %524, label %525, label %219
525: ; preds = %522
%526 = load i32, i32* @CLOCK_MONOTONIC_RAW
%527 = call i32 @clock_gettime(i32 %526, %struct.timespec* %3)
%528 = call i32 (...) @rapl_end()
%529 = call i32 (...) @rapl_deinit()
%530 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%531 = load i32, i32* %530
%532 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%533 = load i32, i32* %532
%534 = call i32 @elapsed_time_hr(i32 %531, i32 %533, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
%535 = call i32 @free(double* %8)
%536 = call i32 @free(double* %10)
ret void
}