#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 omp_get_num_threads();
scalar_t__ omp_get_thread_num();
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ rand();
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");
  }
#pragma omp parallel
  {
    if (omp_get_thread_num() == 0) {
      printf("Running on Host with %d OpenMP thread(s):\n\n",
             omp_get_num_threads());
    }
  }
  struct timespec start, end;
#pragma omp parallel for private(j, k)
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      for (k = 0; k < size; k++) {
        a0[i * size * size + j * size + k] = 0.0;
      }
    }
  }
#pragma omp parallel for private(j, k)
  for (i = 1; i < n + 1; i++) {
    for (j = 1; j < n + 1; j++) {
      for (k = 1; k < n + 1; k++) {
        a0[i * size * size + j * size + k] =
            (double)rand() / (double)(1.0 + RAND_MAX);
      }
    }
  }
  clock_gettime(CLOCK_MONOTONIC_RAW, &start);
  for (iter = 0; iter < 100; iter++) {
#pragma omp parallel
    {
#pragma omp for private(j, k)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          for (k = 1; k < n + 1; k++) {
            a1[i * size * size + j * size + k] =
                (a0[i * size * size + (j - 1) * size + k] +
                 a0[i * size * size + (j + 1) * size + k] +
                 a0[(i - 1) * size * size + j * size + k] +
                 a0[(i + 1) * size * size + j * size + k] +
                 a0[(i - 1) * size * size + (j - 1) * size + k] +
                 a0[(i - 1) * size * size + (j + 1) * size + k] +
                 a0[(i + 1) * size * size + (j - 1) * size + k] +
                 a0[(i + 1) * size * size + (j + 1) * size + k] +
                 a0[i * size * size + (j - 1) * size + (k - 1)] +
                 a0[i * size * size + (j + 1) * size + (k - 1)] +
                 a0[(i - 1) * size * size + j * size + (k - 1)] +
                 a0[(i + 1) * size * size + j * size + (k - 1)] +
                 a0[(i - 1) * size * size + (j - 1) * size + (k - 1)] +
                 a0[(i - 1) * size * size + (j + 1) * size + (k - 1)] +
                 a0[(i + 1) * size * size + (j - 1) * size + (k - 1)] +
                 a0[(i + 1) * size * size + (j + 1) * size + (k - 1)] +
                 a0[i * size * size + (j - 1) * size + (k + 1)] +
                 a0[i * size * size + (j + 1) * size + (k + 1)] +
                 a0[(i - 1) * size * size + j * size + (k + 1)] +
                 a0[(i + 1) * size * size + j * size + (k + 1)] +
                 a0[(i - 1) * size * size + (j - 1) * size + (k + 1)] +
                 a0[(i - 1) * size * size + (j + 1) * size + (k + 1)] +
                 a0[(i + 1) * size * size + (j - 1) * size + (k + 1)] +
                 a0[(i + 1) * size * size + (j + 1) * size + (k + 1)] +
                 a0[i * size * size + j * size + (k - 1)] +
                 a0[i * size * size + j * size + (k + 1)]) *
                fac;
          }
        }
      }
#pragma omp for private(j, k)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          for (k = 1; k < n + 1; k++) {
            a0[i * size * size + j * size + k] =
                a1[i * size * size + j * size + k];
          }
        }
      }
    }
  }
  clock_gettime(CLOCK_MONOTONIC_RAW, &end);
  elapsed_time_hr(start, end, "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  0xe64(%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   1090 <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   1090 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     11f7 <double_stencil27+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1205 <double_stencil27+0x85>
lea    0xe12(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   1050 <omp_get_thread_num@plt>
cmp    $0x0,%rax
jne    122d <double_stencil27+0xad>
mov    $0x0,%al
call   1080 <omp_get_num_threads@plt>
mov    %eax,%esi
lea    0xe2e(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12bf <double_stencil27+0x13f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12ac <double_stencil27+0x12c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1299 <double_stencil27+0x119>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    125a <double_stencil27+0xda>
jmp    129e <double_stencil27+0x11e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1247 <double_stencil27+0xc7>
jmp    12b1 <double_stencil27+0x131>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1234 <double_stencil27+0xb4>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1385 <double_stencil27+0x205>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1372 <double_stencil27+0x1f2>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    135f <double_stencil27+0x1df>
mov    $0x0,%al
call   10a0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x2cce(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xce1(%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    12f6 <double_stencil27+0x176>
jmp    1364 <double_stencil27+0x1e4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12de <double_stencil27+0x15e>
jmp    1377 <double_stencil27+0x1f7>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12c6 <double_stencil27+0x146>
mov    0x2c54(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1060 <clock_gettime@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    1958 <double_stencil27+0x7d8>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1885 <double_stencil27+0x705>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1872 <double_stencil27+0x6f2>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    185f <double_stencil27+0x6df>
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    13df <double_stencil27+0x25f>
jmp    1864 <double_stencil27+0x6e4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13c7 <double_stencil27+0x247>
jmp    1877 <double_stencil27+0x6f7>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13af <double_stencil27+0x22f>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1945 <double_stencil27+0x7c5>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1932 <double_stencil27+0x7b2>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    191f <double_stencil27+0x79f>
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    18bc <double_stencil27+0x73c>
jmp    1924 <double_stencil27+0x7a4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18a4 <double_stencil27+0x724>
jmp    1937 <double_stencil27+0x7b7>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    188c <double_stencil27+0x70c>
jmp    194a <double_stencil27+0x7ca>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    139e <double_stencil27+0x21e>
mov    0x2681(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0x709(%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   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
call   10a0 <malloc@plt>
test   %rbx,%rbx
mov    %rax,0x48(%rsp)
je     11da <double_stencil27+0x4a>
test   %rax,%rax
jne    11e6 <double_stencil27+0x56>
lea    0xe7f(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    1209 <double_stencil27+0x79>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe10(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
xor    %ecx,%ecx
mov    0x30(%rsp),%r8
mov    %r8d,%esi
test   %r8d,%r8d
mov    %r13,0x40(%rsp)
mov    %rsi,0x38(%rsp)
je     14dc <double_stencil27+0x34c>
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,0x10(%rsp)
mov    %esi,%r9d
and    $0x3,%r9d
mov    $0x8,%r10d
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1296 <double_stencil27+0x106>
nop
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    0x40(%rsp),%r13
mov    0x20(%rsp),%r10d
add    %r13d,%r10d
mov    0x18(%rsp),%rax
add    %r13,%rax
cmp    %r8d,%ecx
je     140c <double_stencil27+0x27c>
mov    %rcx,0x28(%rsp)
imul   %ecx,%r13d
mov    %rax,%rcx
xor    %edi,%edi
mov    %rax,0x18(%rsp)
mov    %r10d,0x20(%rsp)
jmp    12be <double_stencil27+0x12e>
add    $0x1,%edi
add    %r8d,%r10d
add    %rsi,%rcx
cmp    %r8d,%edi
je     1270 <double_stencil27+0xe0>
cmp    $0x4,%r8d
jae    1340 <double_stencil27+0x1b0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rsi,%rax
test   %r9,%r9
je     12f5 <double_stencil27+0x165>
mov    %r9,%rsi
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%edx
movq   $0x0,(%rbx,%rdx,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
jne    12e0 <double_stencil27+0x150>
cmp    $0x3,%rax
mov    0x38(%rsp),%rsi
jb     12b0 <double_stencil27+0x120>
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    1300 <double_stencil27+0x170>
jmp    12b0 <double_stencil27+0x120>
nopl   (%rax)
mov    %edi,%eax
imul   %r8d,%eax
add    %r13d,%eax
add    %r14d,%eax
jb     12c4 <double_stencil27+0x134>
mov    %r14,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12c6 <double_stencil27+0x136>
cmp    $0xc,%r11
jae    136e <double_stencil27+0x1de>
xor    %ebp,%ebp
jmp    13c9 <double_stencil27+0x239>
mov    0x10(%rsp),%rax
mov    %r10d,%r8d
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
lea    -0x8(%r8),%esi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm0,0x10(%rbx,%rsi,8)
lea    -0x4(%r8),%esi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm0,0x10(%rbx,%rsi,8)
mov    %r8d,%esi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm0,0x10(%rbx,%rsi,8)
lea    0x4(%r8),%esi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm0,0x10(%rbx,%rsi,8)
add    $0x10,%rbp
add    $0x10,%r8d
add    $0xfffffffffffffffc,%rax
jne    1380 <double_stencil27+0x1f0>
test   %r15,%r15
mov    0x30(%rsp),%r8
je     13f6 <double_stencil27+0x266>
add    %ecx,%ebp
mov    %r15,%rax
nopl   0x0(%rax,%rax,1)
mov    %ebp,%esi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm0,0x10(%rbx,%rsi,8)
add    $0x4,%ebp
add    $0xffffffffffffffff,%rax
jne    13e0 <double_stencil27+0x250>
mov    %r12,%rbp
mov    0x38(%rsp),%rsi
cmp    %rsi,%r12
je     12b0 <double_stencil27+0x120>
jmp    12c6 <double_stencil27+0x136>
lea    -0x1(%r8),%r15d
cmp    $0x2,%r15d
setge  %al
jl     14eb <double_stencil27+0x35b>
mov    %rax,0x28(%rsp)
mov    %r15d,%eax
lea    0x1(%r8),%r14d
imul   %r8d,%r14d
add    $0x1,%r14d
add    $0xffffffffffffffff,%rax
mov    %rax,0x20(%rsp)
mov    $0x1,%eax
mov    0x2ba2(%rip),%rbp
mov    %r15d,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %eax,0x58(%rsp)
mov    %r14d,0x18(%rsp)
mov    $0x1,%r12d
nop
mov    0x20(%rsp),%r13
mov    %r14d,%r15d
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xb81(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq 0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    %r15d,%eax
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%r15d
add    $0xffffffffffffffff,%r13
jne    1470 <double_stencil27+0x2e0>
add    $0x1,%r12d
add    0x30(%rsp),%r14d
mov    0x10(%rsp),%r15d
cmp    %r15d,%r12d
jne    1460 <double_stencil27+0x2d0>
mov    0x58(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%r14d
add    %r13d,%r14d
cmp    %r15d,%eax
jne    1450 <double_stencil27+0x2c0>
jmp    14f2 <double_stencil27+0x362>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0xffffffff,%r15d
jmp    14f2 <double_stencil27+0x362>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    0x2ae7(%rip),%rax
mov    (%rax),%edi
lea    0x68(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %r15d,%esi
lea    -0x2(%rsi),%rax
mov    %rax,0x138(%rsp)
mov    0x30(%rsp),%rdx
lea    0x1(%rdx),%r9d
imul   %edx,%r9d
lea    0x1(%r9),%eax
mov    %eax,0x74(%rsp)
lea    -0x1(%rsi),%r11
lea    (%rbx,%rsi,8),%r8
add    $0xfffffffffffffff8,%r8
mov    0x48(%rsp),%rdi
lea    -0x8(%rdi,%rsi,8),%rcx
lea    -0x5(%rsi),%rax
mov    %rax,0x130(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
cmp    %rbx,%rcx
seta   %cl
cmp    %rdi,%r8
seta   %al
and    %cl,%al
mov    %al,0xf(%rsp)
mov    %rsi,%rcx
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x120(%rsp)
add    $0x1,%rax
mov    %rax,0x118(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
add    $0x2,%rax
mov    %rbp,%rsi
mov    %rbp,0x128(%rsp)
and    %rbp,%rax
mov    %rax,0x110(%rsp)
lea    0x2(%rdx),%eax
imul   %edx,%eax
mov    %rax,0xb8(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0x1,%eax
imul   %edx,%eax
mov    %rax,0xb0(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0x2,%eax
imul   %edx,%eax
mov    %rax,0xa8(%rsp)
mov    $0x1,%eax
sub    %rcx,%rax
mov    %r9,0x80(%rsp)
mov    %r9d,%esi
add    $0x5,%esi
mov    %esi,0x70(%rsp)
movsd  0xa0c(%rip),%xmm0
add    %edx,%edx
mov    %rdx,0xa0(%rsp)
lea    0x0(%r13,%r13,1),%edx
mov    %rdx,0x98(%rsp)
xor    %edx,%edx
mov    %rcx,0x50(%rsp)
mov    %r11,0x88(%rsp)
mov    %rax,0x140(%rsp)
mov    %rbx,0x90(%rsp)
jmp    1654 <double_stencil27+0x4c4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xc0(%rsp),%rdx
add    $0x1,%edx
cmp    $0x64,%edx
je     1bb5 <double_stencil27+0xa25>
mov    %rdx,0xc0(%rsp)
cmpb   $0x0,0x28(%rsp)
je     1640 <double_stencil27+0x4b0>
mov    $0x1,%r8d
mov    0x80(%rsp),%rsi
mov    0xa8(%rsp),%rbx
mov    0x98(%rsp),%rdx
mov    0xa0(%rsp),%rax
xor    %r9d,%r9d
mov    0xb0(%rsp),%r14
mov    0x38(%rsp),%r11
mov    0xb8(%rsp),%rdi
mov    %r13,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8d
mov    %r8d,0x78(%rsp)
mov    %rsi,0x108(%rsp)
mov    %rbx,0x100(%rsp)
mov    %rbx,%rcx
mov    %rdx,0xf8(%rsp)
mov    %rdx,%rbx
mov    %rax,0xf0(%rsp)
mov    %rax,%r8
mov    %r9,0xe8(%rsp)
mov    %r9,%rdx
mov    %r14,0xe0(%rsp)
mov    %r11,0xd8(%rsp)
mov    %r11,%r9
mov    %rdi,0xd0(%rsp)
mov    %rdi,%r11
mov    %r15,0xc8(%rsp)
mov    %r15,%rdi
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
mov    %eax,0x7c(%rsp)
xor    %ebp,%ebp
mov    0x90(%rsp),%r15
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r14,0x58(%rsp)
mov    %r11,0x150(%rsp)
mov    %rdi,0x148(%rsp)
mov    %r8,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
add    %rbp,%rdi
lea    0x1(%rdi),%eax
movsd  (%r15,%rax,8),%xmm1
lea    (%r11,%rbp,1),%rax
lea    0x1(%rax),%esi
addsd  (%r15,%rsi,8),%xmm1
mov    %r9,%r11
lea    (%r9,%rbp,1),%r9
lea    0x1(%r9),%esi
addsd  (%r15,%rsi,8),%xmm1
lea    (%r14,%rbp,1),%r14
lea    0x1(%r14),%esi
addsd  (%r15,%rsi,8),%xmm1
lea    (%rdx,%rbp,1),%rsi
lea    0x1(%rsi),%edx
addsd  (%r15,%rdx,8),%xmm1
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%r8
lea    0x1(%r8),%edx
addsd  (%r15,%rdx,8),%xmm1
lea    (%rbx,%rbp,1),%r12
lea    0x1(%r12),%edx
addsd  (%r15,%rdx,8),%xmm1
lea    (%rcx,%rbp,1),%r13
lea    0x1(%r13),%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %edi,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %eax,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %r9d,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %r14d,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %esi,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %r8d,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %r12d,%edx
addsd  (%r15,%rdx,8),%xmm1
mov    %r13d,%edx
addsd  (%r15,%rdx,8),%xmm1
add    $0x2,%edi
addsd  (%r15,%rdi,8),%xmm1
mov    0x48(%rsp),%r10
add    $0x2,%eax
addsd  (%r15,%rax,8),%xmm1
add    $0x2,%r9d
addsd  (%r15,%r9,8),%xmm1
mov    %r11,%r9
mov    0x150(%rsp),%r11
add    $0x2,%r14d
addsd  (%r15,%r14,8),%xmm1
mov    0x148(%rsp),%rdi
add    $0x2,%esi
addsd  (%r15,%rsi,8),%xmm1
mov    0x18(%rsp),%rsi
add    $0x2,%r8d
addsd  (%r15,%r8,8),%xmm1
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%r14
add    $0x2,%r12d
addsd  (%r15,%r12,8),%xmm1
add    $0x2,%r13d
addsd  (%r15,%r13,8),%xmm1
lea    (%rsi,%rbp,1),%rax
mov    %eax,%edx
addsd  (%r15,%rdx,8),%xmm1
lea    0x2(%rax),%edx
addsd  (%r15,%rdx,8),%xmm1
mov    0x20(%rsp),%rdx
mulsd  %xmm0,%xmm1
add    $0x1,%eax
movsd  %xmm1,(%r10,%rax,8)
add    $0x1,%rbp
mov    0x140(%rsp),%rax
add    %rbp,%rax
jne    1760 <double_stencil27+0x5d0>
mov    0x38(%rsp),%rax
add    %rax,%rdi
add    %rax,%r11
add    %rax,%r9
add    %rax,%r14
add    %rax,%rdx
add    %rax,%r8
add    %rax,%rbx
add    %rax,%rcx
add    %rax,%rsi
mov    0x7c(%rsp),%eax
cmp    0x50(%rsp),%eax
jne    1720 <double_stencil27+0x590>
mov    0x40(%rsp),%r13
mov    0xc8(%rsp),%r15
add    %r13,%r15
mov    0xd0(%rsp),%rdi
add    %r13,%rdi
mov    0xd8(%rsp),%r11
add    %r13,%r11
mov    0xe0(%rsp),%r14
add    %r13,%r14
mov    0xe8(%rsp),%r9
add    %r13,%r9
mov    0xf0(%rsp),%rax
add    %r13,%rax
mov    0xf8(%rsp),%rdx
add    %r13,%rdx
mov    0x100(%rsp),%rbx
add    %r13,%rbx
mov    0x108(%rsp),%rsi
add    %r13,%rsi
mov    0x50(%rsp),%rcx
mov    0x78(%rsp),%r8d
cmp    %ecx,%r8d
jne    16b0 <double_stencil27+0x520>
mov    %r10,%rbp
cmpb   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r8
mov    0x88(%rsp),%r11
mov    0x90(%rsp),%rbx
mov    %r10,%rdi
je     1640 <double_stencil27+0x4b0>
mov    $0x1,%r15d
xor    %edx,%edx
mov    0x80(%rsp),%rsi
mov    0x70(%rsp),%r9d
jmp    19d9 <double_stencil27+0x849>
add    $0x1,%r15d
mov    0x10(%rsp),%edx
add    $0x1,%edx
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%r9d
add    %r13d,%r9d
mov    0x20(%rsp),%rsi
add    %r13,%rsi
cmp    %ecx,%r15d
je     1640 <double_stencil27+0x4b0>
mov    %edx,0x10(%rsp)
imul   %edx,%r13d
add    0x74(%rsp),%r13d
mov    %r15d,%r12d
imul   %r8d,%r12d
mov    %rsi,0x20(%rsp)
mov    %r9d,0x18(%rsp)
xor    %r14d,%r14d
mov    $0x1,%r10d
jmp    1a25 <double_stencil27+0x895>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10d
add    $0x1,%r14d
add    %r8d,%r9d
add    0x38(%rsp),%rsi
cmp    %ecx,%r10d
je     19b0 <double_stencil27+0x820>
mov    $0x1,%ebp
cmp    $0x4,%r11
jb     1b20 <double_stencil27+0x990>
mov    0x138(%rsp),%r11
mov    %r11,%rax
shr    $0x20,%rax
setne  %al
mov    %r14d,%edx
imul   %r8d,%edx
add    %r13d,%edx
add    %r11d,%edx
mov    0x88(%rsp),%r11
setb   %dl
or     %al,%dl
or     0xf(%rsp),%dl
jne    1b20 <double_stencil27+0x990>
cmpq   $0x4,0x130(%rsp)
jae    1a7e <double_stencil27+0x8ee>
xor    %eax,%eax
mov    0x48(%rsp),%r8
jmp    1ace <double_stencil27+0x93e>
mov    0x110(%rsp),%rdx
mov    %r9d,%ebp
xor    %eax,%eax
mov    0x48(%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    1a90 <double_stencil27+0x900>
testb  $0x1,0x128(%rsp)
01
mov    %r8,%rdi
mov    0x30(%rsp),%r8
je     1b03 <double_stencil27+0x973>
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    0x118(%rsp),%rbp
cmp    0x120(%rsp),%r11
je     1a10 <double_stencil27+0x880>
nopl   0x0(%rax)
mov    %ecx,%edx
sub    %ebp,%edx
mov    %rbp,%rax
not    %rax
add    %rcx,%rax
mov    %rdi,%rcx
and    $0x3,%rdx
je     1b57 <double_stencil27+0x9c7>
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    1b40 <double_stencil27+0x9b0>
cmp    $0x3,%rax
mov    %rcx,%rdi
mov    0x50(%rsp),%rcx
jb     1a10 <double_stencil27+0x880>
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    1b70 <double_stencil27+0x9e0>
jmp    1a10 <double_stencil27+0x880>
mov    %rdi,%rbp
mov    0x2421(%rip),%rax
mov    (%rax),%edi
lea    0x60(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x68(%rsp),%edi
mov    0x60(%rsp),%esi
lea    0x462(%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"
@.str.1 = [44 x i8] c"Running on Host with %d OpenMP thread(s):\0A\0A\00"
@RAND_MAX = global i64 0
@CLOCK_MONOTONIC_RAW = global i32 0
@.str.2 = [36 x i8] c"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 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str, i64 0, i64 0))
br label %46
46: ; preds = %44, %41
%47 = call i64 (...) @omp_get_thread_num()
%48 = icmp eq i64 %47, 0
br i1 %48, label %49, label %52
49: ; preds = %46
%50 = call i32 (...) @omp_get_num_threads()
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), i32 %50)
br label %52
52: ; preds = %49, %46
store i32 0, i32* %3
br label %53
53: ; preds = %90, %52
%54 = load i32, i32* %3
%55 = load i32, i32* %2
%56 = icmp ult i32 %54, %55
br i1 %56, label %57, label %93
57: ; preds = %53
store i32 0, i32* %4
br label %58
58: ; preds = %86, %57
%59 = load i32, i32* %4
%60 = load i32, i32* %2
%61 = icmp ult i32 %59, %60
br i1 %61, label %62, label %89
62: ; preds = %58
store i32 0, i32* %5
br label %63
63: ; preds = %82, %62
%64 = load i32, i32* %5
%65 = load i32, i32* %2
%66 = icmp ult i32 %64, %65
br i1 %66, label %67, label %85
67: ; preds = %63
%68 = load double*, double** %9
%69 = load i32, i32* %3
%70 = load i32, i32* %2
%71 = mul i32 %69, %70
%72 = load i32, i32* %2
%73 = mul i32 %71, %72
%74 = load i32, i32* %4
%75 = load i32, i32* %2
%76 = mul i32 %74, %75
%77 = add i32 %73, %76
%78 = load i32, i32* %5
%79 = add i32 %77, %78
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds double, double* %68, i64 %80
store double 0.000000e+00, double* %81
br label %82
82: ; preds = %67
%83 = load i32, i32* %5
%84 = add nsw i32 %83, 1
store i32 %84, i32* %5
br label %63
85: ; preds = %63
br label %86
86: ; preds = %85
%87 = load i32, i32* %4
%88 = add nsw i32 %87, 1
store i32 %88, i32* %4
br label %58
89: ; preds = %58
br label %90
90: ; preds = %89
%91 = load i32, i32* %3
%92 = add nsw i32 %91, 1
store i32 %92, i32* %3
br label %53
93: ; preds = %53
store i32 1, i32* %3
br label %94
94: ; preds = %140, %93
%95 = load i32, i32* %3
%96 = load i32, i32* %7
%97 = add nsw i32 %96, 1
%98 = icmp slt i32 %95, %97
br i1 %98, label %99, label %143
99: ; preds = %94
store i32 1, i32* %4
br label %100
100: ; preds = %136, %99
%101 = load i32, i32* %4
%102 = load i32, i32* %7
%103 = add nsw i32 %102, 1
%104 = icmp slt i32 %101, %103
br i1 %104, label %105, label %139
105: ; preds = %100
store i32 1, i32* %5
br label %106
106: ; preds = %132, %105
%107 = load i32, i32* %5
%108 = load i32, i32* %7
%109 = add nsw i32 %108, 1
%110 = icmp slt i32 %107, %109
br i1 %110, label %111, label %135
111: ; preds = %106
%112 = call i64 (...) @rand()
%113 = sitofp i64 %112 to double
%114 = load i64, i64* @RAND_MAX
%115 = sitofp i64 %114 to double
%116 = fadd double 1.000000e+00, %115
%117 = fdiv double %113, %116
%118 = load double*, double** %9
%119 = load i32, i32* %3
%120 = load i32, i32* %2
%121 = mul i32 %119, %120
%122 = load i32, i32* %2
%123 = mul i32 %121, %122
%124 = load i32, i32* %4
%125 = load i32, i32* %2
%126 = mul i32 %124, %125
%127 = add i32 %123, %126
%128 = load i32, i32* %5
%129 = add i32 %127, %128
%130 = zext i32 %129 to i64
%131 = getelementptr inbounds double, double* %118, i64 %130
store double %117, double* %131
br label %132
132: ; preds = %111
%133 = load i32, i32* %5
%134 = add nsw i32 %133, 1
store i32 %134, i32* %5
br label %106
135: ; preds = %106
br label %136
136: ; preds = %135
%137 = load i32, i32* %4
%138 = add nsw i32 %137, 1
store i32 %138, i32* %4
br label %100
139: ; preds = %100
br label %140
140: ; preds = %139
%141 = load i32, i32* %3
%142 = add nsw i32 %141, 1
store i32 %142, i32* %3
br label %94
143: ; preds = %94
%144 = load i32, i32* @CLOCK_MONOTONIC_RAW
%145 = call i32 @clock_gettime(i32 %144, %struct.timespec* %11)
store i32 0, i32* %6
br label %146
146: ; preds = %724, %143
%147 = load i32, i32* %6
%148 = icmp slt i32 %147, 100
br i1 %148, label %149, label %727
149: ; preds = %146
store i32 1, i32* %3
br label %150
150: ; preds = %661, %149
%151 = load i32, i32* %3
%152 = load i32, i32* %7
%153 = add nsw i32 %152, 1
%154 = icmp slt i32 %151, %153
br i1 %154, label %155, label %664
155: ; preds = %150
store i32 1, i32* %4
br label %156
156: ; preds = %657, %155
%157 = load i32, i32* %4
%158 = load i32, i32* %7
%159 = add nsw i32 %158, 1
%160 = icmp slt i32 %157, %159
br i1 %160, label %161, label %660
161: ; preds = %156
store i32 1, i32* %5
br label %162
162: ; preds = %653, %161
%163 = load i32, i32* %5
%164 = load i32, i32* %7
%165 = add nsw i32 %164, 1
%166 = icmp slt i32 %163, %165
br i1 %166, label %167, label %656
167: ; preds = %162
%168 = load double*, double** %9
%169 = load i32, i32* %3
%170 = load i32, i32* %2
%171 = mul i32 %169, %170
%172 = load i32, i32* %2
%173 = mul i32 %171, %172
%174 = load i32, i32* %4
%175 = sub nsw i32 %174, 1
%176 = load i32, i32* %2
%177 = mul i32 %175, %176
%178 = add i32 %173, %177
%179 = load i32, i32* %5
%180 = add i32 %178, %179
%181 = zext i32 %180 to i64
%182 = getelementptr inbounds double, double* %168, i64 %181
%183 = load double, double* %182
%184 = load double*, double** %9
%185 = load i32, i32* %3
%186 = load i32, i32* %2
%187 = mul i32 %185, %186
%188 = load i32, i32* %2
%189 = mul i32 %187, %188
%190 = load i32, i32* %4
%191 = add nsw i32 %190, 1
%192 = load i32, i32* %2
%193 = mul i32 %191, %192
%194 = add i32 %189, %193
%195 = load i32, i32* %5
%196 = add i32 %194, %195
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds double, double* %184, i64 %197
%199 = load double, double* %198
%200 = fadd double %183, %199
%201 = load double*, double** %9
%202 = load i32, i32* %3
%203 = sub nsw i32 %202, 1
%204 = load i32, i32* %2
%205 = mul i32 %203, %204
%206 = load i32, i32* %2
%207 = mul i32 %205, %206
%208 = load i32, i32* %4
%209 = load i32, i32* %2
%210 = mul i32 %208, %209
%211 = add i32 %207, %210
%212 = load i32, i32* %5
%213 = add i32 %211, %212
%214 = zext i32 %213 to i64
%215 = getelementptr inbounds double, double* %201, i64 %214
%216 = load double, double* %215
%217 = fadd double %200, %216
%218 = load double*, double** %9
%219 = load i32, i32* %3
%220 = add nsw i32 %219, 1
%221 = load i32, i32* %2
%222 = mul i32 %220, %221
%223 = load i32, i32* %2
%224 = mul i32 %222, %223
%225 = load i32, i32* %4
%226 = load i32, i32* %2
%227 = mul i32 %225, %226
%228 = add i32 %224, %227
%229 = load i32, i32* %5
%230 = add i32 %228, %229
%231 = zext i32 %230 to i64
%232 = getelementptr inbounds double, double* %218, i64 %231
%233 = load double, double* %232
%234 = fadd double %217, %233
%235 = load double*, double** %9
%236 = load i32, i32* %3
%237 = sub nsw i32 %236, 1
%238 = load i32, i32* %2
%239 = mul i32 %237, %238
%240 = load i32, i32* %2
%241 = mul i32 %239, %240
%242 = load i32, i32* %4
%243 = sub nsw i32 %242, 1
%244 = load i32, i32* %2
%245 = mul i32 %243, %244
%246 = add i32 %241, %245
%247 = load i32, i32* %5
%248 = add i32 %246, %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds double, double* %235, i64 %249
%251 = load double, double* %250
%252 = fadd double %234, %251
%253 = load double*, double** %9
%254 = load i32, i32* %3
%255 = sub nsw i32 %254, 1
%256 = load i32, i32* %2
%257 = mul i32 %255, %256
%258 = load i32, i32* %2
%259 = mul i32 %257, %258
%260 = load i32, i32* %4
%261 = add nsw i32 %260, 1
%262 = load i32, i32* %2
%263 = mul i32 %261, %262
%264 = add i32 %259, %263
%265 = load i32, i32* %5
%266 = add i32 %264, %265
%267 = zext i32 %266 to i64
%268 = getelementptr inbounds double, double* %253, i64 %267
%269 = load double, double* %268
%270 = fadd double %252, %269
%271 = load double*, double** %9
%272 = load i32, i32* %3
%273 = add nsw i32 %272, 1
%274 = load i32, i32* %2
%275 = mul i32 %273, %274
%276 = load i32, i32* %2
%277 = mul i32 %275, %276
%278 = load i32, i32* %4
%279 = sub nsw i32 %278, 1
%280 = load i32, i32* %2
%281 = mul i32 %279, %280
%282 = add i32 %277, %281
%283 = load i32, i32* %5
%284 = add i32 %282, %283
%285 = zext i32 %284 to i64
%286 = getelementptr inbounds double, double* %271, i64 %285
%287 = load double, double* %286
%288 = fadd double %270, %287
%289 = load double*, double** %9
%290 = load i32, i32* %3
%291 = add nsw i32 %290, 1
%292 = load i32, i32* %2
%293 = mul i32 %291, %292
%294 = load i32, i32* %2
%295 = mul i32 %293, %294
%296 = load i32, i32* %4
%297 = add nsw i32 %296, 1
%298 = load i32, i32* %2
%299 = mul i32 %297, %298
%300 = add i32 %295, %299
%301 = load i32, i32* %5
%302 = add i32 %300, %301
%303 = zext i32 %302 to i64
%304 = getelementptr inbounds double, double* %289, i64 %303
%305 = load double, double* %304
%306 = fadd double %288, %305
%307 = load double*, double** %9
%308 = load i32, i32* %3
%309 = load i32, i32* %2
%310 = mul i32 %308, %309
%311 = load i32, i32* %2
%312 = mul i32 %310, %311
%313 = load i32, i32* %4
%314 = sub nsw i32 %313, 1
%315 = load i32, i32* %2
%316 = mul i32 %314, %315
%317 = add i32 %312, %316
%318 = load i32, i32* %5
%319 = sub nsw i32 %318, 1
%320 = add i32 %317, %319
%321 = zext i32 %320 to i64
%322 = getelementptr inbounds double, double* %307, i64 %321
%323 = load double, double* %322
%324 = fadd double %306, %323
%325 = load double*, double** %9
%326 = load i32, i32* %3
%327 = load i32, i32* %2
%328 = mul i32 %326, %327
%329 = load i32, i32* %2
%330 = mul i32 %328, %329
%331 = load i32, i32* %4
%332 = add nsw i32 %331, 1
%333 = load i32, i32* %2
%334 = mul i32 %332, %333
%335 = add i32 %330, %334
%336 = load i32, i32* %5
%337 = sub nsw i32 %336, 1
%338 = add i32 %335, %337
%339 = zext i32 %338 to i64
%340 = getelementptr inbounds double, double* %325, i64 %339
%341 = load double, double* %340
%342 = fadd double %324, %341
%343 = load double*, double** %9
%344 = load i32, i32* %3
%345 = sub nsw i32 %344, 1
%346 = load i32, i32* %2
%347 = mul i32 %345, %346
%348 = load i32, i32* %2
%349 = mul i32 %347, %348
%350 = load i32, i32* %4
%351 = load i32, i32* %2
%352 = mul i32 %350, %351
%353 = add i32 %349, %352
%354 = load i32, i32* %5
%355 = sub nsw i32 %354, 1
%356 = add i32 %353, %355
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds double, double* %343, i64 %357
%359 = load double, double* %358
%360 = fadd double %342, %359
%361 = load double*, double** %9
%362 = load i32, i32* %3
%363 = add nsw i32 %362, 1
%364 = load i32, i32* %2
%365 = mul i32 %363, %364
%366 = load i32, i32* %2
%367 = mul i32 %365, %366
%368 = load i32, i32* %4
%369 = load i32, i32* %2
%370 = mul i32 %368, %369
%371 = add i32 %367, %370
%372 = load i32, i32* %5
%373 = sub nsw i32 %372, 1
%374 = add i32 %371, %373
%375 = zext i32 %374 to i64
%376 = getelementptr inbounds double, double* %361, i64 %375
%377 = load double, double* %376
%378 = fadd double %360, %377
%379 = load double*, double** %9
%380 = load i32, i32* %3
%381 = sub nsw i32 %380, 1
%382 = load i32, i32* %2
%383 = mul i32 %381, %382
%384 = load i32, i32* %2
%385 = mul i32 %383, %384
%386 = load i32, i32* %4
%387 = sub nsw i32 %386, 1
%388 = load i32, i32* %2
%389 = mul i32 %387, %388
%390 = add i32 %385, %389
%391 = load i32, i32* %5
%392 = sub nsw i32 %391, 1
%393 = add i32 %390, %392
%394 = zext i32 %393 to i64
%395 = getelementptr inbounds double, double* %379, i64 %394
%396 = load double, double* %395
%397 = fadd double %378, %396
%398 = load double*, double** %9
%399 = load i32, i32* %3
%400 = sub nsw i32 %399, 1
%401 = load i32, i32* %2
%402 = mul i32 %400, %401
%403 = load i32, i32* %2
%404 = mul i32 %402, %403
%405 = load i32, i32* %4
%406 = add nsw i32 %405, 1
%407 = load i32, i32* %2
%408 = mul i32 %406, %407
%409 = add i32 %404, %408
%410 = load i32, i32* %5
%411 = sub nsw i32 %410, 1
%412 = add i32 %409, %411
%413 = zext i32 %412 to i64
%414 = getelementptr inbounds double, double* %398, i64 %413
%415 = load double, double* %414
%416 = fadd double %397, %415
%417 = load double*, double** %9
%418 = load i32, i32* %3
%419 = add nsw i32 %418, 1
%420 = load i32, i32* %2
%421 = mul i32 %419, %420
%422 = load i32, i32* %2
%423 = mul i32 %421, %422
%424 = load i32, i32* %4
%425 = sub nsw i32 %424, 1
%426 = load i32, i32* %2
%427 = mul i32 %425, %426
%428 = add i32 %423, %427
%429 = load i32, i32* %5
%430 = sub nsw i32 %429, 1
%431 = add i32 %428, %430
%432 = zext i32 %431 to i64
%433 = getelementptr inbounds double, double* %417, i64 %432
%434 = load double, double* %433
%435 = fadd double %416, %434
%436 = load double*, double** %9
%437 = load i32, i32* %3
%438 = add nsw i32 %437, 1
%439 = load i32, i32* %2
%440 = mul i32 %438, %439
%441 = load i32, i32* %2
%442 = mul i32 %440, %441
%443 = load i32, i32* %4
%444 = add nsw i32 %443, 1
%445 = load i32, i32* %2
%446 = mul i32 %444, %445
%447 = add i32 %442, %446
%448 = load i32, i32* %5
%449 = sub nsw i32 %448, 1
%450 = add i32 %447, %449
%451 = zext i32 %450 to i64
%452 = getelementptr inbounds double, double* %436, i64 %451
%453 = load double, double* %452
%454 = fadd double %435, %453
%455 = load double*, double** %9
%456 = load i32, i32* %3
%457 = load i32, i32* %2
%458 = mul i32 %456, %457
%459 = load i32, i32* %2
%460 = mul i32 %458, %459
%461 = load i32, i32* %4
%462 = sub nsw i32 %461, 1
%463 = load i32, i32* %2
%464 = mul i32 %462, %463
%465 = add i32 %460, %464
%466 = load i32, i32* %5
%467 = add nsw i32 %466, 1
%468 = add i32 %465, %467
%469 = zext i32 %468 to i64
%470 = getelementptr inbounds double, double* %455, i64 %469
%471 = load double, double* %470
%472 = fadd double %454, %471
%473 = load double*, double** %9
%474 = load i32, i32* %3
%475 = load i32, i32* %2
%476 = mul i32 %474, %475
%477 = load i32, i32* %2
%478 = mul i32 %476, %477
%479 = load i32, i32* %4
%480 = add nsw i32 %479, 1
%481 = load i32, i32* %2
%482 = mul i32 %480, %481
%483 = add i32 %478, %482
%484 = load i32, i32* %5
%485 = add nsw i32 %484, 1
%486 = add i32 %483, %485
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds double, double* %473, i64 %487
%489 = load double, double* %488
%490 = fadd double %472, %489
%491 = load double*, double** %9
%492 = load i32, i32* %3
%493 = sub nsw i32 %492, 1
%494 = load i32, i32* %2
%495 = mul i32 %493, %494
%496 = load i32, i32* %2
%497 = mul i32 %495, %496
%498 = load i32, i32* %4
%499 = load i32, i32* %2
%500 = mul i32 %498, %499
%501 = add i32 %497, %500
%502 = load i32, i32* %5
%503 = add nsw i32 %502, 1
%504 = add i32 %501, %503
%505 = zext i32 %504 to i64
%506 = getelementptr inbounds double, double* %491, i64 %505
%507 = load double, double* %506
%508 = fadd double %490, %507
%509 = load double*, double** %9
%510 = load i32, i32* %3
%511 = add nsw i32 %510, 1
%512 = load i32, i32* %2
%513 = mul i32 %511, %512
%514 = load i32, i32* %2
%515 = mul i32 %513, %514
%516 = load i32, i32* %4
%517 = load i32, i32* %2
%518 = mul i32 %516, %517
%519 = add i32 %515, %518
%520 = load i32, i32* %5
%521 = add nsw i32 %520, 1
%522 = add i32 %519, %521
%523 = zext i32 %522 to i64
%524 = getelementptr inbounds double, double* %509, i64 %523
%525 = load double, double* %524
%526 = fadd double %508, %525
%527 = load double*, double** %9
%528 = load i32, i32* %3
%529 = sub nsw i32 %528, 1
%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 = sub nsw i32 %534, 1
%536 = load i32, i32* %2
%537 = mul i32 %535, %536
%538 = add i32 %533, %537
%539 = load i32, i32* %5
%540 = add nsw i32 %539, 1
%541 = add i32 %538, %540
%542 = zext i32 %541 to i64
%543 = getelementptr inbounds double, double* %527, i64 %542
%544 = load double, double* %543
%545 = fadd double %526, %544
%546 = load double*, double** %9
%547 = load i32, i32* %3
%548 = sub nsw i32 %547, 1
%549 = load i32, i32* %2
%550 = mul i32 %548, %549
%551 = load i32, i32* %2
%552 = mul i32 %550, %551
%553 = load i32, i32* %4
%554 = add nsw i32 %553, 1
%555 = load i32, i32* %2
%556 = mul i32 %554, %555
%557 = add i32 %552, %556
%558 = load i32, i32* %5
%559 = add nsw i32 %558, 1
%560 = add i32 %557, %559
%561 = zext i32 %560 to i64
%562 = getelementptr inbounds double, double* %546, i64 %561
%563 = load double, double* %562
%564 = fadd double %545, %563
%565 = load double*, double** %9
%566 = load i32, i32* %3
%567 = add nsw i32 %566, 1
%568 = load i32, i32* %2
%569 = mul i32 %567, %568
%570 = load i32, i32* %2
%571 = mul i32 %569, %570
%572 = load i32, i32* %4
%573 = sub nsw i32 %572, 1
%574 = load i32, i32* %2
%575 = mul i32 %573, %574
%576 = add i32 %571, %575
%577 = load i32, i32* %5
%578 = add nsw i32 %577, 1
%579 = add i32 %576, %578
%580 = zext i32 %579 to i64
%581 = getelementptr inbounds double, double* %565, i64 %580
%582 = load double, double* %581
%583 = fadd double %564, %582
%584 = load double*, double** %9
%585 = load i32, i32* %3
%586 = add nsw i32 %585, 1
%587 = load i32, i32* %2
%588 = mul i32 %586, %587
%589 = load i32, i32* %2
%590 = mul i32 %588, %589
%591 = load i32, i32* %4
%592 = add nsw i32 %591, 1
%593 = load i32, i32* %2
%594 = mul i32 %592, %593
%595 = add i32 %590, %594
%596 = load i32, i32* %5
%597 = add nsw i32 %596, 1
%598 = add i32 %595, %597
%599 = zext i32 %598 to i64
%600 = getelementptr inbounds double, double* %584, i64 %599
%601 = load double, double* %600
%602 = fadd double %583, %601
%603 = load double*, double** %9
%604 = load i32, i32* %3
%605 = load i32, i32* %2
%606 = mul i32 %604, %605
%607 = load i32, i32* %2
%608 = mul i32 %606, %607
%609 = load i32, i32* %4
%610 = load i32, i32* %2
%611 = mul i32 %609, %610
%612 = add i32 %608, %611
%613 = load i32, i32* %5
%614 = sub nsw i32 %613, 1
%615 = add i32 %612, %614
%616 = zext i32 %615 to i64
%617 = getelementptr inbounds double, double* %603, i64 %616
%618 = load double, double* %617
%619 = fadd double %602, %618
%620 = load double*, double** %9
%621 = load i32, i32* %3
%622 = load i32, i32* %2
%623 = mul i32 %621, %622
%624 = load i32, i32* %2
%625 = mul i32 %623, %624
%626 = load i32, i32* %4
%627 = load i32, i32* %2
%628 = mul i32 %626, %627
%629 = add i32 %625, %628
%630 = load i32, i32* %5
%631 = add nsw i32 %630, 1
%632 = add i32 %629, %631
%633 = zext i32 %632 to i64
%634 = getelementptr inbounds double, double* %620, i64 %633
%635 = load double, double* %634
%636 = fadd double %619, %635
%637 = load double, double* %8
%638 = fmul double %636, %637
%639 = load double*, double** %10
%640 = load i32, i32* %3
%641 = load i32, i32* %2
%642 = mul i32 %640, %641
%643 = load i32, i32* %2
%644 = mul i32 %642, %643
%645 = load i32, i32* %4
%646 = load i32, i32* %2
%647 = mul i32 %645, %646
%648 = add i32 %644, %647
%649 = load i32, i32* %5
%650 = add i32 %648, %649
%651 = zext i32 %650 to i64
%652 = getelementptr inbounds double, double* %639, i64 %651
store double %638, double* %652
br label %653
653: ; preds = %167
%654 = load i32, i32* %5
%655 = add nsw i32 %654, 1
store i32 %655, i32* %5
br label %162
656: ; preds = %162
br label %657
657: ; preds = %656
%658 = load i32, i32* %4
%659 = add nsw i32 %658, 1
store i32 %659, i32* %4
br label %156
660: ; preds = %156
br label %661
661: ; preds = %660
%662 = load i32, i32* %3
%663 = add nsw i32 %662, 1
store i32 %663, i32* %3
br label %150
664: ; preds = %150
store i32 1, i32* %3
br label %665
665: ; preds = %720, %664
%666 = load i32, i32* %3
%667 = load i32, i32* %7
%668 = add nsw i32 %667, 1
%669 = icmp slt i32 %666, %668
br i1 %669, label %670, label %723
670: ; preds = %665
store i32 1, i32* %4
br label %671
671: ; preds = %716, %670
%672 = load i32, i32* %4
%673 = load i32, i32* %7
%674 = add nsw i32 %673, 1
%675 = icmp slt i32 %672, %674
br i1 %675, label %676, label %719
676: ; preds = %671
store i32 1, i32* %5
br label %677
677: ; preds = %712, %676
%678 = load i32, i32* %5
%679 = load i32, i32* %7
%680 = add nsw i32 %679, 1
%681 = icmp slt i32 %678, %680
br i1 %681, label %682, label %715
682: ; preds = %677
%683 = load double*, double** %10
%684 = load i32, i32* %3
%685 = load i32, i32* %2
%686 = mul i32 %684, %685
%687 = load i32, i32* %2
%688 = mul i32 %686, %687
%689 = load i32, i32* %4
%690 = load i32, i32* %2
%691 = mul i32 %689, %690
%692 = add i32 %688, %691
%693 = load i32, i32* %5
%694 = add i32 %692, %693
%695 = zext i32 %694 to i64
%696 = getelementptr inbounds double, double* %683, i64 %695
%697 = load double, double* %696
%698 = load double*, double** %9
%699 = load i32, i32* %3
%700 = load i32, i32* %2
%701 = mul i32 %699, %700
%702 = load i32, i32* %2
%703 = mul i32 %701, %702
%704 = load i32, i32* %4
%705 = load i32, i32* %2
%706 = mul i32 %704, %705
%707 = add i32 %703, %706
%708 = load i32, i32* %5
%709 = add i32 %707, %708
%710 = zext i32 %709 to i64
%711 = getelementptr inbounds double, double* %698, i64 %710
store double %697, double* %711
br label %712
712: ; preds = %682
%713 = load i32, i32* %5
%714 = add nsw i32 %713, 1
store i32 %714, i32* %5
br label %677
715: ; preds = %677
br label %716
716: ; preds = %715
%717 = load i32, i32* %4
%718 = add nsw i32 %717, 1
store i32 %718, i32* %4
br label %671
719: ; preds = %671
br label %720
720: ; preds = %719
%721 = load i32, i32* %3
%722 = add nsw i32 %721, 1
store i32 %722, i32* %3
br label %665
723: ; preds = %665
br label %724
724: ; preds = %723
%725 = load i32, i32* %6
%726 = add nsw i32 %725, 1
store i32 %726, i32* %6
br label %146
727: ; preds = %146
%728 = load i32, i32* @CLOCK_MONOTONIC_RAW
%729 = call i32 @clock_gettime(i32 %728, %struct.timespec* %12)
%730 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%731 = load i32, i32* %730
%732 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%733 = load i32, i32* %732
%734 = call i32 @elapsed_time_hr(i32 %731, i32 %733, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%735 = load double*, double** %9
%736 = call i32 @free(double* %735)
%737 = load double*, double** %10
%738 = call i32 @free(double* %737)
ret void
}

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