#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__ malloc(int);
int omp_get_num_teams();
int omp_get_team_num();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  int fail = 0;
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute num_teams(512)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute num_teams(256)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute num_teams(256)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 1) num_teams(512)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 512) num_teams(512)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  int ten = 10;
  int chunkSize = 512 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, chunkSize)           \
    num_teams(512)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 1) num_teams(256)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 500) num_teams(256)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  ten = 10;
  chunkSize = 500 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, chunkSize)           \
    num_teams(256)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 1) num_teams(256)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, 123) num_teams(256)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  ten = 10;
  chunkSize = 123 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute dist_schedule(static, chunkSize)           \
    num_teams(256)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  double p = 2.0, q = 4.0;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute private(p, q) num_teams(256)
    for (int i = 0; i < (992); i++) {
      p = 2;
      q = 3;
      A[i] += p;
      B[i] += q;
    }
  }
  for (int i = 0; i < (992); i++) {
    if (A[i] != (1) * 2) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(1) * 2, A[i]);
      fail = 1;
    }
    if (B[i] != (1) * 3) {
      printf("Error at B[%d], h = %lf, d = %lf\n", i, (double)(1) * 3, B[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  p = 2.0, q = 4.0;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute firstprivate(p, q) num_teams(64)
    for (int i = 0; i < 128; i++) {
      p += 3.0;
      q += 7.0;
      A[i] += p;
      B[i] += q;
    }
  }
  for (int i = 0; i < 128; i++) {
    if (i % 2 == 0) {
      if (A[i] != (2.0 + 3.0) * (1)) {
        printf("Error at A[%d], h = %lf, d = %lf\n", i,
               (double)(2.0 + 3.0) * (1), A[i]);
        fail = 1;
      }
      if (B[i] != (4.0 + 7.0) * (1)) {
        printf("Error at B[%d], h = %lf, d = %lf\n", i,
               (double)(4.0 + 7.0) * (1), B[i]);
        fail = 1;
      }
    } else {
      if (A[i] != (2.0 + 3.0 * 2) * (1)) {
        printf("Error at A[%d], h = %lf, d = %lf\n", i,
               (double)(2.0 + 3.0 * 2) * (1), A[i]);
        fail = 1;
      }
      if (B[i] != (4.0 + 7.0 * 2) * (1)) {
        printf("Error at B[%d], h = %lf, d = %lf\n", i,
               (double)(4.0 + 7.0 * 2) * (1), B[i]);
        fail = 1;
      }
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  int lastpriv[2] = {-1, -1};
#pragma omp target teams distribute lastprivate(lastpriv) num_teams(10)
  for (int i = 0; i < omp_get_num_teams(); i++) {
    lastpriv[0] = omp_get_team_num();
  }
  if (lastpriv[0] != 9) {
    printf("lastpriv value is %d and should have been %d\n", lastpriv[0], 9);
    fail = 1;
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  int nte = 32;
  int tl = 64;
  int blockSize = tl;
  for (int t = 0; t < (1); t++) {
#pragma omp target teams distribute num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 256; j += blockSize) {
#pragma omp parallel for
      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");
  {
    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 teams distribute num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 510; j += blockSize) {
      int ub = (j + blockSize < 510) ? (j + blockSize) : 512;
#pragma omp parallel for
      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");
  double *S = (double *)malloc((992) * (992) * sizeof(double));
  double *T = (double *)malloc((992) * (992) * sizeof(double));
  double *U = (double *)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 teams distribute collapse(2) map(tofrom                     \
                                                    : S[:N * N]),              \
    map(to                                                                     \
        : T[:N * N], U                                                         \
        [:N * N]) num_teams(512)
    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");
  int M = (992) / 8;
  double *V = (double *)malloc(M * M * M * sizeof(double));
  double *Z = (double *)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 teams distribute collapse(3) map(tofrom                     \
                                                    : V[:M * M * M]),          \
    map(to                                                                     \
        : Z[:M * M * M]) num_teams(512)
    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    $0x9ce0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1050 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
movl   $0x0,-0x9b18(%rbp)
cmpl   $0x3e0,-0x9b18(%rbp)
jge    11ed <main+0x9d>
movslq -0x9b18(%rbp),%rax
movsd  0x2e84(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b18(%rbp),%xmm0
ff
movslq -0x9b18(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b18(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b18(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b18(%rbp)
jmp    117d <main+0x2d>
movl   $0x0,-0x9b1c(%rbp)
cmpl   $0x3e0,-0x9b1c(%rbp)
jge    122e <main+0xde>
movslq -0x9b1c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b1c(%rbp)
jmp    11f7 <main+0xa7>
movl   $0x0,-0x9b20(%rbp)
cmpl   $0x1,-0x9b20(%rbp)
jge    12b5 <main+0x165>
movl   $0x0,-0x9b24(%rbp)
cmpl   $0x200,-0x9b24(%rbp)
jge    129c <main+0x14c>
movslq -0x9b24(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b24(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b24(%rbp)
jmp    124f <main+0xff>
jmp    12a1 <main+0x151>
mov    -0x9b20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b20(%rbp)
jmp    1238 <main+0xe8>
movl   $0x0,-0x9b28(%rbp)
cmpl   $0x200,-0x9b28(%rbp)
jge    134b <main+0x1fb>
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2d39(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12fc <main+0x1ac>
jp     12fc <main+0x1ac>
jmp    1332 <main+0x1e2>
mov    -0x9b28(%rbp),%esi
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2d37(%rip),%rdi
movsd  0x2cff(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1337 <main+0x1e7>
mov    -0x9b28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b28(%rbp)
jmp    12bf <main+0x16f>
cmpl   $0x0,-0x9b14(%rbp)
je     136b <main+0x21b>
lea    0x2d10(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1379 <main+0x229>
lea    0x2d05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b2c(%rbp)
cmpl   $0x3e0,-0x9b2c(%rbp)
jge    13ba <main+0x26a>
movslq -0x9b2c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b2c(%rbp)
jmp    1383 <main+0x233>
movl   $0x0,-0x9b30(%rbp)
cmpl   $0x1,-0x9b30(%rbp)
jge    1441 <main+0x2f1>
movl   $0x0,-0x9b34(%rbp)
cmpl   $0x1f4,-0x9b34(%rbp)
jge    1428 <main+0x2d8>
movslq -0x9b34(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b34(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b34(%rbp)
jmp    13db <main+0x28b>
jmp    142d <main+0x2dd>
mov    -0x9b30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b30(%rbp)
jmp    13c4 <main+0x274>
movl   $0x0,-0x9b38(%rbp)
cmpl   $0x1f4,-0x9b38(%rbp)
jge    14d7 <main+0x387>
movslq -0x9b38(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2bad(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1488 <main+0x338>
jp     1488 <main+0x338>
jmp    14be <main+0x36e>
mov    -0x9b38(%rbp),%esi
movslq -0x9b38(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2bab(%rip),%rdi
movsd  0x2b73(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    14c3 <main+0x373>
mov    -0x9b38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b38(%rbp)
jmp    144b <main+0x2fb>
cmpl   $0x0,-0x9b14(%rbp)
je     14f7 <main+0x3a7>
lea    0x2b84(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1505 <main+0x3b5>
lea    0x2b79(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b3c(%rbp)
cmpl   $0x3e0,-0x9b3c(%rbp)
jge    1546 <main+0x3f6>
movslq -0x9b3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b3c(%rbp)
jmp    150f <main+0x3bf>
movl   $0x0,-0x9b40(%rbp)
cmpl   $0x1,-0x9b40(%rbp)
jge    15ca <main+0x47a>
movl   $0x0,-0x9b44(%rbp)
cmpl   $0x7b,-0x9b44(%rbp)
jge    15b1 <main+0x461>
movslq -0x9b44(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b44(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b44(%rbp)
jmp    1567 <main+0x417>
jmp    15b6 <main+0x466>
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    1550 <main+0x400>
movl   $0x0,-0x9b48(%rbp)
cmpl   $0x7b,-0x9b48(%rbp)
jge    165d <main+0x50d>
movslq -0x9b48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2a27(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    160e <main+0x4be>
jp     160e <main+0x4be>
jmp    1644 <main+0x4f4>
mov    -0x9b48(%rbp),%esi
movslq -0x9b48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2a25(%rip),%rdi
movsd  0x29ed(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1649 <main+0x4f9>
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    15d4 <main+0x484>
cmpl   $0x0,-0x9b14(%rbp)
je     167d <main+0x52d>
lea    0x29fe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    168b <main+0x53b>
lea    0x29f3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b4c(%rbp)
cmpl   $0x3e0,-0x9b4c(%rbp)
jge    16cc <main+0x57c>
movslq -0x9b4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    1695 <main+0x545>
movl   $0x0,-0x9b50(%rbp)
cmpl   $0x1,-0x9b50(%rbp)
jge    1753 <main+0x603>
movl   $0x0,-0x9b54(%rbp)
cmpl   $0x200,-0x9b54(%rbp)
jge    173a <main+0x5ea>
movslq -0x9b54(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b54(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    16ed <main+0x59d>
jmp    173f <main+0x5ef>
mov    -0x9b50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b50(%rbp)
jmp    16d6 <main+0x586>
movl   $0x0,-0x9b58(%rbp)
cmpl   $0x200,-0x9b58(%rbp)
jge    17e9 <main+0x699>
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x289b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    179a <main+0x64a>
jp     179a <main+0x64a>
jmp    17d0 <main+0x680>
mov    -0x9b58(%rbp),%esi
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2899(%rip),%rdi
movsd  0x2861(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    17d5 <main+0x685>
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    175d <main+0x60d>
cmpl   $0x0,-0x9b14(%rbp)
je     1809 <main+0x6b9>
lea    0x2872(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1817 <main+0x6c7>
lea    0x2867(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b5c(%rbp)
cmpl   $0x3e0,-0x9b5c(%rbp)
jge    1858 <main+0x708>
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    1821 <main+0x6d1>
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x1,-0x9b60(%rbp)
jge    18df <main+0x78f>
movl   $0x0,-0x9b64(%rbp)
cmpl   $0x200,-0x9b64(%rbp)
jge    18c6 <main+0x776>
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)
ff ff
mov    -0x9b64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b64(%rbp)
jmp    1879 <main+0x729>
jmp    18cb <main+0x77b>
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    1862 <main+0x712>
movl   $0x0,-0x9b68(%rbp)
cmpl   $0x200,-0x9b68(%rbp)
jge    1975 <main+0x825>
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x270f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1926 <main+0x7d6>
jp     1926 <main+0x7d6>
jmp    195c <main+0x80c>
mov    -0x9b68(%rbp),%esi
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x270d(%rip),%rdi
movsd  0x26d5(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1961 <main+0x811>
mov    -0x9b68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b68(%rbp)
jmp    18e9 <main+0x799>
cmpl   $0x0,-0x9b14(%rbp)
je     1995 <main+0x845>
lea    0x26e6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    19a3 <main+0x853>
lea    0x26db(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b6c(%rbp)
cmpl   $0x3e0,-0x9b6c(%rbp)
jge    19e4 <main+0x894>
movslq -0x9b6c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    19ad <main+0x85d>
movl   $0xa,-0x9b70(%rbp)
mov    $0x200,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9b78(%rbp)
cmpl   $0x1,-0x9b78(%rbp)
jge    1a87 <main+0x937>
movl   $0x0,-0x9b7c(%rbp)
cmpl   $0x200,-0x9b7c(%rbp)
jge    1a6e <main+0x91e>
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    1a21 <main+0x8d1>
jmp    1a73 <main+0x923>
mov    -0x9b78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b78(%rbp)
jmp    1a0a <main+0x8ba>
movl   $0x0,-0x9b80(%rbp)
cmpl   $0x200,-0x9b80(%rbp)
jge    1b1d <main+0x9cd>
movslq -0x9b80(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2567(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1ace <main+0x97e>
jp     1ace <main+0x97e>
jmp    1b04 <main+0x9b4>
mov    -0x9b80(%rbp),%esi
movslq -0x9b80(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2565(%rip),%rdi
movsd  0x252d(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1b09 <main+0x9b9>
mov    -0x9b80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b80(%rbp)
jmp    1a91 <main+0x941>
cmpl   $0x0,-0x9b14(%rbp)
je     1b3d <main+0x9ed>
lea    0x253e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b4b <main+0x9fb>
lea    0x2533(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b84(%rbp)
cmpl   $0x3e0,-0x9b84(%rbp)
jge    1b8c <main+0xa3c>
movslq -0x9b84(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1b55 <main+0xa05>
movl   $0x0,-0x9b88(%rbp)
cmpl   $0x1,-0x9b88(%rbp)
jge    1c13 <main+0xac3>
movl   $0x0,-0x9b8c(%rbp)
cmpl   $0x1f4,-0x9b8c(%rbp)
jge    1bfa <main+0xaaa>
movslq -0x9b8c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b8c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b8c(%rbp)
jmp    1bad <main+0xa5d>
jmp    1bff <main+0xaaf>
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1b96 <main+0xa46>
movl   $0x0,-0x9b90(%rbp)
cmpl   $0x1f4,-0x9b90(%rbp)
jge    1ca9 <main+0xb59>
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x23db(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1c5a <main+0xb0a>
jp     1c5a <main+0xb0a>
jmp    1c90 <main+0xb40>
mov    -0x9b90(%rbp),%esi
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x23d9(%rip),%rdi
movsd  0x23a1(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1c95 <main+0xb45>
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1c1d <main+0xacd>
cmpl   $0x0,-0x9b14(%rbp)
je     1cc9 <main+0xb79>
lea    0x23b2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1cd7 <main+0xb87>
lea    0x23a7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b94(%rbp)
cmpl   $0x3e0,-0x9b94(%rbp)
jge    1d18 <main+0xbc8>
movslq -0x9b94(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b94(%rbp)
jmp    1ce1 <main+0xb91>
movl   $0x0,-0x9b98(%rbp)
cmpl   $0x1,-0x9b98(%rbp)
jge    1d9f <main+0xc4f>
movl   $0x0,-0x9b9c(%rbp)
cmpl   $0x1f4,-0x9b9c(%rbp)
jge    1d86 <main+0xc36>
movslq -0x9b9c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b9c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    1d39 <main+0xbe9>
jmp    1d8b <main+0xc3b>
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    1d22 <main+0xbd2>
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x1f4,-0x9ba0(%rbp)
jge    1e35 <main+0xce5>
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x224f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1de6 <main+0xc96>
jp     1de6 <main+0xc96>
jmp    1e1c <main+0xccc>
mov    -0x9ba0(%rbp),%esi
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x224d(%rip),%rdi
movsd  0x2215(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1e21 <main+0xcd1>
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    1da9 <main+0xc59>
cmpl   $0x0,-0x9b14(%rbp)
je     1e55 <main+0xd05>
lea    0x2226(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1e63 <main+0xd13>
lea    0x221b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9ba4(%rbp)
cmpl   $0x3e0,-0x9ba4(%rbp)
jge    1ea4 <main+0xd54>
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    1e6d <main+0xd1d>
movl   $0xa,-0x9b70(%rbp)
mov    $0x1f4,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9ba8(%rbp)
cmpl   $0x1,-0x9ba8(%rbp)
jge    1f47 <main+0xdf7>
movl   $0x0,-0x9bac(%rbp)
cmpl   $0x1f4,-0x9bac(%rbp)
jge    1f2e <main+0xdde>
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    1ee1 <main+0xd91>
jmp    1f33 <main+0xde3>
mov    -0x9ba8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba8(%rbp)
jmp    1eca <main+0xd7a>
movl   $0x0,-0x9bb0(%rbp)
cmpl   $0x1f4,-0x9bb0(%rbp)
jge    1fdd <main+0xe8d>
movslq -0x9bb0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x20a7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f8e <main+0xe3e>
jp     1f8e <main+0xe3e>
jmp    1fc4 <main+0xe74>
mov    -0x9bb0(%rbp),%esi
movslq -0x9bb0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x20a5(%rip),%rdi
movsd  0x206d(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1fc9 <main+0xe79>
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    1f51 <main+0xe01>
cmpl   $0x0,-0x9b14(%rbp)
je     1ffd <main+0xead>
lea    0x207e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    200b <main+0xebb>
lea    0x2073(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x3e0,-0x9bb4(%rbp)
jge    204c <main+0xefc>
movslq -0x9bb4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    2015 <main+0xec5>
movl   $0x0,-0x9bb8(%rbp)
cmpl   $0x1,-0x9bb8(%rbp)
jge    20d0 <main+0xf80>
movl   $0x0,-0x9bbc(%rbp)
cmpl   $0x7b,-0x9bbc(%rbp)
jge    20b7 <main+0xf67>
movslq -0x9bbc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bbc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bbc(%rbp)
jmp    206d <main+0xf1d>
jmp    20bc <main+0xf6c>
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    2056 <main+0xf06>
movl   $0x0,-0x9bc0(%rbp)
cmpl   $0x7b,-0x9bc0(%rbp)
jge    2163 <main+0x1013>
movslq -0x9bc0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1f21(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2114 <main+0xfc4>
jp     2114 <main+0xfc4>
jmp    214a <main+0xffa>
mov    -0x9bc0(%rbp),%esi
movslq -0x9bc0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1f1f(%rip),%rdi
movsd  0x1ee7(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    214f <main+0xfff>
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    20da <main+0xf8a>
cmpl   $0x0,-0x9b14(%rbp)
je     2183 <main+0x1033>
lea    0x1ef8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2191 <main+0x1041>
lea    0x1eed(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bc4(%rbp)
cmpl   $0x3e0,-0x9bc4(%rbp)
jge    21d2 <main+0x1082>
movslq -0x9bc4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc4(%rbp)
jmp    219b <main+0x104b>
movl   $0x0,-0x9bc8(%rbp)
cmpl   $0x1,-0x9bc8(%rbp)
jge    2256 <main+0x1106>
movl   $0x0,-0x9bcc(%rbp)
cmpl   $0x7b,-0x9bcc(%rbp)
jge    223d <main+0x10ed>
movslq -0x9bcc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bcc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    21f3 <main+0x10a3>
jmp    2242 <main+0x10f2>
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    21dc <main+0x108c>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x7b,-0x9bd0(%rbp)
jge    22e9 <main+0x1199>
movslq -0x9bd0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1d9b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    229a <main+0x114a>
jp     229a <main+0x114a>
jmp    22d0 <main+0x1180>
mov    -0x9bd0(%rbp),%esi
movslq -0x9bd0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1d99(%rip),%rdi
movsd  0x1d61(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    22d5 <main+0x1185>
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    2260 <main+0x1110>
cmpl   $0x0,-0x9b14(%rbp)
je     2309 <main+0x11b9>
lea    0x1d72(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2317 <main+0x11c7>
lea    0x1d67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bd4(%rbp)
cmpl   $0x3e0,-0x9bd4(%rbp)
jge    2358 <main+0x1208>
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    2321 <main+0x11d1>
movl   $0xa,-0x9b70(%rbp)
mov    $0x7b,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9bd8(%rbp)
cmpl   $0x1,-0x9bd8(%rbp)
jge    23f8 <main+0x12a8>
movl   $0x0,-0x9bdc(%rbp)
cmpl   $0x7b,-0x9bdc(%rbp)
jge    23df <main+0x128f>
movslq -0x9bdc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bdc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bdc(%rbp)
jmp    2395 <main+0x1245>
jmp    23e4 <main+0x1294>
mov    -0x9bd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd8(%rbp)
jmp    237e <main+0x122e>
movl   $0x0,-0x9be0(%rbp)
cmpl   $0x7b,-0x9be0(%rbp)
jge    248b <main+0x133b>
movslq -0x9be0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1bf9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    243c <main+0x12ec>
jp     243c <main+0x12ec>
jmp    2472 <main+0x1322>
mov    -0x9be0(%rbp),%esi
movslq -0x9be0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1bf7(%rip),%rdi
movsd  0x1bbf(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2477 <main+0x1327>
mov    -0x9be0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be0(%rbp)
jmp    2402 <main+0x12b2>
cmpl   $0x0,-0x9b14(%rbp)
je     24ab <main+0x135b>
lea    0x1bd0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    24b9 <main+0x1369>
lea    0x1bc5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9be4(%rbp)
cmpl   $0x3e0,-0x9be4(%rbp)
jge    24fa <main+0x13aa>
movslq -0x9be4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    24c3 <main+0x1373>
movl   $0x0,-0x9be8(%rbp)
cmpl   $0x3e0,-0x9be8(%rbp)
jge    253b <main+0x13eb>
movslq -0x9be8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be8(%rbp)
jmp    2504 <main+0x13b4>
movsd  0x1ac5(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1aad(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movl   $0x0,-0x9bfc(%rbp)
cmpl   $0x1,-0x9bfc(%rbp)
jge    261b <main+0x14cb>
movl   $0x0,-0x9c00(%rbp)
cmpl   $0x3e0,-0x9c00(%rbp)
jge    2602 <main+0x14b2>
movsd  0x1a74(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1a74(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movsd  -0x9bf0(%rbp),%xmm0
ff
movslq -0x9c00(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movsd  -0x9bf8(%rbp),%xmm0
ff
movslq -0x9c00(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c00(%rbp)
jmp    257c <main+0x142c>
jmp    2607 <main+0x14b7>
mov    -0x9bfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bfc(%rbp)
jmp    2565 <main+0x1415>
movl   $0x0,-0x9c04(%rbp)
cmpl   $0x3e0,-0x9c04(%rbp)
jge    2714 <main+0x15c4>
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x19bb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2662 <main+0x1512>
jp     2662 <main+0x1512>
jmp    2698 <main+0x1548>
mov    -0x9c04(%rbp),%esi
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1a03(%rip),%rdi
movsd  0x1981(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c04(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1968(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    26c5 <main+0x1575>
jp     26c5 <main+0x1575>
jmp    26fb <main+0x15ab>
mov    -0x9c04(%rbp),%esi
movslq -0x9c04(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x19c2(%rip),%rdi
movsd  0x192e(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2700 <main+0x15b0>
mov    -0x9c04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c04(%rbp)
jmp    2625 <main+0x14d5>
cmpl   $0x0,-0x9b14(%rbp)
je     2734 <main+0x15e4>
lea    0x1947(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2742 <main+0x15f2>
lea    0x193c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c08(%rbp)
cmpl   $0x3e0,-0x9c08(%rbp)
jge    2783 <main+0x1633>
movslq -0x9c08(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c08(%rbp)
jmp    274c <main+0x15fc>
movl   $0x0,-0x9c0c(%rbp)
cmpl   $0x3e0,-0x9c0c(%rbp)
jge    27c4 <main+0x1674>
movslq -0x9c0c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c0c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c0c(%rbp)
jmp    278d <main+0x163d>
movsd  0x183c(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1824(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movl   $0x0,-0x9c10(%rbp)
cmpl   $0x1,-0x9c10(%rbp)
jge    28b4 <main+0x1764>
movl   $0x0,-0x9c14(%rbp)
cmpl   $0x80,-0x9c14(%rbp)
jge    289b <main+0x174b>
movsd  0x17fb(%rip),%xmm0
addsd  -0x9bf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x180b(%rip),%xmm0
addsd  -0x9bf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x9bf8(%rbp)
ff
movsd  -0x9bf0(%rbp),%xmm0
ff
movslq -0x9c14(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movsd  -0x9bf8(%rbp),%xmm0
ff
movslq -0x9c14(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    2805 <main+0x16b5>
jmp    28a0 <main+0x1750>
mov    -0x9c10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c10(%rbp)
jmp    27ee <main+0x169e>
movl   $0x0,-0x9c18(%rbp)
cmpl   $0x80,-0x9c18(%rbp)
jge    2a94 <main+0x1944>
mov    -0x9c18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    29b0 <main+0x1860>
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1713(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2912 <main+0x17c2>
jp     2912 <main+0x17c2>
jmp    2948 <main+0x17f8>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1753(%rip),%rdi
movsd  0x16d9(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x16d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2975 <main+0x1825>
jp     2975 <main+0x1825>
jmp    29ab <main+0x185b>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1712(%rip),%rdi
movsd  0x169e(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2a7b <main+0x192b>
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1660(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    29dd <main+0x188d>
jp     29dd <main+0x188d>
jmp    2a13 <main+0x18c3>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1688(%rip),%rdi
movsd  0x1626(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1605(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2a40 <main+0x18f0>
jp     2a40 <main+0x18f0>
jmp    2a76 <main+0x1926>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1647(%rip),%rdi
movsd  0x15cb(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2a7b <main+0x192b>
jmp    2a80 <main+0x1930>
mov    -0x9c18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c18(%rbp)
jmp    28be <main+0x176e>
cmpl   $0x0,-0x9b14(%rbp)
je     2ab4 <main+0x1964>
lea    0x15c7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2ac2 <main+0x1972>
lea    0x15bc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x157f(%rip),%rax
mov    %rax,-0x9c20(%rbp)
movl   $0x0,-0x9c24(%rbp)
mov    -0x9c24(%rbp),%eax
mov    %eax,-0x9cdc(%rbp)
mov    $0x0,%al
call   1070 <omp_get_num_teams@plt>
mov    %eax,%ecx
mov    -0x9cdc(%rbp),%eax
cmp    %ecx,%eax
jge    2b1e <main+0x19ce>
mov    $0x0,%al
call   1060 <omp_get_team_num@plt>
mov    %eax,-0x9c20(%rbp)
mov    -0x9c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c24(%rbp)
jmp    2ada <main+0x198a>
cmpl   $0x9,-0x9c20(%rbp)
je     2b4e <main+0x19fe>
mov    -0x9c20(%rbp),%esi
lea    0x158e(%rip),%rdi
mov    $0x9,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
cmpl   $0x0,-0x9b14(%rbp)
je     2b6e <main+0x1a1e>
lea    0x150d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2b7c <main+0x1a2c>
lea    0x1502(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c28(%rbp)
cmpl   $0x3e0,-0x9c28(%rbp)
jge    2bbd <main+0x1a6d>
movslq -0x9c28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    2b86 <main+0x1a36>
movl   $0x0,-0x9c2c(%rbp)
cmpl   $0x3e0,-0x9c2c(%rbp)
jge    2bfe <main+0x1aae>
movslq -0x9c2c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c2c(%rbp)
jmp    2bc7 <main+0x1a77>
movl   $0x20,-0x9c30(%rbp)
movl   $0x40,-0x9c34(%rbp)
mov    -0x9c34(%rbp),%eax
mov    %eax,-0x9c38(%rbp)
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x1,-0x9c3c(%rbp)
jge    2cf7 <main+0x1ba7>
movl   $0x0,-0x9c40(%rbp)
cmpl   $0x100,-0x9c40(%rbp)
jge    2cde <main+0x1b8e>
mov    -0x9c40(%rbp),%eax
mov    %eax,-0x9c44(%rbp)
mov    -0x9c44(%rbp),%eax
mov    -0x9c40(%rbp),%ecx
add    -0x9c38(%rbp),%ecx
cmp    %ecx,%eax
jge    2cc2 <main+0x1b72>
movslq -0x9c44(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c44(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c44(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c44(%rbp)
jmp    2c5b <main+0x1b0b>
jmp    2cc7 <main+0x1b77>
mov    -0x9c38(%rbp),%eax
add    -0x9c40(%rbp),%eax
mov    %eax,-0x9c40(%rbp)
jmp    2c3f <main+0x1aef>
jmp    2ce3 <main+0x1b93>
mov    -0x9c3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c3c(%rbp)
jmp    2c28 <main+0x1ad8>
movl   $0x0,-0x9c48(%rbp)
cmpl   $0x100,-0x9c48(%rbp)
jge    2d8d <main+0x1c3d>
movslq -0x9c48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x12f7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2d3e <main+0x1bee>
jp     2d3e <main+0x1bee>
jmp    2d74 <main+0x1c24>
mov    -0x9c48(%rbp),%esi
movslq -0x9c48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1327(%rip),%rdi
movsd  0x12ad(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2d79 <main+0x1c29>
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    2d01 <main+0x1bb1>
cmpl   $0x0,-0x9b14(%rbp)
je     2dad <main+0x1c5d>
lea    0x12ce(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2dbb <main+0x1c6b>
lea    0x12c3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c4c(%rbp)
cmpl   $0x3e0,-0x9c4c(%rbp)
jge    2dfc <main+0x1cac>
movslq -0x9c4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c4c(%rbp)
jmp    2dc5 <main+0x1c75>
movl   $0x0,-0x9c50(%rbp)
cmpl   $0x3e0,-0x9c50(%rbp)
jge    2e3d <main+0x1ced>
movslq -0x9c50(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c50(%rbp)
jmp    2e06 <main+0x1cb6>
movl   $0x20,-0x9c30(%rbp)
movl   $0x40,-0x9c34(%rbp)
mov    -0x9c34(%rbp),%eax
mov    %eax,-0x9c38(%rbp)
movl   $0x0,-0x9c54(%rbp)
cmpl   $0x1,-0x9c54(%rbp)
jge    2f78 <main+0x1e28>
movl   $0x0,-0x9c58(%rbp)
cmpl   $0x1fe,-0x9c58(%rbp)
jge    2f5f <main+0x1e0f>
mov    -0x9c58(%rbp),%eax
add    -0x9c38(%rbp),%eax
cmp    $0x1fe,%eax
jge    2ebc <main+0x1d6c>
mov    -0x9c58(%rbp),%eax
add    -0x9c38(%rbp),%eax
mov    %eax,-0x9ce0(%rbp)
jmp    2ecc <main+0x1d7c>
mov    $0x200,%eax
mov    %eax,-0x9ce0(%rbp)
jmp    2ecc <main+0x1d7c>
mov    -0x9ce0(%rbp),%eax
mov    %eax,-0x9c5c(%rbp)
mov    -0x9c58(%rbp),%eax
mov    %eax,-0x9c60(%rbp)
mov    -0x9c60(%rbp),%eax
cmp    -0x9c5c(%rbp),%eax
jge    2f43 <main+0x1df3>
movslq -0x9c60(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c60(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c60(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c60(%rbp)
jmp    2ee4 <main+0x1d94>
jmp    2f48 <main+0x1df8>
mov    -0x9c38(%rbp),%eax
add    -0x9c58(%rbp),%eax
mov    %eax,-0x9c58(%rbp)
jmp    2e7e <main+0x1d2e>
jmp    2f64 <main+0x1e14>
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    2e67 <main+0x1d17>
movl   $0x0,-0x9c64(%rbp)
cmpl   $0x100,-0x9c64(%rbp)
jge    300e <main+0x1ebe>
movslq -0x9c64(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1076(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2fbf <main+0x1e6f>
jp     2fbf <main+0x1e6f>
jmp    2ff5 <main+0x1ea5>
mov    -0x9c64(%rbp),%esi
movslq -0x9c64(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x10a6(%rip),%rdi
movsd  0x102c(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2ffa <main+0x1eaa>
mov    -0x9c64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c64(%rbp)
jmp    2f82 <main+0x1e32>
cmpl   $0x0,-0x9b14(%rbp)
je     302e <main+0x1ede>
lea    0x104d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    303c <main+0x1eec>
lea    0x1042(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c70(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c78(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c80(%rbp)
movl   $0x0,-0x9c84(%rbp)
cmpl   $0x3e0,-0x9c84(%rbp)
jge    3140 <main+0x1ff0>
movl   $0x0,-0x9c88(%rbp)
cmpl   $0x3e0,-0x9c88(%rbp)
jge    3127 <main+0x1fd7>
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c84(%rbp),%ecx
add    -0x9c88(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c78(%rbp),%rax
imul   $0x3e0,-0x9c84(%rbp),%ecx
add    -0x9c88(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xf39(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c80(%rbp),%rax
imul   $0x3e0,-0x9c84(%rbp),%ecx
add    -0x9c88(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xefa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c88(%rbp)
jmp    3093 <main+0x1f43>
jmp    312c <main+0x1fdc>
mov    -0x9c84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c84(%rbp)
jmp    3079 <main+0x1f29>
movl   $0x0,-0x9c8c(%rbp)
cmpl   $0x1,-0x9c8c(%rbp)
jge    3233 <main+0x20e3>
movl   $0x0,-0x9c90(%rbp)
cmpl   $0x3e0,-0x9c90(%rbp)
jge    321a <main+0x20ca>
movl   $0x0,-0x9c94(%rbp)
cmpl   $0x3e0,-0x9c94(%rbp)
jge    3201 <main+0x20b1>
mov    -0x9c78(%rbp),%rax
imul   $0x3e0,-0x9c90(%rbp),%ecx
add    -0x9c94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c80(%rbp),%rax
imul   $0x3e0,-0x9c90(%rbp),%ecx
add    -0x9c94(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c90(%rbp),%ecx
add    -0x9c94(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    317b <main+0x202b>
jmp    3206 <main+0x20b6>
mov    -0x9c90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c90(%rbp)
jmp    3161 <main+0x2011>
jmp    321f <main+0x20cf>
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    314a <main+0x1ffa>
movl   $0x0,-0x9c98(%rbp)
cmpl   $0x3e0,-0x9c98(%rbp)
jge    3320 <main+0x21d0>
movl   $0x0,-0x9c9c(%rbp)
cmpl   $0x3e0,-0x9c9c(%rbp)
jge    3307 <main+0x21b7>
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c98(%rbp),%ecx
add    -0x9c9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd8a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    32a3 <main+0x2153>
jp     32a3 <main+0x2153>
jmp    32ee <main+0x219e>
mov    -0x9c98(%rbp),%esi
mov    -0x9c9c(%rbp),%edx
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c98(%rbp),%ecx
add    -0x9c9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xe1f(%rip),%rdi
movsd  0xd3b(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    32f3 <main+0x21a3>
mov    -0x9c9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c9c(%rbp)
jmp    3257 <main+0x2107>
jmp    330c <main+0x21bc>
mov    -0x9c98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c98(%rbp)
jmp    323d <main+0x20ed>
cmpl   $0x0,-0x9b14(%rbp)
je     3340 <main+0x21f0>
lea    0xd3b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    334e <main+0x21fe>
lea    0xd30(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7c,-0x9ca0(%rbp)
mov    -0x9ca0(%rbp),%eax
imul   -0x9ca0(%rbp),%eax
imul   -0x9ca0(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9ca8(%rbp)
mov    -0x9ca0(%rbp),%eax
imul   -0x9ca0(%rbp),%eax
imul   -0x9ca0(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9cb0(%rbp)
movl   $0x0,-0x9cb4(%rbp)
mov    -0x9cb4(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    34c2 <main+0x2372>
movl   $0x0,-0x9cb8(%rbp)
mov    -0x9cb8(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    34a9 <main+0x2359>
movl   $0x0,-0x9cbc(%rbp)
mov    -0x9cbc(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    3490 <main+0x2340>
mov    -0x9ca8(%rbp),%rax
mov    -0x9cb4(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cb8(%rbp),%edx
imul   -0x9ca0(%rbp),%edx
add    %edx,%ecx
add    -0x9cbc(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xbd1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9cb0(%rbp),%rax
mov    -0x9cb4(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cb8(%rbp),%edx
imul   -0x9ca0(%rbp),%edx
add    %edx,%ecx
add    -0x9cbc(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xba1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9cbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
jmp    33ea <main+0x229a>
jmp    3495 <main+0x2345>
mov    -0x9cb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb8(%rbp)
jmp    33ce <main+0x227e>
jmp    34ae <main+0x235e>
mov    -0x9cb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb4(%rbp)
jmp    33b2 <main+0x2262>
movl   $0x0,-0x9cc0(%rbp)
cmpl   $0x1,-0x9cc0(%rbp)
jge    3601 <main+0x24b1>
movl   $0x0,-0x9cc4(%rbp)
mov    -0x9cc4(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    35e8 <main+0x2498>
movl   $0x0,-0x9cc8(%rbp)
mov    -0x9cc8(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    35cf <main+0x247f>
movl   $0x0,-0x9ccc(%rbp)
mov    -0x9ccc(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    35b6 <main+0x2466>
mov    -0x9cb0(%rbp),%rax
mov    -0x9cc4(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cc8(%rbp),%edx
imul   -0x9ca0(%rbp),%edx
add    %edx,%ecx
add    -0x9ccc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9ca8(%rbp),%rax
mov    -0x9cc4(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cc8(%rbp),%edx
imul   -0x9ca0(%rbp),%edx
add    %edx,%ecx
add    -0x9ccc(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9ccc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ccc(%rbp)
jmp    351b <main+0x23cb>
jmp    35bb <main+0x246b>
mov    -0x9cc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc8(%rbp)
jmp    34ff <main+0x23af>
jmp    35d4 <main+0x2484>
mov    -0x9cc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc4(%rbp)
jmp    34e3 <main+0x2393>
jmp    35ed <main+0x249d>
mov    -0x9cc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc0(%rbp)
jmp    34cc <main+0x237c>
movl   $0x0,-0x9cd0(%rbp)
mov    -0x9cd0(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    3759 <main+0x2609>
movl   $0x0,-0x9cd4(%rbp)
mov    -0x9cd4(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    3740 <main+0x25f0>
movl   $0x0,-0x9cd8(%rbp)
mov    -0x9cd8(%rbp),%eax
cmp    -0x9ca0(%rbp),%eax
jge    3727 <main+0x25d7>
mov    -0x9ca8(%rbp),%rax
mov    -0x9cd0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cd4(%rbp),%edx
imul   -0x9ca0(%rbp),%edx
add    %edx,%ecx
add    -0x9cd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x97b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    36aa <main+0x255a>
jp     36aa <main+0x255a>
jmp    370e <main+0x25be>
mov    -0x9cd0(%rbp),%esi
mov    -0x9cd4(%rbp),%edx
mov    -0x9ca8(%rbp),%rax
mov    -0x9cd0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
imul   -0x9ca0(%rbp),%ecx
mov    -0x9cd4(%rbp),%edi
imul   -0x9ca0(%rbp),%edi
add    %edi,%ecx
add    -0x9cd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x9ff(%rip),%rdi
movsd  0x91b(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    3713 <main+0x25c3>
mov    -0x9cd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd8(%rbp)
jmp    3643 <main+0x24f3>
jmp    372c <main+0x25dc>
mov    -0x9cd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd4(%rbp)
jmp    3627 <main+0x24d7>
jmp    3745 <main+0x25f5>
mov    -0x9cd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd0(%rbp)
jmp    360b <main+0x24bb>
cmpl   $0x0,-0x9b14(%rbp)
je     3779 <main+0x2629>
lea    0x902(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    3787 <main+0x2637>
lea    0x8f7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x9ce0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5d38,%rsp
xor    %eax,%eax
call   1070 <check_offloading@plt>
mov    $0x1e,%eax
movapd 0x1e6b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
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)
movapd %xmm0,0x1f20(%rsp,%rax,8)
movapd %xmm0,0x1f30(%rsp,%rax,8)
add    $0x20,%rax
cmp    $0x3fe,%rax
jne    11a0 <main+0x30>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x1f40(%rsp,%rbx,8),%xmm1
movapd 0x1f50(%rsp,%rbx,8),%xmm2
movapd 0x1f60(%rsp,%rbx,8),%xmm3
addpd  0x30(%rsp,%rbx,8),%xmm0
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
addpd  0x50(%rsp,%rbx,8),%xmm2
addpd  0x60(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x50(%rsp,%rbx,8)
movapd %xmm3,0x60(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1260 <main+0xf0>
xor    %ebx,%ebx
mov    $0x1,%al
movsd  0x1d83(%rip),%xmm0
lea    0x1db4(%rip),%r15
lea    0x1e6c(%rip),%r14
xor    %ebp,%ebp
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    12fd <main+0x18d>
jp     12fd <main+0x18d>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    12e0 <main+0x170>
jmp    1337 <main+0x1c7>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1d46(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1d37(%rip),%xmm0
lea    0x1(%rbx),%rcx
mov    $0x1,%ebp
xor    %eax,%eax
cmp    $0x1ff,%rbx
mov    %rcx,%rbx
jne    12e0 <main+0x170>
mov    $0x1,%ebp
jmp    1350 <main+0x1e0>
lea    0x1dff(%rip),%rcx
lea    0x1e02(%rip),%r14
xor    %edx,%edx
test   $0x1,%al
cmovne %rcx,%r14
cmovne %edx,%ebp
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
xchg   %ax,%ax
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     13d0 <main+0x260>
movapd 0x1f20(%rsp,%rax,8),%xmm0
movapd 0x1f30(%rsp,%rax,8),%xmm1
addpd  0x20(%rsp,%rax,8),%xmm0
addpd  0x30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x20(%rsp,%rax,8)
movapd %xmm1,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1370 <main+0x200>
xor    %ebx,%ebx
lea    0x1caf(%rip),%r15
lea    0x1d67(%rip),%r14
mov    %ebp,%ecx
movsd  0x1c66(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1410 <main+0x2a0>
jp     1410 <main+0x2a0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    13f0 <main+0x280>
jmp    1438 <main+0x2c8>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    13e2 <main+0x272>
mov    $0x1,%ebp
jmp    144e <main+0x2de>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x1cfa(%rip),%rax
lea    0x1cfd(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
addpd  (%rsp,%rax,8),%xmm0
movapd %xmm0,(%rsp,%rax,8)
cmp    $0x7e,%rax
je     14ce <main+0x35e>
movapd 0x1f10(%rsp,%rax,8),%xmm0
movapd 0x1f20(%rsp,%rax,8),%xmm1
movapd 0x1f30(%rsp,%rax,8),%xmm2
addpd  0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,0x10(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm1
movapd %xmm1,0x20(%rsp,%rax,8)
addpd  0x30(%rsp,%rax,8),%xmm2
movapd %xmm2,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1470 <main+0x300>
movsd  0x2300(%rsp),%xmm0
addsd  0x400(%rsp),%xmm0
movsd  %xmm0,0x400(%rsp)
xor    %ebx,%ebx
lea    0x1b96(%rip),%r15
lea    0x1c4e(%rip),%r14
mov    %ebp,%ecx
movsd  0x1b4d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1530 <main+0x3c0>
jp     1530 <main+0x3c0>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1510 <main+0x3a0>
jmp    1555 <main+0x3e5>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    14fb <main+0x38b>
mov    $0x1,%ebp
jmp    156b <main+0x3fb>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x1bdd(%rip),%rax
lea    0x1be0(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
movapd 0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x1f40(%rsp,%rbx,8),%xmm1
movapd 0x1f50(%rsp,%rbx,8),%xmm2
movapd 0x1f60(%rsp,%rbx,8),%xmm3
addpd  0x30(%rsp,%rbx,8),%xmm0
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
addpd  0x50(%rsp,%rbx,8),%xmm2
addpd  0x60(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x50(%rsp,%rbx,8)
movapd %xmm3,0x60(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1590 <main+0x420>
xor    %ebx,%ebx
lea    0x1a8e(%rip),%r15
lea    0x1b46(%rip),%r14
mov    %ebp,%ecx
movsd  0x1a45(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    162d <main+0x4bd>
jp     162d <main+0x4bd>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1610 <main+0x4a0>
jmp    1665 <main+0x4f5>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1a16(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1a07(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1610 <main+0x4a0>
mov    $0x1,%ebp
jmp    167b <main+0x50b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x1acd(%rip),%rax
lea    0x1ad0(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
movapd 0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x1f40(%rsp,%rbx,8),%xmm1
movapd 0x1f50(%rsp,%rbx,8),%xmm2
movapd 0x1f60(%rsp,%rbx,8),%xmm3
addpd  0x30(%rsp,%rbx,8),%xmm0
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
addpd  0x50(%rsp,%rbx,8),%xmm2
addpd  0x60(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x50(%rsp,%rbx,8)
movapd %xmm3,0x60(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    16a0 <main+0x530>
xor    %ebx,%ebx
lea    0x197e(%rip),%r15
lea    0x1a36(%rip),%r14
mov    %ebp,%ecx
movsd  0x1935(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    173d <main+0x5cd>
jp     173d <main+0x5cd>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1720 <main+0x5b0>
jmp    1775 <main+0x605>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1906(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x18f7(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1720 <main+0x5b0>
mov    $0x1,%ebp
jmp    178b <main+0x61b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x19bd(%rip),%rax
lea    0x19c0(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
movapd 0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x1f40(%rsp,%rbx,8),%xmm1
movapd 0x1f50(%rsp,%rbx,8),%xmm2
movapd 0x1f60(%rsp,%rbx,8),%xmm3
addpd  0x30(%rsp,%rbx,8),%xmm0
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
addpd  0x50(%rsp,%rbx,8),%xmm2
addpd  0x60(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x50(%rsp,%rbx,8)
movapd %xmm3,0x60(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    17b0 <main+0x640>
xor    %ebx,%ebx
lea    0x186e(%rip),%r15
lea    0x1926(%rip),%r14
mov    %ebp,%ecx
movsd  0x1825(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    184d <main+0x6dd>
jp     184d <main+0x6dd>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1830 <main+0x6c0>
jmp    1885 <main+0x715>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x17f6(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x17e7(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1830 <main+0x6c0>
mov    $0x1,%ebp
jmp    189b <main+0x72b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x18ad(%rip),%rax
lea    0x18b0(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     1920 <main+0x7b0>
movapd 0x1f20(%rsp,%rax,8),%xmm0
movapd 0x1f30(%rsp,%rax,8),%xmm1
addpd  0x20(%rsp,%rax,8),%xmm0
addpd  0x30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x20(%rsp,%rax,8)
movapd %xmm1,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    18c0 <main+0x750>
xor    %ebx,%ebx
lea    0x175f(%rip),%r15
lea    0x1817(%rip),%r14
mov    %ebp,%ecx
movsd  0x1716(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1960 <main+0x7f0>
jp     1960 <main+0x7f0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1940 <main+0x7d0>
jmp    1988 <main+0x818>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1932 <main+0x7c2>
mov    $0x1,%ebp
jmp    199e <main+0x82e>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x17aa(%rip),%rax
lea    0x17ad(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     1a20 <main+0x8b0>
movapd 0x1f20(%rsp,%rax,8),%xmm0
movapd 0x1f30(%rsp,%rax,8),%xmm1
addpd  0x20(%rsp,%rax,8),%xmm0
addpd  0x30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x20(%rsp,%rax,8)
movapd %xmm1,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    19c0 <main+0x850>
xor    %ebx,%ebx
lea    0x165f(%rip),%r15
lea    0x1717(%rip),%r14
mov    %ebp,%ecx
movsd  0x1616(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1a60 <main+0x8f0>
jp     1a60 <main+0x8f0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1a40 <main+0x8d0>
jmp    1a88 <main+0x918>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1a32 <main+0x8c2>
mov    $0x1,%ebp
jmp    1a9e <main+0x92e>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x16aa(%rip),%rax
lea    0x16ad(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     1b20 <main+0x9b0>
movapd 0x1f20(%rsp,%rax,8),%xmm0
movapd 0x1f30(%rsp,%rax,8),%xmm1
addpd  0x20(%rsp,%rax,8),%xmm0
addpd  0x30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x20(%rsp,%rax,8)
movapd %xmm1,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1ac0 <main+0x950>
xor    %ebx,%ebx
lea    0x155f(%rip),%r15
lea    0x1617(%rip),%r14
mov    %ebp,%ecx
movsd  0x1516(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1b60 <main+0x9f0>
jp     1b60 <main+0x9f0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1b40 <main+0x9d0>
jmp    1b88 <main+0xa18>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1b32 <main+0x9c2>
mov    $0x1,%ebp
jmp    1b9e <main+0xa2e>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x15aa(%rip),%rax
lea    0x15ad(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
addpd  (%rsp,%rax,8),%xmm0
movapd %xmm0,(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1c1e <main+0xaae>
movapd 0x1f10(%rsp,%rax,8),%xmm0
movapd 0x1f20(%rsp,%rax,8),%xmm1
movapd 0x1f30(%rsp,%rax,8),%xmm2
addpd  0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,0x10(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm1
movapd %xmm1,0x20(%rsp,%rax,8)
addpd  0x30(%rsp,%rax,8),%xmm2
movapd %xmm2,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1bc0 <main+0xa50>
movsd  0x2300(%rsp),%xmm0
addsd  0x400(%rsp),%xmm0
movsd  %xmm0,0x400(%rsp)
xor    %ebx,%ebx
lea    0x1446(%rip),%r15
lea    0x14fe(%rip),%r14
mov    %ebp,%ecx
movsd  0x13fd(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1c80 <main+0xb10>
jp     1c80 <main+0xb10>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1c60 <main+0xaf0>
jmp    1ca5 <main+0xb35>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1c4b <main+0xadb>
mov    $0x1,%ebp
jmp    1cbb <main+0xb4b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x148d(%rip),%rax
lea    0x1490(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
addpd  (%rsp,%rax,8),%xmm0
movapd %xmm0,(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1d3e <main+0xbce>
movapd 0x1f10(%rsp,%rax,8),%xmm0
movapd 0x1f20(%rsp,%rax,8),%xmm1
movapd 0x1f30(%rsp,%rax,8),%xmm2
addpd  0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,0x10(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm1
movapd %xmm1,0x20(%rsp,%rax,8)
addpd  0x30(%rsp,%rax,8),%xmm2
movapd %xmm2,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1ce0 <main+0xb70>
movsd  0x2300(%rsp),%xmm0
addsd  0x400(%rsp),%xmm0
movsd  %xmm0,0x400(%rsp)
xor    %ebx,%ebx
lea    0x1326(%rip),%r15
lea    0x13de(%rip),%r14
mov    %ebp,%ecx
movsd  0x12dd(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1da0 <main+0xc30>
jp     1da0 <main+0xc30>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1d80 <main+0xc10>
jmp    1dc5 <main+0xc55>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1d6b <main+0xbfb>
mov    $0x1,%ebp
jmp    1ddb <main+0xc6b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x136d(%rip),%rax
lea    0x1370(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1f00(%rsp,%rax,8),%xmm0
addpd  (%rsp,%rax,8),%xmm0
movapd %xmm0,(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1e5e <main+0xcee>
movapd 0x1f10(%rsp,%rax,8),%xmm0
movapd 0x1f20(%rsp,%rax,8),%xmm1
movapd 0x1f30(%rsp,%rax,8),%xmm2
addpd  0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,0x10(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm1
movapd %xmm1,0x20(%rsp,%rax,8)
addpd  0x30(%rsp,%rax,8),%xmm2
movapd %xmm2,0x30(%rsp,%rax,8)
add    $0x8,%rax
jmp    1e00 <main+0xc90>
movsd  0x2300(%rsp),%xmm0
addsd  0x400(%rsp),%xmm0
movsd  %xmm0,0x400(%rsp)
xor    %ebx,%ebx
lea    0x1206(%rip),%r15
lea    0x12be(%rip),%r14
mov    %ebp,%ecx
movsd  0x11bd(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1ec0 <main+0xd50>
jp     1ec0 <main+0xd50>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1ea0 <main+0xd30>
jmp    1ee5 <main+0xd75>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1e8b <main+0xd1b>
mov    $0x1,%ebp
jmp    1efb <main+0xd8b>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0x124d(%rip),%rax
lea    0x1250(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
movapd 0x10db(%rip),%xmm2
movapd 0x10e3(%rip),%xmm3
nopl   (%rax)
movapd (%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movapd 0x10(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
movapd 0x3e00(%rsp,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movapd 0x3e10(%rsp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,0x3e00(%rsp,%rax,8)
movapd %xmm1,0x3e10(%rsp,%rax,8)
movapd 0x20(%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movapd 0x30(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,0x20(%rsp,%rax,8)
movapd %xmm1,0x30(%rsp,%rax,8)
movapd 0x3e20(%rsp,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movapd 0x3e30(%rsp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,0x3e20(%rsp,%rax,8)
movapd %xmm1,0x3e30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x3e6,%rax
jne    1f40 <main+0xdd0>
xor    %ebx,%ebx
movsd  0x1068(%rip),%xmm2
lea    0x10b0(%rip),%r15
lea    0x10cb(%rip),%r12
lea    0x1142(%rip),%r14
mov    %ebp,%eax
jmp    201d <main+0xead>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     208e <main+0xf1e>
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm2,%xmm1
jne    202b <main+0xebb>
jnp    2048 <main+0xed8>
mov    %r15,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1015(%rip),%xmm2
mov    $0x1,%eax
movsd  0x3e30(%rsp,%rbx,8),%xmm1
movsd  0x1007(%rip),%xmm0
ucomisd %xmm0,%xmm1
jne    2061 <main+0xef1>
jnp    2010 <main+0xea0>
mov    %r12,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xfe3(%rip),%xmm2
add    $0x1,%rbx
mov    $0x1,%eax
cmp    $0x3e0,%rbx
jne    201d <main+0xead>
mov    $0x1,%ebp
jmp    20a4 <main+0xf34>
mov    %eax,%ebp
test   %eax,%eax
lea    0x10a4(%rip),%rax
lea    0x10a7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movapd 0xf55(%rip),%xmm0
movapd 0xf5d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x30(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x30(%rsp,%rbx,8)
movsd  0x3e30(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e30(%rsp,%rbx,8)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x38(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x38(%rsp,%rbx,8)
movsd  0x3e38(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e38(%rsp,%rbx,8)
add    $0x2,%rbx
cmp    $0x80,%rbx
jne    20f0 <main+0xf80>
xor    %ebx,%ebx
movsd  0xf15(%rip),%xmm0
lea    0xf3d(%rip),%r14
lea    0xf58(%rip),%r15
movsd  0xeef(%rip),%xmm2
jmp    21ad <main+0x103d>
nopl   0x0(%rax,%rax,1)
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xed9(%rip),%xmm2
movsd  0xee1(%rip),%xmm0
mov    $0x1,%ebp
add    $0x1,%rbx
cmp    $0x80,%rbx
je     2268 <main+0x10f8>
movsd  0x30(%rsp,%rbx,8),%xmm1
test   $0x1,%bl
jne    2210 <main+0x10a0>
ucomisd %xmm0,%xmm1
jne    21c0 <main+0x1050>
jnp    21e9 <main+0x1079>
mov    %r14,%rdi
mov    %ebx,%esi
movsd  0xeab(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xe8c(%rip),%xmm2
movsd  0xe94(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e30(%rsp,%rbx,8),%xmm1
ucomisd 0xe86(%rip),%xmm1
jne    21fe <main+0x108e>
jnp    219c <main+0x102c>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xe75(%rip),%xmm0
jmp    2180 <main+0x1010>
ucomisd %xmm2,%xmm1
jne    2218 <main+0x10a8>
jnp    223d <main+0x10cd>
mov    %r14,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xe38(%rip),%xmm2
movsd  0xe40(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e30(%rsp,%rbx,8),%xmm1
ucomisd 0xe22(%rip),%xmm1
jne    2256 <main+0x10e6>
jnp    219c <main+0x102c>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xe0d(%rip),%xmm0
jmp    2180 <main+0x1010>
mov    %ebp,%r15d
test   %ebp,%ebp
lea    0xec9(%rip),%r12
lea    0xecc(%rip),%r14
mov    %r14,%rdi
cmove  %r12,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
test   %eax,%eax
jle    22cc <main+0x115c>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
call   1080 <omp_get_team_num@plt>
mov    %eax,%ebx
add    $0x1,%ebp
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
cmp    %eax,%ebp
jl     22a0 <main+0x1130>
cmp    $0x9,%ebx
jne    22d1 <main+0x1161>
test   %r15d,%r15d
lea    0xe81(%rip),%r14
cmove  %r12,%r14
jmp    22ec <main+0x117c>
mov    $0xffffffff,%ebx
lea    0xe13(%rip),%rdi
mov    %ebx,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%r15d
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nopl   0x0(%rax,%rax,1)
movapd 0x3e30(%rsp,%rbx,8),%xmm0
addpd  0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x3e40(%rsp,%rbx,8),%xmm1
addpd  0x30(%rsp,%rbx,8),%xmm0
movapd %xmm0,0x30(%rsp,%rbx,8)
addpd  0x1f40(%rsp,%rbx,8),%xmm1
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm1,0x40(%rsp,%rbx,8)
add    $0x4,%rbx
cmp    $0x40,%rbx
jne    2320 <main+0x11b0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movapd 0x4030(%rsp,%rax,8),%xmm0
addpd  0x2130(%rsp,%rax,8),%xmm0
movapd 0x4040(%rsp,%rax,8),%xmm1
addpd  0x230(%rsp,%rax,8),%xmm0
movapd %xmm0,0x230(%rsp,%rax,8)
addpd  0x2140(%rsp,%rax,8),%xmm1
addpd  0x240(%rsp,%rax,8),%xmm1
movapd %xmm1,0x240(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2370 <main+0x1200>
xor    %eax,%eax
mov    %r15d,%ecx
nopw   0x0(%rax,%rax,1)
movapd 0x4230(%rsp,%rax,8),%xmm0
addpd  0x2330(%rsp,%rax,8),%xmm0
movapd 0x4240(%rsp,%rax,8),%xmm1
addpd  0x430(%rsp,%rax,8),%xmm0
movapd %xmm0,0x430(%rsp,%rax,8)
addpd  0x2340(%rsp,%rax,8),%xmm1
addpd  0x440(%rsp,%rax,8),%xmm1
movapd %xmm1,0x440(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    23d0 <main+0x1260>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4430(%rsp,%rax,8),%xmm0
addpd  0x2530(%rsp,%rax,8),%xmm0
movapd 0x4440(%rsp,%rax,8),%xmm1
addpd  0x630(%rsp,%rax,8),%xmm0
movapd %xmm0,0x630(%rsp,%rax,8)
addpd  0x2540(%rsp,%rax,8),%xmm1
addpd  0x640(%rsp,%rax,8),%xmm1
movapd %xmm1,0x640(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2430 <main+0x12c0>
xor    %ebx,%ebx
lea    0xc1c(%rip),%r15
lea    0xcb5(%rip),%r14
movsd  0xbb6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    24c0 <main+0x1350>
jp     24c0 <main+0x1350>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    24a0 <main+0x1330>
jmp    24f0 <main+0x1380>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xbab(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    2492 <main+0x1322>
mov    $0x1,%ebp
jmp    24ff <main+0x138f>
mov    %ecx,%ebp
test   %ecx,%ecx
lea    0xc4c(%rip),%r14
cmove  %r12,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x30(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xchg   %ax,%ax
movapd 0x3e30(%rsp,%rbx,8),%xmm0
addpd  0x1f30(%rsp,%rbx,8),%xmm0
movapd 0x3e40(%rsp,%rbx,8),%xmm1
addpd  0x30(%rsp,%rbx,8),%xmm0
movapd %xmm0,0x30(%rsp,%rbx,8)
addpd  0x1f40(%rsp,%rbx,8),%xmm1
addpd  0x40(%rsp,%rbx,8),%xmm1
movapd %xmm1,0x40(%rsp,%rbx,8)
add    $0x4,%rbx
cmp    $0x40,%rbx
jne    2530 <main+0x13c0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movapd 0x4030(%rsp,%rax,8),%xmm0
addpd  0x2130(%rsp,%rax,8),%xmm0
movapd 0x4040(%rsp,%rax,8),%xmm1
addpd  0x230(%rsp,%rax,8),%xmm0
movapd %xmm0,0x230(%rsp,%rax,8)
addpd  0x2140(%rsp,%rax,8),%xmm1
addpd  0x240(%rsp,%rax,8),%xmm1
movapd %xmm1,0x240(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2580 <main+0x1410>
xor    %eax,%eax
mov    %ebp,%ecx
cs nopw 0x0(%rax,%rax,1)
movapd 0x4230(%rsp,%rax,8),%xmm0
addpd  0x2330(%rsp,%rax,8),%xmm0
movapd 0x4240(%rsp,%rax,8),%xmm1
addpd  0x430(%rsp,%rax,8),%xmm0
movapd %xmm0,0x430(%rsp,%rax,8)
addpd  0x2340(%rsp,%rax,8),%xmm1
addpd  0x440(%rsp,%rax,8),%xmm1
movapd %xmm1,0x440(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    25e0 <main+0x1470>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4430(%rsp,%rax,8),%xmm0
addpd  0x2530(%rsp,%rax,8),%xmm0
movapd 0x4440(%rsp,%rax,8),%xmm1
addpd  0x630(%rsp,%rax,8),%xmm0
movapd %xmm0,0x630(%rsp,%rax,8)
addpd  0x2540(%rsp,%rax,8),%xmm1
addpd  0x640(%rsp,%rax,8),%xmm1
movapd %xmm1,0x640(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2640 <main+0x14d0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4630(%rsp,%rax,8),%xmm0
addpd  0x2730(%rsp,%rax,8),%xmm0
movapd 0x4640(%rsp,%rax,8),%xmm1
addpd  0x830(%rsp,%rax,8),%xmm0
movapd %xmm0,0x830(%rsp,%rax,8)
addpd  0x2740(%rsp,%rax,8),%xmm1
addpd  0x840(%rsp,%rax,8),%xmm1
movapd %xmm1,0x840(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    26a0 <main+0x1530>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4830(%rsp,%rax,8),%xmm0
addpd  0x2930(%rsp,%rax,8),%xmm0
movapd 0x4840(%rsp,%rax,8),%xmm1
addpd  0xa30(%rsp,%rax,8),%xmm0
movapd %xmm0,0xa30(%rsp,%rax,8)
addpd  0x2940(%rsp,%rax,8),%xmm1
addpd  0xa40(%rsp,%rax,8),%xmm1
movapd %xmm1,0xa40(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2700 <main+0x1590>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4a30(%rsp,%rax,8),%xmm0
addpd  0x2b30(%rsp,%rax,8),%xmm0
movapd 0x4a40(%rsp,%rax,8),%xmm1
addpd  0xc30(%rsp,%rax,8),%xmm0
movapd %xmm0,0xc30(%rsp,%rax,8)
addpd  0x2b40(%rsp,%rax,8),%xmm1
addpd  0xc40(%rsp,%rax,8),%xmm1
movapd %xmm1,0xc40(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2760 <main+0x15f0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4c30(%rsp,%rax,8),%xmm0
addpd  0x2d30(%rsp,%rax,8),%xmm0
movapd 0x4c40(%rsp,%rax,8),%xmm1
addpd  0xe30(%rsp,%rax,8),%xmm0
movapd %xmm0,0xe30(%rsp,%rax,8)
addpd  0x2d40(%rsp,%rax,8),%xmm1
addpd  0xe40(%rsp,%rax,8),%xmm1
movapd %xmm1,0xe40(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    27c0 <main+0x1650>
xor    %ebx,%ebx
lea    0x88c(%rip),%r15
lea    0x925(%rip),%r14
movsd  0x826(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2850 <main+0x16e0>
jp     2850 <main+0x16e0>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    2830 <main+0x16c0>
jmp    2883 <main+0x1713>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x81b(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ecx
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    2822 <main+0x16b2>
movl   $0x1,0x4(%rsp)
jmp    2894 <main+0x1724>
mov    %ecx,0x4(%rsp)
test   %ecx,%ecx
lea    0x8b7(%rip),%r14
cmove  %r12,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x782000,%edi
call   1060 <malloc@plt>
xor    %r8d,%r8d
movabs $0x3ff0000000000000,%rdx
movabs $0x4000000000000000,%r13
xorpd  %xmm0,%xmm0
mov    %r15,%rsi
mov    %r14,%rdi
mov    %rax,0x8(%rsp)
mov    %rax,%rbx
movapd 0x70f(%rip),%xmm1
movapd 0x717(%rip),%xmm2
mov    %r14,0x10(%rsp)
jmp    292b <main+0x17bb>
add    $0x1,%r8
add    $0x1f00,%rbx
add    $0x1f00,%rdi
add    $0x1f00,%rsi
cmp    $0x3e0,%r8
mov    0x10(%rsp),%r14
je     2a45 <main+0x18d5>
imul   $0x1f00,%r8,%rcx
lea    (%r15,%rcx,1),%rbp
lea    (%r15,%rcx,1),%r9
add    $0x1f00,%r9
lea    (%r14,%rcx,1),%r10
lea    0x1f00(%r14,%rcx,1),%r12
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,1),%r14
lea    (%rax,%rcx,1),%r11
add    $0x1f00,%r11
cmp    %r12,%rbp
setb   0x18(%rsp)
cmp    %r9,%r10
setb   %al
cmp    %r11,%rbp
setb   %cl
cmp    %r9,%r14
setb   %bpl
cmp    %r11,%r10
setb   %r9b
cmp    %r12,%r14
setb   %r10b
test   %al,0x18(%rsp)
jne    2a00 <main+0x1890>
and    %bpl,%cl
jne    2a00 <main+0x1890>
and    %r10b,%r9b
jne    2a00 <main+0x1890>
mov    $0x6,%ecx
nop
movupd %xmm0,-0x30(%rsi,%rcx,8)
movupd %xmm0,-0x20(%rsi,%rcx,8)
movupd %xmm1,-0x30(%rdi,%rcx,8)
movupd %xmm1,-0x20(%rdi,%rcx,8)
movupd %xmm2,-0x30(%rbx,%rcx,8)
movupd %xmm2,-0x20(%rbx,%rcx,8)
movupd %xmm0,-0x10(%rsi,%rcx,8)
movupd %xmm0,(%rsi,%rcx,8)
movupd %xmm1,-0x10(%rdi,%rcx,8)
movupd %xmm1,(%rdi,%rcx,8)
movupd %xmm2,-0x10(%rbx,%rcx,8)
movupd %xmm2,(%rbx,%rcx,8)
add    $0x8,%rcx
cmp    $0x3e6,%rcx
jne    29a0 <main+0x1830>
jmp    2900 <main+0x1790>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,-0x8(%rsi,%rcx,8)
mov    %rdx,-0x8(%rdi,%rcx,8)
mov    %r13,-0x8(%rbx,%rcx,8)
movq   $0x0,(%rsi,%rcx,8)
mov    %rdx,(%rdi,%rcx,8)
mov    %r13,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    $0x3e1,%rcx
jne    2a10 <main+0x18a0>
jmp    2900 <main+0x1790>
xor    %r9d,%r9d
mov    %r14,%rdx
mov    0x8(%rsp),%rsi
mov    %r15,%rdi
jmp    2a86 <main+0x1916>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    $0x1f00,%rdi
add    $0x1f00,%rsi
add    $0x1f00,%rdx
cmp    $0x3e0,%r9
je     2b8e <main+0x1a1e>
imul   $0x1f00,%r9,%rax
lea    (%r15,%rax,1),%rbp
lea    (%r15,%rax,1),%rcx
add    $0x1f00,%rcx
mov    0x8(%rsp),%rbx
lea    (%rbx,%rax,1),%r10
add    $0x1f00,%r10
lea    (%rbx,%rax,1),%r8
lea    (%r14,%rax,1),%rbx
add    $0x1f00,%rbx
add    %r14,%rax
cmp    %rbx,%rbp
setb   %r11b
cmp    %rcx,%rax
setb   %al
cmp    %r10,%rbp
setb   %bl
cmp    %rcx,%r8
setb   %r8b
test   %al,%r11b
jne    2b40 <main+0x19d0>
and    %r8b,%bl
jne    2b40 <main+0x19d0>
mov    $0x2,%ebx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
movupd -0x10(%rsi,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd (%rsi,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rdi,%rbx,8),%xmm1
addpd  %xmm2,%xmm1
movupd (%rdi,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rdi,%rbx,8)
movupd %xmm2,(%rdi,%rbx,8)
add    $0x4,%rbx
cmp    $0x3e2,%rbx
jne    2af0 <main+0x1980>
jmp    2a60 <main+0x18f0>
xchg   %ax,%ax
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rbx,8),%xmm0
addsd  -0x8(%rsi,%rbx,8),%xmm0
addsd  -0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm0
addsd  (%rsi,%rbx,8),%xmm0
addsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x2,%rbx
cmp    $0x3e1,%rbx
jne    2b50 <main+0x19e0>
jmp    2a60 <main+0x18f0>
xor    %r12d,%r12d
lea    0x581(%rip),%r14
mov    0x4(%rsp),%eax
movsd  0x4bc(%rip),%xmm0
jmp    2bc4 <main+0x1a54>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x1f00,%r15
cmp    $0x3e0,%r12
je     2c11 <main+0x1aa1>
xor    %ebx,%ebx
jmp    2bdd <main+0x1a6d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     2bb0 <main+0x1a40>
movsd  (%r15,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2beb <main+0x1a7b>
jnp    2bd0 <main+0x1a60>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
movsd  0x465(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x456(%rip),%xmm0
mov    $0x1,%eax
jmp    2bd0 <main+0x1a60>
mov    %eax,0x4(%rsp)
test   %eax,%eax
lea    0x529(%rip),%rdi
lea    0x518(%rip),%rax
cmove  %rax,%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),%rsi
lea    0x18(%rax),%rbx
lea    0x18(%r15),%rdi
xor    %edx,%edx
movabs $0x4008000000000000,%rcx
movapd 0x3a7(%rip),%xmm0
movapd 0x3af(%rip),%xmm1
jmp    2cc3 <main+0x1b53>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
mov    0x8(%rsp),%r8
add    $0x1e080,%r8
mov    0x18(%rsp),%rsi
add    $0x1e080,%rsi
mov    0x10(%rsp),%rbx
add    $0x1e080,%rbx
mov    0x28(%rsp),%rdi
add    $0x1e080,%rdi
cmp    $0x7c,%rdx
je     2dc7 <main+0x1c57>
mov    %rdx,0x20(%rsp)
imul   $0x3c10,%rdx,%r10
lea    0x7c(%r10),%r11
mov    %rdi,0x28(%rsp)
mov    %rbx,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r8,0x8(%rsp)
xor    %r14d,%r14d
jmp    2d1a <main+0x1baa>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x3e0,%r8
add    $0x3e0,%rsi
add    $0x3e0,%rbx
add    $0x3e0,%rdi
cmp    $0x7c,%r14
je     2c80 <main+0x1b10>
imul   $0x7c,%r14,%rdx
lea    (%r10,%rdx,1),%rbp
add    %r11,%rdx
lea    (%rax,%rdx,8),%r9
lea    (%r15,%rbp,8),%r12
cmp    %r9,%r12
jae    2d90 <main+0x1c20>
lea    (%rax,%rbp,8),%rbp
lea    (%r15,%rdx,8),%rdx
cmp    %rdx,%rbp
jae    2d90 <main+0x1c20>
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,-0x18(%rdi,%r9,8)
mov    %rcx,-0x18(%rbx,%r9,8)
mov    %r13,-0x10(%rdi,%r9,8)
mov    %rcx,-0x10(%rbx,%r9,8)
mov    %r13,-0x8(%rdi,%r9,8)
mov    %rcx,-0x8(%rbx,%r9,8)
mov    %r13,(%rdi,%r9,8)
mov    %rcx,(%rbx,%r9,8)
add    $0x4,%r9
cmp    $0x7c,%r9
jne    2d50 <main+0x1be0>
jmp    2cf0 <main+0x1b80>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x10(%rsi,%rdx,8)
movupd %xmm1,-0x10(%r8,%rdx,8)
movupd %xmm0,(%rsi,%rdx,8)
movupd %xmm1,(%r8,%rdx,8)
add    $0x4,%rdx
cmp    $0x7c,%rdx
jne    2da0 <main+0x1c30>
jmp    2cf0 <main+0x1b80>
lea    0x10(%r15),%rbp
lea    0x10(%rax),%rdx
lea    0x8(%r15),%rsi
lea    0x8(%rax),%r11
xor    %r12d,%r12d
jmp    2e19 <main+0x1ca9>
nopl   0x0(%rax)
add    $0x1,%r12
mov    0x8(%rsp),%rbp
add    $0x1e080,%rbp
mov    0x18(%rsp),%rdx
add    $0x1e080,%rdx
mov    0x10(%rsp),%rsi
add    $0x1e080,%rsi
add    $0x1e080,%r11
cmp    $0x7c,%r12
je     2f1a <main+0x1daa>
imul   $0x3c10,%r12,%r14
lea    0x7c(%r14),%r13
mov    %r11,%rdi
mov    %rsi,0x10(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rbp,0x8(%rsp)
xor    %ecx,%ecx
jmp    2e6a <main+0x1cfa>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x3e0,%rbp
add    $0x3e0,%rdx
add    $0x3e0,%rsi
add    $0x3e0,%rdi
cmp    $0x7c,%rcx
je     2de0 <main+0x1c70>
imul   $0x7c,%rcx,%rbx
lea    (%r14,%rbx,1),%r8
add    %r13,%rbx
lea    (%rax,%rbx,8),%r9
lea    (%r15,%r8,8),%r10
cmp    %r9,%r10
jae    2ed0 <main+0x1d60>
lea    (%rax,%r8,8),%r8
lea    (%r15,%rbx,8),%rbx
cmp    %rbx,%r8
jae    2ed0 <main+0x1d60>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rbx,8),%xmm0
addsd  -0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rbx,8)
movsd  (%rdi,%rbx,8),%xmm0
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x2,%rbx
cmp    $0x7c,%rbx
jne    2ea0 <main+0x1d30>
jmp    2e40 <main+0x1cd0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd -0x10(%rbp,%rbx,8),%xmm1
addpd  %xmm0,%xmm1
movupd 0x0(%rbp,%rbx,8),%xmm0
movupd %xmm1,-0x10(%rbp,%rbx,8)
movupd (%rdx,%rbx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    $0x7c,%rbx
jne    2ee0 <main+0x1d70>
jmp    2e40 <main+0x1cd0>
xor    %r13d,%r13d
lea    0x1f5(%rip),%r12
mov    0x4(%rsp),%eax
jmp    2f41 <main+0x1dd1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1e080,%r15
cmp    $0x7c,%r13
je     2fab <main+0x1e3b>
mov    %r15,%rbp
xor    %r14d,%r14d
jmp    2f61 <main+0x1df1>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x3e0,%rbp
cmp    $0x7c,%r14
je     2f30 <main+0x1dc0>
xor    %ebx,%ebx
jmp    2f7a <main+0x1e0a>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
cmp    $0x7c,%rbx
je     2f50 <main+0x1de0>
movsd  0x0(%rbp,%rbx,8),%xmm1
ucomisd 0xf0(%rip),%xmm1
jne    2f8c <main+0x1e1c>
jnp    2f70 <main+0x1e00>
mov    %r12,%rdi
mov    %r13d,%esi
mov    %r14d,%edx
movsd  0xc3(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
mov    $0x1,%eax
jmp    2f70 <main+0x1e00>
test   %eax,%eax
lea    0x189(%rip),%rax
lea    0x18c(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x5d38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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