#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ check_offloading();
scalar_t__ check_results(double *);
double *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  int fail = 0;
  int expected = 1;
  int success = 0;
  int chunkSize;
  double p = 2.0, q = 4.0;
  int nte, tl, blockSize;
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  printf("iterations = teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("iterations > teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("iterations < teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static,1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static,512)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static, chunkSize)\n");
  chunkSize = (992) / 10;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(1024) dist_schedule(static, chunkSize)\n");
  chunkSize = (992) / 10;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(1024) dist_schedule(static, 1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(3) dist_schedule(static, 1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(3) dist_schedule(static, 3)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(10) dist_schedule(static, 99)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(256) dist_schedule(static, 992)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute simd CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(nte) thread_limit(tl) with parallel for innermost\n");
  success = 0;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  nte = 32;
  tl = 64;
  blockSize = tl;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams distribute simd num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 256; j += blockSize) {
      for (int i = j; i < j + blockSize; i++) {
        A[i] += B[i] + C[i];
      }
    }
  }
  for (int i = 0; i < 256; i++) {
    if (A[i] != (1)) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(2.0 + 3.0) * (1),
             A[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(nte) thread_limit(tl) with parallel for innermost\n");
  success = 0;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  nte = 32;
  tl = 64;
  blockSize = tl;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams distribute simd num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 510; j += blockSize) {
      int ub = (j + blockSize < 510) ? (j + blockSize) : 512;
      for (int i = j; i < ub; i++) {
        A[i] += B[i] + C[i];
      }
    }
  }
  for (int i = 0; i < 256; i++) {
    if (A[i] != (1)) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(2.0 + 3.0) * (1),
             A[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(512) collapse(2)\n");
  success = 0;
  double *S = malloc((992) * (992) * sizeof(double));
  double *T = malloc((992) * (992) * sizeof(double));
  double *U = malloc((992) * (992) * sizeof(double));
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++) {
      S[i * (992) + j] = 0.0;
      T[i * (992) + j] = 1.0;
      U[i * (992) + j] = 2.0;
    }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : S[:N * N]), map(to : T[:N * N], U[:N * N])
#pragma omp teams distribute simd num_teams(512) collapse(2)
    for (int i = 0; i < (992); i++)
      for (int j = 0; j < (992); j++)
        S[i * (992) + j] += T[i * (992) + j] + U[i * (992) + j];
  }
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++)
      if (S[i * (992) + j] != (1) * 3.0) {
        printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j, (double)(1) * 3.0,
               S[i * (992) + j]);
        fail = 1;
      }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(512) collapse(3)\n");
  success = 0;
  int M = (992) / 8;
  double *V = malloc(M * M * M * sizeof(double));
  double *Z = malloc(M * M * M * sizeof(double));
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++) {
        V[i * M * M + j * M + k] = 2.0;
        Z[i * M * M + j * M + k] = 3.0;
      }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : V[:M * M * M]), map(to : Z[:M * M * M])
#pragma omp teams distribute simd num_teams(512) collapse(3)
    for (int i = 0; i < M; i++)
      for (int j = 0; j < M; j++)
        for (int k = 0; k < M; k++)
          V[i * M * M + j * M + k] += Z[i * M * M + j * M + k];
  }
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++)
        if (V[i * M * M + j * M + k] != 2.0 + (1) * 3.0) {
          printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j,
                 (double)(1) * 3.0, V[i * M * M + j * M + k]);
          fail = 1;
        }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9c80,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1050 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
movl   $0x1,-0x9b18(%rbp)
movl   $0x0,-0x9b1c(%rbp)
movsd  0x1e89(%rip),%xmm0
movsd  %xmm0,-0x9b28(%rbp)
ff
movsd  0x1e71(%rip),%xmm0
movsd  %xmm0,-0x9b30(%rbp)
ff
movl   $0x0,-0x9b40(%rbp)
cmpl   $0x3e0,-0x9b40(%rbp)
jge    1211 <main+0xd1>
movslq -0x9b40(%rbp),%rax
movsd  0x1e60(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b40(%rbp),%xmm0
ff
movslq -0x9b40(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b40(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b40(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    11a1 <main+0x61>
lea    0x1e10(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b44(%rbp)
cmpl   $0x3e0,-0x9b44(%rbp)
jge    1260 <main+0x120>
movslq -0x9b44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b44(%rbp)
jmp    1229 <main+0xe9>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b48(%rbp)
cmpl   $0x1,-0x9b48(%rbp)
jge    12f1 <main+0x1b1>
movl   $0x0,-0x9b4c(%rbp)
cmpl   $0x3e0,-0x9b4c(%rbp)
jge    12d8 <main+0x198>
movslq -0x9b4c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b4c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    128b <main+0x14b>
jmp    12dd <main+0x19d>
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    1274 <main+0x134>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1330 <main+0x1f0>
lea    0x1d13(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d10(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b50(%rbp)
cmpl   $0x3e0,-0x9b50(%rbp)
jge    137f <main+0x23f>
movslq -0x9b50(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b50(%rbp)
jmp    1348 <main+0x208>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b54(%rbp)
cmpl   $0x1,-0x9b54(%rbp)
jge    1410 <main+0x2d0>
movl   $0x0,-0x9b58(%rbp)
cmpl   $0x3e0,-0x9b58(%rbp)
jge    13f7 <main+0x2b7>
movslq -0x9b58(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b58(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    13aa <main+0x26a>
jmp    13fc <main+0x2bc>
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    1393 <main+0x253>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    144f <main+0x30f>
lea    0x1bf4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b5c(%rbp)
cmpl   $0x3e0,-0x9b5c(%rbp)
jge    149e <main+0x35e>
movslq -0x9b5c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b5c(%rbp)
jmp    1467 <main+0x327>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x1,-0x9b60(%rbp)
jge    152f <main+0x3ef>
movl   $0x0,-0x9b64(%rbp)
cmpl   $0x3e0,-0x9b64(%rbp)
jge    1516 <main+0x3d6>
movslq -0x9b64(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b64(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
mov    -0x9b64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b64(%rbp)
jmp    14c9 <main+0x389>
jmp    151b <main+0x3db>
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    14b2 <main+0x372>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    156e <main+0x42e>
lea    0x1ad5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1afa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b68(%rbp)
cmpl   $0x3e0,-0x9b68(%rbp)
jge    15bd <main+0x47d>
movslq -0x9b68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b68(%rbp)
jmp    1586 <main+0x446>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b6c(%rbp)
cmpl   $0x1,-0x9b6c(%rbp)
jge    164e <main+0x50e>
movl   $0x0,-0x9b70(%rbp)
cmpl   $0x3e0,-0x9b70(%rbp)
jge    1635 <main+0x4f5>
movslq -0x9b70(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b70(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b70(%rbp)
jmp    15e8 <main+0x4a8>
jmp    163a <main+0x4fa>
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    15d1 <main+0x491>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    168d <main+0x54d>
lea    0x19b6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a03(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b74(%rbp)
cmpl   $0x3e0,-0x9b74(%rbp)
jge    16dc <main+0x59c>
movslq -0x9b74(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b74(%rbp)
jmp    16a5 <main+0x565>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b78(%rbp)
cmpl   $0x1,-0x9b78(%rbp)
jge    176d <main+0x62d>
movl   $0x0,-0x9b7c(%rbp)
cmpl   $0x3e0,-0x9b7c(%rbp)
jge    1754 <main+0x614>
movslq -0x9b7c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b7c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b7c(%rbp)
jmp    1707 <main+0x5c7>
jmp    1759 <main+0x619>
mov    -0x9b78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b78(%rbp)
jmp    16f0 <main+0x5b0>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    17ac <main+0x66c>
lea    0x1897(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x190e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x63,-0x9b20(%rbp)
movl   $0x0,-0x9b80(%rbp)
cmpl   $0x3e0,-0x9b80(%rbp)
jge    1805 <main+0x6c5>
movslq -0x9b80(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b80(%rbp)
jmp    17ce <main+0x68e>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b84(%rbp)
cmpl   $0x1,-0x9b84(%rbp)
jge    1896 <main+0x756>
movl   $0x0,-0x9b88(%rbp)
cmpl   $0x3e0,-0x9b88(%rbp)
jge    187d <main+0x73d>
movslq -0x9b88(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b88(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1830 <main+0x6f0>
jmp    1882 <main+0x742>
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1819 <main+0x6d9>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    18d5 <main+0x795>
lea    0x176e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1816(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x63,-0x9b20(%rbp)
movl   $0x0,-0x9b8c(%rbp)
cmpl   $0x3e0,-0x9b8c(%rbp)
jge    192e <main+0x7ee>
movslq -0x9b8c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b8c(%rbp)
jmp    18f7 <main+0x7b7>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b90(%rbp)
cmpl   $0x1,-0x9b90(%rbp)
jge    19bf <main+0x87f>
movl   $0x0,-0x9b94(%rbp)
cmpl   $0x3e0,-0x9b94(%rbp)
jge    19a6 <main+0x866>
movslq -0x9b94(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b94(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b94(%rbp)
jmp    1959 <main+0x819>
jmp    19ab <main+0x86b>
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1942 <main+0x802>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    19fe <main+0x8be>
lea    0x1645(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x171f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b98(%rbp)
cmpl   $0x3e0,-0x9b98(%rbp)
jge    1a4d <main+0x90d>
movslq -0x9b98(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    1a16 <main+0x8d6>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b9c(%rbp)
cmpl   $0x1,-0x9b9c(%rbp)
jge    1ade <main+0x99e>
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x3e0,-0x9ba0(%rbp)
jge    1ac5 <main+0x985>
movslq -0x9ba0(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9ba0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    1a78 <main+0x938>
jmp    1aca <main+0x98a>
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    1a61 <main+0x921>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1b1d <main+0x9dd>
lea    0x1526(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x162a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9ba4(%rbp)
cmpl   $0x3e0,-0x9ba4(%rbp)
jge    1b6c <main+0xa2c>
movslq -0x9ba4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ba4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba4(%rbp)
jmp    1b35 <main+0x9f5>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9ba8(%rbp)
cmpl   $0x1,-0x9ba8(%rbp)
jge    1bfd <main+0xabd>
movl   $0x0,-0x9bac(%rbp)
cmpl   $0x3e0,-0x9bac(%rbp)
jge    1be4 <main+0xaa4>
movslq -0x9bac(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bac(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bac(%rbp)
jmp    1b97 <main+0xa57>
jmp    1be9 <main+0xaa9>
mov    -0x9ba8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba8(%rbp)
jmp    1b80 <main+0xa40>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1c3c <main+0xafc>
lea    0x1407(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1532(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bb0(%rbp)
cmpl   $0x3e0,-0x9bb0(%rbp)
jge    1c8b <main+0xb4b>
movslq -0x9bb0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    1c54 <main+0xb14>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x1,-0x9bb4(%rbp)
jge    1d1c <main+0xbdc>
movl   $0x0,-0x9bb8(%rbp)
cmpl   $0x3e0,-0x9bb8(%rbp)
jge    1d03 <main+0xbc3>
movslq -0x9bb8(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bb8(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    1cb6 <main+0xb76>
jmp    1d08 <main+0xbc8>
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    1c9f <main+0xb5f>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1d5b <main+0xc1b>
lea    0x12e8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x143a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bbc(%rbp)
cmpl   $0x3e0,-0x9bbc(%rbp)
jge    1daa <main+0xc6a>
movslq -0x9bbc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bbc(%rbp)
jmp    1d73 <main+0xc33>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bc0(%rbp)
cmpl   $0x1,-0x9bc0(%rbp)
jge    1e3b <main+0xcfb>
movl   $0x0,-0x9bc4(%rbp)
cmpl   $0x3e0,-0x9bc4(%rbp)
jge    1e22 <main+0xce2>
movslq -0x9bc4(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc4(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc4(%rbp)
jmp    1dd5 <main+0xc95>
jmp    1e27 <main+0xce7>
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    1dbe <main+0xc7e>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1e7a <main+0xd3a>
lea    0x11c9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1344(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bc8(%rbp)
cmpl   $0x3e0,-0x9bc8(%rbp)
jge    1ec9 <main+0xd89>
movslq -0x9bc8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    1e92 <main+0xd52>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bcc(%rbp)
cmpl   $0x1,-0x9bcc(%rbp)
jge    1f5a <main+0xe1a>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x3e0,-0x9bd0(%rbp)
jge    1f41 <main+0xe01>
movslq -0x9bd0(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bd0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    1ef4 <main+0xdb4>
jmp    1f46 <main+0xe06>
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    1edd <main+0xd9d>
lea    -0x1f10(%rbp),%rdi
call   1060 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1f99 <main+0xe59>
lea    0x10aa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1250(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bd4(%rbp)
cmpl   $0x3e0,-0x9bd4(%rbp)
jge    1ff2 <main+0xeb2>
movslq -0x9bd4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd4(%rbp)
jmp    1fbb <main+0xe7b>
movl   $0x0,-0x9bd8(%rbp)
cmpl   $0x3e0,-0x9bd8(%rbp)
jge    2033 <main+0xef3>
movslq -0x9bd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd8(%rbp)
jmp    1ffc <main+0xebc>
movl   $0x20,-0x9b34(%rbp)
movl   $0x40,-0x9b38(%rbp)
mov    -0x9b38(%rbp),%eax
mov    %eax,-0x9b3c(%rbp)
movl   $0x0,-0x9bdc(%rbp)
cmpl   $0x1,-0x9bdc(%rbp)
jge    212c <main+0xfec>
movl   $0x0,-0x9be0(%rbp)
cmpl   $0x100,-0x9be0(%rbp)
jge    2113 <main+0xfd3>
mov    -0x9be0(%rbp),%eax
mov    %eax,-0x9be4(%rbp)
mov    -0x9be4(%rbp),%eax
mov    -0x9be0(%rbp),%ecx
add    -0x9b3c(%rbp),%ecx
cmp    %ecx,%eax
jge    20f7 <main+0xfb7>
movslq -0x9be4(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9be4(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9be4(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    2090 <main+0xf50>
jmp    20fc <main+0xfbc>
mov    -0x9b3c(%rbp),%eax
add    -0x9be0(%rbp),%eax
mov    %eax,-0x9be0(%rbp)
jmp    2074 <main+0xf34>
jmp    2118 <main+0xfd8>
mov    -0x9bdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bdc(%rbp)
jmp    205d <main+0xf1d>
movl   $0x0,-0x9be8(%rbp)
cmpl   $0x100,-0x9be8(%rbp)
jge    21c2 <main+0x1082>
movslq -0x9be8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xec2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2173 <main+0x1033>
jp     2173 <main+0x1033>
jmp    21a9 <main+0x1069>
mov    -0x9be8(%rbp),%esi
movslq -0x9be8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x109d(%rip),%rdi
movsd  0xe78(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    21ae <main+0x106e>
mov    -0x9be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be8(%rbp)
jmp    2136 <main+0xff6>
cmpl   $0x0,-0x9b14(%rbp)
je     21e2 <main+0x10a2>
lea    0x1079(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    21f0 <main+0x10b0>
lea    0xe53(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xff9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bec(%rbp)
cmpl   $0x3e0,-0x9bec(%rbp)
jge    2249 <main+0x1109>
movslq -0x9bec(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bec(%rbp)
jmp    2212 <main+0x10d2>
movl   $0x0,-0x9bf0(%rbp)
cmpl   $0x3e0,-0x9bf0(%rbp)
jge    228a <main+0x114a>
movslq -0x9bf0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf0(%rbp)
jmp    2253 <main+0x1113>
movl   $0x20,-0x9b34(%rbp)
movl   $0x40,-0x9b38(%rbp)
mov    -0x9b38(%rbp),%eax
mov    %eax,-0x9b3c(%rbp)
movl   $0x0,-0x9bf4(%rbp)
cmpl   $0x1,-0x9bf4(%rbp)
jge    23c5 <main+0x1285>
movl   $0x0,-0x9bf8(%rbp)
cmpl   $0x1fe,-0x9bf8(%rbp)
jge    23ac <main+0x126c>
mov    -0x9bf8(%rbp),%eax
add    -0x9b3c(%rbp),%eax
cmp    $0x1fe,%eax
jge    2309 <main+0x11c9>
mov    -0x9bf8(%rbp),%eax
add    -0x9b3c(%rbp),%eax
mov    %eax,-0x9c7c(%rbp)
jmp    2319 <main+0x11d9>
mov    $0x200,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    2319 <main+0x11d9>
mov    -0x9c7c(%rbp),%eax
mov    %eax,-0x9bfc(%rbp)
mov    -0x9bf8(%rbp),%eax
mov    %eax,-0x9c00(%rbp)
mov    -0x9c00(%rbp),%eax
cmp    -0x9bfc(%rbp),%eax
jge    2390 <main+0x1250>
movslq -0x9c00(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c00(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c00(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c00(%rbp)
jmp    2331 <main+0x11f1>
jmp    2395 <main+0x1255>
mov    -0x9b3c(%rbp),%eax
add    -0x9bf8(%rbp),%eax
mov    %eax,-0x9bf8(%rbp)
jmp    22cb <main+0x118b>
jmp    23b1 <main+0x1271>
mov    -0x9bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf4(%rbp)
jmp    22b4 <main+0x1174>
movl   $0x0,-0x9c04(%rbp)
cmpl   $0x100,-0x9c04(%rbp)
jge    245b <main+0x131b>
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xc29(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    240c <main+0x12cc>
jp     240c <main+0x12cc>
jmp    2442 <main+0x1302>
mov    -0x9c04(%rbp),%esi
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0xe04(%rip),%rdi
movsd  0xbdf(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2447 <main+0x1307>
mov    -0x9c04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c04(%rbp)
jmp    23cf <main+0x128f>
cmpl   $0x0,-0x9b14(%rbp)
je     247b <main+0x133b>
lea    0xde0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2489 <main+0x1349>
lea    0xbba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdc7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c10(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c18(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c20(%rbp)
movl   $0x0,-0x9c24(%rbp)
cmpl   $0x3e0,-0x9c24(%rbp)
jge    25a5 <main+0x1465>
movl   $0x0,-0x9c28(%rbp)
cmpl   $0x3e0,-0x9c28(%rbp)
jge    258c <main+0x144c>
mov    -0x9c10(%rbp),%rax
imul   $0x3e0,-0x9c24(%rbp),%ecx
add    -0x9c28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c24(%rbp),%ecx
add    -0x9c28(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xad4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c20(%rbp),%rax
imul   $0x3e0,-0x9c24(%rbp),%ecx
add    -0x9c28(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xa95(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    24f8 <main+0x13b8>
jmp    2591 <main+0x1451>
mov    -0x9c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c24(%rbp)
jmp    24de <main+0x139e>
movl   $0x0,-0x9c2c(%rbp)
cmpl   $0x1,-0x9c2c(%rbp)
jge    2698 <main+0x1558>
movl   $0x0,-0x9c30(%rbp)
cmpl   $0x3e0,-0x9c30(%rbp)
jge    267f <main+0x153f>
movl   $0x0,-0x9c34(%rbp)
cmpl   $0x3e0,-0x9c34(%rbp)
jge    2666 <main+0x1526>
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c30(%rbp),%ecx
add    -0x9c34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c20(%rbp),%rax
imul   $0x3e0,-0x9c30(%rbp),%ecx
add    -0x9c34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x9c10(%rbp),%rax
imul   $0x3e0,-0x9c30(%rbp),%ecx
add    -0x9c34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    25e0 <main+0x14a0>
jmp    266b <main+0x152b>
mov    -0x9c30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c30(%rbp)
jmp    25c6 <main+0x1486>
jmp    2684 <main+0x1544>
mov    -0x9c2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c2c(%rbp)
jmp    25af <main+0x146f>
movl   $0x0,-0x9c38(%rbp)
cmpl   $0x3e0,-0x9c38(%rbp)
jge    2785 <main+0x1645>
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x3e0,-0x9c3c(%rbp)
jge    276c <main+0x162c>
mov    -0x9c10(%rbp),%rax
imul   $0x3e0,-0x9c38(%rbp),%ecx
add    -0x9c3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x925(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2708 <main+0x15c8>
jp     2708 <main+0x15c8>
jmp    2753 <main+0x1613>
mov    -0x9c38(%rbp),%esi
mov    -0x9c3c(%rbp),%edx
mov    -0x9c10(%rbp),%rax
imul   $0x3e0,-0x9c38(%rbp),%ecx
add    -0x9c3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xb39(%rip),%rdi
movsd  0x8d6(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2758 <main+0x1618>
mov    -0x9c3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c3c(%rbp)
jmp    26bc <main+0x157c>
jmp    2771 <main+0x1631>
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c38(%rbp)
jmp    26a2 <main+0x1562>
cmpl   $0x0,-0x9b14(%rbp)
je     27a5 <main+0x1665>
lea    0xab6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    27b3 <main+0x1673>
lea    0x890(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xadd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x7c,-0x9c40(%rbp)
mov    -0x9c40(%rbp),%eax
imul   -0x9c40(%rbp),%eax
imul   -0x9c40(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c48(%rbp)
mov    -0x9c40(%rbp),%eax
imul   -0x9c40(%rbp),%eax
imul   -0x9c40(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c50(%rbp)
movl   $0x0,-0x9c54(%rbp)
mov    -0x9c54(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    293f <main+0x17ff>
movl   $0x0,-0x9c58(%rbp)
mov    -0x9c58(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2926 <main+0x17e6>
movl   $0x0,-0x9c5c(%rbp)
mov    -0x9c5c(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    290d <main+0x17cd>
mov    -0x9c48(%rbp),%rax
mov    -0x9c54(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c58(%rbp),%edx
imul   -0x9c40(%rbp),%edx
add    %edx,%ecx
add    -0x9c5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x754(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c50(%rbp),%rax
mov    -0x9c54(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c58(%rbp),%edx
imul   -0x9c40(%rbp),%edx
add    %edx,%ecx
add    -0x9c5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x724(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    2867 <main+0x1727>
jmp    2912 <main+0x17d2>
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c58(%rbp)
jmp    284b <main+0x170b>
jmp    292b <main+0x17eb>
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    282f <main+0x16ef>
movl   $0x0,-0x9c60(%rbp)
cmpl   $0x1,-0x9c60(%rbp)
jge    2a7e <main+0x193e>
movl   $0x0,-0x9c64(%rbp)
mov    -0x9c64(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2a65 <main+0x1925>
movl   $0x0,-0x9c68(%rbp)
mov    -0x9c68(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2a4c <main+0x190c>
movl   $0x0,-0x9c6c(%rbp)
mov    -0x9c6c(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2a33 <main+0x18f3>
mov    -0x9c50(%rbp),%rax
mov    -0x9c64(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c68(%rbp),%edx
imul   -0x9c40(%rbp),%edx
add    %edx,%ecx
add    -0x9c6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c48(%rbp),%rax
mov    -0x9c64(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c68(%rbp),%edx
imul   -0x9c40(%rbp),%edx
add    %edx,%ecx
add    -0x9c6c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c6c(%rbp)
jmp    2998 <main+0x1858>
jmp    2a38 <main+0x18f8>
mov    -0x9c68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c68(%rbp)
jmp    297c <main+0x183c>
jmp    2a51 <main+0x1911>
mov    -0x9c64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c64(%rbp)
jmp    2960 <main+0x1820>
jmp    2a6a <main+0x192a>
mov    -0x9c60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c60(%rbp)
jmp    2949 <main+0x1809>
movl   $0x0,-0x9c70(%rbp)
mov    -0x9c70(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2bd6 <main+0x1a96>
movl   $0x0,-0x9c74(%rbp)
mov    -0x9c74(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2bbd <main+0x1a7d>
movl   $0x0,-0x9c78(%rbp)
mov    -0x9c78(%rbp),%eax
cmp    -0x9c40(%rbp),%eax
jge    2ba4 <main+0x1a64>
mov    -0x9c48(%rbp),%rax
mov    -0x9c70(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c74(%rbp),%edx
imul   -0x9c40(%rbp),%edx
add    %edx,%ecx
add    -0x9c78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x4fe(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2b27 <main+0x19e7>
jp     2b27 <main+0x19e7>
jmp    2b8b <main+0x1a4b>
mov    -0x9c70(%rbp),%esi
mov    -0x9c74(%rbp),%edx
mov    -0x9c48(%rbp),%rax
mov    -0x9c70(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
imul   -0x9c40(%rbp),%ecx
mov    -0x9c74(%rbp),%edi
imul   -0x9c40(%rbp),%edi
add    %edi,%ecx
add    -0x9c78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x701(%rip),%rdi
movsd  0x49e(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2b90 <main+0x1a50>
mov    -0x9c78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c78(%rbp)
jmp    2ac0 <main+0x1980>
jmp    2ba9 <main+0x1a69>
mov    -0x9c74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
jmp    2aa4 <main+0x1964>
jmp    2bc2 <main+0x1a82>
mov    -0x9c70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c70(%rbp)
jmp    2a88 <main+0x1948>
cmpl   $0x0,-0x9b14(%rbp)
je     2bf6 <main+0x1ab6>
lea    0x665(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2c04 <main+0x1ac4>
lea    0x43f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x9c80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5d18,%rsp
xor    %eax,%eax
call   1070 <check_offloading@plt>
mov    $0x1e,%eax
movapd 0x1e7b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,0x1e20(%rsp,%rax,8)
movapd %xmm0,0x1e30(%rsp,%rax,8)
movapd %xmm0,0x1e40(%rsp,%rax,8)
movapd %xmm0,0x1e50(%rsp,%rax,8)
movapd %xmm0,0x1e60(%rsp,%rax,8)
movapd %xmm0,0x1e70(%rsp,%rax,8)
movapd %xmm0,0x1e80(%rsp,%rax,8)
movapd %xmm0,0x1e90(%rsp,%rax,8)
movapd %xmm0,0x1ea0(%rsp,%rax,8)
movapd %xmm0,0x1eb0(%rsp,%rax,8)
movapd %xmm0,0x1ec0(%rsp,%rax,8)
movapd %xmm0,0x1ed0(%rsp,%rax,8)
movapd %xmm0,0x1ee0(%rsp,%rax,8)
movapd %xmm0,0x1ef0(%rsp,%rax,8)
movapd %xmm0,0x1f00(%rsp,%rax,8)
movapd %xmm0,0x1f10(%rsp,%rax,8)
add    $0x20,%rax
cmp    $0x3fe,%rax
jne    1190 <main+0x30>
lea    0x1e57(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     12e0 <main+0x180>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1270 <main+0x110>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    134c <main+0x1ec>
lea    0x1f71(%rip),%rdi
call   1030 <puts@plt>
lea    0x1d4e(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1400 <main+0x2a0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1390 <main+0x230>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    146c <main+0x30c>
lea    0x1e51(%rip),%rdi
call   1030 <puts@plt>
lea    0x1c41(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1520 <main+0x3c0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    14b0 <main+0x350>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    158c <main+0x42c>
lea    0x1d31(%rip),%rdi
call   1030 <puts@plt>
lea    0x1b34(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1640 <main+0x4e0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    15d0 <main+0x470>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    16ac <main+0x54c>
lea    0x1c11(%rip),%rdi
call   1030 <puts@plt>
lea    0x1a3b(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1760 <main+0x600>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    16f0 <main+0x590>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    17cc <main+0x66c>
lea    0x1af1(%rip),%rdi
call   1030 <puts@plt>
lea    0x1944(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1880 <main+0x720>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1810 <main+0x6b0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    18ec <main+0x78c>
lea    0x19d1(%rip),%rdi
call   1030 <puts@plt>
lea    0x1854(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     19a0 <main+0x840>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1930 <main+0x7d0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1a0c <main+0x8ac>
lea    0x18b1(%rip),%rdi
call   1030 <puts@plt>
lea    0x1765(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1ac0 <main+0x960>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1a50 <main+0x8f0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1b2c <main+0x9cc>
lea    0x1791(%rip),%rdi
call   1030 <puts@plt>
lea    0x166e(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1be0 <main+0xa80>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1b70 <main+0xa10>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1c4c <main+0xaec>
lea    0x1671(%rip),%rdi
call   1030 <puts@plt>
lea    0x1574(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1d00 <main+0xba0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1c90 <main+0xb30>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1d6c <main+0xc0c>
lea    0x1551(%rip),%rdi
call   1030 <puts@plt>
lea    0x147a(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1e20 <main+0xcc0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1db0 <main+0xc50>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1e8c <main+0xd2c>
lea    0x1431(%rip),%rdi
call   1030 <puts@plt>
lea    0x1382(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1f40 <main+0xde0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1ed0 <main+0xd70>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <check_results@plt>
cmp    $0x1,%eax
jne    1fac <main+0xe4c>
lea    0x1311(%rip),%rdi
call   1030 <puts@plt>
lea    0x128c(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movsd  0x3e10(%rsp),%xmm0
addsd  0x1f10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsp,%rax,8),%xmm0
movupd 0x3e00(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rsp,%rax,8)
cmp    $0x3f,%rax
je     2066 <main+0xf06>
movupd 0x10(%rsp,%rax,8),%xmm0
movupd 0x3e10(%rsp,%rax,8),%xmm1
movupd 0x1f10(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rsp,%rax,8)
add    $0x4,%rax
jmp    2010 <main+0xeb0>
movsd  0x4008(%rsp),%xmm0
addsd  0x2108(%rsp),%xmm0
addsd  0x208(%rsp),%xmm0
movsd  %xmm0,0x208(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2090 <main+0xf30>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    20f0 <main+0xf90>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2150 <main+0xff0>
xor    %ebx,%ebx
mov    $0x1,%al
movsd  0xe82(%rip),%xmm0
lea    0xe93(%rip),%r15
lea    0x10f5(%rip),%r14
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    21dd <main+0x107d>
jp     21dd <main+0x107d>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    21c0 <main+0x1060>
jmp    2212 <main+0x10b2>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xe4e(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xe37(%rip),%xmm0
lea    0x1(%rbx),%rcx
mov    $0x1,%ebp
xor    %eax,%eax
cmp    $0xff,%rbx
mov    %rcx,%rbx
jne    21c0 <main+0x1060>
jmp    222b <main+0x10cb>
lea    0x109f(%rip),%rcx
lea    0x1091(%rip),%r14
xor    %edx,%edx
test   $0x1,%al
cmovne %rcx,%r14
cmovne %edx,%ebp
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x1005(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movsd  0x3e10(%rsp),%xmm0
addsd  0x1f10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    $0x3,%eax
nopl   0x0(%rax)
movupd (%rsp,%rax,8),%xmm0
movupd 0x3e00(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rsp,%rax,8)
cmp    $0x3f,%rax
je     22e6 <main+0x1186>
movupd 0x10(%rsp,%rax,8),%xmm0
movupd 0x3e10(%rsp,%rax,8),%xmm1
movupd 0x1f10(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rsp,%rax,8)
add    $0x4,%rax
jmp    2290 <main+0x1130>
movsd  0x4008(%rsp),%xmm0
addsd  0x2108(%rsp),%xmm0
addsd  0x208(%rsp),%xmm0
movsd  %xmm0,0x208(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2310 <main+0x11b0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2370 <main+0x1210>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    23d0 <main+0x1270>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4610(%rsp,%rax,8),%xmm0
addpd  0x2710(%rsp,%rax,8),%xmm0
movapd 0x4620(%rsp,%rax,8),%xmm1
addpd  0x810(%rsp,%rax,8),%xmm0
movapd %xmm0,0x810(%rsp,%rax,8)
addpd  0x2720(%rsp,%rax,8),%xmm1
addpd  0x820(%rsp,%rax,8),%xmm1
movapd %xmm1,0x820(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2430 <main+0x12d0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4810(%rsp,%rax,8),%xmm0
addpd  0x2910(%rsp,%rax,8),%xmm0
movapd 0x4820(%rsp,%rax,8),%xmm1
addpd  0xa10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xa10(%rsp,%rax,8)
addpd  0x2920(%rsp,%rax,8),%xmm1
addpd  0xa20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xa20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2490 <main+0x1330>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4a10(%rsp,%rax,8),%xmm0
addpd  0x2b10(%rsp,%rax,8),%xmm0
movapd 0x4a20(%rsp,%rax,8),%xmm1
addpd  0xc10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xc10(%rsp,%rax,8)
addpd  0x2b20(%rsp,%rax,8),%xmm1
addpd  0xc20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xc20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    24f0 <main+0x1390>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4c10(%rsp,%rax,8),%xmm0
addpd  0x2d10(%rsp,%rax,8),%xmm0
movapd 0x4c20(%rsp,%rax,8),%xmm1
addpd  0xe10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xe10(%rsp,%rax,8)
addpd  0x2d20(%rsp,%rax,8),%xmm1
addpd  0xe20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xe20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2550 <main+0x13f0>
xor    %ebx,%ebx
lea    0xa9d(%rip),%r15
lea    0xcff(%rip),%r14
movsd  0xa76(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    25e0 <main+0x1480>
jp     25e0 <main+0x1480>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    25c0 <main+0x1460>
jmp    260b <main+0x14ab>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xa4b(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    25b2 <main+0x1452>
jmp    261f <main+0x14bf>
test   %ebp,%ebp
lea    0xca4(%rip),%rax
lea    0xc96(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0xc4d(%rip),%rdi
call   1030 <puts@plt>
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
xor    %r12d,%r12d
mov    $0x782000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,%rax
add    $0x70,%rax
mov    %r15,%rcx
add    $0x70,%rcx
movapd 0x98e(%rip),%xmm1
movapd 0x976(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rcx,%rdx,8)
movupd %xmm0,-0x60(%rcx,%rdx,8)
movupd %xmm1,-0x70(%rax,%rdx,8)
movupd %xmm1,-0x60(%rax,%rdx,8)
movupd %xmm0,-0x50(%rcx,%rdx,8)
movupd %xmm0,-0x40(%rcx,%rdx,8)
movupd %xmm1,-0x50(%rax,%rdx,8)
movupd %xmm1,-0x40(%rax,%rdx,8)
movupd %xmm0,-0x30(%rcx,%rdx,8)
movupd %xmm0,-0x20(%rcx,%rdx,8)
movupd %xmm1,-0x30(%rax,%rdx,8)
movupd %xmm1,-0x20(%rax,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,-0x10(%rax,%rdx,8)
movupd %xmm1,(%rax,%rdx,8)
add    $0x10,%rdx
cmp    $0x3e0,%rdx
jne    26a0 <main+0x1540>
add    $0x1,%r12
add    $0x1f00,%rax
add    $0x1f00,%rcx
cmp    $0x3e0,%r12
jne    2690 <main+0x1530>
xor    %eax,%eax
mov    %r14,%rcx
xchg   %ax,%ax
mov    $0x2,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%r15,%rdx,8),%xmm0
movupd (%r15,%rdx,8),%xmm1
movupd -0x10(%rbx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd (%rbx,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rcx,%rdx,8),%xmm1
addpd  %xmm2,%xmm1
movupd (%rcx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm2,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x3e2,%rdx
jne    2740 <main+0x15e0>
add    $0x1,%rax
add    $0x1f00,%rcx
add    $0x1f00,%rbx
add    $0x1f00,%r15
cmp    $0x3e0,%rax
jne    2730 <main+0x15d0>
xor    %r12d,%r12d
movsd  0x889(%rip),%xmm0
lea    0x8ac(%rip),%r15
jmp    27d4 <main+0x1674>
add    $0x1,%r12
add    $0x1f00,%r14
cmp    $0x3e0,%r12
je     2821 <main+0x16c1>
xor    %ebx,%ebx
jmp    27ed <main+0x168d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     27c0 <main+0x1660>
movsd  (%r14,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    27fb <main+0x169b>
jnp    27e0 <main+0x1680>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
movsd  0x835(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x826(%rip),%xmm0
mov    $0x1,%ebp
jmp    27e0 <main+0x1680>
test   %ebp,%ebp
lea    0xa8e(%rip),%rax
lea    0xa80(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0xa55(%rip),%rdi
call   1030 <puts@plt>
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
lea    0x10(%rax),%r8
lea    0x10(%r15),%r9
xor    %esi,%esi
movapd 0x7b1(%rip),%xmm0
movapd 0x799(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
mov    %r9,%rdi
mov    %r8,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm1,-0x10(%rdi,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm1,(%rdi,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x7c,%rdx
jne    28a0 <main+0x1740>
add    $0x1,%rbx
add    $0x3e0,%rcx
add    $0x3e0,%rdi
cmp    $0x7c,%rbx
jne    2890 <main+0x1730>
add    $0x1,%rsi
add    $0x1e080,%r8
add    $0x1e080,%r9
cmp    $0x7c,%rsi
jne    2880 <main+0x1720>
mov    %r15,%r8
add    $0x10,%r8
add    $0x10,%rax
xor    %edx,%edx
nopl   (%rax)
mov    %rax,%rsi
mov    %r8,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rsi,%rcx,8),%xmm0
movupd -0x10(%rdi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%rdi,%rcx,8),%xmm0
movupd %xmm1,-0x10(%rdi,%rcx,8)
movupd (%rsi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    $0x7c,%rcx
jne    2920 <main+0x17c0>
add    $0x1,%rbx
add    $0x3e0,%rdi
add    $0x3e0,%rsi
cmp    $0x7c,%rbx
jne    2910 <main+0x17b0>
add    $0x1,%rdx
add    $0x1e080,%r8
add    $0x1e080,%rax
cmp    $0x7c,%rdx
jne    2900 <main+0x17a0>
xor    %r13d,%r13d
lea    0x6da(%rip),%r12
jmp    29b6 <main+0x1856>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x8(%rsp),%r15
add    $0x1e080,%r15
cmp    $0x7c,%r13
je     2a1a <main+0x18ba>
mov    %r15,0x8(%rsp)
xor    %ebx,%ebx
jmp    29d1 <main+0x1871>
nop
add    $0x1,%rbx
add    $0x3e0,%r15
cmp    $0x7c,%rbx
je     29a0 <main+0x1840>
xor    %r14d,%r14d
jmp    29ea <main+0x188a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    $0x7c,%r14
je     29c0 <main+0x1860>
movsd  (%r15,%r14,8),%xmm1
ucomisd 0x640(%rip),%xmm1
jne    29fc <main+0x189c>
jnp    29e0 <main+0x1880>
mov    %r12,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
movsd  0x634(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
mov    $0x1,%ebp
jmp    29e0 <main+0x1880>
test   %ebp,%ebp
lea    0x88e(%rip),%rdi
lea    0x88e(%rip),%rax
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x5d18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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