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


x86 assembly (clang, -O0):
<double_stencil19>:
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_stencil19+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1205 <double_stencil19+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_stencil19+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_stencil19+0x13f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12ac <double_stencil19+0x12c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1299 <double_stencil19+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_stencil19+0xda>
jmp    129e <double_stencil19+0x11e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1247 <double_stencil19+0xc7>
jmp    12b1 <double_stencil19+0x131>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1234 <double_stencil19+0xb4>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1385 <double_stencil19+0x205>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1372 <double_stencil19+0x1f2>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    135f <double_stencil19+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_stencil19+0x176>
jmp    1364 <double_stencil19+0x1e4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12de <double_stencil19+0x15e>
jmp    1377 <double_stencil19+0x1f7>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12c6 <double_stencil19+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    17f0 <double_stencil19+0x670>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    171d <double_stencil19+0x59d>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    170a <double_stencil19+0x58a>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16f7 <double_stencil19+0x577>
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
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
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_stencil19+0x25f>
jmp    16fc <double_stencil19+0x57c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13c7 <double_stencil19+0x247>
jmp    170f <double_stencil19+0x58f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13af <double_stencil19+0x22f>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17dd <double_stencil19+0x65d>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17ca <double_stencil19+0x64a>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17b7 <double_stencil19+0x637>
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    1754 <double_stencil19+0x5d4>
jmp    17bc <double_stencil19+0x63c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    173c <double_stencil19+0x5bc>
jmp    17cf <double_stencil19+0x64f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1724 <double_stencil19+0x5a4>
jmp    17e2 <double_stencil19+0x662>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    139e <double_stencil19+0x21e>
mov    0x27e9(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0x871(%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_stencil19>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edi,%ebp
mov    %edi,%r13d
imul   %r13d,%r13d
mov    %r13d,%r14d
imul   %edi,%r14d
shl    $0x3,%r14d
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     11d5 <double_stencil19+0x45>
test   %r14,%r14
jne    11e1 <double_stencil19+0x51>
lea    0xe84(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    1204 <double_stencil19+0x74>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe15(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
xor    %esi,%esi
mov    %ebp,%edi
test   %ebp,%ebp
mov    %rbp,0x38(%rsp)
mov    %r13,0x40(%rsp)
mov    %rdi,0x48(%rsp)
je     1503 <double_stencil19+0x373>
mov    %r14,0x20(%rsp)
mov    %r13,%rax
lea    -0x1(%rdi),%rbx
mov    %edi,%r13d
and    $0xfffffffc,%r13d
lea    -0x4(%r13),%rdx
mov    %rdx,0x18(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r12d
and    $0x3,%r12d
and    %rcx,%rdx
mov    %rdx,0x10(%rsp)
mov    %edi,%r10d
and    $0x3,%r10d
mov    $0x8,%r9d
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    12a5 <double_stencil19+0x115>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rsi
add    $0x1,%esi
mov    0x40(%rsp),%rax
mov    0x8(%rsp),%r9d
add    %eax,%r9d
mov    0x28(%rsp),%rcx
add    %rax,%rcx
cmp    %edx,%esi
je     142e <double_stencil19+0x29e>
mov    %eax,%r14d
mov    %rsi,0x30(%rsp)
imul   %esi,%r14d
xor    %r11d,%r11d
mov    %rcx,0x28(%rsp)
mov    %r9d,0x8(%rsp)
mov    0x38(%rsp),%rdx
jmp    12e4 <double_stencil19+0x154>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11d
mov    0x38(%rsp),%rdx
add    %edx,%r9d
add    %rdi,%rcx
cmp    %edx,%r11d
je     1280 <double_stencil19+0xf0>
cmp    $0x4,%edx
jae    1360 <double_stencil19+0x1d0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %r10,%r10
je     1315 <double_stencil19+0x185>
mov    %r10,%rdx
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%esi
movq   $0x0,(%r15,%rsi,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1300 <double_stencil19+0x170>
cmp    $0x3,%rax
jb     12d0 <double_stencil19+0x140>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
mov    %eax,%edx
movq   $0x0,(%r15,%rdx,8)
lea    0x1(%rax),%edx
movq   $0x0,(%r15,%rdx,8)
lea    0x2(%rax),%edx
movq   $0x0,(%r15,%rdx,8)
add    $0x3,%eax
movq   $0x0,(%r15,%rax,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1320 <double_stencil19+0x190>
jmp    12d0 <double_stencil19+0x140>
nopl   (%rax)
mov    %r11d,%eax
imul   %edx,%eax
add    %r14d,%eax
add    %ebx,%eax
jb     12e9 <double_stencil19+0x159>
mov    %rbx,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12eb <double_stencil19+0x15b>
cmpq   $0xc,0x18(%rsp)
jae    138f <double_stencil19+0x1ff>
xor    %ebp,%ebp
jmp    13ed <double_stencil19+0x25d>
mov    0x10(%rsp),%rdx
mov    %r9d,%eax
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    -0x8(%rax),%r8d
movupd %xmm0,(%r15,%r8,8)
movupd %xmm0,0x10(%r15,%r8,8)
lea    -0x4(%rax),%esi
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm0,0x10(%r15,%rsi,8)
mov    %eax,%esi
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm0,0x10(%r15,%rsi,8)
lea    0x4(%rax),%esi
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm0,0x10(%r15,%rsi,8)
add    $0x10,%rbp
add    $0x10,%eax
add    $0xfffffffffffffffc,%rdx
jne    13a0 <double_stencil19+0x210>
test   %r12,%r12
je     1418 <double_stencil19+0x288>
add    %ecx,%ebp
mov    %r12,%rax
nopw   0x0(%rax,%rax,1)
mov    %ebp,%edx
movupd %xmm0,(%r15,%rdx,8)
movupd %xmm0,0x10(%r15,%rdx,8)
add    $0x4,%ebp
add    $0xffffffffffffffff,%rax
jne    1400 <double_stencil19+0x270>
mov    %r13,%rbp
mov    0x48(%rsp),%rdi
cmp    %rdi,%r13
je     12d0 <double_stencil19+0x140>
jmp    12eb <double_stencil19+0x15b>
mov    0x38(%rsp),%rbp
lea    -0x1(%rbp),%ecx
cmp    $0x2,%ecx
setge  %al
jl     1511 <double_stencil19+0x381>
mov    %rax,0x30(%rsp)
mov    %ecx,%eax
lea    0x1(%rbp),%ebx
imul   %ebp,%ebx
add    $0x1,%ebx
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%eax
mov    0x2b81(%rip),%rbp
mov    %ecx,0x18(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %eax,0x28(%rsp)
mov    %ebx,0x8(%rsp)
mov    $0x1,%r12d
xchg   %ax,%ax
mov    0x10(%rsp),%r13
mov    %ebx,%r14d
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xb61(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq 0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    %r14d,%eax
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%r14d
add    $0xffffffffffffffff,%r13
jne    1490 <double_stencil19+0x300>
add    $0x1,%r12d
add    0x38(%rsp),%ebx
mov    0x18(%rsp),%ecx
cmp    %ecx,%r12d
jne    1480 <double_stencil19+0x2f0>
mov    0x28(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%r13
mov    0x8(%rsp),%ebx
add    %r13d,%ebx
cmp    %ecx,%eax
jne    1470 <double_stencil19+0x2e0>
mov    0x20(%rsp),%r14
mov    0x38(%rsp),%rbp
jmp    1522 <double_stencil19+0x392>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0xffffffff,%ebx
jmp    1524 <double_stencil19+0x394>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    0x20(%rsp),%r14
mov    0x40(%rsp),%r13
mov    %ecx,%ebx
mov    0x2ab5(%rip),%rax
mov    (%rax),%edi
lea    0x58(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %ebx,%ebx
lea    -0x2(%rbx),%rax
mov    %rax,0x118(%rsp)
lea    0x1(%rbp),%r10d
imul   %ebp,%r10d
lea    -0x1(%rbx),%rdi
lea    (%r15,%rbx,8),%r8
add    $0xfffffffffffffff8,%r8
lea    -0x8(%r14,%rbx,8),%r9
lea    -0x5(%rbx),%rax
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %r15,%r9
seta   %r9b
cmp    %r14,%r8
seta   %al
and    %r9b,%al
mov    %al,0x7(%rsp)
mov    %rdi,0x70(%rsp)
mov    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
add    $0x2,%rax
mov    %rcx,%rdi
mov    %rcx,0x108(%rsp)
and    %rcx,%rax
mov    %rax,0xf0(%rsp)
lea    0x2(%rbp),%eax
imul   %ebp,%eax
mov    %rax,0x98(%rsp)
lea    0x0(%rbp,%rbp,1),%eax
lea    0x1(%rbp,%rbp,1),%ecx
imul   %ebp,%ecx
mov    %rcx,0x88(%rsp)
lea    0x2(%rbp,%rbp,1),%ecx
imul   %ebp,%ecx
or     $0x1,%rcx
mov    %rcx,0x80(%rsp)
or     $0x1,%rax
mov    %rax,0x90(%rsp)
lea    0x0(%r13,%r13,1),%eax
or     $0x1,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%eax
sub    %rbx,%rax
mov    %r10d,%ecx
add    $0x5,%ecx
mov    %ecx,0x5c(%rsp)
movsd  0x9e7(%rip),%xmm0
mov    %r10,0x68(%rsp)
lea    0x1(%r10),%ecx
mov    %ecx,0x60(%rsp)
mov    %rdx,0x100(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0xf8(%rsp)
xor    %ecx,%ecx
mov    %rbx,0x20(%rsp)
mov    %rax,0x120(%rsp)
jmp    1674 <double_stencil19+0x4e4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xa0(%rsp),%rcx
add    $0x1,%ecx
cmp    $0x64,%ecx
je     1b6d <double_stencil19+0x9dd>
mov    %rcx,0xa0(%rsp)
cmpb   $0x0,0x30(%rsp)
je     1660 <double_stencil19+0x4d0>
mov    $0x1,%eax
xor    %ecx,%ecx
mov    0x78(%rsp),%rdx
mov    0x90(%rsp),%r11
mov    0x80(%rsp),%r12
mov    0x68(%rsp),%rbp
mov    0x88(%rsp),%rsi
mov    0x48(%rsp),%r9
mov    0x98(%rsp),%r10
mov    %r13,%r8
nopl   0x0(%rax)
add    $0x1,%eax
mov    %eax,0x64(%rsp)
mov    %rcx,0xe8(%rsp)
mov    %rcx,%r13
mov    %rdx,0xe0(%rsp)
mov    %r11,0xd8(%rsp)
mov    %r12,0xd0(%rsp)
mov    %r12,%rdi
mov    %rbp,0xc8(%rsp)
mov    %rbp,%rbx
mov    %rsi,0xc0(%rsp)
mov    %r9,0xb8(%rsp)
mov    %r10,0xb0(%rsp)
mov    %r8,0xa8(%rsp)
mov    %r8,%r12
mov    %r9,%r8
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,0x8(%rsp)
mov    %rdx,0x10(%rsp)
mov    %r13,0x18(%rsp)
add    $0x1,%ebp
mov    %ebp,0x28(%rsp)
xor    %ebp,%ebp
mov    0x120(%rsp),%r13
mov    %rdi,%rdx
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%rbp,1),%rsi
lea    0x1(%rsi),%eax
movsd  (%r15,%rax,8),%xmm1
lea    (%r10,%rbp,1),%rax
lea    0x1(%rax),%edi
addsd  (%r15,%rdi,8),%xmm1
lea    (%r8,%rbp,1),%r11
lea    0x1(%r11),%edi
addsd  (%r15,%rdi,8),%xmm1
mov    %r12,%r9
mov    %r10,%r12
mov    %r8,%r10
mov    %r14,%r8
lea    (%rcx,%rbp,1),%r14
lea    0x1(%r14),%edi
addsd  (%r15,%rdi,8),%xmm1
mov    0x18(%rsp),%rdi
lea    0x1(%rdi,%rbp,1),%edi
addsd  (%r15,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addsd  (%r15,%rdi,8),%xmm1
mov    0x10(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addsd  (%r15,%rdi,8),%xmm1
lea    (%rdx,%rbp,1),%edi
addsd  (%r15,%rdi,8),%xmm1
mov    %esi,%edi
addsd  (%r15,%rdi,8),%xmm1
mov    %eax,%edi
addsd  (%r15,%rdi,8),%xmm1
mov    %r11d,%edi
addsd  (%r15,%rdi,8),%xmm1
mov    %r14d,%edi
addsd  (%r15,%rdi,8),%xmm1
add    $0x2,%esi
addsd  (%r15,%rsi,8),%xmm1
add    $0x2,%eax
addsd  (%r15,%rax,8),%xmm1
add    $0x2,%r11d
addsd  (%r15,%r11,8),%xmm1
add    $0x2,%r14d
addsd  (%r15,%r14,8),%xmm1
mov    %r8,%r14
mov    %r10,%r8
mov    %r12,%r10
mov    %r9,%r12
lea    (%rbx,%rbp,1),%rax
mov    %eax,%esi
addsd  (%r15,%rsi,8),%xmm1
lea    0x2(%rax),%esi
addsd  (%r15,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
add    $0x1,%eax
movsd  %xmm1,(%r14,%rax,8)
add    $0x1,%rbp
mov    %r13,%rax
add    %rbp,%rax
jne    1760 <double_stencil19+0x5d0>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r10
add    %rax,%r8
mov    %rcx,%rsi
add    %rax,%rsi
add    %rax,%rbx
mov    %rdx,%rcx
add    %rax,%rcx
mov    0x8(%rsp),%r11
add    %rax,%r11
mov    0x10(%rsp),%rdi
add    %rax,%rdi
mov    0x18(%rsp),%r13
add    %rax,%r13
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%ebp
cmp    %eax,%ebp
mov    %rdi,%rdx
mov    %rcx,%rdi
jne    1730 <double_stencil19+0x5a0>
mov    0x40(%rsp),%r13
mov    0xa8(%rsp),%r8
add    %r13,%r8
mov    0xb0(%rsp),%r10
add    %r13,%r10
mov    %rax,%rbx
mov    0xb8(%rsp),%r9
add    %r13,%r9
mov    0xc0(%rsp),%rsi
add    %r13,%rsi
mov    0xc8(%rsp),%rbp
add    %r13,%rbp
mov    0xd0(%rsp),%r12
add    %r13,%r12
mov    0xd8(%rsp),%r11
add    %r13,%r11
mov    0xe0(%rsp),%rdx
add    %r13,%rdx
mov    0xe8(%rsp),%rcx
add    %r13,%rcx
mov    0x64(%rsp),%eax
cmp    %ebx,%eax
jne    16c0 <double_stencil19+0x530>
cmpb   $0x0,0x30(%rsp)
mov    0x38(%rsp),%rbp
je     1660 <double_stencil19+0x4d0>
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x68(%rsp),%rdi
mov    0x5c(%rsp),%r10d
jmp    1976 <double_stencil19+0x7e6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%edx
add    $0x1,%edx
mov    0x18(%rsp),%ecx
add    $0x1,%ecx
mov    0x8(%rsp),%r10d
add    %r13d,%r10d
mov    0x10(%rsp),%rdi
add    %r13,%rdi
cmp    %ebx,%edx
je     1660 <double_stencil19+0x4d0>
mov    %r13d,%r12d
mov    %ecx,0x18(%rsp)
imul   %ecx,%r12d
add    0x60(%rsp),%r12d
mov    %edx,0x28(%rsp)
mov    %edx,%r11d
imul   %ebp,%r11d
mov    %rdi,0x10(%rsp)
mov    %r10d,0x8(%rsp)
xor    %r9d,%r9d
mov    $0x1,%r8d
jmp    19c5 <double_stencil19+0x835>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8d
add    $0x1,%r9d
add    %ebp,%r10d
add    0x48(%rsp),%rdi
cmp    %ebx,%r8d
je     1950 <double_stencil19+0x7c0>
mov    $0x1,%ecx
cmpq   $0x4,0x70(%rsp)
jb     1ad0 <double_stencil19+0x940>
mov    0x118(%rsp),%rdx
mov    %rdx,%rax
shr    $0x20,%rax
setne  %al
mov    %r9d,%esi
imul   %ebp,%esi
add    %r12d,%esi
add    %edx,%esi
mov    0x20(%rsp),%rbx
setb   %dl
or     %al,%dl
or     0x7(%rsp),%dl
jne    1ad0 <double_stencil19+0x940>
cmpq   $0x4,0x110(%rsp)
jae    1a16 <double_stencil19+0x886>
xor    %eax,%eax
jmp    1a72 <double_stencil19+0x8e2>
mov    0xf0(%rsp),%rcx
mov    %r10d,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x4(%rsi),%edx
movups (%r14,%rdx,8),%xmm1
movups 0x10(%r14,%rdx,8),%xmm2
movups %xmm1,(%r15,%rdx,8)
movups %xmm2,0x10(%r15,%rdx,8)
mov    %esi,%edx
movupd (%r14,%rdx,8),%xmm1
movupd 0x10(%r14,%rdx,8),%xmm2
movupd %xmm1,(%r15,%rdx,8)
movupd %xmm2,0x10(%r15,%rdx,8)
add    $0x8,%rax
add    $0x8,%esi
add    $0xfffffffffffffffe,%rcx
jne    1a30 <double_stencil19+0x8a0>
testb  $0x1,0x108(%rsp)
01
mov    0x20(%rsp),%rbx
je     1aa7 <double_stencil19+0x917>
lea    (%r8,%r11,1),%ecx
imul   %ebp,%ecx
or     $0x1,%eax
add    %ecx,%eax
movupd (%r14,%rax,8),%xmm1
movupd 0x10(%r14,%rax,8),%xmm2
movupd %xmm1,(%r15,%rax,8)
movupd %xmm2,0x10(%r15,%rax,8)
mov    0xf8(%rsp),%rcx
mov    0x100(%rsp),%rax
cmp    %rax,0x70(%rsp)
je     19b0 <double_stencil19+0x820>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rdx
mov    %edx,%esi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
add    %rbx,%rax
and    $0x3,%rsi
je     1b09 <double_stencil19+0x979>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%edx
movsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1af0 <double_stencil19+0x960>
cmp    $0x3,%rax
mov    0x20(%rsp),%rbx
jb     19b0 <double_stencil19+0x820>
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rax
mov    %eax,%edx
movsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
lea    0x1(%rax),%edx
movsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
lea    0x2(%rax),%edx
movsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
add    $0x3,%eax
movsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1b20 <double_stencil19+0x990>
jmp    19b0 <double_stencil19+0x820>
mov    0x246c(%rip),%rax
mov    (%rax),%edi
lea    0x50(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x58(%rsp),%edi
mov    0x50(%rsp),%esi
lea    0x4ad(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i32 }
@.str = [68 x i8] c"19-point 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 - 19 point\00"
define void @double_stencil19(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 0x3FAC71C71C71C71C, 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 = %572, %143
%147 = load i32, i32* %6
%148 = icmp slt i32 %147, 100
br i1 %148, label %149, label %575
149: ; preds = %146
store i32 1, i32* %3
br label %150
150: ; preds = %509, %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 %512
155: ; preds = %150
store i32 1, i32* %4
br label %156
156: ; preds = %505, %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 %508
161: ; preds = %156
store i32 1, i32* %5
br label %162
162: ; preds = %501, %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 %504
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 = load i32, i32* %2
%382 = mul i32 %380, %381
%383 = load i32, i32* %2
%384 = mul i32 %382, %383
%385 = load i32, i32* %4
%386 = sub nsw i32 %385, 1
%387 = load i32, i32* %2
%388 = mul i32 %386, %387
%389 = add i32 %384, %388
%390 = load i32, i32* %5
%391 = add nsw i32 %390, 1
%392 = add i32 %389, %391
%393 = zext i32 %392 to i64
%394 = getelementptr inbounds double, double* %379, i64 %393
%395 = load double, double* %394
%396 = fadd double %378, %395
%397 = load double*, double** %9
%398 = load i32, i32* %3
%399 = load i32, i32* %2
%400 = mul i32 %398, %399
%401 = load i32, i32* %2
%402 = mul i32 %400, %401
%403 = load i32, i32* %4
%404 = add nsw i32 %403, 1
%405 = load i32, i32* %2
%406 = mul i32 %404, %405
%407 = add i32 %402, %406
%408 = load i32, i32* %5
%409 = add nsw i32 %408, 1
%410 = add i32 %407, %409
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds double, double* %397, i64 %411
%413 = load double, double* %412
%414 = fadd double %396, %413
%415 = load double*, double** %9
%416 = load i32, i32* %3
%417 = sub nsw i32 %416, 1
%418 = load i32, i32* %2
%419 = mul i32 %417, %418
%420 = load i32, i32* %2
%421 = mul i32 %419, %420
%422 = load i32, i32* %4
%423 = load i32, i32* %2
%424 = mul i32 %422, %423
%425 = add i32 %421, %424
%426 = load i32, i32* %5
%427 = add nsw i32 %426, 1
%428 = add i32 %425, %427
%429 = zext i32 %428 to i64
%430 = getelementptr inbounds double, double* %415, i64 %429
%431 = load double, double* %430
%432 = fadd double %414, %431
%433 = load double*, double** %9
%434 = load i32, i32* %3
%435 = add nsw i32 %434, 1
%436 = load i32, i32* %2
%437 = mul i32 %435, %436
%438 = load i32, i32* %2
%439 = mul i32 %437, %438
%440 = load i32, i32* %4
%441 = load i32, i32* %2
%442 = mul i32 %440, %441
%443 = add i32 %439, %442
%444 = load i32, i32* %5
%445 = add nsw i32 %444, 1
%446 = add i32 %443, %445
%447 = zext i32 %446 to i64
%448 = getelementptr inbounds double, double* %433, i64 %447
%449 = load double, double* %448
%450 = fadd double %432, %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 = load i32, i32* %2
%459 = mul i32 %457, %458
%460 = add i32 %456, %459
%461 = load i32, i32* %5
%462 = sub nsw i32 %461, 1
%463 = add i32 %460, %462
%464 = zext i32 %463 to i64
%465 = getelementptr inbounds double, double* %451, i64 %464
%466 = load double, double* %465
%467 = fadd double %450, %466
%468 = load double*, double** %9
%469 = load i32, i32* %3
%470 = load i32, i32* %2
%471 = mul i32 %469, %470
%472 = load i32, i32* %2
%473 = mul i32 %471, %472
%474 = load i32, i32* %4
%475 = load i32, i32* %2
%476 = mul i32 %474, %475
%477 = add i32 %473, %476
%478 = load i32, i32* %5
%479 = add nsw i32 %478, 1
%480 = add i32 %477, %479
%481 = zext i32 %480 to i64
%482 = getelementptr inbounds double, double* %468, i64 %481
%483 = load double, double* %482
%484 = fadd double %467, %483
%485 = load double, double* %8
%486 = fmul double %484, %485
%487 = load double*, double** %10
%488 = load i32, i32* %3
%489 = load i32, i32* %2
%490 = mul i32 %488, %489
%491 = load i32, i32* %2
%492 = mul i32 %490, %491
%493 = load i32, i32* %4
%494 = load i32, i32* %2
%495 = mul i32 %493, %494
%496 = add i32 %492, %495
%497 = load i32, i32* %5
%498 = add i32 %496, %497
%499 = zext i32 %498 to i64
%500 = getelementptr inbounds double, double* %487, i64 %499
store double %486, double* %500
br label %501
501: ; preds = %167
%502 = load i32, i32* %5
%503 = add nsw i32 %502, 1
store i32 %503, i32* %5
br label %162
504: ; preds = %162
br label %505
505: ; preds = %504
%506 = load i32, i32* %4
%507 = add nsw i32 %506, 1
store i32 %507, i32* %4
br label %156
508: ; preds = %156
br label %509
509: ; preds = %508
%510 = load i32, i32* %3
%511 = add nsw i32 %510, 1
store i32 %511, i32* %3
br label %150
512: ; preds = %150
store i32 1, i32* %3
br label %513
513: ; preds = %568, %512
%514 = load i32, i32* %3
%515 = load i32, i32* %7
%516 = add nsw i32 %515, 1
%517 = icmp slt i32 %514, %516
br i1 %517, label %518, label %571
518: ; preds = %513
store i32 1, i32* %4
br label %519
519: ; preds = %564, %518
%520 = load i32, i32* %4
%521 = load i32, i32* %7
%522 = add nsw i32 %521, 1
%523 = icmp slt i32 %520, %522
br i1 %523, label %524, label %567
524: ; preds = %519
store i32 1, i32* %5
br label %525
525: ; preds = %560, %524
%526 = load i32, i32* %5
%527 = load i32, i32* %7
%528 = add nsw i32 %527, 1
%529 = icmp slt i32 %526, %528
br i1 %529, label %530, label %563
530: ; preds = %525
%531 = load double*, double** %10
%532 = load i32, i32* %3
%533 = load i32, i32* %2
%534 = mul i32 %532, %533
%535 = load i32, i32* %2
%536 = mul i32 %534, %535
%537 = load i32, i32* %4
%538 = load i32, i32* %2
%539 = mul i32 %537, %538
%540 = add i32 %536, %539
%541 = load i32, i32* %5
%542 = add i32 %540, %541
%543 = zext i32 %542 to i64
%544 = getelementptr inbounds double, double* %531, i64 %543
%545 = load double, double* %544
%546 = load double*, double** %9
%547 = load i32, i32* %3
%548 = load i32, i32* %2
%549 = mul i32 %547, %548
%550 = load i32, i32* %2
%551 = mul i32 %549, %550
%552 = load i32, i32* %4
%553 = load i32, i32* %2
%554 = mul i32 %552, %553
%555 = add i32 %551, %554
%556 = load i32, i32* %5
%557 = add i32 %555, %556
%558 = zext i32 %557 to i64
%559 = getelementptr inbounds double, double* %546, i64 %558
store double %545, double* %559
br label %560
560: ; preds = %530
%561 = load i32, i32* %5
%562 = add nsw i32 %561, 1
store i32 %562, i32* %5
br label %525
563: ; preds = %525
br label %564
564: ; preds = %563
%565 = load i32, i32* %4
%566 = add nsw i32 %565, 1
store i32 %566, i32* %4
br label %519
567: ; preds = %519
br label %568
568: ; preds = %567
%569 = load i32, i32* %3
%570 = add nsw i32 %569, 1
store i32 %570, i32* %3
br label %513
571: ; preds = %513
br label %572
572: ; preds = %571
%573 = load i32, i32* %6
%574 = add nsw i32 %573, 1
store i32 %574, i32* %6
br label %146
575: ; preds = %146
%576 = load i32, i32* @CLOCK_MONOTONIC_RAW
%577 = call i32 @clock_gettime(i32 %576, %struct.timespec* %12)
%578 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%579 = load i32, i32* %578
%580 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%581 = load i32, i32* %580
%582 = call i32 @elapsed_time_hr(i32 %579, i32 %581, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%583 = load double*, double** %9
%584 = call i32 @free(double* %583)
%585 = load double*, double** %10
%586 = call i32 @free(double* %585)
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 - 19 point\00"
@str = [67 x i8] c"19-point Double Precision Stencil Error: Unable to allocate memory\00"
define void @double_stencil19(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, %484
%224 = phi i32 [ 0, %191 ], [ %485, %484 ]
br i1 %192, label %226, label %484
225: ; preds = %350
br i1 %192, label %352, label %484
226: ; preds = %223, %350
%227 = phi i32 [ %231, %350 ], [ 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 = %348, %226
%234 = phi i32 [ 1, %226 ], [ %238, %348 ]
%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 %241, %228
br label %245
245: ; preds = %233, %245
%246 = phi i64 [ 1, %233 ], [ %311, %245 ]
%247 = trunc i64 %246 to i32
%248 = add i32 %237, %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds double, double* %8, i64 %249
%251 = load double, double* %250
%252 = add i32 %240, %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 %242, %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 %243, %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 %236, %247
%268 = add i32 %267, %230
%269 = zext i32 %268 to i64
%270 = getelementptr inbounds double, double* %8, i64 %269
%271 = load double, double* %270
%272 = fadd double %266, %271
%273 = add i32 %239, %247
%274 = add i32 %273, %230
%275 = zext i32 %274 to i64
%276 = getelementptr inbounds double, double* %8, i64 %275
%277 = load double, double* %276
%278 = fadd double %272, %277
%279 = add i32 %267, %232
%280 = zext i32 %279 to i64
%281 = getelementptr inbounds double, double* %8, i64 %280
%282 = load double, double* %281
%283 = fadd double %278, %282
%284 = add i32 %273, %232
%285 = zext i32 %284 to i64
%286 = getelementptr inbounds double, double* %8, i64 %285
%287 = load double, double* %286
%288 = fadd double %283, %287
%289 = trunc i64 %246 to i32
%290 = add i32 %289, -1
%291 = add i32 %290, %237
%292 = zext i32 %291 to i64
%293 = getelementptr inbounds double, double* %8, i64 %292
%294 = load double, double* %293
%295 = fadd double %288, %294
%296 = add i32 %290, %240
%297 = zext i32 %296 to i64
%298 = getelementptr inbounds double, double* %8, i64 %297
%299 = load double, double* %298
%300 = fadd double %295, %299
%301 = add i32 %290, %242
%302 = zext i32 %301 to i64
%303 = getelementptr inbounds double, double* %8, i64 %302
%304 = load double, double* %303
%305 = fadd double %300, %304
%306 = add i32 %290, %243
%307 = zext i32 %306 to i64
%308 = getelementptr inbounds double, double* %8, i64 %307
%309 = load double, double* %308
%310 = fadd double %305, %309
%311 = add nuw nsw i64 %246, 1
%312 = trunc i64 %311 to i32
%313 = add i32 %237, %312
%314 = zext i32 %313 to i64
%315 = getelementptr inbounds double, double* %8, i64 %314
%316 = load double, double* %315
%317 = fadd double %310, %316
%318 = add i32 %240, %312
%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 %242, %312
%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 %243, %312
%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 i32 %290, %244
%334 = zext i32 %333 to i64
%335 = getelementptr inbounds double, double* %8, i64 %334
%336 = load double, double* %335
%337 = fadd double %332, %336
%338 = add i32 %244, %312
%339 = zext i32 %338 to i64
%340 = getelementptr inbounds double, double* %8, i64 %339
%341 = load double, double* %340
%342 = fadd double %337, %341
%343 = fmul double %342, 0x3FAC71C71C71C71C
%344 = add i32 %244, %247
%345 = zext i32 %344 to i64
%346 = getelementptr inbounds double, double* %10, i64 %345
store double %343, double* %346
%347 = icmp eq i64 %311, %196
br i1 %347, label %348, label %245
348: ; preds = %245
%349 = icmp eq i32 %238, %193
br i1 %349, label %350, label %233
350: ; preds = %348
%351 = icmp eq i32 %231, %193
br i1 %351, label %225, label %226
352: ; preds = %225, %480
%353 = phi i32 [ %483, %480 ], [ 0, %225 ]
%354 = phi i32 [ %481, %480 ], [ 1, %225 ]
%355 = mul i32 %202, %353
%356 = add i32 %201, %355
%357 = mul i32 %354, %0
br label %358
358: ; preds = %476, %352
%359 = phi i32 [ %479, %476 ], [ 0, %352 ]
%360 = phi i32 [ %477, %476 ], [ 1, %352 ]
%361 = add i32 %360, %357
%362 = mul i32 %361, %0
br i1 %210, label %423, label %363
363: ; preds = %358
%364 = mul i32 %359, %0
%365 = add i32 %356, %364
%366 = xor i32 %365, -1
%367 = icmp ult i32 %366, %211
%368 = or i1 %367, %212
%369 = select i1 %368, i1 true, i1 %215
br i1 %369, label %423, label %370
370: ; preds = %363
br i1 %219, label %405, label %371
371: ; preds = %370, %371
%372 = phi i64 [ %402, %371 ], [ 0, %370 ]
%373 = phi i64 [ %403, %371 ], [ 0, %370 ]
%374 = trunc i64 %372 to i32
%375 = or i32 %374, 1
%376 = add i32 %362, %375
%377 = zext i32 %376 to i64
%378 = getelementptr inbounds double, double* %10, i64 %377
%379 = bitcast double* %378 to <2 x double>*
%380 = load <2 x double>, <2 x double>* %379
%381 = getelementptr inbounds double, double* %378, i64 2
%382 = bitcast double* %381 to <2 x double>*
%383 = load <2 x double>, <2 x double>* %382
%384 = getelementptr inbounds double, double* %8, i64 %377
%385 = bitcast double* %384 to <2 x double>*
store <2 x double> %380, <2 x double>* %385
%386 = getelementptr inbounds double, double* %384, i64 2
%387 = bitcast double* %386 to <2 x double>*
store <2 x double> %383, <2 x double>* %387
%388 = trunc i64 %372 to i32
%389 = or i32 %388, 5
%390 = add i32 %362, %389
%391 = zext i32 %390 to i64
%392 = getelementptr inbounds double, double* %10, i64 %391
%393 = bitcast double* %392 to <2 x double>*
%394 = load <2 x double>, <2 x double>* %393
%395 = getelementptr inbounds double, double* %392, i64 2
%396 = bitcast double* %395 to <2 x double>*
%397 = load <2 x double>, <2 x double>* %396
%398 = getelementptr inbounds double, double* %8, i64 %391
%399 = bitcast double* %398 to <2 x double>*
store <2 x double> %394, <2 x double>* %399
%400 = getelementptr inbounds double, double* %398, i64 2
%401 = bitcast double* %400 to <2 x double>*
store <2 x double> %397, <2 x double>* %401
%402 = add nuw i64 %372, 8
%403 = add i64 %373, 2
%404 = icmp eq i64 %403, %220
br i1 %404, label %405, label %371
405: ; preds = %371, %370
%406 = phi i64 [ 0, %370 ], [ %402, %371 ]
br i1 %221, label %422, label %407
407: ; preds = %405
%408 = trunc i64 %406 to i32
%409 = or i32 %408, 1
%410 = add i32 %362, %409
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds double, double* %10, i64 %411
%413 = bitcast double* %412 to <2 x double>*
%414 = load <2 x double>, <2 x double>* %413
%415 = getelementptr inbounds double, double* %412, i64 2
%416 = bitcast double* %415 to <2 x double>*
%417 = load <2 x double>, <2 x double>* %416
%418 = getelementptr inbounds double, double* %8, i64 %411
%419 = bitcast double* %418 to <2 x double>*
store <2 x double> %414, <2 x double>* %419
%420 = getelementptr inbounds double, double* %418, i64 2
%421 = bitcast double* %420 to <2 x double>*
store <2 x double> %417, <2 x double>* %421
br label %422
422: ; preds = %405, %407
br i1 %222, label %476, label %423
423: ; preds = %363, %358, %422
%424 = phi i64 [ 1, %363 ], [ 1, %358 ], [ %217, %422 ]
%425 = sub nsw i64 %196, %424
%426 = xor i64 %424, -1
%427 = add nsw i64 %426, %196
%428 = and i64 %425, 3
%429 = icmp eq i64 %428, 0
br i1 %429, label %442, label %430
430: ; preds = %423, %430
%431 = phi i64 [ %439, %430 ], [ %424, %423 ]
%432 = phi i64 [ %440, %430 ], [ 0, %423 ]
%433 = trunc i64 %431 to i32
%434 = add i32 %362, %433
%435 = zext i32 %434 to i64
%436 = getelementptr inbounds double, double* %10, i64 %435
%437 = load double, double* %436
%438 = getelementptr inbounds double, double* %8, i64 %435
store double %437, double* %438
%439 = add nuw nsw i64 %431, 1
%440 = add i64 %432, 1
%441 = icmp eq i64 %440, %428
br i1 %441, label %442, label %430
442: ; preds = %430, %423
%443 = phi i64 [ %424, %423 ], [ %439, %430 ]
%444 = icmp ult i64 %427, 3
br i1 %444, label %476, label %445
445: ; preds = %442, %445
%446 = phi i64 [ %474, %445 ], [ %443, %442 ]
%447 = trunc i64 %446 to i32
%448 = add i32 %362, %447
%449 = zext i32 %448 to i64
%450 = getelementptr inbounds double, double* %10, i64 %449
%451 = load double, double* %450
%452 = getelementptr inbounds double, double* %8, i64 %449
store double %451, double* %452
%453 = trunc i64 %446 to i32
%454 = add i32 %453, 1
%455 = add i32 %362, %454
%456 = zext i32 %455 to i64
%457 = getelementptr inbounds double, double* %10, i64 %456
%458 = load double, double* %457
%459 = getelementptr inbounds double, double* %8, i64 %456
store double %458, double* %459
%460 = trunc i64 %446 to i32
%461 = add i32 %460, 2
%462 = add i32 %362, %461
%463 = zext i32 %462 to i64
%464 = getelementptr inbounds double, double* %10, i64 %463
%465 = load double, double* %464
%466 = getelementptr inbounds double, double* %8, i64 %463
store double %465, double* %466
%467 = trunc i64 %446 to i32
%468 = add i32 %467, 3
%469 = add i32 %362, %468
%470 = zext i32 %469 to i64
%471 = getelementptr inbounds double, double* %10, i64 %470
%472 = load double, double* %471
%473 = getelementptr inbounds double, double* %8, i64 %470
store double %472, double* %473
%474 = add nuw nsw i64 %446, 4
%475 = icmp eq i64 %474, %197
br i1 %475, label %476, label %445
476: ; preds = %442, %445, %422
%477 = add nuw nsw i32 %360, 1
%478 = icmp eq i32 %477, %193
%479 = add i32 %359, 1
br i1 %478, label %480, label %358
480: ; preds = %476
%481 = add nuw nsw i32 %354, 1
%482 = icmp eq i32 %481, %193
%483 = add i32 %353, 1
br i1 %482, label %484, label %352
484: ; preds = %480, %223, %225
%485 = add nuw nsw i32 %224, 1
%486 = icmp eq i32 %485, 100
br i1 %486, label %487, label %223
487: ; preds = %484
%488 = load i32, i32* @CLOCK_MONOTONIC_RAW
%489 = call i32 @clock_gettime(i32 %488, %struct.timespec* %3)
%490 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%491 = load i32, i32* %490
%492 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%493 = load i32, i32* %492
%494 = call i32 @elapsed_time_hr(i32 %491, i32 %493, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%495 = call i32 @free(double* %8)
%496 = call i32 @free(double* %10)
ret void
}