#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();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  int fail;
  double A[1024], B[1024], C[1024], D[1024], E[1024];
  double *pA, *pB, *pC, *pD, *pE;
  int t;
  pA = &A[0];
  pB = &B[0];
  pC = &C[0];
  pD = &D[0];
  pE = &E[0];
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp parallel for num_threads(T) schedule(static, 1)
  for (t = 0; t < 8; t++) {
    int i0 = t * (1024 / 8);
    int i1 = (t + 1) * (1024 / 8);
#pragma omp target map(A [i0:M], C [i0:M], D [i0:M])
    {
      for (int i = i0; i < i1; i++)
        A[i] = C[i] + D[i] + 1;
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_A: Failed\n");
  } else {
    printf("Test PAR_A: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp parallel for num_threads(T) schedule(static, 1)
  for (t = 0; t < 8; t++) {
    int i0 = t * (1024 / 8);
    int i1 = (t + 1) * (1024 / 8);
#pragma omp target map(pA [i0:M], pC [i0:M], pD [i0:M])
    {
      for (int i = i0; i < i1; i++)
        pA[i] = pC[i] + pD[i] + 1;
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_P: Failed\n");
  } else {
    printf("Test PAR_P: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp target data map(A, B, C)
  {
#pragma omp parallel for num_threads(T) schedule(static, 1)
    for (t = 0; t < 8; t++) {
      int i0 = t * (1024 / 8);
      int i1 = (t + 1) * (1024 / 8);
#pragma omp target map(A [i0:M], C [i0:M], D [i0:M])
      {
        for (int i = i0; i < i1; i++)
          A[i] = C[i] + D[i] + 1;
      }
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_1_DATA_A: Failed\n");
  } else {
    printf("Test PAR_1_DATA_A: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp parallel for num_threads(T) schedule(static, 1)
  for (t = 0; t < 8; t++) {
    int i0 = t * (1024 / 8);
    int i1 = (t + 1) * (1024 / 8);
#pragma omp target data map(A [i0:M], C [i0:M], D [i0:M])
    {
#pragma omp target map(A [i0:M], C [i0:M], D [i0:M])
      {
        for (int i = i0; i < i1; i++)
          A[i] = C[i] + D[i] + 1;
      }
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_T_DATA_A: Failed\n");
  } else {
    printf("Test PAR_T_DATA_A: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp parallel for num_threads(T) schedule(static, 1)
  for (t = 0; t < 8; t++) {
    int i0 = t * (1024 / 8);
    int i1 = (t + 1) * (1024 / 8);
#pragma omp target map(from : A [i0:M]) map(to : C [i0:M], D [i0:M])
    {
      for (int i = i0; i < i1; i++)
        A[i] = C[i] + D[i] + 1;
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_TOFROM_A: Failed\n");
  } else {
    printf("Test PAR_TOFROM_A: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < 1024; i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp parallel for num_threads(T) schedule(static, 1)
  for (t = 0; t < 8; t++) {
    int i0 = t * (1024 / 8);
    int i1 = (t + 1) * (1024 / 8);
#pragma omp target map(from : A [i0:M]) map(to : C, D)
    {
      for (int i = i0; i < i1; i++)
        A[i] = C[i] + D[i] + 1;
    }
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1024; i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test PAR_TOALL_FROM_A: Failed\n");
  } else {
    printf("Test PAR_TOALL_FROM_A: Succeeded\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0d0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1040 <check_offloading@plt>
lea    -0x2010(%rbp),%rax
mov    %rax,-0xa018(%rbp)
lea    -0x4010(%rbp),%rax
mov    %rax,-0xa020(%rbp)
lea    -0x6010(%rbp),%rax
mov    %rax,-0xa028(%rbp)
lea    -0x8010(%rbp),%rax
mov    %rax,-0xa030(%rbp)
lea    -0xa010(%rbp),%rax
mov    %rax,-0xa038(%rbp)
movl   $0x0,-0xa040(%rbp)
cmpl   $0x400,-0xa040(%rbp)
jge    120c <main+0xec>
movslq -0xa040(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa040(%rbp),%rax
movsd  0xe45(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa040(%rbp),%xmm0
ff
movslq -0xa040(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa040(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa040(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa040(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa040(%rbp)
jmp    1189 <main+0x69>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    12cb <main+0x1ab>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa044(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa048(%rbp)
mov    -0xa044(%rbp),%eax
mov    %eax,-0xa04c(%rbp)
mov    -0xa04c(%rbp),%eax
cmp    -0xa048(%rbp),%eax
jge    12b2 <main+0x192>
movslq -0xa04c(%rbp),%rax
movsd  -0x6010(%rbp,%rax,8),%xmm0
ff ff
movslq -0xa04c(%rbp),%rax
addsd  -0x8010(%rbp,%rax,8),%xmm0
ff ff
movsd  0xd76(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0xa04c(%rbp),%rax
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
mov    -0xa04c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa04c(%rbp)
jmp    1250 <main+0x130>
jmp    12b7 <main+0x197>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    1216 <main+0xf6>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa054(%rbp)
movl   $0x0,-0xa050(%rbp)
cmpl   $0x400,-0xa050(%rbp)
jge    13a4 <main+0x284>
movslq -0xa050(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa050(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1328 <main+0x208>
jp     1328 <main+0x208>
jmp    138b <main+0x26b>
mov    -0xa050(%rbp),%esi
mov    -0xa050(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa050(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0xcb6(%rip),%rdi
lea    0xcdb(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa054(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa054(%rbp)
cmp    $0xa,%eax
jle    1386 <main+0x266>
jmp    13a4 <main+0x284>
jmp    138b <main+0x26b>
jmp    1390 <main+0x270>
mov    -0xa050(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa050(%rbp)
jmp    12e6 <main+0x1c6>
cmpl   $0x0,-0x8(%rbp)
je     13c1 <main+0x2a1>
lea    0xc84(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13cf <main+0x2af>
lea    0xc85(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa058(%rbp)
cmpl   $0x400,-0xa058(%rbp)
jge    145c <main+0x33c>
movslq -0xa058(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa058(%rbp),%rax
movsd  0xbf5(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa058(%rbp),%xmm0
ff
movslq -0xa058(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa058(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa058(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa058(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa058(%rbp)
jmp    13d9 <main+0x2b9>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    1524 <main+0x404>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa05c(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa060(%rbp)
mov    -0xa05c(%rbp),%eax
mov    %eax,-0xa064(%rbp)
mov    -0xa064(%rbp),%eax
cmp    -0xa060(%rbp),%eax
jge    150b <main+0x3eb>
mov    -0xa028(%rbp),%rax
movslq -0xa064(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa030(%rbp),%rax
movslq -0xa064(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xb20(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xa018(%rbp),%rax
movslq -0xa064(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa064(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa064(%rbp)
jmp    14a0 <main+0x380>
jmp    1510 <main+0x3f0>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    1466 <main+0x346>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa06c(%rbp)
movl   $0x0,-0xa068(%rbp)
cmpl   $0x400,-0xa068(%rbp)
jge    15fd <main+0x4dd>
movslq -0xa068(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa068(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1581 <main+0x461>
jp     1581 <main+0x461>
jmp    15e4 <main+0x4c4>
mov    -0xa068(%rbp),%esi
mov    -0xa068(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa068(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0xa5d(%rip),%rdi
lea    0xa82(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa06c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa06c(%rbp)
cmp    $0xa,%eax
jle    15df <main+0x4bf>
jmp    15fd <main+0x4dd>
jmp    15e4 <main+0x4c4>
jmp    15e9 <main+0x4c9>
mov    -0xa068(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa068(%rbp)
jmp    153f <main+0x41f>
cmpl   $0x0,-0x8(%rbp)
je     161a <main+0x4fa>
lea    0xa56(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1628 <main+0x508>
lea    0xa57(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa070(%rbp)
cmpl   $0x400,-0xa070(%rbp)
jge    16b5 <main+0x595>
movslq -0xa070(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa070(%rbp),%rax
movsd  0x99c(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa070(%rbp),%xmm0
ff
movslq -0xa070(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa070(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa070(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa070(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa070(%rbp)
jmp    1632 <main+0x512>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    1774 <main+0x654>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa074(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa078(%rbp)
mov    -0xa074(%rbp),%eax
mov    %eax,-0xa07c(%rbp)
mov    -0xa07c(%rbp),%eax
cmp    -0xa078(%rbp),%eax
jge    175b <main+0x63b>
movslq -0xa07c(%rbp),%rax
movsd  -0x6010(%rbp,%rax,8),%xmm0
ff ff
movslq -0xa07c(%rbp),%rax
addsd  -0x8010(%rbp,%rax,8),%xmm0
ff ff
movsd  0x8cd(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0xa07c(%rbp),%rax
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
mov    -0xa07c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa07c(%rbp)
jmp    16f9 <main+0x5d9>
jmp    1760 <main+0x640>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    16bf <main+0x59f>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa084(%rbp)
movl   $0x0,-0xa080(%rbp)
cmpl   $0x400,-0xa080(%rbp)
jge    184d <main+0x72d>
movslq -0xa080(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa080(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    17d1 <main+0x6b1>
jp     17d1 <main+0x6b1>
jmp    1834 <main+0x714>
mov    -0xa080(%rbp),%esi
mov    -0xa080(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa080(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0x80d(%rip),%rdi
lea    0x832(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa084(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa084(%rbp)
cmp    $0xa,%eax
jle    182f <main+0x70f>
jmp    184d <main+0x72d>
jmp    1834 <main+0x714>
jmp    1839 <main+0x719>
mov    -0xa080(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa080(%rbp)
jmp    178f <main+0x66f>
cmpl   $0x0,-0x8(%rbp)
je     186a <main+0x74a>
lea    0x831(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1878 <main+0x758>
lea    0x839(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa088(%rbp)
cmpl   $0x400,-0xa088(%rbp)
jge    1905 <main+0x7e5>
movslq -0xa088(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa088(%rbp),%rax
movsd  0x74c(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa088(%rbp),%xmm0
ff
movslq -0xa088(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa088(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa088(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa088(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa088(%rbp)
jmp    1882 <main+0x762>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    19c4 <main+0x8a4>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa08c(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa090(%rbp)
mov    -0xa08c(%rbp),%eax
mov    %eax,-0xa094(%rbp)
mov    -0xa094(%rbp),%eax
cmp    -0xa090(%rbp),%eax
jge    19ab <main+0x88b>
movslq -0xa094(%rbp),%rax
movsd  -0x6010(%rbp,%rax,8),%xmm0
ff ff
movslq -0xa094(%rbp),%rax
addsd  -0x8010(%rbp,%rax,8),%xmm0
ff ff
movsd  0x67d(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0xa094(%rbp),%rax
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
mov    -0xa094(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa094(%rbp)
jmp    1949 <main+0x829>
jmp    19b0 <main+0x890>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    190f <main+0x7ef>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa09c(%rbp)
movl   $0x0,-0xa098(%rbp)
cmpl   $0x400,-0xa098(%rbp)
jge    1a9d <main+0x97d>
movslq -0xa098(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa098(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1a21 <main+0x901>
jp     1a21 <main+0x901>
jmp    1a84 <main+0x964>
mov    -0xa098(%rbp),%esi
mov    -0xa098(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa098(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0x5bd(%rip),%rdi
lea    0x5e2(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa09c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa09c(%rbp)
cmp    $0xa,%eax
jle    1a7f <main+0x95f>
jmp    1a9d <main+0x97d>
jmp    1a84 <main+0x964>
jmp    1a89 <main+0x969>
mov    -0xa098(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa098(%rbp)
jmp    19df <main+0x8bf>
cmpl   $0x0,-0x8(%rbp)
je     1aba <main+0x99a>
lea    0x61a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1ac8 <main+0x9a8>
lea    0x622(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa0a0(%rbp)
cmpl   $0x400,-0xa0a0(%rbp)
jge    1b55 <main+0xa35>
movslq -0xa0a0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa0a0(%rbp),%rax
movsd  0x4fc(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa0a0(%rbp),%xmm0
ff
movslq -0xa0a0(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa0a0(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa0a0(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa0a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0a0(%rbp)
jmp    1ad2 <main+0x9b2>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    1c14 <main+0xaf4>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa0a4(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa0a8(%rbp)
mov    -0xa0a4(%rbp),%eax
mov    %eax,-0xa0ac(%rbp)
mov    -0xa0ac(%rbp),%eax
cmp    -0xa0a8(%rbp),%eax
jge    1bfb <main+0xadb>
movslq -0xa0ac(%rbp),%rax
movsd  -0x6010(%rbp,%rax,8),%xmm0
ff ff
movslq -0xa0ac(%rbp),%rax
addsd  -0x8010(%rbp,%rax,8),%xmm0
ff ff
movsd  0x42d(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0xa0ac(%rbp),%rax
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
mov    -0xa0ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0ac(%rbp)
jmp    1b99 <main+0xa79>
jmp    1c00 <main+0xae0>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    1b5f <main+0xa3f>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa0b4(%rbp)
movl   $0x0,-0xa0b0(%rbp)
cmpl   $0x400,-0xa0b0(%rbp)
jge    1ced <main+0xbcd>
movslq -0xa0b0(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa0b0(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1c71 <main+0xb51>
jp     1c71 <main+0xb51>
jmp    1cd4 <main+0xbb4>
mov    -0xa0b0(%rbp),%esi
mov    -0xa0b0(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa0b0(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0x36d(%rip),%rdi
lea    0x392(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa0b4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa0b4(%rbp)
cmp    $0xa,%eax
jle    1ccf <main+0xbaf>
jmp    1ced <main+0xbcd>
jmp    1cd4 <main+0xbb4>
jmp    1cd9 <main+0xbb9>
mov    -0xa0b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0b0(%rbp)
jmp    1c2f <main+0xb0f>
cmpl   $0x0,-0x8(%rbp)
je     1d0a <main+0xbea>
lea    0x403(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1d18 <main+0xbf8>
lea    0x40b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa0b8(%rbp)
cmpl   $0x400,-0xa0b8(%rbp)
jge    1da5 <main+0xc85>
movslq -0xa0b8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
movslq -0xa0b8(%rbp),%rax
movsd  0x2ac(%rip),%xmm0
movsd  %xmm0,-0x6010(%rbp,%rax,8)
ff ff
cvtsi2sdl -0xa0b8(%rbp),%xmm0
ff
movslq -0xa0b8(%rbp),%rax
movsd  %xmm0,-0x8010(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0xa0b8(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xa0b8(%rbp),%rax
movsd  %xmm0,-0xa010(%rbp,%rax,8)
ff ff
mov    -0xa0b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0b8(%rbp)
jmp    1d22 <main+0xc02>
movl   $0x0,-0xa03c(%rbp)
cmpl   $0x8,-0xa03c(%rbp)
jge    1e64 <main+0xd44>
mov    -0xa03c(%rbp),%eax
shl    $0x7,%eax
mov    %eax,-0xa0bc(%rbp)
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
shl    $0x7,%eax
mov    %eax,-0xa0c0(%rbp)
mov    -0xa0bc(%rbp),%eax
mov    %eax,-0xa0c4(%rbp)
mov    -0xa0c4(%rbp),%eax
cmp    -0xa0c0(%rbp),%eax
jge    1e4b <main+0xd2b>
movslq -0xa0c4(%rbp),%rax
movsd  -0x6010(%rbp,%rax,8),%xmm0
ff ff
movslq -0xa0c4(%rbp),%rax
addsd  -0x8010(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1dd(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0xa0c4(%rbp),%rax
movsd  %xmm0,-0x2010(%rbp,%rax,8)
ff ff
mov    -0xa0c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0c4(%rbp)
jmp    1de9 <main+0xcc9>
jmp    1e50 <main+0xd30>
mov    -0xa03c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa03c(%rbp)
jmp    1daf <main+0xc8f>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xa0cc(%rbp)
movl   $0x0,-0xa0c8(%rbp)
cmpl   $0x400,-0xa0c8(%rbp)
jge    1f3d <main+0xe1d>
movslq -0xa0c8(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm0
ff ff
mov    -0xa0c8(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1ec1 <main+0xda1>
jp     1ec1 <main+0xda1>
jmp    1f24 <main+0xe04>
mov    -0xa0c8(%rbp),%esi
mov    -0xa0c8(%rbp),%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm0
movslq -0xa0c8(%rbp),%rax
movsd  -0x2010(%rbp,%rax,8),%xmm1
ff ff
lea    0x11d(%rip),%rdi
lea    0x142(%rip),%rdx
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0xa0cc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa0cc(%rbp)
cmp    $0xa,%eax
jle    1f1f <main+0xdff>
jmp    1f3d <main+0xe1d>
jmp    1f24 <main+0xe04>
jmp    1f29 <main+0xe09>
mov    -0xa0c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0c8(%rbp)
jmp    1e7f <main+0xd5f>
cmpl   $0x0,-0x8(%rbp)
je     1f5a <main+0xe3a>
lea    0x1ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1f68 <main+0xe48>
lea    0x1f8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xa0d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x6000,%rsp
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <check_offloading@plt>
lea    0x4000(%rsp),%rdi
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x2e8c(%rip),%xmm0
movapd 0x2ea4(%rip),%xmm4
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  0x2e84(%rip),%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  0x2e75(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  0x2e79(%rip),%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  0x2e57(%rip),%xmm0
cmp    $0x400,%rbx
jne    1180 <main+0x40>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1210 <main+0xd0>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1290 <main+0x150>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1320 <main+0x1e0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    13b0 <main+0x270>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1440 <main+0x300>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    14d0 <main+0x390>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1560 <main+0x420>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    15f0 <main+0x4b0>
xor    %ebx,%ebx
lea    0x2a0c(%rip),%rdi
lea    0x29d4(%rip),%r14
lea    0x29f9(%rip),%r15
lea    0x2b1a(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    16d0 <main+0x590>
jp     16d0 <main+0x590>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    16a0 <main+0x560>
jmp    16f7 <main+0x5b7>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     16f4 <main+0x5b4>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    169c <main+0x55c>
mov    %r12,%rdi
call   1030 <puts@plt>
lea    0x4000(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x28e6(%rip),%xmm0
movapd 0x28fe(%rip),%xmm4
movdqa 0x28e6(%rip),%xmm3
movdqa 0x28fe(%rip),%xmm5
movdqa 0x2906(%rip),%xmm6
movdqa 0x290e(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  %xmm7,%xmm0
cmp    $0x400,%rbx
jne    1750 <main+0x610>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    17d0 <main+0x690>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1850 <main+0x710>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    18e0 <main+0x7a0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1970 <main+0x830>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1a00 <main+0x8c0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1a90 <main+0x950>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1b20 <main+0x9e0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1bb0 <main+0xa70>
xor    %ebx,%ebx
lea    0x2462(%rip),%rdi
lea    0x2414(%rip),%r14
lea    0x2439(%rip),%r15
lea    0x2547(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    1c90 <main+0xb50>
jp     1c90 <main+0xb50>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    1c60 <main+0xb20>
jmp    1cb7 <main+0xb77>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     1cb4 <main+0xb74>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    1c5c <main+0xb1c>
mov    %r12,%rdi
call   1030 <puts@plt>
lea    0x4000(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x2326(%rip),%xmm0
movapd 0x233e(%rip),%xmm4
movdqa 0x2326(%rip),%xmm3
movdqa 0x233e(%rip),%xmm5
movdqa 0x2346(%rip),%xmm6
movdqa 0x234e(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  %xmm7,%xmm0
cmp    $0x400,%rbx
jne    1d10 <main+0xbd0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1d90 <main+0xc50>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1e10 <main+0xcd0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1ea0 <main+0xd60>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1f30 <main+0xdf0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    1fc0 <main+0xe80>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2050 <main+0xf10>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    20e0 <main+0xfa0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2170 <main+0x1030>
xor    %ebx,%ebx
lea    0x1eb8(%rip),%rdi
lea    0x1e54(%rip),%r14
lea    0x1e79(%rip),%r15
lea    0x1f6d(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    2250 <main+0x1110>
jp     2250 <main+0x1110>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    2220 <main+0x10e0>
jmp    2277 <main+0x1137>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     2274 <main+0x1134>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    221c <main+0x10dc>
mov    %r12,%rdi
call   1030 <puts@plt>
lea    0x4000(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x1d66(%rip),%xmm0
movapd 0x1d7e(%rip),%xmm4
movdqa 0x1d66(%rip),%xmm3
movdqa 0x1d7e(%rip),%xmm5
movdqa 0x1d86(%rip),%xmm6
movdqa 0x1d8e(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  %xmm7,%xmm0
cmp    $0x400,%rbx
jne    22d0 <main+0x1190>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2350 <main+0x1210>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    23d0 <main+0x1290>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2460 <main+0x1320>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    24f0 <main+0x13b0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2580 <main+0x1440>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2610 <main+0x14d0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    26a0 <main+0x1560>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2730 <main+0x15f0>
xor    %ebx,%ebx
lea    0x1915(%rip),%rdi
lea    0x1894(%rip),%r14
lea    0x18b9(%rip),%r15
lea    0x1993(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    2810 <main+0x16d0>
jp     2810 <main+0x16d0>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    27e0 <main+0x16a0>
jmp    2837 <main+0x16f7>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     2834 <main+0x16f4>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    27dc <main+0x169c>
mov    %r12,%rdi
call   1030 <puts@plt>
lea    0x4000(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x17a6(%rip),%xmm0
movapd 0x17be(%rip),%xmm4
movdqa 0x17a6(%rip),%xmm3
movdqa 0x17be(%rip),%xmm5
movdqa 0x17c6(%rip),%xmm6
movdqa 0x17ce(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  %xmm7,%xmm0
cmp    $0x400,%rbx
jne    2890 <main+0x1750>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2910 <main+0x17d0>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2990 <main+0x1850>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2a20 <main+0x18e0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2ab0 <main+0x1970>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2b40 <main+0x1a00>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2bd0 <main+0x1a90>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2c60 <main+0x1b20>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2cf0 <main+0x1bb0>
xor    %ebx,%ebx
lea    0x1372(%rip),%rdi
lea    0x12d4(%rip),%r14
lea    0x12f9(%rip),%r15
lea    0x13b9(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    2dd0 <main+0x1c90>
jp     2dd0 <main+0x1c90>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    2da0 <main+0x1c60>
jmp    2df7 <main+0x1cb7>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     2df4 <main+0x1cb4>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    2d9c <main+0x1c5c>
mov    %r12,%rdi
call   1030 <puts@plt>
lea    0x4000(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x2000,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x11e6(%rip),%xmm0
movapd 0x11fe(%rip),%xmm4
movdqa 0x11e6(%rip),%xmm3
movdqa 0x11fe(%rip),%xmm5
movdqa 0x1206(%rip),%xmm6
movdqa 0x120e(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movapd %xmm4,0x2000(%rsp,%rbx,8)
cvtdq2pd %xmm0,%xmm2
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2010(%rsp,%rbx,8)
movaps %xmm2,(%rsp,%rbx,8)
movaps %xmm1,0x10(%rsp,%rbx,8)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movapd %xmm4,0x2020(%rsp,%rbx,8)
cvtdq2pd %xmm1,%xmm1
movapd %xmm4,0x2030(%rsp,%rbx,8)
cvtdq2pd %xmm2,%xmm2
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm2,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
paddd  %xmm7,%xmm0
cmp    $0x400,%rbx
jne    2e50 <main+0x1d10>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x2000(%rsp,%rax,8),%xmm0
movapd 0x2010(%rsp,%rax,8),%xmm1
movapd 0x2020(%rsp,%rax,8),%xmm2
movapd 0x2030(%rsp,%rax,8),%xmm3
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4000(%rsp,%rax,8)
movapd %xmm1,0x4010(%rsp,%rax,8)
addpd  0x20(%rsp,%rax,8),%xmm2
addpd  0x30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4020(%rsp,%rax,8)
movapd %xmm3,0x4030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2ed0 <main+0x1d90>
xor    %eax,%eax
nopl   (%rax)
movapd 0x2400(%rsp,%rax,8),%xmm0
movapd 0x2410(%rsp,%rax,8),%xmm1
movapd 0x2420(%rsp,%rax,8),%xmm2
movapd 0x2430(%rsp,%rax,8),%xmm3
addpd  0x400(%rsp,%rax,8),%xmm0
addpd  0x410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4400(%rsp,%rax,8)
movapd %xmm1,0x4410(%rsp,%rax,8)
addpd  0x420(%rsp,%rax,8),%xmm2
addpd  0x430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4420(%rsp,%rax,8)
movapd %xmm3,0x4430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2f50 <main+0x1e10>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2800(%rsp,%rax,8),%xmm0
movapd 0x2810(%rsp,%rax,8),%xmm1
movapd 0x2820(%rsp,%rax,8),%xmm2
movapd 0x2830(%rsp,%rax,8),%xmm3
addpd  0x800(%rsp,%rax,8),%xmm0
addpd  0x810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4800(%rsp,%rax,8)
movapd %xmm1,0x4810(%rsp,%rax,8)
addpd  0x820(%rsp,%rax,8),%xmm2
addpd  0x830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4820(%rsp,%rax,8)
movapd %xmm3,0x4830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    2fe0 <main+0x1ea0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x2c00(%rsp,%rax,8),%xmm0
movapd 0x2c10(%rsp,%rax,8),%xmm1
movapd 0x2c20(%rsp,%rax,8),%xmm2
movapd 0x2c30(%rsp,%rax,8),%xmm3
addpd  0xc00(%rsp,%rax,8),%xmm0
addpd  0xc10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x4c00(%rsp,%rax,8)
movapd %xmm1,0x4c10(%rsp,%rax,8)
addpd  0xc20(%rsp,%rax,8),%xmm2
addpd  0xc30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x4c20(%rsp,%rax,8)
movapd %xmm3,0x4c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    3070 <main+0x1f30>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3000(%rsp,%rax,8),%xmm0
movapd 0x3010(%rsp,%rax,8),%xmm1
movapd 0x3020(%rsp,%rax,8),%xmm2
movapd 0x3030(%rsp,%rax,8),%xmm3
addpd  0x1000(%rsp,%rax,8),%xmm0
addpd  0x1010(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5000(%rsp,%rax,8)
movapd %xmm1,0x5010(%rsp,%rax,8)
addpd  0x1020(%rsp,%rax,8),%xmm2
addpd  0x1030(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5020(%rsp,%rax,8)
movapd %xmm3,0x5030(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    3100 <main+0x1fc0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3400(%rsp,%rax,8),%xmm0
movapd 0x3410(%rsp,%rax,8),%xmm1
movapd 0x3420(%rsp,%rax,8),%xmm2
movapd 0x3430(%rsp,%rax,8),%xmm3
addpd  0x1400(%rsp,%rax,8),%xmm0
addpd  0x1410(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5400(%rsp,%rax,8)
movapd %xmm1,0x5410(%rsp,%rax,8)
addpd  0x1420(%rsp,%rax,8),%xmm2
addpd  0x1430(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5420(%rsp,%rax,8)
movapd %xmm3,0x5430(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    3190 <main+0x2050>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3800(%rsp,%rax,8),%xmm0
movapd 0x3810(%rsp,%rax,8),%xmm1
movapd 0x3820(%rsp,%rax,8),%xmm2
movapd 0x3830(%rsp,%rax,8),%xmm3
addpd  0x1800(%rsp,%rax,8),%xmm0
addpd  0x1810(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5800(%rsp,%rax,8)
movapd %xmm1,0x5810(%rsp,%rax,8)
addpd  0x1820(%rsp,%rax,8),%xmm2
addpd  0x1830(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5820(%rsp,%rax,8)
movapd %xmm3,0x5830(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    3220 <main+0x20e0>
xor    %eax,%eax
xchg   %ax,%ax
movapd 0x3c00(%rsp,%rax,8),%xmm0
movapd 0x3c10(%rsp,%rax,8),%xmm1
movapd 0x3c20(%rsp,%rax,8),%xmm2
movapd 0x3c30(%rsp,%rax,8),%xmm3
addpd  0x1c00(%rsp,%rax,8),%xmm0
addpd  0x1c10(%rsp,%rax,8),%xmm1
addpd  %xmm4,%xmm0
addpd  %xmm4,%xmm1
movapd %xmm0,0x5c00(%rsp,%rax,8)
movapd %xmm1,0x5c10(%rsp,%rax,8)
addpd  0x1c20(%rsp,%rax,8),%xmm2
addpd  0x1c30(%rsp,%rax,8),%xmm3
addpd  %xmm4,%xmm2
addpd  %xmm4,%xmm3
movapd %xmm2,0x5c20(%rsp,%rax,8)
movapd %xmm3,0x5c30(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x80,%rax
jne    32b0 <main+0x2170>
lea    0xdd1(%rip),%rdi
xor    %ebx,%ebx
lea    0xd14(%rip),%r14
lea    0xd39(%rip),%r15
lea    0xddb(%rip),%r12
xor    %ebp,%ebp
add    $0x1,%rbx
movsd  0x3ff8(%rsp,%rbx,8),%xmm1
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jne    3390 <main+0x2250>
jp     3390 <main+0x2250>
add    $0x1,%rbx
cmp    $0x401,%rbx
jne    3360 <main+0x2220>
jmp    33b7 <main+0x2277>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%esi
mov    %r14,%rdi
mov    %r15,%rdx
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0xa,%ebp
ja     33b4 <main+0x2274>
add    $0x1,%ebp
mov    %r12,%rdi
cmp    $0x400,%rbx
jne    335c <main+0x221c>
mov    %r12,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x6000,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [44 x i8] c"Failed at %3d with %s, expected %f, got %f\0A\00"
@.str.1 = [5 x i8] c"A[i]\00"
@str = [22 x i8] c"Test PAR_A: Succeeded\00"
@str.14 = [22 x i8] c"Test PAR_P: Succeeded\00"
@str.15 = [29 x i8] c"Test PAR_1_DATA_A: Succeeded\00"
@str.16 = [29 x i8] c"Test PAR_T_DATA_A: Succeeded\00"
@str.17 = [29 x i8] c"Test PAR_TOFROM_A: Succeeded\00"
@str.18 = [33 x i8] c"Test PAR_TOALL_FROM_A: Succeeded\00"
@str.19 = [30 x i8] c"Test PAR_TOALL_FROM_A: Failed\00"
@str.20 = [26 x i8] c"Test PAR_TOFROM_A: Failed\00"
@str.21 = [26 x i8] c"Test PAR_T_DATA_A: Failed\00"
@str.22 = [26 x i8] c"Test PAR_1_DATA_A: Failed\00"
@str.23 = [19 x i8] c"Test PAR_P: Failed\00"
@str.24 = [19 x i8] c"Test PAR_A: Failed\00"
define i32 @main() {
%1 = alloca [1024 x double]
%2 = bitcast [1024 x double]* %1 to i8*
%3 = alloca [1024 x double]
%4 = alloca [1024 x double]
%5 = tail call i32 (...) @check_offloading()
%6 = bitcast [1024 x double]* %3 to i8*
%7 = bitcast [1024 x double]* %4 to i8*
br label %8
8: ; preds = %8, %0
%9 = phi i64 [ 0, %0 ], [ %35, %8 ]
%10 = phi <2 x i32> [ <i32 0, i32 1>, %0 ], [ %36, %8 ]
%11 = add <2 x i32> %10, <i32 2, i32 2>
%12 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %9
%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 = getelementptr inbounds double, double* %12, i64 2
%15 = bitcast double* %14 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %15
%16 = sitofp <2 x i32> %10 to <2 x double>
%17 = sitofp <2 x i32> %11 to <2 x double>
%18 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %9
%19 = bitcast double* %18 to <2 x double>*
store <2 x double> %16, <2 x double>* %19
%20 = getelementptr inbounds double, double* %18, i64 2
%21 = bitcast double* %20 to <2 x double>*
store <2 x double> %17, <2 x double>* %21
%22 = or i64 %9, 4
%23 = add <2 x i32> %10, <i32 4, i32 4>
%24 = add <2 x i32> %10, <i32 6, i32 6>
%25 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %22
%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 = sitofp <2 x i32> %23 to <2 x double>
%30 = sitofp <2 x i32> %24 to <2 x double>
%31 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %22
%32 = bitcast double* %31 to <2 x double>*
store <2 x double> %29, <2 x double>* %32
%33 = getelementptr inbounds double, double* %31, i64 2
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> %30, <2 x double>* %34
%35 = add nuw nsw i64 %9, 8
%36 = add <2 x i32> %10, <i32 8, i32 8>
%37 = icmp eq i64 %35, 1024
br i1 %37, label %38, label %8
38: ; preds = %8, %38
%39 = phi i64 [ %81, %38 ], [ 0, %8 ]
%40 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %39
%41 = bitcast double* %40 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = getelementptr inbounds double, double* %40, i64 2
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %39
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = getelementptr inbounds double, double* %46, i64 2
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fadd <2 x double> %42, %48
%53 = fadd <2 x double> %45, %51
%54 = fadd <2 x double> %52, <double 1.000000e+00, double 1.000000e+00>
%55 = fadd <2 x double> %53, <double 1.000000e+00, double 1.000000e+00>
%56 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %39
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %54, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> %55, <2 x double>* %59
%60 = or i64 %39, 4
%61 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %60
%62 = bitcast double* %61 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = getelementptr inbounds double, double* %61, i64 2
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %60
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = getelementptr inbounds double, double* %67, i64 2
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = fadd <2 x double> %63, %69
%74 = fadd <2 x double> %66, %72
%75 = fadd <2 x double> %73, <double 1.000000e+00, double 1.000000e+00>
%76 = fadd <2 x double> %74, <double 1.000000e+00, double 1.000000e+00>
%77 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %60
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> %75, <2 x double>* %78
%79 = getelementptr inbounds double, double* %77, i64 2
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> %76, <2 x double>* %80
%81 = add nuw nsw i64 %39, 8
%82 = icmp eq i64 %81, 128
br i1 %82, label %363, label %38
83: ; preds = %363, %83
%84 = phi i64 [ %127, %83 ], [ 0, %363 ]
%85 = add nuw nsw i64 %84, 256
%86 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %85
%87 = bitcast double* %86 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = getelementptr inbounds double, double* %86, i64 2
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %85
%93 = bitcast double* %92 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = getelementptr inbounds double, double* %92, i64 2
%96 = bitcast double* %95 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = fadd <2 x double> %88, %94
%99 = fadd <2 x double> %91, %97
%100 = fadd <2 x double> %98, <double 1.000000e+00, double 1.000000e+00>
%101 = fadd <2 x double> %99, <double 1.000000e+00, double 1.000000e+00>
%102 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %85
%103 = bitcast double* %102 to <2 x double>*
store <2 x double> %100, <2 x double>* %103
%104 = getelementptr inbounds double, double* %102, i64 2
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> %101, <2 x double>* %105
%106 = add nuw nsw i64 %84, 260
%107 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %106
%108 = bitcast double* %107 to <2 x double>*
%109 = load <2 x double>, <2 x double>* %108
%110 = getelementptr inbounds double, double* %107, i64 2
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %106
%114 = bitcast double* %113 to <2 x double>*
%115 = load <2 x double>, <2 x double>* %114
%116 = getelementptr inbounds double, double* %113, i64 2
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = fadd <2 x double> %109, %115
%120 = fadd <2 x double> %112, %118
%121 = fadd <2 x double> %119, <double 1.000000e+00, double 1.000000e+00>
%122 = fadd <2 x double> %120, <double 1.000000e+00, double 1.000000e+00>
%123 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %106
%124 = bitcast double* %123 to <2 x double>*
store <2 x double> %121, <2 x double>* %124
%125 = getelementptr inbounds double, double* %123, i64 2
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %122, <2 x double>* %126
%127 = add nuw nsw i64 %84, 8
%128 = icmp eq i64 %127, 128
br i1 %128, label %129, label %83
129: ; preds = %83, %129
%130 = phi i64 [ %173, %129 ], [ 0, %83 ]
%131 = add nuw nsw i64 %130, 384
%132 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %131
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %132, i64 2
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %131
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = getelementptr inbounds double, double* %138, i64 2
%142 = bitcast double* %141 to <2 x double>*
%143 = load <2 x double>, <2 x double>* %142
%144 = fadd <2 x double> %134, %140
%145 = fadd <2 x double> %137, %143
%146 = fadd <2 x double> %144, <double 1.000000e+00, double 1.000000e+00>
%147 = fadd <2 x double> %145, <double 1.000000e+00, double 1.000000e+00>
%148 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %131
%149 = bitcast double* %148 to <2 x double>*
store <2 x double> %146, <2 x double>* %149
%150 = getelementptr inbounds double, double* %148, i64 2
%151 = bitcast double* %150 to <2 x double>*
store <2 x double> %147, <2 x double>* %151
%152 = add nuw nsw i64 %130, 388
%153 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %152
%154 = bitcast double* %153 to <2 x double>*
%155 = load <2 x double>, <2 x double>* %154
%156 = getelementptr inbounds double, double* %153, i64 2
%157 = bitcast double* %156 to <2 x double>*
%158 = load <2 x double>, <2 x double>* %157
%159 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %152
%160 = bitcast double* %159 to <2 x double>*
%161 = load <2 x double>, <2 x double>* %160
%162 = getelementptr inbounds double, double* %159, i64 2
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = fadd <2 x double> %155, %161
%166 = fadd <2 x double> %158, %164
%167 = fadd <2 x double> %165, <double 1.000000e+00, double 1.000000e+00>
%168 = fadd <2 x double> %166, <double 1.000000e+00, double 1.000000e+00>
%169 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %152
%170 = bitcast double* %169 to <2 x double>*
store <2 x double> %167, <2 x double>* %170
%171 = getelementptr inbounds double, double* %169, i64 2
%172 = bitcast double* %171 to <2 x double>*
store <2 x double> %168, <2 x double>* %172
%173 = add nuw nsw i64 %130, 8
%174 = icmp eq i64 %173, 128
br i1 %174, label %175, label %129
175: ; preds = %129, %175
%176 = phi i64 [ %219, %175 ], [ 0, %129 ]
%177 = add nuw nsw i64 %176, 512
%178 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %177
%179 = bitcast double* %178 to <2 x double>*
%180 = load <2 x double>, <2 x double>* %179
%181 = getelementptr inbounds double, double* %178, i64 2
%182 = bitcast double* %181 to <2 x double>*
%183 = load <2 x double>, <2 x double>* %182
%184 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %177
%185 = bitcast double* %184 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = getelementptr inbounds double, double* %184, i64 2
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = fadd <2 x double> %180, %186
%191 = fadd <2 x double> %183, %189
%192 = fadd <2 x double> %190, <double 1.000000e+00, double 1.000000e+00>
%193 = fadd <2 x double> %191, <double 1.000000e+00, double 1.000000e+00>
%194 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %177
%195 = bitcast double* %194 to <2 x double>*
store <2 x double> %192, <2 x double>* %195
%196 = getelementptr inbounds double, double* %194, i64 2
%197 = bitcast double* %196 to <2 x double>*
store <2 x double> %193, <2 x double>* %197
%198 = add nuw nsw i64 %176, 516
%199 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %198
%200 = bitcast double* %199 to <2 x double>*
%201 = load <2 x double>, <2 x double>* %200
%202 = getelementptr inbounds double, double* %199, i64 2
%203 = bitcast double* %202 to <2 x double>*
%204 = load <2 x double>, <2 x double>* %203
%205 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %198
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %205, i64 2
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fadd <2 x double> %201, %207
%212 = fadd <2 x double> %204, %210
%213 = fadd <2 x double> %211, <double 1.000000e+00, double 1.000000e+00>
%214 = fadd <2 x double> %212, <double 1.000000e+00, double 1.000000e+00>
%215 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %198
%216 = bitcast double* %215 to <2 x double>*
store <2 x double> %213, <2 x double>* %216
%217 = getelementptr inbounds double, double* %215, i64 2
%218 = bitcast double* %217 to <2 x double>*
store <2 x double> %214, <2 x double>* %218
%219 = add nuw nsw i64 %176, 8
%220 = icmp eq i64 %219, 128
br i1 %220, label %221, label %175
221: ; preds = %175, %221
%222 = phi i64 [ %265, %221 ], [ 0, %175 ]
%223 = add nuw nsw i64 %222, 640
%224 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %223
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %224, i64 2
%228 = bitcast double* %227 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %223
%231 = bitcast double* %230 to <2 x double>*
%232 = load <2 x double>, <2 x double>* %231
%233 = getelementptr inbounds double, double* %230, i64 2
%234 = bitcast double* %233 to <2 x double>*
%235 = load <2 x double>, <2 x double>* %234
%236 = fadd <2 x double> %226, %232
%237 = fadd <2 x double> %229, %235
%238 = fadd <2 x double> %236, <double 1.000000e+00, double 1.000000e+00>
%239 = fadd <2 x double> %237, <double 1.000000e+00, double 1.000000e+00>
%240 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %223
%241 = bitcast double* %240 to <2 x double>*
store <2 x double> %238, <2 x double>* %241
%242 = getelementptr inbounds double, double* %240, i64 2
%243 = bitcast double* %242 to <2 x double>*
store <2 x double> %239, <2 x double>* %243
%244 = add nuw nsw i64 %222, 644
%245 = getelementptr inbounds [1024 x double], [1024 x double]* %3, 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 [1024 x double], [1024 x double]* %4, 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 = fadd <2 x double> %257, <double 1.000000e+00, double 1.000000e+00>
%260 = fadd <2 x double> %258, <double 1.000000e+00, double 1.000000e+00>
%261 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %244
%262 = bitcast double* %261 to <2 x double>*
store <2 x double> %259, <2 x double>* %262
%263 = getelementptr inbounds double, double* %261, i64 2
%264 = bitcast double* %263 to <2 x double>*
store <2 x double> %260, <2 x double>* %264
%265 = add nuw nsw i64 %222, 8
%266 = icmp eq i64 %265, 128
br i1 %266, label %267, label %221
267: ; preds = %221, %267
%268 = phi i64 [ %311, %267 ], [ 0, %221 ]
%269 = add nuw nsw i64 %268, 768
%270 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %269
%271 = bitcast double* %270 to <2 x double>*
%272 = load <2 x double>, <2 x double>* %271
%273 = getelementptr inbounds double, double* %270, i64 2
%274 = bitcast double* %273 to <2 x double>*
%275 = load <2 x double>, <2 x double>* %274
%276 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %269
%277 = bitcast double* %276 to <2 x double>*
%278 = load <2 x double>, <2 x double>* %277
%279 = getelementptr inbounds double, double* %276, i64 2
%280 = bitcast double* %279 to <2 x double>*
%281 = load <2 x double>, <2 x double>* %280
%282 = fadd <2 x double> %272, %278
%283 = fadd <2 x double> %275, %281
%284 = fadd <2 x double> %282, <double 1.000000e+00, double 1.000000e+00>
%285 = fadd <2 x double> %283, <double 1.000000e+00, double 1.000000e+00>
%286 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %269
%287 = bitcast double* %286 to <2 x double>*
store <2 x double> %284, <2 x double>* %287
%288 = getelementptr inbounds double, double* %286, i64 2
%289 = bitcast double* %288 to <2 x double>*
store <2 x double> %285, <2 x double>* %289
%290 = add nuw nsw i64 %268, 772
%291 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %290
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = getelementptr inbounds double, double* %291, i64 2
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %290
%298 = bitcast double* %297 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = getelementptr inbounds double, double* %297, i64 2
%301 = bitcast double* %300 to <2 x double>*
%302 = load <2 x double>, <2 x double>* %301
%303 = fadd <2 x double> %293, %299
%304 = fadd <2 x double> %296, %302
%305 = fadd <2 x double> %303, <double 1.000000e+00, double 1.000000e+00>
%306 = fadd <2 x double> %304, <double 1.000000e+00, double 1.000000e+00>
%307 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %290
%308 = bitcast double* %307 to <2 x double>*
store <2 x double> %305, <2 x double>* %308
%309 = getelementptr inbounds double, double* %307, i64 2
%310 = bitcast double* %309 to <2 x double>*
store <2 x double> %306, <2 x double>* %310
%311 = add nuw nsw i64 %268, 8
%312 = icmp eq i64 %311, 128
br i1 %312, label %313, label %267
313: ; preds = %267, %313
%314 = phi i64 [ %357, %313 ], [ 0, %267 ]
%315 = add nuw nsw i64 %314, 896
%316 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %315
%317 = bitcast double* %316 to <2 x double>*
%318 = load <2 x double>, <2 x double>* %317
%319 = getelementptr inbounds double, double* %316, i64 2
%320 = bitcast double* %319 to <2 x double>*
%321 = load <2 x double>, <2 x double>* %320
%322 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %315
%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 = fadd <2 x double> %318, %324
%329 = fadd <2 x double> %321, %327
%330 = fadd <2 x double> %328, <double 1.000000e+00, double 1.000000e+00>
%331 = fadd <2 x double> %329, <double 1.000000e+00, double 1.000000e+00>
%332 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %315
%333 = bitcast double* %332 to <2 x double>*
store <2 x double> %330, <2 x double>* %333
%334 = getelementptr inbounds double, double* %332, i64 2
%335 = bitcast double* %334 to <2 x double>*
store <2 x double> %331, <2 x double>* %335
%336 = add nuw nsw i64 %314, 900
%337 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %336
%338 = bitcast double* %337 to <2 x double>*
%339 = load <2 x double>, <2 x double>* %338
%340 = getelementptr inbounds double, double* %337, i64 2
%341 = bitcast double* %340 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %336
%344 = bitcast double* %343 to <2 x double>*
%345 = load <2 x double>, <2 x double>* %344
%346 = getelementptr inbounds double, double* %343, i64 2
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = fadd <2 x double> %339, %345
%350 = fadd <2 x double> %342, %348
%351 = fadd <2 x double> %349, <double 1.000000e+00, double 1.000000e+00>
%352 = fadd <2 x double> %350, <double 1.000000e+00, double 1.000000e+00>
%353 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %336
%354 = bitcast double* %353 to <2 x double>*
store <2 x double> %351, <2 x double>* %354
%355 = getelementptr inbounds double, double* %353, i64 2
%356 = bitcast double* %355 to <2 x double>*
store <2 x double> %352, <2 x double>* %356
%357 = add nuw nsw i64 %314, 8
%358 = icmp eq i64 %357, 128
br i1 %358, label %359, label %313
359: ; preds = %313, %417
%360 = phi i64 [ %422, %417 ], [ 0, %313 ]
%361 = phi i8* [ getelementptr inbounds ([19 x i8], [19 x i8]* @str.24, i64 0, i64 0), %417 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @str, i64 0, i64 0), %313 ]
%362 = phi i32 [ %420, %417 ], [ 0, %313 ]
br label %409
363: ; preds = %38, %363
%364 = phi i64 [ %407, %363 ], [ 0, %38 ]
%365 = add nuw nsw i64 %364, 128
%366 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %365
%367 = bitcast double* %366 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = getelementptr inbounds double, double* %366, i64 2
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %365
%373 = bitcast double* %372 to <2 x double>*
%374 = load <2 x double>, <2 x double>* %373
%375 = getelementptr inbounds double, double* %372, i64 2
%376 = bitcast double* %375 to <2 x double>*
%377 = load <2 x double>, <2 x double>* %376
%378 = fadd <2 x double> %368, %374
%379 = fadd <2 x double> %371, %377
%380 = fadd <2 x double> %378, <double 1.000000e+00, double 1.000000e+00>
%381 = fadd <2 x double> %379, <double 1.000000e+00, double 1.000000e+00>
%382 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %365
%383 = bitcast double* %382 to <2 x double>*
store <2 x double> %380, <2 x double>* %383
%384 = getelementptr inbounds double, double* %382, i64 2
%385 = bitcast double* %384 to <2 x double>*
store <2 x double> %381, <2 x double>* %385
%386 = add nuw nsw i64 %364, 132
%387 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %386
%388 = bitcast double* %387 to <2 x double>*
%389 = load <2 x double>, <2 x double>* %388
%390 = getelementptr inbounds double, double* %387, i64 2
%391 = bitcast double* %390 to <2 x double>*
%392 = load <2 x double>, <2 x double>* %391
%393 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %386
%394 = bitcast double* %393 to <2 x double>*
%395 = load <2 x double>, <2 x double>* %394
%396 = getelementptr inbounds double, double* %393, i64 2
%397 = bitcast double* %396 to <2 x double>*
%398 = load <2 x double>, <2 x double>* %397
%399 = fadd <2 x double> %389, %395
%400 = fadd <2 x double> %392, %398
%401 = fadd <2 x double> %399, <double 1.000000e+00, double 1.000000e+00>
%402 = fadd <2 x double> %400, <double 1.000000e+00, double 1.000000e+00>
%403 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %386
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> %401, <2 x double>* %404
%405 = getelementptr inbounds double, double* %403, i64 2
%406 = bitcast double* %405 to <2 x double>*
store <2 x double> %402, <2 x double>* %406
%407 = add nuw nsw i64 %364, 8
%408 = icmp eq i64 %407, 128
br i1 %408, label %83, label %363
409: ; preds = %359, %425
%410 = phi i64 [ %426, %425 ], [ %360, %359 ]
%411 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %410
%412 = load double, double* %411
%413 = trunc i64 %410 to i32
%414 = add i32 %413, 2
%415 = sitofp i32 %414 to double
%416 = fcmp une double %412, %415
br i1 %416, label %417, label %425
417: ; preds = %409
%418 = trunc i64 %410 to i32
%419 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %418, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %415, double %412)
%420 = add nuw nsw i32 %362, 1
%421 = icmp ugt i32 %362, 10
%422 = add nuw nsw i64 %410, 1
%423 = icmp eq i64 %422, 1024
%424 = select i1 %421, i1 true, i1 %423
br i1 %424, label %428, label %359
425: ; preds = %409
%426 = add nuw nsw i64 %410, 1
%427 = icmp eq i64 %426, 1024
br i1 %427, label %428, label %409
428: ; preds = %417, %425
%429 = phi i8* [ %361, %425 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @str.24, i64 0, i64 0), %417 ]
%430 = tail call i32 @puts(i8* dereferenceable(1) %429)
br label %431
431: ; preds = %431, %428
%432 = phi i64 [ 0, %428 ], [ %458, %431 ]
%433 = phi <2 x i32> [ <i32 0, i32 1>, %428 ], [ %459, %431 ]
%434 = add <2 x i32> %433, <i32 2, i32 2>
%435 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %432
%436 = bitcast double* %435 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %436
%437 = getelementptr inbounds double, double* %435, i64 2
%438 = bitcast double* %437 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %438
%439 = sitofp <2 x i32> %433 to <2 x double>
%440 = sitofp <2 x i32> %434 to <2 x double>
%441 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %432
%442 = bitcast double* %441 to <2 x double>*
store <2 x double> %439, <2 x double>* %442
%443 = getelementptr inbounds double, double* %441, i64 2
%444 = bitcast double* %443 to <2 x double>*
store <2 x double> %440, <2 x double>* %444
%445 = or i64 %432, 4
%446 = add <2 x i32> %433, <i32 4, i32 4>
%447 = add <2 x i32> %433, <i32 6, i32 6>
%448 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %445
%449 = bitcast double* %448 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %449
%450 = getelementptr inbounds double, double* %448, i64 2
%451 = bitcast double* %450 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %451
%452 = sitofp <2 x i32> %446 to <2 x double>
%453 = sitofp <2 x i32> %447 to <2 x double>
%454 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %445
%455 = bitcast double* %454 to <2 x double>*
store <2 x double> %452, <2 x double>* %455
%456 = getelementptr inbounds double, double* %454, i64 2
%457 = bitcast double* %456 to <2 x double>*
store <2 x double> %453, <2 x double>* %457
%458 = add nuw nsw i64 %432, 8
%459 = add <2 x i32> %433, <i32 8, i32 8>
%460 = icmp eq i64 %458, 1024
br i1 %460, label %461, label %431
461: ; preds = %431, %461
%462 = phi i64 [ %504, %461 ], [ 0, %431 ]
%463 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %462
%464 = bitcast double* %463 to <2 x double>*
%465 = load <2 x double>, <2 x double>* %464
%466 = getelementptr inbounds double, double* %463, i64 2
%467 = bitcast double* %466 to <2 x double>*
%468 = load <2 x double>, <2 x double>* %467
%469 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %462
%470 = bitcast double* %469 to <2 x double>*
%471 = load <2 x double>, <2 x double>* %470
%472 = getelementptr inbounds double, double* %469, i64 2
%473 = bitcast double* %472 to <2 x double>*
%474 = load <2 x double>, <2 x double>* %473
%475 = fadd <2 x double> %465, %471
%476 = fadd <2 x double> %468, %474
%477 = fadd <2 x double> %475, <double 1.000000e+00, double 1.000000e+00>
%478 = fadd <2 x double> %476, <double 1.000000e+00, double 1.000000e+00>
%479 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %462
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %477, <2 x double>* %480
%481 = getelementptr inbounds double, double* %479, i64 2
%482 = bitcast double* %481 to <2 x double>*
store <2 x double> %478, <2 x double>* %482
%483 = or i64 %462, 4
%484 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %483
%491 = bitcast double* %490 to <2 x double>*
%492 = load <2 x double>, <2 x double>* %491
%493 = getelementptr inbounds double, double* %490, i64 2
%494 = bitcast double* %493 to <2 x double>*
%495 = load <2 x double>, <2 x double>* %494
%496 = fadd <2 x double> %486, %492
%497 = fadd <2 x double> %489, %495
%498 = fadd <2 x double> %496, <double 1.000000e+00, double 1.000000e+00>
%499 = fadd <2 x double> %497, <double 1.000000e+00, double 1.000000e+00>
%500 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %483
%501 = bitcast double* %500 to <2 x double>*
store <2 x double> %498, <2 x double>* %501
%502 = getelementptr inbounds double, double* %500, i64 2
%503 = bitcast double* %502 to <2 x double>*
store <2 x double> %499, <2 x double>* %503
%504 = add nuw nsw i64 %462, 8
%505 = icmp eq i64 %504, 128
br i1 %505, label %786, label %461
506: ; preds = %786, %506
%507 = phi i64 [ %550, %506 ], [ 0, %786 ]
%508 = add nuw nsw i64 %507, 256
%509 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %508
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = getelementptr inbounds double, double* %509, i64 2
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %508
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = getelementptr inbounds double, double* %515, i64 2
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = fadd <2 x double> %511, %517
%522 = fadd <2 x double> %514, %520
%523 = fadd <2 x double> %521, <double 1.000000e+00, double 1.000000e+00>
%524 = fadd <2 x double> %522, <double 1.000000e+00, double 1.000000e+00>
%525 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %508
%526 = bitcast double* %525 to <2 x double>*
store <2 x double> %523, <2 x double>* %526
%527 = getelementptr inbounds double, double* %525, i64 2
%528 = bitcast double* %527 to <2 x double>*
store <2 x double> %524, <2 x double>* %528
%529 = add nuw nsw i64 %507, 260
%530 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %529
%531 = bitcast double* %530 to <2 x double>*
%532 = load <2 x double>, <2 x double>* %531
%533 = getelementptr inbounds double, double* %530, i64 2
%534 = bitcast double* %533 to <2 x double>*
%535 = load <2 x double>, <2 x double>* %534
%536 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %529
%537 = bitcast double* %536 to <2 x double>*
%538 = load <2 x double>, <2 x double>* %537
%539 = getelementptr inbounds double, double* %536, i64 2
%540 = bitcast double* %539 to <2 x double>*
%541 = load <2 x double>, <2 x double>* %540
%542 = fadd <2 x double> %532, %538
%543 = fadd <2 x double> %535, %541
%544 = fadd <2 x double> %542, <double 1.000000e+00, double 1.000000e+00>
%545 = fadd <2 x double> %543, <double 1.000000e+00, double 1.000000e+00>
%546 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %529
%547 = bitcast double* %546 to <2 x double>*
store <2 x double> %544, <2 x double>* %547
%548 = getelementptr inbounds double, double* %546, i64 2
%549 = bitcast double* %548 to <2 x double>*
store <2 x double> %545, <2 x double>* %549
%550 = add nuw nsw i64 %507, 8
%551 = icmp eq i64 %550, 128
br i1 %551, label %552, label %506
552: ; preds = %506, %552
%553 = phi i64 [ %596, %552 ], [ 0, %506 ]
%554 = add nuw nsw i64 %553, 384
%555 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %554
%556 = bitcast double* %555 to <2 x double>*
%557 = load <2 x double>, <2 x double>* %556
%558 = getelementptr inbounds double, double* %555, i64 2
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %554
%562 = bitcast double* %561 to <2 x double>*
%563 = load <2 x double>, <2 x double>* %562
%564 = getelementptr inbounds double, double* %561, i64 2
%565 = bitcast double* %564 to <2 x double>*
%566 = load <2 x double>, <2 x double>* %565
%567 = fadd <2 x double> %557, %563
%568 = fadd <2 x double> %560, %566
%569 = fadd <2 x double> %567, <double 1.000000e+00, double 1.000000e+00>
%570 = fadd <2 x double> %568, <double 1.000000e+00, double 1.000000e+00>
%571 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %554
%572 = bitcast double* %571 to <2 x double>*
store <2 x double> %569, <2 x double>* %572
%573 = getelementptr inbounds double, double* %571, i64 2
%574 = bitcast double* %573 to <2 x double>*
store <2 x double> %570, <2 x double>* %574
%575 = add nuw nsw i64 %553, 388
%576 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %575
%577 = bitcast double* %576 to <2 x double>*
%578 = load <2 x double>, <2 x double>* %577
%579 = getelementptr inbounds double, double* %576, i64 2
%580 = bitcast double* %579 to <2 x double>*
%581 = load <2 x double>, <2 x double>* %580
%582 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %575
%583 = bitcast double* %582 to <2 x double>*
%584 = load <2 x double>, <2 x double>* %583
%585 = getelementptr inbounds double, double* %582, i64 2
%586 = bitcast double* %585 to <2 x double>*
%587 = load <2 x double>, <2 x double>* %586
%588 = fadd <2 x double> %578, %584
%589 = fadd <2 x double> %581, %587
%590 = fadd <2 x double> %588, <double 1.000000e+00, double 1.000000e+00>
%591 = fadd <2 x double> %589, <double 1.000000e+00, double 1.000000e+00>
%592 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %575
%593 = bitcast double* %592 to <2 x double>*
store <2 x double> %590, <2 x double>* %593
%594 = getelementptr inbounds double, double* %592, i64 2
%595 = bitcast double* %594 to <2 x double>*
store <2 x double> %591, <2 x double>* %595
%596 = add nuw nsw i64 %553, 8
%597 = icmp eq i64 %596, 128
br i1 %597, label %598, label %552
598: ; preds = %552, %598
%599 = phi i64 [ %642, %598 ], [ 0, %552 ]
%600 = add nuw nsw i64 %599, 512
%601 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %600
%602 = bitcast double* %601 to <2 x double>*
%603 = load <2 x double>, <2 x double>* %602
%604 = getelementptr inbounds double, double* %601, i64 2
%605 = bitcast double* %604 to <2 x double>*
%606 = load <2 x double>, <2 x double>* %605
%607 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %600
%608 = bitcast double* %607 to <2 x double>*
%609 = load <2 x double>, <2 x double>* %608
%610 = getelementptr inbounds double, double* %607, i64 2
%611 = bitcast double* %610 to <2 x double>*
%612 = load <2 x double>, <2 x double>* %611
%613 = fadd <2 x double> %603, %609
%614 = fadd <2 x double> %606, %612
%615 = fadd <2 x double> %613, <double 1.000000e+00, double 1.000000e+00>
%616 = fadd <2 x double> %614, <double 1.000000e+00, double 1.000000e+00>
%617 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %600
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %615, <2 x double>* %618
%619 = getelementptr inbounds double, double* %617, i64 2
%620 = bitcast double* %619 to <2 x double>*
store <2 x double> %616, <2 x double>* %620
%621 = add nuw nsw i64 %599, 516
%622 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %621
%623 = bitcast double* %622 to <2 x double>*
%624 = load <2 x double>, <2 x double>* %623
%625 = getelementptr inbounds double, double* %622, i64 2
%626 = bitcast double* %625 to <2 x double>*
%627 = load <2 x double>, <2 x double>* %626
%628 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %621
%629 = bitcast double* %628 to <2 x double>*
%630 = load <2 x double>, <2 x double>* %629
%631 = getelementptr inbounds double, double* %628, i64 2
%632 = bitcast double* %631 to <2 x double>*
%633 = load <2 x double>, <2 x double>* %632
%634 = fadd <2 x double> %624, %630
%635 = fadd <2 x double> %627, %633
%636 = fadd <2 x double> %634, <double 1.000000e+00, double 1.000000e+00>
%637 = fadd <2 x double> %635, <double 1.000000e+00, double 1.000000e+00>
%638 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %621
%639 = bitcast double* %638 to <2 x double>*
store <2 x double> %636, <2 x double>* %639
%640 = getelementptr inbounds double, double* %638, i64 2
%641 = bitcast double* %640 to <2 x double>*
store <2 x double> %637, <2 x double>* %641
%642 = add nuw nsw i64 %599, 8
%643 = icmp eq i64 %642, 128
br i1 %643, label %644, label %598
644: ; preds = %598, %644
%645 = phi i64 [ %688, %644 ], [ 0, %598 ]
%646 = add nuw nsw i64 %645, 640
%647 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %646
%648 = bitcast double* %647 to <2 x double>*
%649 = load <2 x double>, <2 x double>* %648
%650 = getelementptr inbounds double, double* %647, i64 2
%651 = bitcast double* %650 to <2 x double>*
%652 = load <2 x double>, <2 x double>* %651
%653 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %646
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %653, i64 2
%657 = bitcast double* %656 to <2 x double>*
%658 = load <2 x double>, <2 x double>* %657
%659 = fadd <2 x double> %649, %655
%660 = fadd <2 x double> %652, %658
%661 = fadd <2 x double> %659, <double 1.000000e+00, double 1.000000e+00>
%662 = fadd <2 x double> %660, <double 1.000000e+00, double 1.000000e+00>
%663 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %646
%664 = bitcast double* %663 to <2 x double>*
store <2 x double> %661, <2 x double>* %664
%665 = getelementptr inbounds double, double* %663, i64 2
%666 = bitcast double* %665 to <2 x double>*
store <2 x double> %662, <2 x double>* %666
%667 = add nuw nsw i64 %645, 644
%668 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %667
%669 = bitcast double* %668 to <2 x double>*
%670 = load <2 x double>, <2 x double>* %669
%671 = getelementptr inbounds double, double* %668, i64 2
%672 = bitcast double* %671 to <2 x double>*
%673 = load <2 x double>, <2 x double>* %672
%674 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %667
%675 = bitcast double* %674 to <2 x double>*
%676 = load <2 x double>, <2 x double>* %675
%677 = getelementptr inbounds double, double* %674, i64 2
%678 = bitcast double* %677 to <2 x double>*
%679 = load <2 x double>, <2 x double>* %678
%680 = fadd <2 x double> %670, %676
%681 = fadd <2 x double> %673, %679
%682 = fadd <2 x double> %680, <double 1.000000e+00, double 1.000000e+00>
%683 = fadd <2 x double> %681, <double 1.000000e+00, double 1.000000e+00>
%684 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %667
%685 = bitcast double* %684 to <2 x double>*
store <2 x double> %682, <2 x double>* %685
%686 = getelementptr inbounds double, double* %684, i64 2
%687 = bitcast double* %686 to <2 x double>*
store <2 x double> %683, <2 x double>* %687
%688 = add nuw nsw i64 %645, 8
%689 = icmp eq i64 %688, 128
br i1 %689, label %690, label %644
690: ; preds = %644, %690
%691 = phi i64 [ %734, %690 ], [ 0, %644 ]
%692 = add nuw nsw i64 %691, 768
%693 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %692
%694 = bitcast double* %693 to <2 x double>*
%695 = load <2 x double>, <2 x double>* %694
%696 = getelementptr inbounds double, double* %693, i64 2
%697 = bitcast double* %696 to <2 x double>*
%698 = load <2 x double>, <2 x double>* %697
%699 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %692
%700 = bitcast double* %699 to <2 x double>*
%701 = load <2 x double>, <2 x double>* %700
%702 = getelementptr inbounds double, double* %699, i64 2
%703 = bitcast double* %702 to <2 x double>*
%704 = load <2 x double>, <2 x double>* %703
%705 = fadd <2 x double> %695, %701
%706 = fadd <2 x double> %698, %704
%707 = fadd <2 x double> %705, <double 1.000000e+00, double 1.000000e+00>
%708 = fadd <2 x double> %706, <double 1.000000e+00, double 1.000000e+00>
%709 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %692
%710 = bitcast double* %709 to <2 x double>*
store <2 x double> %707, <2 x double>* %710
%711 = getelementptr inbounds double, double* %709, i64 2
%712 = bitcast double* %711 to <2 x double>*
store <2 x double> %708, <2 x double>* %712
%713 = add nuw nsw i64 %691, 772
%714 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %713
%715 = bitcast double* %714 to <2 x double>*
%716 = load <2 x double>, <2 x double>* %715
%717 = getelementptr inbounds double, double* %714, i64 2
%718 = bitcast double* %717 to <2 x double>*
%719 = load <2 x double>, <2 x double>* %718
%720 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %713
%721 = bitcast double* %720 to <2 x double>*
%722 = load <2 x double>, <2 x double>* %721
%723 = getelementptr inbounds double, double* %720, i64 2
%724 = bitcast double* %723 to <2 x double>*
%725 = load <2 x double>, <2 x double>* %724
%726 = fadd <2 x double> %716, %722
%727 = fadd <2 x double> %719, %725
%728 = fadd <2 x double> %726, <double 1.000000e+00, double 1.000000e+00>
%729 = fadd <2 x double> %727, <double 1.000000e+00, double 1.000000e+00>
%730 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %713
%731 = bitcast double* %730 to <2 x double>*
store <2 x double> %728, <2 x double>* %731
%732 = getelementptr inbounds double, double* %730, i64 2
%733 = bitcast double* %732 to <2 x double>*
store <2 x double> %729, <2 x double>* %733
%734 = add nuw nsw i64 %691, 8
%735 = icmp eq i64 %734, 128
br i1 %735, label %736, label %690
736: ; preds = %690, %736
%737 = phi i64 [ %780, %736 ], [ 0, %690 ]
%738 = add nuw nsw i64 %737, 896
%739 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %738
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = getelementptr inbounds double, double* %739, i64 2
%743 = bitcast double* %742 to <2 x double>*
%744 = load <2 x double>, <2 x double>* %743
%745 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %738
%746 = bitcast double* %745 to <2 x double>*
%747 = load <2 x double>, <2 x double>* %746
%748 = getelementptr inbounds double, double* %745, i64 2
%749 = bitcast double* %748 to <2 x double>*
%750 = load <2 x double>, <2 x double>* %749
%751 = fadd <2 x double> %741, %747
%752 = fadd <2 x double> %744, %750
%753 = fadd <2 x double> %751, <double 1.000000e+00, double 1.000000e+00>
%754 = fadd <2 x double> %752, <double 1.000000e+00, double 1.000000e+00>
%755 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %738
%756 = bitcast double* %755 to <2 x double>*
store <2 x double> %753, <2 x double>* %756
%757 = getelementptr inbounds double, double* %755, i64 2
%758 = bitcast double* %757 to <2 x double>*
store <2 x double> %754, <2 x double>* %758
%759 = add nuw nsw i64 %737, 900
%760 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %759
%761 = bitcast double* %760 to <2 x double>*
%762 = load <2 x double>, <2 x double>* %761
%763 = getelementptr inbounds double, double* %760, i64 2
%764 = bitcast double* %763 to <2 x double>*
%765 = load <2 x double>, <2 x double>* %764
%766 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %759
%767 = bitcast double* %766 to <2 x double>*
%768 = load <2 x double>, <2 x double>* %767
%769 = getelementptr inbounds double, double* %766, i64 2
%770 = bitcast double* %769 to <2 x double>*
%771 = load <2 x double>, <2 x double>* %770
%772 = fadd <2 x double> %762, %768
%773 = fadd <2 x double> %765, %771
%774 = fadd <2 x double> %772, <double 1.000000e+00, double 1.000000e+00>
%775 = fadd <2 x double> %773, <double 1.000000e+00, double 1.000000e+00>
%776 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %759
%777 = bitcast double* %776 to <2 x double>*
store <2 x double> %774, <2 x double>* %777
%778 = getelementptr inbounds double, double* %776, i64 2
%779 = bitcast double* %778 to <2 x double>*
store <2 x double> %775, <2 x double>* %779
%780 = add nuw nsw i64 %737, 8
%781 = icmp eq i64 %780, 128
br i1 %781, label %782, label %736
782: ; preds = %736, %840
%783 = phi i64 [ %845, %840 ], [ 0, %736 ]
%784 = phi i8* [ getelementptr inbounds ([19 x i8], [19 x i8]* @str.23, i64 0, i64 0), %840 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @str.14, i64 0, i64 0), %736 ]
%785 = phi i32 [ %843, %840 ], [ 0, %736 ]
br label %832
786: ; preds = %461, %786
%787 = phi i64 [ %830, %786 ], [ 0, %461 ]
%788 = add nuw nsw i64 %787, 128
%789 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %788
%790 = bitcast double* %789 to <2 x double>*
%791 = load <2 x double>, <2 x double>* %790
%792 = getelementptr inbounds double, double* %789, i64 2
%793 = bitcast double* %792 to <2 x double>*
%794 = load <2 x double>, <2 x double>* %793
%795 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %788
%796 = bitcast double* %795 to <2 x double>*
%797 = load <2 x double>, <2 x double>* %796
%798 = getelementptr inbounds double, double* %795, i64 2
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = fadd <2 x double> %791, %797
%802 = fadd <2 x double> %794, %800
%803 = fadd <2 x double> %801, <double 1.000000e+00, double 1.000000e+00>
%804 = fadd <2 x double> %802, <double 1.000000e+00, double 1.000000e+00>
%805 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %788
%806 = bitcast double* %805 to <2 x double>*
store <2 x double> %803, <2 x double>* %806
%807 = getelementptr inbounds double, double* %805, i64 2
%808 = bitcast double* %807 to <2 x double>*
store <2 x double> %804, <2 x double>* %808
%809 = add nuw nsw i64 %787, 132
%810 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %809
%811 = bitcast double* %810 to <2 x double>*
%812 = load <2 x double>, <2 x double>* %811
%813 = getelementptr inbounds double, double* %810, i64 2
%814 = bitcast double* %813 to <2 x double>*
%815 = load <2 x double>, <2 x double>* %814
%816 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %809
%817 = bitcast double* %816 to <2 x double>*
%818 = load <2 x double>, <2 x double>* %817
%819 = getelementptr inbounds double, double* %816, i64 2
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = fadd <2 x double> %812, %818
%823 = fadd <2 x double> %815, %821
%824 = fadd <2 x double> %822, <double 1.000000e+00, double 1.000000e+00>
%825 = fadd <2 x double> %823, <double 1.000000e+00, double 1.000000e+00>
%826 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %809
%827 = bitcast double* %826 to <2 x double>*
store <2 x double> %824, <2 x double>* %827
%828 = getelementptr inbounds double, double* %826, i64 2
%829 = bitcast double* %828 to <2 x double>*
store <2 x double> %825, <2 x double>* %829
%830 = add nuw nsw i64 %787, 8
%831 = icmp eq i64 %830, 128
br i1 %831, label %506, label %786
832: ; preds = %782, %848
%833 = phi i64 [ %849, %848 ], [ %783, %782 ]
%834 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %833
%835 = load double, double* %834
%836 = trunc i64 %833 to i32
%837 = add i32 %836, 2
%838 = sitofp i32 %837 to double
%839 = fcmp une double %835, %838
br i1 %839, label %840, label %848
840: ; preds = %832
%841 = trunc i64 %833 to i32
%842 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %841, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %838, double %835)
%843 = add nuw nsw i32 %785, 1
%844 = icmp ugt i32 %785, 10
%845 = add nuw nsw i64 %833, 1
%846 = icmp eq i64 %845, 1024
%847 = select i1 %844, i1 true, i1 %846
br i1 %847, label %851, label %782
848: ; preds = %832
%849 = add nuw nsw i64 %833, 1
%850 = icmp eq i64 %849, 1024
br i1 %850, label %851, label %832
851: ; preds = %840, %848
%852 = phi i8* [ %784, %848 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @str.23, i64 0, i64 0), %840 ]
%853 = tail call i32 @puts(i8* dereferenceable(1) %852)
br label %854
854: ; preds = %854, %851
%855 = phi i64 [ 0, %851 ], [ %881, %854 ]
%856 = phi <2 x i32> [ <i32 0, i32 1>, %851 ], [ %882, %854 ]
%857 = add <2 x i32> %856, <i32 2, i32 2>
%858 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %855
%859 = bitcast double* %858 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %859
%860 = getelementptr inbounds double, double* %858, i64 2
%861 = bitcast double* %860 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %861
%862 = sitofp <2 x i32> %856 to <2 x double>
%863 = sitofp <2 x i32> %857 to <2 x double>
%864 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %855
%865 = bitcast double* %864 to <2 x double>*
store <2 x double> %862, <2 x double>* %865
%866 = getelementptr inbounds double, double* %864, i64 2
%867 = bitcast double* %866 to <2 x double>*
store <2 x double> %863, <2 x double>* %867
%868 = or i64 %855, 4
%869 = add <2 x i32> %856, <i32 4, i32 4>
%870 = add <2 x i32> %856, <i32 6, i32 6>
%871 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %868
%872 = bitcast double* %871 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %872
%873 = getelementptr inbounds double, double* %871, i64 2
%874 = bitcast double* %873 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %874
%875 = sitofp <2 x i32> %869 to <2 x double>
%876 = sitofp <2 x i32> %870 to <2 x double>
%877 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %868
%878 = bitcast double* %877 to <2 x double>*
store <2 x double> %875, <2 x double>* %878
%879 = getelementptr inbounds double, double* %877, i64 2
%880 = bitcast double* %879 to <2 x double>*
store <2 x double> %876, <2 x double>* %880
%881 = add nuw nsw i64 %855, 8
%882 = add <2 x i32> %856, <i32 8, i32 8>
%883 = icmp eq i64 %881, 1024
br i1 %883, label %884, label %854
884: ; preds = %854, %884
%885 = phi i64 [ %927, %884 ], [ 0, %854 ]
%886 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %885
%887 = bitcast double* %886 to <2 x double>*
%888 = load <2 x double>, <2 x double>* %887
%889 = getelementptr inbounds double, double* %886, i64 2
%890 = bitcast double* %889 to <2 x double>*
%891 = load <2 x double>, <2 x double>* %890
%892 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %885
%893 = bitcast double* %892 to <2 x double>*
%894 = load <2 x double>, <2 x double>* %893
%895 = getelementptr inbounds double, double* %892, i64 2
%896 = bitcast double* %895 to <2 x double>*
%897 = load <2 x double>, <2 x double>* %896
%898 = fadd <2 x double> %888, %894
%899 = fadd <2 x double> %891, %897
%900 = fadd <2 x double> %898, <double 1.000000e+00, double 1.000000e+00>
%901 = fadd <2 x double> %899, <double 1.000000e+00, double 1.000000e+00>
%902 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %885
%903 = bitcast double* %902 to <2 x double>*
store <2 x double> %900, <2 x double>* %903
%904 = getelementptr inbounds double, double* %902, i64 2
%905 = bitcast double* %904 to <2 x double>*
store <2 x double> %901, <2 x double>* %905
%906 = or i64 %885, 4
%907 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %906
%908 = bitcast double* %907 to <2 x double>*
%909 = load <2 x double>, <2 x double>* %908
%910 = getelementptr inbounds double, double* %907, i64 2
%911 = bitcast double* %910 to <2 x double>*
%912 = load <2 x double>, <2 x double>* %911
%913 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %906
%914 = bitcast double* %913 to <2 x double>*
%915 = load <2 x double>, <2 x double>* %914
%916 = getelementptr inbounds double, double* %913, i64 2
%917 = bitcast double* %916 to <2 x double>*
%918 = load <2 x double>, <2 x double>* %917
%919 = fadd <2 x double> %909, %915
%920 = fadd <2 x double> %912, %918
%921 = fadd <2 x double> %919, <double 1.000000e+00, double 1.000000e+00>
%922 = fadd <2 x double> %920, <double 1.000000e+00, double 1.000000e+00>
%923 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %906
%924 = bitcast double* %923 to <2 x double>*
store <2 x double> %921, <2 x double>* %924
%925 = getelementptr inbounds double, double* %923, i64 2
%926 = bitcast double* %925 to <2 x double>*
store <2 x double> %922, <2 x double>* %926
%927 = add nuw nsw i64 %885, 8
%928 = icmp eq i64 %927, 128
br i1 %928, label %1209, label %884
929: ; preds = %1209, %929
%930 = phi i64 [ %973, %929 ], [ 0, %1209 ]
%931 = add nuw nsw i64 %930, 256
%932 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %931
%933 = bitcast double* %932 to <2 x double>*
%934 = load <2 x double>, <2 x double>* %933
%935 = getelementptr inbounds double, double* %932, i64 2
%936 = bitcast double* %935 to <2 x double>*
%937 = load <2 x double>, <2 x double>* %936
%938 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %931
%939 = bitcast double* %938 to <2 x double>*
%940 = load <2 x double>, <2 x double>* %939
%941 = getelementptr inbounds double, double* %938, i64 2
%942 = bitcast double* %941 to <2 x double>*
%943 = load <2 x double>, <2 x double>* %942
%944 = fadd <2 x double> %934, %940
%945 = fadd <2 x double> %937, %943
%946 = fadd <2 x double> %944, <double 1.000000e+00, double 1.000000e+00>
%947 = fadd <2 x double> %945, <double 1.000000e+00, double 1.000000e+00>
%948 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %931
%949 = bitcast double* %948 to <2 x double>*
store <2 x double> %946, <2 x double>* %949
%950 = getelementptr inbounds double, double* %948, i64 2
%951 = bitcast double* %950 to <2 x double>*
store <2 x double> %947, <2 x double>* %951
%952 = add nuw nsw i64 %930, 260
%953 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %952
%954 = bitcast double* %953 to <2 x double>*
%955 = load <2 x double>, <2 x double>* %954
%956 = getelementptr inbounds double, double* %953, i64 2
%957 = bitcast double* %956 to <2 x double>*
%958 = load <2 x double>, <2 x double>* %957
%959 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %952
%960 = bitcast double* %959 to <2 x double>*
%961 = load <2 x double>, <2 x double>* %960
%962 = getelementptr inbounds double, double* %959, i64 2
%963 = bitcast double* %962 to <2 x double>*
%964 = load <2 x double>, <2 x double>* %963
%965 = fadd <2 x double> %955, %961
%966 = fadd <2 x double> %958, %964
%967 = fadd <2 x double> %965, <double 1.000000e+00, double 1.000000e+00>
%968 = fadd <2 x double> %966, <double 1.000000e+00, double 1.000000e+00>
%969 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %952
%970 = bitcast double* %969 to <2 x double>*
store <2 x double> %967, <2 x double>* %970
%971 = getelementptr inbounds double, double* %969, i64 2
%972 = bitcast double* %971 to <2 x double>*
store <2 x double> %968, <2 x double>* %972
%973 = add nuw nsw i64 %930, 8
%974 = icmp eq i64 %973, 128
br i1 %974, label %975, label %929
975: ; preds = %929, %975
%976 = phi i64 [ %1019, %975 ], [ 0, %929 ]
%977 = add nuw nsw i64 %976, 384
%978 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %977
%979 = bitcast double* %978 to <2 x double>*
%980 = load <2 x double>, <2 x double>* %979
%981 = getelementptr inbounds double, double* %978, i64 2
%982 = bitcast double* %981 to <2 x double>*
%983 = load <2 x double>, <2 x double>* %982
%984 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %977
%985 = bitcast double* %984 to <2 x double>*
%986 = load <2 x double>, <2 x double>* %985
%987 = getelementptr inbounds double, double* %984, i64 2
%988 = bitcast double* %987 to <2 x double>*
%989 = load <2 x double>, <2 x double>* %988
%990 = fadd <2 x double> %980, %986
%991 = fadd <2 x double> %983, %989
%992 = fadd <2 x double> %990, <double 1.000000e+00, double 1.000000e+00>
%993 = fadd <2 x double> %991, <double 1.000000e+00, double 1.000000e+00>
%994 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %977
%995 = bitcast double* %994 to <2 x double>*
store <2 x double> %992, <2 x double>* %995
%996 = getelementptr inbounds double, double* %994, i64 2
%997 = bitcast double* %996 to <2 x double>*
store <2 x double> %993, <2 x double>* %997
%998 = add nuw nsw i64 %976, 388
%999 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %998
%1000 = bitcast double* %999 to <2 x double>*
%1001 = load <2 x double>, <2 x double>* %1000
%1002 = getelementptr inbounds double, double* %999, i64 2
%1003 = bitcast double* %1002 to <2 x double>*
%1004 = load <2 x double>, <2 x double>* %1003
%1005 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %998
%1006 = bitcast double* %1005 to <2 x double>*
%1007 = load <2 x double>, <2 x double>* %1006
%1008 = getelementptr inbounds double, double* %1005, i64 2
%1009 = bitcast double* %1008 to <2 x double>*
%1010 = load <2 x double>, <2 x double>* %1009
%1011 = fadd <2 x double> %1001, %1007
%1012 = fadd <2 x double> %1004, %1010
%1013 = fadd <2 x double> %1011, <double 1.000000e+00, double 1.000000e+00>
%1014 = fadd <2 x double> %1012, <double 1.000000e+00, double 1.000000e+00>
%1015 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %998
%1016 = bitcast double* %1015 to <2 x double>*
store <2 x double> %1013, <2 x double>* %1016
%1017 = getelementptr inbounds double, double* %1015, i64 2
%1018 = bitcast double* %1017 to <2 x double>*
store <2 x double> %1014, <2 x double>* %1018
%1019 = add nuw nsw i64 %976, 8
%1020 = icmp eq i64 %1019, 128
br i1 %1020, label %1021, label %975
1021: ; preds = %975, %1021
%1022 = phi i64 [ %1065, %1021 ], [ 0, %975 ]
%1023 = add nuw nsw i64 %1022, 512
%1024 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1023
%1025 = bitcast double* %1024 to <2 x double>*
%1026 = load <2 x double>, <2 x double>* %1025
%1027 = getelementptr inbounds double, double* %1024, i64 2
%1028 = bitcast double* %1027 to <2 x double>*
%1029 = load <2 x double>, <2 x double>* %1028
%1030 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1023
%1031 = bitcast double* %1030 to <2 x double>*
%1032 = load <2 x double>, <2 x double>* %1031
%1033 = getelementptr inbounds double, double* %1030, i64 2
%1034 = bitcast double* %1033 to <2 x double>*
%1035 = load <2 x double>, <2 x double>* %1034
%1036 = fadd <2 x double> %1026, %1032
%1037 = fadd <2 x double> %1029, %1035
%1038 = fadd <2 x double> %1036, <double 1.000000e+00, double 1.000000e+00>
%1039 = fadd <2 x double> %1037, <double 1.000000e+00, double 1.000000e+00>
%1040 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1023
%1041 = bitcast double* %1040 to <2 x double>*
store <2 x double> %1038, <2 x double>* %1041
%1042 = getelementptr inbounds double, double* %1040, i64 2
%1043 = bitcast double* %1042 to <2 x double>*
store <2 x double> %1039, <2 x double>* %1043
%1044 = add nuw nsw i64 %1022, 516
%1045 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1044
%1046 = bitcast double* %1045 to <2 x double>*
%1047 = load <2 x double>, <2 x double>* %1046
%1048 = getelementptr inbounds double, double* %1045, i64 2
%1049 = bitcast double* %1048 to <2 x double>*
%1050 = load <2 x double>, <2 x double>* %1049
%1051 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1044
%1052 = bitcast double* %1051 to <2 x double>*
%1053 = load <2 x double>, <2 x double>* %1052
%1054 = getelementptr inbounds double, double* %1051, i64 2
%1055 = bitcast double* %1054 to <2 x double>*
%1056 = load <2 x double>, <2 x double>* %1055
%1057 = fadd <2 x double> %1047, %1053
%1058 = fadd <2 x double> %1050, %1056
%1059 = fadd <2 x double> %1057, <double 1.000000e+00, double 1.000000e+00>
%1060 = fadd <2 x double> %1058, <double 1.000000e+00, double 1.000000e+00>
%1061 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1044
%1062 = bitcast double* %1061 to <2 x double>*
store <2 x double> %1059, <2 x double>* %1062
%1063 = getelementptr inbounds double, double* %1061, i64 2
%1064 = bitcast double* %1063 to <2 x double>*
store <2 x double> %1060, <2 x double>* %1064
%1065 = add nuw nsw i64 %1022, 8
%1066 = icmp eq i64 %1065, 128
br i1 %1066, label %1067, label %1021
1067: ; preds = %1021, %1067
%1068 = phi i64 [ %1111, %1067 ], [ 0, %1021 ]
%1069 = add nuw nsw i64 %1068, 640
%1070 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1069
%1071 = bitcast double* %1070 to <2 x double>*
%1072 = load <2 x double>, <2 x double>* %1071
%1073 = getelementptr inbounds double, double* %1070, i64 2
%1074 = bitcast double* %1073 to <2 x double>*
%1075 = load <2 x double>, <2 x double>* %1074
%1076 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1069
%1077 = bitcast double* %1076 to <2 x double>*
%1078 = load <2 x double>, <2 x double>* %1077
%1079 = getelementptr inbounds double, double* %1076, i64 2
%1080 = bitcast double* %1079 to <2 x double>*
%1081 = load <2 x double>, <2 x double>* %1080
%1082 = fadd <2 x double> %1072, %1078
%1083 = fadd <2 x double> %1075, %1081
%1084 = fadd <2 x double> %1082, <double 1.000000e+00, double 1.000000e+00>
%1085 = fadd <2 x double> %1083, <double 1.000000e+00, double 1.000000e+00>
%1086 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1069
%1087 = bitcast double* %1086 to <2 x double>*
store <2 x double> %1084, <2 x double>* %1087
%1088 = getelementptr inbounds double, double* %1086, i64 2
%1089 = bitcast double* %1088 to <2 x double>*
store <2 x double> %1085, <2 x double>* %1089
%1090 = add nuw nsw i64 %1068, 644
%1091 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1090
%1092 = bitcast double* %1091 to <2 x double>*
%1093 = load <2 x double>, <2 x double>* %1092
%1094 = getelementptr inbounds double, double* %1091, i64 2
%1095 = bitcast double* %1094 to <2 x double>*
%1096 = load <2 x double>, <2 x double>* %1095
%1097 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1090
%1098 = bitcast double* %1097 to <2 x double>*
%1099 = load <2 x double>, <2 x double>* %1098
%1100 = getelementptr inbounds double, double* %1097, i64 2
%1101 = bitcast double* %1100 to <2 x double>*
%1102 = load <2 x double>, <2 x double>* %1101
%1103 = fadd <2 x double> %1093, %1099
%1104 = fadd <2 x double> %1096, %1102
%1105 = fadd <2 x double> %1103, <double 1.000000e+00, double 1.000000e+00>
%1106 = fadd <2 x double> %1104, <double 1.000000e+00, double 1.000000e+00>
%1107 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1090
%1108 = bitcast double* %1107 to <2 x double>*
store <2 x double> %1105, <2 x double>* %1108
%1109 = getelementptr inbounds double, double* %1107, i64 2
%1110 = bitcast double* %1109 to <2 x double>*
store <2 x double> %1106, <2 x double>* %1110
%1111 = add nuw nsw i64 %1068, 8
%1112 = icmp eq i64 %1111, 128
br i1 %1112, label %1113, label %1067
1113: ; preds = %1067, %1113
%1114 = phi i64 [ %1157, %1113 ], [ 0, %1067 ]
%1115 = add nuw nsw i64 %1114, 768
%1116 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1115
%1117 = bitcast double* %1116 to <2 x double>*
%1118 = load <2 x double>, <2 x double>* %1117
%1119 = getelementptr inbounds double, double* %1116, i64 2
%1120 = bitcast double* %1119 to <2 x double>*
%1121 = load <2 x double>, <2 x double>* %1120
%1122 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1115
%1123 = bitcast double* %1122 to <2 x double>*
%1124 = load <2 x double>, <2 x double>* %1123
%1125 = getelementptr inbounds double, double* %1122, i64 2
%1126 = bitcast double* %1125 to <2 x double>*
%1127 = load <2 x double>, <2 x double>* %1126
%1128 = fadd <2 x double> %1118, %1124
%1129 = fadd <2 x double> %1121, %1127
%1130 = fadd <2 x double> %1128, <double 1.000000e+00, double 1.000000e+00>
%1131 = fadd <2 x double> %1129, <double 1.000000e+00, double 1.000000e+00>
%1132 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1115
%1133 = bitcast double* %1132 to <2 x double>*
store <2 x double> %1130, <2 x double>* %1133
%1134 = getelementptr inbounds double, double* %1132, i64 2
%1135 = bitcast double* %1134 to <2 x double>*
store <2 x double> %1131, <2 x double>* %1135
%1136 = add nuw nsw i64 %1114, 772
%1137 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1136
%1138 = bitcast double* %1137 to <2 x double>*
%1139 = load <2 x double>, <2 x double>* %1138
%1140 = getelementptr inbounds double, double* %1137, i64 2
%1141 = bitcast double* %1140 to <2 x double>*
%1142 = load <2 x double>, <2 x double>* %1141
%1143 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1136
%1144 = bitcast double* %1143 to <2 x double>*
%1145 = load <2 x double>, <2 x double>* %1144
%1146 = getelementptr inbounds double, double* %1143, i64 2
%1147 = bitcast double* %1146 to <2 x double>*
%1148 = load <2 x double>, <2 x double>* %1147
%1149 = fadd <2 x double> %1139, %1145
%1150 = fadd <2 x double> %1142, %1148
%1151 = fadd <2 x double> %1149, <double 1.000000e+00, double 1.000000e+00>
%1152 = fadd <2 x double> %1150, <double 1.000000e+00, double 1.000000e+00>
%1153 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1136
%1154 = bitcast double* %1153 to <2 x double>*
store <2 x double> %1151, <2 x double>* %1154
%1155 = getelementptr inbounds double, double* %1153, i64 2
%1156 = bitcast double* %1155 to <2 x double>*
store <2 x double> %1152, <2 x double>* %1156
%1157 = add nuw nsw i64 %1114, 8
%1158 = icmp eq i64 %1157, 128
br i1 %1158, label %1159, label %1113
1159: ; preds = %1113, %1159
%1160 = phi i64 [ %1203, %1159 ], [ 0, %1113 ]
%1161 = add nuw nsw i64 %1160, 896
%1162 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1161
%1163 = bitcast double* %1162 to <2 x double>*
%1164 = load <2 x double>, <2 x double>* %1163
%1165 = getelementptr inbounds double, double* %1162, i64 2
%1166 = bitcast double* %1165 to <2 x double>*
%1167 = load <2 x double>, <2 x double>* %1166
%1168 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1161
%1169 = bitcast double* %1168 to <2 x double>*
%1170 = load <2 x double>, <2 x double>* %1169
%1171 = getelementptr inbounds double, double* %1168, i64 2
%1172 = bitcast double* %1171 to <2 x double>*
%1173 = load <2 x double>, <2 x double>* %1172
%1174 = fadd <2 x double> %1164, %1170
%1175 = fadd <2 x double> %1167, %1173
%1176 = fadd <2 x double> %1174, <double 1.000000e+00, double 1.000000e+00>
%1177 = fadd <2 x double> %1175, <double 1.000000e+00, double 1.000000e+00>
%1178 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1161
%1179 = bitcast double* %1178 to <2 x double>*
store <2 x double> %1176, <2 x double>* %1179
%1180 = getelementptr inbounds double, double* %1178, i64 2
%1181 = bitcast double* %1180 to <2 x double>*
store <2 x double> %1177, <2 x double>* %1181
%1182 = add nuw nsw i64 %1160, 900
%1183 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1182
%1184 = bitcast double* %1183 to <2 x double>*
%1185 = load <2 x double>, <2 x double>* %1184
%1186 = getelementptr inbounds double, double* %1183, i64 2
%1187 = bitcast double* %1186 to <2 x double>*
%1188 = load <2 x double>, <2 x double>* %1187
%1189 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1182
%1190 = bitcast double* %1189 to <2 x double>*
%1191 = load <2 x double>, <2 x double>* %1190
%1192 = getelementptr inbounds double, double* %1189, i64 2
%1193 = bitcast double* %1192 to <2 x double>*
%1194 = load <2 x double>, <2 x double>* %1193
%1195 = fadd <2 x double> %1185, %1191
%1196 = fadd <2 x double> %1188, %1194
%1197 = fadd <2 x double> %1195, <double 1.000000e+00, double 1.000000e+00>
%1198 = fadd <2 x double> %1196, <double 1.000000e+00, double 1.000000e+00>
%1199 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1182
%1200 = bitcast double* %1199 to <2 x double>*
store <2 x double> %1197, <2 x double>* %1200
%1201 = getelementptr inbounds double, double* %1199, i64 2
%1202 = bitcast double* %1201 to <2 x double>*
store <2 x double> %1198, <2 x double>* %1202
%1203 = add nuw nsw i64 %1160, 8
%1204 = icmp eq i64 %1203, 128
br i1 %1204, label %1205, label %1159
1205: ; preds = %1159, %1263
%1206 = phi i64 [ %1268, %1263 ], [ 0, %1159 ]
%1207 = phi i8* [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.22, i64 0, i64 0), %1263 ], [ getelementptr inbounds ([29 x i8], [29 x i8]* @str.15, i64 0, i64 0), %1159 ]
%1208 = phi i32 [ %1266, %1263 ], [ 0, %1159 ]
br label %1255
1209: ; preds = %884, %1209
%1210 = phi i64 [ %1253, %1209 ], [ 0, %884 ]
%1211 = add nuw nsw i64 %1210, 128
%1212 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1211
%1213 = bitcast double* %1212 to <2 x double>*
%1214 = load <2 x double>, <2 x double>* %1213
%1215 = getelementptr inbounds double, double* %1212, i64 2
%1216 = bitcast double* %1215 to <2 x double>*
%1217 = load <2 x double>, <2 x double>* %1216
%1218 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1211
%1219 = bitcast double* %1218 to <2 x double>*
%1220 = load <2 x double>, <2 x double>* %1219
%1221 = getelementptr inbounds double, double* %1218, i64 2
%1222 = bitcast double* %1221 to <2 x double>*
%1223 = load <2 x double>, <2 x double>* %1222
%1224 = fadd <2 x double> %1214, %1220
%1225 = fadd <2 x double> %1217, %1223
%1226 = fadd <2 x double> %1224, <double 1.000000e+00, double 1.000000e+00>
%1227 = fadd <2 x double> %1225, <double 1.000000e+00, double 1.000000e+00>
%1228 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1211
%1229 = bitcast double* %1228 to <2 x double>*
store <2 x double> %1226, <2 x double>* %1229
%1230 = getelementptr inbounds double, double* %1228, i64 2
%1231 = bitcast double* %1230 to <2 x double>*
store <2 x double> %1227, <2 x double>* %1231
%1232 = add nuw nsw i64 %1210, 132
%1233 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1232
%1234 = bitcast double* %1233 to <2 x double>*
%1235 = load <2 x double>, <2 x double>* %1234
%1236 = getelementptr inbounds double, double* %1233, i64 2
%1237 = bitcast double* %1236 to <2 x double>*
%1238 = load <2 x double>, <2 x double>* %1237
%1239 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1232
%1240 = bitcast double* %1239 to <2 x double>*
%1241 = load <2 x double>, <2 x double>* %1240
%1242 = getelementptr inbounds double, double* %1239, i64 2
%1243 = bitcast double* %1242 to <2 x double>*
%1244 = load <2 x double>, <2 x double>* %1243
%1245 = fadd <2 x double> %1235, %1241
%1246 = fadd <2 x double> %1238, %1244
%1247 = fadd <2 x double> %1245, <double 1.000000e+00, double 1.000000e+00>
%1248 = fadd <2 x double> %1246, <double 1.000000e+00, double 1.000000e+00>
%1249 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1232
%1250 = bitcast double* %1249 to <2 x double>*
store <2 x double> %1247, <2 x double>* %1250
%1251 = getelementptr inbounds double, double* %1249, i64 2
%1252 = bitcast double* %1251 to <2 x double>*
store <2 x double> %1248, <2 x double>* %1252
%1253 = add nuw nsw i64 %1210, 8
%1254 = icmp eq i64 %1253, 128
br i1 %1254, label %929, label %1209
1255: ; preds = %1205, %1271
%1256 = phi i64 [ %1272, %1271 ], [ %1206, %1205 ]
%1257 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1256
%1258 = load double, double* %1257
%1259 = trunc i64 %1256 to i32
%1260 = add i32 %1259, 2
%1261 = sitofp i32 %1260 to double
%1262 = fcmp une double %1258, %1261
br i1 %1262, label %1263, label %1271
1263: ; preds = %1255
%1264 = trunc i64 %1256 to i32
%1265 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1264, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %1261, double %1258)
%1266 = add nuw nsw i32 %1208, 1
%1267 = icmp ugt i32 %1208, 10
%1268 = add nuw nsw i64 %1256, 1
%1269 = icmp eq i64 %1268, 1024
%1270 = select i1 %1267, i1 true, i1 %1269
br i1 %1270, label %1274, label %1205
1271: ; preds = %1255
%1272 = add nuw nsw i64 %1256, 1
%1273 = icmp eq i64 %1272, 1024
br i1 %1273, label %1274, label %1255
1274: ; preds = %1263, %1271
%1275 = phi i8* [ %1207, %1271 ], [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.22, i64 0, i64 0), %1263 ]
%1276 = tail call i32 @puts(i8* dereferenceable(1) %1275)
br label %1277
1277: ; preds = %1277, %1274
%1278 = phi i64 [ 0, %1274 ], [ %1304, %1277 ]
%1279 = phi <2 x i32> [ <i32 0, i32 1>, %1274 ], [ %1305, %1277 ]
%1280 = add <2 x i32> %1279, <i32 2, i32 2>
%1281 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1278
%1282 = bitcast double* %1281 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1282
%1283 = getelementptr inbounds double, double* %1281, i64 2
%1284 = bitcast double* %1283 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1284
%1285 = sitofp <2 x i32> %1279 to <2 x double>
%1286 = sitofp <2 x i32> %1280 to <2 x double>
%1287 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1278
%1288 = bitcast double* %1287 to <2 x double>*
store <2 x double> %1285, <2 x double>* %1288
%1289 = getelementptr inbounds double, double* %1287, i64 2
%1290 = bitcast double* %1289 to <2 x double>*
store <2 x double> %1286, <2 x double>* %1290
%1291 = or i64 %1278, 4
%1292 = add <2 x i32> %1279, <i32 4, i32 4>
%1293 = add <2 x i32> %1279, <i32 6, i32 6>
%1294 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1291
%1295 = bitcast double* %1294 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1295
%1296 = getelementptr inbounds double, double* %1294, i64 2
%1297 = bitcast double* %1296 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1297
%1298 = sitofp <2 x i32> %1292 to <2 x double>
%1299 = sitofp <2 x i32> %1293 to <2 x double>
%1300 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1291
%1301 = bitcast double* %1300 to <2 x double>*
store <2 x double> %1298, <2 x double>* %1301
%1302 = getelementptr inbounds double, double* %1300, i64 2
%1303 = bitcast double* %1302 to <2 x double>*
store <2 x double> %1299, <2 x double>* %1303
%1304 = add nuw nsw i64 %1278, 8
%1305 = add <2 x i32> %1279, <i32 8, i32 8>
%1306 = icmp eq i64 %1304, 1024
br i1 %1306, label %1307, label %1277
1307: ; preds = %1277, %1307
%1308 = phi i64 [ %1350, %1307 ], [ 0, %1277 ]
%1309 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1308
%1310 = bitcast double* %1309 to <2 x double>*
%1311 = load <2 x double>, <2 x double>* %1310
%1312 = getelementptr inbounds double, double* %1309, i64 2
%1313 = bitcast double* %1312 to <2 x double>*
%1314 = load <2 x double>, <2 x double>* %1313
%1315 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1308
%1316 = bitcast double* %1315 to <2 x double>*
%1317 = load <2 x double>, <2 x double>* %1316
%1318 = getelementptr inbounds double, double* %1315, i64 2
%1319 = bitcast double* %1318 to <2 x double>*
%1320 = load <2 x double>, <2 x double>* %1319
%1321 = fadd <2 x double> %1311, %1317
%1322 = fadd <2 x double> %1314, %1320
%1323 = fadd <2 x double> %1321, <double 1.000000e+00, double 1.000000e+00>
%1324 = fadd <2 x double> %1322, <double 1.000000e+00, double 1.000000e+00>
%1325 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1308
%1326 = bitcast double* %1325 to <2 x double>*
store <2 x double> %1323, <2 x double>* %1326
%1327 = getelementptr inbounds double, double* %1325, i64 2
%1328 = bitcast double* %1327 to <2 x double>*
store <2 x double> %1324, <2 x double>* %1328
%1329 = or i64 %1308, 4
%1330 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1329
%1331 = bitcast double* %1330 to <2 x double>*
%1332 = load <2 x double>, <2 x double>* %1331
%1333 = getelementptr inbounds double, double* %1330, i64 2
%1334 = bitcast double* %1333 to <2 x double>*
%1335 = load <2 x double>, <2 x double>* %1334
%1336 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1329
%1337 = bitcast double* %1336 to <2 x double>*
%1338 = load <2 x double>, <2 x double>* %1337
%1339 = getelementptr inbounds double, double* %1336, i64 2
%1340 = bitcast double* %1339 to <2 x double>*
%1341 = load <2 x double>, <2 x double>* %1340
%1342 = fadd <2 x double> %1332, %1338
%1343 = fadd <2 x double> %1335, %1341
%1344 = fadd <2 x double> %1342, <double 1.000000e+00, double 1.000000e+00>
%1345 = fadd <2 x double> %1343, <double 1.000000e+00, double 1.000000e+00>
%1346 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1329
%1347 = bitcast double* %1346 to <2 x double>*
store <2 x double> %1344, <2 x double>* %1347
%1348 = getelementptr inbounds double, double* %1346, i64 2
%1349 = bitcast double* %1348 to <2 x double>*
store <2 x double> %1345, <2 x double>* %1349
%1350 = add nuw nsw i64 %1308, 8
%1351 = icmp eq i64 %1350, 128
br i1 %1351, label %1632, label %1307
1352: ; preds = %1632, %1352
%1353 = phi i64 [ %1396, %1352 ], [ 0, %1632 ]
%1354 = add nuw nsw i64 %1353, 256
%1355 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1354
%1356 = bitcast double* %1355 to <2 x double>*
%1357 = load <2 x double>, <2 x double>* %1356
%1358 = getelementptr inbounds double, double* %1355, i64 2
%1359 = bitcast double* %1358 to <2 x double>*
%1360 = load <2 x double>, <2 x double>* %1359
%1361 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1354
%1362 = bitcast double* %1361 to <2 x double>*
%1363 = load <2 x double>, <2 x double>* %1362
%1364 = getelementptr inbounds double, double* %1361, i64 2
%1365 = bitcast double* %1364 to <2 x double>*
%1366 = load <2 x double>, <2 x double>* %1365
%1367 = fadd <2 x double> %1357, %1363
%1368 = fadd <2 x double> %1360, %1366
%1369 = fadd <2 x double> %1367, <double 1.000000e+00, double 1.000000e+00>
%1370 = fadd <2 x double> %1368, <double 1.000000e+00, double 1.000000e+00>
%1371 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1354
%1372 = bitcast double* %1371 to <2 x double>*
store <2 x double> %1369, <2 x double>* %1372
%1373 = getelementptr inbounds double, double* %1371, i64 2
%1374 = bitcast double* %1373 to <2 x double>*
store <2 x double> %1370, <2 x double>* %1374
%1375 = add nuw nsw i64 %1353, 260
%1376 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1375
%1377 = bitcast double* %1376 to <2 x double>*
%1378 = load <2 x double>, <2 x double>* %1377
%1379 = getelementptr inbounds double, double* %1376, i64 2
%1380 = bitcast double* %1379 to <2 x double>*
%1381 = load <2 x double>, <2 x double>* %1380
%1382 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1375
%1383 = bitcast double* %1382 to <2 x double>*
%1384 = load <2 x double>, <2 x double>* %1383
%1385 = getelementptr inbounds double, double* %1382, i64 2
%1386 = bitcast double* %1385 to <2 x double>*
%1387 = load <2 x double>, <2 x double>* %1386
%1388 = fadd <2 x double> %1378, %1384
%1389 = fadd <2 x double> %1381, %1387
%1390 = fadd <2 x double> %1388, <double 1.000000e+00, double 1.000000e+00>
%1391 = fadd <2 x double> %1389, <double 1.000000e+00, double 1.000000e+00>
%1392 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1375
%1393 = bitcast double* %1392 to <2 x double>*
store <2 x double> %1390, <2 x double>* %1393
%1394 = getelementptr inbounds double, double* %1392, i64 2
%1395 = bitcast double* %1394 to <2 x double>*
store <2 x double> %1391, <2 x double>* %1395
%1396 = add nuw nsw i64 %1353, 8
%1397 = icmp eq i64 %1396, 128
br i1 %1397, label %1398, label %1352
1398: ; preds = %1352, %1398
%1399 = phi i64 [ %1442, %1398 ], [ 0, %1352 ]
%1400 = add nuw nsw i64 %1399, 384
%1401 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1400
%1402 = bitcast double* %1401 to <2 x double>*
%1403 = load <2 x double>, <2 x double>* %1402
%1404 = getelementptr inbounds double, double* %1401, i64 2
%1405 = bitcast double* %1404 to <2 x double>*
%1406 = load <2 x double>, <2 x double>* %1405
%1407 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1400
%1408 = bitcast double* %1407 to <2 x double>*
%1409 = load <2 x double>, <2 x double>* %1408
%1410 = getelementptr inbounds double, double* %1407, i64 2
%1411 = bitcast double* %1410 to <2 x double>*
%1412 = load <2 x double>, <2 x double>* %1411
%1413 = fadd <2 x double> %1403, %1409
%1414 = fadd <2 x double> %1406, %1412
%1415 = fadd <2 x double> %1413, <double 1.000000e+00, double 1.000000e+00>
%1416 = fadd <2 x double> %1414, <double 1.000000e+00, double 1.000000e+00>
%1417 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1400
%1418 = bitcast double* %1417 to <2 x double>*
store <2 x double> %1415, <2 x double>* %1418
%1419 = getelementptr inbounds double, double* %1417, i64 2
%1420 = bitcast double* %1419 to <2 x double>*
store <2 x double> %1416, <2 x double>* %1420
%1421 = add nuw nsw i64 %1399, 388
%1422 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1421
%1423 = bitcast double* %1422 to <2 x double>*
%1424 = load <2 x double>, <2 x double>* %1423
%1425 = getelementptr inbounds double, double* %1422, i64 2
%1426 = bitcast double* %1425 to <2 x double>*
%1427 = load <2 x double>, <2 x double>* %1426
%1428 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1421
%1429 = bitcast double* %1428 to <2 x double>*
%1430 = load <2 x double>, <2 x double>* %1429
%1431 = getelementptr inbounds double, double* %1428, i64 2
%1432 = bitcast double* %1431 to <2 x double>*
%1433 = load <2 x double>, <2 x double>* %1432
%1434 = fadd <2 x double> %1424, %1430
%1435 = fadd <2 x double> %1427, %1433
%1436 = fadd <2 x double> %1434, <double 1.000000e+00, double 1.000000e+00>
%1437 = fadd <2 x double> %1435, <double 1.000000e+00, double 1.000000e+00>
%1438 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1421
%1439 = bitcast double* %1438 to <2 x double>*
store <2 x double> %1436, <2 x double>* %1439
%1440 = getelementptr inbounds double, double* %1438, i64 2
%1441 = bitcast double* %1440 to <2 x double>*
store <2 x double> %1437, <2 x double>* %1441
%1442 = add nuw nsw i64 %1399, 8
%1443 = icmp eq i64 %1442, 128
br i1 %1443, label %1444, label %1398
1444: ; preds = %1398, %1444
%1445 = phi i64 [ %1488, %1444 ], [ 0, %1398 ]
%1446 = add nuw nsw i64 %1445, 512
%1447 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1446
%1448 = bitcast double* %1447 to <2 x double>*
%1449 = load <2 x double>, <2 x double>* %1448
%1450 = getelementptr inbounds double, double* %1447, i64 2
%1451 = bitcast double* %1450 to <2 x double>*
%1452 = load <2 x double>, <2 x double>* %1451
%1453 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1446
%1454 = bitcast double* %1453 to <2 x double>*
%1455 = load <2 x double>, <2 x double>* %1454
%1456 = getelementptr inbounds double, double* %1453, i64 2
%1457 = bitcast double* %1456 to <2 x double>*
%1458 = load <2 x double>, <2 x double>* %1457
%1459 = fadd <2 x double> %1449, %1455
%1460 = fadd <2 x double> %1452, %1458
%1461 = fadd <2 x double> %1459, <double 1.000000e+00, double 1.000000e+00>
%1462 = fadd <2 x double> %1460, <double 1.000000e+00, double 1.000000e+00>
%1463 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1446
%1464 = bitcast double* %1463 to <2 x double>*
store <2 x double> %1461, <2 x double>* %1464
%1465 = getelementptr inbounds double, double* %1463, i64 2
%1466 = bitcast double* %1465 to <2 x double>*
store <2 x double> %1462, <2 x double>* %1466
%1467 = add nuw nsw i64 %1445, 516
%1468 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1467
%1469 = bitcast double* %1468 to <2 x double>*
%1470 = load <2 x double>, <2 x double>* %1469
%1471 = getelementptr inbounds double, double* %1468, i64 2
%1472 = bitcast double* %1471 to <2 x double>*
%1473 = load <2 x double>, <2 x double>* %1472
%1474 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1467
%1475 = bitcast double* %1474 to <2 x double>*
%1476 = load <2 x double>, <2 x double>* %1475
%1477 = getelementptr inbounds double, double* %1474, i64 2
%1478 = bitcast double* %1477 to <2 x double>*
%1479 = load <2 x double>, <2 x double>* %1478
%1480 = fadd <2 x double> %1470, %1476
%1481 = fadd <2 x double> %1473, %1479
%1482 = fadd <2 x double> %1480, <double 1.000000e+00, double 1.000000e+00>
%1483 = fadd <2 x double> %1481, <double 1.000000e+00, double 1.000000e+00>
%1484 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1467
%1485 = bitcast double* %1484 to <2 x double>*
store <2 x double> %1482, <2 x double>* %1485
%1486 = getelementptr inbounds double, double* %1484, i64 2
%1487 = bitcast double* %1486 to <2 x double>*
store <2 x double> %1483, <2 x double>* %1487
%1488 = add nuw nsw i64 %1445, 8
%1489 = icmp eq i64 %1488, 128
br i1 %1489, label %1490, label %1444
1490: ; preds = %1444, %1490
%1491 = phi i64 [ %1534, %1490 ], [ 0, %1444 ]
%1492 = add nuw nsw i64 %1491, 640
%1493 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1492
%1494 = bitcast double* %1493 to <2 x double>*
%1495 = load <2 x double>, <2 x double>* %1494
%1496 = getelementptr inbounds double, double* %1493, i64 2
%1497 = bitcast double* %1496 to <2 x double>*
%1498 = load <2 x double>, <2 x double>* %1497
%1499 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1492
%1500 = bitcast double* %1499 to <2 x double>*
%1501 = load <2 x double>, <2 x double>* %1500
%1502 = getelementptr inbounds double, double* %1499, i64 2
%1503 = bitcast double* %1502 to <2 x double>*
%1504 = load <2 x double>, <2 x double>* %1503
%1505 = fadd <2 x double> %1495, %1501
%1506 = fadd <2 x double> %1498, %1504
%1507 = fadd <2 x double> %1505, <double 1.000000e+00, double 1.000000e+00>
%1508 = fadd <2 x double> %1506, <double 1.000000e+00, double 1.000000e+00>
%1509 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1492
%1510 = bitcast double* %1509 to <2 x double>*
store <2 x double> %1507, <2 x double>* %1510
%1511 = getelementptr inbounds double, double* %1509, i64 2
%1512 = bitcast double* %1511 to <2 x double>*
store <2 x double> %1508, <2 x double>* %1512
%1513 = add nuw nsw i64 %1491, 644
%1514 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1513
%1515 = bitcast double* %1514 to <2 x double>*
%1516 = load <2 x double>, <2 x double>* %1515
%1517 = getelementptr inbounds double, double* %1514, i64 2
%1518 = bitcast double* %1517 to <2 x double>*
%1519 = load <2 x double>, <2 x double>* %1518
%1520 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1513
%1521 = bitcast double* %1520 to <2 x double>*
%1522 = load <2 x double>, <2 x double>* %1521
%1523 = getelementptr inbounds double, double* %1520, i64 2
%1524 = bitcast double* %1523 to <2 x double>*
%1525 = load <2 x double>, <2 x double>* %1524
%1526 = fadd <2 x double> %1516, %1522
%1527 = fadd <2 x double> %1519, %1525
%1528 = fadd <2 x double> %1526, <double 1.000000e+00, double 1.000000e+00>
%1529 = fadd <2 x double> %1527, <double 1.000000e+00, double 1.000000e+00>
%1530 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1513
%1531 = bitcast double* %1530 to <2 x double>*
store <2 x double> %1528, <2 x double>* %1531
%1532 = getelementptr inbounds double, double* %1530, i64 2
%1533 = bitcast double* %1532 to <2 x double>*
store <2 x double> %1529, <2 x double>* %1533
%1534 = add nuw nsw i64 %1491, 8
%1535 = icmp eq i64 %1534, 128
br i1 %1535, label %1536, label %1490
1536: ; preds = %1490, %1536
%1537 = phi i64 [ %1580, %1536 ], [ 0, %1490 ]
%1538 = add nuw nsw i64 %1537, 768
%1539 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1538
%1540 = bitcast double* %1539 to <2 x double>*
%1541 = load <2 x double>, <2 x double>* %1540
%1542 = getelementptr inbounds double, double* %1539, i64 2
%1543 = bitcast double* %1542 to <2 x double>*
%1544 = load <2 x double>, <2 x double>* %1543
%1545 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1538
%1546 = bitcast double* %1545 to <2 x double>*
%1547 = load <2 x double>, <2 x double>* %1546
%1548 = getelementptr inbounds double, double* %1545, i64 2
%1549 = bitcast double* %1548 to <2 x double>*
%1550 = load <2 x double>, <2 x double>* %1549
%1551 = fadd <2 x double> %1541, %1547
%1552 = fadd <2 x double> %1544, %1550
%1553 = fadd <2 x double> %1551, <double 1.000000e+00, double 1.000000e+00>
%1554 = fadd <2 x double> %1552, <double 1.000000e+00, double 1.000000e+00>
%1555 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1538
%1556 = bitcast double* %1555 to <2 x double>*
store <2 x double> %1553, <2 x double>* %1556
%1557 = getelementptr inbounds double, double* %1555, i64 2
%1558 = bitcast double* %1557 to <2 x double>*
store <2 x double> %1554, <2 x double>* %1558
%1559 = add nuw nsw i64 %1537, 772
%1560 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1559
%1561 = bitcast double* %1560 to <2 x double>*
%1562 = load <2 x double>, <2 x double>* %1561
%1563 = getelementptr inbounds double, double* %1560, i64 2
%1564 = bitcast double* %1563 to <2 x double>*
%1565 = load <2 x double>, <2 x double>* %1564
%1566 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1559
%1567 = bitcast double* %1566 to <2 x double>*
%1568 = load <2 x double>, <2 x double>* %1567
%1569 = getelementptr inbounds double, double* %1566, i64 2
%1570 = bitcast double* %1569 to <2 x double>*
%1571 = load <2 x double>, <2 x double>* %1570
%1572 = fadd <2 x double> %1562, %1568
%1573 = fadd <2 x double> %1565, %1571
%1574 = fadd <2 x double> %1572, <double 1.000000e+00, double 1.000000e+00>
%1575 = fadd <2 x double> %1573, <double 1.000000e+00, double 1.000000e+00>
%1576 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1559
%1577 = bitcast double* %1576 to <2 x double>*
store <2 x double> %1574, <2 x double>* %1577
%1578 = getelementptr inbounds double, double* %1576, i64 2
%1579 = bitcast double* %1578 to <2 x double>*
store <2 x double> %1575, <2 x double>* %1579
%1580 = add nuw nsw i64 %1537, 8
%1581 = icmp eq i64 %1580, 128
br i1 %1581, label %1582, label %1536
1582: ; preds = %1536, %1582
%1583 = phi i64 [ %1626, %1582 ], [ 0, %1536 ]
%1584 = add nuw nsw i64 %1583, 896
%1585 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1584
%1586 = bitcast double* %1585 to <2 x double>*
%1587 = load <2 x double>, <2 x double>* %1586
%1588 = getelementptr inbounds double, double* %1585, i64 2
%1589 = bitcast double* %1588 to <2 x double>*
%1590 = load <2 x double>, <2 x double>* %1589
%1591 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1584
%1592 = bitcast double* %1591 to <2 x double>*
%1593 = load <2 x double>, <2 x double>* %1592
%1594 = getelementptr inbounds double, double* %1591, i64 2
%1595 = bitcast double* %1594 to <2 x double>*
%1596 = load <2 x double>, <2 x double>* %1595
%1597 = fadd <2 x double> %1587, %1593
%1598 = fadd <2 x double> %1590, %1596
%1599 = fadd <2 x double> %1597, <double 1.000000e+00, double 1.000000e+00>
%1600 = fadd <2 x double> %1598, <double 1.000000e+00, double 1.000000e+00>
%1601 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1584
%1602 = bitcast double* %1601 to <2 x double>*
store <2 x double> %1599, <2 x double>* %1602
%1603 = getelementptr inbounds double, double* %1601, i64 2
%1604 = bitcast double* %1603 to <2 x double>*
store <2 x double> %1600, <2 x double>* %1604
%1605 = add nuw nsw i64 %1583, 900
%1606 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1605
%1607 = bitcast double* %1606 to <2 x double>*
%1608 = load <2 x double>, <2 x double>* %1607
%1609 = getelementptr inbounds double, double* %1606, i64 2
%1610 = bitcast double* %1609 to <2 x double>*
%1611 = load <2 x double>, <2 x double>* %1610
%1612 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1605
%1613 = bitcast double* %1612 to <2 x double>*
%1614 = load <2 x double>, <2 x double>* %1613
%1615 = getelementptr inbounds double, double* %1612, i64 2
%1616 = bitcast double* %1615 to <2 x double>*
%1617 = load <2 x double>, <2 x double>* %1616
%1618 = fadd <2 x double> %1608, %1614
%1619 = fadd <2 x double> %1611, %1617
%1620 = fadd <2 x double> %1618, <double 1.000000e+00, double 1.000000e+00>
%1621 = fadd <2 x double> %1619, <double 1.000000e+00, double 1.000000e+00>
%1622 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1605
%1623 = bitcast double* %1622 to <2 x double>*
store <2 x double> %1620, <2 x double>* %1623
%1624 = getelementptr inbounds double, double* %1622, i64 2
%1625 = bitcast double* %1624 to <2 x double>*
store <2 x double> %1621, <2 x double>* %1625
%1626 = add nuw nsw i64 %1583, 8
%1627 = icmp eq i64 %1626, 128
br i1 %1627, label %1628, label %1582
1628: ; preds = %1582, %1686
%1629 = phi i64 [ %1691, %1686 ], [ 0, %1582 ]
%1630 = phi i8* [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.21, i64 0, i64 0), %1686 ], [ getelementptr inbounds ([29 x i8], [29 x i8]* @str.16, i64 0, i64 0), %1582 ]
%1631 = phi i32 [ %1689, %1686 ], [ 0, %1582 ]
br label %1678
1632: ; preds = %1307, %1632
%1633 = phi i64 [ %1676, %1632 ], [ 0, %1307 ]
%1634 = add nuw nsw i64 %1633, 128
%1635 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1634
%1636 = bitcast double* %1635 to <2 x double>*
%1637 = load <2 x double>, <2 x double>* %1636
%1638 = getelementptr inbounds double, double* %1635, i64 2
%1639 = bitcast double* %1638 to <2 x double>*
%1640 = load <2 x double>, <2 x double>* %1639
%1641 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1634
%1642 = bitcast double* %1641 to <2 x double>*
%1643 = load <2 x double>, <2 x double>* %1642
%1644 = getelementptr inbounds double, double* %1641, i64 2
%1645 = bitcast double* %1644 to <2 x double>*
%1646 = load <2 x double>, <2 x double>* %1645
%1647 = fadd <2 x double> %1637, %1643
%1648 = fadd <2 x double> %1640, %1646
%1649 = fadd <2 x double> %1647, <double 1.000000e+00, double 1.000000e+00>
%1650 = fadd <2 x double> %1648, <double 1.000000e+00, double 1.000000e+00>
%1651 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1634
%1652 = bitcast double* %1651 to <2 x double>*
store <2 x double> %1649, <2 x double>* %1652
%1653 = getelementptr inbounds double, double* %1651, i64 2
%1654 = bitcast double* %1653 to <2 x double>*
store <2 x double> %1650, <2 x double>* %1654
%1655 = add nuw nsw i64 %1633, 132
%1656 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1655
%1657 = bitcast double* %1656 to <2 x double>*
%1658 = load <2 x double>, <2 x double>* %1657
%1659 = getelementptr inbounds double, double* %1656, i64 2
%1660 = bitcast double* %1659 to <2 x double>*
%1661 = load <2 x double>, <2 x double>* %1660
%1662 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1655
%1663 = bitcast double* %1662 to <2 x double>*
%1664 = load <2 x double>, <2 x double>* %1663
%1665 = getelementptr inbounds double, double* %1662, i64 2
%1666 = bitcast double* %1665 to <2 x double>*
%1667 = load <2 x double>, <2 x double>* %1666
%1668 = fadd <2 x double> %1658, %1664
%1669 = fadd <2 x double> %1661, %1667
%1670 = fadd <2 x double> %1668, <double 1.000000e+00, double 1.000000e+00>
%1671 = fadd <2 x double> %1669, <double 1.000000e+00, double 1.000000e+00>
%1672 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1655
%1673 = bitcast double* %1672 to <2 x double>*
store <2 x double> %1670, <2 x double>* %1673
%1674 = getelementptr inbounds double, double* %1672, i64 2
%1675 = bitcast double* %1674 to <2 x double>*
store <2 x double> %1671, <2 x double>* %1675
%1676 = add nuw nsw i64 %1633, 8
%1677 = icmp eq i64 %1676, 128
br i1 %1677, label %1352, label %1632
1678: ; preds = %1628, %1694
%1679 = phi i64 [ %1695, %1694 ], [ %1629, %1628 ]
%1680 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1679
%1681 = load double, double* %1680
%1682 = trunc i64 %1679 to i32
%1683 = add i32 %1682, 2
%1684 = sitofp i32 %1683 to double
%1685 = fcmp une double %1681, %1684
br i1 %1685, label %1686, label %1694
1686: ; preds = %1678
%1687 = trunc i64 %1679 to i32
%1688 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1687, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %1684, double %1681)
%1689 = add nuw nsw i32 %1631, 1
%1690 = icmp ugt i32 %1631, 10
%1691 = add nuw nsw i64 %1679, 1
%1692 = icmp eq i64 %1691, 1024
%1693 = select i1 %1690, i1 true, i1 %1692
br i1 %1693, label %1697, label %1628
1694: ; preds = %1678
%1695 = add nuw nsw i64 %1679, 1
%1696 = icmp eq i64 %1695, 1024
br i1 %1696, label %1697, label %1678
1697: ; preds = %1686, %1694
%1698 = phi i8* [ %1630, %1694 ], [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.21, i64 0, i64 0), %1686 ]
%1699 = tail call i32 @puts(i8* dereferenceable(1) %1698)
br label %1700
1700: ; preds = %1700, %1697
%1701 = phi i64 [ 0, %1697 ], [ %1727, %1700 ]
%1702 = phi <2 x i32> [ <i32 0, i32 1>, %1697 ], [ %1728, %1700 ]
%1703 = add <2 x i32> %1702, <i32 2, i32 2>
%1704 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1701
%1705 = bitcast double* %1704 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1705
%1706 = getelementptr inbounds double, double* %1704, i64 2
%1707 = bitcast double* %1706 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1707
%1708 = sitofp <2 x i32> %1702 to <2 x double>
%1709 = sitofp <2 x i32> %1703 to <2 x double>
%1710 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1701
%1711 = bitcast double* %1710 to <2 x double>*
store <2 x double> %1708, <2 x double>* %1711
%1712 = getelementptr inbounds double, double* %1710, i64 2
%1713 = bitcast double* %1712 to <2 x double>*
store <2 x double> %1709, <2 x double>* %1713
%1714 = or i64 %1701, 4
%1715 = add <2 x i32> %1702, <i32 4, i32 4>
%1716 = add <2 x i32> %1702, <i32 6, i32 6>
%1717 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1714
%1718 = bitcast double* %1717 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1718
%1719 = getelementptr inbounds double, double* %1717, i64 2
%1720 = bitcast double* %1719 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %1720
%1721 = sitofp <2 x i32> %1715 to <2 x double>
%1722 = sitofp <2 x i32> %1716 to <2 x double>
%1723 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1714
%1724 = bitcast double* %1723 to <2 x double>*
store <2 x double> %1721, <2 x double>* %1724
%1725 = getelementptr inbounds double, double* %1723, i64 2
%1726 = bitcast double* %1725 to <2 x double>*
store <2 x double> %1722, <2 x double>* %1726
%1727 = add nuw nsw i64 %1701, 8
%1728 = add <2 x i32> %1702, <i32 8, i32 8>
%1729 = icmp eq i64 %1727, 1024
br i1 %1729, label %1730, label %1700
1730: ; preds = %1700, %1730
%1731 = phi i64 [ %1773, %1730 ], [ 0, %1700 ]
%1732 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1731
%1733 = bitcast double* %1732 to <2 x double>*
%1734 = load <2 x double>, <2 x double>* %1733
%1735 = getelementptr inbounds double, double* %1732, i64 2
%1736 = bitcast double* %1735 to <2 x double>*
%1737 = load <2 x double>, <2 x double>* %1736
%1738 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1731
%1739 = bitcast double* %1738 to <2 x double>*
%1740 = load <2 x double>, <2 x double>* %1739
%1741 = getelementptr inbounds double, double* %1738, i64 2
%1742 = bitcast double* %1741 to <2 x double>*
%1743 = load <2 x double>, <2 x double>* %1742
%1744 = fadd <2 x double> %1734, %1740
%1745 = fadd <2 x double> %1737, %1743
%1746 = fadd <2 x double> %1744, <double 1.000000e+00, double 1.000000e+00>
%1747 = fadd <2 x double> %1745, <double 1.000000e+00, double 1.000000e+00>
%1748 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1731
%1749 = bitcast double* %1748 to <2 x double>*
store <2 x double> %1746, <2 x double>* %1749
%1750 = getelementptr inbounds double, double* %1748, i64 2
%1751 = bitcast double* %1750 to <2 x double>*
store <2 x double> %1747, <2 x double>* %1751
%1752 = or i64 %1731, 4
%1753 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1752
%1754 = bitcast double* %1753 to <2 x double>*
%1755 = load <2 x double>, <2 x double>* %1754
%1756 = getelementptr inbounds double, double* %1753, i64 2
%1757 = bitcast double* %1756 to <2 x double>*
%1758 = load <2 x double>, <2 x double>* %1757
%1759 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1752
%1760 = bitcast double* %1759 to <2 x double>*
%1761 = load <2 x double>, <2 x double>* %1760
%1762 = getelementptr inbounds double, double* %1759, i64 2
%1763 = bitcast double* %1762 to <2 x double>*
%1764 = load <2 x double>, <2 x double>* %1763
%1765 = fadd <2 x double> %1755, %1761
%1766 = fadd <2 x double> %1758, %1764
%1767 = fadd <2 x double> %1765, <double 1.000000e+00, double 1.000000e+00>
%1768 = fadd <2 x double> %1766, <double 1.000000e+00, double 1.000000e+00>
%1769 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1752
%1770 = bitcast double* %1769 to <2 x double>*
store <2 x double> %1767, <2 x double>* %1770
%1771 = getelementptr inbounds double, double* %1769, i64 2
%1772 = bitcast double* %1771 to <2 x double>*
store <2 x double> %1768, <2 x double>* %1772
%1773 = add nuw nsw i64 %1731, 8
%1774 = icmp eq i64 %1773, 128
br i1 %1774, label %2055, label %1730
1775: ; preds = %2055, %1775
%1776 = phi i64 [ %1819, %1775 ], [ 0, %2055 ]
%1777 = add nuw nsw i64 %1776, 256
%1778 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1777
%1779 = bitcast double* %1778 to <2 x double>*
%1780 = load <2 x double>, <2 x double>* %1779
%1781 = getelementptr inbounds double, double* %1778, i64 2
%1782 = bitcast double* %1781 to <2 x double>*
%1783 = load <2 x double>, <2 x double>* %1782
%1784 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1777
%1785 = bitcast double* %1784 to <2 x double>*
%1786 = load <2 x double>, <2 x double>* %1785
%1787 = getelementptr inbounds double, double* %1784, i64 2
%1788 = bitcast double* %1787 to <2 x double>*
%1789 = load <2 x double>, <2 x double>* %1788
%1790 = fadd <2 x double> %1780, %1786
%1791 = fadd <2 x double> %1783, %1789
%1792 = fadd <2 x double> %1790, <double 1.000000e+00, double 1.000000e+00>
%1793 = fadd <2 x double> %1791, <double 1.000000e+00, double 1.000000e+00>
%1794 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1777
%1795 = bitcast double* %1794 to <2 x double>*
store <2 x double> %1792, <2 x double>* %1795
%1796 = getelementptr inbounds double, double* %1794, i64 2
%1797 = bitcast double* %1796 to <2 x double>*
store <2 x double> %1793, <2 x double>* %1797
%1798 = add nuw nsw i64 %1776, 260
%1799 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1798
%1800 = bitcast double* %1799 to <2 x double>*
%1801 = load <2 x double>, <2 x double>* %1800
%1802 = getelementptr inbounds double, double* %1799, i64 2
%1803 = bitcast double* %1802 to <2 x double>*
%1804 = load <2 x double>, <2 x double>* %1803
%1805 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1798
%1806 = bitcast double* %1805 to <2 x double>*
%1807 = load <2 x double>, <2 x double>* %1806
%1808 = getelementptr inbounds double, double* %1805, i64 2
%1809 = bitcast double* %1808 to <2 x double>*
%1810 = load <2 x double>, <2 x double>* %1809
%1811 = fadd <2 x double> %1801, %1807
%1812 = fadd <2 x double> %1804, %1810
%1813 = fadd <2 x double> %1811, <double 1.000000e+00, double 1.000000e+00>
%1814 = fadd <2 x double> %1812, <double 1.000000e+00, double 1.000000e+00>
%1815 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1798
%1816 = bitcast double* %1815 to <2 x double>*
store <2 x double> %1813, <2 x double>* %1816
%1817 = getelementptr inbounds double, double* %1815, i64 2
%1818 = bitcast double* %1817 to <2 x double>*
store <2 x double> %1814, <2 x double>* %1818
%1819 = add nuw nsw i64 %1776, 8
%1820 = icmp eq i64 %1819, 128
br i1 %1820, label %1821, label %1775
1821: ; preds = %1775, %1821
%1822 = phi i64 [ %1865, %1821 ], [ 0, %1775 ]
%1823 = add nuw nsw i64 %1822, 384
%1824 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1823
%1825 = bitcast double* %1824 to <2 x double>*
%1826 = load <2 x double>, <2 x double>* %1825
%1827 = getelementptr inbounds double, double* %1824, i64 2
%1828 = bitcast double* %1827 to <2 x double>*
%1829 = load <2 x double>, <2 x double>* %1828
%1830 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1823
%1831 = bitcast double* %1830 to <2 x double>*
%1832 = load <2 x double>, <2 x double>* %1831
%1833 = getelementptr inbounds double, double* %1830, i64 2
%1834 = bitcast double* %1833 to <2 x double>*
%1835 = load <2 x double>, <2 x double>* %1834
%1836 = fadd <2 x double> %1826, %1832
%1837 = fadd <2 x double> %1829, %1835
%1838 = fadd <2 x double> %1836, <double 1.000000e+00, double 1.000000e+00>
%1839 = fadd <2 x double> %1837, <double 1.000000e+00, double 1.000000e+00>
%1840 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1823
%1841 = bitcast double* %1840 to <2 x double>*
store <2 x double> %1838, <2 x double>* %1841
%1842 = getelementptr inbounds double, double* %1840, i64 2
%1843 = bitcast double* %1842 to <2 x double>*
store <2 x double> %1839, <2 x double>* %1843
%1844 = add nuw nsw i64 %1822, 388
%1845 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1844
%1846 = bitcast double* %1845 to <2 x double>*
%1847 = load <2 x double>, <2 x double>* %1846
%1848 = getelementptr inbounds double, double* %1845, i64 2
%1849 = bitcast double* %1848 to <2 x double>*
%1850 = load <2 x double>, <2 x double>* %1849
%1851 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1844
%1852 = bitcast double* %1851 to <2 x double>*
%1853 = load <2 x double>, <2 x double>* %1852
%1854 = getelementptr inbounds double, double* %1851, i64 2
%1855 = bitcast double* %1854 to <2 x double>*
%1856 = load <2 x double>, <2 x double>* %1855
%1857 = fadd <2 x double> %1847, %1853
%1858 = fadd <2 x double> %1850, %1856
%1859 = fadd <2 x double> %1857, <double 1.000000e+00, double 1.000000e+00>
%1860 = fadd <2 x double> %1858, <double 1.000000e+00, double 1.000000e+00>
%1861 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1844
%1862 = bitcast double* %1861 to <2 x double>*
store <2 x double> %1859, <2 x double>* %1862
%1863 = getelementptr inbounds double, double* %1861, i64 2
%1864 = bitcast double* %1863 to <2 x double>*
store <2 x double> %1860, <2 x double>* %1864
%1865 = add nuw nsw i64 %1822, 8
%1866 = icmp eq i64 %1865, 128
br i1 %1866, label %1867, label %1821
1867: ; preds = %1821, %1867
%1868 = phi i64 [ %1911, %1867 ], [ 0, %1821 ]
%1869 = add nuw nsw i64 %1868, 512
%1870 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1869
%1871 = bitcast double* %1870 to <2 x double>*
%1872 = load <2 x double>, <2 x double>* %1871
%1873 = getelementptr inbounds double, double* %1870, i64 2
%1874 = bitcast double* %1873 to <2 x double>*
%1875 = load <2 x double>, <2 x double>* %1874
%1876 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1869
%1877 = bitcast double* %1876 to <2 x double>*
%1878 = load <2 x double>, <2 x double>* %1877
%1879 = getelementptr inbounds double, double* %1876, i64 2
%1880 = bitcast double* %1879 to <2 x double>*
%1881 = load <2 x double>, <2 x double>* %1880
%1882 = fadd <2 x double> %1872, %1878
%1883 = fadd <2 x double> %1875, %1881
%1884 = fadd <2 x double> %1882, <double 1.000000e+00, double 1.000000e+00>
%1885 = fadd <2 x double> %1883, <double 1.000000e+00, double 1.000000e+00>
%1886 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1869
%1887 = bitcast double* %1886 to <2 x double>*
store <2 x double> %1884, <2 x double>* %1887
%1888 = getelementptr inbounds double, double* %1886, i64 2
%1889 = bitcast double* %1888 to <2 x double>*
store <2 x double> %1885, <2 x double>* %1889
%1890 = add nuw nsw i64 %1868, 516
%1891 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1890
%1892 = bitcast double* %1891 to <2 x double>*
%1893 = load <2 x double>, <2 x double>* %1892
%1894 = getelementptr inbounds double, double* %1891, i64 2
%1895 = bitcast double* %1894 to <2 x double>*
%1896 = load <2 x double>, <2 x double>* %1895
%1897 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1890
%1898 = bitcast double* %1897 to <2 x double>*
%1899 = load <2 x double>, <2 x double>* %1898
%1900 = getelementptr inbounds double, double* %1897, i64 2
%1901 = bitcast double* %1900 to <2 x double>*
%1902 = load <2 x double>, <2 x double>* %1901
%1903 = fadd <2 x double> %1893, %1899
%1904 = fadd <2 x double> %1896, %1902
%1905 = fadd <2 x double> %1903, <double 1.000000e+00, double 1.000000e+00>
%1906 = fadd <2 x double> %1904, <double 1.000000e+00, double 1.000000e+00>
%1907 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1890
%1908 = bitcast double* %1907 to <2 x double>*
store <2 x double> %1905, <2 x double>* %1908
%1909 = getelementptr inbounds double, double* %1907, i64 2
%1910 = bitcast double* %1909 to <2 x double>*
store <2 x double> %1906, <2 x double>* %1910
%1911 = add nuw nsw i64 %1868, 8
%1912 = icmp eq i64 %1911, 128
br i1 %1912, label %1913, label %1867
1913: ; preds = %1867, %1913
%1914 = phi i64 [ %1957, %1913 ], [ 0, %1867 ]
%1915 = add nuw nsw i64 %1914, 640
%1916 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1915
%1917 = bitcast double* %1916 to <2 x double>*
%1918 = load <2 x double>, <2 x double>* %1917
%1919 = getelementptr inbounds double, double* %1916, i64 2
%1920 = bitcast double* %1919 to <2 x double>*
%1921 = load <2 x double>, <2 x double>* %1920
%1922 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1915
%1923 = bitcast double* %1922 to <2 x double>*
%1924 = load <2 x double>, <2 x double>* %1923
%1925 = getelementptr inbounds double, double* %1922, i64 2
%1926 = bitcast double* %1925 to <2 x double>*
%1927 = load <2 x double>, <2 x double>* %1926
%1928 = fadd <2 x double> %1918, %1924
%1929 = fadd <2 x double> %1921, %1927
%1930 = fadd <2 x double> %1928, <double 1.000000e+00, double 1.000000e+00>
%1931 = fadd <2 x double> %1929, <double 1.000000e+00, double 1.000000e+00>
%1932 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1915
%1933 = bitcast double* %1932 to <2 x double>*
store <2 x double> %1930, <2 x double>* %1933
%1934 = getelementptr inbounds double, double* %1932, i64 2
%1935 = bitcast double* %1934 to <2 x double>*
store <2 x double> %1931, <2 x double>* %1935
%1936 = add nuw nsw i64 %1914, 644
%1937 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1936
%1938 = bitcast double* %1937 to <2 x double>*
%1939 = load <2 x double>, <2 x double>* %1938
%1940 = getelementptr inbounds double, double* %1937, i64 2
%1941 = bitcast double* %1940 to <2 x double>*
%1942 = load <2 x double>, <2 x double>* %1941
%1943 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1936
%1944 = bitcast double* %1943 to <2 x double>*
%1945 = load <2 x double>, <2 x double>* %1944
%1946 = getelementptr inbounds double, double* %1943, i64 2
%1947 = bitcast double* %1946 to <2 x double>*
%1948 = load <2 x double>, <2 x double>* %1947
%1949 = fadd <2 x double> %1939, %1945
%1950 = fadd <2 x double> %1942, %1948
%1951 = fadd <2 x double> %1949, <double 1.000000e+00, double 1.000000e+00>
%1952 = fadd <2 x double> %1950, <double 1.000000e+00, double 1.000000e+00>
%1953 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1936
%1954 = bitcast double* %1953 to <2 x double>*
store <2 x double> %1951, <2 x double>* %1954
%1955 = getelementptr inbounds double, double* %1953, i64 2
%1956 = bitcast double* %1955 to <2 x double>*
store <2 x double> %1952, <2 x double>* %1956
%1957 = add nuw nsw i64 %1914, 8
%1958 = icmp eq i64 %1957, 128
br i1 %1958, label %1959, label %1913
1959: ; preds = %1913, %1959
%1960 = phi i64 [ %2003, %1959 ], [ 0, %1913 ]
%1961 = add nuw nsw i64 %1960, 768
%1962 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1961
%1963 = bitcast double* %1962 to <2 x double>*
%1964 = load <2 x double>, <2 x double>* %1963
%1965 = getelementptr inbounds double, double* %1962, i64 2
%1966 = bitcast double* %1965 to <2 x double>*
%1967 = load <2 x double>, <2 x double>* %1966
%1968 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1961
%1969 = bitcast double* %1968 to <2 x double>*
%1970 = load <2 x double>, <2 x double>* %1969
%1971 = getelementptr inbounds double, double* %1968, i64 2
%1972 = bitcast double* %1971 to <2 x double>*
%1973 = load <2 x double>, <2 x double>* %1972
%1974 = fadd <2 x double> %1964, %1970
%1975 = fadd <2 x double> %1967, %1973
%1976 = fadd <2 x double> %1974, <double 1.000000e+00, double 1.000000e+00>
%1977 = fadd <2 x double> %1975, <double 1.000000e+00, double 1.000000e+00>
%1978 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1961
%1979 = bitcast double* %1978 to <2 x double>*
store <2 x double> %1976, <2 x double>* %1979
%1980 = getelementptr inbounds double, double* %1978, i64 2
%1981 = bitcast double* %1980 to <2 x double>*
store <2 x double> %1977, <2 x double>* %1981
%1982 = add nuw nsw i64 %1960, 772
%1983 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %1982
%1984 = bitcast double* %1983 to <2 x double>*
%1985 = load <2 x double>, <2 x double>* %1984
%1986 = getelementptr inbounds double, double* %1983, i64 2
%1987 = bitcast double* %1986 to <2 x double>*
%1988 = load <2 x double>, <2 x double>* %1987
%1989 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %1982
%1990 = bitcast double* %1989 to <2 x double>*
%1991 = load <2 x double>, <2 x double>* %1990
%1992 = getelementptr inbounds double, double* %1989, i64 2
%1993 = bitcast double* %1992 to <2 x double>*
%1994 = load <2 x double>, <2 x double>* %1993
%1995 = fadd <2 x double> %1985, %1991
%1996 = fadd <2 x double> %1988, %1994
%1997 = fadd <2 x double> %1995, <double 1.000000e+00, double 1.000000e+00>
%1998 = fadd <2 x double> %1996, <double 1.000000e+00, double 1.000000e+00>
%1999 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %1982
%2000 = bitcast double* %1999 to <2 x double>*
store <2 x double> %1997, <2 x double>* %2000
%2001 = getelementptr inbounds double, double* %1999, i64 2
%2002 = bitcast double* %2001 to <2 x double>*
store <2 x double> %1998, <2 x double>* %2002
%2003 = add nuw nsw i64 %1960, 8
%2004 = icmp eq i64 %2003, 128
br i1 %2004, label %2005, label %1959
2005: ; preds = %1959, %2005
%2006 = phi i64 [ %2049, %2005 ], [ 0, %1959 ]
%2007 = add nuw nsw i64 %2006, 896
%2008 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2007
%2009 = bitcast double* %2008 to <2 x double>*
%2010 = load <2 x double>, <2 x double>* %2009
%2011 = getelementptr inbounds double, double* %2008, i64 2
%2012 = bitcast double* %2011 to <2 x double>*
%2013 = load <2 x double>, <2 x double>* %2012
%2014 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2007
%2015 = bitcast double* %2014 to <2 x double>*
%2016 = load <2 x double>, <2 x double>* %2015
%2017 = getelementptr inbounds double, double* %2014, i64 2
%2018 = bitcast double* %2017 to <2 x double>*
%2019 = load <2 x double>, <2 x double>* %2018
%2020 = fadd <2 x double> %2010, %2016
%2021 = fadd <2 x double> %2013, %2019
%2022 = fadd <2 x double> %2020, <double 1.000000e+00, double 1.000000e+00>
%2023 = fadd <2 x double> %2021, <double 1.000000e+00, double 1.000000e+00>
%2024 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2007
%2025 = bitcast double* %2024 to <2 x double>*
store <2 x double> %2022, <2 x double>* %2025
%2026 = getelementptr inbounds double, double* %2024, i64 2
%2027 = bitcast double* %2026 to <2 x double>*
store <2 x double> %2023, <2 x double>* %2027
%2028 = add nuw nsw i64 %2006, 900
%2029 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2028
%2030 = bitcast double* %2029 to <2 x double>*
%2031 = load <2 x double>, <2 x double>* %2030
%2032 = getelementptr inbounds double, double* %2029, i64 2
%2033 = bitcast double* %2032 to <2 x double>*
%2034 = load <2 x double>, <2 x double>* %2033
%2035 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2028
%2036 = bitcast double* %2035 to <2 x double>*
%2037 = load <2 x double>, <2 x double>* %2036
%2038 = getelementptr inbounds double, double* %2035, i64 2
%2039 = bitcast double* %2038 to <2 x double>*
%2040 = load <2 x double>, <2 x double>* %2039
%2041 = fadd <2 x double> %2031, %2037
%2042 = fadd <2 x double> %2034, %2040
%2043 = fadd <2 x double> %2041, <double 1.000000e+00, double 1.000000e+00>
%2044 = fadd <2 x double> %2042, <double 1.000000e+00, double 1.000000e+00>
%2045 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2028
%2046 = bitcast double* %2045 to <2 x double>*
store <2 x double> %2043, <2 x double>* %2046
%2047 = getelementptr inbounds double, double* %2045, i64 2
%2048 = bitcast double* %2047 to <2 x double>*
store <2 x double> %2044, <2 x double>* %2048
%2049 = add nuw nsw i64 %2006, 8
%2050 = icmp eq i64 %2049, 128
br i1 %2050, label %2051, label %2005
2051: ; preds = %2005, %2109
%2052 = phi i64 [ %2114, %2109 ], [ 0, %2005 ]
%2053 = phi i8* [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.20, i64 0, i64 0), %2109 ], [ getelementptr inbounds ([29 x i8], [29 x i8]* @str.17, i64 0, i64 0), %2005 ]
%2054 = phi i32 [ %2112, %2109 ], [ 0, %2005 ]
br label %2101
2055: ; preds = %1730, %2055
%2056 = phi i64 [ %2099, %2055 ], [ 0, %1730 ]
%2057 = add nuw nsw i64 %2056, 128
%2058 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2057
%2059 = bitcast double* %2058 to <2 x double>*
%2060 = load <2 x double>, <2 x double>* %2059
%2061 = getelementptr inbounds double, double* %2058, i64 2
%2062 = bitcast double* %2061 to <2 x double>*
%2063 = load <2 x double>, <2 x double>* %2062
%2064 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2057
%2065 = bitcast double* %2064 to <2 x double>*
%2066 = load <2 x double>, <2 x double>* %2065
%2067 = getelementptr inbounds double, double* %2064, i64 2
%2068 = bitcast double* %2067 to <2 x double>*
%2069 = load <2 x double>, <2 x double>* %2068
%2070 = fadd <2 x double> %2060, %2066
%2071 = fadd <2 x double> %2063, %2069
%2072 = fadd <2 x double> %2070, <double 1.000000e+00, double 1.000000e+00>
%2073 = fadd <2 x double> %2071, <double 1.000000e+00, double 1.000000e+00>
%2074 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2057
%2075 = bitcast double* %2074 to <2 x double>*
store <2 x double> %2072, <2 x double>* %2075
%2076 = getelementptr inbounds double, double* %2074, i64 2
%2077 = bitcast double* %2076 to <2 x double>*
store <2 x double> %2073, <2 x double>* %2077
%2078 = add nuw nsw i64 %2056, 132
%2079 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2078
%2080 = bitcast double* %2079 to <2 x double>*
%2081 = load <2 x double>, <2 x double>* %2080
%2082 = getelementptr inbounds double, double* %2079, i64 2
%2083 = bitcast double* %2082 to <2 x double>*
%2084 = load <2 x double>, <2 x double>* %2083
%2085 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2078
%2086 = bitcast double* %2085 to <2 x double>*
%2087 = load <2 x double>, <2 x double>* %2086
%2088 = getelementptr inbounds double, double* %2085, i64 2
%2089 = bitcast double* %2088 to <2 x double>*
%2090 = load <2 x double>, <2 x double>* %2089
%2091 = fadd <2 x double> %2081, %2087
%2092 = fadd <2 x double> %2084, %2090
%2093 = fadd <2 x double> %2091, <double 1.000000e+00, double 1.000000e+00>
%2094 = fadd <2 x double> %2092, <double 1.000000e+00, double 1.000000e+00>
%2095 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2078
%2096 = bitcast double* %2095 to <2 x double>*
store <2 x double> %2093, <2 x double>* %2096
%2097 = getelementptr inbounds double, double* %2095, i64 2
%2098 = bitcast double* %2097 to <2 x double>*
store <2 x double> %2094, <2 x double>* %2098
%2099 = add nuw nsw i64 %2056, 8
%2100 = icmp eq i64 %2099, 128
br i1 %2100, label %1775, label %2055
2101: ; preds = %2051, %2117
%2102 = phi i64 [ %2118, %2117 ], [ %2052, %2051 ]
%2103 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2102
%2104 = load double, double* %2103
%2105 = trunc i64 %2102 to i32
%2106 = add i32 %2105, 2
%2107 = sitofp i32 %2106 to double
%2108 = fcmp une double %2104, %2107
br i1 %2108, label %2109, label %2117
2109: ; preds = %2101
%2110 = trunc i64 %2102 to i32
%2111 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %2110, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %2107, double %2104)
%2112 = add nuw nsw i32 %2054, 1
%2113 = icmp ugt i32 %2054, 10
%2114 = add nuw nsw i64 %2102, 1
%2115 = icmp eq i64 %2114, 1024
%2116 = select i1 %2113, i1 true, i1 %2115
br i1 %2116, label %2120, label %2051
2117: ; preds = %2101
%2118 = add nuw nsw i64 %2102, 1
%2119 = icmp eq i64 %2118, 1024
br i1 %2119, label %2120, label %2101
2120: ; preds = %2109, %2117
%2121 = phi i8* [ %2053, %2117 ], [ getelementptr inbounds ([26 x i8], [26 x i8]* @str.20, i64 0, i64 0), %2109 ]
%2122 = tail call i32 @puts(i8* dereferenceable(1) %2121)
br label %2123
2123: ; preds = %2123, %2120
%2124 = phi i64 [ 0, %2120 ], [ %2150, %2123 ]
%2125 = phi <2 x i32> [ <i32 0, i32 1>, %2120 ], [ %2151, %2123 ]
%2126 = add <2 x i32> %2125, <i32 2, i32 2>
%2127 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2124
%2128 = bitcast double* %2127 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %2128
%2129 = getelementptr inbounds double, double* %2127, i64 2
%2130 = bitcast double* %2129 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %2130
%2131 = sitofp <2 x i32> %2125 to <2 x double>
%2132 = sitofp <2 x i32> %2126 to <2 x double>
%2133 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2124
%2134 = bitcast double* %2133 to <2 x double>*
store <2 x double> %2131, <2 x double>* %2134
%2135 = getelementptr inbounds double, double* %2133, i64 2
%2136 = bitcast double* %2135 to <2 x double>*
store <2 x double> %2132, <2 x double>* %2136
%2137 = or i64 %2124, 4
%2138 = add <2 x i32> %2125, <i32 4, i32 4>
%2139 = add <2 x i32> %2125, <i32 6, i32 6>
%2140 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2137
%2141 = bitcast double* %2140 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %2141
%2142 = getelementptr inbounds double, double* %2140, i64 2
%2143 = bitcast double* %2142 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %2143
%2144 = sitofp <2 x i32> %2138 to <2 x double>
%2145 = sitofp <2 x i32> %2139 to <2 x double>
%2146 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2137
%2147 = bitcast double* %2146 to <2 x double>*
store <2 x double> %2144, <2 x double>* %2147
%2148 = getelementptr inbounds double, double* %2146, i64 2
%2149 = bitcast double* %2148 to <2 x double>*
store <2 x double> %2145, <2 x double>* %2149
%2150 = add nuw nsw i64 %2124, 8
%2151 = add <2 x i32> %2125, <i32 8, i32 8>
%2152 = icmp eq i64 %2150, 1024
br i1 %2152, label %2153, label %2123
2153: ; preds = %2123, %2153
%2154 = phi i64 [ %2196, %2153 ], [ 0, %2123 ]
%2155 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2154
%2156 = bitcast double* %2155 to <2 x double>*
%2157 = load <2 x double>, <2 x double>* %2156
%2158 = getelementptr inbounds double, double* %2155, i64 2
%2159 = bitcast double* %2158 to <2 x double>*
%2160 = load <2 x double>, <2 x double>* %2159
%2161 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2154
%2162 = bitcast double* %2161 to <2 x double>*
%2163 = load <2 x double>, <2 x double>* %2162
%2164 = getelementptr inbounds double, double* %2161, i64 2
%2165 = bitcast double* %2164 to <2 x double>*
%2166 = load <2 x double>, <2 x double>* %2165
%2167 = fadd <2 x double> %2157, %2163
%2168 = fadd <2 x double> %2160, %2166
%2169 = fadd <2 x double> %2167, <double 1.000000e+00, double 1.000000e+00>
%2170 = fadd <2 x double> %2168, <double 1.000000e+00, double 1.000000e+00>
%2171 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2154
%2172 = bitcast double* %2171 to <2 x double>*
store <2 x double> %2169, <2 x double>* %2172
%2173 = getelementptr inbounds double, double* %2171, i64 2
%2174 = bitcast double* %2173 to <2 x double>*
store <2 x double> %2170, <2 x double>* %2174
%2175 = or i64 %2154, 4
%2176 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2175
%2177 = bitcast double* %2176 to <2 x double>*
%2178 = load <2 x double>, <2 x double>* %2177
%2179 = getelementptr inbounds double, double* %2176, i64 2
%2180 = bitcast double* %2179 to <2 x double>*
%2181 = load <2 x double>, <2 x double>* %2180
%2182 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2175
%2183 = bitcast double* %2182 to <2 x double>*
%2184 = load <2 x double>, <2 x double>* %2183
%2185 = getelementptr inbounds double, double* %2182, i64 2
%2186 = bitcast double* %2185 to <2 x double>*
%2187 = load <2 x double>, <2 x double>* %2186
%2188 = fadd <2 x double> %2178, %2184
%2189 = fadd <2 x double> %2181, %2187
%2190 = fadd <2 x double> %2188, <double 1.000000e+00, double 1.000000e+00>
%2191 = fadd <2 x double> %2189, <double 1.000000e+00, double 1.000000e+00>
%2192 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2175
%2193 = bitcast double* %2192 to <2 x double>*
store <2 x double> %2190, <2 x double>* %2193
%2194 = getelementptr inbounds double, double* %2192, i64 2
%2195 = bitcast double* %2194 to <2 x double>*
store <2 x double> %2191, <2 x double>* %2195
%2196 = add nuw nsw i64 %2154, 8
%2197 = icmp eq i64 %2196, 128
br i1 %2197, label %2478, label %2153
2198: ; preds = %2478, %2198
%2199 = phi i64 [ %2242, %2198 ], [ 0, %2478 ]
%2200 = add nuw nsw i64 %2199, 256
%2201 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2200
%2202 = bitcast double* %2201 to <2 x double>*
%2203 = load <2 x double>, <2 x double>* %2202
%2204 = getelementptr inbounds double, double* %2201, i64 2
%2205 = bitcast double* %2204 to <2 x double>*
%2206 = load <2 x double>, <2 x double>* %2205
%2207 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2200
%2208 = bitcast double* %2207 to <2 x double>*
%2209 = load <2 x double>, <2 x double>* %2208
%2210 = getelementptr inbounds double, double* %2207, i64 2
%2211 = bitcast double* %2210 to <2 x double>*
%2212 = load <2 x double>, <2 x double>* %2211
%2213 = fadd <2 x double> %2203, %2209
%2214 = fadd <2 x double> %2206, %2212
%2215 = fadd <2 x double> %2213, <double 1.000000e+00, double 1.000000e+00>
%2216 = fadd <2 x double> %2214, <double 1.000000e+00, double 1.000000e+00>
%2217 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2200
%2218 = bitcast double* %2217 to <2 x double>*
store <2 x double> %2215, <2 x double>* %2218
%2219 = getelementptr inbounds double, double* %2217, i64 2
%2220 = bitcast double* %2219 to <2 x double>*
store <2 x double> %2216, <2 x double>* %2220
%2221 = add nuw nsw i64 %2199, 260
%2222 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2221
%2223 = bitcast double* %2222 to <2 x double>*
%2224 = load <2 x double>, <2 x double>* %2223
%2225 = getelementptr inbounds double, double* %2222, i64 2
%2226 = bitcast double* %2225 to <2 x double>*
%2227 = load <2 x double>, <2 x double>* %2226
%2228 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2221
%2229 = bitcast double* %2228 to <2 x double>*
%2230 = load <2 x double>, <2 x double>* %2229
%2231 = getelementptr inbounds double, double* %2228, i64 2
%2232 = bitcast double* %2231 to <2 x double>*
%2233 = load <2 x double>, <2 x double>* %2232
%2234 = fadd <2 x double> %2224, %2230
%2235 = fadd <2 x double> %2227, %2233
%2236 = fadd <2 x double> %2234, <double 1.000000e+00, double 1.000000e+00>
%2237 = fadd <2 x double> %2235, <double 1.000000e+00, double 1.000000e+00>
%2238 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2221
%2239 = bitcast double* %2238 to <2 x double>*
store <2 x double> %2236, <2 x double>* %2239
%2240 = getelementptr inbounds double, double* %2238, i64 2
%2241 = bitcast double* %2240 to <2 x double>*
store <2 x double> %2237, <2 x double>* %2241
%2242 = add nuw nsw i64 %2199, 8
%2243 = icmp eq i64 %2242, 128
br i1 %2243, label %2244, label %2198
2244: ; preds = %2198, %2244
%2245 = phi i64 [ %2288, %2244 ], [ 0, %2198 ]
%2246 = add nuw nsw i64 %2245, 384
%2247 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2246
%2248 = bitcast double* %2247 to <2 x double>*
%2249 = load <2 x double>, <2 x double>* %2248
%2250 = getelementptr inbounds double, double* %2247, i64 2
%2251 = bitcast double* %2250 to <2 x double>*
%2252 = load <2 x double>, <2 x double>* %2251
%2253 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2246
%2254 = bitcast double* %2253 to <2 x double>*
%2255 = load <2 x double>, <2 x double>* %2254
%2256 = getelementptr inbounds double, double* %2253, i64 2
%2257 = bitcast double* %2256 to <2 x double>*
%2258 = load <2 x double>, <2 x double>* %2257
%2259 = fadd <2 x double> %2249, %2255
%2260 = fadd <2 x double> %2252, %2258
%2261 = fadd <2 x double> %2259, <double 1.000000e+00, double 1.000000e+00>
%2262 = fadd <2 x double> %2260, <double 1.000000e+00, double 1.000000e+00>
%2263 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2246
%2264 = bitcast double* %2263 to <2 x double>*
store <2 x double> %2261, <2 x double>* %2264
%2265 = getelementptr inbounds double, double* %2263, i64 2
%2266 = bitcast double* %2265 to <2 x double>*
store <2 x double> %2262, <2 x double>* %2266
%2267 = add nuw nsw i64 %2245, 388
%2268 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2267
%2269 = bitcast double* %2268 to <2 x double>*
%2270 = load <2 x double>, <2 x double>* %2269
%2271 = getelementptr inbounds double, double* %2268, i64 2
%2272 = bitcast double* %2271 to <2 x double>*
%2273 = load <2 x double>, <2 x double>* %2272
%2274 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2267
%2275 = bitcast double* %2274 to <2 x double>*
%2276 = load <2 x double>, <2 x double>* %2275
%2277 = getelementptr inbounds double, double* %2274, i64 2
%2278 = bitcast double* %2277 to <2 x double>*
%2279 = load <2 x double>, <2 x double>* %2278
%2280 = fadd <2 x double> %2270, %2276
%2281 = fadd <2 x double> %2273, %2279
%2282 = fadd <2 x double> %2280, <double 1.000000e+00, double 1.000000e+00>
%2283 = fadd <2 x double> %2281, <double 1.000000e+00, double 1.000000e+00>
%2284 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2267
%2285 = bitcast double* %2284 to <2 x double>*
store <2 x double> %2282, <2 x double>* %2285
%2286 = getelementptr inbounds double, double* %2284, i64 2
%2287 = bitcast double* %2286 to <2 x double>*
store <2 x double> %2283, <2 x double>* %2287
%2288 = add nuw nsw i64 %2245, 8
%2289 = icmp eq i64 %2288, 128
br i1 %2289, label %2290, label %2244
2290: ; preds = %2244, %2290
%2291 = phi i64 [ %2334, %2290 ], [ 0, %2244 ]
%2292 = add nuw nsw i64 %2291, 512
%2293 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2292
%2294 = bitcast double* %2293 to <2 x double>*
%2295 = load <2 x double>, <2 x double>* %2294
%2296 = getelementptr inbounds double, double* %2293, i64 2
%2297 = bitcast double* %2296 to <2 x double>*
%2298 = load <2 x double>, <2 x double>* %2297
%2299 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2292
%2300 = bitcast double* %2299 to <2 x double>*
%2301 = load <2 x double>, <2 x double>* %2300
%2302 = getelementptr inbounds double, double* %2299, i64 2
%2303 = bitcast double* %2302 to <2 x double>*
%2304 = load <2 x double>, <2 x double>* %2303
%2305 = fadd <2 x double> %2295, %2301
%2306 = fadd <2 x double> %2298, %2304
%2307 = fadd <2 x double> %2305, <double 1.000000e+00, double 1.000000e+00>
%2308 = fadd <2 x double> %2306, <double 1.000000e+00, double 1.000000e+00>
%2309 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2292
%2310 = bitcast double* %2309 to <2 x double>*
store <2 x double> %2307, <2 x double>* %2310
%2311 = getelementptr inbounds double, double* %2309, i64 2
%2312 = bitcast double* %2311 to <2 x double>*
store <2 x double> %2308, <2 x double>* %2312
%2313 = add nuw nsw i64 %2291, 516
%2314 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2313
%2315 = bitcast double* %2314 to <2 x double>*
%2316 = load <2 x double>, <2 x double>* %2315
%2317 = getelementptr inbounds double, double* %2314, i64 2
%2318 = bitcast double* %2317 to <2 x double>*
%2319 = load <2 x double>, <2 x double>* %2318
%2320 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2313
%2321 = bitcast double* %2320 to <2 x double>*
%2322 = load <2 x double>, <2 x double>* %2321
%2323 = getelementptr inbounds double, double* %2320, i64 2
%2324 = bitcast double* %2323 to <2 x double>*
%2325 = load <2 x double>, <2 x double>* %2324
%2326 = fadd <2 x double> %2316, %2322
%2327 = fadd <2 x double> %2319, %2325
%2328 = fadd <2 x double> %2326, <double 1.000000e+00, double 1.000000e+00>
%2329 = fadd <2 x double> %2327, <double 1.000000e+00, double 1.000000e+00>
%2330 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2313
%2331 = bitcast double* %2330 to <2 x double>*
store <2 x double> %2328, <2 x double>* %2331
%2332 = getelementptr inbounds double, double* %2330, i64 2
%2333 = bitcast double* %2332 to <2 x double>*
store <2 x double> %2329, <2 x double>* %2333
%2334 = add nuw nsw i64 %2291, 8
%2335 = icmp eq i64 %2334, 128
br i1 %2335, label %2336, label %2290
2336: ; preds = %2290, %2336
%2337 = phi i64 [ %2380, %2336 ], [ 0, %2290 ]
%2338 = add nuw nsw i64 %2337, 640
%2339 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2338
%2340 = bitcast double* %2339 to <2 x double>*
%2341 = load <2 x double>, <2 x double>* %2340
%2342 = getelementptr inbounds double, double* %2339, i64 2
%2343 = bitcast double* %2342 to <2 x double>*
%2344 = load <2 x double>, <2 x double>* %2343
%2345 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2338
%2346 = bitcast double* %2345 to <2 x double>*
%2347 = load <2 x double>, <2 x double>* %2346
%2348 = getelementptr inbounds double, double* %2345, i64 2
%2349 = bitcast double* %2348 to <2 x double>*
%2350 = load <2 x double>, <2 x double>* %2349
%2351 = fadd <2 x double> %2341, %2347
%2352 = fadd <2 x double> %2344, %2350
%2353 = fadd <2 x double> %2351, <double 1.000000e+00, double 1.000000e+00>
%2354 = fadd <2 x double> %2352, <double 1.000000e+00, double 1.000000e+00>
%2355 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2338
%2356 = bitcast double* %2355 to <2 x double>*
store <2 x double> %2353, <2 x double>* %2356
%2357 = getelementptr inbounds double, double* %2355, i64 2
%2358 = bitcast double* %2357 to <2 x double>*
store <2 x double> %2354, <2 x double>* %2358
%2359 = add nuw nsw i64 %2337, 644
%2360 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2359
%2361 = bitcast double* %2360 to <2 x double>*
%2362 = load <2 x double>, <2 x double>* %2361
%2363 = getelementptr inbounds double, double* %2360, i64 2
%2364 = bitcast double* %2363 to <2 x double>*
%2365 = load <2 x double>, <2 x double>* %2364
%2366 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2359
%2367 = bitcast double* %2366 to <2 x double>*
%2368 = load <2 x double>, <2 x double>* %2367
%2369 = getelementptr inbounds double, double* %2366, i64 2
%2370 = bitcast double* %2369 to <2 x double>*
%2371 = load <2 x double>, <2 x double>* %2370
%2372 = fadd <2 x double> %2362, %2368
%2373 = fadd <2 x double> %2365, %2371
%2374 = fadd <2 x double> %2372, <double 1.000000e+00, double 1.000000e+00>
%2375 = fadd <2 x double> %2373, <double 1.000000e+00, double 1.000000e+00>
%2376 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2359
%2377 = bitcast double* %2376 to <2 x double>*
store <2 x double> %2374, <2 x double>* %2377
%2378 = getelementptr inbounds double, double* %2376, i64 2
%2379 = bitcast double* %2378 to <2 x double>*
store <2 x double> %2375, <2 x double>* %2379
%2380 = add nuw nsw i64 %2337, 8
%2381 = icmp eq i64 %2380, 128
br i1 %2381, label %2382, label %2336
2382: ; preds = %2336, %2382
%2383 = phi i64 [ %2426, %2382 ], [ 0, %2336 ]
%2384 = add nuw nsw i64 %2383, 768
%2385 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2384
%2386 = bitcast double* %2385 to <2 x double>*
%2387 = load <2 x double>, <2 x double>* %2386
%2388 = getelementptr inbounds double, double* %2385, i64 2
%2389 = bitcast double* %2388 to <2 x double>*
%2390 = load <2 x double>, <2 x double>* %2389
%2391 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2384
%2392 = bitcast double* %2391 to <2 x double>*
%2393 = load <2 x double>, <2 x double>* %2392
%2394 = getelementptr inbounds double, double* %2391, i64 2
%2395 = bitcast double* %2394 to <2 x double>*
%2396 = load <2 x double>, <2 x double>* %2395
%2397 = fadd <2 x double> %2387, %2393
%2398 = fadd <2 x double> %2390, %2396
%2399 = fadd <2 x double> %2397, <double 1.000000e+00, double 1.000000e+00>
%2400 = fadd <2 x double> %2398, <double 1.000000e+00, double 1.000000e+00>
%2401 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2384
%2402 = bitcast double* %2401 to <2 x double>*
store <2 x double> %2399, <2 x double>* %2402
%2403 = getelementptr inbounds double, double* %2401, i64 2
%2404 = bitcast double* %2403 to <2 x double>*
store <2 x double> %2400, <2 x double>* %2404
%2405 = add nuw nsw i64 %2383, 772
%2406 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2405
%2407 = bitcast double* %2406 to <2 x double>*
%2408 = load <2 x double>, <2 x double>* %2407
%2409 = getelementptr inbounds double, double* %2406, i64 2
%2410 = bitcast double* %2409 to <2 x double>*
%2411 = load <2 x double>, <2 x double>* %2410
%2412 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2405
%2413 = bitcast double* %2412 to <2 x double>*
%2414 = load <2 x double>, <2 x double>* %2413
%2415 = getelementptr inbounds double, double* %2412, i64 2
%2416 = bitcast double* %2415 to <2 x double>*
%2417 = load <2 x double>, <2 x double>* %2416
%2418 = fadd <2 x double> %2408, %2414
%2419 = fadd <2 x double> %2411, %2417
%2420 = fadd <2 x double> %2418, <double 1.000000e+00, double 1.000000e+00>
%2421 = fadd <2 x double> %2419, <double 1.000000e+00, double 1.000000e+00>
%2422 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2405
%2423 = bitcast double* %2422 to <2 x double>*
store <2 x double> %2420, <2 x double>* %2423
%2424 = getelementptr inbounds double, double* %2422, i64 2
%2425 = bitcast double* %2424 to <2 x double>*
store <2 x double> %2421, <2 x double>* %2425
%2426 = add nuw nsw i64 %2383, 8
%2427 = icmp eq i64 %2426, 128
br i1 %2427, label %2428, label %2382
2428: ; preds = %2382, %2428
%2429 = phi i64 [ %2472, %2428 ], [ 0, %2382 ]
%2430 = add nuw nsw i64 %2429, 896
%2431 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2430
%2432 = bitcast double* %2431 to <2 x double>*
%2433 = load <2 x double>, <2 x double>* %2432
%2434 = getelementptr inbounds double, double* %2431, i64 2
%2435 = bitcast double* %2434 to <2 x double>*
%2436 = load <2 x double>, <2 x double>* %2435
%2437 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2430
%2438 = bitcast double* %2437 to <2 x double>*
%2439 = load <2 x double>, <2 x double>* %2438
%2440 = getelementptr inbounds double, double* %2437, i64 2
%2441 = bitcast double* %2440 to <2 x double>*
%2442 = load <2 x double>, <2 x double>* %2441
%2443 = fadd <2 x double> %2433, %2439
%2444 = fadd <2 x double> %2436, %2442
%2445 = fadd <2 x double> %2443, <double 1.000000e+00, double 1.000000e+00>
%2446 = fadd <2 x double> %2444, <double 1.000000e+00, double 1.000000e+00>
%2447 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2430
%2448 = bitcast double* %2447 to <2 x double>*
store <2 x double> %2445, <2 x double>* %2448
%2449 = getelementptr inbounds double, double* %2447, i64 2
%2450 = bitcast double* %2449 to <2 x double>*
store <2 x double> %2446, <2 x double>* %2450
%2451 = add nuw nsw i64 %2429, 900
%2452 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2451
%2453 = bitcast double* %2452 to <2 x double>*
%2454 = load <2 x double>, <2 x double>* %2453
%2455 = getelementptr inbounds double, double* %2452, i64 2
%2456 = bitcast double* %2455 to <2 x double>*
%2457 = load <2 x double>, <2 x double>* %2456
%2458 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2451
%2459 = bitcast double* %2458 to <2 x double>*
%2460 = load <2 x double>, <2 x double>* %2459
%2461 = getelementptr inbounds double, double* %2458, i64 2
%2462 = bitcast double* %2461 to <2 x double>*
%2463 = load <2 x double>, <2 x double>* %2462
%2464 = fadd <2 x double> %2454, %2460
%2465 = fadd <2 x double> %2457, %2463
%2466 = fadd <2 x double> %2464, <double 1.000000e+00, double 1.000000e+00>
%2467 = fadd <2 x double> %2465, <double 1.000000e+00, double 1.000000e+00>
%2468 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2451
%2469 = bitcast double* %2468 to <2 x double>*
store <2 x double> %2466, <2 x double>* %2469
%2470 = getelementptr inbounds double, double* %2468, i64 2
%2471 = bitcast double* %2470 to <2 x double>*
store <2 x double> %2467, <2 x double>* %2471
%2472 = add nuw nsw i64 %2429, 8
%2473 = icmp eq i64 %2472, 128
br i1 %2473, label %2474, label %2428
2474: ; preds = %2428, %2532
%2475 = phi i64 [ %2537, %2532 ], [ 0, %2428 ]
%2476 = phi i32 [ %2535, %2532 ], [ 0, %2428 ]
%2477 = phi i8* [ getelementptr inbounds ([30 x i8], [30 x i8]* @str.19, i64 0, i64 0), %2532 ], [ getelementptr inbounds ([33 x i8], [33 x i8]* @str.18, i64 0, i64 0), %2428 ]
br label %2524
2478: ; preds = %2153, %2478
%2479 = phi i64 [ %2522, %2478 ], [ 0, %2153 ]
%2480 = add nuw nsw i64 %2479, 128
%2481 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2480
%2482 = bitcast double* %2481 to <2 x double>*
%2483 = load <2 x double>, <2 x double>* %2482
%2484 = getelementptr inbounds double, double* %2481, i64 2
%2485 = bitcast double* %2484 to <2 x double>*
%2486 = load <2 x double>, <2 x double>* %2485
%2487 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2480
%2488 = bitcast double* %2487 to <2 x double>*
%2489 = load <2 x double>, <2 x double>* %2488
%2490 = getelementptr inbounds double, double* %2487, i64 2
%2491 = bitcast double* %2490 to <2 x double>*
%2492 = load <2 x double>, <2 x double>* %2491
%2493 = fadd <2 x double> %2483, %2489
%2494 = fadd <2 x double> %2486, %2492
%2495 = fadd <2 x double> %2493, <double 1.000000e+00, double 1.000000e+00>
%2496 = fadd <2 x double> %2494, <double 1.000000e+00, double 1.000000e+00>
%2497 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2480
%2498 = bitcast double* %2497 to <2 x double>*
store <2 x double> %2495, <2 x double>* %2498
%2499 = getelementptr inbounds double, double* %2497, i64 2
%2500 = bitcast double* %2499 to <2 x double>*
store <2 x double> %2496, <2 x double>* %2500
%2501 = add nuw nsw i64 %2479, 132
%2502 = getelementptr inbounds [1024 x double], [1024 x double]* %3, i64 0, i64 %2501
%2503 = bitcast double* %2502 to <2 x double>*
%2504 = load <2 x double>, <2 x double>* %2503
%2505 = getelementptr inbounds double, double* %2502, i64 2
%2506 = bitcast double* %2505 to <2 x double>*
%2507 = load <2 x double>, <2 x double>* %2506
%2508 = getelementptr inbounds [1024 x double], [1024 x double]* %4, i64 0, i64 %2501
%2509 = bitcast double* %2508 to <2 x double>*
%2510 = load <2 x double>, <2 x double>* %2509
%2511 = getelementptr inbounds double, double* %2508, i64 2
%2512 = bitcast double* %2511 to <2 x double>*
%2513 = load <2 x double>, <2 x double>* %2512
%2514 = fadd <2 x double> %2504, %2510
%2515 = fadd <2 x double> %2507, %2513
%2516 = fadd <2 x double> %2514, <double 1.000000e+00, double 1.000000e+00>
%2517 = fadd <2 x double> %2515, <double 1.000000e+00, double 1.000000e+00>
%2518 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2501
%2519 = bitcast double* %2518 to <2 x double>*
store <2 x double> %2516, <2 x double>* %2519
%2520 = getelementptr inbounds double, double* %2518, i64 2
%2521 = bitcast double* %2520 to <2 x double>*
store <2 x double> %2517, <2 x double>* %2521
%2522 = add nuw nsw i64 %2479, 8
%2523 = icmp eq i64 %2522, 128
br i1 %2523, label %2198, label %2478
2524: ; preds = %2474, %2540
%2525 = phi i64 [ %2541, %2540 ], [ %2475, %2474 ]
%2526 = getelementptr inbounds [1024 x double], [1024 x double]* %1, i64 0, i64 %2525
%2527 = load double, double* %2526
%2528 = trunc i64 %2525 to i32
%2529 = add i32 %2528, 2
%2530 = sitofp i32 %2529 to double
%2531 = fcmp une double %2527, %2530
br i1 %2531, label %2532, label %2540
2532: ; preds = %2524
%2533 = trunc i64 %2525 to i32
%2534 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %2533, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %2530, double %2527)
%2535 = add nuw nsw i32 %2476, 1
%2536 = icmp ugt i32 %2476, 10
%2537 = add nuw nsw i64 %2525, 1
%2538 = icmp eq i64 %2537, 1024
%2539 = select i1 %2536, i1 true, i1 %2538
br i1 %2539, label %2543, label %2474
2540: ; preds = %2524
%2541 = add nuw nsw i64 %2525, 1
%2542 = icmp eq i64 %2541, 1024
br i1 %2542, label %2543, label %2524
2543: ; preds = %2532, %2540
%2544 = phi i8* [ %2477, %2540 ], [ getelementptr inbounds ([30 x i8], [30 x i8]* @str.19, i64 0, i64 0), %2532 ]
%2545 = tail call i32 @puts(i8* dereferenceable(1) %2544)
ret i32 0
}