int main(int argc, char *argv[]) {
  int M = 200;
  int threadCount = -1;
  int c;
  extern char *optarg;
  const char *optstring = "n:p:";
  while ((c = getopt(argc, argv, optstring)) != -1) {
    switch (c) {
    case 'n':
      M = atoi(optarg);
      break;
    case 'p':
      threadCount = atoi(optarg);
      break;
    }
  }
  double alpha = 2.0;
  double waveNumber = 1.0;
  double alphaX = alpha;
  double alphaY = alpha;
  double waveNumberX = waveNumber;
  double waveNumberY = waveNumber;
  int xPanel = M;
  int yPanel = M;
  double xMin = 0.0;
  double xMax = 1.0;
  double yMin = 0.0;
  double yMax = 1.0;
  double hx = (xMax - xMin) / (double)xPanel;
  double hy = (yMax - yMin) / (double)yPanel;
  double dt_0 =
      4 * hx * hx / (alpha * 3.14159265358979323846 * 3.14159265358979323846);
  printf("\n==== Douglas ADI Program Start ====\n");
  printf("** alpha_x/alpha_y : %f/%f\n", alphaX, alphaY);
  printf("** X/Y Panel Count : %d/%d\n", xPanel, yPanel);
  int N = M + 1;
  double *f = (double *)_mm_malloc(N * N * sizeof(double), 64);
  double *uk = (double *)_mm_malloc(N * N * sizeof(double), 64);
  double *uLast = (double *)_mm_malloc(N * N * sizeof(double), 64);
  memset(uk, 0.0, N * N);
  double tol = 1.0e-6;
  __assume_aligned(f, 64);
  __assume_aligned(uk, 64);
  __assume_aligned(uLast, 64);
  double x;
  double y;
  for (int j = 0; j < N; j++) {
    y = yMin + j * hy;
    for (int i = 0; i < N; i++) {
      x = xMin + i * hx;
      f[j * N + i] = cos(2.0 * 3.14159265358979323846 * x * waveNumberX) *
                     cos(2.0 * 3.14159265358979323846 * y * waveNumberY);
    }
  }
  int index = 0;
  y = yMin + index * hy;
  for (int i = 0; i < N; i++) {
    x = xMin + i * hx;
    uk[i] = test_init(x, y, waveNumberX, waveNumberY, alphaX, alphaY);
    f[i] = 0.0;
  }
  index = M;
  y = yMin + index * hy;
  for (int i = 0; i < N; i++) {
    x = xMin + i * hx;
    uk[index * N + i] =
        test_init(x, y, waveNumberX, waveNumberY, alphaX, alphaY);
    f[index * N + i] = 0.0;
  }
  index = 0;
  x = xMin + index * hx;
  for (int i = 0; i < N; i++) {
    y = yMin + i * hy;
    uk[index + i * N] =
        test_init(x, y, waveNumberX, waveNumberY, alphaX, alphaY);
    f[index + i * N] = 0.0;
  }
  index = M;
  x = xMin + index * hx;
  for (int i = 0; i < N; i++) {
    y = yMin + i * hy;
    uk[index + i * N] =
        test_init(x, y, waveNumberX, waveNumberY, alphaX, alphaY);
    f[index + i * N] = 0.0;
  }
  double dt = dt_0;
  double ax = dt * alphaX / (hx * hx);
  double ay = dt * alphaY / (hy * hy);
  double bx = -2.0 * ax;
  double by = -2.0 * ay;
  const int maxSweepSize = (int)ceil(log(M) / log(2)) + 1;
  double diffNorm = 2 * tol;
  int iterMax = 200;
  int counter = 0;
  double ukNorm = 0;
  double *fstar =
      (double *)_mm_malloc(maxSweepSize * N * N * sizeof(double), 64);
  double *scratch = (double *)_mm_malloc(N * sizeof(double), 64);
  for (int i = 0; i < maxSweepSize; i++) {
    int offset = i * N * N;
    for (int j = 0; j < N * N; j++) {
      fstar[offset + j] = f[j] * dt;
    }
    dt *= 2 * 2;
  }
  double t0 = omp_get_wtime();
  int half_iteration = 0;
  while ((diffNorm > tol) && (counter < iterMax)) {
    memcpy(uLast, uk, N * N * sizeof(double));
    for (int j = 0; j < maxSweepSize; j++) {
      relaxOperation(uk, fstar + j * N * N, scratch, ax, bx, N);
      ax *= 2 * 2;
      bx *= 2 * 2;
    }
    ukNorm = normInf_cache(uk, N);
    for (int i = 0; i < N * N; i++) {
      uLast[i] -= uk[i];
    }
    diffNorm = normInf_cache(uLast, N) / ukNorm;
    if (diffNorm < tol) {
      half_iteration = 1;
      break;
    }
    memcpy(uLast, uk, N * N * sizeof(double));
    for (int j = maxSweepSize - 2; j > -1; j--) {
      ax /= 2 * 2;
      bx /= 2 * 2;
      relaxOperation(uk, fstar + j * N * N, scratch, ax, bx, N);
    }
    ukNorm = normInf_cache(uk, N);
    for (int i = 0; i < N * N; i++) {
      uLast[i] -= uk[i];
    }
    diffNorm = normInf_cache(uLast, N) / ukNorm;
    counter++;
  }
  double t1 = omp_get_wtime();
  _mm_free(scratch);
  _mm_free(fstar);
  _mm_free(f);
  _mm_free(uk);
  _mm_free(uLast);
  printf("==== Multi-scale Timstep Relaxation Output XXXX ====\n");
  printf("** Difference between iterates : \t%lf\n", diffNorm);
  printf("** Iteration Count for multi-scale time scheme :\t %d \n\n",
         counter * 2 * maxSweepSize + half_iteration * maxSweepSize);
  printf(
      "** Time it takes to solve the multi-scale timestep solution is %e s\n",
      t1 - t0);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xc8,-0x14(%rbp)
movl   $0xffffffff,-0x18(%rbp)
lea    0x1e1a(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    $0x0,%al
call   10e0 <getopt@plt>
mov    %eax,-0x1c(%rbp)
cmp    $0xffffffff,%eax
je     129d <main+0xad>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x184(%rbp)
sub    $0x6e,%eax
je     126b <main+0x7b>
jmp    1257 <main+0x67>
mov    -0x184(%rbp),%eax
sub    $0x70,%eax
je     1284 <main+0x94>
jmp    1298 <main+0xa8>
mov    0x3d6e(%rip),%rax
mov    (%rax),%rdi
mov    $0x0,%al
call   10f0 <atoi@plt>
mov    %eax,-0x14(%rbp)
jmp    1298 <main+0xa8>
mov    0x3d55(%rip),%rax
mov    (%rax),%rdi
mov    $0x0,%al
call   10f0 <atoi@plt>
mov    %eax,-0x18(%rbp)
jmp    1222 <main+0x32>
movsd  0x1d7b(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x1d66(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x1d1d(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x1d08(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
cvtsi2sdl -0x5c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
cvtsi2sdl -0x60(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x1cbd(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  0x1c9d(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
movsd  0x1c90(%rip),%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    0x1cae(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
lea    0x1cbc(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
lea    0x1cc4(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1100 <_mm_malloc@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1100 <_mm_malloc@plt>
cltq
mov    %rax,-0xb0(%rbp)
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1100 <_mm_malloc@plt>
cltq
mov    %rax,-0xb8(%rbp)
mov    -0xb0(%rbp),%rdi
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
movsd  0x1b91(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xa8(%rbp),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1090 <__assume_aligned@plt>
mov    -0xb0(%rbp),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1090 <__assume_aligned@plt>
mov    -0xb8(%rbp),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1090 <__assume_aligned@plt>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    15cc <main+0x3dc>
movsd  -0x78(%rbp),%xmm1
cvtsi2sdl -0xd4(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    15b3 <main+0x3c3>
movsd  -0x68(%rbp),%xmm1
cvtsi2sdl -0xd8(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x1af6(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x50(%rbp),%xmm0
call   10c0 <cos@plt>
movsd  %xmm0,-0x190(%rbp)
ff
movsd  0x1ad4(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
call   10c0 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
mov    -0xd4(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    14fb <main+0x30b>
jmp    15b8 <main+0x3c8>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    14ba <main+0x2ca>
movl   $0x0,-0xdc(%rbp)
movsd  -0x78(%rbp),%xmm1
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    16a8 <main+0x4b8>
movsd  -0x68(%rbp),%xmm1
cvtsi2sdl -0xe0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
cvtsi2sd %eax,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0xe0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0xe0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1605 <main+0x415>
mov    -0x14(%rbp),%eax
mov    %eax,-0xdc(%rbp)
movsd  -0x78(%rbp),%xmm1
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    17a1 <main+0x5b1>
movsd  -0x68(%rbp),%xmm1
cvtsi2sdl -0xe4(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
cvtsi2sd %eax,%xmm0
mov    -0xb0(%rbp),%rax
mov    -0xdc(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0xe4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
mov    -0xdc(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0xe4(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    16e0 <main+0x4f0>
movl   $0x0,-0xdc(%rbp)
movsd  -0x68(%rbp),%xmm1
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    189f <main+0x6af>
movsd  -0x78(%rbp),%xmm1
cvtsi2sdl -0xe8(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
cvtsi2sd %eax,%xmm0
mov    -0xb0(%rbp),%rax
mov    -0xdc(%rbp),%ecx
mov    -0xe8(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
mov    -0xdc(%rbp),%ecx
mov    -0xe8(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    17da <main+0x5ea>
mov    -0x14(%rbp),%eax
mov    %eax,-0xdc(%rbp)
movsd  -0x68(%rbp),%xmm1
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    199c <main+0x7ac>
movsd  -0x78(%rbp),%xmm1
cvtsi2sdl -0xec(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
cvtsi2sd %eax,%xmm0
mov    -0xb0(%rbp),%rax
mov    -0xdc(%rbp),%ecx
mov    -0xec(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
mov    -0xdc(%rbp),%ecx
mov    -0xec(%rbp),%edx
imul   -0x9c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    18d7 <main+0x6e7>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  -0x40(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  -0x48(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0x1622(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0x160a(%rip),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
cvtsi2sdl -0x14(%rbp),%xmm0
call   10d0 <log@plt>
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0x15d8(%rip),%xmm0
call   10d0 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x198(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
call   1050 <ceil@plt>
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
movsd  0x15aa(%rip),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0xc8,-0x12c(%rbp)
movl   $0x0,-0x130(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x11c(%rbp),%eax
imul   -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1100 <_mm_malloc@plt>
cltq
mov    %rax,-0x140(%rbp)
movslq -0x9c(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1100 <_mm_malloc@plt>
cltq
mov    %rax,-0x148(%rbp)
movl   $0x0,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x11c(%rbp),%eax
jge    1bc6 <main+0x9d6>
mov    -0x14c(%rbp),%eax
imul   -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0x150(%rbp)
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
cmp    %ecx,%eax
jge    1b9a <main+0x9aa>
mov    -0xa8(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
mov    -0x150(%rbp),%ecx
add    -0x154(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1b35 <main+0x945>
movsd  0x146e(%rip),%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x14c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1aff <main+0x90f>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movl   $0x0,-0x164(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
xor    %eax,%eax
ucomisd -0xc0(%rbp),%xmm0
ff
mov    %al,-0x199(%rbp)
jbe    1c16 <main+0xa26>
mov    -0x130(%rbp),%eax
cmp    -0x12c(%rbp),%eax
setl   %al
mov    %al,-0x199(%rbp)
mov    -0x199(%rbp),%al
test   $0x1,%al
jne    1c29 <main+0xa39>
jmp    1f7a <main+0xd8a>
mov    -0xb8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdx
shl    $0x3,%rdx
call   10a0 <memcpy@plt>
movl   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%eax
cmp    -0x11c(%rbp),%eax
jge    1cff <main+0xb0f>
mov    -0xb0(%rbp),%rdi
mov    -0x140(%rbp),%rsi
mov    -0x168(%rbp),%eax
imul   -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x148(%rbp),%rdx
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
mov    -0x9c(%rbp),%ecx
mov    $0x2,%al
call   10b0 <relaxOperation@plt>
movsd  0x134d(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0x1335(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    1c5a <main+0xa6a>
mov    -0xb0(%rbp),%rdi
mov    -0x9c(%rbp),%esi
mov    $0x0,%al
call   1070 <normInf_cache@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
cmp    %ecx,%eax
jge    1d87 <main+0xb97>
mov    -0xb0(%rbp),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb8(%rbp),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    1d29 <main+0xb39>
mov    -0xb8(%rbp),%rdi
mov    -0x9c(%rbp),%esi
mov    $0x0,%al
call   1070 <normInf_cache@plt>
cvtsi2sd %eax,%xmm0
divsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1dd8 <main+0xbe8>
movl   $0x1,-0x164(%rbp)
jmp    1f7a <main+0xd8a>
mov    -0xb8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
movslq %eax,%rdx
shl    $0x3,%rdx
call   10a0 <memcpy@plt>
mov    -0x11c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x170(%rbp)
cmpl   $0xffffffff,-0x170(%rbp)
jle    1eb6 <main+0xcc6>
movsd  -0x100(%rbp),%xmm0
ff
movsd  0x11e5(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  0x11c9(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xb0(%rbp),%rdi
mov    -0x140(%rbp),%rsi
mov    -0x170(%rbp),%eax
imul   -0x9c(%rbp),%eax
imul   -0x9c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x148(%rbp),%rdx
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
mov    -0x9c(%rbp),%ecx
mov    $0x2,%al
call   10b0 <relaxOperation@plt>
mov    -0x170(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x170(%rbp)
jmp    1e0e <main+0xc1e>
mov    -0xb0(%rbp),%rdi
mov    -0x9c(%rbp),%esi
mov    $0x0,%al
call   1070 <normInf_cache@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x174(%rbp)
mov    -0x174(%rbp),%eax
mov    -0x9c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
cmp    %ecx,%eax
jge    1f3e <main+0xd4e>
mov    -0xb0(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb8(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    1ee0 <main+0xcf0>
mov    -0xb8(%rbp),%rdi
mov    -0x9c(%rbp),%esi
mov    $0x0,%al
call   1070 <normInf_cache@plt>
cvtsi2sd %eax,%xmm0
divsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1be3 <main+0x9f3>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x148(%rbp),%rdi
mov    $0x0,%al
call   1110 <_mm_free@plt>
mov    -0x140(%rbp),%rdi
mov    $0x0,%al
call   1110 <_mm_free@plt>
mov    -0xa8(%rbp),%rdi
mov    $0x0,%al
call   1110 <_mm_free@plt>
mov    -0xb0(%rbp),%rdi
mov    $0x0,%al
call   1110 <_mm_free@plt>
mov    -0xb8(%rbp),%rdi
mov    $0x0,%al
call   1110 <_mm_free@plt>
lea    0x10c1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x128(%rbp),%xmm0
ff
lea    0x10e1(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x130(%rbp),%esi
shl    $0x1,%esi
imul   -0x11c(%rbp),%esi
mov    -0x164(%rbp),%eax
imul   -0x11c(%rbp),%eax
add    %eax,%esi
lea    0x10db(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x180(%rbp),%xmm0
ff
subsd  -0x160(%rbp),%xmm0
ff
lea    0x10f5(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
xor    %eax,%eax
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rsi,%rbx
mov    %edi,%ebp
mov    $0xc8,%eax
mov    %rax,0x30(%rsp)
lea    0x1e49(%rip),%r14
mov    0x3db2(%rip),%r15
jmp    123a <main+0x3a>
mov    (%r15),%rdi
xor    %eax,%eax
call   1100 <atoi@plt>
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   10f0 <getopt@plt>
cmp    $0x70,%eax
je     1230 <main+0x30>
cmp    $0xffffffff,%eax
je     1269 <main+0x69>
cmp    $0x6e,%eax
jne    123a <main+0x3a>
mov    (%r15),%rdi
xor    %eax,%eax
call   1100 <atoi@plt>
mov    %rax,0x30(%rsp)
jmp    123a <main+0x3a>
mov    0x30(%rsp),%r12
cvtsi2sd %r12d,%xmm0
movsd  0x1d85(%rip),%xmm1
movsd  %xmm0,0x40(%rsp)
divsd  %xmm0,%xmm1
movsd  0x1d7b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm1,0x10(%rsp)
mulsd  %xmm1,%xmm0
divsd  0x1d6d(%rip),%xmm0
movapd %xmm0,0xc0(%rsp)
lea    0x1e9e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1db6(%rip),%rdi
movsd  0x1d51(%rip),%xmm0
movapd %xmm0,%xmm1
mov    $0x2,%al
call   1070 <printf@plt>
lea    0x1db8(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x1(%r12),%r13d
mov    %r13d,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1110 <_mm_malloc@plt>
cltq
mov    %rax,0x48(%rsp)
mov    %rbp,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1110 <_mm_malloc@plt>
movslq %eax,%r15
mov    %rbp,0xa8(%rsp)
mov    %rbp,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1110 <_mm_malloc@plt>
movslq %eax,%r14
mov    %r15,%rdi
xor    %esi,%esi
mov    %rbx,0x68(%rsp)
mov    %rbx,%rdx
call   1090 <memset@plt>
mov    0x48(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   10a0 <__assume_aligned@plt>
mov    %r15,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   10a0 <__assume_aligned@plt>
mov    %r14,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   10a0 <__assume_aligned@plt>
mov    %r12,%rdx
movslq %r13d,%rax
mov    %rax,0x38(%rsp)
test   %edx,%edx
mov    %r13d,0x54(%rsp)
mov    %r15,0x60(%rsp)
js     1782 <main+0x582>
mov    %r13d,%ecx
mov    %ecx,%r13d
and    $0xfffffffe,%r13d
lea    0x8(%rbx),%r12
lea    0x0(,%rcx,8),%rax
mov    %rax,0x58(%rsp)
xor    %r15d,%r15d
xorpd  %xmm1,%xmm1
movsd  0x1c5a(%rip),%xmm2
movsd  0x10(%rsp),%xmm0
mov    %rdx,%rbx
mov    %rcx,0x28(%rsp)
jmp    1453 <main+0x253>
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
imul   %rcx,%rbx
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
call   10d0 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%rsp),%xmm0
call   10d0 <cos@plt>
movsd  0x1c06(%rip),%xmm2
xorpd  %xmm1,%xmm1
mov    0x28(%rsp),%rcx
mulsd  0x8(%rsp),%xmm0
add    %rbp,%rbx
mov    0x48(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    0x30(%rsp),%rbx
movsd  0x10(%rsp),%xmm0
add    $0x1,%r15
add    0x58(%rsp),%r12
cmp    %rcx,%r15
je     1540 <main+0x340>
xorps  %xmm3,%xmm3
cvtsi2sd %r15d,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
test   %ebx,%ebx
movsd  %xmm3,0x20(%rsp)
je     1530 <main+0x330>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
call   10d0 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%rsp),%xmm0
call   10d0 <cos@plt>
mulsd  0x8(%rsp),%xmm0
lea    0x1(%rbp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm0,-0x8(%r12,%rbp,8)
mulsd  0x10(%rsp),%xmm1
addsd  0x1b70(%rip),%xmm1
mulsd  0x1b48(%rip),%xmm1
movapd %xmm1,%xmm0
call   10d0 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%rsp),%xmm0
call   10d0 <cos@plt>
movsd  0x1b26(%rip),%xmm2
xorpd  %xmm1,%xmm1
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
add    $0x2,%rbp
cmp    %r13,%rbp
jne    1480 <main+0x280>
movsd  0x10(%rsp),%xmm0
mov    0x28(%rsp),%rcx
test   $0x1,%cl
je     1441 <main+0x241>
jmp    13e0 <main+0x1e0>
xor    %ebp,%ebp
test   $0x1,%cl
je     1441 <main+0x241>
jmp    13e0 <main+0x1e0>
test   %ebx,%ebx
mov    0x54(%rsp),%r12d
mov    0x60(%rsp),%rbp
js     1782 <main+0x582>
xorpd  %xmm0,%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
xor    %ebx,%ebx
movsd  %xmm1,0x20(%rsp)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x1abb(%rip),%xmm0
movsd  0x1a73(%rip),%xmm2
movapd %xmm2,%xmm3
movsd  0x1a7f(%rip),%xmm4
movapd %xmm4,%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
movsd  0x20(%rsp),%xmm1
mov    0x48(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movq   $0x0,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,0x28(%rsp)
jne    1570 <main+0x370>
mov    0x30(%rsp),%rdx
test   %edx,%edx
js     1782 <main+0x582>
movsd  0x40(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm1
xorpd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
mov    %r12d,%eax
imul   %edx,%eax
cltq
lea    0x0(,%rax,8),%r12
add    %rbp,%r12
lea    (%rcx,%rax,8),%rbx
xor    %ebp,%ebp
movsd  %xmm1,0x8(%rsp)
nop
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x1a1b(%rip),%xmm0
movsd  0x19d3(%rip),%xmm2
movapd %xmm2,%xmm3
movsd  0x19df(%rip),%xmm4
movapd %xmm4,%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
movsd  0x8(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movq   $0x0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x28(%rsp)
jne    1610 <main+0x410>
cmpl   $0x0,0x30(%rsp)
mov    0x60(%rsp),%r12
movsd  0x20(%rsp),%xmm0
js     1782 <main+0x582>
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%r13
xor    %ebp,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  0x198b(%rip),%xmm1
movsd  0x1943(%rip),%xmm2
movapd %xmm2,%xmm3
movsd  0x194f(%rip),%xmm4
movapd %xmm4,%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
movsd  0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,(%r12,%rbp,1)
mov    0x48(%rsp),%rax
movq   $0x0,(%rax,%rbp,1)
add    $0x1,%rbx
add    %r13,%rbp
cmp    %rbx,0x28(%rsp)
jne    16a0 <main+0x4a0>
mov    0x30(%rsp),%rax
test   %eax,%eax
movsd  0x8(%rsp),%xmm0
js     1782 <main+0x582>
mov    %r12,%rbx
mov    %eax,%r12d
shl    $0x3,%r12
xor    %ebp,%ebp
nopl   (%rax)
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  0x190b(%rip),%xmm1
movsd  0x18c3(%rip),%xmm2
movapd %xmm2,%xmm3
movsd  0x18cf(%rip),%xmm4
movapd %xmm4,%xmm5
mov    $0x6,%al
call   1030 <test_init@plt>
movsd  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,(%rbx,%r12,1)
mov    0x48(%rsp),%rax
movq   $0x0,(%rax,%r12,1)
add    $0x1,%rbp
add    %r13,%r12
cmp    %rbp,0x28(%rsp)
jne    1720 <main+0x520>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x80(%rsp)
movapd 0xc0(%rsp),%xmm0
addsd  %xmm0,%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  0x1871(%rip),%xmm1
movapd %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0xb0(%rsp)
movsd  0x40(%rsp),%xmm0
call   10e0 <log@plt>
divsd  0x1853(%rip),%xmm0
call   1060 <ceil@plt>
cvttsd2si %xmm0,%r13d
lea    0x1(%r13),%ebx
mov    0x68(%rsp),%rbp
mov    %ebp,%eax
imul   %ebx,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
xor    %r12d,%r12d
mov    $0x40,%esi
xor    %eax,%eax
call   1110 <_mm_malloc@plt>
movslq %eax,%r15
mov    0x38(%rsp),%rdi
shl    $0x3,%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1110 <_mm_malloc@plt>
movapd 0xc0(%rsp),%xmm4
mov    %r15,%r8
mov    %eax,0x70(%rsp)
mov    %ebx,0x94(%rsp)
mov    %ebx,%eax
mov    %rax,0x30(%rsp)
mov    %r13,0x8(%rsp)
test   %r13d,%r13d
mov    0x48(%rsp),%rdi
mov    %r15,0x40(%rsp)
mov    0x60(%rsp),%r15
js     1a78 <main+0x878>
lea    (%r8,%rbp,8),%rax
mov    %rax,0x58(%rsp)
lea    (%rdi,%rbp,8),%rax
mov    %rax,0x20(%rsp)
mov    %ebp,%r13d
and    $0xfffffffc,%r13d
lea    -0x4(%r13),%r10
mov    %r10,0x38(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x88(%rsp)
mov    %ebp,%r11d
and    $0x3,%r11d
lea    0x30(%r8),%rax
mov    %rax,0x78(%rsp)
lea    0x18(%r8),%rax
mov    %rax,0x28(%rsp)
movsd  0x1747(%rip),%xmm0
xor    %eax,%eax
jmp    18e6 <main+0x6e6>
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  %xmm0,%xmm4
add    $0x1,%rax
add    %ebp,%r12d
cmp    0x30(%rsp),%rax
je     1a78 <main+0x878>
test   %rbp,%rbp
je     18d0 <main+0x6d0>
movslq %r12d,%r9
cmp    $0x4,%ebp
jb     191c <main+0x71c>
mov    %eax,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
lea    (%r8,%rcx,8),%rdx
cmp    0x20(%rsp),%rdx
jae    19bc <main+0x7bc>
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
cmp    %rcx,%rdi
jae    19bc <main+0x7bc>
xor    %esi,%esi
mov    %rsi,%rbx
not    %rbx
add    %rbp,%rbx
test   %r11,%r11
je     1958 <main+0x758>
lea    (%r8,%r9,8),%rdx
mov    %r11,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1940 <main+0x740>
cmp    $0x3,%rbx
jb     18d0 <main+0x6d0>
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,8),%rbx
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x18(%rbx,%rsi,8)
movsd  0x8(%rdi,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x10(%rbx,%rsi,8)
movsd  0x10(%rdi,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x8(%rbx,%rsi,8)
movsd  0x18(%rdi,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1970 <main+0x770>
jmp    18d0 <main+0x6d0>
movapd %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
cmpq   $0x0,0x38(%rsp)
je     1a2a <main+0x82a>
mov    0x78(%rsp),%rcx
lea    (%rcx,%r9,8),%rbx
mov    0x88(%rsp),%r8
xor    %esi,%esi
nop
movupd (%rdi,%rsi,8),%xmm2
movupd 0x10(%rdi,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbx,%rsi,8)
movupd %xmm3,-0x20(%rbx,%rsi,8)
movupd 0x20(%rdi,%rsi,8),%xmm2
movupd 0x30(%rdi,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbx,%rsi,8)
movupd %xmm3,(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%r8
jne    19e0 <main+0x7e0>
jmp    1a2c <main+0x82c>
xor    %esi,%esi
test   $0x1,%r10b
mov    0x68(%rsp),%rbp
mov    0x40(%rsp),%r8
je     1a67 <main+0x867>
mov    %ebp,%ecx
imul   %eax,%ecx
movslq %ecx,%rcx
movupd (%rdi,%rsi,8),%xmm2
movupd 0x10(%rdi,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
add    %rsi,%rcx
movupd %xmm2,(%r8,%rcx,8)
movupd %xmm3,0x10(%r8,%rcx,8)
mov    %r13,%rsi
cmp    %rbp,%r13
je     18d0 <main+0x6d0>
jmp    191e <main+0x71e>
movslq 0x70(%rsp),%r12
xor    %eax,%eax
call   1050 <omp_get_wtime@plt>
mov    %eax,0x90(%rsp)
mov    0x8(%rsp),%rdx
movslq %edx,%rsi
lea    (%r14,%rbp,8),%rax
lea    (%r15,%rbp,8),%rcx
movapd 0x10(%rsp),%xmm0
unpcklpd 0xb0(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
mov    %ebp,%edi
and    $0xfffffffc,%edi
mov    %rdi,0xb0(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x70(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %rcx,%r14
setb   %cl
cmp    %rax,%r15
setb   %al
and    %cl,%al
mov    %al,0x38(%rsp)
mov    %rdi,%rax
mov    %rdi,0x98(%rsp)
and    %rdi,0x80(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x78(%rsp)
add    $0x1,%rsi
mov    %rsi,0xc0(%rsp)
lea    -0x1(%rdx),%eax
imul   %ebp,%eax
mov    %eax,0x88(%rsp)
xor    %eax,%eax
mov    %r14,0xa0(%rsp)
mov    %r12,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,0x58(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
mov    0xa8(%rsp),%rdx
call   10b0 <memcpy@plt>
cmpl   $0x0,0x8(%rsp)
js     1bb0 <main+0x9b0>
xor    %ebp,%ebp
mov    0x30(%rsp),%rbx
mov    0x54(%rsp),%r13d
mov    0x68(%rsp),%r12
movaps 0x10(%rsp),%xmm1
mov    0x40(%rsp),%r15
mov    0x60(%rsp),%r14
nop
movaps %xmm1,0x10(%rsp)
movslq %ebp,%rbp
lea    (%r15,%rbp,8),%rsi
movhlps %xmm1,%xmm1
mov    %r14,%rdi
mov    0x20(%rsp),%rdx
movapd 0x10(%rsp),%xmm0
mov    %r13d,%ecx
mov    $0x2,%al
call   10c0 <relaxOperation@plt>
movapd 0x10(%rsp),%xmm1
mulpd  0x14ab(%rip),%xmm1
add    %r12d,%ebp
add    $0xffffffffffffffff,%rbx
jne    1b70 <main+0x970>
jmp    1bc5 <main+0x9c5>
mov    0x54(%rsp),%r13d
mov    0x68(%rsp),%r12
movapd 0x10(%rsp),%xmm1
mov    0x60(%rsp),%r14
movapd %xmm1,0x10(%rsp)
mov    %r14,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <normInf_cache@plt>
test   %r12,%r12
mov    %r12,%rdi
mov    %r14,%r15
mov    0xa0(%rsp),%r14
mov    0x20(%rsp),%r12
je     1d8a <main+0xb8a>
cmp    $0x4,%edi
setb   %cl
or     0x38(%rsp),%cl
je     1c10 <main+0xa10>
xor    %ecx,%ecx
jmp    1ce8 <main+0xae8>
nopw   0x0(%rax,%rax,1)
cmpq   $0x0,0x70(%rsp)
je     2064 <main+0xe64>
mov    0x80(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x30(%r15,%rcx,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,0x20(%r14,%rcx,8)
movupd %xmm3,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1c30 <main+0xa30>
testb  $0x1,0x98(%rsp)
01
je     1cd4 <main+0xad4>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
mov    0xb0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rdi,%rdx
je     1d8a <main+0xb8a>
mov    %rcx,%rdx
not    %rdx
add    %rdi,%rdx
mov    0x78(%rsp),%rsi
test   %rsi,%rsi
je     1d1c <main+0xb1c>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1d00 <main+0xb00>
cmp    $0x3,%rdx
jb     1d8a <main+0xb8a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rcx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm0,(%r14,%rcx,8)
subsd  0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
subsd  0x10(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
subsd  0x18(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1d30 <main+0xb30>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %r14,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <normInf_cache@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  0x28(%rsp),%xmm1
movsd  0x127f(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     208e <main+0xe8e>
mov    %r14,%rdi
mov    %r15,%rsi
mov    0xa8(%rsp),%rdx
call   10b0 <memcpy@plt>
mov    0x88(%rsp),%eax
mov    %eax,%ebp
mov    0xc0(%rsp),%rbx
cmpl   $0x0,0x8(%rsp)
mov    0x68(%rsp),%r12
movapd 0x10(%rsp),%xmm2
mov    %r15,%r14
mov    0x40(%rsp),%r15
jle    1e56 <main+0xc56>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulpd  0x1248(%rip),%xmm2
movapd %xmm2,0x10(%rsp)
movslq %ebp,%rbp
lea    (%r15,%rbp,8),%rsi
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mov    %r14,%rdi
mov    0x20(%rsp),%rdx
movapd %xmm2,%xmm0
mov    %r13d,%ecx
mov    $0x2,%al
call   10c0 <relaxOperation@plt>
movapd 0x10(%rsp),%xmm2
add    $0xffffffffffffffff,%rbx
sub    %r12d,%ebp
cmp    $0x1,%rbx
jg     1e10 <main+0xc10>
movapd %xmm2,0x10(%rsp)
mov    %r14,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <normInf_cache@plt>
test   %r12,%r12
mov    %r12,%rbp
mov    %r14,%r15
mov    0xa0(%rsp),%r14
mov    0x20(%rsp),%r12
je     201a <main+0xe1a>
cmp    $0x4,%ebp
setb   %cl
or     0x38(%rsp),%cl
je     1ea0 <main+0xca0>
xor    %ecx,%ecx
jmp    1f78 <main+0xd78>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x70(%rsp)
je     2079 <main+0xe79>
mov    0x80(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x30(%r15,%rcx,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,0x20(%r14,%rcx,8)
movupd %xmm3,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1ec0 <main+0xcc0>
testb  $0x1,0x98(%rsp)
01
je     1f64 <main+0xd64>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
mov    0xb0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
je     201a <main+0xe1a>
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
test   $0x3,%bpl
je     1fac <main+0xdac>
mov    0x78(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%r14,%rcx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1f90 <main+0xd90>
cmp    $0x3,%rdx
jb     201a <main+0xe1a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rcx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm0,(%r14,%rcx,8)
subsd  0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
subsd  0x10(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
subsd  0x18(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1fc0 <main+0xdc0>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
xor    %ebx,%ebx
mov    %r14,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <normInf_cache@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  0x28(%rsp),%xmm1
mov    0x58(%rsp),%rax
lea    0x1(%rax),%ebp
ucomisd 0xfe5(%rip),%xmm1
jbe    2098 <main+0xe98>
cmp    $0xc7,%eax
mov    %ebp,%eax
jb     1b30 <main+0x930>
jmp    2098 <main+0xe98>
xor    %ecx,%ecx
testb  $0x1,0x98(%rsp)
01
jne    1ca5 <main+0xaa5>
jmp    1cd4 <main+0xad4>
xor    %ecx,%ecx
testb  $0x1,0x98(%rsp)
01
jne    1f35 <main+0xd35>
jmp    1f64 <main+0xd64>
mov    $0x1,%ebx
mov    0x58(%rsp),%rbp
movsd  %xmm1,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x90(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1050 <omp_get_wtime@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r12,%rdi
xor    %eax,%eax
call   1120 <_mm_free@plt>
mov    0x40(%rsp),%rdi
xor    %eax,%eax
call   1120 <_mm_free@plt>
mov    0x48(%rsp),%rdi
xor    %eax,%eax
call   1120 <_mm_free@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1120 <_mm_free@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1120 <_mm_free@plt>
lea    0x106f(%rip),%rdi
call   1040 <puts@plt>
lea    0xf9a(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
lea    (%rbx,%rbp,2),%esi
imul   0x94(%rsp),%esi
lea    0xfa2(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xfcc(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"n:p:\00"
@optarg = external global i8*
@.str.1 = [38 x i8] c"\0A==== Douglas ADI Program Start ====\0A\00"
@.str.2 = [28 x i8] c"** alpha_x/alpha_y : %f/%f\0A\00"
@.str.3 = [28 x i8] c"** X/Y Panel Count : %d/%d\0A\00"
@.str.4 = [54 x i8] c"==== Multi-scale Timstep Relaxation Output XXXX ====\0A\00"
@.str.5 = [39 x i8] c"** Difference between iterates : \09%lf\0A\00"
@.str.6 = [56 x i8] c"** Iteration Count for multi-scale time scheme :\09 %d \0A\0A\00"
@.str.7 = [69 x i8] c"** Time it takes to solve the multi-scale timestep solution is %e s\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca i32
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca i32
%45 = alloca double
%46 = alloca i32
%47 = alloca i32
%48 = alloca double
%49 = alloca double*
%50 = alloca double*
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca double
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 200, i32* %6
store i32 -1, i32* %7
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i8** %9
br label %61
61: ; preds = %75, %2
%62 = load i32, i32* %4
%63 = load i8**, i8*** %5
%64 = load i8*, i8** %9
%65 = call i32 (i32, i8**, i8*, ...) bitcast (i32 (...)* @getopt to i32 (i32, i8**, i8*, ...)*)(i32 %62, i8** %63, i8* %64)
store i32 %65, i32* %8
%66 = icmp ne i32 %65, -1
br i1 %66, label %67, label %76
67: ; preds = %61
%68 = load i32, i32* %8
switch i32 %68, label %75 [
i32 110, label %69
i32 112, label %72
]
69: ; preds = %67
%70 = load i8*, i8** @optarg
%71 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %70)
store i32 %71, i32* %6
br label %75
72: ; preds = %67
%73 = load i8*, i8** @optarg
%74 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %73)
store i32 %74, i32* %7
br label %75
75: ; preds = %67, %72, %69
br label %61
76: ; preds = %61
store double 2.000000e+00, double* %10
store double 1.000000e+00, double* %11
%77 = load double, double* %10
store double %77, double* %12
%78 = load double, double* %10
store double %78, double* %13
%79 = load double, double* %11
store double %79, double* %14
%80 = load double, double* %11
store double %80, double* %15
%81 = load i32, i32* %6
store i32 %81, i32* %16
%82 = load i32, i32* %6
store i32 %82, i32* %17
store double 0.000000e+00, double* %18
store double 1.000000e+00, double* %19
store double 0.000000e+00, double* %20
store double 1.000000e+00, double* %21
%83 = load double, double* %19
%84 = load double, double* %18
%85 = fsub double %83, %84
%86 = load i32, i32* %16
%87 = sitofp i32 %86 to double
%88 = fdiv double %85, %87
store double %88, double* %22
%89 = load double, double* %21
%90 = load double, double* %20
%91 = fsub double %89, %90
%92 = load i32, i32* %17
%93 = sitofp i32 %92 to double
%94 = fdiv double %91, %93
store double %94, double* %23
%95 = load double, double* %22
%96 = fmul double 4.000000e+00, %95
%97 = load double, double* %22
%98 = fmul double %96, %97
%99 = load double, double* %10
%100 = fmul double %99, 0x400921FB54442D18
%101 = fmul double %100, 0x400921FB54442D18
%102 = fdiv double %98, %101
store double %102, double* %24
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.1, i64 0, i64 0))
%104 = load double, double* %12
%105 = load double, double* %13
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0), double %104, double %105)
%107 = load i32, i32* %16
%108 = load i32, i32* %17
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0), i32 %107, i32 %108)
%110 = load i32, i32* %6
%111 = add nsw i32 %110, 1
store i32 %111, i32* %25
%112 = load i32, i32* %25
%113 = load i32, i32* %25
%114 = mul nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = mul i64 %115, 8
%117 = call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %116, i32 64)
%118 = sext i32 %117 to i64
%119 = inttoptr i64 %118 to double*
store double* %119, double** %26
%120 = load i32, i32* %25
%121 = load i32, i32* %25
%122 = mul nsw i32 %120, %121
%123 = sext i32 %122 to i64
%124 = mul i64 %123, 8
%125 = call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %124, i32 64)
%126 = sext i32 %125 to i64
%127 = inttoptr i64 %126 to double*
store double* %127, double** %27
%128 = load i32, i32* %25
%129 = load i32, i32* %25
%130 = mul nsw i32 %128, %129
%131 = sext i32 %130 to i64
%132 = mul i64 %131, 8
%133 = call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %132, i32 64)
%134 = sext i32 %133 to i64
%135 = inttoptr i64 %134 to double*
store double* %135, double** %28
%136 = load double*, double** %27
%137 = bitcast double* %136 to i8*
%138 = load i32, i32* %25
%139 = load i32, i32* %25
%140 = mul nsw i32 %138, %139
%141 = sext i32 %140 to i64
store double 0x3EB0C6F7A0B5ED8D, double* %29
%142 = load double*, double** %26
%143 = call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %142, i32 64)
%144 = load double*, double** %27
%145 = call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %144, i32 64)
%146 = load double*, double** %28
%147 = call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %146, i32 64)
store i32 0, i32* %32
br label %148
148: ; preds = %191, %76
%149 = load i32, i32* %32
%150 = load i32, i32* %25
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %194
152: ; preds = %148
%153 = load double, double* %20
%154 = load i32, i32* %32
%155 = sitofp i32 %154 to double
%156 = load double, double* %23
%157 = call double @llvm.fmuladd.f64(double %155, double %156, double %153)
store double %157, double* %31
store i32 0, i32* %33
br label %158
158: ; preds = %187, %152
%159 = load i32, i32* %33
%160 = load i32, i32* %25
%161 = icmp slt i32 %159, %160
br i1 %161, label %162, label %190
162: ; preds = %158
%163 = load double, double* %18
%164 = load i32, i32* %33
%165 = sitofp i32 %164 to double
%166 = load double, double* %22
%167 = call double @llvm.fmuladd.f64(double %165, double %166, double %163)
store double %167, double* %30
%168 = load double, double* %30
%169 = fmul double 0x401921FB54442D18, %168
%170 = load double, double* %14
%171 = fmul double %169, %170
%172 = call double @cos(double %171)
%173 = load double, double* %31
%174 = fmul double 0x401921FB54442D18, %173
%175 = load double, double* %15
%176 = fmul double %174, %175
%177 = call double @cos(double %176)
%178 = fmul double %172, %177
%179 = load double*, double** %26
%180 = load i32, i32* %32
%181 = load i32, i32* %25
%182 = mul nsw i32 %180, %181
%183 = load i32, i32* %33
%184 = add nsw i32 %182, %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %179, i64 %185
store double %178, double* %186
br label %187
187: ; preds = %162
%188 = load i32, i32* %33
%189 = add nsw i32 %188, 1
store i32 %189, i32* %33
br label %158
190: ; preds = %158
br label %191
191: ; preds = %190
%192 = load i32, i32* %32
%193 = add nsw i32 %192, 1
store i32 %193, i32* %32
br label %148
194: ; preds = %148
store i32 0, i32* %34
%195 = load double, double* %20
%196 = load i32, i32* %34
%197 = sitofp i32 %196 to double
%198 = load double, double* %23
%199 = call double @llvm.fmuladd.f64(double %197, double %198, double %195)
store double %199, double* %31
store i32 0, i32* %35
br label %200
200: ; preds = %226, %194
%201 = load i32, i32* %35
%202 = load i32, i32* %25
%203 = icmp slt i32 %201, %202
br i1 %203, label %204, label %229
204: ; preds = %200
%205 = load double, double* %18
%206 = load i32, i32* %35
%207 = sitofp i32 %206 to double
%208 = load double, double* %22
%209 = call double @llvm.fmuladd.f64(double %207, double %208, double %205)
store double %209, double* %30
%210 = load double, double* %30
%211 = load double, double* %31
%212 = load double, double* %14
%213 = load double, double* %15
%214 = load double, double* %12
%215 = load double, double* %13
%216 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %210, double %211, double %212, double %213, double %214, double %215)
%217 = sitofp i32 %216 to double
%218 = load double*, double** %27
%219 = load i32, i32* %35
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
store double %217, double* %221
%222 = load double*, double** %26
%223 = load i32, i32* %35
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %222, i64 %224
store double 0.000000e+00, double* %225
br label %226
226: ; preds = %204
%227 = load i32, i32* %35
%228 = add nsw i32 %227, 1
store i32 %228, i32* %35
br label %200
229: ; preds = %200
%230 = load i32, i32* %6
store i32 %230, i32* %34
%231 = load double, double* %20
%232 = load i32, i32* %34
%233 = sitofp i32 %232 to double
%234 = load double, double* %23
%235 = call double @llvm.fmuladd.f64(double %233, double %234, double %231)
store double %235, double* %31
store i32 0, i32* %36
br label %236
236: ; preds = %270, %229
%237 = load i32, i32* %36
%238 = load i32, i32* %25
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %273
240: ; preds = %236
%241 = load double, double* %18
%242 = load i32, i32* %36
%243 = sitofp i32 %242 to double
%244 = load double, double* %22
%245 = call double @llvm.fmuladd.f64(double %243, double %244, double %241)
store double %245, double* %30
%246 = load double, double* %30
%247 = load double, double* %31
%248 = load double, double* %14
%249 = load double, double* %15
%250 = load double, double* %12
%251 = load double, double* %13
%252 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %246, double %247, double %248, double %249, double %250, double %251)
%253 = sitofp i32 %252 to double
%254 = load double*, double** %27
%255 = load i32, i32* %34
%256 = load i32, i32* %25
%257 = mul nsw i32 %255, %256
%258 = load i32, i32* %36
%259 = add nsw i32 %257, %258
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %254, i64 %260
store double %253, double* %261
%262 = load double*, double** %26
%263 = load i32, i32* %34
%264 = load i32, i32* %25
%265 = mul nsw i32 %263, %264
%266 = load i32, i32* %36
%267 = add nsw i32 %265, %266
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double, double* %262, i64 %268
store double 0.000000e+00, double* %269
br label %270
270: ; preds = %240
%271 = load i32, i32* %36
%272 = add nsw i32 %271, 1
store i32 %272, i32* %36
br label %236
273: ; preds = %236
store i32 0, i32* %34
%274 = load double, double* %18
%275 = load i32, i32* %34
%276 = sitofp i32 %275 to double
%277 = load double, double* %22
%278 = call double @llvm.fmuladd.f64(double %276, double %277, double %274)
store double %278, double* %30
store i32 0, i32* %37
br label %279
279: ; preds = %313, %273
%280 = load i32, i32* %37
%281 = load i32, i32* %25
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %316
283: ; preds = %279
%284 = load double, double* %20
%285 = load i32, i32* %37
%286 = sitofp i32 %285 to double
%287 = load double, double* %23
%288 = call double @llvm.fmuladd.f64(double %286, double %287, double %284)
store double %288, double* %31
%289 = load double, double* %30
%290 = load double, double* %31
%291 = load double, double* %14
%292 = load double, double* %15
%293 = load double, double* %12
%294 = load double, double* %13
%295 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %289, double %290, double %291, double %292, double %293, double %294)
%296 = sitofp i32 %295 to double
%297 = load double*, double** %27
%298 = load i32, i32* %34
%299 = load i32, i32* %37
%300 = load i32, i32* %25
%301 = mul nsw i32 %299, %300
%302 = add nsw i32 %298, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %297, i64 %303
store double %296, double* %304
%305 = load double*, double** %26
%306 = load i32, i32* %34
%307 = load i32, i32* %37
%308 = load i32, i32* %25
%309 = mul nsw i32 %307, %308
%310 = add nsw i32 %306, %309
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %305, i64 %311
store double 0.000000e+00, double* %312
br label %313
313: ; preds = %283
%314 = load i32, i32* %37
%315 = add nsw i32 %314, 1
store i32 %315, i32* %37
br label %279
316: ; preds = %279
%317 = load i32, i32* %6
store i32 %317, i32* %34
%318 = load double, double* %18
%319 = load i32, i32* %34
%320 = sitofp i32 %319 to double
%321 = load double, double* %22
%322 = call double @llvm.fmuladd.f64(double %320, double %321, double %318)
store double %322, double* %30
store i32 0, i32* %38
br label %323
323: ; preds = %357, %316
%324 = load i32, i32* %38
%325 = load i32, i32* %25
%326 = icmp slt i32 %324, %325
br i1 %326, label %327, label %360
327: ; preds = %323
%328 = load double, double* %20
%329 = load i32, i32* %38
%330 = sitofp i32 %329 to double
%331 = load double, double* %23
%332 = call double @llvm.fmuladd.f64(double %330, double %331, double %328)
store double %332, double* %31
%333 = load double, double* %30
%334 = load double, double* %31
%335 = load double, double* %14
%336 = load double, double* %15
%337 = load double, double* %12
%338 = load double, double* %13
%339 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %333, double %334, double %335, double %336, double %337, double %338)
%340 = sitofp i32 %339 to double
%341 = load double*, double** %27
%342 = load i32, i32* %34
%343 = load i32, i32* %38
%344 = load i32, i32* %25
%345 = mul nsw i32 %343, %344
%346 = add nsw i32 %342, %345
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %341, i64 %347
store double %340, double* %348
%349 = load double*, double** %26
%350 = load i32, i32* %34
%351 = load i32, i32* %38
%352 = load i32, i32* %25
%353 = mul nsw i32 %351, %352
%354 = add nsw i32 %350, %353
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %349, i64 %355
store double 0.000000e+00, double* %356
br label %357
357: ; preds = %327
%358 = load i32, i32* %38
%359 = add nsw i32 %358, 1
store i32 %359, i32* %38
br label %323
360: ; preds = %323
%361 = load double, double* %24
store double %361, double* %39
%362 = load double, double* %39
%363 = load double, double* %12
%364 = fmul double %362, %363
%365 = load double, double* %22
%366 = load double, double* %22
%367 = fmul double %365, %366
%368 = fdiv double %364, %367
store double %368, double* %40
%369 = load double, double* %39
%370 = load double, double* %13
%371 = fmul double %369, %370
%372 = load double, double* %23
%373 = load double, double* %23
%374 = fmul double %372, %373
%375 = fdiv double %371, %374
store double %375, double* %41
%376 = load double, double* %40
%377 = fmul double -2.000000e+00, %376
store double %377, double* %42
%378 = load double, double* %41
%379 = fmul double -2.000000e+00, %378
store double %379, double* %43
%380 = load i32, i32* %6
%381 = sitofp i32 %380 to double
%382 = call double @log(double %381)
%383 = call double @log(double 2.000000e+00)
%384 = fdiv double %382, %383
%385 = call double @llvm.ceil.f64(double %384)
%386 = fptosi double %385 to i32
%387 = add nsw i32 %386, 1
store i32 %387, i32* %44
%388 = load double, double* %29
%389 = fmul double 2.000000e+00, %388
store double %389, double* %45
store i32 200, i32* %46
store i32 0, i32* %47
store double 0.000000e+00, double* %48
%390 = load i32, i32* %44
%391 = load i32, i32* %25
%392 = mul nsw i32 %390, %391
%393 = load i32, i32* %25
%394 = mul nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = mul i64 %395, 8
%397 = call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %396, i32 64)
%398 = sext i32 %397 to i64
%399 = inttoptr i64 %398 to double*
store double* %399, double** %49
%400 = load i32, i32* %25
%401 = sext i32 %400 to i64
%402 = mul i64 %401, 8
%403 = call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %402, i32 64)
%404 = sext i32 %403 to i64
%405 = inttoptr i64 %404 to double*
store double* %405, double** %50
store i32 0, i32* %51
br label %406
406: ; preds = %442, %360
%407 = load i32, i32* %51
%408 = load i32, i32* %44
%409 = icmp slt i32 %407, %408
br i1 %409, label %410, label %445
410: ; preds = %406
%411 = load i32, i32* %51
%412 = load i32, i32* %25
%413 = mul nsw i32 %411, %412
%414 = load i32, i32* %25
%415 = mul nsw i32 %413, %414
store i32 %415, i32* %52
store i32 0, i32* %53
br label %416
416: ; preds = %436, %410
%417 = load i32, i32* %53
%418 = load i32, i32* %25
%419 = load i32, i32* %25
%420 = mul nsw i32 %418, %419
%421 = icmp slt i32 %417, %420
br i1 %421, label %422, label %439
422: ; preds = %416
%423 = load double*, double** %26
%424 = load i32, i32* %53
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %423, i64 %425
%427 = load double, double* %426
%428 = load double, double* %39
%429 = fmul double %427, %428
%430 = load double*, double** %49
%431 = load i32, i32* %52
%432 = load i32, i32* %53
%433 = add nsw i32 %431, %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds double, double* %430, i64 %434
store double %429, double* %435
br label %436
436: ; preds = %422
%437 = load i32, i32* %53
%438 = add nsw i32 %437, 1
store i32 %438, i32* %53
br label %416
439: ; preds = %416
%440 = load double, double* %39
%441 = fmul double %440, 4.000000e+00
store double %441, double* %39
br label %442
442: ; preds = %439
%443 = load i32, i32* %51
%444 = add nsw i32 %443, 1
store i32 %444, i32* %51
br label %406
445: ; preds = %406
%446 = call i32 (...) @omp_get_wtime()
%447 = sitofp i32 %446 to double
store double %447, double* %54
store i32 0, i32* %55
br label %448
448: ; preds = %594, %445
%449 = load double, double* %45
%450 = load double, double* %29
%451 = fcmp ogt double %449, %450
br i1 %451, label %452, label %456
452: ; preds = %448
%453 = load i32, i32* %47
%454 = load i32, i32* %46
%455 = icmp slt i32 %453, %454
br label %456
456: ; preds = %452, %448
%457 = phi i1 [ false, %448 ], [ %455, %452 ]
br i1 %457, label %458, label %603
458: ; preds = %456
%459 = load double*, double** %28
%460 = bitcast double* %459 to i8*
%461 = load double*, double** %27
%462 = bitcast double* %461 to i8*
%463 = load i32, i32* %25
%464 = load i32, i32* %25
%465 = mul nsw i32 %463, %464
%466 = sext i32 %465 to i64
%467 = mul i64 %466, 8
store i32 0, i32* %56
br label %468
468: ; preds = %491, %458
%469 = load i32, i32* %56
%470 = load i32, i32* %44
%471 = icmp slt i32 %469, %470
br i1 %471, label %472, label %494
472: ; preds = %468
%473 = load double*, double** %27
%474 = load double*, double** %49
%475 = load i32, i32* %56
%476 = load i32, i32* %25
%477 = mul nsw i32 %475, %476
%478 = load i32, i32* %25
%479 = mul nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %474, i64 %480
%482 = load double*, double** %50
%483 = load double, double* %40
%484 = load double, double* %42
%485 = load i32, i32* %25
%486 = call i32 (double*, double*, double*, double, double, i32, ...) bitcast (i32 (...)* @relaxOperation to i32 (double*, double*, double*, double, double, i32, ...)*)(double* %473, double* %481, double* %482, double %483, double %484, i32 %485)
%487 = load double, double* %40
%488 = fmul double %487, 4.000000e+00
store double %488, double* %40
%489 = load double, double* %42
%490 = fmul double %489, 4.000000e+00
store double %490, double* %42
br label %491
491: ; preds = %472
%492 = load i32, i32* %56
%493 = add nsw i32 %492, 1
store i32 %493, i32* %56
br label %468
494: ; preds = %468
%495 = load double*, double** %27
%496 = load i32, i32* %25
%497 = call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %495, i32 %496)
%498 = sitofp i32 %497 to double
store double %498, double* %48
store i32 0, i32* %57
br label %499
499: ; preds = %517, %494
%500 = load i32, i32* %57
%501 = load i32, i32* %25
%502 = load i32, i32* %25
%503 = mul nsw i32 %501, %502
%504 = icmp slt i32 %500, %503
br i1 %504, label %505, label %520
505: ; preds = %499
%506 = load double*, double** %27
%507 = load i32, i32* %57
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %506, i64 %508
%510 = load double, double* %509
%511 = load double*, double** %28
%512 = load i32, i32* %57
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds double, double* %511, i64 %513
%515 = load double, double* %514
%516 = fsub double %515, %510
store double %516, double* %514
br label %517
517: ; preds = %505
%518 = load i32, i32* %57
%519 = add nsw i32 %518, 1
store i32 %519, i32* %57
br label %499
520: ; preds = %499
%521 = load double*, double** %28
%522 = load i32, i32* %25
%523 = call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %521, i32 %522)
%524 = sitofp i32 %523 to double
%525 = load double, double* %48
%526 = fdiv double %524, %525
store double %526, double* %45
%527 = load double, double* %45
%528 = load double, double* %29
%529 = fcmp olt double %527, %528
br i1 %529, label %530, label %531
530: ; preds = %520
store i32 1, i32* %55
br label %603
531: ; preds = %520
%532 = load double*, double** %28
%533 = bitcast double* %532 to i8*
%534 = load double*, double** %27
%535 = bitcast double* %534 to i8*
%536 = load i32, i32* %25
%537 = load i32, i32* %25
%538 = mul nsw i32 %536, %537
%539 = sext i32 %538 to i64
%540 = mul i64 %539, 8
%541 = load i32, i32* %44
%542 = sub nsw i32 %541, 2
store i32 %542, i32* %58
br label %543
543: ; preds = %565, %531
%544 = load i32, i32* %58
%545 = icmp sgt i32 %544, -1
br i1 %545, label %546, label %568
546: ; preds = %543
%547 = load double, double* %40
%548 = fdiv double %547, 4.000000e+00
store double %548, double* %40
%549 = load double, double* %42
%550 = fdiv double %549, 4.000000e+00
store double %550, double* %42
%551 = load double*, double** %27
%552 = load double*, double** %49
%553 = load i32, i32* %58
%554 = load i32, i32* %25
%555 = mul nsw i32 %553, %554
%556 = load i32, i32* %25
%557 = mul nsw i32 %555, %556
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds double, double* %552, i64 %558
%560 = load double*, double** %50
%561 = load double, double* %40
%562 = load double, double* %42
%563 = load i32, i32* %25
%564 = call i32 (double*, double*, double*, double, double, i32, ...) bitcast (i32 (...)* @relaxOperation to i32 (double*, double*, double*, double, double, i32, ...)*)(double* %551, double* %559, double* %560, double %561, double %562, i32 %563)
br label %565
565: ; preds = %546
%566 = load i32, i32* %58
%567 = add nsw i32 %566, -1
store i32 %567, i32* %58
br label %543
568: ; preds = %543
%569 = load double*, double** %27
%570 = load i32, i32* %25
%571 = call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %569, i32 %570)
%572 = sitofp i32 %571 to double
store double %572, double* %48
store i32 0, i32* %59
br label %573
573: ; preds = %591, %568
%574 = load i32, i32* %59
%575 = load i32, i32* %25
%576 = load i32, i32* %25
%577 = mul nsw i32 %575, %576
%578 = icmp slt i32 %574, %577
br i1 %578, label %579, label %594
579: ; preds = %573
%580 = load double*, double** %27
%581 = load i32, i32* %59
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %580, i64 %582
%584 = load double, double* %583
%585 = load double*, double** %28
%586 = load i32, i32* %59
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds double, double* %585, i64 %587
%589 = load double, double* %588
%590 = fsub double %589, %584
store double %590, double* %588
br label %591
591: ; preds = %579
%592 = load i32, i32* %59
%593 = add nsw i32 %592, 1
store i32 %593, i32* %59
br label %573
594: ; preds = %573
%595 = load double*, double** %28
%596 = load i32, i32* %25
%597 = call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %595, i32 %596)
%598 = sitofp i32 %597 to double
%599 = load double, double* %48
%600 = fdiv double %598, %599
store double %600, double* %45
%601 = load i32, i32* %47
%602 = add nsw i32 %601, 1
store i32 %602, i32* %47
br label %448
603: ; preds = %530, %456
%604 = call i32 (...) @omp_get_wtime()
%605 = sitofp i32 %604 to double
store double %605, double* %60
%606 = load double*, double** %50
%607 = call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %606)
%608 = load double*, double** %49
%609 = call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %608)
%610 = load double*, double** %26
%611 = call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %610)
%612 = load double*, double** %27
%613 = call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %612)
%614 = load double*, double** %28
%615 = call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %614)
%616 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.4, i64 0, i64 0))
%617 = load double, double* %45
%618 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.5, i64 0, i64 0), double %617)
%619 = load i32, i32* %47
%620 = mul nsw i32 %619, 2
%621 = load i32, i32* %44
%622 = mul nsw i32 %620, %621
%623 = load i32, i32* %55
%624 = load i32, i32* %44
%625 = mul nsw i32 %623, %624
%626 = add nsw i32 %622, %625
%627 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0), i32 %626)
%628 = load double, double* %60
%629 = load double, double* %54
%630 = fsub double %628, %629
%631 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.7, i64 0, i64 0), double %630)
ret i32 0
}

LLVM IR (-O2):
@.str = [5 x i8] c"n:p:\00"
@optarg = external global i8*
@.str.2 = [28 x i8] c"** alpha_x/alpha_y : %f/%f\0A\00"
@.str.3 = [28 x i8] c"** X/Y Panel Count : %d/%d\0A\00"
@.str.5 = [39 x i8] c"** Difference between iterates : \09%lf\0A\00"
@.str.6 = [56 x i8] c"** Iteration Count for multi-scale time scheme :\09 %d \0A\0A\00"
@.str.7 = [69 x i8] c"** Time it takes to solve the multi-scale timestep solution is %e s\0A\00"
@str = [37 x i8] c"\0A==== Douglas ADI Program Start ====\00"
@str.8 = [53 x i8] c"==== Multi-scale Timstep Relaxation Output XXXX ====\00"
define i32 @main(i32 %0, i8** %1) {
br label %3
3: ; preds = %8, %2
%4 = phi i32 [ %10, %8 ], [ 200, %2 ]
br label %5
5: ; preds = %7, %3
%6 = tail call i32 (i32, i8**, i8*, ...) bitcast (i32 (...)* @getopt to i32 (i32, i8**, i8*, ...)*)(i32 %0, i8** %1, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
switch i32 %6, label %7 [
i32 -1, label %14
i32 110, label %8
i32 112, label %11
]
7: ; preds = %5, %11
br label %5
8: ; preds = %5
%9 = load i8*, i8** @optarg
%10 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %9)
br label %3
11: ; preds = %5
%12 = load i8*, i8** @optarg
%13 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %12)
br label %7
14: ; preds = %5
%15 = sitofp i32 %4 to double
%16 = fdiv double 1.000000e+00, %15
%17 = fmul double %16, 4.000000e+00
%18 = fmul double %16, %17
%19 = fdiv double %18, 0x4033BD3CC9BE45DE
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str, i64 0, i64 0))
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0), double 2.000000e+00, double 2.000000e+00)
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0), i32 %4, i32 %4)
%23 = add nsw i32 %4, 1
%24 = mul i32 %23, %23
%25 = zext i32 %24 to i64
%26 = shl nuw nsw i64 %25, 3
%27 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %26, i32 64)
%28 = sext i32 %27 to i64
%29 = inttoptr i64 %28 to double*
%30 = inttoptr i64 %28 to i8*
%31 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %26, i32 64)
%32 = sext i32 %31 to i64
%33 = inttoptr i64 %32 to double*
%34 = inttoptr i64 %32 to i8*
%35 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %26, i32 64)
%36 = sext i32 %35 to i64
%37 = inttoptr i64 %36 to double*
%38 = inttoptr i64 %36 to i8*
%39 = inttoptr i64 %32 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %39, i8 0, i64 %25, i1 false)
%40 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %29, i32 64)
%41 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %33, i32 64)
%42 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @__assume_aligned to i32 (double*, i32, ...)*)(double* %37, i32 64)
%43 = icmp slt i32 %4, 0
br i1 %43, label %136, label %44
44: ; preds = %14
%45 = zext i32 %23 to i64
%46 = zext i32 %23 to i64
%47 = and i64 %46, 1
%48 = icmp eq i32 %4, 0
%49 = and i64 %46, 4294967294
%50 = icmp eq i64 %47, 0
br label %55
51: ; preds = %74
%52 = tail call double @llvm.fmuladd.f64(double %16, double 0.000000e+00, double 0.000000e+00)
br i1 %43, label %136, label %53
53: ; preds = %51
%54 = zext i32 %23 to i64
br label %108
55: ; preds = %74, %44
%56 = phi i64 [ 0, %44 ], [ %75, %74 ]
%57 = trunc i64 %56 to i32
%58 = sitofp i32 %57 to double
%59 = tail call double @llvm.fmuladd.f64(double %58, double %16, double 0.000000e+00)
%60 = fmul double %59, 0x401921FB54442D18
%61 = mul nsw i64 %56, %45
br i1 %48, label %62, label %77
62: ; preds = %77, %55
%63 = phi i64 [ 0, %55 ], [ %99, %77 ]
br i1 %50, label %74, label %64
64: ; preds = %62
%65 = trunc i64 %63 to i32
%66 = sitofp i32 %65 to double
%67 = tail call double @llvm.fmuladd.f64(double %66, double %16, double 0.000000e+00)
%68 = fmul double %67, 0x401921FB54442D18
%69 = tail call double @cos(double %68)
%70 = tail call double @cos(double %60)
%71 = fmul double %69, %70
%72 = add nuw nsw i64 %63, %61
%73 = getelementptr inbounds double, double* %29, i64 %72
store double %71, double* %73
br label %74
74: ; preds = %62, %64
%75 = add nuw nsw i64 %56, 1
%76 = icmp eq i64 %75, %46
br i1 %76, label %51, label %55
77: ; preds = %55, %77
%78 = phi i64 [ %99, %77 ], [ 0, %55 ]
%79 = phi i64 [ %100, %77 ], [ 0, %55 ]
%80 = trunc i64 %78 to i32
%81 = sitofp i32 %80 to double
%82 = tail call double @llvm.fmuladd.f64(double %81, double %16, double 0.000000e+00)
%83 = fmul double %82, 0x401921FB54442D18
%84 = tail call double @cos(double %83)
%85 = tail call double @cos(double %60)
%86 = fmul double %84, %85
%87 = add nuw nsw i64 %78, %61
%88 = getelementptr inbounds double, double* %29, i64 %87
store double %86, double* %88
%89 = or i64 %78, 1
%90 = trunc i64 %89 to i32
%91 = sitofp i32 %90 to double
%92 = tail call double @llvm.fmuladd.f64(double %91, double %16, double 0.000000e+00)
%93 = fmul double %92, 0x401921FB54442D18
%94 = tail call double @cos(double %93)
%95 = tail call double @cos(double %60)
%96 = fmul double %94, %95
%97 = add nuw nsw i64 %89, %61
%98 = getelementptr inbounds double, double* %29, i64 %97
store double %96, double* %98
%99 = add nuw nsw i64 %78, 2
%100 = add i64 %79, 2
%101 = icmp eq i64 %100, %49
br i1 %101, label %62, label %77
102: ; preds = %108
%103 = tail call double @llvm.fmuladd.f64(double %15, double %16, double 0.000000e+00)
br i1 %43, label %136, label %104
104: ; preds = %102
%105 = mul nsw i32 %23, %4
%106 = sext i32 %105 to i64
%107 = zext i32 %23 to i64
br label %123
108: ; preds = %53, %108
%109 = phi i64 [ 0, %53 ], [ %117, %108 ]
%110 = trunc i64 %109 to i32
%111 = sitofp i32 %110 to double
%112 = tail call double @llvm.fmuladd.f64(double %111, double %16, double 0.000000e+00)
%113 = tail call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %112, double %52, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00)
%114 = sitofp i32 %113 to double
%115 = getelementptr inbounds double, double* %33, i64 %109
store double %114, double* %115
%116 = getelementptr inbounds double, double* %29, i64 %109
store double 0.000000e+00, double* %116
%117 = add nuw nsw i64 %109, 1
%118 = icmp eq i64 %117, %54
br i1 %118, label %102, label %108
119: ; preds = %123
br i1 %43, label %136, label %120
120: ; preds = %119
%121 = sext i32 %23 to i64
%122 = zext i32 %23 to i64
br label %142
123: ; preds = %104, %123
%124 = phi i64 [ 0, %104 ], [ %133, %123 ]
%125 = trunc i64 %124 to i32
%126 = sitofp i32 %125 to double
%127 = tail call double @llvm.fmuladd.f64(double %126, double %16, double 0.000000e+00)
%128 = tail call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %127, double %103, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00)
%129 = sitofp i32 %128 to double
%130 = add nsw i64 %124, %106
%131 = getelementptr inbounds double, double* %33, i64 %130
store double %129, double* %131
%132 = getelementptr inbounds double, double* %29, i64 %130
store double 0.000000e+00, double* %132
%133 = add nuw nsw i64 %124, 1
%134 = icmp eq i64 %133, %107
br i1 %134, label %119, label %123
135: ; preds = %142
br i1 %43, label %136, label %138
136: ; preds = %14, %51, %102, %119, %135
%137 = sext i32 %23 to i64
br label %154
138: ; preds = %135
%139 = sext i32 %23 to i64
%140 = zext i32 %4 to i64
%141 = zext i32 %23 to i64
br label %194
142: ; preds = %120, %142
%143 = phi i64 [ 0, %120 ], [ %152, %142 ]
%144 = trunc i64 %143 to i32
%145 = sitofp i32 %144 to double
%146 = tail call double @llvm.fmuladd.f64(double %145, double %16, double 0.000000e+00)
%147 = tail call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %52, double %146, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00)
%148 = sitofp i32 %147 to double
%149 = mul nsw i64 %143, %121
%150 = getelementptr inbounds double, double* %33, i64 %149
store double %148, double* %150
%151 = getelementptr inbounds double, double* %29, i64 %149
store double 0.000000e+00, double* %151
%152 = add nuw nsw i64 %143, 1
%153 = icmp eq i64 %152, %122
br i1 %153, label %135, label %142
154: ; preds = %194, %136
%155 = phi i64 [ %137, %136 ], [ %139, %194 ]
%156 = fmul double %19, 2.000000e+00
%157 = fmul double %16, %16
%158 = fdiv double %156, %157
%159 = fmul double %158, -2.000000e+00
%160 = tail call double @log(double %15)
%161 = fdiv double %160, 0x3FE62E42FEFA39EF
%162 = tail call double @llvm.ceil.f64(double %161)
%163 = fptosi double %162 to i32
%164 = add i32 %163, 1
%165 = mul i32 %24, %164
%166 = sext i32 %165 to i64
%167 = shl nsw i64 %166, 3
%168 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %167, i32 64)
%169 = sext i32 %168 to i64
%170 = inttoptr i64 %169 to double*
%171 = shl nsw i64 %155, 3
%172 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @_mm_malloc to i32 (i64, i32, ...)*)(i64 %171, i32 64)
%173 = sext i32 %172 to i64
%174 = inttoptr i64 %173 to double*
%175 = icmp slt i32 %163, 0
br i1 %175, label %207, label %176
176: ; preds = %154
%177 = icmp eq i32 %24, 0
%178 = zext i32 %164 to i64
%179 = getelementptr double, double* %170, i64 %25
%180 = getelementptr double, double* %29, i64 %25
%181 = and i64 %25, 4294967292
%182 = add nsw i64 %181, -4
%183 = lshr exact i64 %182, 2
%184 = add nuw nsw i64 %183, 1
%185 = icmp ult i32 %24, 4
%186 = and i64 %25, 4294967292
%187 = and i64 %184, 1
%188 = icmp eq i64 %182, 0
%189 = and i64 %184, 9223372036854775806
%190 = icmp eq i64 %187, 0
%191 = icmp eq i64 %186, %25
%192 = and i64 %25, 3
%193 = icmp eq i64 %192, 0
br label %252
194: ; preds = %138, %194
%195 = phi i64 [ 0, %138 ], [ %205, %194 ]
%196 = trunc i64 %195 to i32
%197 = sitofp i32 %196 to double
%198 = tail call double @llvm.fmuladd.f64(double %197, double %16, double 0.000000e+00)
%199 = tail call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @test_init to i32 (double, double, double, double, double, double, ...)*)(double %103, double %198, double 1.000000e+00, double 1.000000e+00, double 2.000000e+00, double 2.000000e+00)
%200 = sitofp i32 %199 to double
%201 = mul nsw i64 %195, %139
%202 = add nsw i64 %201, %140
%203 = getelementptr inbounds double, double* %33, i64 %202
store double %200, double* %203
%204 = getelementptr inbounds double, double* %29, i64 %202
store double 0.000000e+00, double* %204
%205 = add nuw nsw i64 %195, 1
%206 = icmp eq i64 %205, %141
br i1 %206, label %154, label %194
207: ; preds = %342, %154
%208 = tail call i32 (...) @omp_get_wtime()
%209 = inttoptr i64 %36 to i8*
%210 = icmp eq i32 %24, 0
%211 = icmp sgt i32 %163, 0
%212 = sext i32 %163 to i64
%213 = zext i32 %164 to i64
%214 = getelementptr double, double* %37, i64 %25
%215 = bitcast double* %214 to i8*
%216 = getelementptr double, double* %33, i64 %25
%217 = bitcast double* %216 to i8*
%218 = getelementptr double, double* %37, i64 %25
%219 = bitcast double* %218 to i8*
%220 = getelementptr double, double* %33, i64 %25
%221 = bitcast double* %220 to i8*
%222 = insertelement <2 x double> poison, double %158, i64 0
%223 = insertelement <2 x double> %222, double %159, i64 1
%224 = and i64 %25, 4294967292
%225 = add nsw i64 %224, -4
%226 = lshr exact i64 %225, 2
%227 = add nuw nsw i64 %226, 1
%228 = icmp ult i32 %24, 4
%229 = icmp ult i8* %38, %221
%230 = icmp ult i8* %34, %219
%231 = and i1 %229, %230
%232 = and i64 %25, 4294967292
%233 = and i64 %227, 1
%234 = icmp eq i64 %225, 0
%235 = and i64 %227, 9223372036854775806
%236 = icmp eq i64 %233, 0
%237 = icmp eq i64 %232, %25
%238 = and i64 %25, 3
%239 = icmp eq i64 %238, 0
%240 = icmp ult i32 %24, 4
%241 = icmp ult i8* %38, %217
%242 = icmp ult i8* %34, %215
%243 = and i1 %241, %242
%244 = and i64 %25, 4294967292
%245 = and i64 %227, 1
%246 = icmp eq i64 %225, 0
%247 = and i64 %227, 9223372036854775806
%248 = icmp eq i64 %245, 0
%249 = icmp eq i64 %244, %25
%250 = and i64 %25, 3
%251 = icmp eq i64 %250, 0
br label %373
252: ; preds = %176, %342
%253 = phi i64 [ 0, %176 ], [ %344, %342 ]
%254 = phi double [ %19, %176 ], [ %343, %342 ]
%255 = trunc i64 %253 to i32
%256 = mul i32 %24, %255
%257 = sext i32 %256 to i64
%258 = getelementptr double, double* %170, i64 %257
%259 = getelementptr double, double* %179, i64 %257
%260 = bitcast double* %259 to i8*
br i1 %177, label %342, label %261
261: ; preds = %252
%262 = trunc i64 %253 to i32
%263 = mul i32 %24, %262
%264 = sext i32 %263 to i64
br i1 %185, label %324, label %265
265: ; preds = %261
%266 = icmp ult double* %258, %180
%267 = icmp ult i8* %30, %260
%268 = and i1 %266, %267
br i1 %268, label %324, label %269
269: ; preds = %265
%270 = insertelement <2 x double> poison, double %254, i64 0
%271 = shufflevector <2 x double> %270, <2 x double> poison, <2 x i32> zeroinitializer
%272 = insertelement <2 x double> poison, double %254, i64 0
%273 = shufflevector <2 x double> %272, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %188, label %307, label %274
274: ; preds = %269, %274
%275 = phi i64 [ %304, %274 ], [ 0, %269 ]
%276 = phi i64 [ %305, %274 ], [ 0, %269 ]
%277 = getelementptr inbounds double, double* %29, i64 %275
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = getelementptr inbounds double, double* %277, i64 2
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = fmul <2 x double> %271, %279
%284 = fmul <2 x double> %273, %282
%285 = add nsw i64 %275, %264
%286 = getelementptr inbounds double, double* %170, i64 %285
%287 = bitcast double* %286 to <2 x double>*
store <2 x double> %283, <2 x double>* %287
%288 = getelementptr inbounds double, double* %286, i64 2
%289 = bitcast double* %288 to <2 x double>*
store <2 x double> %284, <2 x double>* %289
%290 = or i64 %275, 4
%291 = getelementptr inbounds double, double* %29, i64 %290
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = getelementptr inbounds double, double* %291, i64 2
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = fmul <2 x double> %271, %293
%298 = fmul <2 x double> %273, %296
%299 = add nsw i64 %290, %264
%300 = getelementptr inbounds double, double* %170, i64 %299
%301 = bitcast double* %300 to <2 x double>*
store <2 x double> %297, <2 x double>* %301
%302 = getelementptr inbounds double, double* %300, i64 2
%303 = bitcast double* %302 to <2 x double>*
store <2 x double> %298, <2 x double>* %303
%304 = add nuw i64 %275, 8
%305 = add i64 %276, 2
%306 = icmp eq i64 %305, %189
br i1 %306, label %307, label %274
307: ; preds = %274, %269
%308 = phi i64 [ 0, %269 ], [ %304, %274 ]
br i1 %190, label %323, label %309
309: ; preds = %307
%310 = getelementptr inbounds double, double* %29, i64 %308
%311 = bitcast double* %310 to <2 x double>*
%312 = load <2 x double>, <2 x double>* %311
%313 = getelementptr inbounds double, double* %310, i64 2
%314 = bitcast double* %313 to <2 x double>*
%315 = load <2 x double>, <2 x double>* %314
%316 = fmul <2 x double> %271, %312
%317 = fmul <2 x double> %273, %315
%318 = add nsw i64 %308, %264
%319 = getelementptr inbounds double, double* %170, i64 %318
%320 = bitcast double* %319 to <2 x double>*
store <2 x double> %316, <2 x double>* %320
%321 = getelementptr inbounds double, double* %319, i64 2
%322 = bitcast double* %321 to <2 x double>*
store <2 x double> %317, <2 x double>* %322
br label %323
323: ; preds = %307, %309
br i1 %191, label %342, label %324
324: ; preds = %265, %261, %323
%325 = phi i64 [ 0, %265 ], [ 0, %261 ], [ %186, %323 ]
%326 = xor i64 %325, -1
%327 = add nsw i64 %326, %25
br i1 %193, label %339, label %328
328: ; preds = %324, %328
%329 = phi i64 [ %336, %328 ], [ %325, %324 ]
%330 = phi i64 [ %337, %328 ], [ 0, %324 ]
%331 = getelementptr inbounds double, double* %29, i64 %329
%332 = load double, double* %331
%333 = fmul double %254, %332
%334 = add nsw i64 %329, %264
%335 = getelementptr inbounds double, double* %170, i64 %334
store double %333, double* %335
%336 = add nuw nsw i64 %329, 1
%337 = add i64 %330, 1
%338 = icmp eq i64 %337, %192
br i1 %338, label %339, label %328
339: ; preds = %328, %324
%340 = phi i64 [ %325, %324 ], [ %336, %328 ]
%341 = icmp ult i64 %327, 3
br i1 %341, label %342, label %346
342: ; preds = %339, %346, %323, %252
%343 = fmul double %254, 4.000000e+00
%344 = add nuw nsw i64 %253, 1
%345 = icmp eq i64 %344, %178
br i1 %345, label %207, label %252
346: ; preds = %339, %346
%347 = phi i64 [ %371, %346 ], [ %340, %339 ]
%348 = getelementptr inbounds double, double* %29, i64 %347
%349 = load double, double* %348
%350 = fmul double %254, %349
%351 = add nsw i64 %347, %264
%352 = getelementptr inbounds double, double* %170, i64 %351
store double %350, double* %352
%353 = add nuw nsw i64 %347, 1
%354 = getelementptr inbounds double, double* %29, i64 %353
%355 = load double, double* %354
%356 = fmul double %254, %355
%357 = add nsw i64 %353, %264
%358 = getelementptr inbounds double, double* %170, i64 %357
store double %356, double* %358
%359 = add nuw nsw i64 %347, 2
%360 = getelementptr inbounds double, double* %29, i64 %359
%361 = load double, double* %360
%362 = fmul double %254, %361
%363 = add nsw i64 %359, %264
%364 = getelementptr inbounds double, double* %170, i64 %363
store double %362, double* %364
%365 = add nuw nsw i64 %347, 3
%366 = getelementptr inbounds double, double* %29, i64 %365
%367 = load double, double* %366
%368 = fmul double %254, %367
%369 = add nsw i64 %365, %264
%370 = getelementptr inbounds double, double* %170, i64 %369
store double %368, double* %370
%371 = add nuw nsw i64 %347, 4
%372 = icmp eq i64 %371, %25
br i1 %372, label %342, label %346
373: ; preds = %207, %603
%374 = phi i32 [ 0, %207 ], [ %607, %603 ]
%375 = phi <2 x double> [ %223, %207 ], [ %507, %603 ]
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %209, i8* align 8 %39, i64 %26, i1 false)
br i1 %175, label %376, label %460
376: ; preds = %460, %373
%377 = phi <2 x double> [ %375, %373 ], [ %470, %460 ]
%378 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %33, i32 %23)
%379 = sitofp i32 %378 to double
br i1 %210, label %473, label %380
380: ; preds = %376
%381 = select i1 %228, i1 true, i1 %231
br i1 %381, label %442, label %382
382: ; preds = %380
br i1 %234, label %422, label %383
383: ; preds = %382, %383
%384 = phi i64 [ %419, %383 ], [ 0, %382 ]
%385 = phi i64 [ %420, %383 ], [ 0, %382 ]
%386 = getelementptr inbounds double, double* %33, i64 %384
%387 = bitcast double* %386 to <2 x double>*
%388 = load <2 x double>, <2 x double>* %387
%389 = getelementptr inbounds double, double* %386, i64 2
%390 = bitcast double* %389 to <2 x double>*
%391 = load <2 x double>, <2 x double>* %390
%392 = getelementptr inbounds double, double* %37, i64 %384
%393 = bitcast double* %392 to <2 x double>*
%394 = load <2 x double>, <2 x double>* %393
%395 = getelementptr inbounds double, double* %392, i64 2
%396 = bitcast double* %395 to <2 x double>*
%397 = load <2 x double>, <2 x double>* %396
%398 = fsub <2 x double> %394, %388
%399 = fsub <2 x double> %397, %391
%400 = bitcast double* %392 to <2 x double>*
store <2 x double> %398, <2 x double>* %400
%401 = bitcast double* %395 to <2 x double>*
store <2 x double> %399, <2 x double>* %401
%402 = or i64 %384, 4
%403 = getelementptr inbounds double, double* %33, i64 %402
%404 = bitcast double* %403 to <2 x double>*
%405 = load <2 x double>, <2 x double>* %404
%406 = getelementptr inbounds double, double* %403, i64 2
%407 = bitcast double* %406 to <2 x double>*
%408 = load <2 x double>, <2 x double>* %407
%409 = getelementptr inbounds double, double* %37, i64 %402
%410 = bitcast double* %409 to <2 x double>*
%411 = load <2 x double>, <2 x double>* %410
%412 = getelementptr inbounds double, double* %409, i64 2
%413 = bitcast double* %412 to <2 x double>*
%414 = load <2 x double>, <2 x double>* %413
%415 = fsub <2 x double> %411, %405
%416 = fsub <2 x double> %414, %408
%417 = bitcast double* %409 to <2 x double>*
store <2 x double> %415, <2 x double>* %417
%418 = bitcast double* %412 to <2 x double>*
store <2 x double> %416, <2 x double>* %418
%419 = add nuw i64 %384, 8
%420 = add i64 %385, 2
%421 = icmp eq i64 %420, %235
br i1 %421, label %422, label %383
422: ; preds = %383, %382
%423 = phi i64 [ 0, %382 ], [ %419, %383 ]
br i1 %236, label %441, label %424
424: ; preds = %422
%425 = getelementptr inbounds double, double* %33, i64 %423
%426 = bitcast double* %425 to <2 x double>*
%427 = load <2 x double>, <2 x double>* %426
%428 = getelementptr inbounds double, double* %425, i64 2
%429 = bitcast double* %428 to <2 x double>*
%430 = load <2 x double>, <2 x double>* %429
%431 = getelementptr inbounds double, double* %37, i64 %423
%432 = bitcast double* %431 to <2 x double>*
%433 = load <2 x double>, <2 x double>* %432
%434 = getelementptr inbounds double, double* %431, i64 2
%435 = bitcast double* %434 to <2 x double>*
%436 = load <2 x double>, <2 x double>* %435
%437 = fsub <2 x double> %433, %427
%438 = fsub <2 x double> %436, %430
%439 = bitcast double* %431 to <2 x double>*
store <2 x double> %437, <2 x double>* %439
%440 = bitcast double* %434 to <2 x double>*
store <2 x double> %438, <2 x double>* %440
br label %441
441: ; preds = %422, %424
br i1 %237, label %473, label %442
442: ; preds = %380, %441
%443 = phi i64 [ 0, %380 ], [ %232, %441 ]
%444 = xor i64 %443, -1
%445 = add nsw i64 %444, %25
br i1 %239, label %457, label %446
446: ; preds = %442, %446
%447 = phi i64 [ %454, %446 ], [ %443, %442 ]
%448 = phi i64 [ %455, %446 ], [ 0, %442 ]
%449 = getelementptr inbounds double, double* %33, i64 %447
%450 = load double, double* %449
%451 = getelementptr inbounds double, double* %37, i64 %447
%452 = load double, double* %451
%453 = fsub double %452, %450
store double %453, double* %451
%454 = add nuw nsw i64 %447, 1
%455 = add i64 %448, 1
%456 = icmp eq i64 %455, %238
br i1 %456, label %457, label %446
457: ; preds = %446, %442
%458 = phi i64 [ %443, %442 ], [ %454, %446 ]
%459 = icmp ult i64 %445, 3
br i1 %459, label %473, label %478
460: ; preds = %373, %460
%461 = phi i64 [ %471, %460 ], [ 0, %373 ]
%462 = phi <2 x double> [ %470, %460 ], [ %375, %373 ]
%463 = trunc i64 %461 to i32
%464 = mul i32 %24, %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %170, i64 %465
%467 = extractelement <2 x double> %462, i64 0
%468 = extractelement <2 x double> %462, i64 1
%469 = tail call i32 (double*, double*, double*, double, double, i32, ...) bitcast (i32 (...)* @relaxOperation to i32 (double*, double*, double*, double, double, i32, ...)*)(double* %33, double* %466, double* %174, double %467, double %468, i32 %23)
%470 = fmul <2 x double> %462, <double 4.000000e+00, double 4.000000e+00>
%471 = add nuw nsw i64 %461, 1
%472 = icmp eq i64 %471, %213
br i1 %472, label %376, label %460
473: ; preds = %457, %478, %441, %376
%474 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %37, i32 %23)
%475 = sitofp i32 %474 to double
%476 = fdiv double %475, %379
%477 = fcmp olt double %476, 0x3EB0C6F7A0B5ED8D
br i1 %477, label %638, label %505
478: ; preds = %457, %478
%479 = phi i64 [ %503, %478 ], [ %458, %457 ]
%480 = getelementptr inbounds double, double* %33, i64 %479
%481 = load double, double* %480
%482 = getelementptr inbounds double, double* %37, i64 %479
%483 = load double, double* %482
%484 = fsub double %483, %481
store double %484, double* %482
%485 = add nuw nsw i64 %479, 1
%486 = getelementptr inbounds double, double* %33, i64 %485
%487 = load double, double* %486
%488 = getelementptr inbounds double, double* %37, i64 %485
%489 = load double, double* %488
%490 = fsub double %489, %487
store double %490, double* %488
%491 = add nuw nsw i64 %479, 2
%492 = getelementptr inbounds double, double* %33, i64 %491
%493 = load double, double* %492
%494 = getelementptr inbounds double, double* %37, i64 %491
%495 = load double, double* %494
%496 = fsub double %495, %493
store double %496, double* %494
%497 = add nuw nsw i64 %479, 3
%498 = getelementptr inbounds double, double* %33, i64 %497
%499 = load double, double* %498
%500 = getelementptr inbounds double, double* %37, i64 %497
%501 = load double, double* %500
%502 = fsub double %501, %499
store double %502, double* %500
%503 = add nuw nsw i64 %479, 4
%504 = icmp eq i64 %503, %25
br i1 %504, label %473, label %478
505: ; preds = %473
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %209, i8* align 8 %39, i64 %26, i1 false)
br i1 %211, label %590, label %506
506: ; preds = %590, %505
%507 = phi <2 x double> [ %377, %505 ], [ %594, %590 ]
%508 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %33, i32 %23)
%509 = sitofp i32 %508 to double
br i1 %210, label %603, label %510
510: ; preds = %506
%511 = select i1 %240, i1 true, i1 %243
br i1 %511, label %572, label %512
512: ; preds = %510
br i1 %246, label %552, label %513
513: ; preds = %512, %513
%514 = phi i64 [ %549, %513 ], [ 0, %512 ]
%515 = phi i64 [ %550, %513 ], [ 0, %512 ]
%516 = getelementptr inbounds double, double* %33, i64 %514
%517 = bitcast double* %516 to <2 x double>*
%518 = load <2 x double>, <2 x double>* %517
%519 = getelementptr inbounds double, double* %516, i64 2
%520 = bitcast double* %519 to <2 x double>*
%521 = load <2 x double>, <2 x double>* %520
%522 = getelementptr inbounds double, double* %37, i64 %514
%523 = bitcast double* %522 to <2 x double>*
%524 = load <2 x double>, <2 x double>* %523
%525 = getelementptr inbounds double, double* %522, i64 2
%526 = bitcast double* %525 to <2 x double>*
%527 = load <2 x double>, <2 x double>* %526
%528 = fsub <2 x double> %524, %518
%529 = fsub <2 x double> %527, %521
%530 = bitcast double* %522 to <2 x double>*
store <2 x double> %528, <2 x double>* %530
%531 = bitcast double* %525 to <2 x double>*
store <2 x double> %529, <2 x double>* %531
%532 = or i64 %514, 4
%533 = getelementptr inbounds double, double* %33, i64 %532
%534 = bitcast double* %533 to <2 x double>*
%535 = load <2 x double>, <2 x double>* %534
%536 = getelementptr inbounds double, double* %533, i64 2
%537 = bitcast double* %536 to <2 x double>*
%538 = load <2 x double>, <2 x double>* %537
%539 = getelementptr inbounds double, double* %37, i64 %532
%540 = bitcast double* %539 to <2 x double>*
%541 = load <2 x double>, <2 x double>* %540
%542 = getelementptr inbounds double, double* %539, i64 2
%543 = bitcast double* %542 to <2 x double>*
%544 = load <2 x double>, <2 x double>* %543
%545 = fsub <2 x double> %541, %535
%546 = fsub <2 x double> %544, %538
%547 = bitcast double* %539 to <2 x double>*
store <2 x double> %545, <2 x double>* %547
%548 = bitcast double* %542 to <2 x double>*
store <2 x double> %546, <2 x double>* %548
%549 = add nuw i64 %514, 8
%550 = add i64 %515, 2
%551 = icmp eq i64 %550, %247
br i1 %551, label %552, label %513
552: ; preds = %513, %512
%553 = phi i64 [ 0, %512 ], [ %549, %513 ]
br i1 %248, label %571, label %554
554: ; preds = %552
%555 = getelementptr inbounds double, double* %33, i64 %553
%556 = bitcast double* %555 to <2 x double>*
%557 = load <2 x double>, <2 x double>* %556
%558 = getelementptr inbounds double, double* %555, i64 2
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = getelementptr inbounds double, double* %37, i64 %553
%562 = bitcast double* %561 to <2 x double>*
%563 = load <2 x double>, <2 x double>* %562
%564 = getelementptr inbounds double, double* %561, i64 2
%565 = bitcast double* %564 to <2 x double>*
%566 = load <2 x double>, <2 x double>* %565
%567 = fsub <2 x double> %563, %557
%568 = fsub <2 x double> %566, %560
%569 = bitcast double* %561 to <2 x double>*
store <2 x double> %567, <2 x double>* %569
%570 = bitcast double* %564 to <2 x double>*
store <2 x double> %568, <2 x double>* %570
br label %571
571: ; preds = %552, %554
br i1 %249, label %603, label %572
572: ; preds = %510, %571
%573 = phi i64 [ 0, %510 ], [ %244, %571 ]
%574 = xor i64 %573, -1
%575 = add nsw i64 %574, %25
br i1 %251, label %587, label %576
576: ; preds = %572, %576
%577 = phi i64 [ %584, %576 ], [ %573, %572 ]
%578 = phi i64 [ %585, %576 ], [ 0, %572 ]
%579 = getelementptr inbounds double, double* %33, i64 %577
%580 = load double, double* %579
%581 = getelementptr inbounds double, double* %37, i64 %577
%582 = load double, double* %581
%583 = fsub double %582, %580
store double %583, double* %581
%584 = add nuw nsw i64 %577, 1
%585 = add i64 %578, 1
%586 = icmp eq i64 %585, %250
br i1 %586, label %587, label %576
587: ; preds = %576, %572
%588 = phi i64 [ %573, %572 ], [ %584, %576 ]
%589 = icmp ult i64 %575, 3
br i1 %589, label %603, label %611
590: ; preds = %505, %590
%591 = phi i64 [ %593, %590 ], [ %212, %505 ]
%592 = phi <2 x double> [ %594, %590 ], [ %377, %505 ]
%593 = add nsw i64 %591, -1
%594 = fmul <2 x double> %592, <double 2.500000e-01, double 2.500000e-01>
%595 = trunc i64 %593 to i32
%596 = mul i32 %24, %595
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %170, i64 %597
%599 = extractelement <2 x double> %594, i64 0
%600 = extractelement <2 x double> %594, i64 1
%601 = tail call i32 (double*, double*, double*, double, double, i32, ...) bitcast (i32 (...)* @relaxOperation to i32 (double*, double*, double*, double, double, i32, ...)*)(double* %33, double* %598, double* %174, double %599, double %600, i32 %23)
%602 = icmp sgt i64 %591, 1
br i1 %602, label %590, label %506
603: ; preds = %587, %611, %571, %506
%604 = tail call i32 (double*, i32, ...) bitcast (i32 (...)* @normInf_cache to i32 (double*, i32, ...)*)(double* %37, i32 %23)
%605 = sitofp i32 %604 to double
%606 = fdiv double %605, %509
%607 = add nuw nsw i32 %374, 1
%608 = fcmp ogt double %606, 0x3EB0C6F7A0B5ED8D
%609 = icmp ult i32 %374, 199
%610 = select i1 %608, i1 %609, i1 false
br i1 %610, label %373, label %638
611: ; preds = %587, %611
%612 = phi i64 [ %636, %611 ], [ %588, %587 ]
%613 = getelementptr inbounds double, double* %33, i64 %612
%614 = load double, double* %613
%615 = getelementptr inbounds double, double* %37, i64 %612
%616 = load double, double* %615
%617 = fsub double %616, %614
store double %617, double* %615
%618 = add nuw nsw i64 %612, 1
%619 = getelementptr inbounds double, double* %33, i64 %618
%620 = load double, double* %619
%621 = getelementptr inbounds double, double* %37, i64 %618
%622 = load double, double* %621
%623 = fsub double %622, %620
store double %623, double* %621
%624 = add nuw nsw i64 %612, 2
%625 = getelementptr inbounds double, double* %33, i64 %624
%626 = load double, double* %625
%627 = getelementptr inbounds double, double* %37, i64 %624
%628 = load double, double* %627
%629 = fsub double %628, %626
store double %629, double* %627
%630 = add nuw nsw i64 %612, 3
%631 = getelementptr inbounds double, double* %33, i64 %630
%632 = load double, double* %631
%633 = getelementptr inbounds double, double* %37, i64 %630
%634 = load double, double* %633
%635 = fsub double %634, %632
store double %635, double* %633
%636 = add nuw nsw i64 %612, 4
%637 = icmp eq i64 %636, %25
br i1 %637, label %603, label %611
638: ; preds = %473, %603
%639 = phi i32 [ %374, %473 ], [ %607, %603 ]
%640 = phi double [ %476, %473 ], [ %606, %603 ]
%641 = phi i32 [ 1, %473 ], [ 0, %603 ]
%642 = sitofp i32 %208 to double
%643 = tail call i32 (...) @omp_get_wtime()
%644 = sitofp i32 %643 to double
%645 = tail call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %174)
%646 = tail call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %170)
%647 = tail call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %29)
%648 = tail call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %33)
%649 = tail call i32 (double*, ...) bitcast (i32 (...)* @_mm_free to i32 (double*, ...)*)(double* %37)
%650 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.8, i64 0, i64 0))
%651 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.5, i64 0, i64 0), double %640)
%652 = shl nuw nsw i32 %639, 1
%653 = or i32 %641, %652
%654 = mul i32 %653, %164
%655 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0), i32 %654)
%656 = fsub double %644, %642
%657 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.7, i64 0, i64 0), double %656)
ret i32 0
}