#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();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  double *ptrA = &A[0];
  unsigned long long addr1;
  unsigned long long addr2;
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  for (int t = 0; t < (1); t++) {
    int threads[1];
    threads[0] = t;
    for (int i = 0; i < (992); i++) {
      A[i] = 1.0;
    }
#pragma omp target data map(A)
    {
#pragma omp target data map(B) use_device_ptr(ptrA)
      {
        addr1 = (unsigned long long)((void *)ptrA);
#pragma omp target is_device_ptr(ptrA) map(to : D, E) map(from : addr2)
        {
          addr2 = (unsigned long long)((void *)ptrA);
          for (int i = 0; i < (992); i++) {
            ptrA[i] += D[i] - E[i];
          }
        }
      }
    }
    int error = 0;
    if (addr1 != addr2)
      printf("Address of A: 0x%llx, ptrA on host 0x%llx, in use device 0x%llx, "
             "on device 0x%llx, error %d\n",
             (unsigned long long)((void *)&A[0]),
             (unsigned long long)((void *)ptrA), addr1, addr2, ++error);
    for (int i = 0; i < (992); i++) {
      if (A[i] != 2.0 * i + 1.0)
        printf("%d: got %f, wanted %f, error %d\n", i, A[i], 2.0 * i + 1.0,
               ++error);
    }
    if (error)
      printf("Failed with %d errors\n", error);
    else
      printf("Success\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9b50,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1040 <check_offloading@plt>
lea    -0x1f10(%rbp),%rax
mov    %rax,-0x9b18(%rbp)
movl   $0x0,-0x9b2c(%rbp)
cmpl   $0x3e0,-0x9b2c(%rbp)
jge    11c1 <main+0xa1>
movslq -0x9b2c(%rbp),%rax
movsd  0xe90(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b2c(%rbp),%xmm0
ff
movslq -0x9b2c(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b2c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b2c(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b2c(%rbp)
jmp    1151 <main+0x31>
movl   $0x0,-0x9b30(%rbp)
cmpl   $0x1,-0x9b30(%rbp)
jge    140e <main+0x2ee>
mov    -0x9b30(%rbp),%eax
mov    %eax,-0x9b34(%rbp)
movl   $0x0,-0x9b38(%rbp)
cmpl   $0x3e0,-0x9b38(%rbp)
jge    122a <main+0x10a>
movslq -0x9b38(%rbp),%rax
movsd  0xdf3(%rip),%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b38(%rbp)
jmp    11ee <main+0xce>
mov    -0x9b18(%rbp),%rax
mov    %rax,-0x9b20(%rbp)
mov    -0x9b18(%rbp),%rax
mov    %rax,-0x9b28(%rbp)
movl   $0x0,-0x9b3c(%rbp)
cmpl   $0x3e0,-0x9b3c(%rbp)
jge    12ac <main+0x18c>
movslq -0x9b3c(%rbp),%rax
movsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b3c(%rbp),%rax
subsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b18(%rbp),%rax
movslq -0x9b3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9b3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b3c(%rbp)
jmp    1250 <main+0x130>
movl   $0x0,-0x9b40(%rbp)
mov    -0x9b20(%rbp),%rax
cmp    -0x9b28(%rbp),%rax
je     1306 <main+0x1e6>
lea    -0x1f10(%rbp),%rsi
mov    -0x9b18(%rbp),%rdx
mov    -0x9b20(%rbp),%rcx
mov    -0x9b28(%rbp),%r8
mov    -0x9b40(%rbp),%r9d
add    $0x1,%r9d
mov    %r9d,-0x9b40(%rbp)
lea    0xd09(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b44(%rbp)
cmpl   $0x3e0,-0x9b44(%rbp)
jge    13c1 <main+0x2a1>
movslq -0x9b44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9b44(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
movsd  0xcbc(%rip),%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    135d <main+0x23d>
jp     135d <main+0x23d>
jmp    13a8 <main+0x288>
mov    -0x9b44(%rbp),%esi
movslq -0x9b44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9b44(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
movsd  0xc79(%rip),%xmm2
addsd  %xmm2,%xmm1
mov    -0x9b40(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x9b40(%rbp)
lea    0xcc4(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    13ad <main+0x28d>
mov    -0x9b44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b44(%rbp)
jmp    1310 <main+0x1f0>
cmpl   $0x0,-0x9b40(%rbp)
je     13e7 <main+0x2c7>
mov    -0x9b40(%rbp),%esi
lea    0xcab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13f5 <main+0x2d5>
lea    0xcaf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13fa <main+0x2da>
mov    -0x9b30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b30(%rbp)
jmp    11cb <main+0xab>
xor    %eax,%eax
add    $0x9b50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x5d00,%rsp
xor    %eax,%eax
call   1050 <check_offloading@plt>
movdqa 0xeb6(%rip),%xmm0
mov    $0x2,%eax
movdqa 0xeb9(%rip),%xmm1
movdqa 0xec1(%rip),%xmm2
movdqa 0xec9(%rip),%xmm3
movdqa %xmm0,%xmm4
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
cvtdq2pd %xmm0,%xmm6
cvtdq2pd %xmm5,%xmm5
movaps %xmm6,0x3df0(%rsp,%rax,8)
movdqa %xmm5,0x3e00(%rsp,%rax,8)
pxor   %xmm5,%xmm5
psubd  %xmm4,%xmm5
movdqa %xmm2,%xmm6
psubd  %xmm4,%xmm6
cvtdq2pd %xmm5,%xmm5
cvtdq2pd %xmm6,%xmm6
movaps %xmm5,0x1ef0(%rsp,%rax,8)
movaps %xmm6,0x1f00(%rsp,%rax,8)
paddd  %xmm3,%xmm0
paddd  %xmm3,%xmm4
add    $0x4,%rax
cmp    $0x3e2,%rax
jne    1170 <main+0x40>
mov    $0x1e,%eax
movapd 0xe66(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movapd %xmm0,-0xf0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0xe0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0xd0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0xc0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0xb0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0xa0(%rsp,%rax,8)
ff ff
movapd %xmm0,-0x90(%rsp,%rax,8)
ff ff
movapd %xmm0,-0x80(%rsp,%rax,8)
movapd %xmm0,-0x70(%rsp,%rax,8)
movapd %xmm0,-0x60(%rsp,%rax,8)
movapd %xmm0,-0x50(%rsp,%rax,8)
movapd %xmm0,-0x40(%rsp,%rax,8)
movapd %xmm0,-0x30(%rsp,%rax,8)
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm0,-0x10(%rsp,%rax,8)
movapd %xmm0,(%rsp,%rax,8)
add    $0x20,%rax
cmp    $0x3fe,%rax
jne    11e0 <main+0xb0>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x3dd0(%rsp,%rax,8),%xmm0
movapd 0x3de0(%rsp,%rax,8),%xmm1
movapd 0x3df0(%rsp,%rax,8),%xmm2
movapd 0x3e00(%rsp,%rax,8),%xmm3
subpd  0x1ed0(%rsp,%rax,8),%xmm0
subpd  0x1ee0(%rsp,%rax,8),%xmm1
addpd  -0x30(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x30(%rsp,%rax,8)
movapd %xmm1,-0x20(%rsp,%rax,8)
subpd  0x1ef0(%rsp,%rax,8),%xmm2
subpd  0x1f00(%rsp,%rax,8),%xmm3
addpd  -0x10(%rsp,%rax,8),%xmm2
addpd  (%rsp,%rax,8),%xmm3
movapd %xmm2,-0x10(%rsp,%rax,8)
movapd %xmm3,(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x3e6,%rax
jne    1270 <main+0x140>
xor    %ebx,%ebx
lea    0xd59(%rip),%r14
xor    %ebp,%ebp
jmp    131d <main+0x1ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     1350 <main+0x220>
movsd  (%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
addsd  %xmm1,%xmm1
addsd  0xd1b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    133d <main+0x20d>
jnp    1310 <main+0x1e0>
add    $0x1,%ebp
mov    %r14,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    $0x2,%al
call   1040 <printf@plt>
jmp    1310 <main+0x1e0>
test   %ebp,%ebp
je     1366 <main+0x236>
lea    0xd1e(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1372 <main+0x242>
lea    0xd23(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x5d00,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@.str = [93 x i8] c"Address of A: 0x%llx, ptrA on host 0x%llx, in use device 0x%llx, on device 0x%llx, error %d\0A\00"
@.str.1 = [33 x i8] c"%d: got %f, wanted %f, error %d\0A\00"
@.str.2 = [23 x i8] c"Failed with %d errors\0A\00"
@.str.3 = [9 x i8] c"Success\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [992 x double]
%3 = alloca [992 x double]
%4 = alloca [992 x double]
%5 = alloca [992 x double]
%6 = alloca [992 x double]
%7 = alloca double*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca [1 x i32]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32 0, i32* %1
%17 = call i32 (...) @check_offloading()
%18 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double* %18, double** %7
store i32 0, i32* %10
br label %19
19: ; preds = %37, %0
%20 = load i32, i32* %10
%21 = icmp slt i32 %20, 992
br i1 %21, label %22, label %40
22: ; preds = %19
%23 = load i32, i32* %10
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %24
store double 1.000000e+00, double* %25
%26 = load i32, i32* %10
%27 = sitofp i32 %26 to double
%28 = load i32, i32* %10
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %29
store double %27, double* %30
%31 = load i32, i32* %10
%32 = sub nsw i32 0, %31
%33 = sitofp i32 %32 to double
%34 = load i32, i32* %10
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %35
store double %33, double* %36
br label %37
37: ; preds = %22
%38 = load i32, i32* %10
%39 = add nsw i32 %38, 1
store i32 %39, i32* %10
br label %19
40: ; preds = %19
store i32 0, i32* %11
br label %41
41: ; preds = %140, %40
%42 = load i32, i32* %11
%43 = icmp slt i32 %42, 1
br i1 %43, label %44, label %143
44: ; preds = %41
%45 = load i32, i32* %11
%46 = getelementptr inbounds [1 x i32], [1 x i32]* %12, i64 0, i64 0
store i32 %45, i32* %46
store i32 0, i32* %13
br label %47
47: ; preds = %54, %44
%48 = load i32, i32* %13
%49 = icmp slt i32 %48, 992
br i1 %49, label %50, label %57
50: ; preds = %47
%51 = load i32, i32* %13
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %52
store double 1.000000e+00, double* %53
br label %54
54: ; preds = %50
%55 = load i32, i32* %13
%56 = add nsw i32 %55, 1
store i32 %56, i32* %13
br label %47
57: ; preds = %47
%58 = load double*, double** %7
%59 = bitcast double* %58 to i8*
%60 = ptrtoint i8* %59 to i64
store i64 %60, i64* %8
%61 = load double*, double** %7
%62 = bitcast double* %61 to i8*
%63 = ptrtoint i8* %62 to i64
store i64 %63, i64* %9
store i32 0, i32* %14
br label %64
64: ; preds = %83, %57
%65 = load i32, i32* %14
%66 = icmp slt i32 %65, 992
br i1 %66, label %67, label %86
67: ; preds = %64
%68 = load i32, i32* %14
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %69
%71 = load double, double* %70
%72 = load i32, i32* %14
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %73
%75 = load double, double* %74
%76 = fsub double %71, %75
%77 = load double*, double** %7
%78 = load i32, i32* %14
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = fadd double %81, %76
store double %82, double* %80
br label %83
83: ; preds = %67
%84 = load i32, i32* %14
%85 = add nsw i32 %84, 1
store i32 %85, i32* %14
br label %64
86: ; preds = %64
store i32 0, i32* %15
%87 = load i64, i64* %8
%88 = load i64, i64* %9
%89 = icmp ne i64 %87, %88
br i1 %89, label %90, label %102
90: ; preds = %86
%91 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%92 = bitcast double* %91 to i8*
%93 = ptrtoint i8* %92 to i64
%94 = load double*, double** %7
%95 = bitcast double* %94 to i8*
%96 = ptrtoint i8* %95 to i64
%97 = load i64, i64* %8
%98 = load i64, i64* %9
%99 = load i32, i32* %15
%100 = add nsw i32 %99, 1
store i32 %100, i32* %15
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str, i64 0, i64 0), i64 %93, i64 %96, i64 %97, i64 %98, i32 %100)
br label %102
102: ; preds = %90, %86
store i32 0, i32* %16
br label %103
103: ; preds = %128, %102
%104 = load i32, i32* %16
%105 = icmp slt i32 %104, 992
br i1 %105, label %106, label %131
106: ; preds = %103
%107 = load i32, i32* %16
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %108
%110 = load double, double* %109
%111 = load i32, i32* %16
%112 = sitofp i32 %111 to double
%113 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %112, double 1.000000e+00)
%114 = fcmp une double %110, %113
br i1 %114, label %115, label %127
115: ; preds = %106
%116 = load i32, i32* %16
%117 = load i32, i32* %16
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %118
%120 = load double, double* %119
%121 = load i32, i32* %16
%122 = sitofp i32 %121 to double
%123 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %122, double 1.000000e+00)
%124 = load i32, i32* %15
%125 = add nsw i32 %124, 1
store i32 %125, i32* %15
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i32 %116, double %120, double %123, i32 %125)
br label %127
127: ; preds = %115, %106
br label %128
128: ; preds = %127
%129 = load i32, i32* %16
%130 = add nsw i32 %129, 1
store i32 %130, i32* %16
br label %103
131: ; preds = %103
%132 = load i32, i32* %15
%133 = icmp ne i32 %132, 0
br i1 %133, label %134, label %137
134: ; preds = %131
%135 = load i32, i32* %15
%136 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %135)
br label %139
137: ; preds = %131
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br label %139
139: ; preds = %137, %134
br label %140
140: ; preds = %139
%141 = load i32, i32* %11
%142 = add nsw i32 %141, 1
store i32 %142, i32* %11
br label %41
143: ; preds = %41
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [33 x i8] c"%d: got %f, wanted %f, error %d\0A\00"
@.str.2 = [23 x i8] c"Failed with %d errors\0A\00"
@str = [8 x i8] c"Success\00"
define i32 @main() {
%1 = alloca [992 x double]
%2 = alloca [992 x double]
%3 = alloca [992 x double]
%4 = tail call i32 (...) @check_offloading()
%5 = bitcast [992 x double]* %1 to i8*
%6 = bitcast [992 x double]* %2 to i8*
%7 = bitcast [992 x double]* %3 to i8*
br label %8
8: ; preds = %8, %0
%9 = phi i64 [ 0, %0 ], [ %27, %8 ]
%10 = phi <2 x i32> [ <i32 0, i32 1>, %0 ], [ %28, %8 ]
%11 = phi <2 x i32> [ <i32 0, i32 1>, %0 ], [ %29, %8 ]
%12 = add <2 x i32> %10, <i32 2, i32 2>
%13 = sitofp <2 x i32> %10 to <2 x double>
%14 = sitofp <2 x i32> %12 to <2 x double>
%15 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %9
%16 = bitcast double* %15 to <2 x double>*
store <2 x double> %13, <2 x double>* %16
%17 = getelementptr inbounds double, double* %15, i64 2
%18 = bitcast double* %17 to <2 x double>*
store <2 x double> %14, <2 x double>* %18
%19 = sub <2 x i32> zeroinitializer, %11
%20 = sub <2 x i32> <i32 -2, i32 -2>, %11
%21 = sitofp <2 x i32> %19 to <2 x double>
%22 = sitofp <2 x i32> %20 to <2 x double>
%23 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %9
%24 = bitcast double* %23 to <2 x double>*
store <2 x double> %21, <2 x double>* %24
%25 = getelementptr inbounds double, double* %23, i64 2
%26 = bitcast double* %25 to <2 x double>*
store <2 x double> %22, <2 x double>* %26
%27 = add nuw i64 %9, 4
%28 = add <2 x i32> %10, <i32 4, i32 4>
%29 = add <2 x i32> %11, <i32 4, i32 4>
%30 = icmp eq i64 %27, 992
br i1 %30, label %31, label %8
31: ; preds = %8, %31
%32 = phi i64 [ %72, %31 ], [ 0, %8 ]
%33 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %32
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %34
%35 = getelementptr inbounds double, double* %33, i64 2
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %36
%37 = or i64 %32, 4
%38 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %37
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %39
%40 = getelementptr inbounds double, double* %38, i64 2
%41 = bitcast double* %40 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %41
%42 = or i64 %32, 8
%43 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %42
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %44
%45 = getelementptr inbounds double, double* %43, i64 2
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %46
%47 = or i64 %32, 12
%48 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %47
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %49
%50 = getelementptr inbounds double, double* %48, i64 2
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %51
%52 = or i64 %32, 16
%53 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %52
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %54
%55 = getelementptr inbounds double, double* %53, i64 2
%56 = bitcast double* %55 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %56
%57 = or i64 %32, 20
%58 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %57
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %59
%60 = getelementptr inbounds double, double* %58, i64 2
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %61
%62 = or i64 %32, 24
%63 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %62
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %64
%65 = getelementptr inbounds double, double* %63, i64 2
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %66
%67 = or i64 %32, 28
%68 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %67
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %69
%70 = getelementptr inbounds double, double* %68, i64 2
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %71
%72 = add nuw nsw i64 %32, 32
%73 = icmp eq i64 %72, 992
br i1 %73, label %75, label %31
74: ; preds = %146, %148
ret i32 0
75: ; preds = %31, %75
%76 = phi i64 [ %126, %75 ], [ 0, %31 ]
%77 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %76
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = getelementptr inbounds double, double* %77, i64 2
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %76
%84 = bitcast double* %83 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = getelementptr inbounds double, double* %83, i64 2
%87 = bitcast double* %86 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = fsub <2 x double> %79, %85
%90 = fsub <2 x double> %82, %88
%91 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %76
%92 = bitcast double* %91 to <2 x double>*
%93 = load <2 x double>, <2 x double>* %92
%94 = getelementptr inbounds double, double* %91, i64 2
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = fadd <2 x double> %93, %89
%98 = fadd <2 x double> %96, %90
%99 = bitcast double* %91 to <2 x double>*
store <2 x double> %97, <2 x double>* %99
%100 = bitcast double* %94 to <2 x double>*
store <2 x double> %98, <2 x double>* %100
%101 = or i64 %76, 4
%102 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %101
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = getelementptr inbounds double, double* %102, i64 2
%106 = bitcast double* %105 to <2 x double>*
%107 = load <2 x double>, <2 x double>* %106
%108 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %101
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds double, double* %108, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = fsub <2 x double> %104, %110
%115 = fsub <2 x double> %107, %113
%116 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %101
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr inbounds double, double* %116, i64 2
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = fadd <2 x double> %118, %114
%123 = fadd <2 x double> %121, %115
%124 = bitcast double* %116 to <2 x double>*
store <2 x double> %122, <2 x double>* %124
%125 = bitcast double* %119 to <2 x double>*
store <2 x double> %123, <2 x double>* %125
%126 = add nuw nsw i64 %76, 8
%127 = icmp eq i64 %126, 992
br i1 %127, label %130, label %75
128: ; preds = %142
%129 = icmp eq i32 %143, 0
br i1 %129, label %148, label %146
130: ; preds = %75, %142
%131 = phi i64 [ %144, %142 ], [ 0, %75 ]
%132 = phi i32 [ %143, %142 ], [ 0, %75 ]
%133 = getelementptr inbounds [992 x double], [992 x double]* %1, i64 0, i64 %131
%134 = load double, double* %133
%135 = trunc i64 %131 to i32
%136 = sitofp i32 %135 to double
%137 = tail call double @llvm.fmuladd.f64(double %136, double 2.000000e+00, double 1.000000e+00)
%138 = fcmp une double %134, %137
br i1 %138, label %139, label %142
139: ; preds = %130
%140 = add nsw i32 %132, 1
%141 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i32 %135, double %134, double %137, i32 %140)
br label %142
142: ; preds = %130, %139
%143 = phi i32 [ %140, %139 ], [ %132, %130 ]
%144 = add nuw nsw i64 %131, 1
%145 = icmp eq i64 %144, 992
br i1 %145, label %128, label %130
146: ; preds = %128
%147 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 %143)
br label %74
148: ; preds = %128
%149 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str, i64 0, i64 0))
br label %74
}