#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 */

/* Variables and functions */
scalar_t__ RAND_MAX;
int cbrt(unsigned int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double max_diff(double *, double *, int);
int /*<<< orphan*/ memcpy(double *, double *, int);
double omp_get_wtime();
scalar_t__ rand();
double stencil() {
  extern unsigned int datasize;
  int sz = cbrt((datasize / sizeof(double)) / 2);
  int i, j, k, iter;
  int n = sz - 2;
  double fac = (1. / 26);
  double t1, t2;
  double md;
  double *a0 = (double *)malloc(sizeof(double) * sz * sz * sz);
  double *device_result = (double *)malloc(sizeof(double) * sz * sz * sz);
  double *a1 = (double *)malloc(sizeof(double) * sz * sz * sz);
  double *host_result = (double *)malloc(sizeof(double) * sz * sz * sz);
  double *a0_init = (double *)malloc(sizeof(double) * sz * sz * sz);
  if (a0 == NULL || device_result == NULL || a1 == NULL ||
      host_result == NULL || a0_init == NULL) {
    return (-10000);
  }
  for (i = 0; i < sz; i++) {
    for (j = 0; j < sz; j++) {
      for (k = 0; k < sz; k++) {
        a0[i * sz * sz + j * sz + k] = 0.0;
      }
    }
  }
  for (i = 1; i < n + 1; i++) {
    for (j = 1; j < n + 1; j++) {
      for (k = 1; k < n + 1; k++) {
        a0[i * sz * sz + j * sz + k] =
            (double)rand() / (double)(1.0 + RAND_MAX);
      }
    }
  }
  for (i = 0; i < sz; i++) {
    for (j = 0; j < sz; j++) {
      for (k = 0; k < sz; k++) {
        a0_init[i * sz * sz + j * sz + k] = a0[i * sz * sz + j * sz + k];
      }
    }
  }
  for (iter = 0; iter < 10; iter++) {
    for (i = 1; i < n + 1; i++) {
      for (j = 1; j < n + 1; j++) {
        for (k = 1; k < n + 1; k++) {
          a1[i * sz * sz + j * sz + k] =
              (a0[i * sz * sz + (j - 1) * sz + k] +
               a0[i * sz * sz + (j + 1) * sz + k] +
               a0[(i - 1) * sz * sz + j * sz + k] +
               a0[(i + 1) * sz * sz + j * sz + k] +
               a0[(i - 1) * sz * sz + (j - 1) * sz + k] +
               a0[(i - 1) * sz * sz + (j + 1) * sz + k] +
               a0[(i + 1) * sz * sz + (j - 1) * sz + k] +
               a0[(i + 1) * sz * sz + (j + 1) * sz + k] +
               a0[i * sz * sz + (j - 1) * sz + (k - 1)] +
               a0[i * sz * sz + (j + 1) * sz + (k - 1)] +
               a0[(i - 1) * sz * sz + j * sz + (k - 1)] +
               a0[(i + 1) * sz * sz + j * sz + (k - 1)] +
               a0[(i - 1) * sz * sz + (j - 1) * sz + (k - 1)] +
               a0[(i - 1) * sz * sz + (j + 1) * sz + (k - 1)] +
               a0[(i + 1) * sz * sz + (j - 1) * sz + (k - 1)] +
               a0[(i + 1) * sz * sz + (j + 1) * sz + (k - 1)] +
               a0[i * sz * sz + (j - 1) * sz + (k + 1)] +
               a0[i * sz * sz + (j + 1) * sz + (k + 1)] +
               a0[(i - 1) * sz * sz + j * sz + (k + 1)] +
               a0[(i + 1) * sz * sz + j * sz + (k + 1)] +
               a0[(i - 1) * sz * sz + (j - 1) * sz + (k + 1)] +
               a0[(i - 1) * sz * sz + (j + 1) * sz + (k + 1)] +
               a0[(i + 1) * sz * sz + (j - 1) * sz + (k + 1)] +
               a0[(i + 1) * sz * sz + (j + 1) * sz + (k + 1)] +
               a0[i * sz * sz + j * sz + (k - 1)] +
               a0[i * sz * sz + j * sz + (k + 1)]) *
              fac;
        }
      }
    }
    for (i = 1; i < n + 1; i++) {
      for (j = 1; j < n + 1; j++) {
        for (k = 1; k < n + 1; k++) {
          a0[i * sz * sz + j * sz + k] = a1[i * sz * sz + j * sz + k];
        }
      }
    }
  }
  for (i = 0; i < sz; i++) {
    for (j = 0; j < sz; j++) {
      for (k = 0; k < sz; k++) {
        host_result[i * sz * sz + j * sz + k] = a0[i * sz * sz + j * sz + k];
      }
    }
  }
  for (i = 0; i < sz; i++) {
    for (j = 0; j < sz; j++) {
      for (k = 0; k < sz; k++) {
        a0[i * sz * sz + j * sz + k] = a0_init[i * sz * sz + j * sz + k];
      }
    }
  }
  t1 = omp_get_wtime();
#pragma acc data copy(a0 [0:sz * sz * sz]),                                    \
    create(a1 [0:sz * sz * sz], i, j, k, iter), copyin(sz, fac, n)
  {
    for (iter = 0; iter < 10; iter++) {
#pragma acc parallel loop
      for (i = 1; i < n + 1; i++) {
#pragma acc loop
        for (j = 1; j < n + 1; j++) {
#pragma acc loop
          for (k = 1; k < n + 1; k++) {
            a1[i * sz * sz + j * sz + k] =
                (a0[i * sz * sz + (j - 1) * sz + k] +
                 a0[i * sz * sz + (j + 1) * sz + k] +
                 a0[(i - 1) * sz * sz + j * sz + k] +
                 a0[(i + 1) * sz * sz + j * sz + k] +
                 a0[(i - 1) * sz * sz + (j - 1) * sz + k] +
                 a0[(i - 1) * sz * sz + (j + 1) * sz + k] +
                 a0[(i + 1) * sz * sz + (j - 1) * sz + k] +
                 a0[(i + 1) * sz * sz + (j + 1) * sz + k] +
                 a0[i * sz * sz + (j - 1) * sz + (k - 1)] +
                 a0[i * sz * sz + (j + 1) * sz + (k - 1)] +
                 a0[(i - 1) * sz * sz + j * sz + (k - 1)] +
                 a0[(i + 1) * sz * sz + j * sz + (k - 1)] +
                 a0[(i - 1) * sz * sz + (j - 1) * sz + (k - 1)] +
                 a0[(i - 1) * sz * sz + (j + 1) * sz + (k - 1)] +
                 a0[(i + 1) * sz * sz + (j - 1) * sz + (k - 1)] +
                 a0[(i + 1) * sz * sz + (j + 1) * sz + (k - 1)] +
                 a0[i * sz * sz + (j - 1) * sz + (k + 1)] +
                 a0[i * sz * sz + (j + 1) * sz + (k + 1)] +
                 a0[(i - 1) * sz * sz + j * sz + (k + 1)] +
                 a0[(i + 1) * sz * sz + j * sz + (k + 1)] +
                 a0[(i - 1) * sz * sz + (j - 1) * sz + (k + 1)] +
                 a0[(i - 1) * sz * sz + (j + 1) * sz + (k + 1)] +
                 a0[(i + 1) * sz * sz + (j - 1) * sz + (k + 1)] +
                 a0[(i + 1) * sz * sz + (j + 1) * sz + (k + 1)] +
                 a0[i * sz * sz + j * sz + (k - 1)] +
                 a0[i * sz * sz + j * sz + (k + 1)]) *
                fac;
          }
        }
      }
#pragma acc parallel loop
      for (i = 1; i < n + 1; i++) {
#pragma acc loop
        for (j = 1; j < n + 1; j++) {
#pragma acc loop
          for (k = 1; k < n + 1; k++) {
            a0[i * sz * sz + j * sz + k] = a1[i * sz * sz + j * sz + k];
          }
        }
      }
    }
  }
#pragma acc wait
  t2 = omp_get_wtime();
  memcpy(&device_result[0], &a0[0], sizeof(double) * sz * sz * sz);
  md = max_diff(&host_result[0], &device_result[0], sz);
  free(a0);
  free(a0_init);
  free(a1);
  free(host_result);
  free(device_result);
  if (md < 1.0e-15) {
    return (t2 - t1);
  } else {
    return (-11000);
  }
}


x86 assembly (clang, -O0):
<stencil>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x3e61(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
shr    $0x1,%rax
mov    %eax,%edi
call   1070 <cbrt@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
movsd  0x1e5c(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     128f <stencil+0x11f>
cmpq   $0x0,-0x50(%rbp)
je     128f <stencil+0x11f>
cmpq   $0x0,-0x58(%rbp)
je     128f <stencil+0x11f>
cmpq   $0x0,-0x60(%rbp)
je     128f <stencil+0x11f>
cmpq   $0x0,-0x68(%rbp)
jne    12a1 <stencil+0x131>
movsd  0x1d89(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    2285 <stencil+0x1115>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1334 <stencil+0x1c4>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1321 <stencil+0x1b1>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    130e <stencil+0x19e>
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12ce <stencil+0x15e>
jmp    1313 <stencil+0x1a3>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12bb <stencil+0x14b>
jmp    1326 <stencil+0x1b6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12a8 <stencil+0x138>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13fb <stencil+0x28b>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13e8 <stencil+0x278>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13d5 <stencil+0x265>
mov    $0x0,%al
call   1090 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3c59(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0x1c7c(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    136b <stencil+0x1fb>
jmp    13da <stencil+0x26a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1353 <stencil+0x1e3>
jmp    13ed <stencil+0x27d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    133b <stencil+0x1cb>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ae <stencil+0x33e>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    149b <stencil+0x32b>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1488 <stencil+0x318>
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1428 <stencil+0x2b8>
jmp    148d <stencil+0x31d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1415 <stencil+0x2a5>
jmp    14a0 <stencil+0x330>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1402 <stencil+0x292>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1a8c <stencil+0x91c>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    19b7 <stencil+0x847>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    19a4 <stencil+0x834>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1991 <stencil+0x821>
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mulsd  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14f6 <stencil+0x386>
jmp    1996 <stencil+0x826>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14de <stencil+0x36e>
jmp    19a9 <stencil+0x839>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14c6 <stencil+0x356>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a79 <stencil+0x909>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a66 <stencil+0x8f6>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a53 <stencil+0x8e3>
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    19ee <stencil+0x87e>
jmp    1a58 <stencil+0x8e8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    19d6 <stencil+0x866>
jmp    1a6b <stencil+0x8fb>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19be <stencil+0x84e>
jmp    1a7e <stencil+0x90e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b5 <stencil+0x345>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b3f <stencil+0x9cf>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b2c <stencil+0x9bc>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b19 <stencil+0x9a9>
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1ab9 <stencil+0x949>
jmp    1b1e <stencil+0x9ae>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1aa6 <stencil+0x936>
jmp    1b31 <stencil+0x9c1>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1a93 <stencil+0x923>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bf2 <stencil+0xa82>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bdf <stencil+0xa6f>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bcc <stencil+0xa5c>
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1b6c <stencil+0x9fc>
jmp    1bd1 <stencil+0xa61>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1b59 <stencil+0x9e9>
jmp    1be4 <stencil+0xa74>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1b46 <stencil+0x9d6>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    21dc <stencil+0x106c>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2107 <stencil+0xf97>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    20f4 <stencil+0xf84>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    20e1 <stencil+0xf71>
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mulsd  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1c46 <stencil+0xad6>
jmp    20e6 <stencil+0xf76>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1c2e <stencil+0xabe>
jmp    20f9 <stencil+0xf89>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1c16 <stencil+0xaa6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    21c9 <stencil+0x1059>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    21b6 <stencil+0x1046>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    21a3 <stencil+0x1033>
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    213e <stencil+0xfce>
jmp    21a8 <stencil+0x1038>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    2126 <stencil+0xfb6>
jmp    21bb <stencil+0x104b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    210e <stencil+0xf9e>
jmp    21ce <stencil+0x105e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1c05 <stencil+0xa95>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1080 <max_diff@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movsd  0xdaf(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    2278 <stencil+0x1108>
movsd  -0x38(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    2285 <stencil+0x1115>
movsd  0xd90(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stencil>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    0x3e48(%rip),%rax
mov    (%rax),%edi
shr    $0x4,%edi
call   1080 <cbrt@plt>
mov    %eax,%r15d
imul   %eax,%eax
mov    %rax,0x48(%rsp)
mov    %eax,%ebp
imul   %r15d,%ebp
shl    $0x3,%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0xa0(%rsp)
movsd  0x1e01(%rip),%xmm0
test   %r12,%r12
je     272f <stencil+0x15af>
test   %rbx,%rbx
je     272f <stencil+0x15af>
cmpq   $0x0,0x90(%rsp)
je     272f <stencil+0x15af>
cmpq   $0x0,0xc8(%rsp)
je     272f <stencil+0x15af>
cmpq   $0x0,0xa0(%rsp)
je     272f <stencil+0x15af>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
mov    %rax,0xc0(%rsp)
mov    %r15d,%eax
test   %r15d,%r15d
mov    %r15,0x10(%rsp)
mov    %r12,0x8(%rsp)
mov    %rax,0x80(%rsp)
mov    %rbx,0x140(%rsp)
mov    %ebp,0xf4(%rsp)
jle    14dc <stencil+0x35c>
lea    0x0(,%rax,8),%r13
lea    -0x1(%rax),%rcx
mov    %rcx,0xa8(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x88(%rsp)
mov    %eax,%r14d
and    $0xfffffffc,%r14d
lea    (%r15,%r15,1),%eax
mov    %rax,0x40(%rsp)
mov    %r15d,%eax
imul   %r15d,%eax
mov    %eax,0x30(%rsp)
lea    0x0(,%r15,4),%ecx
lea    (%r15,%r15,2),%eax
mov    %rax,0xb0(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %edx,%edx
mov    %ecx,0x38(%rsp)
jmp    12fd <stencil+0x17d>
nopl   0x0(%rax)
mov    0x68(%rsp),%edx
add    $0x1,%edx
mov    0x18(%rsp),%rax
add    0x30(%rsp),%eax
mov    %rax,0x18(%rsp)
cmp    %ebx,%edx
je     140f <stencil+0x28f>
mov    %edx,0x68(%rsp)
cmpq   $0x3,0xa8(%rsp)
jae    1320 <stencil+0x1a0>
xor    %r15d,%r15d
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rbp
jmp    13c6 <stencil+0x246>
xchg   %ax,%ax
mov    0x18(%rsp),%r12
xor    %r15d,%r15d
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %r12d,%r12
lea    0x0(,%r12,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
lea    (%rbx,%r12,1),%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
mov    0x40(%rsp),%rax
add    %r12d,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
mov    0xb0(%rsp),%rax
add    %r12d,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
add    $0x4,%r15
add    0x38(%rsp),%r12d
cmp    %r15,%r14
jne    1340 <stencil+0x1c0>
cmpq   $0x0,0x88(%rsp)
mov    %rbp,%r12
je     12e0 <stencil+0x160>
imul   %ebx,%r15d
add    0x18(%rsp),%r15d
mov    0x88(%rsp),%rbp
nopl   0x0(%rax)
movslq %r15d,%r15
lea    (%r12,%r15,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1050 <memset@plt>
add    %ebx,%r15d
add    $0xffffffffffffffff,%rbp
jne    13f0 <stencil+0x270>
jmp    12e0 <stencil+0x160>
mov    %rbx,%r15
lea    -0x1(%rbx),%ecx
cmp    $0x3,%r15d
setge  %al
mov    %eax,0x24(%rsp)
mov    %ecx,0x28(%rsp)
jl     14ed <stencil+0x36d>
mov    %ecx,%ebx
lea    0x1(%r15),%r13d
imul   %r15d,%r13d
mov    $0x1,%eax
mov    0x3ba8(%rip),%rbp
mov    %eax,0x38(%rsp)
mov    $0x1,%r12d
mov    %r13d,0x40(%rsp)
nop
movslq %r13d,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
mov    $0x1,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   10a0 <rand@plt>
movsd  0x1b89(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq 0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%r15,8)
add    $0x1,%r15
cmp    %r15,%rbx
jne    1470 <stencil+0x2f0>
add    $0x1,%r12
mov    0x10(%rsp),%r15
add    %r15d,%r13d
cmp    %rbx,%r12
jne    1450 <stencil+0x2d0>
mov    0x38(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%r13d
add    0x30(%rsp),%r13d
mov    0x28(%rsp),%ecx
cmp    %ecx,%eax
jne    1440 <stencil+0x2c0>
mov    0x8(%rsp),%r12
jmp    14f5 <stencil+0x375>
lea    -0x1(%r15),%ecx
movl   $0x0,0x24(%rsp)
jmp    17ca <stencil+0x64a>
movl   $0x0,0x24(%rsp)
test   %r15d,%r15d
mov    0x80(%rsp),%rsi
jle    17ca <stencil+0x64a>
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rsi,8),%rax
lea    (%r12,%rsi,8),%rcx
mov    %esi,%r14d
and    $0xfffffffc,%r14d
lea    -0x4(%r14),%rdi
mov    %rdi,0x40(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %rdx,%rcx
seta   %cl
cmp    %r12,%rax
mov    %r12,%rax
seta   %r12b
and    %cl,%r12b
mov    %edi,%r8d
and    $0x3,%r8d
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rdi
mov    %rdi,0x88(%rsp)
mov    %esi,%r15d
and    $0x3,%r15d
lea    0x70(%rdx),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x70(%rax),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x10(%rdx),%rcx
mov    %rcx,0x18(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x68(%rsp)
mov    %r8,%rdi
shl    $0x5,%rdi
lea    0x18(%rdx),%rcx
mov    %rcx,0x38(%rsp)
add    $0x18,%rax
mov    %rax,0xb0(%rsp)
xor    %ecx,%ecx
xor    %edx,%edx
jmp    15cb <stencil+0x44b>
mov    0x58(%rsp),%edx
add    $0x1,%edx
mov    0xb8(%rsp),%rcx
add    0x30(%rsp),%ecx
cmp    %eax,%edx
je     17bc <stencil+0x63c>
mov    %edx,0x58(%rsp)
mov    %rcx,0xb8(%rsp)
mov    %ecx,%r9d
xor    %r10d,%r10d
mov    0x10(%rsp),%rax
jmp    1601 <stencil+0x481>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
mov    0x10(%rsp),%rax
add    %eax,%r9d
cmp    %rsi,%r10
je     15b0 <stencil+0x430>
cmp    $0x4,%eax
setb   %al
movslq %r9d,%rbx
or     %r12b,%al
je     1620 <stencil+0x4a0>
xor    %eax,%eax
jmp    170b <stencil+0x58b>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0xc,0x40(%rsp)
jae    1630 <stencil+0x4b0>
xor    %eax,%eax
jmp    16c4 <stencil+0x544>
nop
mov    0xa8(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
mov    0xd8(%rsp),%rax
lea    (%rax,%rbx,8),%r11
mov    0x88(%rsp),%r13
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%r11,%rax,8),%xmm0
movups -0x60(%r11,%rax,8),%xmm1
movups %xmm0,-0x70(%rcx,%rax,8)
movups %xmm1,-0x60(%rcx,%rax,8)
movups -0x50(%r11,%rax,8),%xmm0
movups -0x40(%r11,%rax,8),%xmm1
movups %xmm0,-0x50(%rcx,%rax,8)
movups %xmm1,-0x40(%rcx,%rax,8)
movups -0x30(%r11,%rax,8),%xmm0
movups -0x20(%r11,%rax,8),%xmm1
movups %xmm0,-0x30(%rcx,%rax,8)
movups %xmm1,-0x20(%rcx,%rax,8)
movupd -0x10(%r11,%rax,8),%xmm0
movupd (%r11,%rax,8),%xmm1
movupd %xmm0,-0x10(%rcx,%rax,8)
movupd %xmm1,(%rcx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%r13
jne    1660 <stencil+0x4e0>
test   %r8,%r8
je     16ff <stencil+0x57f>
add    %rbx,%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    16e0 <stencil+0x560>
mov    %r14,%rax
cmp    %rsi,%r14
je     15f0 <stencil+0x470>
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
test   %r15,%r15
je     1755 <stencil+0x5d5>
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbp
mov    0x8(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1740 <stencil+0x5c0>
cmp    $0x3,%rcx
mov    0x80(%rsp),%rsi
jb     15f0 <stencil+0x470>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
nopl   0x0(%rax)
movsd  -0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rax,8)
movsd  -0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rax,8)
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1780 <stencil+0x600>
jmp    15f0 <stencil+0x470>
mov    0x10(%rsp),%r15
mov    0x8(%rsp),%r12
mov    0x28(%rsp),%ecx
movslq %r15d,%r8
mov    %ecx,%eax
mov    %rax,0xf8(%rsp)
lea    0x8(%r12),%rbp
lea    (%r12,%rax,8),%rdi
mov    0x90(%rsp),%rcx
lea    0x8(%rcx),%rbx
lea    (%rcx,%rax,8),%rdx
lea    -0x1(%rax),%r13
add    $0xfffffffffffffffb,%rax
mov    %rax,0xb0(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rbp,0x130(%rsp)
mov    %rdx,0x120(%rsp)
cmp    %rdx,%rbp
setb   %al
mov    %rdi,0x138(%rsp)
mov    %rbx,0x128(%rsp)
cmp    %rdi,%rbx
setb   %dl
and    %al,%dl
mov    %dl,0x18(%rsp)
mov    %r13,%rdi
and    $0xfffffffffffffffc,%rdi
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
lea    0x2(%rax),%rbp
mov    %rsi,%rax
mov    %rsi,0x40(%rsp)
mov    %rbp,0xb8(%rsp)
and    %rbp,%rsi
mov    %rsi,0x58(%rsp)
mov    %r8,%rax
shl    $0x4,%rax
add    %r12,%rax
add    $0x10,%rax
mov    %rax,0x108(%rsp)
lea    0x1(%r15),%eax
mov    %r15d,%edx
mov    %eax,0x9c(%rsp)
imul   %eax,%edx
mov    %edx,0xe0(%rsp)
mov    %rdi,0x38(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x30(%rsp)
lea    0x8(%rcx,%r8,8),%rax
mov    %rax,0x100(%rsp)
mov    %r12,%rax
mov    %r8,0x110(%rsp)
lea    0x0(,%r8,8),%r12
mov    0x48(%rsp),%rdx
lea    (%rdx,%rdx,1),%edx
mov    %edx,0x64(%rsp)
lea    0x10(%rax),%rdx
mov    %rdx,0xd0(%rsp)
lea    0x38(%rax),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x38(%rcx),%rdx
mov    %rdx,0xd8(%rsp)
add    $0x18,%rax
mov    %rax,0x68(%rsp)
lea    0x18(%rcx),%rax
mov    %rax,0x88(%rsp)
xor    %eax,%eax
jmp    1924 <stencil+0x7a4>
nop
mov    0xe8(%rsp),%rax
add    $0x1,%eax
cmp    $0xa,%eax
je     1cdc <stencil+0xb5c>
mov    %rax,0xe8(%rsp)
cmpb   $0x0,0x24(%rsp)
je     1910 <stencil+0x790>
mov    $0x1,%ecx
xor    %edx,%edx
mov    0x64(%rsp),%esi
mov    0x48(%rsp),%rax
mov    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,0x28(%rsp)
mov    %edi,0x70(%rsp)
movslq %edi,%rax
mov    0x100(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    %esi,0x50(%rsp)
movslq %esi,%rcx
mov    0x108(%rsp),%rbp
lea    0x0(%rbp,%rcx,8),%r10
mov    0xd0(%rsp),%r14
lea    (%r14,%rcx,8),%r11
mov    %edx,0x78(%rsp)
movslq %edx,%rdx
lea    0x0(,%rdx,8),%r9
add    %rbp,%r9
lea    (%r14,%rdx,8),%rsi
mov    0x110(%rsp),%r8
add    %r8,%rcx
lea    (%r14,%rcx,8),%r15
add    %r8,%rdx
lea    (%r14,%rdx,8),%rbx
lea    0x0(%rbp,%rax,8),%rbp
lea    (%r14,%rax,8),%rdx
add    %r8,%rax
lea    (%r14,%rax,8),%r8
mov    0xf8(%rsp),%r14
addq   $0x1,0x28(%rsp)
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rax,8),%xmm0
addsd  -0x8(%rbp,%rax,8),%xmm0
addsd  -0x8(%rbx,%rax,8),%xmm0
addsd  -0x8(%r15,%rax,8),%xmm0
addsd  -0x8(%rsi,%rax,8),%xmm0
addsd  -0x8(%r9,%rax,8),%xmm0
addsd  -0x8(%r11,%rax,8),%xmm0
addsd  -0x8(%r10,%rax,8),%xmm0
addsd  -0x10(%rdx,%rax,8),%xmm0
addsd  -0x10(%rbp,%rax,8),%xmm0
addsd  -0x10(%rbx,%rax,8),%xmm0
addsd  -0x10(%r15,%rax,8),%xmm0
addsd  -0x10(%rsi,%rax,8),%xmm0
addsd  -0x10(%r9,%rax,8),%xmm0
addsd  -0x10(%r11,%rax,8),%xmm0
addsd  -0x10(%r10,%rax,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
addsd  (%r9,%rax,8),%xmm0
addsd  (%r11,%rax,8),%xmm0
addsd  (%r10,%rax,8),%xmm0
addsd  -0x10(%r8,%rax,8),%xmm0
addsd  (%r8,%rax,8),%xmm0
mulsd  0x1576(%rip),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    19f0 <stencil+0x870>
add    %r12,%rdi
add    %r12,%r10
add    %r12,%r11
add    %r12,%r9
add    %r12,%rsi
add    %r12,%r15
add    %r12,%rbx
add    %r12,%rbp
add    %r12,%rdx
add    %r12,%r8
cmp    %r14,%rcx
jne    19e0 <stencil+0x860>
mov    0x48(%rsp),%rax
mov    0x70(%rsp),%edi
add    %eax,%edi
mov    0x50(%rsp),%esi
add    %eax,%esi
mov    0x78(%rsp),%edx
add    %eax,%edx
mov    0x28(%rsp),%rcx
cmp    %r14,%rcx
jne    1950 <stencil+0x7d0>
cmpb   $0x0,0x24(%rsp)
mov    0x10(%rsp),%r15
je     1910 <stencil+0x790>
mov    $0x1,%r10d
mov    0xe0(%rsp),%r9d
jmp    1b32 <stencil+0x9b2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10d
add    0x48(%rsp),%r9d
cmp    %r14d,%r10d
je     1910 <stencil+0x790>
mov    %r10d,%r11d
imul   %r15d,%r11d
mov    $0x1,%edi
mov    %r9d,%r8d
jmp    1b5c <stencil+0x9dc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
add    %r15d,%r8d
cmp    %r14,%rdi
je     1b20 <stencil+0x9a0>
cmp    $0x4,%r13
setb   %al
movslq %r8d,%rsi
or     0x18(%rsp),%al
mov    $0x1,%eax
jne    1c31 <stencil+0xab1>
cmpq   $0x4,0xb0(%rsp)
jae    1b90 <stencil+0xa10>
xor    %eax,%eax
jmp    1be5 <stencil+0xa65>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%rax
lea    (%rax,%rsi,8),%rbp
mov    0xd8(%rsp),%rax
lea    (%rax,%rsi,8),%rbx
mov    0x58(%rsp),%rdx
xor    %eax,%eax
nop
movups -0x30(%rbx,%rax,8),%xmm0
movups -0x20(%rbx,%rax,8),%xmm1
movups %xmm0,-0x30(%rbp,%rax,8)
movups %xmm1,-0x20(%rbp,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd %xmm0,-0x10(%rbp,%rax,8)
movupd %xmm1,0x0(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1bb0 <stencil+0xa30>
testb  $0x1,0x40(%rsp)
je     1c21 <stencil+0xaa1>
lea    (%r11,%rdi,1),%ecx
imul   %r15d,%ecx
movslq %ecx,%rcx
or     $0x1,%rax
add    %rcx,%rax
mov    0x90(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
mov    0x8(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x30(%rsp),%rax
cmp    0x38(%rsp),%r13
je     1b50 <stencil+0x9d0>
mov    %r14d,%ebx
sub    %eax,%ebx
mov    %rax,%rbp
not    %rbp
add    %r14,%rbp
and    $0x3,%rbx
je     1c74 <stencil+0xaf4>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rdx
mov    0x90(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1c60 <stencil+0xae0>
cmp    $0x3,%rbp
jb     1b50 <stencil+0x9d0>
mov    %r14,%rbp
sub    %rax,%rbp
add    %rax,%rsi
mov    0x68(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rsi,8),%rdx
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  -0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  -0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  -0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1ca0 <stencil+0xb20>
jmp    1b50 <stencil+0x9d0>
test   %r15d,%r15d
mov    0x80(%rsp),%rbp
jle    220c <stencil+0x108c>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rbp,8),%rax
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x30(%rsp)
lea    -0x4(%rcx),%rsi
mov    %rsi,0x18(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    0xc8(%rsp),%rdi
mov    %rax,0x118(%rsp)
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%rbp,8),%rcx
cmp    %rdx,%rcx
seta   %r11b
and    %al,%r11b
mov    %esi,%ecx
and    $0x3,%ecx
mov    %rsi,0xe0(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rsi
mov    %rsi,0x50(%rsp)
mov    %ebp,%r8d
and    $0x3,%r8d
lea    0x70(%rdi),%rax
mov    %rax,0x70(%rsp)
mov    0x10(%rsp),%r15
mov    %r15d,%eax
imul   %r15d,%eax
mov    %eax,0x64(%rsp)
lea    0x70(%rdx),%rax
mov    %rax,0x58(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0x78(%rsp)
mov    %rcx,%r14
mov    %rcx,%rsi
shl    $0x5,%rsi
lea    0x18(%rdi),%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
jmp    1dbc <stencil+0xc3c>
nop
mov    0xe8(%rsp),%ecx
add    $0x1,%ecx
mov    0x48(%rsp),%rax
add    0x64(%rsp),%eax
cmp    %r15d,%ecx
je     1f8c <stencil+0xe0c>
mov    %ecx,0xe8(%rsp)
mov    %rax,0x48(%rsp)
mov    %eax,%r9d
xor    %r10d,%r10d
jmp    1ddc <stencil+0xc5c>
add    $0x1,%r10
add    %r15d,%r9d
cmp    %rbp,%r10
je     1da0 <stencil+0xc20>
cmp    $0x4,%r15d
setb   %al
movslq %r9d,%rbx
or     %r11b,%al
je     1e00 <stencil+0xc80>
xor    %edi,%edi
jmp    1ee0 <stencil+0xd60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpq   $0xc,0x18(%rsp)
jae    1e10 <stencil+0xc90>
xor    %edi,%edi
jmp    1e8c <stencil+0xd0c>
nop
mov    0x70(%rsp),%rax
lea    (%rax,%rbx,8),%rdx
mov    0x58(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x50(%rsp),%r15
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x70(%rax,%rdi,8),%xmm0
movups -0x60(%rax,%rdi,8),%xmm1
movups %xmm0,-0x70(%rdx,%rdi,8)
movups %xmm1,-0x60(%rdx,%rdi,8)
movups -0x50(%rax,%rdi,8),%xmm0
movups -0x40(%rax,%rdi,8),%xmm1
movups %xmm0,-0x50(%rdx,%rdi,8)
movups %xmm1,-0x40(%rdx,%rdi,8)
movups -0x30(%rax,%rdi,8),%xmm0
movups -0x20(%rax,%rdi,8),%xmm1
movups %xmm0,-0x30(%rdx,%rdi,8)
movups %xmm1,-0x20(%rdx,%rdi,8)
movupd -0x10(%rax,%rdi,8),%xmm0
movupd (%rax,%rdi,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,8)
movupd %xmm1,(%rdx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%r15
jne    1e30 <stencil+0xcb0>
test   %r14,%r14
mov    0x10(%rsp),%r15
je     1ecf <stencil+0xd4f>
add    %rbx,%rdi
mov    0x78(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
xor    %edx,%edx
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rax,%rdx,1)
movupd %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1eb0 <stencil+0xd30>
mov    0x30(%rsp),%rax
mov    %rax,%rdi
cmp    %rbp,%rax
je     1dd0 <stencil+0xc50>
mov    %rdi,%rax
not    %rax
add    %rbp,%rax
test   %r8,%r8
je     1f25 <stencil+0xda5>
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rbp
mov    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
jne    1f10 <stencil+0xd90>
cmp    $0x3,%rax
mov    0x80(%rsp),%rbp
jb     1dd0 <stencil+0xc50>
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
nopl   0x0(%rax)
movsd  -0x18(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rdi,8)
movsd  -0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rdi,8)
movsd  -0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1f50 <stencil+0xdd0>
jmp    1dd0 <stencil+0xc50>
test   %r15d,%r15d
jle    220c <stencil+0x108c>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rbp,8),%rax
cmp    0x8(%rsp),%rax
seta   %al
cmp    %rcx,0x118(%rsp)
seta   %r14b
and    %al,%r14b
mov    %ebp,%r10d
and    $0xfffffffc,%r10d
mov    0xe0(%rsp),%rax
mov    %eax,%edx
and    $0x3,%edx
and    %rax,0xc0(%rsp)
mov    %ebp,%r15d
and    $0x3,%r15d
lea    0x70(%rcx),%rax
mov    %rax,0x50(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x78(%rsp)
mov    %rdx,0x30(%rsp)
shl    $0x5,%rdx
lea    0x18(%rcx),%rax
mov    %rax,0x28(%rsp)
xor    %ecx,%ecx
xor    %esi,%esi
jmp    2028 <stencil+0xea8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x48(%rsp),%esi
add    $0x1,%esi
mov    0x70(%rsp),%rcx
add    0x64(%rsp),%ecx
cmp    %eax,%esi
je     220c <stencil+0x108c>
mov    %esi,0x48(%rsp)
mov    %rcx,0x70(%rsp)
mov    %ecx,%r8d
xor    %r9d,%r9d
mov    0x10(%rsp),%rax
jmp    2051 <stencil+0xed1>
xchg   %ax,%ax
add    $0x1,%r9
mov    0x10(%rsp),%rax
add    %eax,%r8d
cmp    %rbp,%r9
je     2010 <stencil+0xe90>
cmp    $0x4,%eax
setb   %al
movslq %r8d,%rbx
or     %r14b,%al
je     2070 <stencil+0xef0>
xor    %esi,%esi
jmp    215b <stencil+0xfdb>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0xc,0x18(%rsp)
jae    2080 <stencil+0xf00>
xor    %esi,%esi
jmp    2104 <stencil+0xf84>
nop
mov    0x58(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x50(%rsp),%rcx
lea    (%rcx,%rbx,8),%r11
mov    0xc0(%rsp),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x70(%r11,%rsi,8),%xmm0
movups -0x60(%r11,%rsi,8),%xmm1
movups %xmm0,-0x70(%rax,%rsi,8)
movups %xmm1,-0x60(%rax,%rsi,8)
movups -0x50(%r11,%rsi,8),%xmm0
movups -0x40(%r11,%rsi,8),%xmm1
movups %xmm0,-0x50(%rax,%rsi,8)
movups %xmm1,-0x40(%rax,%rsi,8)
movups -0x30(%r11,%rsi,8),%xmm0
movups -0x20(%r11,%rsi,8),%xmm1
movups %xmm0,-0x30(%rax,%rsi,8)
movups %xmm1,-0x20(%rax,%rsi,8)
movupd -0x10(%r11,%rsi,8),%xmm0
movupd (%r11,%rsi,8),%xmm1
movupd %xmm0,-0x10(%rax,%rsi,8)
movupd %xmm1,(%rax,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rcx
jne    20a0 <stencil+0xf20>
cmpq   $0x0,0x30(%rsp)
je     214f <stencil+0xfcf>
add    %rbx,%rsi
mov    0xd0(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rax,%rsi,1)
movupd %xmm1,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    2130 <stencil+0xfb0>
mov    %r10,%rsi
cmp    %rbp,%r10
je     2040 <stencil+0xec0>
mov    %rsi,%rax
not    %rax
add    %rbp,%rax
test   %r15,%r15
je     21a5 <stencil+0x1025>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
mov    0xa0(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbp
mov    %r15,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    2190 <stencil+0x1010>
cmp    $0x3,%rax
mov    0x80(%rsp),%rbp
jb     2040 <stencil+0xec0>
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
nopl   0x0(%rax)
movsd  -0x18(%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rsi,8)
movsd  -0x10(%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rsi,8)
movsd  -0x8(%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    21d0 <stencil+0x1050>
jmp    2040 <stencil+0xec0>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  0xdf3(%rip),%xmm2
movsd  %xmm0,0xc0(%rsp)
mov    0x120(%rsp),%rax
cmp    %rax,0x130(%rsp)
setb   %al
mov    0x128(%rsp),%rcx
cmp    0x138(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0x18(%rsp)
mov    0x38(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x30(%rsp)
mov    0xb8(%rsp),%rax
and    0x40(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x10(%rsp),%r15
mov    %r15d,%eax
imul   %eax,%eax
mov    %rax,0x50(%rsp)
add    %eax,%eax
mov    %eax,0x48(%rsp)
mov    0x9c(%rsp),%eax
imul   %r15d,%eax
mov    %eax,0x9c(%rsp)
jmp    22b1 <stencil+0x1131>
nop
mov    0x70(%rsp),%rbx
add    $0x1,%ebx
cmp    $0xa,%ebx
je     268c <stencil+0x150c>
mov    %rbx,0x70(%rsp)
cmpb   $0x0,0x24(%rsp)
je     22a0 <stencil+0x1120>
mov    $0x1,%ecx
xor    %esi,%esi
mov    0x48(%rsp),%edx
mov    0x50(%rsp),%rax
mov    %eax,%edi
nop
mov    %rcx,0x58(%rsp)
mov    %edi,0x78(%rsp)
movslq %edi,%rax
mov    0x100(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    %edx,0x80(%rsp)
movslq %edx,%rdx
mov    0x108(%rsp),%r11
lea    (%r11,%rdx,8),%rcx
mov    0xd0(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%r8
mov    %esi,0x28(%rsp)
movslq %esi,%rsi
lea    (%r11,%rsi,8),%r9
lea    0x0(,%rsi,8),%r10
add    %rbp,%r10
mov    0x110(%rsp),%r14
add    %r14,%rdx
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
add    %r14,%rsi
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
lea    (%r11,%rax,8),%r11
lea    0x0(,%rax,8),%r15
add    %rbp,%r15
add    %r14,%rax
mov    0xf8(%rsp),%r14
lea    0x0(,%rax,8),%rdx
add    %rbp,%rdx
addq   $0x1,0x58(%rsp)
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rax,8),%xmm0
addsd  -0x8(%r11,%rax,8),%xmm0
addsd  -0x8(%rsi,%rax,8),%xmm0
addsd  -0x8(%rbx,%rax,8),%xmm0
addsd  -0x8(%r10,%rax,8),%xmm0
addsd  -0x8(%r9,%rax,8),%xmm0
addsd  -0x8(%r8,%rax,8),%xmm0
addsd  -0x8(%rcx,%rax,8),%xmm0
addsd  -0x10(%r15,%rax,8),%xmm0
addsd  -0x10(%r11,%rax,8),%xmm0
addsd  -0x10(%rsi,%rax,8),%xmm0
addsd  -0x10(%rbx,%rax,8),%xmm0
addsd  -0x10(%r10,%rax,8),%xmm0
addsd  -0x10(%r9,%rax,8),%xmm0
addsd  -0x10(%r8,%rax,8),%xmm0
addsd  -0x10(%rcx,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
addsd  (%r11,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
addsd  (%r10,%rax,8),%xmm0
addsd  (%r9,%rax,8),%xmm0
addsd  (%r8,%rax,8),%xmm0
addsd  (%rcx,%rax,8),%xmm0
addsd  -0x10(%rdx,%rax,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    2390 <stencil+0x1210>
add    %r12,%rdi
add    %r12,%rcx
add    %r12,%r8
add    %r12,%r9
add    %r12,%r10
add    %r12,%rbx
add    %r12,%rsi
add    %r12,%r11
add    %r12,%r15
add    %r12,%rdx
cmp    %r14,%rbp
jne    2380 <stencil+0x1200>
mov    0x50(%rsp),%rax
mov    0x78(%rsp),%edi
add    %eax,%edi
mov    0x80(%rsp),%edx
add    %eax,%edx
mov    0x28(%rsp),%esi
add    %eax,%esi
mov    0x58(%rsp),%rcx
cmp    %r14,%rcx
jne    22d0 <stencil+0x1150>
cmpb   $0x0,0x24(%rsp)
mov    0x10(%rsp),%r15
je     22a0 <stencil+0x1120>
mov    $0x1,%r8d
mov    0x9c(%rsp),%r10d
jmp    24d2 <stencil+0x1352>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8d
add    0x50(%rsp),%r10d
cmp    %r14d,%r8d
je     22a0 <stencil+0x1120>
mov    %r8d,%r9d
imul   %r15d,%r9d
mov    $0x1,%ebp
mov    %r10d,%edi
jmp    24fc <stencil+0x137c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
add    %r15d,%edi
cmp    %r14,%rbp
je     24c0 <stencil+0x1340>
cmp    $0x4,%r13
setb   %al
movslq %edi,%r11
or     0x18(%rsp),%al
mov    $0x1,%eax
jne    25e0 <stencil+0x1460>
cmpq   $0x4,0xb0(%rsp)
jae    2530 <stencil+0x13b0>
xor    %eax,%eax
jmp    2594 <stencil+0x1414>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%rax
lea    (%rax,%r11,8),%rsi
mov    0xd8(%rsp),%rax
lea    (%rax,%r11,8),%rbx
mov    0xb8(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rbx,%rax,8),%xmm0
movups -0x20(%rbx,%rax,8),%xmm1
movups %xmm0,-0x30(%rsi,%rax,8)
movups %xmm1,-0x20(%rsi,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rax,8)
movupd %xmm1,(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    2560 <stencil+0x13e0>
testb  $0x1,0x40(%rsp)
je     25d0 <stencil+0x1450>
lea    (%r9,%rbp,1),%ecx
imul   %r15d,%ecx
movslq %ecx,%rcx
or     $0x1,%rax
add    %rcx,%rax
mov    0x90(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
mov    0x8(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x30(%rsp),%rax
cmp    0x38(%rsp),%r13
je     24f0 <stencil+0x1370>
mov    %r14d,%esi
sub    %eax,%esi
mov    %rax,%rbx
not    %rbx
add    %r14,%rbx
and    $0x3,%rsi
je     2624 <stencil+0x14a4>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r11,8),%rdx
mov    0x90(%rsp),%rcx
lea    (%rcx,%r11,8),%rcx
nopl   0x0(%rax)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    2610 <stencil+0x1490>
cmp    $0x3,%rbx
jb     24f0 <stencil+0x1370>
mov    %r14,%rsi
sub    %rax,%rsi
add    %rax,%r11
mov    0x68(%rsp),%rax
lea    (%rax,%r11,8),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%r11,8),%rcx
xor    %edx,%edx
xchg   %ax,%ax
movsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rdx,8)
movsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rdx,8)
movsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    2650 <stencil+0x14d0>
jmp    24f0 <stencil+0x1370>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x38(%rsp)
mov    0x140(%rsp),%rbx
mov    %rbx,%rdi
mov    0x8(%rsp),%rbp
mov    %rbp,%rsi
mov    0xf4(%rsp),%edx
call   1060 <memcpy@plt>
mov    0xc8(%rsp),%r14
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
call   1090 <max_diff@plt>
movsd  %xmm0,0x40(%rsp)
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
movsd  0x912(%rip),%xmm0
ucomisd 0x40(%rsp),%xmm0
jbe    2727 <stencil+0x15a7>
movsd  0x38(%rsp),%xmm0
subsd  0xc0(%rsp),%xmm0
jmp    272f <stencil+0x15af>
movsd  0x8e9(%rip),%xmm0
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@datasize = external global i32
@RAND_MAX = global i64 0
define double @stencil() {
%1 = alloca double
%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 double
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = load i32, i32* @datasize
%18 = zext i32 %17 to i64
%19 = udiv i64 %18, 8
%20 = udiv i64 %19, 2
%21 = trunc i64 %20 to i32
%22 = call i32 @cbrt(i32 %21)
store i32 %22, i32* %2
%23 = load i32, i32* %2
%24 = sub nsw i32 %23, 2
store i32 %24, i32* %7
store double 0x3FA3B13B13B13B14, double* %8
%25 = load i32, i32* %2
%26 = sext i32 %25 to i64
%27 = mul i64 8, %26
%28 = load i32, i32* %2
%29 = sext i32 %28 to i64
%30 = mul i64 %27, %29
%31 = load i32, i32* %2
%32 = sext i32 %31 to i64
%33 = mul i64 %30, %32
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to double*
store double* %36, double** %12
%37 = load i32, i32* %2
%38 = sext i32 %37 to i64
%39 = mul i64 8, %38
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = mul i64 %39, %41
%43 = load i32, i32* %2
%44 = sext i32 %43 to i64
%45 = mul i64 %42, %44
%46 = trunc i64 %45 to i32
%47 = call i64 @malloc(i32 %46)
%48 = inttoptr i64 %47 to double*
store double* %48, double** %13
%49 = load i32, i32* %2
%50 = sext i32 %49 to i64
%51 = mul i64 8, %50
%52 = load i32, i32* %2
%53 = sext i32 %52 to i64
%54 = mul i64 %51, %53
%55 = load i32, i32* %2
%56 = sext i32 %55 to i64
%57 = mul i64 %54, %56
%58 = trunc i64 %57 to i32
%59 = call i64 @malloc(i32 %58)
%60 = inttoptr i64 %59 to double*
store double* %60, double** %14
%61 = load i32, i32* %2
%62 = sext i32 %61 to i64
%63 = mul i64 8, %62
%64 = load i32, i32* %2
%65 = sext i32 %64 to i64
%66 = mul i64 %63, %65
%67 = load i32, i32* %2
%68 = sext i32 %67 to i64
%69 = mul i64 %66, %68
%70 = trunc i64 %69 to i32
%71 = call i64 @malloc(i32 %70)
%72 = inttoptr i64 %71 to double*
store double* %72, double** %15
%73 = load i32, i32* %2
%74 = sext i32 %73 to i64
%75 = mul i64 8, %74
%76 = load i32, i32* %2
%77 = sext i32 %76 to i64
%78 = mul i64 %75, %77
%79 = load i32, i32* %2
%80 = sext i32 %79 to i64
%81 = mul i64 %78, %80
%82 = trunc i64 %81 to i32
%83 = call i64 @malloc(i32 %82)
%84 = inttoptr i64 %83 to double*
store double* %84, double** %16
%85 = load double*, double** %12
%86 = icmp eq double* %85, null
br i1 %86, label %99, label %87
87: ; preds = %0
%88 = load double*, double** %13
%89 = icmp eq double* %88, null
br i1 %89, label %99, label %90
90: ; preds = %87
%91 = load double*, double** %14
%92 = icmp eq double* %91, null
br i1 %92, label %99, label %93
93: ; preds = %90
%94 = load double*, double** %15
%95 = icmp eq double* %94, null
br i1 %95, label %99, label %96
96: ; preds = %93
%97 = load double*, double** %16
%98 = icmp eq double* %97, null
br i1 %98, label %99, label %100
99: ; preds = %96, %93, %90, %87, %0
store double -1.000000e+04, double* %1
br label %1564
100: ; preds = %96
store i32 0, i32* %3
br label %101
101: ; preds = %138, %100
%102 = load i32, i32* %3
%103 = load i32, i32* %2
%104 = icmp slt i32 %102, %103
br i1 %104, label %105, label %141
105: ; preds = %101
store i32 0, i32* %4
br label %106
106: ; preds = %134, %105
%107 = load i32, i32* %4
%108 = load i32, i32* %2
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %137
110: ; preds = %106
store i32 0, i32* %5
br label %111
111: ; preds = %130, %110
%112 = load i32, i32* %5
%113 = load i32, i32* %2
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %133
115: ; preds = %111
%116 = load double*, double** %12
%117 = load i32, i32* %3
%118 = load i32, i32* %2
%119 = mul nsw i32 %117, %118
%120 = load i32, i32* %2
%121 = mul nsw i32 %119, %120
%122 = load i32, i32* %4
%123 = load i32, i32* %2
%124 = mul nsw i32 %122, %123
%125 = add nsw i32 %121, %124
%126 = load i32, i32* %5
%127 = add nsw i32 %125, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %116, i64 %128
store double 0.000000e+00, double* %129
br label %130
130: ; preds = %115
%131 = load i32, i32* %5
%132 = add nsw i32 %131, 1
store i32 %132, i32* %5
br label %111
133: ; preds = %111
br label %134
134: ; preds = %133
%135 = load i32, i32* %4
%136 = add nsw i32 %135, 1
store i32 %136, i32* %4
br label %106
137: ; preds = %106
br label %138
138: ; preds = %137
%139 = load i32, i32* %3
%140 = add nsw i32 %139, 1
store i32 %140, i32* %3
br label %101
141: ; preds = %101
store i32 1, i32* %3
br label %142
142: ; preds = %188, %141
%143 = load i32, i32* %3
%144 = load i32, i32* %7
%145 = add nsw i32 %144, 1
%146 = icmp slt i32 %143, %145
br i1 %146, label %147, label %191
147: ; preds = %142
store i32 1, i32* %4
br label %148
148: ; preds = %184, %147
%149 = load i32, i32* %4
%150 = load i32, i32* %7
%151 = add nsw i32 %150, 1
%152 = icmp slt i32 %149, %151
br i1 %152, label %153, label %187
153: ; preds = %148
store i32 1, i32* %5
br label %154
154: ; preds = %180, %153
%155 = load i32, i32* %5
%156 = load i32, i32* %7
%157 = add nsw i32 %156, 1
%158 = icmp slt i32 %155, %157
br i1 %158, label %159, label %183
159: ; preds = %154
%160 = call i64 (...) @rand()
%161 = sitofp i64 %160 to double
%162 = load i64, i64* @RAND_MAX
%163 = sitofp i64 %162 to double
%164 = fadd double 1.000000e+00, %163
%165 = fdiv double %161, %164
%166 = load double*, double** %12
%167 = load i32, i32* %3
%168 = load i32, i32* %2
%169 = mul nsw i32 %167, %168
%170 = load i32, i32* %2
%171 = mul nsw i32 %169, %170
%172 = load i32, i32* %4
%173 = load i32, i32* %2
%174 = mul nsw i32 %172, %173
%175 = add nsw i32 %171, %174
%176 = load i32, i32* %5
%177 = add nsw i32 %175, %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %166, i64 %178
store double %165, double* %179
br label %180
180: ; preds = %159
%181 = load i32, i32* %5
%182 = add nsw i32 %181, 1
store i32 %182, i32* %5
br label %154
183: ; preds = %154
br label %184
184: ; preds = %183
%185 = load i32, i32* %4
%186 = add nsw i32 %185, 1
store i32 %186, i32* %4
br label %148
187: ; preds = %148
br label %188
188: ; preds = %187
%189 = load i32, i32* %3
%190 = add nsw i32 %189, 1
store i32 %190, i32* %3
br label %142
191: ; preds = %142
store i32 0, i32* %3
br label %192
192: ; preds = %244, %191
%193 = load i32, i32* %3
%194 = load i32, i32* %2
%195 = icmp slt i32 %193, %194
br i1 %195, label %196, label %247
196: ; preds = %192
store i32 0, i32* %4
br label %197
197: ; preds = %240, %196
%198 = load i32, i32* %4
%199 = load i32, i32* %2
%200 = icmp slt i32 %198, %199
br i1 %200, label %201, label %243
201: ; preds = %197
store i32 0, i32* %5
br label %202
202: ; preds = %236, %201
%203 = load i32, i32* %5
%204 = load i32, i32* %2
%205 = icmp slt i32 %203, %204
br i1 %205, label %206, label %239
206: ; preds = %202
%207 = load double*, double** %12
%208 = load i32, i32* %3
%209 = load i32, i32* %2
%210 = mul nsw i32 %208, %209
%211 = load i32, i32* %2
%212 = mul nsw i32 %210, %211
%213 = load i32, i32* %4
%214 = load i32, i32* %2
%215 = mul nsw i32 %213, %214
%216 = add nsw i32 %212, %215
%217 = load i32, i32* %5
%218 = add nsw i32 %216, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %207, i64 %219
%221 = load double, double* %220
%222 = load double*, double** %16
%223 = load i32, i32* %3
%224 = load i32, i32* %2
%225 = mul nsw i32 %223, %224
%226 = load i32, i32* %2
%227 = mul nsw i32 %225, %226
%228 = load i32, i32* %4
%229 = load i32, i32* %2
%230 = mul nsw i32 %228, %229
%231 = add nsw i32 %227, %230
%232 = load i32, i32* %5
%233 = add nsw i32 %231, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double, double* %222, i64 %234
store double %221, double* %235
br label %236
236: ; preds = %206
%237 = load i32, i32* %5
%238 = add nsw i32 %237, 1
store i32 %238, i32* %5
br label %202
239: ; preds = %202
br label %240
240: ; preds = %239
%241 = load i32, i32* %4
%242 = add nsw i32 %241, 1
store i32 %242, i32* %4
br label %197
243: ; preds = %197
br label %244
244: ; preds = %243
%245 = load i32, i32* %3
%246 = add nsw i32 %245, 1
store i32 %246, i32* %3
br label %192
247: ; preds = %192
store i32 0, i32* %6
br label %248
248: ; preds = %826, %247
%249 = load i32, i32* %6
%250 = icmp slt i32 %249, 10
br i1 %250, label %251, label %829
251: ; preds = %248
store i32 1, i32* %3
br label %252
252: ; preds = %763, %251
%253 = load i32, i32* %3
%254 = load i32, i32* %7
%255 = add nsw i32 %254, 1
%256 = icmp slt i32 %253, %255
br i1 %256, label %257, label %766
257: ; preds = %252
store i32 1, i32* %4
br label %258
258: ; preds = %759, %257
%259 = load i32, i32* %4
%260 = load i32, i32* %7
%261 = add nsw i32 %260, 1
%262 = icmp slt i32 %259, %261
br i1 %262, label %263, label %762
263: ; preds = %258
store i32 1, i32* %5
br label %264
264: ; preds = %755, %263
%265 = load i32, i32* %5
%266 = load i32, i32* %7
%267 = add nsw i32 %266, 1
%268 = icmp slt i32 %265, %267
br i1 %268, label %269, label %758
269: ; preds = %264
%270 = load double*, double** %12
%271 = load i32, i32* %3
%272 = load i32, i32* %2
%273 = mul nsw i32 %271, %272
%274 = load i32, i32* %2
%275 = mul nsw i32 %273, %274
%276 = load i32, i32* %4
%277 = sub nsw i32 %276, 1
%278 = load i32, i32* %2
%279 = mul nsw i32 %277, %278
%280 = add nsw i32 %275, %279
%281 = load i32, i32* %5
%282 = add nsw i32 %280, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %270, i64 %283
%285 = load double, double* %284
%286 = load double*, double** %12
%287 = load i32, i32* %3
%288 = load i32, i32* %2
%289 = mul nsw i32 %287, %288
%290 = load i32, i32* %2
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %4
%293 = add nsw i32 %292, 1
%294 = load i32, i32* %2
%295 = mul nsw i32 %293, %294
%296 = add nsw i32 %291, %295
%297 = load i32, i32* %5
%298 = add nsw i32 %296, %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %286, i64 %299
%301 = load double, double* %300
%302 = fadd double %285, %301
%303 = load double*, double** %12
%304 = load i32, i32* %3
%305 = sub nsw i32 %304, 1
%306 = load i32, i32* %2
%307 = mul nsw i32 %305, %306
%308 = load i32, i32* %2
%309 = mul nsw i32 %307, %308
%310 = load i32, i32* %4
%311 = load i32, i32* %2
%312 = mul nsw i32 %310, %311
%313 = add nsw i32 %309, %312
%314 = load i32, i32* %5
%315 = add nsw i32 %313, %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %303, i64 %316
%318 = load double, double* %317
%319 = fadd double %302, %318
%320 = load double*, double** %12
%321 = load i32, i32* %3
%322 = add nsw i32 %321, 1
%323 = load i32, i32* %2
%324 = mul nsw i32 %322, %323
%325 = load i32, i32* %2
%326 = mul nsw i32 %324, %325
%327 = load i32, i32* %4
%328 = load i32, i32* %2
%329 = mul nsw i32 %327, %328
%330 = add nsw i32 %326, %329
%331 = load i32, i32* %5
%332 = add nsw i32 %330, %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %320, i64 %333
%335 = load double, double* %334
%336 = fadd double %319, %335
%337 = load double*, double** %12
%338 = load i32, i32* %3
%339 = sub nsw i32 %338, 1
%340 = load i32, i32* %2
%341 = mul nsw i32 %339, %340
%342 = load i32, i32* %2
%343 = mul nsw i32 %341, %342
%344 = load i32, i32* %4
%345 = sub nsw i32 %344, 1
%346 = load i32, i32* %2
%347 = mul nsw i32 %345, %346
%348 = add nsw i32 %343, %347
%349 = load i32, i32* %5
%350 = add nsw i32 %348, %349
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %337, i64 %351
%353 = load double, double* %352
%354 = fadd double %336, %353
%355 = load double*, double** %12
%356 = load i32, i32* %3
%357 = sub nsw i32 %356, 1
%358 = load i32, i32* %2
%359 = mul nsw i32 %357, %358
%360 = load i32, i32* %2
%361 = mul nsw i32 %359, %360
%362 = load i32, i32* %4
%363 = add nsw i32 %362, 1
%364 = load i32, i32* %2
%365 = mul nsw i32 %363, %364
%366 = add nsw i32 %361, %365
%367 = load i32, i32* %5
%368 = add nsw i32 %366, %367
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %355, i64 %369
%371 = load double, double* %370
%372 = fadd double %354, %371
%373 = load double*, double** %12
%374 = load i32, i32* %3
%375 = add nsw i32 %374, 1
%376 = load i32, i32* %2
%377 = mul nsw i32 %375, %376
%378 = load i32, i32* %2
%379 = mul nsw i32 %377, %378
%380 = load i32, i32* %4
%381 = sub nsw i32 %380, 1
%382 = load i32, i32* %2
%383 = mul nsw i32 %381, %382
%384 = add nsw i32 %379, %383
%385 = load i32, i32* %5
%386 = add nsw i32 %384, %385
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %373, i64 %387
%389 = load double, double* %388
%390 = fadd double %372, %389
%391 = load double*, double** %12
%392 = load i32, i32* %3
%393 = add nsw i32 %392, 1
%394 = load i32, i32* %2
%395 = mul nsw i32 %393, %394
%396 = load i32, i32* %2
%397 = mul nsw i32 %395, %396
%398 = load i32, i32* %4
%399 = add nsw i32 %398, 1
%400 = load i32, i32* %2
%401 = mul nsw i32 %399, %400
%402 = add nsw i32 %397, %401
%403 = load i32, i32* %5
%404 = add nsw i32 %402, %403
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %391, i64 %405
%407 = load double, double* %406
%408 = fadd double %390, %407
%409 = load double*, double** %12
%410 = load i32, i32* %3
%411 = load i32, i32* %2
%412 = mul nsw i32 %410, %411
%413 = load i32, i32* %2
%414 = mul nsw i32 %412, %413
%415 = load i32, i32* %4
%416 = sub nsw i32 %415, 1
%417 = load i32, i32* %2
%418 = mul nsw i32 %416, %417
%419 = add nsw i32 %414, %418
%420 = load i32, i32* %5
%421 = sub nsw i32 %420, 1
%422 = add nsw i32 %419, %421
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %409, i64 %423
%425 = load double, double* %424
%426 = fadd double %408, %425
%427 = load double*, double** %12
%428 = load i32, i32* %3
%429 = load i32, i32* %2
%430 = mul nsw i32 %428, %429
%431 = load i32, i32* %2
%432 = mul nsw i32 %430, %431
%433 = load i32, i32* %4
%434 = add nsw i32 %433, 1
%435 = load i32, i32* %2
%436 = mul nsw i32 %434, %435
%437 = add nsw i32 %432, %436
%438 = load i32, i32* %5
%439 = sub nsw i32 %438, 1
%440 = add nsw i32 %437, %439
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds double, double* %427, i64 %441
%443 = load double, double* %442
%444 = fadd double %426, %443
%445 = load double*, double** %12
%446 = load i32, i32* %3
%447 = sub nsw i32 %446, 1
%448 = load i32, i32* %2
%449 = mul nsw i32 %447, %448
%450 = load i32, i32* %2
%451 = mul nsw i32 %449, %450
%452 = load i32, i32* %4
%453 = load i32, i32* %2
%454 = mul nsw i32 %452, %453
%455 = add nsw i32 %451, %454
%456 = load i32, i32* %5
%457 = sub nsw i32 %456, 1
%458 = add nsw i32 %455, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %445, i64 %459
%461 = load double, double* %460
%462 = fadd double %444, %461
%463 = load double*, double** %12
%464 = load i32, i32* %3
%465 = add nsw i32 %464, 1
%466 = load i32, i32* %2
%467 = mul nsw i32 %465, %466
%468 = load i32, i32* %2
%469 = mul nsw i32 %467, %468
%470 = load i32, i32* %4
%471 = load i32, i32* %2
%472 = mul nsw i32 %470, %471
%473 = add nsw i32 %469, %472
%474 = load i32, i32* %5
%475 = sub nsw i32 %474, 1
%476 = add nsw i32 %473, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %463, i64 %477
%479 = load double, double* %478
%480 = fadd double %462, %479
%481 = load double*, double** %12
%482 = load i32, i32* %3
%483 = sub nsw i32 %482, 1
%484 = load i32, i32* %2
%485 = mul nsw i32 %483, %484
%486 = load i32, i32* %2
%487 = mul nsw i32 %485, %486
%488 = load i32, i32* %4
%489 = sub nsw i32 %488, 1
%490 = load i32, i32* %2
%491 = mul nsw i32 %489, %490
%492 = add nsw i32 %487, %491
%493 = load i32, i32* %5
%494 = sub nsw i32 %493, 1
%495 = add nsw i32 %492, %494
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %481, i64 %496
%498 = load double, double* %497
%499 = fadd double %480, %498
%500 = load double*, double** %12
%501 = load i32, i32* %3
%502 = sub nsw i32 %501, 1
%503 = load i32, i32* %2
%504 = mul nsw i32 %502, %503
%505 = load i32, i32* %2
%506 = mul nsw i32 %504, %505
%507 = load i32, i32* %4
%508 = add nsw i32 %507, 1
%509 = load i32, i32* %2
%510 = mul nsw i32 %508, %509
%511 = add nsw i32 %506, %510
%512 = load i32, i32* %5
%513 = sub nsw i32 %512, 1
%514 = add nsw i32 %511, %513
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %500, i64 %515
%517 = load double, double* %516
%518 = fadd double %499, %517
%519 = load double*, double** %12
%520 = load i32, i32* %3
%521 = add nsw i32 %520, 1
%522 = load i32, i32* %2
%523 = mul nsw i32 %521, %522
%524 = load i32, i32* %2
%525 = mul nsw i32 %523, %524
%526 = load i32, i32* %4
%527 = sub nsw i32 %526, 1
%528 = load i32, i32* %2
%529 = mul nsw i32 %527, %528
%530 = add nsw i32 %525, %529
%531 = load i32, i32* %5
%532 = sub nsw i32 %531, 1
%533 = add nsw i32 %530, %532
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %519, i64 %534
%536 = load double, double* %535
%537 = fadd double %518, %536
%538 = load double*, double** %12
%539 = load i32, i32* %3
%540 = add nsw i32 %539, 1
%541 = load i32, i32* %2
%542 = mul nsw i32 %540, %541
%543 = load i32, i32* %2
%544 = mul nsw i32 %542, %543
%545 = load i32, i32* %4
%546 = add nsw i32 %545, 1
%547 = load i32, i32* %2
%548 = mul nsw i32 %546, %547
%549 = add nsw i32 %544, %548
%550 = load i32, i32* %5
%551 = sub nsw i32 %550, 1
%552 = add nsw i32 %549, %551
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %538, i64 %553
%555 = load double, double* %554
%556 = fadd double %537, %555
%557 = load double*, double** %12
%558 = load i32, i32* %3
%559 = load i32, i32* %2
%560 = mul nsw i32 %558, %559
%561 = load i32, i32* %2
%562 = mul nsw i32 %560, %561
%563 = load i32, i32* %4
%564 = sub nsw i32 %563, 1
%565 = load i32, i32* %2
%566 = mul nsw i32 %564, %565
%567 = add nsw i32 %562, %566
%568 = load i32, i32* %5
%569 = add nsw i32 %568, 1
%570 = add nsw i32 %567, %569
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double, double* %557, i64 %571
%573 = load double, double* %572
%574 = fadd double %556, %573
%575 = load double*, double** %12
%576 = load i32, i32* %3
%577 = load i32, i32* %2
%578 = mul nsw i32 %576, %577
%579 = load i32, i32* %2
%580 = mul nsw i32 %578, %579
%581 = load i32, i32* %4
%582 = add nsw i32 %581, 1
%583 = load i32, i32* %2
%584 = mul nsw i32 %582, %583
%585 = add nsw i32 %580, %584
%586 = load i32, i32* %5
%587 = add nsw i32 %586, 1
%588 = add nsw i32 %585, %587
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %575, i64 %589
%591 = load double, double* %590
%592 = fadd double %574, %591
%593 = load double*, double** %12
%594 = load i32, i32* %3
%595 = sub nsw i32 %594, 1
%596 = load i32, i32* %2
%597 = mul nsw i32 %595, %596
%598 = load i32, i32* %2
%599 = mul nsw i32 %597, %598
%600 = load i32, i32* %4
%601 = load i32, i32* %2
%602 = mul nsw i32 %600, %601
%603 = add nsw i32 %599, %602
%604 = load i32, i32* %5
%605 = add nsw i32 %604, 1
%606 = add nsw i32 %603, %605
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %593, i64 %607
%609 = load double, double* %608
%610 = fadd double %592, %609
%611 = load double*, double** %12
%612 = load i32, i32* %3
%613 = add nsw i32 %612, 1
%614 = load i32, i32* %2
%615 = mul nsw i32 %613, %614
%616 = load i32, i32* %2
%617 = mul nsw i32 %615, %616
%618 = load i32, i32* %4
%619 = load i32, i32* %2
%620 = mul nsw i32 %618, %619
%621 = add nsw i32 %617, %620
%622 = load i32, i32* %5
%623 = add nsw i32 %622, 1
%624 = add nsw i32 %621, %623
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %611, i64 %625
%627 = load double, double* %626
%628 = fadd double %610, %627
%629 = load double*, double** %12
%630 = load i32, i32* %3
%631 = sub nsw i32 %630, 1
%632 = load i32, i32* %2
%633 = mul nsw i32 %631, %632
%634 = load i32, i32* %2
%635 = mul nsw i32 %633, %634
%636 = load i32, i32* %4
%637 = sub nsw i32 %636, 1
%638 = load i32, i32* %2
%639 = mul nsw i32 %637, %638
%640 = add nsw i32 %635, %639
%641 = load i32, i32* %5
%642 = add nsw i32 %641, 1
%643 = add nsw i32 %640, %642
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double, double* %629, i64 %644
%646 = load double, double* %645
%647 = fadd double %628, %646
%648 = load double*, double** %12
%649 = load i32, i32* %3
%650 = sub nsw i32 %649, 1
%651 = load i32, i32* %2
%652 = mul nsw i32 %650, %651
%653 = load i32, i32* %2
%654 = mul nsw i32 %652, %653
%655 = load i32, i32* %4
%656 = add nsw i32 %655, 1
%657 = load i32, i32* %2
%658 = mul nsw i32 %656, %657
%659 = add nsw i32 %654, %658
%660 = load i32, i32* %5
%661 = add nsw i32 %660, 1
%662 = add nsw i32 %659, %661
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds double, double* %648, i64 %663
%665 = load double, double* %664
%666 = fadd double %647, %665
%667 = load double*, double** %12
%668 = load i32, i32* %3
%669 = add nsw i32 %668, 1
%670 = load i32, i32* %2
%671 = mul nsw i32 %669, %670
%672 = load i32, i32* %2
%673 = mul nsw i32 %671, %672
%674 = load i32, i32* %4
%675 = sub nsw i32 %674, 1
%676 = load i32, i32* %2
%677 = mul nsw i32 %675, %676
%678 = add nsw i32 %673, %677
%679 = load i32, i32* %5
%680 = add nsw i32 %679, 1
%681 = add nsw i32 %678, %680
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %667, i64 %682
%684 = load double, double* %683
%685 = fadd double %666, %684
%686 = load double*, double** %12
%687 = load i32, i32* %3
%688 = add nsw i32 %687, 1
%689 = load i32, i32* %2
%690 = mul nsw i32 %688, %689
%691 = load i32, i32* %2
%692 = mul nsw i32 %690, %691
%693 = load i32, i32* %4
%694 = add nsw i32 %693, 1
%695 = load i32, i32* %2
%696 = mul nsw i32 %694, %695
%697 = add nsw i32 %692, %696
%698 = load i32, i32* %5
%699 = add nsw i32 %698, 1
%700 = add nsw i32 %697, %699
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %686, i64 %701
%703 = load double, double* %702
%704 = fadd double %685, %703
%705 = load double*, double** %12
%706 = load i32, i32* %3
%707 = load i32, i32* %2
%708 = mul nsw i32 %706, %707
%709 = load i32, i32* %2
%710 = mul nsw i32 %708, %709
%711 = load i32, i32* %4
%712 = load i32, i32* %2
%713 = mul nsw i32 %711, %712
%714 = add nsw i32 %710, %713
%715 = load i32, i32* %5
%716 = sub nsw i32 %715, 1
%717 = add nsw i32 %714, %716
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds double, double* %705, i64 %718
%720 = load double, double* %719
%721 = fadd double %704, %720
%722 = load double*, double** %12
%723 = load i32, i32* %3
%724 = load i32, i32* %2
%725 = mul nsw i32 %723, %724
%726 = load i32, i32* %2
%727 = mul nsw i32 %725, %726
%728 = load i32, i32* %4
%729 = load i32, i32* %2
%730 = mul nsw i32 %728, %729
%731 = add nsw i32 %727, %730
%732 = load i32, i32* %5
%733 = add nsw i32 %732, 1
%734 = add nsw i32 %731, %733
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %722, i64 %735
%737 = load double, double* %736
%738 = fadd double %721, %737
%739 = load double, double* %8
%740 = fmul double %738, %739
%741 = load double*, double** %14
%742 = load i32, i32* %3
%743 = load i32, i32* %2
%744 = mul nsw i32 %742, %743
%745 = load i32, i32* %2
%746 = mul nsw i32 %744, %745
%747 = load i32, i32* %4
%748 = load i32, i32* %2
%749 = mul nsw i32 %747, %748
%750 = add nsw i32 %746, %749
%751 = load i32, i32* %5
%752 = add nsw i32 %750, %751
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds double, double* %741, i64 %753
store double %740, double* %754
br label %755
755: ; preds = %269
%756 = load i32, i32* %5
%757 = add nsw i32 %756, 1
store i32 %757, i32* %5
br label %264
758: ; preds = %264
br label %759
759: ; preds = %758
%760 = load i32, i32* %4
%761 = add nsw i32 %760, 1
store i32 %761, i32* %4
br label %258
762: ; preds = %258
br label %763
763: ; preds = %762
%764 = load i32, i32* %3
%765 = add nsw i32 %764, 1
store i32 %765, i32* %3
br label %252
766: ; preds = %252
store i32 1, i32* %3
br label %767
767: ; preds = %822, %766
%768 = load i32, i32* %3
%769 = load i32, i32* %7
%770 = add nsw i32 %769, 1
%771 = icmp slt i32 %768, %770
br i1 %771, label %772, label %825
772: ; preds = %767
store i32 1, i32* %4
br label %773
773: ; preds = %818, %772
%774 = load i32, i32* %4
%775 = load i32, i32* %7
%776 = add nsw i32 %775, 1
%777 = icmp slt i32 %774, %776
br i1 %777, label %778, label %821
778: ; preds = %773
store i32 1, i32* %5
br label %779
779: ; preds = %814, %778
%780 = load i32, i32* %5
%781 = load i32, i32* %7
%782 = add nsw i32 %781, 1
%783 = icmp slt i32 %780, %782
br i1 %783, label %784, label %817
784: ; preds = %779
%785 = load double*, double** %14
%786 = load i32, i32* %3
%787 = load i32, i32* %2
%788 = mul nsw i32 %786, %787
%789 = load i32, i32* %2
%790 = mul nsw i32 %788, %789
%791 = load i32, i32* %4
%792 = load i32, i32* %2
%793 = mul nsw i32 %791, %792
%794 = add nsw i32 %790, %793
%795 = load i32, i32* %5
%796 = add nsw i32 %794, %795
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds double, double* %785, i64 %797
%799 = load double, double* %798
%800 = load double*, double** %12
%801 = load i32, i32* %3
%802 = load i32, i32* %2
%803 = mul nsw i32 %801, %802
%804 = load i32, i32* %2
%805 = mul nsw i32 %803, %804
%806 = load i32, i32* %4
%807 = load i32, i32* %2
%808 = mul nsw i32 %806, %807
%809 = add nsw i32 %805, %808
%810 = load i32, i32* %5
%811 = add nsw i32 %809, %810
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double, double* %800, i64 %812
store double %799, double* %813
br label %814
814: ; preds = %784
%815 = load i32, i32* %5
%816 = add nsw i32 %815, 1
store i32 %816, i32* %5
br label %779
817: ; preds = %779
br label %818
818: ; preds = %817
%819 = load i32, i32* %4
%820 = add nsw i32 %819, 1
store i32 %820, i32* %4
br label %773
821: ; preds = %773
br label %822
822: ; preds = %821
%823 = load i32, i32* %3
%824 = add nsw i32 %823, 1
store i32 %824, i32* %3
br label %767
825: ; preds = %767
br label %826
826: ; preds = %825
%827 = load i32, i32* %6
%828 = add nsw i32 %827, 1
store i32 %828, i32* %6
br label %248
829: ; preds = %248
store i32 0, i32* %3
br label %830
830: ; preds = %882, %829
%831 = load i32, i32* %3
%832 = load i32, i32* %2
%833 = icmp slt i32 %831, %832
br i1 %833, label %834, label %885
834: ; preds = %830
store i32 0, i32* %4
br label %835
835: ; preds = %878, %834
%836 = load i32, i32* %4
%837 = load i32, i32* %2
%838 = icmp slt i32 %836, %837
br i1 %838, label %839, label %881
839: ; preds = %835
store i32 0, i32* %5
br label %840
840: ; preds = %874, %839
%841 = load i32, i32* %5
%842 = load i32, i32* %2
%843 = icmp slt i32 %841, %842
br i1 %843, label %844, label %877
844: ; preds = %840
%845 = load double*, double** %12
%846 = load i32, i32* %3
%847 = load i32, i32* %2
%848 = mul nsw i32 %846, %847
%849 = load i32, i32* %2
%850 = mul nsw i32 %848, %849
%851 = load i32, i32* %4
%852 = load i32, i32* %2
%853 = mul nsw i32 %851, %852
%854 = add nsw i32 %850, %853
%855 = load i32, i32* %5
%856 = add nsw i32 %854, %855
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %845, i64 %857
%859 = load double, double* %858
%860 = load double*, double** %15
%861 = load i32, i32* %3
%862 = load i32, i32* %2
%863 = mul nsw i32 %861, %862
%864 = load i32, i32* %2
%865 = mul nsw i32 %863, %864
%866 = load i32, i32* %4
%867 = load i32, i32* %2
%868 = mul nsw i32 %866, %867
%869 = add nsw i32 %865, %868
%870 = load i32, i32* %5
%871 = add nsw i32 %869, %870
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds double, double* %860, i64 %872
store double %859, double* %873
br label %874
874: ; preds = %844
%875 = load i32, i32* %5
%876 = add nsw i32 %875, 1
store i32 %876, i32* %5
br label %840
877: ; preds = %840
br label %878
878: ; preds = %877
%879 = load i32, i32* %4
%880 = add nsw i32 %879, 1
store i32 %880, i32* %4
br label %835
881: ; preds = %835
br label %882
882: ; preds = %881
%883 = load i32, i32* %3
%884 = add nsw i32 %883, 1
store i32 %884, i32* %3
br label %830
885: ; preds = %830
store i32 0, i32* %3
br label %886
886: ; preds = %938, %885
%887 = load i32, i32* %3
%888 = load i32, i32* %2
%889 = icmp slt i32 %887, %888
br i1 %889, label %890, label %941
890: ; preds = %886
store i32 0, i32* %4
br label %891
891: ; preds = %934, %890
%892 = load i32, i32* %4
%893 = load i32, i32* %2
%894 = icmp slt i32 %892, %893
br i1 %894, label %895, label %937
895: ; preds = %891
store i32 0, i32* %5
br label %896
896: ; preds = %930, %895
%897 = load i32, i32* %5
%898 = load i32, i32* %2
%899 = icmp slt i32 %897, %898
br i1 %899, label %900, label %933
900: ; preds = %896
%901 = load double*, double** %16
%902 = load i32, i32* %3
%903 = load i32, i32* %2
%904 = mul nsw i32 %902, %903
%905 = load i32, i32* %2
%906 = mul nsw i32 %904, %905
%907 = load i32, i32* %4
%908 = load i32, i32* %2
%909 = mul nsw i32 %907, %908
%910 = add nsw i32 %906, %909
%911 = load i32, i32* %5
%912 = add nsw i32 %910, %911
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds double, double* %901, i64 %913
%915 = load double, double* %914
%916 = load double*, double** %12
%917 = load i32, i32* %3
%918 = load i32, i32* %2
%919 = mul nsw i32 %917, %918
%920 = load i32, i32* %2
%921 = mul nsw i32 %919, %920
%922 = load i32, i32* %4
%923 = load i32, i32* %2
%924 = mul nsw i32 %922, %923
%925 = add nsw i32 %921, %924
%926 = load i32, i32* %5
%927 = add nsw i32 %925, %926
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds double, double* %916, i64 %928
store double %915, double* %929
br label %930
930: ; preds = %900
%931 = load i32, i32* %5
%932 = add nsw i32 %931, 1
store i32 %932, i32* %5
br label %896
933: ; preds = %896
br label %934
934: ; preds = %933
%935 = load i32, i32* %4
%936 = add nsw i32 %935, 1
store i32 %936, i32* %4
br label %891
937: ; preds = %891
br label %938
938: ; preds = %937
%939 = load i32, i32* %3
%940 = add nsw i32 %939, 1
store i32 %940, i32* %3
br label %886
941: ; preds = %886
%942 = call double (...) @omp_get_wtime()
store double %942, double* %9
store i32 0, i32* %6
br label %943
943: ; preds = %1521, %941
%944 = load i32, i32* %6
%945 = icmp slt i32 %944, 10
br i1 %945, label %946, label %1524
946: ; preds = %943
store i32 1, i32* %3
br label %947
947: ; preds = %1458, %946
%948 = load i32, i32* %3
%949 = load i32, i32* %7
%950 = add nsw i32 %949, 1
%951 = icmp slt i32 %948, %950
br i1 %951, label %952, label %1461
952: ; preds = %947
store i32 1, i32* %4
br label %953
953: ; preds = %1454, %952
%954 = load i32, i32* %4
%955 = load i32, i32* %7
%956 = add nsw i32 %955, 1
%957 = icmp slt i32 %954, %956
br i1 %957, label %958, label %1457
958: ; preds = %953
store i32 1, i32* %5
br label %959
959: ; preds = %1450, %958
%960 = load i32, i32* %5
%961 = load i32, i32* %7
%962 = add nsw i32 %961, 1
%963 = icmp slt i32 %960, %962
br i1 %963, label %964, label %1453
964: ; preds = %959
%965 = load double*, double** %12
%966 = load i32, i32* %3
%967 = load i32, i32* %2
%968 = mul nsw i32 %966, %967
%969 = load i32, i32* %2
%970 = mul nsw i32 %968, %969
%971 = load i32, i32* %4
%972 = sub nsw i32 %971, 1
%973 = load i32, i32* %2
%974 = mul nsw i32 %972, %973
%975 = add nsw i32 %970, %974
%976 = load i32, i32* %5
%977 = add nsw i32 %975, %976
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds double, double* %965, i64 %978
%980 = load double, double* %979
%981 = load double*, double** %12
%982 = load i32, i32* %3
%983 = load i32, i32* %2
%984 = mul nsw i32 %982, %983
%985 = load i32, i32* %2
%986 = mul nsw i32 %984, %985
%987 = load i32, i32* %4
%988 = add nsw i32 %987, 1
%989 = load i32, i32* %2
%990 = mul nsw i32 %988, %989
%991 = add nsw i32 %986, %990
%992 = load i32, i32* %5
%993 = add nsw i32 %991, %992
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %981, i64 %994
%996 = load double, double* %995
%997 = fadd double %980, %996
%998 = load double*, double** %12
%999 = load i32, i32* %3
%1000 = sub nsw i32 %999, 1
%1001 = load i32, i32* %2
%1002 = mul nsw i32 %1000, %1001
%1003 = load i32, i32* %2
%1004 = mul nsw i32 %1002, %1003
%1005 = load i32, i32* %4
%1006 = load i32, i32* %2
%1007 = mul nsw i32 %1005, %1006
%1008 = add nsw i32 %1004, %1007
%1009 = load i32, i32* %5
%1010 = add nsw i32 %1008, %1009
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds double, double* %998, i64 %1011
%1013 = load double, double* %1012
%1014 = fadd double %997, %1013
%1015 = load double*, double** %12
%1016 = load i32, i32* %3
%1017 = add nsw i32 %1016, 1
%1018 = load i32, i32* %2
%1019 = mul nsw i32 %1017, %1018
%1020 = load i32, i32* %2
%1021 = mul nsw i32 %1019, %1020
%1022 = load i32, i32* %4
%1023 = load i32, i32* %2
%1024 = mul nsw i32 %1022, %1023
%1025 = add nsw i32 %1021, %1024
%1026 = load i32, i32* %5
%1027 = add nsw i32 %1025, %1026
%1028 = sext i32 %1027 to i64
%1029 = getelementptr inbounds double, double* %1015, i64 %1028
%1030 = load double, double* %1029
%1031 = fadd double %1014, %1030
%1032 = load double*, double** %12
%1033 = load i32, i32* %3
%1034 = sub nsw i32 %1033, 1
%1035 = load i32, i32* %2
%1036 = mul nsw i32 %1034, %1035
%1037 = load i32, i32* %2
%1038 = mul nsw i32 %1036, %1037
%1039 = load i32, i32* %4
%1040 = sub nsw i32 %1039, 1
%1041 = load i32, i32* %2
%1042 = mul nsw i32 %1040, %1041
%1043 = add nsw i32 %1038, %1042
%1044 = load i32, i32* %5
%1045 = add nsw i32 %1043, %1044
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds double, double* %1032, i64 %1046
%1048 = load double, double* %1047
%1049 = fadd double %1031, %1048
%1050 = load double*, double** %12
%1051 = load i32, i32* %3
%1052 = sub nsw i32 %1051, 1
%1053 = load i32, i32* %2
%1054 = mul nsw i32 %1052, %1053
%1055 = load i32, i32* %2
%1056 = mul nsw i32 %1054, %1055
%1057 = load i32, i32* %4
%1058 = add nsw i32 %1057, 1
%1059 = load i32, i32* %2
%1060 = mul nsw i32 %1058, %1059
%1061 = add nsw i32 %1056, %1060
%1062 = load i32, i32* %5
%1063 = add nsw i32 %1061, %1062
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds double, double* %1050, i64 %1064
%1066 = load double, double* %1065
%1067 = fadd double %1049, %1066
%1068 = load double*, double** %12
%1069 = load i32, i32* %3
%1070 = add nsw i32 %1069, 1
%1071 = load i32, i32* %2
%1072 = mul nsw i32 %1070, %1071
%1073 = load i32, i32* %2
%1074 = mul nsw i32 %1072, %1073
%1075 = load i32, i32* %4
%1076 = sub nsw i32 %1075, 1
%1077 = load i32, i32* %2
%1078 = mul nsw i32 %1076, %1077
%1079 = add nsw i32 %1074, %1078
%1080 = load i32, i32* %5
%1081 = add nsw i32 %1079, %1080
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds double, double* %1068, i64 %1082
%1084 = load double, double* %1083
%1085 = fadd double %1067, %1084
%1086 = load double*, double** %12
%1087 = load i32, i32* %3
%1088 = add nsw i32 %1087, 1
%1089 = load i32, i32* %2
%1090 = mul nsw i32 %1088, %1089
%1091 = load i32, i32* %2
%1092 = mul nsw i32 %1090, %1091
%1093 = load i32, i32* %4
%1094 = add nsw i32 %1093, 1
%1095 = load i32, i32* %2
%1096 = mul nsw i32 %1094, %1095
%1097 = add nsw i32 %1092, %1096
%1098 = load i32, i32* %5
%1099 = add nsw i32 %1097, %1098
%1100 = sext i32 %1099 to i64
%1101 = getelementptr inbounds double, double* %1086, i64 %1100
%1102 = load double, double* %1101
%1103 = fadd double %1085, %1102
%1104 = load double*, double** %12
%1105 = load i32, i32* %3
%1106 = load i32, i32* %2
%1107 = mul nsw i32 %1105, %1106
%1108 = load i32, i32* %2
%1109 = mul nsw i32 %1107, %1108
%1110 = load i32, i32* %4
%1111 = sub nsw i32 %1110, 1
%1112 = load i32, i32* %2
%1113 = mul nsw i32 %1111, %1112
%1114 = add nsw i32 %1109, %1113
%1115 = load i32, i32* %5
%1116 = sub nsw i32 %1115, 1
%1117 = add nsw i32 %1114, %1116
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds double, double* %1104, i64 %1118
%1120 = load double, double* %1119
%1121 = fadd double %1103, %1120
%1122 = load double*, double** %12
%1123 = load i32, i32* %3
%1124 = load i32, i32* %2
%1125 = mul nsw i32 %1123, %1124
%1126 = load i32, i32* %2
%1127 = mul nsw i32 %1125, %1126
%1128 = load i32, i32* %4
%1129 = add nsw i32 %1128, 1
%1130 = load i32, i32* %2
%1131 = mul nsw i32 %1129, %1130
%1132 = add nsw i32 %1127, %1131
%1133 = load i32, i32* %5
%1134 = sub nsw i32 %1133, 1
%1135 = add nsw i32 %1132, %1134
%1136 = sext i32 %1135 to i64
%1137 = getelementptr inbounds double, double* %1122, i64 %1136
%1138 = load double, double* %1137
%1139 = fadd double %1121, %1138
%1140 = load double*, double** %12
%1141 = load i32, i32* %3
%1142 = sub nsw i32 %1141, 1
%1143 = load i32, i32* %2
%1144 = mul nsw i32 %1142, %1143
%1145 = load i32, i32* %2
%1146 = mul nsw i32 %1144, %1145
%1147 = load i32, i32* %4
%1148 = load i32, i32* %2
%1149 = mul nsw i32 %1147, %1148
%1150 = add nsw i32 %1146, %1149
%1151 = load i32, i32* %5
%1152 = sub nsw i32 %1151, 1
%1153 = add nsw i32 %1150, %1152
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds double, double* %1140, i64 %1154
%1156 = load double, double* %1155
%1157 = fadd double %1139, %1156
%1158 = load double*, double** %12
%1159 = load i32, i32* %3
%1160 = add nsw i32 %1159, 1
%1161 = load i32, i32* %2
%1162 = mul nsw i32 %1160, %1161
%1163 = load i32, i32* %2
%1164 = mul nsw i32 %1162, %1163
%1165 = load i32, i32* %4
%1166 = load i32, i32* %2
%1167 = mul nsw i32 %1165, %1166
%1168 = add nsw i32 %1164, %1167
%1169 = load i32, i32* %5
%1170 = sub nsw i32 %1169, 1
%1171 = add nsw i32 %1168, %1170
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds double, double* %1158, i64 %1172
%1174 = load double, double* %1173
%1175 = fadd double %1157, %1174
%1176 = load double*, double** %12
%1177 = load i32, i32* %3
%1178 = sub nsw i32 %1177, 1
%1179 = load i32, i32* %2
%1180 = mul nsw i32 %1178, %1179
%1181 = load i32, i32* %2
%1182 = mul nsw i32 %1180, %1181
%1183 = load i32, i32* %4
%1184 = sub nsw i32 %1183, 1
%1185 = load i32, i32* %2
%1186 = mul nsw i32 %1184, %1185
%1187 = add nsw i32 %1182, %1186
%1188 = load i32, i32* %5
%1189 = sub nsw i32 %1188, 1
%1190 = add nsw i32 %1187, %1189
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds double, double* %1176, i64 %1191
%1193 = load double, double* %1192
%1194 = fadd double %1175, %1193
%1195 = load double*, double** %12
%1196 = load i32, i32* %3
%1197 = sub nsw i32 %1196, 1
%1198 = load i32, i32* %2
%1199 = mul nsw i32 %1197, %1198
%1200 = load i32, i32* %2
%1201 = mul nsw i32 %1199, %1200
%1202 = load i32, i32* %4
%1203 = add nsw i32 %1202, 1
%1204 = load i32, i32* %2
%1205 = mul nsw i32 %1203, %1204
%1206 = add nsw i32 %1201, %1205
%1207 = load i32, i32* %5
%1208 = sub nsw i32 %1207, 1
%1209 = add nsw i32 %1206, %1208
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds double, double* %1195, i64 %1210
%1212 = load double, double* %1211
%1213 = fadd double %1194, %1212
%1214 = load double*, double** %12
%1215 = load i32, i32* %3
%1216 = add nsw i32 %1215, 1
%1217 = load i32, i32* %2
%1218 = mul nsw i32 %1216, %1217
%1219 = load i32, i32* %2
%1220 = mul nsw i32 %1218, %1219
%1221 = load i32, i32* %4
%1222 = sub nsw i32 %1221, 1
%1223 = load i32, i32* %2
%1224 = mul nsw i32 %1222, %1223
%1225 = add nsw i32 %1220, %1224
%1226 = load i32, i32* %5
%1227 = sub nsw i32 %1226, 1
%1228 = add nsw i32 %1225, %1227
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds double, double* %1214, i64 %1229
%1231 = load double, double* %1230
%1232 = fadd double %1213, %1231
%1233 = load double*, double** %12
%1234 = load i32, i32* %3
%1235 = add nsw i32 %1234, 1
%1236 = load i32, i32* %2
%1237 = mul nsw i32 %1235, %1236
%1238 = load i32, i32* %2
%1239 = mul nsw i32 %1237, %1238
%1240 = load i32, i32* %4
%1241 = add nsw i32 %1240, 1
%1242 = load i32, i32* %2
%1243 = mul nsw i32 %1241, %1242
%1244 = add nsw i32 %1239, %1243
%1245 = load i32, i32* %5
%1246 = sub nsw i32 %1245, 1
%1247 = add nsw i32 %1244, %1246
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds double, double* %1233, i64 %1248
%1250 = load double, double* %1249
%1251 = fadd double %1232, %1250
%1252 = load double*, double** %12
%1253 = load i32, i32* %3
%1254 = load i32, i32* %2
%1255 = mul nsw i32 %1253, %1254
%1256 = load i32, i32* %2
%1257 = mul nsw i32 %1255, %1256
%1258 = load i32, i32* %4
%1259 = sub nsw i32 %1258, 1
%1260 = load i32, i32* %2
%1261 = mul nsw i32 %1259, %1260
%1262 = add nsw i32 %1257, %1261
%1263 = load i32, i32* %5
%1264 = add nsw i32 %1263, 1
%1265 = add nsw i32 %1262, %1264
%1266 = sext i32 %1265 to i64
%1267 = getelementptr inbounds double, double* %1252, i64 %1266
%1268 = load double, double* %1267
%1269 = fadd double %1251, %1268
%1270 = load double*, double** %12
%1271 = load i32, i32* %3
%1272 = load i32, i32* %2
%1273 = mul nsw i32 %1271, %1272
%1274 = load i32, i32* %2
%1275 = mul nsw i32 %1273, %1274
%1276 = load i32, i32* %4
%1277 = add nsw i32 %1276, 1
%1278 = load i32, i32* %2
%1279 = mul nsw i32 %1277, %1278
%1280 = add nsw i32 %1275, %1279
%1281 = load i32, i32* %5
%1282 = add nsw i32 %1281, 1
%1283 = add nsw i32 %1280, %1282
%1284 = sext i32 %1283 to i64
%1285 = getelementptr inbounds double, double* %1270, i64 %1284
%1286 = load double, double* %1285
%1287 = fadd double %1269, %1286
%1288 = load double*, double** %12
%1289 = load i32, i32* %3
%1290 = sub nsw i32 %1289, 1
%1291 = load i32, i32* %2
%1292 = mul nsw i32 %1290, %1291
%1293 = load i32, i32* %2
%1294 = mul nsw i32 %1292, %1293
%1295 = load i32, i32* %4
%1296 = load i32, i32* %2
%1297 = mul nsw i32 %1295, %1296
%1298 = add nsw i32 %1294, %1297
%1299 = load i32, i32* %5
%1300 = add nsw i32 %1299, 1
%1301 = add nsw i32 %1298, %1300
%1302 = sext i32 %1301 to i64
%1303 = getelementptr inbounds double, double* %1288, i64 %1302
%1304 = load double, double* %1303
%1305 = fadd double %1287, %1304
%1306 = load double*, double** %12
%1307 = load i32, i32* %3
%1308 = add nsw i32 %1307, 1
%1309 = load i32, i32* %2
%1310 = mul nsw i32 %1308, %1309
%1311 = load i32, i32* %2
%1312 = mul nsw i32 %1310, %1311
%1313 = load i32, i32* %4
%1314 = load i32, i32* %2
%1315 = mul nsw i32 %1313, %1314
%1316 = add nsw i32 %1312, %1315
%1317 = load i32, i32* %5
%1318 = add nsw i32 %1317, 1
%1319 = add nsw i32 %1316, %1318
%1320 = sext i32 %1319 to i64
%1321 = getelementptr inbounds double, double* %1306, i64 %1320
%1322 = load double, double* %1321
%1323 = fadd double %1305, %1322
%1324 = load double*, double** %12
%1325 = load i32, i32* %3
%1326 = sub nsw i32 %1325, 1
%1327 = load i32, i32* %2
%1328 = mul nsw i32 %1326, %1327
%1329 = load i32, i32* %2
%1330 = mul nsw i32 %1328, %1329
%1331 = load i32, i32* %4
%1332 = sub nsw i32 %1331, 1
%1333 = load i32, i32* %2
%1334 = mul nsw i32 %1332, %1333
%1335 = add nsw i32 %1330, %1334
%1336 = load i32, i32* %5
%1337 = add nsw i32 %1336, 1
%1338 = add nsw i32 %1335, %1337
%1339 = sext i32 %1338 to i64
%1340 = getelementptr inbounds double, double* %1324, i64 %1339
%1341 = load double, double* %1340
%1342 = fadd double %1323, %1341
%1343 = load double*, double** %12
%1344 = load i32, i32* %3
%1345 = sub nsw i32 %1344, 1
%1346 = load i32, i32* %2
%1347 = mul nsw i32 %1345, %1346
%1348 = load i32, i32* %2
%1349 = mul nsw i32 %1347, %1348
%1350 = load i32, i32* %4
%1351 = add nsw i32 %1350, 1
%1352 = load i32, i32* %2
%1353 = mul nsw i32 %1351, %1352
%1354 = add nsw i32 %1349, %1353
%1355 = load i32, i32* %5
%1356 = add nsw i32 %1355, 1
%1357 = add nsw i32 %1354, %1356
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds double, double* %1343, i64 %1358
%1360 = load double, double* %1359
%1361 = fadd double %1342, %1360
%1362 = load double*, double** %12
%1363 = load i32, i32* %3
%1364 = add nsw i32 %1363, 1
%1365 = load i32, i32* %2
%1366 = mul nsw i32 %1364, %1365
%1367 = load i32, i32* %2
%1368 = mul nsw i32 %1366, %1367
%1369 = load i32, i32* %4
%1370 = sub nsw i32 %1369, 1
%1371 = load i32, i32* %2
%1372 = mul nsw i32 %1370, %1371
%1373 = add nsw i32 %1368, %1372
%1374 = load i32, i32* %5
%1375 = add nsw i32 %1374, 1
%1376 = add nsw i32 %1373, %1375
%1377 = sext i32 %1376 to i64
%1378 = getelementptr inbounds double, double* %1362, i64 %1377
%1379 = load double, double* %1378
%1380 = fadd double %1361, %1379
%1381 = load double*, double** %12
%1382 = load i32, i32* %3
%1383 = add nsw i32 %1382, 1
%1384 = load i32, i32* %2
%1385 = mul nsw i32 %1383, %1384
%1386 = load i32, i32* %2
%1387 = mul nsw i32 %1385, %1386
%1388 = load i32, i32* %4
%1389 = add nsw i32 %1388, 1
%1390 = load i32, i32* %2
%1391 = mul nsw i32 %1389, %1390
%1392 = add nsw i32 %1387, %1391
%1393 = load i32, i32* %5
%1394 = add nsw i32 %1393, 1
%1395 = add nsw i32 %1392, %1394
%1396 = sext i32 %1395 to i64
%1397 = getelementptr inbounds double, double* %1381, i64 %1396
%1398 = load double, double* %1397
%1399 = fadd double %1380, %1398
%1400 = load double*, double** %12
%1401 = load i32, i32* %3
%1402 = load i32, i32* %2
%1403 = mul nsw i32 %1401, %1402
%1404 = load i32, i32* %2
%1405 = mul nsw i32 %1403, %1404
%1406 = load i32, i32* %4
%1407 = load i32, i32* %2
%1408 = mul nsw i32 %1406, %1407
%1409 = add nsw i32 %1405, %1408
%1410 = load i32, i32* %5
%1411 = sub nsw i32 %1410, 1
%1412 = add nsw i32 %1409, %1411
%1413 = sext i32 %1412 to i64
%1414 = getelementptr inbounds double, double* %1400, i64 %1413
%1415 = load double, double* %1414
%1416 = fadd double %1399, %1415
%1417 = load double*, double** %12
%1418 = load i32, i32* %3
%1419 = load i32, i32* %2
%1420 = mul nsw i32 %1418, %1419
%1421 = load i32, i32* %2
%1422 = mul nsw i32 %1420, %1421
%1423 = load i32, i32* %4
%1424 = load i32, i32* %2
%1425 = mul nsw i32 %1423, %1424
%1426 = add nsw i32 %1422, %1425
%1427 = load i32, i32* %5
%1428 = add nsw i32 %1427, 1
%1429 = add nsw i32 %1426, %1428
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds double, double* %1417, i64 %1430
%1432 = load double, double* %1431
%1433 = fadd double %1416, %1432
%1434 = load double, double* %8
%1435 = fmul double %1433, %1434
%1436 = load double*, double** %14
%1437 = load i32, i32* %3
%1438 = load i32, i32* %2
%1439 = mul nsw i32 %1437, %1438
%1440 = load i32, i32* %2
%1441 = mul nsw i32 %1439, %1440
%1442 = load i32, i32* %4
%1443 = load i32, i32* %2
%1444 = mul nsw i32 %1442, %1443
%1445 = add nsw i32 %1441, %1444
%1446 = load i32, i32* %5
%1447 = add nsw i32 %1445, %1446
%1448 = sext i32 %1447 to i64
%1449 = getelementptr inbounds double, double* %1436, i64 %1448
store double %1435, double* %1449
br label %1450
1450: ; preds = %964
%1451 = load i32, i32* %5
%1452 = add nsw i32 %1451, 1
store i32 %1452, i32* %5
br label %959
1453: ; preds = %959
br label %1454
1454: ; preds = %1453
%1455 = load i32, i32* %4
%1456 = add nsw i32 %1455, 1
store i32 %1456, i32* %4
br label %953
1457: ; preds = %953
br label %1458
1458: ; preds = %1457
%1459 = load i32, i32* %3
%1460 = add nsw i32 %1459, 1
store i32 %1460, i32* %3
br label %947
1461: ; preds = %947
store i32 1, i32* %3
br label %1462
1462: ; preds = %1517, %1461
%1463 = load i32, i32* %3
%1464 = load i32, i32* %7
%1465 = add nsw i32 %1464, 1
%1466 = icmp slt i32 %1463, %1465
br i1 %1466, label %1467, label %1520
1467: ; preds = %1462
store i32 1, i32* %4
br label %1468
1468: ; preds = %1513, %1467
%1469 = load i32, i32* %4
%1470 = load i32, i32* %7
%1471 = add nsw i32 %1470, 1
%1472 = icmp slt i32 %1469, %1471
br i1 %1472, label %1473, label %1516
1473: ; preds = %1468
store i32 1, i32* %5
br label %1474
1474: ; preds = %1509, %1473
%1475 = load i32, i32* %5
%1476 = load i32, i32* %7
%1477 = add nsw i32 %1476, 1
%1478 = icmp slt i32 %1475, %1477
br i1 %1478, label %1479, label %1512
1479: ; preds = %1474
%1480 = load double*, double** %14
%1481 = load i32, i32* %3
%1482 = load i32, i32* %2
%1483 = mul nsw i32 %1481, %1482
%1484 = load i32, i32* %2
%1485 = mul nsw i32 %1483, %1484
%1486 = load i32, i32* %4
%1487 = load i32, i32* %2
%1488 = mul nsw i32 %1486, %1487
%1489 = add nsw i32 %1485, %1488
%1490 = load i32, i32* %5
%1491 = add nsw i32 %1489, %1490
%1492 = sext i32 %1491 to i64
%1493 = getelementptr inbounds double, double* %1480, i64 %1492
%1494 = load double, double* %1493
%1495 = load double*, double** %12
%1496 = load i32, i32* %3
%1497 = load i32, i32* %2
%1498 = mul nsw i32 %1496, %1497
%1499 = load i32, i32* %2
%1500 = mul nsw i32 %1498, %1499
%1501 = load i32, i32* %4
%1502 = load i32, i32* %2
%1503 = mul nsw i32 %1501, %1502
%1504 = add nsw i32 %1500, %1503
%1505 = load i32, i32* %5
%1506 = add nsw i32 %1504, %1505
%1507 = sext i32 %1506 to i64
%1508 = getelementptr inbounds double, double* %1495, i64 %1507
store double %1494, double* %1508
br label %1509
1509: ; preds = %1479
%1510 = load i32, i32* %5
%1511 = add nsw i32 %1510, 1
store i32 %1511, i32* %5
br label %1474
1512: ; preds = %1474
br label %1513
1513: ; preds = %1512
%1514 = load i32, i32* %4
%1515 = add nsw i32 %1514, 1
store i32 %1515, i32* %4
br label %1468
1516: ; preds = %1468
br label %1517
1517: ; preds = %1516
%1518 = load i32, i32* %3
%1519 = add nsw i32 %1518, 1
store i32 %1519, i32* %3
br label %1462
1520: ; preds = %1462
br label %1521
1521: ; preds = %1520
%1522 = load i32, i32* %6
%1523 = add nsw i32 %1522, 1
store i32 %1523, i32* %6
br label %943
1524: ; preds = %943
%1525 = call double (...) @omp_get_wtime()
store double %1525, double* %10
%1526 = load double*, double** %13
%1527 = getelementptr inbounds double, double* %1526, i64 0
%1528 = load double*, double** %12
%1529 = getelementptr inbounds double, double* %1528, i64 0
%1530 = load i32, i32* %2
%1531 = sext i32 %1530 to i64
%1532 = mul i64 8, %1531
%1533 = load i32, i32* %2
%1534 = sext i32 %1533 to i64
%1535 = mul i64 %1532, %1534
%1536 = load i32, i32* %2
%1537 = sext i32 %1536 to i64
%1538 = mul i64 %1535, %1537
%1539 = trunc i64 %1538 to i32
%1540 = call i32 @memcpy(double* %1527, double* %1529, i32 %1539)
%1541 = load double*, double** %15
%1542 = getelementptr inbounds double, double* %1541, i64 0
%1543 = load double*, double** %13
%1544 = getelementptr inbounds double, double* %1543, i64 0
%1545 = load i32, i32* %2
%1546 = call double @max_diff(double* %1542, double* %1544, i32 %1545)
store double %1546, double* %11
%1547 = load double*, double** %12
%1548 = call i32 @free(double* %1547)
%1549 = load double*, double** %16
%1550 = call i32 @free(double* %1549)
%1551 = load double*, double** %14
%1552 = call i32 @free(double* %1551)
%1553 = load double*, double** %15
%1554 = call i32 @free(double* %1553)
%1555 = load double*, double** %13
%1556 = call i32 @free(double* %1555)
%1557 = load double, double* %11
%1558 = fcmp olt double %1557, 1.000000e-15
br i1 %1558, label %1559, label %1563
1559: ; preds = %1524
%1560 = load double, double* %10
%1561 = load double, double* %9
%1562 = fsub double %1560, %1561
store double %1562, double* %1
br label %1564
1563: ; preds = %1524
store double -1.100000e+04, double* %1
br label %1564
1564: ; preds = %1563, %1559, %99
%1565 = load double, double* %1
ret double %1565
}

LLVM IR (-O2):
@datasize = external global i32
@RAND_MAX = global i64 0
define double @stencil() {
%1 = load i32, i32* @datasize
%2 = lshr i32 %1, 4
%3 = tail call i32 @cbrt(i32 %2)
%4 = mul i32 %3, %3
%5 = shl i32 %4, 3
%6 = mul i32 %5, %3
%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 = tail call i64 @malloc(i32 %6)
%12 = inttoptr i64 %11 to double*
%13 = tail call i64 @malloc(i32 %6)
%14 = inttoptr i64 %13 to double*
%15 = tail call i64 @malloc(i32 %6)
%16 = inttoptr i64 %15 to double*
%17 = icmp eq i64 %7, 0
%18 = icmp eq i64 %9, 0
%19 = select i1 %17, i1 true, i1 %18
%20 = icmp eq i64 %11, 0
%21 = select i1 %19, i1 true, i1 %20
%22 = icmp eq i64 %13, 0
%23 = select i1 %21, i1 true, i1 %22
%24 = icmp eq i64 %15, 0
%25 = select i1 %23, i1 true, i1 %24
br i1 %25, label %1142, label %26
26: ; preds = %0
%27 = icmp sgt i32 %3, 0
br i1 %27, label %30, label %28
28: ; preds = %26
%29 = add i32 %3, -1
br label %148
30: ; preds = %26
%31 = zext i32 %3 to i64
%32 = shl nuw nsw i64 %31, 3
%33 = add nsw i64 %31, -1
%34 = and i64 %31, 3
%35 = icmp ult i64 %33, 3
%36 = and i64 %31, 4294967292
%37 = icmp eq i64 %34, 0
br label %38
38: ; preds = %93, %30
%39 = phi i32 [ 0, %30 ], [ %94, %93 ]
%40 = mul i32 %4, %39
br i1 %35, label %79, label %46
41: ; preds = %93
%42 = add i32 %3, -1
%43 = icmp sgt i32 %3, 2
br i1 %43, label %44, label %99
44: ; preds = %41
%45 = zext i32 %42 to i64
br label %96
46: ; preds = %38, %46
%47 = phi i64 [ %76, %46 ], [ 0, %38 ]
%48 = phi i64 [ %77, %46 ], [ 0, %38 ]
%49 = trunc i64 %47 to i32
%50 = mul i32 %3, %49
%51 = add i32 %40, %50
%52 = sext i32 %51 to i64
%53 = getelementptr double, double* %8, i64 %52
%54 = bitcast double* %53 to i8*
%55 = trunc i64 %47 to i32
%56 = or i32 %55, 1
%57 = mul i32 %3, %56
%58 = add i32 %40, %57
%59 = sext i32 %58 to i64
%60 = getelementptr double, double* %8, i64 %59
%61 = bitcast double* %60 to i8*
%62 = trunc i64 %47 to i32
%63 = or i32 %62, 2
%64 = mul i32 %3, %63
%65 = add i32 %40, %64
%66 = sext i32 %65 to i64
%67 = getelementptr double, double* %8, i64 %66
%68 = bitcast double* %67 to i8*
%69 = trunc i64 %47 to i32
%70 = or i32 %69, 3
%71 = mul i32 %3, %70
%72 = add i32 %40, %71
%73 = sext i32 %72 to i64
%74 = getelementptr double, double* %8, i64 %73
%75 = bitcast double* %74 to i8*
%76 = add nuw nsw i64 %47, 4
%77 = add i64 %48, 4
%78 = icmp eq i64 %77, %36
br i1 %78, label %79, label %46
79: ; preds = %46, %38
%80 = phi i64 [ 0, %38 ], [ %76, %46 ]
br i1 %37, label %93, label %81
81: ; preds = %79, %81
%82 = phi i64 [ %90, %81 ], [ %80, %79 ]
%83 = phi i64 [ %91, %81 ], [ 0, %79 ]
%84 = trunc i64 %82 to i32
%85 = mul i32 %3, %84
%86 = add i32 %40, %85
%87 = sext i32 %86 to i64
%88 = getelementptr double, double* %8, i64 %87
%89 = bitcast double* %88 to i8*
%90 = add nuw nsw i64 %82, 1
%91 = add i64 %83, 1
%92 = icmp eq i64 %91, %34
br i1 %92, label %93, label %81
93: ; preds = %81, %79
%94 = add nuw nsw i32 %39, 1
%95 = icmp eq i32 %94, %3
br i1 %95, label %41, label %38
96: ; preds = %142, %44
%97 = phi i32 [ 1, %44 ], [ %143, %142 ]
%98 = mul nsw i32 %97, %3
br label %121
99: ; preds = %142, %41
%100 = phi i1 [ false, %41 ], [ %43, %142 ]
br i1 %27, label %101, label %148
101: ; preds = %99
%102 = zext i32 %3 to i64
%103 = getelementptr double, double* %16, i64 %31
%104 = getelementptr double, double* %8, i64 %31
%105 = and i64 %31, 4294967292
%106 = add nsw i64 %105, -4
%107 = lshr exact i64 %106, 2
%108 = add nuw nsw i64 %107, 1
%109 = icmp ult i32 %3, 4
%110 = icmp ugt double* %104, %16
%111 = icmp ugt double* %103, %8
%112 = and i1 %110, %111
%113 = and i64 %31, 4294967292
%114 = and i64 %108, 3
%115 = icmp ult i64 %106, 12
%116 = and i64 %108, 9223372036854775804
%117 = icmp eq i64 %114, 0
%118 = icmp eq i64 %113, %31
%119 = and i64 %31, 3
%120 = icmp eq i64 %119, 0
br label %145
121: ; preds = %139, %96
%122 = phi i64 [ 1, %96 ], [ %140, %139 ]
%123 = trunc i64 %122 to i32
%124 = add i32 %98, %123
%125 = mul i32 %124, %3
%126 = sext i32 %125 to i64
br label %127
127: ; preds = %121, %127
%128 = phi i64 [ 1, %121 ], [ %137, %127 ]
%129 = tail call i64 (...) @rand()
%130 = sitofp i64 %129 to double
%131 = load i64, i64* @RAND_MAX
%132 = sitofp i64 %131 to double
%133 = fadd double %132, 1.000000e+00
%134 = fdiv double %130, %133
%135 = add nsw i64 %128, %126
%136 = getelementptr inbounds double, double* %8, i64 %135
store double %134, double* %136
%137 = add nuw nsw i64 %128, 1
%138 = icmp eq i64 %137, %45
br i1 %138, label %139, label %127
139: ; preds = %127
%140 = add nuw nsw i64 %122, 1
%141 = icmp eq i64 %140, %45
br i1 %141, label %142, label %121
142: ; preds = %139
%143 = add nuw nsw i32 %97, 1
%144 = icmp eq i32 %143, %42
br i1 %144, label %99, label %96
145: ; preds = %297, %101
%146 = phi i32 [ %298, %297 ], [ 0, %101 ]
%147 = mul nsw i32 %146, %3
br label %173
148: ; preds = %297, %28, %99
%149 = phi i32 [ %29, %28 ], [ %42, %99 ], [ %42, %297 ]
%150 = phi i1 [ false, %28 ], [ %100, %99 ], [ %100, %297 ]
%151 = sext i32 %3 to i64
%152 = zext i32 %149 to i64
%153 = zext i32 %149 to i64
%154 = getelementptr double, double* %8, i64 1
%155 = getelementptr double, double* %8, i64 %152
%156 = getelementptr double, double* %12, i64 1
%157 = getelementptr double, double* %12, i64 %152
%158 = add nsw i64 %152, -1
%159 = add nsw i64 %152, -5
%160 = lshr i64 %159, 2
%161 = add nuw nsw i64 %160, 1
%162 = icmp ult i64 %158, 4
%163 = icmp ult double* %154, %157
%164 = icmp ult double* %156, %155
%165 = and i1 %163, %164
%166 = and i64 %158, -4
%167 = or i64 %166, 1
%168 = and i64 %161, 1
%169 = icmp ult i64 %159, 4
%170 = and i64 %161, 9223372036854775806
%171 = icmp eq i64 %168, 0
%172 = icmp eq i64 %158, %166
br label %300
173: ; preds = %294, %145
%174 = phi i64 [ 0, %145 ], [ %295, %294 ]
%175 = trunc i64 %174 to i32
%176 = add i32 %147, %175
%177 = mul i32 %176, %3
%178 = sext i32 %177 to i64
%179 = select i1 %109, i1 true, i1 %112
br i1 %179, label %254, label %180
180: ; preds = %173
br i1 %115, label %234, label %181
181: ; preds = %180, %181
%182 = phi i64 [ %231, %181 ], [ 0, %180 ]
%183 = phi i64 [ %232, %181 ], [ 0, %180 ]
%184 = add nsw i64 %182, %178
%185 = getelementptr inbounds double, double* %8, i64 %184
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = getelementptr inbounds double, double* %185, i64 2
%189 = bitcast double* %188 to <2 x double>*
%190 = load <2 x double>, <2 x double>* %189
%191 = getelementptr inbounds double, double* %16, i64 %184
%192 = bitcast double* %191 to <2 x double>*
store <2 x double> %187, <2 x double>* %192
%193 = getelementptr inbounds double, double* %191, i64 2
%194 = bitcast double* %193 to <2 x double>*
store <2 x double> %190, <2 x double>* %194
%195 = or i64 %182, 4
%196 = add nsw i64 %195, %178
%197 = getelementptr inbounds double, double* %8, i64 %196
%198 = bitcast double* %197 to <2 x double>*
%199 = load <2 x double>, <2 x double>* %198
%200 = getelementptr inbounds double, double* %197, i64 2
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = getelementptr inbounds double, double* %16, i64 %196
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> %199, <2 x double>* %204
%205 = getelementptr inbounds double, double* %203, i64 2
%206 = bitcast double* %205 to <2 x double>*
store <2 x double> %202, <2 x double>* %206
%207 = or i64 %182, 8
%208 = add nsw i64 %207, %178
%209 = getelementptr inbounds double, double* %8, i64 %208
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = getelementptr inbounds double, double* %209, i64 2
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = getelementptr inbounds double, double* %16, i64 %208
%216 = bitcast double* %215 to <2 x double>*
store <2 x double> %211, <2 x double>* %216
%217 = getelementptr inbounds double, double* %215, i64 2
%218 = bitcast double* %217 to <2 x double>*
store <2 x double> %214, <2 x double>* %218
%219 = or i64 %182, 12
%220 = add nsw i64 %219, %178
%221 = getelementptr inbounds double, double* %8, i64 %220
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = getelementptr inbounds double, double* %221, i64 2
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %16, i64 %220
%228 = bitcast double* %227 to <2 x double>*
store <2 x double> %223, <2 x double>* %228
%229 = getelementptr inbounds double, double* %227, i64 2
%230 = bitcast double* %229 to <2 x double>*
store <2 x double> %226, <2 x double>* %230
%231 = add nuw i64 %182, 16
%232 = add nuw i64 %183, 4
%233 = icmp eq i64 %232, %116
br i1 %233, label %234, label %181
234: ; preds = %181, %180
%235 = phi i64 [ 0, %180 ], [ %231, %181 ]
br i1 %117, label %253, label %236
236: ; preds = %234, %236
%237 = phi i64 [ %250, %236 ], [ %235, %234 ]
%238 = phi i64 [ %251, %236 ], [ 0, %234 ]
%239 = add nsw i64 %237, %178
%240 = getelementptr inbounds double, double* %8, i64 %239
%241 = bitcast double* %240 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = getelementptr inbounds double, double* %240, i64 2
%244 = bitcast double* %243 to <2 x double>*
%245 = load <2 x double>, <2 x double>* %244
%246 = getelementptr inbounds double, double* %16, i64 %239
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> %242, <2 x double>* %247
%248 = getelementptr inbounds double, double* %246, i64 2
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> %245, <2 x double>* %249
%250 = add nuw i64 %237, 4
%251 = add i64 %238, 1
%252 = icmp eq i64 %251, %114
br i1 %252, label %253, label %236
253: ; preds = %236, %234
br i1 %118, label %294, label %254
254: ; preds = %173, %253
%255 = phi i64 [ 0, %173 ], [ %113, %253 ]
%256 = xor i64 %255, -1
%257 = add nsw i64 %256, %31
br i1 %120, label %268, label %258
258: ; preds = %254, %258
%259 = phi i64 [ %265, %258 ], [ %255, %254 ]
%260 = phi i64 [ %266, %258 ], [ 0, %254 ]
%261 = add nsw i64 %259, %178
%262 = getelementptr inbounds double, double* %8, i64 %261
%263 = load double, double* %262
%264 = getelementptr inbounds double, double* %16, i64 %261
store double %263, double* %264
%265 = add nuw nsw i64 %259, 1
%266 = add i64 %260, 1
%267 = icmp eq i64 %266, %119
br i1 %267, label %268, label %258
268: ; preds = %258, %254
%269 = phi i64 [ %255, %254 ], [ %265, %258 ]
%270 = icmp ult i64 %257, 3
br i1 %270, label %294, label %271
271: ; preds = %268, %271
%272 = phi i64 [ %292, %271 ], [ %269, %268 ]
%273 = add nsw i64 %272, %178
%274 = getelementptr inbounds double, double* %8, i64 %273
%275 = load double, double* %274
%276 = getelementptr inbounds double, double* %16, i64 %273
store double %275, double* %276
%277 = add nuw nsw i64 %272, 1
%278 = add nsw i64 %277, %178
%279 = getelementptr inbounds double, double* %8, i64 %278
%280 = load double, double* %279
%281 = getelementptr inbounds double, double* %16, i64 %278
store double %280, double* %281
%282 = add nuw nsw i64 %272, 2
%283 = add nsw i64 %282, %178
%284 = getelementptr inbounds double, double* %8, i64 %283
%285 = load double, double* %284
%286 = getelementptr inbounds double, double* %16, i64 %283
store double %285, double* %286
%287 = add nuw nsw i64 %272, 3
%288 = add nsw i64 %287, %178
%289 = getelementptr inbounds double, double* %8, i64 %288
%290 = load double, double* %289
%291 = getelementptr inbounds double, double* %16, i64 %288
store double %290, double* %291
%292 = add nuw nsw i64 %272, 4
%293 = icmp eq i64 %292, %102
br i1 %293, label %294, label %271
294: ; preds = %268, %271, %253
%295 = add nuw nsw i64 %174, 1
%296 = icmp eq i64 %295, %102
br i1 %296, label %297, label %173
297: ; preds = %294
%298 = add nuw nsw i32 %146, 1
%299 = icmp eq i32 %298, %3
br i1 %299, label %148, label %145
300: ; preds = %148, %574
%301 = phi i32 [ 0, %148 ], [ %575, %574 ]
br i1 %150, label %324, label %574
302: ; preds = %574
br i1 %27, label %303, label %854
303: ; preds = %302
%304 = zext i32 %3 to i64
%305 = getelementptr double, double* %14, i64 %304
%306 = getelementptr double, double* %8, i64 %304
%307 = and i64 %304, 4294967292
%308 = add nsw i64 %307, -4
%309 = lshr exact i64 %308, 2
%310 = add nuw nsw i64 %309, 1
%311 = icmp ult i32 %3, 4
%312 = icmp ugt double* %306, %14
%313 = icmp ugt double* %305, %8
%314 = and i1 %312, %313
%315 = and i64 %304, 4294967292
%316 = and i64 %310, 3
%317 = icmp ult i64 %308, 12
%318 = and i64 %310, 9223372036854775804
%319 = icmp eq i64 %316, 0
%320 = icmp eq i64 %315, %304
%321 = and i64 %304, 3
%322 = icmp eq i64 %321, 0
br label %577
323: ; preds = %466
br i1 %150, label %468, label %574
324: ; preds = %300, %466
%325 = phi i64 [ %331, %466 ], [ 1, %300 ]
%326 = trunc i64 %325 to i32
%327 = mul i32 %4, %326
%328 = trunc i64 %325 to i32
%329 = add i32 %328, -1
%330 = mul i32 %4, %329
%331 = add nuw nsw i64 %325, 1
%332 = trunc i64 %331 to i32
%333 = mul i32 %4, %332
%334 = sext i32 %327 to i64
%335 = sext i32 %330 to i64
%336 = sext i32 %333 to i64
br label %337
337: ; preds = %464, %324
%338 = phi i64 [ 1, %324 ], [ %342, %464 ]
%339 = add nsw i64 %338, -1
%340 = mul nsw i64 %339, %151
%341 = add nsw i64 %340, %334
%342 = add nuw nsw i64 %338, 1
%343 = mul nsw i64 %342, %151
%344 = add nsw i64 %343, %334
%345 = mul nsw i64 %338, %151
%346 = add nsw i64 %345, %335
%347 = add nsw i64 %345, %336
%348 = add nsw i64 %340, %335
%349 = add nsw i64 %343, %335
%350 = add nsw i64 %340, %336
%351 = add nsw i64 %343, %336
%352 = add nsw i64 %345, %334
br label %353
353: ; preds = %337, %353
%354 = phi i64 [ 1, %337 ], [ %419, %353 ]
%355 = add nsw i64 %354, %341
%356 = getelementptr inbounds double, double* %8, i64 %355
%357 = load double, double* %356
%358 = add nsw i64 %354, %344
%359 = getelementptr inbounds double, double* %8, i64 %358
%360 = load double, double* %359
%361 = fadd double %357, %360
%362 = add nsw i64 %354, %346
%363 = getelementptr inbounds double, double* %8, i64 %362
%364 = load double, double* %363
%365 = fadd double %361, %364
%366 = add nsw i64 %354, %347
%367 = getelementptr inbounds double, double* %8, i64 %366
%368 = load double, double* %367
%369 = fadd double %365, %368
%370 = add nsw i64 %354, %348
%371 = getelementptr inbounds double, double* %8, i64 %370
%372 = load double, double* %371
%373 = fadd double %369, %372
%374 = add nsw i64 %354, %349
%375 = getelementptr inbounds double, double* %8, i64 %374
%376 = load double, double* %375
%377 = fadd double %373, %376
%378 = add nsw i64 %354, %350
%379 = getelementptr inbounds double, double* %8, i64 %378
%380 = load double, double* %379
%381 = fadd double %377, %380
%382 = add nsw i64 %354, %351
%383 = getelementptr inbounds double, double* %8, i64 %382
%384 = load double, double* %383
%385 = fadd double %381, %384
%386 = add nsw i64 %354, -1
%387 = add nsw i64 %386, %341
%388 = getelementptr inbounds double, double* %8, i64 %387
%389 = load double, double* %388
%390 = fadd double %385, %389
%391 = add nsw i64 %386, %344
%392 = getelementptr inbounds double, double* %8, i64 %391
%393 = load double, double* %392
%394 = fadd double %390, %393
%395 = add nsw i64 %386, %346
%396 = getelementptr inbounds double, double* %8, i64 %395
%397 = load double, double* %396
%398 = fadd double %394, %397
%399 = add nsw i64 %386, %347
%400 = getelementptr inbounds double, double* %8, i64 %399
%401 = load double, double* %400
%402 = fadd double %398, %401
%403 = add nsw i64 %386, %348
%404 = getelementptr inbounds double, double* %8, i64 %403
%405 = load double, double* %404
%406 = fadd double %402, %405
%407 = add nsw i64 %386, %349
%408 = getelementptr inbounds double, double* %8, i64 %407
%409 = load double, double* %408
%410 = fadd double %406, %409
%411 = add nsw i64 %386, %350
%412 = getelementptr inbounds double, double* %8, i64 %411
%413 = load double, double* %412
%414 = fadd double %410, %413
%415 = add nsw i64 %386, %351
%416 = getelementptr inbounds double, double* %8, i64 %415
%417 = load double, double* %416
%418 = fadd double %414, %417
%419 = add nuw nsw i64 %354, 1
%420 = add nsw i64 %419, %341
%421 = getelementptr inbounds double, double* %8, i64 %420
%422 = load double, double* %421
%423 = fadd double %418, %422
%424 = add nsw i64 %419, %344
%425 = getelementptr inbounds double, double* %8, i64 %424
%426 = load double, double* %425
%427 = fadd double %423, %426
%428 = add nsw i64 %419, %346
%429 = getelementptr inbounds double, double* %8, i64 %428
%430 = load double, double* %429
%431 = fadd double %427, %430
%432 = add nsw i64 %419, %347
%433 = getelementptr inbounds double, double* %8, i64 %432
%434 = load double, double* %433
%435 = fadd double %431, %434
%436 = add nsw i64 %419, %348
%437 = getelementptr inbounds double, double* %8, i64 %436
%438 = load double, double* %437
%439 = fadd double %435, %438
%440 = add nsw i64 %419, %349
%441 = getelementptr inbounds double, double* %8, i64 %440
%442 = load double, double* %441
%443 = fadd double %439, %442
%444 = add nsw i64 %419, %350
%445 = getelementptr inbounds double, double* %8, i64 %444
%446 = load double, double* %445
%447 = fadd double %443, %446
%448 = add nsw i64 %419, %351
%449 = getelementptr inbounds double, double* %8, i64 %448
%450 = load double, double* %449
%451 = fadd double %447, %450
%452 = add nsw i64 %386, %352
%453 = getelementptr inbounds double, double* %8, i64 %452
%454 = load double, double* %453
%455 = fadd double %451, %454
%456 = add nsw i64 %419, %352
%457 = getelementptr inbounds double, double* %8, i64 %456
%458 = load double, double* %457
%459 = fadd double %455, %458
%460 = fmul double %459, 0x3FA3B13B13B13B14
%461 = add nsw i64 %354, %352
%462 = getelementptr inbounds double, double* %12, i64 %461
store double %460, double* %462
%463 = icmp eq i64 %419, %152
br i1 %463, label %464, label %353
464: ; preds = %353
%465 = icmp eq i64 %342, %152
br i1 %465, label %466, label %337
466: ; preds = %464
%467 = icmp eq i64 %331, %152
br i1 %467, label %323, label %324
468: ; preds = %323, %571
%469 = phi i32 [ %572, %571 ], [ 1, %323 ]
%470 = mul nsw i32 %469, %3
br label %471
471: ; preds = %568, %468
%472 = phi i64 [ %569, %568 ], [ 1, %468 ]
%473 = trunc i64 %472 to i32
%474 = add i32 %470, %473
%475 = mul i32 %474, %3
%476 = sext i32 %475 to i64
%477 = select i1 %162, i1 true, i1 %165
br i1 %477, label %525, label %478
478: ; preds = %471
br i1 %169, label %509, label %479
479: ; preds = %478, %479
%480 = phi i64 [ %506, %479 ], [ 0, %478 ]
%481 = phi i64 [ %507, %479 ], [ 0, %478 ]
%482 = or i64 %480, 1
%483 = add nsw i64 %482, %476
%484 = getelementptr inbounds double, double* %12, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds double, double* %8, i64 %483
%491 = bitcast double* %490 to <2 x double>*
store <2 x double> %486, <2 x double>* %491
%492 = getelementptr inbounds double, double* %490, i64 2
%493 = bitcast double* %492 to <2 x double>*
store <2 x double> %489, <2 x double>* %493
%494 = or i64 %480, 5
%495 = add nsw i64 %494, %476
%496 = getelementptr inbounds double, double* %12, i64 %495
%497 = bitcast double* %496 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497
%499 = getelementptr inbounds double, double* %496, i64 2
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = getelementptr inbounds double, double* %8, i64 %495
%503 = bitcast double* %502 to <2 x double>*
store <2 x double> %498, <2 x double>* %503
%504 = getelementptr inbounds double, double* %502, i64 2
%505 = bitcast double* %504 to <2 x double>*
store <2 x double> %501, <2 x double>* %505
%506 = add nuw i64 %480, 8
%507 = add i64 %481, 2
%508 = icmp eq i64 %507, %170
br i1 %508, label %509, label %479
509: ; preds = %479, %478
%510 = phi i64 [ 0, %478 ], [ %506, %479 ]
br i1 %171, label %524, label %511
511: ; preds = %509
%512 = or i64 %510, 1
%513 = add nsw i64 %512, %476
%514 = getelementptr inbounds double, double* %12, i64 %513
%515 = bitcast double* %514 to <2 x double>*
%516 = load <2 x double>, <2 x double>* %515
%517 = getelementptr inbounds double, double* %514, i64 2
%518 = bitcast double* %517 to <2 x double>*
%519 = load <2 x double>, <2 x double>* %518
%520 = getelementptr inbounds double, double* %8, i64 %513
%521 = bitcast double* %520 to <2 x double>*
store <2 x double> %516, <2 x double>* %521
%522 = getelementptr inbounds double, double* %520, i64 2
%523 = bitcast double* %522 to <2 x double>*
store <2 x double> %519, <2 x double>* %523
br label %524
524: ; preds = %509, %511
br i1 %172, label %568, label %525
525: ; preds = %471, %524
%526 = phi i64 [ 1, %471 ], [ %167, %524 ]
%527 = sub nsw i64 %152, %526
%528 = xor i64 %526, -1
%529 = add nsw i64 %528, %152
%530 = and i64 %527, 3
%531 = icmp eq i64 %530, 0
br i1 %531, label %542, label %532
532: ; preds = %525, %532
%533 = phi i64 [ %539, %532 ], [ %526, %525 ]
%534 = phi i64 [ %540, %532 ], [ 0, %525 ]
%535 = add nsw i64 %533, %476
%536 = getelementptr inbounds double, double* %12, i64 %535
%537 = load double, double* %536
%538 = getelementptr inbounds double, double* %8, i64 %535
store double %537, double* %538
%539 = add nuw nsw i64 %533, 1
%540 = add i64 %534, 1
%541 = icmp eq i64 %540, %530
br i1 %541, label %542, label %532
542: ; preds = %532, %525
%543 = phi i64 [ %526, %525 ], [ %539, %532 ]
%544 = icmp ult i64 %529, 3
br i1 %544, label %568, label %545
545: ; preds = %542, %545
%546 = phi i64 [ %566, %545 ], [ %543, %542 ]
%547 = add nsw i64 %546, %476
%548 = getelementptr inbounds double, double* %12, i64 %547
%549 = load double, double* %548
%550 = getelementptr inbounds double, double* %8, i64 %547
store double %549, double* %550
%551 = add nuw nsw i64 %546, 1
%552 = add nsw i64 %551, %476
%553 = getelementptr inbounds double, double* %12, i64 %552
%554 = load double, double* %553
%555 = getelementptr inbounds double, double* %8, i64 %552
store double %554, double* %555
%556 = add nuw nsw i64 %546, 2
%557 = add nsw i64 %556, %476
%558 = getelementptr inbounds double, double* %12, i64 %557
%559 = load double, double* %558
%560 = getelementptr inbounds double, double* %8, i64 %557
store double %559, double* %560
%561 = add nuw nsw i64 %546, 3
%562 = add nsw i64 %561, %476
%563 = getelementptr inbounds double, double* %12, i64 %562
%564 = load double, double* %563
%565 = getelementptr inbounds double, double* %8, i64 %562
store double %564, double* %565
%566 = add nuw nsw i64 %546, 4
%567 = icmp eq i64 %566, %153
br i1 %567, label %568, label %545
568: ; preds = %542, %545, %524
%569 = add nuw nsw i64 %472, 1
%570 = icmp eq i64 %569, %153
br i1 %570, label %571, label %471
571: ; preds = %568
%572 = add nuw nsw i32 %469, 1
%573 = icmp eq i32 %572, %149
br i1 %573, label %574, label %468
574: ; preds = %571, %300, %323
%575 = add nuw nsw i32 %301, 1
%576 = icmp eq i32 %575, 10
br i1 %576, label %302, label %300
577: ; preds = %721, %303
%578 = phi i32 [ %722, %721 ], [ 0, %303 ]
%579 = mul nsw i32 %578, %3
br label %597
580: ; preds = %721
br i1 %27, label %581, label %854
581: ; preds = %580
%582 = zext i32 %3 to i64
%583 = getelementptr double, double* %8, i64 %304
%584 = getelementptr double, double* %16, i64 %304
%585 = icmp ult i32 %3, 4
%586 = icmp ugt double* %584, %8
%587 = icmp ugt double* %583, %16
%588 = and i1 %586, %587
%589 = and i64 %304, 4294967292
%590 = and i64 %310, 3
%591 = icmp ult i64 %308, 12
%592 = and i64 %310, 9223372036854775804
%593 = icmp eq i64 %590, 0
%594 = icmp eq i64 %589, %304
%595 = and i64 %304, 3
%596 = icmp eq i64 %595, 0
br label %724
597: ; preds = %718, %577
%598 = phi i64 [ 0, %577 ], [ %719, %718 ]
%599 = trunc i64 %598 to i32
%600 = add i32 %579, %599
%601 = mul i32 %600, %3
%602 = sext i32 %601 to i64
%603 = select i1 %311, i1 true, i1 %314
br i1 %603, label %678, label %604
604: ; preds = %597
br i1 %317, label %658, label %605
605: ; preds = %604, %605
%606 = phi i64 [ %655, %605 ], [ 0, %604 ]
%607 = phi i64 [ %656, %605 ], [ 0, %604 ]
%608 = add nsw i64 %606, %602
%609 = getelementptr inbounds double, double* %8, i64 %608
%610 = bitcast double* %609 to <2 x double>*
%611 = load <2 x double>, <2 x double>* %610
%612 = getelementptr inbounds double, double* %609, i64 2
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds double, double* %14, i64 %608
%616 = bitcast double* %615 to <2 x double>*
store <2 x double> %611, <2 x double>* %616
%617 = getelementptr inbounds double, double* %615, i64 2
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %614, <2 x double>* %618
%619 = or i64 %606, 4
%620 = add nsw i64 %619, %602
%621 = getelementptr inbounds double, double* %8, i64 %620
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = getelementptr inbounds double, double* %621, i64 2
%625 = bitcast double* %624 to <2 x double>*
%626 = load <2 x double>, <2 x double>* %625
%627 = getelementptr inbounds double, double* %14, i64 %620
%628 = bitcast double* %627 to <2 x double>*
store <2 x double> %623, <2 x double>* %628
%629 = getelementptr inbounds double, double* %627, i64 2
%630 = bitcast double* %629 to <2 x double>*
store <2 x double> %626, <2 x double>* %630
%631 = or i64 %606, 8
%632 = add nsw i64 %631, %602
%633 = getelementptr inbounds double, double* %8, i64 %632
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %633, i64 2
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = getelementptr inbounds double, double* %14, i64 %632
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %635, <2 x double>* %640
%641 = getelementptr inbounds double, double* %639, i64 2
%642 = bitcast double* %641 to <2 x double>*
store <2 x double> %638, <2 x double>* %642
%643 = or i64 %606, 12
%644 = add nsw i64 %643, %602
%645 = getelementptr inbounds double, double* %8, i64 %644
%646 = bitcast double* %645 to <2 x double>*
%647 = load <2 x double>, <2 x double>* %646
%648 = getelementptr inbounds double, double* %645, i64 2
%649 = bitcast double* %648 to <2 x double>*
%650 = load <2 x double>, <2 x double>* %649
%651 = getelementptr inbounds double, double* %14, i64 %644
%652 = bitcast double* %651 to <2 x double>*
store <2 x double> %647, <2 x double>* %652
%653 = getelementptr inbounds double, double* %651, i64 2
%654 = bitcast double* %653 to <2 x double>*
store <2 x double> %650, <2 x double>* %654
%655 = add nuw i64 %606, 16
%656 = add nuw i64 %607, 4
%657 = icmp eq i64 %656, %318
br i1 %657, label %658, label %605
658: ; preds = %605, %604
%659 = phi i64 [ 0, %604 ], [ %655, %605 ]
br i1 %319, label %677, label %660
660: ; preds = %658, %660
%661 = phi i64 [ %674, %660 ], [ %659, %658 ]
%662 = phi i64 [ %675, %660 ], [ 0, %658 ]
%663 = add nsw i64 %661, %602
%664 = getelementptr inbounds double, double* %8, i64 %663
%665 = bitcast double* %664 to <2 x double>*
%666 = load <2 x double>, <2 x double>* %665
%667 = getelementptr inbounds double, double* %664, i64 2
%668 = bitcast double* %667 to <2 x double>*
%669 = load <2 x double>, <2 x double>* %668
%670 = getelementptr inbounds double, double* %14, i64 %663
%671 = bitcast double* %670 to <2 x double>*
store <2 x double> %666, <2 x double>* %671
%672 = getelementptr inbounds double, double* %670, i64 2
%673 = bitcast double* %672 to <2 x double>*
store <2 x double> %669, <2 x double>* %673
%674 = add nuw i64 %661, 4
%675 = add i64 %662, 1
%676 = icmp eq i64 %675, %316
br i1 %676, label %677, label %660
677: ; preds = %660, %658
br i1 %320, label %718, label %678
678: ; preds = %597, %677
%679 = phi i64 [ 0, %597 ], [ %315, %677 ]
%680 = xor i64 %679, -1
%681 = add nsw i64 %680, %304
br i1 %322, label %692, label %682
682: ; preds = %678, %682
%683 = phi i64 [ %689, %682 ], [ %679, %678 ]
%684 = phi i64 [ %690, %682 ], [ 0, %678 ]
%685 = add nsw i64 %683, %602
%686 = getelementptr inbounds double, double* %8, i64 %685
%687 = load double, double* %686
%688 = getelementptr inbounds double, double* %14, i64 %685
store double %687, double* %688
%689 = add nuw nsw i64 %683, 1
%690 = add i64 %684, 1
%691 = icmp eq i64 %690, %321
br i1 %691, label %692, label %682
692: ; preds = %682, %678
%693 = phi i64 [ %679, %678 ], [ %689, %682 ]
%694 = icmp ult i64 %681, 3
br i1 %694, label %718, label %695
695: ; preds = %692, %695
%696 = phi i64 [ %716, %695 ], [ %693, %692 ]
%697 = add nsw i64 %696, %602
%698 = getelementptr inbounds double, double* %8, i64 %697
%699 = load double, double* %698
%700 = getelementptr inbounds double, double* %14, i64 %697
store double %699, double* %700
%701 = add nuw nsw i64 %696, 1
%702 = add nsw i64 %701, %602
%703 = getelementptr inbounds double, double* %8, i64 %702
%704 = load double, double* %703
%705 = getelementptr inbounds double, double* %14, i64 %702
store double %704, double* %705
%706 = add nuw nsw i64 %696, 2
%707 = add nsw i64 %706, %602
%708 = getelementptr inbounds double, double* %8, i64 %707
%709 = load double, double* %708
%710 = getelementptr inbounds double, double* %14, i64 %707
store double %709, double* %710
%711 = add nuw nsw i64 %696, 3
%712 = add nsw i64 %711, %602
%713 = getelementptr inbounds double, double* %8, i64 %712
%714 = load double, double* %713
%715 = getelementptr inbounds double, double* %14, i64 %712
store double %714, double* %715
%716 = add nuw nsw i64 %696, 4
%717 = icmp eq i64 %716, %304
br i1 %717, label %718, label %695
718: ; preds = %692, %695, %677
%719 = add nuw nsw i64 %598, 1
%720 = icmp eq i64 %719, %304
br i1 %720, label %721, label %597
721: ; preds = %718
%722 = add nuw nsw i32 %578, 1
%723 = icmp eq i32 %722, %3
br i1 %723, label %580, label %577
724: ; preds = %851, %581
%725 = phi i32 [ %852, %851 ], [ 0, %581 ]
%726 = mul nsw i32 %725, %3
br label %727
727: ; preds = %848, %724
%728 = phi i64 [ 0, %724 ], [ %849, %848 ]
%729 = trunc i64 %728 to i32
%730 = add i32 %726, %729
%731 = mul i32 %730, %3
%732 = sext i32 %731 to i64
%733 = select i1 %585, i1 true, i1 %588
br i1 %733, label %808, label %734
734: ; preds = %727
br i1 %591, label %788, label %735
735: ; preds = %734, %735
%736 = phi i64 [ %785, %735 ], [ 0, %734 ]
%737 = phi i64 [ %786, %735 ], [ 0, %734 ]
%738 = add nsw i64 %736, %732
%739 = getelementptr inbounds double, double* %16, i64 %738
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = getelementptr inbounds double, double* %739, i64 2
%743 = bitcast double* %742 to <2 x double>*
%744 = load <2 x double>, <2 x double>* %743
%745 = getelementptr inbounds double, double* %8, i64 %738
%746 = bitcast double* %745 to <2 x double>*
store <2 x double> %741, <2 x double>* %746
%747 = getelementptr inbounds double, double* %745, i64 2
%748 = bitcast double* %747 to <2 x double>*
store <2 x double> %744, <2 x double>* %748
%749 = or i64 %736, 4
%750 = add nsw i64 %749, %732
%751 = getelementptr inbounds double, double* %16, i64 %750
%752 = bitcast double* %751 to <2 x double>*
%753 = load <2 x double>, <2 x double>* %752
%754 = getelementptr inbounds double, double* %751, i64 2
%755 = bitcast double* %754 to <2 x double>*
%756 = load <2 x double>, <2 x double>* %755
%757 = getelementptr inbounds double, double* %8, i64 %750
%758 = bitcast double* %757 to <2 x double>*
store <2 x double> %753, <2 x double>* %758
%759 = getelementptr inbounds double, double* %757, i64 2
%760 = bitcast double* %759 to <2 x double>*
store <2 x double> %756, <2 x double>* %760
%761 = or i64 %736, 8
%762 = add nsw i64 %761, %732
%763 = getelementptr inbounds double, double* %16, i64 %762
%764 = bitcast double* %763 to <2 x double>*
%765 = load <2 x double>, <2 x double>* %764
%766 = getelementptr inbounds double, double* %763, i64 2
%767 = bitcast double* %766 to <2 x double>*
%768 = load <2 x double>, <2 x double>* %767
%769 = getelementptr inbounds double, double* %8, i64 %762
%770 = bitcast double* %769 to <2 x double>*
store <2 x double> %765, <2 x double>* %770
%771 = getelementptr inbounds double, double* %769, i64 2
%772 = bitcast double* %771 to <2 x double>*
store <2 x double> %768, <2 x double>* %772
%773 = or i64 %736, 12
%774 = add nsw i64 %773, %732
%775 = getelementptr inbounds double, double* %16, i64 %774
%776 = bitcast double* %775 to <2 x double>*
%777 = load <2 x double>, <2 x double>* %776
%778 = getelementptr inbounds double, double* %775, i64 2
%779 = bitcast double* %778 to <2 x double>*
%780 = load <2 x double>, <2 x double>* %779
%781 = getelementptr inbounds double, double* %8, i64 %774
%782 = bitcast double* %781 to <2 x double>*
store <2 x double> %777, <2 x double>* %782
%783 = getelementptr inbounds double, double* %781, i64 2
%784 = bitcast double* %783 to <2 x double>*
store <2 x double> %780, <2 x double>* %784
%785 = add nuw i64 %736, 16
%786 = add nuw i64 %737, 4
%787 = icmp eq i64 %786, %592
br i1 %787, label %788, label %735
788: ; preds = %735, %734
%789 = phi i64 [ 0, %734 ], [ %785, %735 ]
br i1 %593, label %807, label %790
790: ; preds = %788, %790
%791 = phi i64 [ %804, %790 ], [ %789, %788 ]
%792 = phi i64 [ %805, %790 ], [ 0, %788 ]
%793 = add nsw i64 %791, %732
%794 = getelementptr inbounds double, double* %16, i64 %793
%795 = bitcast double* %794 to <2 x double>*
%796 = load <2 x double>, <2 x double>* %795
%797 = getelementptr inbounds double, double* %794, i64 2
%798 = bitcast double* %797 to <2 x double>*
%799 = load <2 x double>, <2 x double>* %798
%800 = getelementptr inbounds double, double* %8, i64 %793
%801 = bitcast double* %800 to <2 x double>*
store <2 x double> %796, <2 x double>* %801
%802 = getelementptr inbounds double, double* %800, i64 2
%803 = bitcast double* %802 to <2 x double>*
store <2 x double> %799, <2 x double>* %803
%804 = add nuw i64 %791, 4
%805 = add i64 %792, 1
%806 = icmp eq i64 %805, %590
br i1 %806, label %807, label %790
807: ; preds = %790, %788
br i1 %594, label %848, label %808
808: ; preds = %727, %807
%809 = phi i64 [ 0, %727 ], [ %589, %807 ]
%810 = xor i64 %809, -1
%811 = add nsw i64 %810, %304
br i1 %596, label %822, label %812
812: ; preds = %808, %812
%813 = phi i64 [ %819, %812 ], [ %809, %808 ]
%814 = phi i64 [ %820, %812 ], [ 0, %808 ]
%815 = add nsw i64 %813, %732
%816 = getelementptr inbounds double, double* %16, i64 %815
%817 = load double, double* %816
%818 = getelementptr inbounds double, double* %8, i64 %815
store double %817, double* %818
%819 = add nuw nsw i64 %813, 1
%820 = add i64 %814, 1
%821 = icmp eq i64 %820, %595
br i1 %821, label %822, label %812
822: ; preds = %812, %808
%823 = phi i64 [ %809, %808 ], [ %819, %812 ]
%824 = icmp ult i64 %811, 3
br i1 %824, label %848, label %825
825: ; preds = %822, %825
%826 = phi i64 [ %846, %825 ], [ %823, %822 ]
%827 = add nsw i64 %826, %732
%828 = getelementptr inbounds double, double* %16, i64 %827
%829 = load double, double* %828
%830 = getelementptr inbounds double, double* %8, i64 %827
store double %829, double* %830
%831 = add nuw nsw i64 %826, 1
%832 = add nsw i64 %831, %732
%833 = getelementptr inbounds double, double* %16, i64 %832
%834 = load double, double* %833
%835 = getelementptr inbounds double, double* %8, i64 %832
store double %834, double* %835
%836 = add nuw nsw i64 %826, 2
%837 = add nsw i64 %836, %732
%838 = getelementptr inbounds double, double* %16, i64 %837
%839 = load double, double* %838
%840 = getelementptr inbounds double, double* %8, i64 %837
store double %839, double* %840
%841 = add nuw nsw i64 %826, 3
%842 = add nsw i64 %841, %732
%843 = getelementptr inbounds double, double* %16, i64 %842
%844 = load double, double* %843
%845 = getelementptr inbounds double, double* %8, i64 %842
store double %844, double* %845
%846 = add nuw nsw i64 %826, 4
%847 = icmp eq i64 %846, %582
br i1 %847, label %848, label %825
848: ; preds = %822, %825, %807
%849 = add nuw nsw i64 %728, 1
%850 = icmp eq i64 %849, %582
br i1 %850, label %851, label %727
851: ; preds = %848
%852 = add nuw nsw i32 %725, 1
%853 = icmp eq i32 %852, %3
br i1 %853, label %854, label %724
854: ; preds = %851, %302, %580
%855 = tail call double (...) @omp_get_wtime()
%856 = zext i32 %149 to i64
%857 = zext i32 %149 to i64
%858 = getelementptr double, double* %8, i64 1
%859 = getelementptr double, double* %8, i64 %152
%860 = getelementptr double, double* %12, i64 1
%861 = getelementptr double, double* %12, i64 %152
%862 = add nsw i64 %152, -1
%863 = icmp ult i64 %862, 4
%864 = icmp ult double* %858, %861
%865 = icmp ult double* %860, %859
%866 = and i1 %864, %865
%867 = and i64 %862, -4
%868 = or i64 %867, 1
%869 = and i64 %161, 1
%870 = icmp ult i64 %159, 4
%871 = and i64 %161, 9223372036854775806
%872 = icmp eq i64 %869, 0
%873 = icmp eq i64 %862, %867
br label %874
874: ; preds = %854, %1127
%875 = phi i32 [ 0, %854 ], [ %1128, %1127 ]
br i1 %150, label %877, label %1127
876: ; preds = %1019
br i1 %150, label %1021, label %1127
877: ; preds = %874, %1019
%878 = phi i64 [ %884, %1019 ], [ 1, %874 ]
%879 = trunc i64 %878 to i32
%880 = mul i32 %4, %879
%881 = trunc i64 %878 to i32
%882 = add i32 %881, -1
%883 = mul i32 %4, %882
%884 = add nuw nsw i64 %878, 1
%885 = trunc i64 %884 to i32
%886 = mul i32 %4, %885
%887 = sext i32 %880 to i64
%888 = sext i32 %883 to i64
%889 = sext i32 %886 to i64
br label %890
890: ; preds = %1017, %877
%891 = phi i64 [ 1, %877 ], [ %895, %1017 ]
%892 = add nsw i64 %891, -1
%893 = mul nsw i64 %892, %151
%894 = add nsw i64 %893, %887
%895 = add nuw nsw i64 %891, 1
%896 = mul nsw i64 %895, %151
%897 = add nsw i64 %896, %887
%898 = mul nsw i64 %891, %151
%899 = add nsw i64 %898, %888
%900 = add nsw i64 %898, %889
%901 = add nsw i64 %893, %888
%902 = add nsw i64 %896, %888
%903 = add nsw i64 %893, %889
%904 = add nsw i64 %896, %889
%905 = add nsw i64 %898, %887
br label %906
906: ; preds = %890, %906
%907 = phi i64 [ 1, %890 ], [ %972, %906 ]
%908 = add nsw i64 %907, %894
%909 = getelementptr inbounds double, double* %8, i64 %908
%910 = load double, double* %909
%911 = add nsw i64 %907, %897
%912 = getelementptr inbounds double, double* %8, i64 %911
%913 = load double, double* %912
%914 = fadd double %910, %913
%915 = add nsw i64 %907, %899
%916 = getelementptr inbounds double, double* %8, i64 %915
%917 = load double, double* %916
%918 = fadd double %914, %917
%919 = add nsw i64 %907, %900
%920 = getelementptr inbounds double, double* %8, i64 %919
%921 = load double, double* %920
%922 = fadd double %918, %921
%923 = add nsw i64 %907, %901
%924 = getelementptr inbounds double, double* %8, i64 %923
%925 = load double, double* %924
%926 = fadd double %922, %925
%927 = add nsw i64 %907, %902
%928 = getelementptr inbounds double, double* %8, i64 %927
%929 = load double, double* %928
%930 = fadd double %926, %929
%931 = add nsw i64 %907, %903
%932 = getelementptr inbounds double, double* %8, i64 %931
%933 = load double, double* %932
%934 = fadd double %930, %933
%935 = add nsw i64 %907, %904
%936 = getelementptr inbounds double, double* %8, i64 %935
%937 = load double, double* %936
%938 = fadd double %934, %937
%939 = add nsw i64 %907, -1
%940 = add nsw i64 %939, %894
%941 = getelementptr inbounds double, double* %8, i64 %940
%942 = load double, double* %941
%943 = fadd double %938, %942
%944 = add nsw i64 %939, %897
%945 = getelementptr inbounds double, double* %8, i64 %944
%946 = load double, double* %945
%947 = fadd double %943, %946
%948 = add nsw i64 %939, %899
%949 = getelementptr inbounds double, double* %8, i64 %948
%950 = load double, double* %949
%951 = fadd double %947, %950
%952 = add nsw i64 %939, %900
%953 = getelementptr inbounds double, double* %8, i64 %952
%954 = load double, double* %953
%955 = fadd double %951, %954
%956 = add nsw i64 %939, %901
%957 = getelementptr inbounds double, double* %8, i64 %956
%958 = load double, double* %957
%959 = fadd double %955, %958
%960 = add nsw i64 %939, %902
%961 = getelementptr inbounds double, double* %8, i64 %960
%962 = load double, double* %961
%963 = fadd double %959, %962
%964 = add nsw i64 %939, %903
%965 = getelementptr inbounds double, double* %8, i64 %964
%966 = load double, double* %965
%967 = fadd double %963, %966
%968 = add nsw i64 %939, %904
%969 = getelementptr inbounds double, double* %8, i64 %968
%970 = load double, double* %969
%971 = fadd double %967, %970
%972 = add nuw nsw i64 %907, 1
%973 = add nsw i64 %972, %894
%974 = getelementptr inbounds double, double* %8, i64 %973
%975 = load double, double* %974
%976 = fadd double %971, %975
%977 = add nsw i64 %972, %897
%978 = getelementptr inbounds double, double* %8, i64 %977
%979 = load double, double* %978
%980 = fadd double %976, %979
%981 = add nsw i64 %972, %899
%982 = getelementptr inbounds double, double* %8, i64 %981
%983 = load double, double* %982
%984 = fadd double %980, %983
%985 = add nsw i64 %972, %900
%986 = getelementptr inbounds double, double* %8, i64 %985
%987 = load double, double* %986
%988 = fadd double %984, %987
%989 = add nsw i64 %972, %901
%990 = getelementptr inbounds double, double* %8, i64 %989
%991 = load double, double* %990
%992 = fadd double %988, %991
%993 = add nsw i64 %972, %902
%994 = getelementptr inbounds double, double* %8, i64 %993
%995 = load double, double* %994
%996 = fadd double %992, %995
%997 = add nsw i64 %972, %903
%998 = getelementptr inbounds double, double* %8, i64 %997
%999 = load double, double* %998
%1000 = fadd double %996, %999
%1001 = add nsw i64 %972, %904
%1002 = getelementptr inbounds double, double* %8, i64 %1001
%1003 = load double, double* %1002
%1004 = fadd double %1000, %1003
%1005 = add nsw i64 %939, %905
%1006 = getelementptr inbounds double, double* %8, i64 %1005
%1007 = load double, double* %1006
%1008 = fadd double %1004, %1007
%1009 = add nsw i64 %972, %905
%1010 = getelementptr inbounds double, double* %8, i64 %1009
%1011 = load double, double* %1010
%1012 = fadd double %1008, %1011
%1013 = fmul double %1012, 0x3FA3B13B13B13B14
%1014 = add nsw i64 %907, %905
%1015 = getelementptr inbounds double, double* %12, i64 %1014
store double %1013, double* %1015
%1016 = icmp eq i64 %972, %856
br i1 %1016, label %1017, label %906
1017: ; preds = %906
%1018 = icmp eq i64 %895, %856
br i1 %1018, label %1019, label %890
1019: ; preds = %1017
%1020 = icmp eq i64 %884, %856
br i1 %1020, label %876, label %877
1021: ; preds = %876, %1124
%1022 = phi i32 [ %1125, %1124 ], [ 1, %876 ]
%1023 = mul nsw i32 %1022, %3
br label %1024
1024: ; preds = %1121, %1021
%1025 = phi i64 [ %1122, %1121 ], [ 1, %1021 ]
%1026 = trunc i64 %1025 to i32
%1027 = add i32 %1023, %1026
%1028 = mul i32 %1027, %3
%1029 = sext i32 %1028 to i64
%1030 = select i1 %863, i1 true, i1 %866
br i1 %1030, label %1078, label %1031
1031: ; preds = %1024
br i1 %870, label %1062, label %1032
1032: ; preds = %1031, %1032
%1033 = phi i64 [ %1059, %1032 ], [ 0, %1031 ]
%1034 = phi i64 [ %1060, %1032 ], [ 0, %1031 ]
%1035 = or i64 %1033, 1
%1036 = add nsw i64 %1035, %1029
%1037 = getelementptr inbounds double, double* %12, i64 %1036
%1038 = bitcast double* %1037 to <2 x double>*
%1039 = load <2 x double>, <2 x double>* %1038
%1040 = getelementptr inbounds double, double* %1037, i64 2
%1041 = bitcast double* %1040 to <2 x double>*
%1042 = load <2 x double>, <2 x double>* %1041
%1043 = getelementptr inbounds double, double* %8, i64 %1036
%1044 = bitcast double* %1043 to <2 x double>*
store <2 x double> %1039, <2 x double>* %1044
%1045 = getelementptr inbounds double, double* %1043, i64 2
%1046 = bitcast double* %1045 to <2 x double>*
store <2 x double> %1042, <2 x double>* %1046
%1047 = or i64 %1033, 5
%1048 = add nsw i64 %1047, %1029
%1049 = getelementptr inbounds double, double* %12, i64 %1048
%1050 = bitcast double* %1049 to <2 x double>*
%1051 = load <2 x double>, <2 x double>* %1050
%1052 = getelementptr inbounds double, double* %1049, i64 2
%1053 = bitcast double* %1052 to <2 x double>*
%1054 = load <2 x double>, <2 x double>* %1053
%1055 = getelementptr inbounds double, double* %8, i64 %1048
%1056 = bitcast double* %1055 to <2 x double>*
store <2 x double> %1051, <2 x double>* %1056
%1057 = getelementptr inbounds double, double* %1055, i64 2
%1058 = bitcast double* %1057 to <2 x double>*
store <2 x double> %1054, <2 x double>* %1058
%1059 = add nuw i64 %1033, 8
%1060 = add i64 %1034, 2
%1061 = icmp eq i64 %1060, %871
br i1 %1061, label %1062, label %1032
1062: ; preds = %1032, %1031
%1063 = phi i64 [ 0, %1031 ], [ %1059, %1032 ]
br i1 %872, label %1077, label %1064
1064: ; preds = %1062
%1065 = or i64 %1063, 1
%1066 = add nsw i64 %1065, %1029
%1067 = getelementptr inbounds double, double* %12, i64 %1066
%1068 = bitcast double* %1067 to <2 x double>*
%1069 = load <2 x double>, <2 x double>* %1068
%1070 = getelementptr inbounds double, double* %1067, i64 2
%1071 = bitcast double* %1070 to <2 x double>*
%1072 = load <2 x double>, <2 x double>* %1071
%1073 = getelementptr inbounds double, double* %8, i64 %1066
%1074 = bitcast double* %1073 to <2 x double>*
store <2 x double> %1069, <2 x double>* %1074
%1075 = getelementptr inbounds double, double* %1073, i64 2
%1076 = bitcast double* %1075 to <2 x double>*
store <2 x double> %1072, <2 x double>* %1076
br label %1077
1077: ; preds = %1062, %1064
br i1 %873, label %1121, label %1078
1078: ; preds = %1024, %1077
%1079 = phi i64 [ 1, %1024 ], [ %868, %1077 ]
%1080 = sub nsw i64 %856, %1079
%1081 = xor i64 %1079, -1
%1082 = add nsw i64 %1081, %856
%1083 = and i64 %1080, 3
%1084 = icmp eq i64 %1083, 0
br i1 %1084, label %1095, label %1085
1085: ; preds = %1078, %1085
%1086 = phi i64 [ %1092, %1085 ], [ %1079, %1078 ]
%1087 = phi i64 [ %1093, %1085 ], [ 0, %1078 ]
%1088 = add nsw i64 %1086, %1029
%1089 = getelementptr inbounds double, double* %12, i64 %1088
%1090 = load double, double* %1089
%1091 = getelementptr inbounds double, double* %8, i64 %1088
store double %1090, double* %1091
%1092 = add nuw nsw i64 %1086, 1
%1093 = add i64 %1087, 1
%1094 = icmp eq i64 %1093, %1083
br i1 %1094, label %1095, label %1085
1095: ; preds = %1085, %1078
%1096 = phi i64 [ %1079, %1078 ], [ %1092, %1085 ]
%1097 = icmp ult i64 %1082, 3
br i1 %1097, label %1121, label %1098
1098: ; preds = %1095, %1098
%1099 = phi i64 [ %1119, %1098 ], [ %1096, %1095 ]
%1100 = add nsw i64 %1099, %1029
%1101 = getelementptr inbounds double, double* %12, i64 %1100
%1102 = load double, double* %1101
%1103 = getelementptr inbounds double, double* %8, i64 %1100
store double %1102, double* %1103
%1104 = add nuw nsw i64 %1099, 1
%1105 = add nsw i64 %1104, %1029
%1106 = getelementptr inbounds double, double* %12, i64 %1105
%1107 = load double, double* %1106
%1108 = getelementptr inbounds double, double* %8, i64 %1105
store double %1107, double* %1108
%1109 = add nuw nsw i64 %1099, 2
%1110 = add nsw i64 %1109, %1029
%1111 = getelementptr inbounds double, double* %12, i64 %1110
%1112 = load double, double* %1111
%1113 = getelementptr inbounds double, double* %8, i64 %1110
store double %1112, double* %1113
%1114 = add nuw nsw i64 %1099, 3
%1115 = add nsw i64 %1114, %1029
%1116 = getelementptr inbounds double, double* %12, i64 %1115
%1117 = load double, double* %1116
%1118 = getelementptr inbounds double, double* %8, i64 %1115
store double %1117, double* %1118
%1119 = add nuw nsw i64 %1099, 4
%1120 = icmp eq i64 %1119, %857
br i1 %1120, label %1121, label %1098
1121: ; preds = %1095, %1098, %1077
%1122 = add nuw nsw i64 %1025, 1
%1123 = icmp eq i64 %1122, %857
br i1 %1123, label %1124, label %1024
1124: ; preds = %1121
%1125 = add nuw nsw i32 %1022, 1
%1126 = icmp eq i32 %1125, %149
br i1 %1126, label %1127, label %1021
1127: ; preds = %1124, %874, %876
%1128 = add nuw nsw i32 %875, 1
%1129 = icmp eq i32 %1128, 10
br i1 %1129, label %1130, label %874
1130: ; preds = %1127
%1131 = tail call double (...) @omp_get_wtime()
%1132 = tail call i32 @memcpy(double* %10, double* %8, i32 %6)
%1133 = tail call double @max_diff(double* %14, double* %10, i32 %3)
%1134 = tail call i32 @free(double* %8)
%1135 = tail call i32 @free(double* %16)
%1136 = tail call i32 @free(double* %12)
%1137 = tail call i32 @free(double* %14)
%1138 = tail call i32 @free(double* %10)
%1139 = fcmp olt double %1133, 1.000000e-15
br i1 %1139, label %1140, label %1142
1140: ; preds = %1130
%1141 = fsub double %1131, %855
br label %1142
1142: ; preds = %1130, %0, %1140
%1143 = phi double [ %1141, %1140 ], [ -1.000000e+04, %0 ], [ -1.100000e+04, %1130 ]
ret double %1143
}