#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();
double *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
#pragma omp teams num_teams(512)
#pragma omp distribute
    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
#pragma omp teams num_teams(256)
#pragma omp distribute
    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
#pragma omp teams num_teams(256)
#pragma omp distribute
    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
#pragma omp teams num_teams(512)
#pragma omp distribute dist_schedule(static, 1)
    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
#pragma omp teams num_teams(512)
#pragma omp distribute dist_schedule(static, 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
#pragma omp teams num_teams(512)
#pragma omp distribute dist_schedule(static, chunkSize)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, 1)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, 500)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, chunkSize)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, 1)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, 123)
    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
#pragma omp teams num_teams(256)
#pragma omp distribute dist_schedule(static, chunkSize)
    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
#pragma omp teams num_teams(256)
    {
#pragma omp distribute private(p, q)
      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
#pragma omp teams num_teams(64)
    {
#pragma omp distribute firstprivate(p, q)
      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 = -1;
#pragma omp target map(tofrom : lastpriv)
#pragma omp teams num_teams(10)
#pragma omp distribute lastprivate(lastpriv)
  for (int i = 0; i < omp_get_num_teams(); i++)
    lastpriv = omp_get_team_num();
  if (lastpriv != 9) {
    printf("lastpriv value is %d and should have been %d\n", lastpriv, 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
#pragma omp teams num_teams(nte) thread_limit(tl)
    {
#pragma omp distribute
      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
#pragma omp teams num_teams(nte) thread_limit(tl)
    {
#pragma omp distribute
      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 = malloc((992) * (992) * sizeof(double));
  double *T = malloc((992) * (992) * sizeof(double));
  double *U = malloc((992) * (992) * sizeof(double));
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++) {
      S[i * (992) + j] = 0.0;
      T[i * (992) + j] = 1.0;
      U[i * (992) + j] = 2.0;
    }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : S[:N * N]), map(to : T[:N * N], U[:N * N])
#pragma omp teams num_teams(512)
#pragma omp distribute collapse(2)
    for (int i = 0; i < (992); i++)
      for (int j = 0; j < (992); j++)
        S[i * (992) + j] += T[i * (992) + j] + U[i * (992) + j];
  }
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++)
      if (S[i * (992) + j] != (1) * 3.0) {
        printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j, (double)(1) * 3.0,
               S[i * (992) + j]);
        fail = 1;
      }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  int M = (992) / 8;
  double *V = malloc(M * M * M * sizeof(double));
  double *Z = malloc(M * M * M * sizeof(double));
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++) {
        V[i * M * M + j * M + k] = 2.0;
        Z[i * M * M + j * M + k] = 3.0;
      }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : V[:M * M * M]), map(to : Z[:M * M * M])
#pragma omp teams num_teams(512)
#pragma omp distribute collapse(3)
    for (int i = 0; i < M; i++)
      for (int j = 0; j < M; j++)
        for (int k = 0; k < M; k++)
          V[i * M * M + j * M + k] += Z[i * M * M + j * M + k];
  }
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++)
        if (V[i * M * M + j * M + k] != 2.0 + (1) * 3.0) {
          printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j,
                 (double)(1) * 3.0, V[i * M * M + j * M + k]);
          fail = 1;
        }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $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    0x2d2f(%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    0x2d08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1379 <main+0x229>
lea    0x2cfd(%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    0x2ba3(%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    0x2b7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1505 <main+0x3b5>
lea    0x2b71(%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    0x2a1d(%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    0x29f6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    168b <main+0x53b>
lea    0x29eb(%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    0x2891(%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    0x286a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1817 <main+0x6c7>
lea    0x285f(%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    0x2705(%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    0x26de(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    19a3 <main+0x853>
lea    0x26d3(%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    0x255d(%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    0x2536(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b4b <main+0x9fb>
lea    0x252b(%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    0x23d1(%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    0x23aa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1cd7 <main+0xb87>
lea    0x239f(%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    0x2245(%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    0x221e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1e63 <main+0xd13>
lea    0x2213(%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    0x209d(%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    0x2076(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    200b <main+0xebb>
lea    0x206b(%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    0x1f17(%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    0x1ef0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2191 <main+0x1041>
lea    0x1ee5(%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    0x1d91(%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    0x1d6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2317 <main+0x11c7>
lea    0x1d5f(%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    0x1bef(%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    0x1bc8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    24b9 <main+0x1369>
lea    0x1bbd(%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    0x19fb(%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    0x19ba(%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    0x193f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2742 <main+0x15f2>
lea    0x1934(%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    0x174b(%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    0x170a(%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    0x1680(%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    0x163f(%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    0x15bf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2ac2 <main+0x1972>
lea    0x15b4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xffffffff,-0x9c1c(%rbp)
ff ff ff
movl   $0x0,-0x9c20(%rbp)
mov    -0x9c20(%rbp),%eax
mov    %eax,-0x9cd4(%rbp)
mov    $0x0,%al
call   1070 <omp_get_num_teams@plt>
mov    %eax,%ecx
mov    -0x9cd4(%rbp),%eax
cmp    %ecx,%eax
jge    2b1a <main+0x19ca>
mov    $0x0,%al
call   1060 <omp_get_team_num@plt>
mov    %eax,-0x9c1c(%rbp)
mov    -0x9c20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c20(%rbp)
jmp    2ad6 <main+0x1986>
cmpl   $0x9,-0x9c1c(%rbp)
je     2b4a <main+0x19fa>
mov    -0x9c1c(%rbp),%esi
lea    0x158a(%rip),%rdi
mov    $0x9,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
cmpl   $0x0,-0x9b14(%rbp)
je     2b6a <main+0x1a1a>
lea    0x1509(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2b78 <main+0x1a28>
lea    0x14fe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c24(%rbp)
cmpl   $0x3e0,-0x9c24(%rbp)
jge    2bb9 <main+0x1a69>
movslq -0x9c24(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c24(%rbp)
jmp    2b82 <main+0x1a32>
movl   $0x0,-0x9c28(%rbp)
cmpl   $0x3e0,-0x9c28(%rbp)
jge    2bfa <main+0x1aaa>
movslq -0x9c28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    2bc3 <main+0x1a73>
movl   $0x20,-0x9c2c(%rbp)
movl   $0x40,-0x9c30(%rbp)
mov    -0x9c30(%rbp),%eax
mov    %eax,-0x9c34(%rbp)
movl   $0x0,-0x9c38(%rbp)
cmpl   $0x1,-0x9c38(%rbp)
jge    2cf3 <main+0x1ba3>
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x100,-0x9c3c(%rbp)
jge    2cda <main+0x1b8a>
mov    -0x9c3c(%rbp),%eax
mov    %eax,-0x9c40(%rbp)
mov    -0x9c40(%rbp),%eax
mov    -0x9c3c(%rbp),%ecx
add    -0x9c34(%rbp),%ecx
cmp    %ecx,%eax
jge    2cbe <main+0x1b6e>
movslq -0x9c40(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c40(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c40(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c40(%rbp)
jmp    2c57 <main+0x1b07>
jmp    2cc3 <main+0x1b73>
mov    -0x9c34(%rbp),%eax
add    -0x9c3c(%rbp),%eax
mov    %eax,-0x9c3c(%rbp)
jmp    2c3b <main+0x1aeb>
jmp    2cdf <main+0x1b8f>
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c38(%rbp)
jmp    2c24 <main+0x1ad4>
movl   $0x0,-0x9c44(%rbp)
cmpl   $0x100,-0x9c44(%rbp)
jge    2d89 <main+0x1c39>
movslq -0x9c44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x12fb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2d3a <main+0x1bea>
jp     2d3a <main+0x1bea>
jmp    2d70 <main+0x1c20>
mov    -0x9c44(%rbp),%esi
movslq -0x9c44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1323(%rip),%rdi
movsd  0x12b1(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2d75 <main+0x1c25>
mov    -0x9c44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c44(%rbp)
jmp    2cfd <main+0x1bad>
cmpl   $0x0,-0x9b14(%rbp)
je     2da9 <main+0x1c59>
lea    0x12ca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2db7 <main+0x1c67>
lea    0x12bf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c48(%rbp)
cmpl   $0x3e0,-0x9c48(%rbp)
jge    2df8 <main+0x1ca8>
movslq -0x9c48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    2dc1 <main+0x1c71>
movl   $0x0,-0x9c4c(%rbp)
cmpl   $0x3e0,-0x9c4c(%rbp)
jge    2e39 <main+0x1ce9>
movslq -0x9c4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c4c(%rbp)
jmp    2e02 <main+0x1cb2>
movl   $0x20,-0x9c2c(%rbp)
movl   $0x40,-0x9c30(%rbp)
mov    -0x9c30(%rbp),%eax
mov    %eax,-0x9c34(%rbp)
movl   $0x0,-0x9c50(%rbp)
cmpl   $0x1,-0x9c50(%rbp)
jge    2f74 <main+0x1e24>
movl   $0x0,-0x9c54(%rbp)
cmpl   $0x1fe,-0x9c54(%rbp)
jge    2f5b <main+0x1e0b>
mov    -0x9c54(%rbp),%eax
add    -0x9c34(%rbp),%eax
cmp    $0x1fe,%eax
jge    2eb8 <main+0x1d68>
mov    -0x9c54(%rbp),%eax
add    -0x9c34(%rbp),%eax
mov    %eax,-0x9cd8(%rbp)
jmp    2ec8 <main+0x1d78>
mov    $0x200,%eax
mov    %eax,-0x9cd8(%rbp)
jmp    2ec8 <main+0x1d78>
mov    -0x9cd8(%rbp),%eax
mov    %eax,-0x9c58(%rbp)
mov    -0x9c54(%rbp),%eax
mov    %eax,-0x9c5c(%rbp)
mov    -0x9c5c(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    2f3f <main+0x1def>
movslq -0x9c5c(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
movslq -0x9c5c(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c5c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    2ee0 <main+0x1d90>
jmp    2f44 <main+0x1df4>
mov    -0x9c34(%rbp),%eax
add    -0x9c54(%rbp),%eax
mov    %eax,-0x9c54(%rbp)
jmp    2e7a <main+0x1d2a>
jmp    2f60 <main+0x1e10>
mov    -0x9c50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c50(%rbp)
jmp    2e63 <main+0x1d13>
movl   $0x0,-0x9c60(%rbp)
cmpl   $0x100,-0x9c60(%rbp)
jge    300a <main+0x1eba>
movslq -0x9c60(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x107a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2fbb <main+0x1e6b>
jp     2fbb <main+0x1e6b>
jmp    2ff1 <main+0x1ea1>
mov    -0x9c60(%rbp),%esi
movslq -0x9c60(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x10a2(%rip),%rdi
movsd  0x1030(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2ff6 <main+0x1ea6>
mov    -0x9c60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c60(%rbp)
jmp    2f7e <main+0x1e2e>
cmpl   $0x0,-0x9b14(%rbp)
je     302a <main+0x1eda>
lea    0x1049(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    3038 <main+0x1ee8>
lea    0x103e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c68(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c70(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c78(%rbp)
movl   $0x0,-0x9c7c(%rbp)
cmpl   $0x3e0,-0x9c7c(%rbp)
jge    313c <main+0x1fec>
movl   $0x0,-0x9c80(%rbp)
cmpl   $0x3e0,-0x9c80(%rbp)
jge    3123 <main+0x1fd3>
mov    -0x9c68(%rbp),%rax
imul   $0x3e0,-0x9c7c(%rbp),%ecx
add    -0x9c80(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c7c(%rbp),%ecx
add    -0x9c80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xf3d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c78(%rbp),%rax
imul   $0x3e0,-0x9c7c(%rbp),%ecx
add    -0x9c80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xefe(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c80(%rbp)
jmp    308f <main+0x1f3f>
jmp    3128 <main+0x1fd8>
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    3075 <main+0x1f25>
movl   $0x0,-0x9c84(%rbp)
cmpl   $0x1,-0x9c84(%rbp)
jge    322f <main+0x20df>
movl   $0x0,-0x9c88(%rbp)
cmpl   $0x3e0,-0x9c88(%rbp)
jge    3216 <main+0x20c6>
movl   $0x0,-0x9c8c(%rbp)
cmpl   $0x3e0,-0x9c8c(%rbp)
jge    31fd <main+0x20ad>
mov    -0x9c70(%rbp),%rax
imul   $0x3e0,-0x9c88(%rbp),%ecx
add    -0x9c8c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c78(%rbp),%rax
imul   $0x3e0,-0x9c88(%rbp),%ecx
add    -0x9c8c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x9c68(%rbp),%rax
imul   $0x3e0,-0x9c88(%rbp),%ecx
add    -0x9c8c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    3177 <main+0x2027>
jmp    3202 <main+0x20b2>
mov    -0x9c88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c88(%rbp)
jmp    315d <main+0x200d>
jmp    321b <main+0x20cb>
mov    -0x9c84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c84(%rbp)
jmp    3146 <main+0x1ff6>
movl   $0x0,-0x9c90(%rbp)
cmpl   $0x3e0,-0x9c90(%rbp)
jge    331c <main+0x21cc>
movl   $0x0,-0x9c94(%rbp)
cmpl   $0x3e0,-0x9c94(%rbp)
jge    3303 <main+0x21b3>
mov    -0x9c68(%rbp),%rax
imul   $0x3e0,-0x9c90(%rbp),%ecx
add    -0x9c94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd8e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    329f <main+0x214f>
jp     329f <main+0x214f>
jmp    32ea <main+0x219a>
mov    -0x9c90(%rbp),%esi
mov    -0x9c94(%rbp),%edx
mov    -0x9c68(%rbp),%rax
imul   $0x3e0,-0x9c90(%rbp),%ecx
add    -0x9c94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xe1b(%rip),%rdi
movsd  0xd3f(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    32ef <main+0x219f>
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    3253 <main+0x2103>
jmp    3308 <main+0x21b8>
mov    -0x9c90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c90(%rbp)
jmp    3239 <main+0x20e9>
cmpl   $0x0,-0x9b14(%rbp)
je     333c <main+0x21ec>
lea    0xd37(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    334a <main+0x21fa>
lea    0xd2c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7c,-0x9c98(%rbp)
mov    -0x9c98(%rbp),%eax
imul   -0x9c98(%rbp),%eax
imul   -0x9c98(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9ca0(%rbp)
mov    -0x9c98(%rbp),%eax
imul   -0x9c98(%rbp),%eax
imul   -0x9c98(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9ca8(%rbp)
movl   $0x0,-0x9cac(%rbp)
mov    -0x9cac(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    34be <main+0x236e>
movl   $0x0,-0x9cb0(%rbp)
mov    -0x9cb0(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    34a5 <main+0x2355>
movl   $0x0,-0x9cb4(%rbp)
mov    -0x9cb4(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    348c <main+0x233c>
mov    -0x9ca0(%rbp),%rax
mov    -0x9cac(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9cb0(%rbp),%edx
imul   -0x9c98(%rbp),%edx
add    %edx,%ecx
add    -0x9cb4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xbd5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9ca8(%rbp),%rax
mov    -0x9cac(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9cb0(%rbp),%edx
imul   -0x9c98(%rbp),%edx
add    %edx,%ecx
add    -0x9cb4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xba5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9cb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb4(%rbp)
jmp    33e6 <main+0x2296>
jmp    3491 <main+0x2341>
mov    -0x9cb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb0(%rbp)
jmp    33ca <main+0x227a>
jmp    34aa <main+0x235a>
mov    -0x9cac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cac(%rbp)
jmp    33ae <main+0x225e>
movl   $0x0,-0x9cb8(%rbp)
cmpl   $0x1,-0x9cb8(%rbp)
jge    35fd <main+0x24ad>
movl   $0x0,-0x9cbc(%rbp)
mov    -0x9cbc(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    35e4 <main+0x2494>
movl   $0x0,-0x9cc0(%rbp)
mov    -0x9cc0(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    35cb <main+0x247b>
movl   $0x0,-0x9cc4(%rbp)
mov    -0x9cc4(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    35b2 <main+0x2462>
mov    -0x9ca8(%rbp),%rax
mov    -0x9cbc(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9cc0(%rbp),%edx
imul   -0x9c98(%rbp),%edx
add    %edx,%ecx
add    -0x9cc4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9ca0(%rbp),%rax
mov    -0x9cbc(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9cc0(%rbp),%edx
imul   -0x9c98(%rbp),%edx
add    %edx,%ecx
add    -0x9cc4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9cc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc4(%rbp)
jmp    3517 <main+0x23c7>
jmp    35b7 <main+0x2467>
mov    -0x9cc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc0(%rbp)
jmp    34fb <main+0x23ab>
jmp    35d0 <main+0x2480>
mov    -0x9cbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
jmp    34df <main+0x238f>
jmp    35e9 <main+0x2499>
mov    -0x9cb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb8(%rbp)
jmp    34c8 <main+0x2378>
movl   $0x0,-0x9cc8(%rbp)
mov    -0x9cc8(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    3755 <main+0x2605>
movl   $0x0,-0x9ccc(%rbp)
mov    -0x9ccc(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    373c <main+0x25ec>
movl   $0x0,-0x9cd0(%rbp)
mov    -0x9cd0(%rbp),%eax
cmp    -0x9c98(%rbp),%eax
jge    3723 <main+0x25d3>
mov    -0x9ca0(%rbp),%rax
mov    -0x9cc8(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9ccc(%rbp),%edx
imul   -0x9c98(%rbp),%edx
add    %edx,%ecx
add    -0x9cd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x97f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    36a6 <main+0x2556>
jp     36a6 <main+0x2556>
jmp    370a <main+0x25ba>
mov    -0x9cc8(%rbp),%esi
mov    -0x9ccc(%rbp),%edx
mov    -0x9ca0(%rbp),%rax
mov    -0x9cc8(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
imul   -0x9c98(%rbp),%ecx
mov    -0x9ccc(%rbp),%edi
imul   -0x9c98(%rbp),%edi
add    %edi,%ecx
add    -0x9cd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x9fb(%rip),%rdi
movsd  0x91f(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    370f <main+0x25bf>
mov    -0x9cd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd0(%rbp)
jmp    363f <main+0x24ef>
jmp    3728 <main+0x25d8>
mov    -0x9ccc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ccc(%rbp)
jmp    3623 <main+0x24d3>
jmp    3741 <main+0x25f1>
mov    -0x9cc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc8(%rbp)
jmp    3607 <main+0x24b7>
cmpl   $0x0,-0x9b14(%rbp)
je     3775 <main+0x2625>
lea    0x8fe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    3783 <main+0x2633>
lea    0x8f3(%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    $0x5d18,%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,0x1e20(%rsp,%rax,8)
movapd %xmm0,0x1e30(%rsp,%rax,8)
movapd %xmm0,0x1e40(%rsp,%rax,8)
movapd %xmm0,0x1e50(%rsp,%rax,8)
movapd %xmm0,0x1e60(%rsp,%rax,8)
movapd %xmm0,0x1e70(%rsp,%rax,8)
movapd %xmm0,0x1e80(%rsp,%rax,8)
movapd %xmm0,0x1e90(%rsp,%rax,8)
movapd %xmm0,0x1ea0(%rsp,%rax,8)
movapd %xmm0,0x1eb0(%rsp,%rax,8)
movapd %xmm0,0x1ec0(%rsp,%rax,8)
movapd %xmm0,0x1ed0(%rsp,%rax,8)
movapd %xmm0,0x1ee0(%rsp,%rax,8)
movapd %xmm0,0x1ef0(%rsp,%rax,8)
movapd %xmm0,0x1f00(%rsp,%rax,8)
movapd %xmm0,0x1f10(%rsp,%rax,8)
add    $0x20,%rax
cmp    $0x3fe,%rax
jne    11a0 <main+0x30>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%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  0x10(%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    1332 <main+0x1c2>
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>
jmp    134b <main+0x1db>
lea    0x1e04(%rip),%rcx
lea    0x1e07(%rip),%r14
xor    %edx,%edx
test   $0x1,%al
cmovne %rcx,%r14
cmovne %edx,%ebp
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     13d0 <main+0x260>
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)
add    $0x8,%rax
jmp    1370 <main+0x200>
xor    %ebx,%ebx
lea    0x1caf(%rip),%r15
lea    0x1d67(%rip),%r14
movsd  0x1c68(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%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    1433 <main+0x2c3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    13e0 <main+0x270>
jmp    1447 <main+0x2d7>
test   %ebp,%ebp
lea    0x1d01(%rip),%rax
lea    0x1d04(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     14ce <main+0x35e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1470 <main+0x300>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1b96(%rip),%r15
lea    0x1c4e(%rip),%r14
movsd  0x1b4f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%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    1550 <main+0x3e0>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    14f9 <main+0x389>
jmp    1564 <main+0x3f4>
test   %ebp,%ebp
lea    0x1be4(%rip),%rax
lea    0x1be7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1580 <main+0x410>
xor    %ebx,%ebx
lea    0x1a9e(%rip),%r15
lea    0x1b56(%rip),%r14
movsd  0x1a57(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    161d <main+0x4ad>
jp     161d <main+0x4ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1600 <main+0x490>
jmp    1650 <main+0x4e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1a26(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1a17(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1600 <main+0x490>
jmp    1664 <main+0x4f4>
test   %ebp,%ebp
lea    0x1ae4(%rip),%rax
lea    0x1ae7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1680 <main+0x510>
xor    %ebx,%ebx
lea    0x199e(%rip),%r15
lea    0x1a56(%rip),%r14
movsd  0x1957(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    171d <main+0x5ad>
jp     171d <main+0x5ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1700 <main+0x590>
jmp    1750 <main+0x5e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1926(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1917(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1700 <main+0x590>
jmp    1764 <main+0x5f4>
test   %ebp,%ebp
lea    0x19e4(%rip),%rax
lea    0x19e7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1780 <main+0x610>
xor    %ebx,%ebx
lea    0x189e(%rip),%r15
lea    0x1956(%rip),%r14
movsd  0x1857(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    181d <main+0x6ad>
jp     181d <main+0x6ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1800 <main+0x690>
jmp    1850 <main+0x6e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1826(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1817(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1800 <main+0x690>
jmp    1864 <main+0x6f4>
test   %ebp,%ebp
lea    0x18e4(%rip),%rax
lea    0x18e7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     18f0 <main+0x780>
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)
add    $0x8,%rax
jmp    1890 <main+0x720>
xor    %ebx,%ebx
lea    0x178f(%rip),%r15
lea    0x1847(%rip),%r14
movsd  0x1748(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1930 <main+0x7c0>
jp     1930 <main+0x7c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1910 <main+0x7a0>
jmp    1953 <main+0x7e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1900 <main+0x790>
jmp    1967 <main+0x7f7>
test   %ebp,%ebp
lea    0x17e1(%rip),%rax
lea    0x17e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     19f0 <main+0x880>
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)
add    $0x8,%rax
jmp    1990 <main+0x820>
xor    %ebx,%ebx
lea    0x168f(%rip),%r15
lea    0x1747(%rip),%r14
movsd  0x1648(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1a30 <main+0x8c0>
jp     1a30 <main+0x8c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1a10 <main+0x8a0>
jmp    1a53 <main+0x8e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1a00 <main+0x890>
jmp    1a67 <main+0x8f7>
test   %ebp,%ebp
lea    0x16e1(%rip),%rax
lea    0x16e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     1af0 <main+0x980>
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)
add    $0x8,%rax
jmp    1a90 <main+0x920>
xor    %ebx,%ebx
lea    0x158f(%rip),%r15
lea    0x1647(%rip),%r14
movsd  0x1548(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1b30 <main+0x9c0>
jp     1b30 <main+0x9c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1b10 <main+0x9a0>
jmp    1b53 <main+0x9e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1b00 <main+0x990>
jmp    1b67 <main+0x9f7>
test   %ebp,%ebp
lea    0x15e1(%rip),%rax
lea    0x15e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1bee <main+0xa7e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1b90 <main+0xa20>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1476(%rip),%r15
lea    0x152e(%rip),%r14
movsd  0x142f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1c50 <main+0xae0>
jp     1c50 <main+0xae0>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1c30 <main+0xac0>
jmp    1c70 <main+0xb00>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1c19 <main+0xaa9>
jmp    1c84 <main+0xb14>
test   %ebp,%ebp
lea    0x14c4(%rip),%rax
lea    0x14c7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1d0e <main+0xb9e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1cb0 <main+0xb40>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1356(%rip),%r15
lea    0x140e(%rip),%r14
movsd  0x130f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1d70 <main+0xc00>
jp     1d70 <main+0xc00>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1d50 <main+0xbe0>
jmp    1d90 <main+0xc20>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1d39 <main+0xbc9>
jmp    1da4 <main+0xc34>
test   %ebp,%ebp
lea    0x13a4(%rip),%rax
lea    0x13a7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1e2e <main+0xcbe>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1dd0 <main+0xc60>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1236(%rip),%r15
lea    0x12ee(%rip),%r14
movsd  0x11ef(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1e90 <main+0xd20>
jp     1e90 <main+0xd20>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1e70 <main+0xd00>
jmp    1eb0 <main+0xd40>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1e59 <main+0xce9>
jmp    1ec4 <main+0xd54>
test   %ebp,%ebp
lea    0x1284(%rip),%rax
lea    0x1287(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
movapd 0x1112(%rip),%xmm2
movapd 0x111a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
movapd -0x20(%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movapd -0x10(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
movapd 0x3de0(%rsp,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movapd 0x3df0(%rsp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,0x3de0(%rsp,%rax,8)
movapd %xmm1,0x3df0(%rsp,%rax,8)
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)
add    $0x8,%rax
cmp    $0x3e6,%rax
jne    1f10 <main+0xda0>
xor    %ebx,%ebx
movsd  0x1098(%rip),%xmm2
lea    0x10e0(%rip),%r15
lea    0x10fb(%rip),%r12
lea    0x1172(%rip),%r14
jmp    1fed <main+0xe7d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     2059 <main+0xee9>
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm2,%xmm1
jne    1ffb <main+0xe8b>
jnp    2018 <main+0xea8>
mov    %r15,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1045(%rip),%xmm2
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
movsd  0x1037(%rip),%xmm0
ucomisd %xmm0,%xmm1
jne    2031 <main+0xec1>
jnp    1fe0 <main+0xe70>
mov    %r12,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1013(%rip),%xmm2
add    $0x1,%rbx
mov    $0x1,%ebp
cmp    $0x3e0,%rbx
jne    1fed <main+0xe7d>
jmp    206d <main+0xefd>
test   %ebp,%ebp
lea    0x10db(%rip),%rax
lea    0x10de(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movapd 0xf8c(%rip),%xmm0
movapd 0xf94(%rip),%xmm1
nopl   0x0(%rax)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x10(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x10(%rsp,%rbx,8)
movsd  0x3e10(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e10(%rsp,%rbx,8)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x18(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x18(%rsp,%rbx,8)
movsd  0x3e18(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e18(%rsp,%rbx,8)
add    $0x2,%rbx
cmp    $0x80,%rbx
jne    20b0 <main+0xf40>
xor    %ebx,%ebx
movsd  0xf55(%rip),%xmm0
lea    0xf7d(%rip),%r14
lea    0xf98(%rip),%r15
movsd  0xf2f(%rip),%xmm2
jmp    216d <main+0xffd>
nopl   0x0(%rax,%rax,1)
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xf19(%rip),%xmm2
movsd  0xf21(%rip),%xmm0
mov    $0x1,%ebp
add    $0x1,%rbx
cmp    $0x80,%rbx
je     2228 <main+0x10b8>
movsd  0x10(%rsp,%rbx,8),%xmm1
test   $0x1,%bl
jne    21d0 <main+0x1060>
ucomisd %xmm0,%xmm1
jne    2180 <main+0x1010>
jnp    21a9 <main+0x1039>
mov    %r14,%rdi
mov    %ebx,%esi
movsd  0xeeb(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xecc(%rip),%xmm2
movsd  0xed4(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
ucomisd 0xec6(%rip),%xmm1
jne    21be <main+0x104e>
jnp    215c <main+0xfec>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xeb5(%rip),%xmm0
jmp    2140 <main+0xfd0>
ucomisd %xmm2,%xmm1
jne    21d8 <main+0x1068>
jnp    21fd <main+0x108d>
mov    %r14,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xe78(%rip),%xmm2
movsd  0xe80(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
ucomisd 0xe62(%rip),%xmm1
jne    2216 <main+0x10a6>
jnp    215c <main+0xfec>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xe4d(%rip),%xmm0
jmp    2140 <main+0xfd0>
test   %ebp,%ebp
lea    0xf0c(%rip),%r13
lea    0xf0f(%rip),%r14
mov    %r14,%rdi
cmove  %r13,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
test   %eax,%eax
jle    228d <main+0x111d>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <omp_get_team_num@plt>
mov    %eax,%r15d
add    $0x1,%ebx
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
cmp    %eax,%ebx
jl     2260 <main+0x10f0>
cmp    $0x9,%r15d
jne    2293 <main+0x1123>
test   %ebp,%ebp
lea    0xec0(%rip),%r14
cmove  %r13,%r14
jmp    22ae <main+0x113e>
mov    $0xffffffff,%r15d
lea    0xe51(%rip),%rdi
mov    %r15d,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%ebp
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nopl   (%rax)
movapd 0x3e10(%rsp,%rbx,8),%xmm0
addpd  0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x3e20(%rsp,%rbx,8),%xmm1
addpd  0x10(%rsp,%rbx,8),%xmm0
movapd %xmm0,0x10(%rsp,%rbx,8)
addpd  0x1f20(%rsp,%rbx,8),%xmm1
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm1,0x20(%rsp,%rbx,8)
add    $0x4,%rbx
cmp    $0x40,%rbx
jne    22e0 <main+0x1170>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2330 <main+0x11c0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2390 <main+0x1220>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    23f0 <main+0x1280>
xor    %ebx,%ebx
lea    0xc5c(%rip),%r15
lea    0xcf5(%rip),%r14
movsd  0xbf6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2480 <main+0x1310>
jp     2480 <main+0x1310>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    2460 <main+0x12f0>
jmp    24ab <main+0x133b>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xbeb(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    2452 <main+0x12e2>
jmp    24b8 <main+0x1348>
test   %ebp,%ebp
lea    0xc93(%rip),%r14
cmove  %r13,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nopw   0x0(%rax,%rax,1)
movapd 0x3e10(%rsp,%rbx,8),%xmm0
addpd  0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x3e20(%rsp,%rbx,8),%xmm1
addpd  0x10(%rsp,%rbx,8),%xmm0
movapd %xmm0,0x10(%rsp,%rbx,8)
addpd  0x1f20(%rsp,%rbx,8),%xmm1
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm1,0x20(%rsp,%rbx,8)
add    $0x4,%rbx
cmp    $0x40,%rbx
jne    24f0 <main+0x1380>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2540 <main+0x13d0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    25a0 <main+0x1430>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2600 <main+0x1490>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4610(%rsp,%rax,8),%xmm0
addpd  0x2710(%rsp,%rax,8),%xmm0
movapd 0x4620(%rsp,%rax,8),%xmm1
addpd  0x810(%rsp,%rax,8),%xmm0
movapd %xmm0,0x810(%rsp,%rax,8)
addpd  0x2720(%rsp,%rax,8),%xmm1
addpd  0x820(%rsp,%rax,8),%xmm1
movapd %xmm1,0x820(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2660 <main+0x14f0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4810(%rsp,%rax,8),%xmm0
addpd  0x2910(%rsp,%rax,8),%xmm0
movapd 0x4820(%rsp,%rax,8),%xmm1
addpd  0xa10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xa10(%rsp,%rax,8)
addpd  0x2920(%rsp,%rax,8),%xmm1
addpd  0xa20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xa20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    26c0 <main+0x1550>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4a10(%rsp,%rax,8),%xmm0
addpd  0x2b10(%rsp,%rax,8),%xmm0
movapd 0x4a20(%rsp,%rax,8),%xmm1
addpd  0xc10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xc10(%rsp,%rax,8)
addpd  0x2b20(%rsp,%rax,8),%xmm1
addpd  0xc20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xc20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2720 <main+0x15b0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4c10(%rsp,%rax,8),%xmm0
addpd  0x2d10(%rsp,%rax,8),%xmm0
movapd 0x4c20(%rsp,%rax,8),%xmm1
addpd  0xe10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xe10(%rsp,%rax,8)
addpd  0x2d20(%rsp,%rax,8),%xmm1
addpd  0xe20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xe20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2780 <main+0x1610>
xor    %ebx,%ebx
lea    0x8cc(%rip),%r15
lea    0x965(%rip),%r14
movsd  0x866(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2810 <main+0x16a0>
jp     2810 <main+0x16a0>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    27f0 <main+0x1680>
jmp    283b <main+0x16cb>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x85b(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    27e2 <main+0x1672>
jmp    2848 <main+0x16d8>
test   %ebp,%ebp
lea    0x903(%rip),%r14
cmove  %r13,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
xor    %r12d,%r12d
mov    $0x782000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,%rax
add    $0x70,%rax
mov    %r15,%rcx
add    $0x70,%rcx
movapd 0x761(%rip),%xmm0
movapd 0x769(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rcx,%rdx,8)
movupd %xmm0,-0x60(%rcx,%rdx,8)
movupd %xmm1,-0x70(%rax,%rdx,8)
movupd %xmm1,-0x60(%rax,%rdx,8)
movupd %xmm0,-0x50(%rcx,%rdx,8)
movupd %xmm0,-0x40(%rcx,%rdx,8)
movupd %xmm1,-0x50(%rax,%rdx,8)
movupd %xmm1,-0x40(%rax,%rdx,8)
movupd %xmm0,-0x30(%rcx,%rdx,8)
movupd %xmm0,-0x20(%rcx,%rdx,8)
movupd %xmm1,-0x30(%rax,%rdx,8)
movupd %xmm1,-0x20(%rax,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,-0x10(%rax,%rdx,8)
movupd %xmm1,(%rax,%rdx,8)
add    $0x10,%rdx
cmp    $0x3e0,%rdx
jne    28c0 <main+0x1750>
add    $0x1,%r12
add    $0x1f00,%rax
add    $0x1f00,%rcx
cmp    $0x3e0,%r12
jne    28b0 <main+0x1740>
xor    %eax,%eax
mov    %r14,%rcx
xchg   %ax,%ax
mov    $0x2,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%r15,%rdx,8),%xmm0
movupd (%r15,%rdx,8),%xmm1
movupd -0x10(%rbx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd (%rbx,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rcx,%rdx,8),%xmm1
addpd  %xmm2,%xmm1
movupd (%rcx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm2,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x3e2,%rdx
jne    2960 <main+0x17f0>
add    $0x1,%rax
add    $0x1f00,%rcx
add    $0x1f00,%rbx
add    $0x1f00,%r15
cmp    $0x3e0,%rax
jne    2950 <main+0x17e0>
xor    %r12d,%r12d
lea    0x743(%rip),%r15
movsd  0x682(%rip),%xmm0
jmp    29f4 <main+0x1884>
add    $0x1,%r12
add    $0x1f00,%r14
cmp    $0x3e0,%r12
je     2a41 <main+0x18d1>
xor    %ebx,%ebx
jmp    2a0d <main+0x189d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     29e0 <main+0x1870>
movsd  (%r14,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2a1b <main+0x18ab>
jnp    2a00 <main+0x1890>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
movsd  0x635(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x626(%rip),%xmm0
mov    $0x1,%ebp
jmp    2a00 <main+0x1890>
test   %ebp,%ebp
lea    0x6fd(%rip),%rdi
cmove  %r13,%rdi
call   1030 <puts@plt>
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
lea    0x10(%rax),%r8
lea    0x10(%r15),%r9
xor    %esi,%esi
movapd 0x594(%rip),%xmm0
movapd 0x59c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9,%rdi
mov    %r8,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x10(%rdi,%rdx,8)
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rdi,%rdx,8)
movupd %xmm1,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x7c,%rdx
jne    2ab0 <main+0x1940>
add    $0x1,%rbx
add    $0x3e0,%rcx
add    $0x3e0,%rdi
cmp    $0x7c,%rbx
jne    2aa0 <main+0x1930>
add    $0x1,%rsi
add    $0x1e080,%r8
add    $0x1e080,%r9
cmp    $0x7c,%rsi
jne    2a90 <main+0x1920>
mov    %r15,%r8
add    $0x10,%r8
add    $0x10,%rax
xor    %edx,%edx
nopl   (%rax)
mov    %rax,%rsi
mov    %r8,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rsi,%rcx,8),%xmm0
movupd -0x10(%rdi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%rdi,%rcx,8),%xmm0
movupd %xmm1,-0x10(%rdi,%rcx,8)
movupd (%rsi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    $0x7c,%rcx
jne    2b30 <main+0x19c0>
add    $0x1,%rbx
add    $0x3e0,%rdi
add    $0x3e0,%rsi
cmp    $0x7c,%rbx
jne    2b20 <main+0x19b0>
add    $0x1,%rdx
add    $0x1e080,%r8
add    $0x1e080,%rax
cmp    $0x7c,%rdx
jne    2b10 <main+0x19a0>
xor    %r13d,%r13d
lea    0x579(%rip),%r12
jmp    2bc6 <main+0x1a56>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x8(%rsp),%r15
add    $0x1e080,%r15
cmp    $0x7c,%r13
je     2c2a <main+0x1aba>
mov    %r15,0x8(%rsp)
xor    %ebx,%ebx
jmp    2be1 <main+0x1a71>
nop
add    $0x1,%rbx
add    $0x3e0,%r15
cmp    $0x7c,%rbx
je     2bb0 <main+0x1a40>
xor    %r14d,%r14d
jmp    2bfa <main+0x1a8a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    $0x7c,%r14
je     2bd0 <main+0x1a60>
movsd  (%r15,%r14,8),%xmm1
ucomisd 0x470(%rip),%xmm1
jne    2c0c <main+0x1a9c>
jnp    2bf0 <main+0x1a80>
mov    %r12,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
movsd  0x444(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
mov    $0x1,%ebp
jmp    2bf0 <main+0x1a80>
test   %ebp,%ebp
lea    0x50a(%rip),%rax
lea    0x50d(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x5d18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [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"
@.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 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
store i32 -1, i32* %71
store i32 0, i32* %72
br label %1127
1127: ; preds = %1133, %1126
%1128 = load i32, i32* %72
%1129 = call i32 (...) @omp_get_num_teams()
%1130 = icmp slt i32 %1128, %1129
br i1 %1130, label %1131, label %1136
1131: ; preds = %1127
%1132 = call i32 (...) @omp_get_team_num()
store i32 %1132, i32* %71
br label %1133
1133: ; preds = %1131
%1134 = load i32, i32* %72
%1135 = add nsw i32 %1134, 1
store i32 %1135, i32* %72
br label %1127
1136: ; preds = %1127
%1137 = load i32, i32* %71
%1138 = icmp ne i32 %1137, 9
br i1 %1138, label %1139, label %1142
1139: ; preds = %1136
%1140 = load i32, i32* %71
%1141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.5, i64 0, i64 0), i32 %1140, i32 9)
store i32 1, i32* %7
br label %1142
1142: ; preds = %1139, %1136
%1143 = load i32, i32* %7
%1144 = icmp ne i32 %1143, 0
br i1 %1144, label %1145, label %1147
1145: ; preds = %1142
%1146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1149
1147: ; preds = %1142
%1148 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1149
1149: ; preds = %1147, %1145
store i32 0, i32* %73
br label %1150
1150: ; preds = %1157, %1149
%1151 = load i32, i32* %73
%1152 = icmp slt i32 %1151, 992
br i1 %1152, label %1153, label %1160
1153: ; preds = %1150
%1154 = load i32, i32* %73
%1155 = sext i32 %1154 to i64
%1156 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1155
store double 0.000000e+00, double* %1156
br label %1157
1157: ; preds = %1153
%1158 = load i32, i32* %73
%1159 = add nsw i32 %1158, 1
store i32 %1159, i32* %73
br label %1150
1160: ; preds = %1150
store i32 0, i32* %74
br label %1161
1161: ; preds = %1168, %1160
%1162 = load i32, i32* %74
%1163 = icmp slt i32 %1162, 992
br i1 %1163, label %1164, label %1171
1164: ; preds = %1161
%1165 = load i32, i32* %74
%1166 = sext i32 %1165 to i64
%1167 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1166
store double 0.000000e+00, double* %1167
br label %1168
1168: ; preds = %1164
%1169 = load i32, i32* %74
%1170 = add nsw i32 %1169, 1
store i32 %1170, i32* %74
br label %1161
1171: ; preds = %1161
store i32 32, i32* %75
store i32 64, i32* %76
%1172 = load i32, i32* %76
store i32 %1172, i32* %77
store i32 0, i32* %78
br label %1173
1173: ; preds = %1212, %1171
%1174 = load i32, i32* %78
%1175 = icmp slt i32 %1174, 1
br i1 %1175, label %1176, label %1215
1176: ; preds = %1173
store i32 0, i32* %79
br label %1177
1177: ; preds = %1207, %1176
%1178 = load i32, i32* %79
%1179 = icmp slt i32 %1178, 256
br i1 %1179, label %1180, label %1211
1180: ; preds = %1177
%1181 = load i32, i32* %79
store i32 %1181, i32* %80
br label %1182
1182: ; preds = %1203, %1180
%1183 = load i32, i32* %80
%1184 = load i32, i32* %79
%1185 = load i32, i32* %77
%1186 = add nsw i32 %1184, %1185
%1187 = icmp slt i32 %1183, %1186
br i1 %1187, label %1188, label %1206
1188: ; preds = %1182
%1189 = load i32, i32* %80
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1190
%1192 = load double, double* %1191
%1193 = load i32, i32* %80
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %1194
%1196 = load double, double* %1195
%1197 = fadd double %1192, %1196
%1198 = load i32, i32* %80
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1199
%1201 = load double, double* %1200
%1202 = fadd double %1201, %1197
store double %1202, double* %1200
br label %1203
1203: ; preds = %1188
%1204 = load i32, i32* %80
%1205 = add nsw i32 %1204, 1
store i32 %1205, i32* %80
br label %1182
1206: ; preds = %1182
br label %1207
1207: ; preds = %1206
%1208 = load i32, i32* %77
%1209 = load i32, i32* %79
%1210 = add nsw i32 %1209, %1208
store i32 %1210, i32* %79
br label %1177
1211: ; preds = %1177
br label %1212
1212: ; preds = %1211
%1213 = load i32, i32* %78
%1214 = add nsw i32 %1213, 1
store i32 %1214, i32* %78
br label %1173
1215: ; preds = %1173
store i32 0, i32* %81
br label %1216
1216: ; preds = %1233, %1215
%1217 = load i32, i32* %81
%1218 = icmp slt i32 %1217, 256
br i1 %1218, label %1219, label %1236
1219: ; preds = %1216
%1220 = load i32, i32* %81
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1221
%1223 = load double, double* %1222
%1224 = fcmp une double %1223, 1.000000e+00
br i1 %1224, label %1225, label %1232
1225: ; preds = %1219
%1226 = load i32, i32* %81
%1227 = load i32, i32* %81
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1228
%1230 = load double, double* %1229
%1231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i32 %1226, double 5.000000e+00, double %1230)
store i32 1, i32* %7
br label %1232
1232: ; preds = %1225, %1219
br label %1233
1233: ; preds = %1232
%1234 = load i32, i32* %81
%1235 = add nsw i32 %1234, 1
store i32 %1235, i32* %81
br label %1216
1236: ; preds = %1216
%1237 = load i32, i32* %7
%1238 = icmp ne i32 %1237, 0
br i1 %1238, label %1239, label %1241
1239: ; preds = %1236
%1240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1243
1241: ; preds = %1236
%1242 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1243
1243: ; preds = %1241, %1239
store i32 0, i32* %82
br label %1244
1244: ; preds = %1251, %1243
%1245 = load i32, i32* %82
%1246 = icmp slt i32 %1245, 992
br i1 %1246, label %1247, label %1254
1247: ; preds = %1244
%1248 = load i32, i32* %82
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1249
store double 0.000000e+00, double* %1250
br label %1251
1251: ; preds = %1247
%1252 = load i32, i32* %82
%1253 = add nsw i32 %1252, 1
store i32 %1253, i32* %82
br label %1244
1254: ; preds = %1244
store i32 0, i32* %83
br label %1255
1255: ; preds = %1262, %1254
%1256 = load i32, i32* %83
%1257 = icmp slt i32 %1256, 992
br i1 %1257, label %1258, label %1265
1258: ; preds = %1255
%1259 = load i32, i32* %83
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1260
store double 0.000000e+00, double* %1261
br label %1262
1262: ; preds = %1258
%1263 = load i32, i32* %83
%1264 = add nsw i32 %1263, 1
store i32 %1264, i32* %83
br label %1255
1265: ; preds = %1255
store i32 32, i32* %75
store i32 64, i32* %76
%1266 = load i32, i32* %76
store i32 %1266, i32* %77
store i32 0, i32* %84
br label %1267
1267: ; preds = %1315, %1265
%1268 = load i32, i32* %84
%1269 = icmp slt i32 %1268, 1
br i1 %1269, label %1270, label %1318
1270: ; preds = %1267
store i32 0, i32* %85
br label %1271
1271: ; preds = %1310, %1270
%1272 = load i32, i32* %85
%1273 = icmp slt i32 %1272, 510
br i1 %1273, label %1274, label %1314
1274: ; preds = %1271
%1275 = load i32, i32* %85
%1276 = load i32, i32* %77
%1277 = add nsw i32 %1275, %1276
%1278 = icmp slt i32 %1277, 510
br i1 %1278, label %1279, label %1283
1279: ; preds = %1274
%1280 = load i32, i32* %85
%1281 = load i32, i32* %77
%1282 = add nsw i32 %1280, %1281
br label %1284
1283: ; preds = %1274
br label %1284
1284: ; preds = %1283, %1279
%1285 = phi i32 [ %1282, %1279 ], [ 512, %1283 ]
store i32 %1285, i32* %86
%1286 = load i32, i32* %85
store i32 %1286, i32* %87
br label %1287
1287: ; preds = %1306, %1284
%1288 = load i32, i32* %87
%1289 = load i32, i32* %86
%1290 = icmp slt i32 %1288, %1289
br i1 %1290, label %1291, label %1309
1291: ; preds = %1287
%1292 = load i32, i32* %87
%1293 = sext i32 %1292 to i64
%1294 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1293
%1295 = load double, double* %1294
%1296 = load i32, i32* %87
%1297 = sext i32 %1296 to i64
%1298 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %1297
%1299 = load double, double* %1298
%1300 = fadd double %1295, %1299
%1301 = load i32, i32* %87
%1302 = sext i32 %1301 to i64
%1303 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1302
%1304 = load double, double* %1303
%1305 = fadd double %1304, %1300
store double %1305, double* %1303
br label %1306
1306: ; preds = %1291
%1307 = load i32, i32* %87
%1308 = add nsw i32 %1307, 1
store i32 %1308, i32* %87
br label %1287
1309: ; preds = %1287
br label %1310
1310: ; preds = %1309
%1311 = load i32, i32* %77
%1312 = load i32, i32* %85
%1313 = add nsw i32 %1312, %1311
store i32 %1313, i32* %85
br label %1271
1314: ; preds = %1271
br label %1315
1315: ; preds = %1314
%1316 = load i32, i32* %84
%1317 = add nsw i32 %1316, 1
store i32 %1317, i32* %84
br label %1267
1318: ; preds = %1267
store i32 0, i32* %88
br label %1319
1319: ; preds = %1336, %1318
%1320 = load i32, i32* %88
%1321 = icmp slt i32 %1320, 256
br i1 %1321, label %1322, label %1339
1322: ; preds = %1319
%1323 = load i32, i32* %88
%1324 = sext i32 %1323 to i64
%1325 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1324
%1326 = load double, double* %1325
%1327 = fcmp une double %1326, 1.000000e+00
br i1 %1327, label %1328, label %1335
1328: ; preds = %1322
%1329 = load i32, i32* %88
%1330 = load i32, i32* %88
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1331
%1333 = load double, double* %1332
%1334 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i32 %1329, double 5.000000e+00, double %1333)
store i32 1, i32* %7
br label %1335
1335: ; preds = %1328, %1322
br label %1336
1336: ; preds = %1335
%1337 = load i32, i32* %88
%1338 = add nsw i32 %1337, 1
store i32 %1338, i32* %88
br label %1319
1339: ; preds = %1319
%1340 = load i32, i32* %7
%1341 = icmp ne i32 %1340, 0
br i1 %1341, label %1342, label %1344
1342: ; preds = %1339
%1343 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1346
1344: ; preds = %1339
%1345 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1346
1346: ; preds = %1344, %1342
%1347 = call double* @malloc(i32 7872512)
store double* %1347, double** %89
%1348 = call double* @malloc(i32 7872512)
store double* %1348, double** %90
%1349 = call double* @malloc(i32 7872512)
store double* %1349, double** %91
store i32 0, i32* %92
br label %1350
1350: ; preds = %1383, %1346
%1351 = load i32, i32* %92
%1352 = icmp slt i32 %1351, 992
br i1 %1352, label %1353, label %1386
1353: ; preds = %1350
store i32 0, i32* %93
br label %1354
1354: ; preds = %1379, %1353
%1355 = load i32, i32* %93
%1356 = icmp slt i32 %1355, 992
br i1 %1356, label %1357, label %1382
1357: ; preds = %1354
%1358 = load double*, double** %89
%1359 = load i32, i32* %92
%1360 = mul nsw i32 %1359, 992
%1361 = load i32, i32* %93
%1362 = add nsw i32 %1360, %1361
%1363 = sext i32 %1362 to i64
%1364 = getelementptr inbounds double, double* %1358, i64 %1363
store double 0.000000e+00, double* %1364
%1365 = load double*, double** %90
%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 1.000000e+00, double* %1371
%1372 = load double*, double** %91
%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 2.000000e+00, double* %1378
br label %1379
1379: ; preds = %1357
%1380 = load i32, i32* %93
%1381 = add nsw i32 %1380, 1
store i32 %1381, i32* %93
br label %1354
1382: ; preds = %1354
br label %1383
1383: ; preds = %1382
%1384 = load i32, i32* %92
%1385 = add nsw i32 %1384, 1
store i32 %1385, i32* %92
br label %1350
1386: ; preds = %1350
store i32 0, i32* %94
br label %1387
1387: ; preds = %1433, %1386
%1388 = load i32, i32* %94
%1389 = icmp slt i32 %1388, 1
br i1 %1389, label %1390, label %1436
1390: ; preds = %1387
store i32 0, i32* %95
br label %1391
1391: ; preds = %1429, %1390
%1392 = load i32, i32* %95
%1393 = icmp slt i32 %1392, 992
br i1 %1393, label %1394, label %1432
1394: ; preds = %1391
store i32 0, i32* %96
br label %1395
1395: ; preds = %1425, %1394
%1396 = load i32, i32* %96
%1397 = icmp slt i32 %1396, 992
br i1 %1397, label %1398, label %1428
1398: ; preds = %1395
%1399 = load double*, double** %90
%1400 = load i32, i32* %95
%1401 = mul nsw i32 %1400, 992
%1402 = load i32, i32* %96
%1403 = add nsw i32 %1401, %1402
%1404 = sext i32 %1403 to i64
%1405 = getelementptr inbounds double, double* %1399, i64 %1404
%1406 = load double, double* %1405
%1407 = load double*, double** %91
%1408 = load i32, i32* %95
%1409 = mul nsw i32 %1408, 992
%1410 = load i32, i32* %96
%1411 = add nsw i32 %1409, %1410
%1412 = sext i32 %1411 to i64
%1413 = getelementptr inbounds double, double* %1407, i64 %1412
%1414 = load double, double* %1413
%1415 = fadd double %1406, %1414
%1416 = load double*, double** %89
%1417 = load i32, i32* %95
%1418 = mul nsw i32 %1417, 992
%1419 = load i32, i32* %96
%1420 = add nsw i32 %1418, %1419
%1421 = sext i32 %1420 to i64
%1422 = getelementptr inbounds double, double* %1416, i64 %1421
%1423 = load double, double* %1422
%1424 = fadd double %1423, %1415
store double %1424, double* %1422
br label %1425
1425: ; preds = %1398
%1426 = load i32, i32* %96
%1427 = add nsw i32 %1426, 1
store i32 %1427, i32* %96
br label %1395
1428: ; preds = %1395
br label %1429
1429: ; preds = %1428
%1430 = load i32, i32* %95
%1431 = add nsw i32 %1430, 1
store i32 %1431, i32* %95
br label %1391
1432: ; preds = %1391
br label %1433
1433: ; preds = %1432
%1434 = load i32, i32* %94
%1435 = add nsw i32 %1434, 1
store i32 %1435, i32* %94
br label %1387
1436: ; preds = %1387
store i32 0, i32* %97
br label %1437
1437: ; preds = %1471, %1436
%1438 = load i32, i32* %97
%1439 = icmp slt i32 %1438, 992
br i1 %1439, label %1440, label %1474
1440: ; preds = %1437
store i32 0, i32* %98
br label %1441
1441: ; preds = %1467, %1440
%1442 = load i32, i32* %98
%1443 = icmp slt i32 %1442, 992
br i1 %1443, label %1444, label %1470
1444: ; preds = %1441
%1445 = load double*, double** %89
%1446 = load i32, i32* %97
%1447 = mul nsw i32 %1446, 992
%1448 = load i32, i32* %98
%1449 = add nsw i32 %1447, %1448
%1450 = sext i32 %1449 to i64
%1451 = getelementptr inbounds double, double* %1445, i64 %1450
%1452 = load double, double* %1451
%1453 = fcmp une double %1452, 3.000000e+00
br i1 %1453, label %1454, label %1466
1454: ; preds = %1444
%1455 = load i32, i32* %97
%1456 = load i32, i32* %98
%1457 = load double*, double** %89
%1458 = load i32, i32* %97
%1459 = mul nsw i32 %1458, 992
%1460 = load i32, i32* %98
%1461 = add nsw i32 %1459, %1460
%1462 = sext i32 %1461 to i64
%1463 = getelementptr inbounds double, double* %1457, i64 %1462
%1464 = load double, double* %1463
%1465 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1455, i32 %1456, double 3.000000e+00, double %1464)
store i32 1, i32* %7
br label %1466
1466: ; preds = %1454, %1444
br label %1467
1467: ; preds = %1466
%1468 = load i32, i32* %98
%1469 = add nsw i32 %1468, 1
store i32 %1469, i32* %98
br label %1441
1470: ; preds = %1441
br label %1471
1471: ; preds = %1470
%1472 = load i32, i32* %97
%1473 = add nsw i32 %1472, 1
store i32 %1473, i32* %97
br label %1437
1474: ; preds = %1437
%1475 = load i32, i32* %7
%1476 = icmp ne i32 %1475, 0
br i1 %1476, label %1477, label %1479
1477: ; preds = %1474
%1478 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1481
1479: ; preds = %1474
%1480 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1481
1481: ; preds = %1479, %1477
store i32 124, i32* %99
%1482 = load i32, i32* %99
%1483 = load i32, i32* %99
%1484 = mul nsw i32 %1482, %1483
%1485 = load i32, i32* %99
%1486 = mul nsw i32 %1484, %1485
%1487 = sext i32 %1486 to i64
%1488 = mul i64 %1487, 8
%1489 = trunc i64 %1488 to i32
%1490 = call double* @malloc(i32 %1489)
store double* %1490, double** %100
%1491 = load i32, i32* %99
%1492 = load i32, i32* %99
%1493 = mul nsw i32 %1491, %1492
%1494 = load i32, i32* %99
%1495 = mul nsw i32 %1493, %1494
%1496 = sext i32 %1495 to i64
%1497 = mul i64 %1496, 8
%1498 = trunc i64 %1497 to i32
%1499 = call double* @malloc(i32 %1498)
store double* %1499, double** %101
store i32 0, i32* %102
br label %1500
1500: ; preds = %1551, %1481
%1501 = load i32, i32* %102
%1502 = load i32, i32* %99
%1503 = icmp slt i32 %1501, %1502
br i1 %1503, label %1504, label %1554
1504: ; preds = %1500
store i32 0, i32* %103
br label %1505
1505: ; preds = %1547, %1504
%1506 = load i32, i32* %103
%1507 = load i32, i32* %99
%1508 = icmp slt i32 %1506, %1507
br i1 %1508, label %1509, label %1550
1509: ; preds = %1505
store i32 0, i32* %104
br label %1510
1510: ; preds = %1543, %1509
%1511 = load i32, i32* %104
%1512 = load i32, i32* %99
%1513 = icmp slt i32 %1511, %1512
br i1 %1513, label %1514, label %1546
1514: ; preds = %1510
%1515 = load double*, double** %100
%1516 = load i32, i32* %102
%1517 = load i32, i32* %99
%1518 = mul nsw i32 %1516, %1517
%1519 = load i32, i32* %99
%1520 = mul nsw i32 %1518, %1519
%1521 = load i32, i32* %103
%1522 = load i32, i32* %99
%1523 = mul nsw i32 %1521, %1522
%1524 = add nsw i32 %1520, %1523
%1525 = load i32, i32* %104
%1526 = add nsw i32 %1524, %1525
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds double, double* %1515, i64 %1527
store double 2.000000e+00, double* %1528
%1529 = load double*, double** %101
%1530 = load i32, i32* %102
%1531 = load i32, i32* %99
%1532 = mul nsw i32 %1530, %1531
%1533 = load i32, i32* %99
%1534 = mul nsw i32 %1532, %1533
%1535 = load i32, i32* %103
%1536 = load i32, i32* %99
%1537 = mul nsw i32 %1535, %1536
%1538 = add nsw i32 %1534, %1537
%1539 = load i32, i32* %104
%1540 = add nsw i32 %1538, %1539
%1541 = sext i32 %1540 to i64
%1542 = getelementptr inbounds double, double* %1529, i64 %1541
store double 3.000000e+00, double* %1542
br label %1543
1543: ; preds = %1514
%1544 = load i32, i32* %104
%1545 = add nsw i32 %1544, 1
store i32 %1545, i32* %104
br label %1510
1546: ; preds = %1510
br label %1547
1547: ; preds = %1546
%1548 = load i32, i32* %103
%1549 = add nsw i32 %1548, 1
store i32 %1549, i32* %103
br label %1505
1550: ; preds = %1505
br label %1551
1551: ; preds = %1550
%1552 = load i32, i32* %102
%1553 = add nsw i32 %1552, 1
store i32 %1553, i32* %102
br label %1500
1554: ; preds = %1500
store i32 0, i32* %105
br label %1555
1555: ; preds = %1617, %1554
%1556 = load i32, i32* %105
%1557 = icmp slt i32 %1556, 1
br i1 %1557, label %1558, label %1620
1558: ; preds = %1555
store i32 0, i32* %106
br label %1559
1559: ; preds = %1613, %1558
%1560 = load i32, i32* %106
%1561 = load i32, i32* %99
%1562 = icmp slt i32 %1560, %1561
br i1 %1562, label %1563, label %1616
1563: ; preds = %1559
store i32 0, i32* %107
br label %1564
1564: ; preds = %1609, %1563
%1565 = load i32, i32* %107
%1566 = load i32, i32* %99
%1567 = icmp slt i32 %1565, %1566
br i1 %1567, label %1568, label %1612
1568: ; preds = %1564
store i32 0, i32* %108
br label %1569
1569: ; preds = %1605, %1568
%1570 = load i32, i32* %108
%1571 = load i32, i32* %99
%1572 = icmp slt i32 %1570, %1571
br i1 %1572, label %1573, label %1608
1573: ; preds = %1569
%1574 = load double*, double** %101
%1575 = load i32, i32* %106
%1576 = load i32, i32* %99
%1577 = mul nsw i32 %1575, %1576
%1578 = load i32, i32* %99
%1579 = mul nsw i32 %1577, %1578
%1580 = load i32, i32* %107
%1581 = load i32, i32* %99
%1582 = mul nsw i32 %1580, %1581
%1583 = add nsw i32 %1579, %1582
%1584 = load i32, i32* %108
%1585 = add nsw i32 %1583, %1584
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds double, double* %1574, i64 %1586
%1588 = load double, double* %1587
%1589 = load double*, double** %100
%1590 = load i32, i32* %106
%1591 = load i32, i32* %99
%1592 = mul nsw i32 %1590, %1591
%1593 = load i32, i32* %99
%1594 = mul nsw i32 %1592, %1593
%1595 = load i32, i32* %107
%1596 = load i32, i32* %99
%1597 = mul nsw i32 %1595, %1596
%1598 = add nsw i32 %1594, %1597
%1599 = load i32, i32* %108
%1600 = add nsw i32 %1598, %1599
%1601 = sext i32 %1600 to i64
%1602 = getelementptr inbounds double, double* %1589, i64 %1601
%1603 = load double, double* %1602
%1604 = fadd double %1603, %1588
store double %1604, double* %1602
br label %1605
1605: ; preds = %1573
%1606 = load i32, i32* %108
%1607 = add nsw i32 %1606, 1
store i32 %1607, i32* %108
br label %1569
1608: ; preds = %1569
br label %1609
1609: ; preds = %1608
%1610 = load i32, i32* %107
%1611 = add nsw i32 %1610, 1
store i32 %1611, i32* %107
br label %1564
1612: ; preds = %1564
br label %1613
1613: ; preds = %1612
%1614 = load i32, i32* %106
%1615 = add nsw i32 %1614, 1
store i32 %1615, i32* %106
br label %1559
1616: ; preds = %1559
br label %1617
1617: ; preds = %1616
%1618 = load i32, i32* %105
%1619 = add nsw i32 %1618, 1
store i32 %1619, i32* %105
br label %1555
1620: ; preds = %1555
store i32 0, i32* %109
br label %1621
1621: ; preds = %1680, %1620
%1622 = load i32, i32* %109
%1623 = load i32, i32* %99
%1624 = icmp slt i32 %1622, %1623
br i1 %1624, label %1625, label %1683
1625: ; preds = %1621
store i32 0, i32* %110
br label %1626
1626: ; preds = %1676, %1625
%1627 = load i32, i32* %110
%1628 = load i32, i32* %99
%1629 = icmp slt i32 %1627, %1628
br i1 %1629, label %1630, label %1679
1630: ; preds = %1626
store i32 0, i32* %111
br label %1631
1631: ; preds = %1672, %1630
%1632 = load i32, i32* %111
%1633 = load i32, i32* %99
%1634 = icmp slt i32 %1632, %1633
br i1 %1634, label %1635, label %1675
1635: ; preds = %1631
%1636 = load double*, double** %100
%1637 = load i32, i32* %109
%1638 = load i32, i32* %99
%1639 = mul nsw i32 %1637, %1638
%1640 = load i32, i32* %99
%1641 = mul nsw i32 %1639, %1640
%1642 = load i32, i32* %110
%1643 = load i32, i32* %99
%1644 = mul nsw i32 %1642, %1643
%1645 = add nsw i32 %1641, %1644
%1646 = load i32, i32* %111
%1647 = add nsw i32 %1645, %1646
%1648 = sext i32 %1647 to i64
%1649 = getelementptr inbounds double, double* %1636, i64 %1648
%1650 = load double, double* %1649
%1651 = fcmp une double %1650, 5.000000e+00
br i1 %1651, label %1652, label %1671
1652: ; preds = %1635
%1653 = load i32, i32* %109
%1654 = load i32, i32* %110
%1655 = load double*, double** %100
%1656 = load i32, i32* %109
%1657 = load i32, i32* %99
%1658 = mul nsw i32 %1656, %1657
%1659 = load i32, i32* %99
%1660 = mul nsw i32 %1658, %1659
%1661 = load i32, i32* %110
%1662 = load i32, i32* %99
%1663 = mul nsw i32 %1661, %1662
%1664 = add nsw i32 %1660, %1663
%1665 = load i32, i32* %111
%1666 = add nsw i32 %1664, %1665
%1667 = sext i32 %1666 to i64
%1668 = getelementptr inbounds double, double* %1655, i64 %1667
%1669 = load double, double* %1668
%1670 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1653, i32 %1654, double 3.000000e+00, double %1669)
store i32 1, i32* %7
br label %1671
1671: ; preds = %1652, %1635
br label %1672
1672: ; preds = %1671
%1673 = load i32, i32* %111
%1674 = add nsw i32 %1673, 1
store i32 %1674, i32* %111
br label %1631
1675: ; preds = %1631
br label %1676
1676: ; preds = %1675
%1677 = load i32, i32* %110
%1678 = add nsw i32 %1677, 1
store i32 %1678, i32* %110
br label %1626
1679: ; preds = %1626
br label %1680
1680: ; preds = %1679
%1681 = load i32, i32* %109
%1682 = add nsw i32 %1681, 1
store i32 %1682, i32* %109
br label %1621
1683: ; preds = %1621
%1684 = load i32, i32* %7
%1685 = icmp ne i32 %1684, 0
br i1 %1685, label %1686, label %1688
1686: ; preds = %1683
%1687 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1690
1688: ; preds = %1683
%1689 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1690
1690: ; preds = %1688, %1686
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 double* @malloc(i32 7872512)
%1376 = bitcast double* %1375 to i8*
%1377 = tail call double* @malloc(i32 7872512)
%1378 = tail call double* @malloc(i32 7872512)
br label %1379
1379: ; preds = %1371, %1425
%1380 = phi i64 [ 0, %1371 ], [ %1426, %1425 ]
%1381 = mul nuw nsw i64 %1380, 992
br label %1382
1382: ; preds = %1382, %1379
%1383 = phi i64 [ 0, %1379 ], [ %1423, %1382 ]
%1384 = add nuw nsw i64 %1383, %1381
%1385 = getelementptr inbounds double, double* %1377, i64 %1384
%1386 = bitcast double* %1385 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1386
%1387 = getelementptr inbounds double, double* %1385, i64 2
%1388 = bitcast double* %1387 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1388
%1389 = getelementptr inbounds double, double* %1378, i64 %1384
%1390 = bitcast double* %1389 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1390
%1391 = getelementptr inbounds double, double* %1389, i64 2
%1392 = bitcast double* %1391 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1392
%1393 = or i64 %1383, 4
%1394 = add nuw nsw i64 %1393, %1381
%1395 = getelementptr inbounds double, double* %1377, i64 %1394
%1396 = bitcast double* %1395 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1396
%1397 = getelementptr inbounds double, double* %1395, i64 2
%1398 = bitcast double* %1397 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1398
%1399 = getelementptr inbounds double, double* %1378, i64 %1394
%1400 = bitcast double* %1399 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1400
%1401 = getelementptr inbounds double, double* %1399, i64 2
%1402 = bitcast double* %1401 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1402
%1403 = or i64 %1383, 8
%1404 = add nuw nsw i64 %1403, %1381
%1405 = getelementptr inbounds double, double* %1377, i64 %1404
%1406 = bitcast double* %1405 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1406
%1407 = getelementptr inbounds double, double* %1405, i64 2
%1408 = bitcast double* %1407 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1408
%1409 = getelementptr inbounds double, double* %1378, i64 %1404
%1410 = bitcast double* %1409 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1410
%1411 = getelementptr inbounds double, double* %1409, i64 2
%1412 = bitcast double* %1411 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1412
%1413 = or i64 %1383, 12
%1414 = add nuw nsw i64 %1413, %1381
%1415 = getelementptr inbounds double, double* %1377, i64 %1414
%1416 = bitcast double* %1415 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1416
%1417 = getelementptr inbounds double, double* %1415, i64 2
%1418 = bitcast double* %1417 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1418
%1419 = getelementptr inbounds double, double* %1378, i64 %1414
%1420 = bitcast double* %1419 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1420
%1421 = getelementptr inbounds double, double* %1419, i64 2
%1422 = bitcast double* %1421 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1422
%1423 = add nuw nsw i64 %1383, 16
%1424 = icmp eq i64 %1423, 992
br i1 %1424, label %1425, label %1382
1425: ; preds = %1382
%1426 = add nuw nsw i64 %1380, 1
%1427 = icmp eq i64 %1426, 992
br i1 %1427, label %1428, label %1379
1428: ; preds = %1425, %1460
%1429 = phi i64 [ %1461, %1460 ], [ 0, %1425 ]
%1430 = mul nuw nsw i64 %1429, 992
br label %1431
1431: ; preds = %1431, %1428
%1432 = phi i64 [ 0, %1428 ], [ %1458, %1431 ]
%1433 = add nuw nsw i64 %1432, %1430
%1434 = getelementptr inbounds double, double* %1377, i64 %1433
%1435 = bitcast double* %1434 to <2 x double>*
%1436 = load <2 x double>, <2 x double>* %1435
%1437 = getelementptr inbounds double, double* %1434, i64 2
%1438 = bitcast double* %1437 to <2 x double>*
%1439 = load <2 x double>, <2 x double>* %1438
%1440 = getelementptr inbounds double, double* %1378, i64 %1433
%1441 = bitcast double* %1440 to <2 x double>*
%1442 = load <2 x double>, <2 x double>* %1441
%1443 = getelementptr inbounds double, double* %1440, i64 2
%1444 = bitcast double* %1443 to <2 x double>*
%1445 = load <2 x double>, <2 x double>* %1444
%1446 = fadd <2 x double> %1436, %1442
%1447 = fadd <2 x double> %1439, %1445
%1448 = getelementptr inbounds double, double* %1375, i64 %1433
%1449 = bitcast double* %1448 to <2 x double>*
%1450 = load <2 x double>, <2 x double>* %1449
%1451 = getelementptr inbounds double, double* %1448, i64 2
%1452 = bitcast double* %1451 to <2 x double>*
%1453 = load <2 x double>, <2 x double>* %1452
%1454 = fadd <2 x double> %1450, %1446
%1455 = fadd <2 x double> %1453, %1447
%1456 = bitcast double* %1448 to <2 x double>*
store <2 x double> %1454, <2 x double>* %1456
%1457 = bitcast double* %1451 to <2 x double>*
store <2 x double> %1455, <2 x double>* %1457
%1458 = add nuw i64 %1432, 4
%1459 = icmp eq i64 %1458, 992
br i1 %1459, label %1460, label %1431
1460: ; preds = %1431
%1461 = add nuw nsw i64 %1429, 1
%1462 = icmp eq i64 %1461, 992
br i1 %1462, label %1463, label %1428
1463: ; preds = %1460, %1474
%1464 = phi i64 [ %1475, %1474 ], [ 0, %1460 ]
%1465 = phi i32 [ %1488, %1474 ], [ %1373, %1460 ]
%1466 = mul nuw nsw i64 %1464, 992
%1467 = trunc i64 %1464 to i32
br label %1477
1468: ; preds = %1474
%1469 = icmp eq i32 %1488, 0
%1470 = select i1 %1469, 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)
%1471 = tail call i32 @puts(i8* dereferenceable(1) %1470)
%1472 = tail call double* @malloc(i32 15252992)
%1473 = tail call double* @malloc(i32 15252992)
br label %1491
1474: ; preds = %1487
%1475 = add nuw nsw i64 %1464, 1
%1476 = icmp eq i64 %1475, 992
br i1 %1476, label %1468, label %1463
1477: ; preds = %1463, %1487
%1478 = phi i64 [ 0, %1463 ], [ %1489, %1487 ]
%1479 = phi i32 [ %1465, %1463 ], [ %1488, %1487 ]
%1480 = add nuw nsw i64 %1478, %1466
%1481 = getelementptr inbounds double, double* %1375, i64 %1480
%1482 = load double, double* %1481
%1483 = fcmp une double %1482, 3.000000e+00
br i1 %1483, label %1484, label %1487
1484: ; preds = %1477
%1485 = trunc i64 %1478 to i32
%1486 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1467, i32 %1485, double 3.000000e+00, double %1482)
br label %1487
1487: ; preds = %1477, %1484
%1488 = phi i32 [ 1, %1484 ], [ %1479, %1477 ]
%1489 = add nuw nsw i64 %1478, 1
%1490 = icmp eq i64 %1489, 992
br i1 %1490, label %1474, label %1477
1491: ; preds = %1468, %1513
%1492 = phi i64 [ 0, %1468 ], [ %1514, %1513 ]
%1493 = mul nuw nsw i64 %1492, 15376
br label %1494
1494: ; preds = %1491, %1516
%1495 = phi i64 [ 0, %1491 ], [ %1517, %1516 ]
%1496 = mul nuw nsw i64 %1495, 124
%1497 = add nuw nsw i64 %1496, %1493
br label %1498
1498: ; preds = %1498, %1494
%1499 = phi i64 [ 0, %1494 ], [ %1511, %1498 ]
%1500 = add nuw nsw i64 %1497, %1499
%1501 = getelementptr inbounds double, double* %1472, i64 %1500
%1502 = bitcast double* %1501 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1502
%1503 = getelementptr inbounds double, double* %1473, i64 %1500
%1504 = bitcast double* %1503 to <2 x double>*
store <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double>* %1504
%1505 = or i64 %1499, 2
%1506 = add nuw nsw i64 %1497, %1505
%1507 = getelementptr inbounds double, double* %1472, i64 %1506
%1508 = bitcast double* %1507 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %1508
%1509 = getelementptr inbounds double, double* %1473, i64 %1506
%1510 = bitcast double* %1509 to <2 x double>*
store <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double>* %1510
%1511 = add nuw nsw i64 %1499, 4
%1512 = icmp eq i64 %1511, 124
br i1 %1512, label %1516, label %1498
1513: ; preds = %1516
%1514 = add nuw nsw i64 %1492, 1
%1515 = icmp eq i64 %1514, 124
br i1 %1515, label %1519, label %1491
1516: ; preds = %1498
%1517 = add nuw nsw i64 %1495, 1
%1518 = icmp eq i64 %1517, 124
br i1 %1518, label %1513, label %1494
1519: ; preds = %1513, %1549
%1520 = phi i64 [ %1550, %1549 ], [ 0, %1513 ]
%1521 = mul nuw nsw i64 %1520, 15376
br label %1522
1522: ; preds = %1519, %1552
%1523 = phi i64 [ 0, %1519 ], [ %1553, %1552 ]
%1524 = mul nuw nsw i64 %1523, 124
%1525 = add nuw nsw i64 %1524, %1521
br label %1526
1526: ; preds = %1526, %1522
%1527 = phi i64 [ 0, %1522 ], [ %1547, %1526 ]
%1528 = add nuw nsw i64 %1525, %1527
%1529 = getelementptr inbounds double, double* %1473, i64 %1528
%1530 = bitcast double* %1529 to <2 x double>*
%1531 = load <2 x double>, <2 x double>* %1530
%1532 = getelementptr inbounds double, double* %1472, i64 %1528
%1533 = bitcast double* %1532 to <2 x double>*
%1534 = load <2 x double>, <2 x double>* %1533
%1535 = fadd <2 x double> %1531, %1534
%1536 = bitcast double* %1532 to <2 x double>*
store <2 x double> %1535, <2 x double>* %1536
%1537 = or i64 %1527, 2
%1538 = add nuw nsw i64 %1525, %1537
%1539 = getelementptr inbounds double, double* %1473, i64 %1538
%1540 = bitcast double* %1539 to <2 x double>*
%1541 = load <2 x double>, <2 x double>* %1540
%1542 = getelementptr inbounds double, double* %1472, i64 %1538
%1543 = bitcast double* %1542 to <2 x double>*
%1544 = load <2 x double>, <2 x double>* %1543
%1545 = fadd <2 x double> %1541, %1544
%1546 = bitcast double* %1542 to <2 x double>*
store <2 x double> %1545, <2 x double>* %1546
%1547 = add nuw nsw i64 %1527, 4
%1548 = icmp eq i64 %1547, 124
br i1 %1548, label %1552, label %1526
1549: ; preds = %1552
%1550 = add nuw nsw i64 %1520, 1
%1551 = icmp eq i64 %1550, 124
br i1 %1551, label %1555, label %1519
1552: ; preds = %1526
%1553 = add nuw nsw i64 %1523, 1
%1554 = icmp eq i64 %1553, 124
br i1 %1554, label %1549, label %1522
1555: ; preds = %1549, %1570
%1556 = phi i64 [ %1571, %1570 ], [ 0, %1549 ]
%1557 = phi i32 [ %1586, %1570 ], [ %1488, %1549 ]
%1558 = mul nuw nsw i64 %1556, 15376
%1559 = trunc i64 %1556 to i32
br label %1564
1560: ; preds = %1570
%1561 = icmp eq i32 %1586, 0
%1562 = select i1 %1561, 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)
%1563 = tail call i32 @puts(i8* dereferenceable(1) %1562)
ret i32 0
1564: ; preds = %1555, %1573
%1565 = phi i64 [ 0, %1555 ], [ %1574, %1573 ]
%1566 = phi i32 [ %1557, %1555 ], [ %1586, %1573 ]
%1567 = mul nuw nsw i64 %1565, 124
%1568 = add nuw nsw i64 %1567, %1558
%1569 = trunc i64 %1565 to i32
br label %1576
1570: ; preds = %1573
%1571 = add nuw nsw i64 %1556, 1
%1572 = icmp eq i64 %1571, 124
br i1 %1572, label %1560, label %1555
1573: ; preds = %1585
%1574 = add nuw nsw i64 %1565, 1
%1575 = icmp eq i64 %1574, 124
br i1 %1575, label %1570, label %1564
1576: ; preds = %1564, %1585
%1577 = phi i64 [ 0, %1564 ], [ %1587, %1585 ]
%1578 = phi i32 [ %1566, %1564 ], [ %1586, %1585 ]
%1579 = add nuw nsw i64 %1568, %1577
%1580 = getelementptr inbounds double, double* %1472, i64 %1579
%1581 = load double, double* %1580
%1582 = fcmp une double %1581, 5.000000e+00
br i1 %1582, label %1583, label %1585
1583: ; preds = %1576
%1584 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1559, i32 %1569, double 3.000000e+00, double %1581)
br label %1585
1585: ; preds = %1576, %1583
%1586 = phi i32 [ 1, %1583 ], [ %1578, %1576 ]
%1587 = add nuw nsw i64 %1577, 1
%1588 = icmp eq i64 %1587, 124
br i1 %1588, label %1573, label %1576
}