#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*/ assert(int);
void gwv_np_4() {
  int i, j;
  float arr[32768];
  float res = 0, mres = 0, hres = 0, hmres = 0;
  for (i = 0; i < 32768; i++)
    arr[i] = i % (32768 / 64);
#pragma acc parallel num_gangs(32) num_workers(32) vector_length(32)
  {
#pragma acc loop gang reduction(+ : res) reduction(max : mres)
    for (j = 0; j < 32; j++) {
#pragma acc loop worker vector reduction(+ : res) reduction(max : mres)
      for (i = 0; i < 1024; i++) {
        res += arr[j * 1024 + i];
        if (arr[j * 1024 + i] > mres)
          mres = arr[j * 1024 + i];
      }
#pragma acc loop worker vector reduction(+ : res) reduction(max : mres)
      for (i = 0; i < 1024; i++) {
        res += arr[j * 1024 + (1023 - i)];
        if (arr[j * 1024 + (1023 - i)] > mres)
          mres = arr[j * 1024 + (1023 - i)];
      }
    }
  }
  for (j = 0; j < 32; j++)
    for (i = 0; i < 1024; i++) {
      hres += arr[j * 1024 + i];
      hres += arr[j * 1024 + (1023 - i)];
      if (arr[j * 1024 + i] > hmres)
        hmres = arr[j * 1024 + i];
      if (arr[j * 1024 + (1023 - i)] > hmres)
        hmres = arr[j * 1024 + (1023 - i)];
    }
  assert(hres <= 16777216);
  assert(res == hres);
  assert(hmres <= 16777216);
  assert(mres == hmres);
}


x86 assembly (clang, -O0):
<gwv_np_4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20020,%rsp
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20014(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20018(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2001c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20020(%rbp)
ff
movl   $0x0,-0x4(%rbp)
cmpl   $0x8000,-0x4(%rbp)
jge    1185 <gwv_np_4+0x75>
mov    -0x4(%rbp),%eax
mov    $0x200,%ecx
cltd
idiv   %ecx
cvtsi2ss %edx,%xmm0
movslq -0x4(%rbp),%rax
movss  %xmm0,-0x20010(%rbp,%rax,4)
fd ff
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    114e <gwv_np_4+0x3e>
movl   $0x0,-0x8(%rbp)
cmpl   $0x20,-0x8(%rbp)
jge    12ce <gwv_np_4+0x1be>
movl   $0x0,-0x4(%rbp)
cmpl   $0x400,-0x4(%rbp)
jge    121e <gwv_np_4+0x10e>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
addss  -0x20014(%rbp),%xmm0
ff
movss  %xmm0,-0x20014(%rbp)
ff
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
ucomiss -0x20018(%rbp),%xmm0
jbe    120b <gwv_np_4+0xfb>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x20018(%rbp)
ff
jmp    1210 <gwv_np_4+0x100>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    119d <gwv_np_4+0x8d>
movl   $0x0,-0x4(%rbp)
cmpl   $0x400,-0x4(%rbp)
jge    12bb <gwv_np_4+0x1ab>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
addss  -0x20014(%rbp),%xmm0
ff
movss  %xmm0,-0x20014(%rbp)
ff
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
ucomiss -0x20018(%rbp),%xmm0
jbe    12a8 <gwv_np_4+0x198>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x20018(%rbp)
ff
jmp    12ad <gwv_np_4+0x19d>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1225 <gwv_np_4+0x115>
jmp    12c0 <gwv_np_4+0x1b0>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    118c <gwv_np_4+0x7c>
movl   $0x0,-0x8(%rbp)
cmpl   $0x20,-0x8(%rbp)
jge    13f0 <gwv_np_4+0x2e0>
movl   $0x0,-0x4(%rbp)
cmpl   $0x400,-0x4(%rbp)
jge    13dd <gwv_np_4+0x2cd>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
addss  -0x2001c(%rbp),%xmm0
ff
movss  %xmm0,-0x2001c(%rbp)
ff
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
addss  -0x2001c(%rbp),%xmm0
ff
movss  %xmm0,-0x2001c(%rbp)
ff
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
ucomiss -0x20020(%rbp),%xmm0
jbe    137f <gwv_np_4+0x26f>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
add    -0x4(%rbp),%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x20020(%rbp)
ff
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
ucomiss -0x20020(%rbp),%xmm0
jbe    13ca <gwv_np_4+0x2ba>
mov    -0x8(%rbp),%eax
shl    $0xa,%eax
mov    $0x3ff,%ecx
sub    -0x4(%rbp),%ecx
add    %ecx,%eax
cltq
movss  -0x20010(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x20020(%rbp)
ff
jmp    13cf <gwv_np_4+0x2bf>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    12e6 <gwv_np_4+0x1d6>
jmp    13e2 <gwv_np_4+0x2d2>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12d5 <gwv_np_4+0x1c5>
movss  0xc08(%rip),%xmm0
ucomiss -0x2001c(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movss  -0x20014(%rbp),%xmm0
ff
ucomiss -0x2001c(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movss  0xbcb(%rip),%xmm0
ucomiss -0x20020(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movss  -0x20018(%rbp),%xmm0
ff
ucomiss -0x20020(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
add    $0x20020,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gwv_np_4>:
sub    $0x20018,%rsp
movdqa 0xee1(%rip),%xmm0
xor    %eax,%eax
movdqa 0xee7(%rip),%xmm1
movdqa 0xeef(%rip),%xmm2
movdqa 0xef7(%rip),%xmm3
movdqa 0xeff(%rip),%xmm4
movdqa 0xf07(%rip),%xmm5
nopl   0x0(%rax)
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
pand   %xmm2,%xmm7
pand   %xmm2,%xmm6
cvtdq2ps %xmm7,%xmm7
cvtdq2ps %xmm6,%xmm6
movaps %xmm7,0x10(%rsp,%rax,4)
movaps %xmm6,0x20(%rsp,%rax,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
pand   %xmm2,%xmm6
pand   %xmm2,%xmm7
cvtdq2ps %xmm6,%xmm6
cvtdq2ps %xmm7,%xmm7
movaps %xmm6,0x30(%rsp,%rax,4)
movaps %xmm7,0x40(%rsp,%rax,4)
add    $0x10,%rax
paddd  %xmm5,%xmm0
cmp    $0x8000,%rax
jne    1150 <gwv_np_4+0x40>
lea    0x1c(%rsp),%rax
pxor   %xmm2,%xmm2
lea    0x10(%rsp),%rcx
xor    %edx,%edx
pxor   %xmm3,%xmm3
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0xc(%rax,%rsi,4),%xmm0
movss  -0x8(%rax,%rsi,4),%xmm1
addss  %xmm0,%xmm3
maxss  %xmm2,%xmm0
addss  %xmm1,%xmm3
maxss  %xmm0,%xmm1
movss  -0x4(%rax,%rsi,4),%xmm0
addss  %xmm0,%xmm3
maxss  %xmm1,%xmm0
movss  (%rax,%rsi,4),%xmm2
addss  %xmm2,%xmm3
maxss  %xmm0,%xmm2
add    $0x4,%rsi
cmp    $0x400,%rsi
jne    11d0 <gwv_np_4+0xc0>
mov    $0x1000,%esi
nopl   0x0(%rax)
movss  -0x4(%rcx,%rsi,1),%xmm0
addss  %xmm0,%xmm3
maxss  %xmm2,%xmm0
movss  -0x8(%rcx,%rsi,1),%xmm1
addss  %xmm1,%xmm3
maxss  %xmm0,%xmm1
movss  -0x10(%rcx,%rsi,1),%xmm2
movss  -0xc(%rcx,%rsi,1),%xmm0
addss  %xmm0,%xmm3
maxss  %xmm1,%xmm0
addss  %xmm2,%xmm3
maxss  %xmm0,%xmm2
add    $0xfffffffffffffff0,%rsi
jne    1220 <gwv_np_4+0x110>
add    $0x1,%rdx
add    $0x1000,%rax
add    $0x1000,%rcx
cmp    $0x20,%rdx
jne    11c0 <gwv_np_4+0xb0>
movss  %xmm3,0x8(%rsp)
movss  %xmm2,0xc(%rsp)
lea    0x14(%rsp),%rax
xorps  %xmm2,%xmm2
lea    0x10(%rsp),%rcx
xor    %edx,%edx
pxor   %xmm4,%xmm4
nopl   0x0(%rax,%rax,1)
mov    $0x1000,%esi
mov    %rax,%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rdi),%xmm0
movss  (%rdi),%xmm1
addss  %xmm0,%xmm4
maxss  %xmm2,%xmm0
movss  -0x8(%rcx,%rsi,1),%xmm2
movss  -0x4(%rcx,%rsi,1),%xmm3
addss  %xmm3,%xmm4
maxss  %xmm0,%xmm3
addss  %xmm1,%xmm4
addss  %xmm2,%xmm4
maxss  %xmm3,%xmm1
maxss  %xmm1,%xmm2
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rsi
jne    12b0 <gwv_np_4+0x1a0>
add    $0x1,%rdx
add    $0x1000,%rax
add    $0x1000,%rcx
cmp    $0x20,%rdx
jne    12a0 <gwv_np_4+0x190>
movss  0xd52(%rip),%xmm0
xor    %edi,%edi
ucomiss %xmm4,%xmm0
setae  %dil
movss  %xmm2,(%rsp)
movss  %xmm4,0x4(%rsp)
call   1030 <assert@plt>
movss  0x8(%rsp),%xmm0
cmpeqss 0x4(%rsp),%xmm0
movd   %xmm0,%edi
and    $0x1,%edi
call   1030 <assert@plt>
xor    %edi,%edi
movss  0xd16(%rip),%xmm0
ucomiss (%rsp),%xmm0
setae  %dil
call   1030 <assert@plt>
movss  0xc(%rsp),%xmm0
cmpeqss (%rsp),%xmm0
movd   %xmm0,%edi
and    $0x1,%edi
add    $0x20018,%rsp
jmp    1030 <assert@plt>

LLVM IR (-O0):
define void @gwv_np_4() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [32768 x float]
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
store float 0.000000e+00, float* %4
store float 0.000000e+00, float* %5
store float 0.000000e+00, float* %6
store float 0.000000e+00, float* %7
store i32 0, i32* %1
br label %8
8: ; preds = %18, %0
%9 = load i32, i32* %1
%10 = icmp slt i32 %9, 32768
br i1 %10, label %11, label %21
11: ; preds = %8
%12 = load i32, i32* %1
%13 = srem i32 %12, 512
%14 = sitofp i32 %13 to float
%15 = load i32, i32* %1
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %16
store float %14, float* %17
br label %18
18: ; preds = %11
%19 = load i32, i32* %1
%20 = add nsw i32 %19, 1
store i32 %20, i32* %1
br label %8
21: ; preds = %8
store i32 0, i32* %2
br label %22
22: ; preds = %99, %21
%23 = load i32, i32* %2
%24 = icmp slt i32 %23, 32
br i1 %24, label %25, label %102
25: ; preds = %22
store i32 0, i32* %1
br label %26
26: ; preds = %57, %25
%27 = load i32, i32* %1
%28 = icmp slt i32 %27, 1024
br i1 %28, label %29, label %60
29: ; preds = %26
%30 = load i32, i32* %2
%31 = mul nsw i32 %30, 1024
%32 = load i32, i32* %1
%33 = add nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %34
%36 = load float, float* %35
%37 = load float, float* %4
%38 = fadd float %37, %36
store float %38, float* %4
%39 = load i32, i32* %2
%40 = mul nsw i32 %39, 1024
%41 = load i32, i32* %1
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %43
%45 = load float, float* %44
%46 = load float, float* %5
%47 = fcmp ogt float %45, %46
br i1 %47, label %48, label %56
48: ; preds = %29
%49 = load i32, i32* %2
%50 = mul nsw i32 %49, 1024
%51 = load i32, i32* %1
%52 = add nsw i32 %50, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %53
%55 = load float, float* %54
store float %55, float* %5
br label %56
56: ; preds = %48, %29
br label %57
57: ; preds = %56
%58 = load i32, i32* %1
%59 = add nsw i32 %58, 1
store i32 %59, i32* %1
br label %26
60: ; preds = %26
store i32 0, i32* %1
br label %61
61: ; preds = %95, %60
%62 = load i32, i32* %1
%63 = icmp slt i32 %62, 1024
br i1 %63, label %64, label %98
64: ; preds = %61
%65 = load i32, i32* %2
%66 = mul nsw i32 %65, 1024
%67 = load i32, i32* %1
%68 = sub nsw i32 1023, %67
%69 = add nsw i32 %66, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %70
%72 = load float, float* %71
%73 = load float, float* %4
%74 = fadd float %73, %72
store float %74, float* %4
%75 = load i32, i32* %2
%76 = mul nsw i32 %75, 1024
%77 = load i32, i32* %1
%78 = sub nsw i32 1023, %77
%79 = add nsw i32 %76, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %80
%82 = load float, float* %81
%83 = load float, float* %5
%84 = fcmp ogt float %82, %83
br i1 %84, label %85, label %94
85: ; preds = %64
%86 = load i32, i32* %2
%87 = mul nsw i32 %86, 1024
%88 = load i32, i32* %1
%89 = sub nsw i32 1023, %88
%90 = add nsw i32 %87, %89
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %91
%93 = load float, float* %92
store float %93, float* %5
br label %94
94: ; preds = %85, %64
br label %95
95: ; preds = %94
%96 = load i32, i32* %1
%97 = add nsw i32 %96, 1
store i32 %97, i32* %1
br label %61
98: ; preds = %61
br label %99
99: ; preds = %98
%100 = load i32, i32* %2
%101 = add nsw i32 %100, 1
store i32 %101, i32* %2
br label %22
102: ; preds = %22
store i32 0, i32* %2
br label %103
103: ; preds = %172, %102
%104 = load i32, i32* %2
%105 = icmp slt i32 %104, 32
br i1 %105, label %106, label %175
106: ; preds = %103
store i32 0, i32* %1
br label %107
107: ; preds = %168, %106
%108 = load i32, i32* %1
%109 = icmp slt i32 %108, 1024
br i1 %109, label %110, label %171
110: ; preds = %107
%111 = load i32, i32* %2
%112 = mul nsw i32 %111, 1024
%113 = load i32, i32* %1
%114 = add nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %115
%117 = load float, float* %116
%118 = load float, float* %6
%119 = fadd float %118, %117
store float %119, float* %6
%120 = load i32, i32* %2
%121 = mul nsw i32 %120, 1024
%122 = load i32, i32* %1
%123 = sub nsw i32 1023, %122
%124 = add nsw i32 %121, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %125
%127 = load float, float* %126
%128 = load float, float* %6
%129 = fadd float %128, %127
store float %129, float* %6
%130 = load i32, i32* %2
%131 = mul nsw i32 %130, 1024
%132 = load i32, i32* %1
%133 = add nsw i32 %131, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %134
%136 = load float, float* %135
%137 = load float, float* %7
%138 = fcmp ogt float %136, %137
br i1 %138, label %139, label %147
139: ; preds = %110
%140 = load i32, i32* %2
%141 = mul nsw i32 %140, 1024
%142 = load i32, i32* %1
%143 = add nsw i32 %141, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %144
%146 = load float, float* %145
store float %146, float* %7
br label %147
147: ; preds = %139, %110
%148 = load i32, i32* %2
%149 = mul nsw i32 %148, 1024
%150 = load i32, i32* %1
%151 = sub nsw i32 1023, %150
%152 = add nsw i32 %149, %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %153
%155 = load float, float* %154
%156 = load float, float* %7
%157 = fcmp ogt float %155, %156
br i1 %157, label %158, label %167
158: ; preds = %147
%159 = load i32, i32* %2
%160 = mul nsw i32 %159, 1024
%161 = load i32, i32* %1
%162 = sub nsw i32 1023, %161
%163 = add nsw i32 %160, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [32768 x float], [32768 x float]* %3, i64 0, i64 %164
%166 = load float, float* %165
store float %166, float* %7
br label %167
167: ; preds = %158, %147
br label %168
168: ; preds = %167
%169 = load i32, i32* %1
%170 = add nsw i32 %169, 1
store i32 %170, i32* %1
br label %107
171: ; preds = %107
br label %172
172: ; preds = %171
%173 = load i32, i32* %2
%174 = add nsw i32 %173, 1
store i32 %174, i32* %2
br label %103
175: ; preds = %103
%176 = load float, float* %6
%177 = fcmp ole float %176, 0x4170000000000000
%178 = zext i1 %177 to i32
%179 = call i32 @assert(i32 %178)
%180 = load float, float* %4
%181 = load float, float* %6
%182 = fcmp oeq float %180, %181
%183 = zext i1 %182 to i32
%184 = call i32 @assert(i32 %183)
%185 = load float, float* %7
%186 = fcmp ole float %185, 0x4170000000000000
%187 = zext i1 %186 to i32
%188 = call i32 @assert(i32 %187)
%189 = load float, float* %5
%190 = load float, float* %7
%191 = fcmp oeq float %189, %190
%192 = zext i1 %191 to i32
%193 = call i32 @assert(i32 %192)
ret void
}

LLVM IR (-O2):
define void @gwv_np_4() {
%1 = alloca [32768 x float]
%2 = bitcast [32768 x float]* %1 to i8*
br label %3
3: ; preds = %3, %0
%4 = phi i64 [ 0, %0 ], [ %26, %3 ]
%5 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %0 ], [ %27, %3 ]
%6 = add <4 x i32> %5, <i32 4, i32 4, i32 4, i32 4>
%7 = and <4 x i32> %5, <i32 511, i32 511, i32 511, i32 511>
%8 = and <4 x i32> %6, <i32 511, i32 511, i32 511, i32 511>
%9 = sitofp <4 x i32> %7 to <4 x float>
%10 = sitofp <4 x i32> %8 to <4 x float>
%11 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %4
%12 = bitcast float* %11 to <4 x float>*
store <4 x float> %9, <4 x float>* %12
%13 = getelementptr inbounds float, float* %11, i64 4
%14 = bitcast float* %13 to <4 x float>*
store <4 x float> %10, <4 x float>* %14
%15 = or i64 %4, 8
%16 = add <4 x i32> %5, <i32 8, i32 8, i32 8, i32 8>
%17 = add <4 x i32> %5, <i32 12, i32 12, i32 12, i32 12>
%18 = and <4 x i32> %16, <i32 511, i32 511, i32 511, i32 511>
%19 = and <4 x i32> %17, <i32 511, i32 511, i32 511, i32 511>
%20 = sitofp <4 x i32> %18 to <4 x float>
%21 = sitofp <4 x i32> %19 to <4 x float>
%22 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %15
%23 = bitcast float* %22 to <4 x float>*
store <4 x float> %20, <4 x float>* %23
%24 = getelementptr inbounds float, float* %22, i64 4
%25 = bitcast float* %24 to <4 x float>*
store <4 x float> %21, <4 x float>* %25
%26 = add nuw nsw i64 %4, 16
%27 = add <4 x i32> %5, <i32 16, i32 16, i32 16, i32 16>
%28 = icmp eq i64 %26, 32768
br i1 %28, label %29, label %3
29: ; preds = %3, %102
%30 = phi i64 [ %103, %102 ], [ 0, %3 ]
%31 = phi float [ %99, %102 ], [ 0.000000e+00, %3 ]
%32 = phi float [ %97, %102 ], [ 0.000000e+00, %3 ]
%33 = shl nsw i64 %30, 10
br label %36
34: ; preds = %36
%35 = or i64 %33, 1023
br label %69
36: ; preds = %36, %29
%37 = phi i64 [ 0, %29 ], [ %67, %36 ]
%38 = phi float [ %31, %29 ], [ %66, %36 ]
%39 = phi float [ %32, %29 ], [ %64, %36 ]
%40 = add nuw nsw i64 %37, %33
%41 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %40
%42 = load float, float* %41
%43 = fadd float %39, %42
%44 = fcmp ogt float %42, %38
%45 = select i1 %44, float %42, float %38
%46 = or i64 %37, 1
%47 = add nuw nsw i64 %46, %33
%48 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %47
%49 = load float, float* %48
%50 = fadd float %43, %49
%51 = fcmp ogt float %49, %45
%52 = select i1 %51, float %49, float %45
%53 = or i64 %37, 2
%54 = add nuw nsw i64 %53, %33
%55 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %54
%56 = load float, float* %55
%57 = fadd float %50, %56
%58 = fcmp ogt float %56, %52
%59 = select i1 %58, float %56, float %52
%60 = or i64 %37, 3
%61 = add nuw nsw i64 %60, %33
%62 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %61
%63 = load float, float* %62
%64 = fadd float %57, %63
%65 = fcmp ogt float %63, %59
%66 = select i1 %65, float %63, float %59
%67 = add nuw nsw i64 %37, 4
%68 = icmp eq i64 %67, 1024
br i1 %68, label %34, label %36
69: ; preds = %69, %34
%70 = phi i64 [ 0, %34 ], [ %100, %69 ]
%71 = phi float [ %66, %34 ], [ %99, %69 ]
%72 = phi float [ %64, %34 ], [ %97, %69 ]
%73 = sub nuw nsw i64 %35, %70
%74 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %73
%75 = load float, float* %74
%76 = fadd float %72, %75
%77 = fcmp ogt float %75, %71
%78 = select i1 %77, float %75, float %71
%79 = xor i64 %70, -1
%80 = add nsw i64 %35, %79
%81 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %80
%82 = load float, float* %81
%83 = fadd float %76, %82
%84 = fcmp ogt float %82, %78
%85 = select i1 %84, float %82, float %78
%86 = or i64 %70, 2
%87 = sub nuw nsw i64 %35, %86
%88 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %87
%89 = load float, float* %88
%90 = fadd float %83, %89
%91 = fcmp ogt float %89, %85
%92 = select i1 %91, float %89, float %85
%93 = or i64 %70, 3
%94 = sub nuw nsw i64 %35, %93
%95 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %94
%96 = load float, float* %95
%97 = fadd float %90, %96
%98 = fcmp ogt float %96, %92
%99 = select i1 %98, float %96, float %92
%100 = add nuw nsw i64 %70, 4
%101 = icmp eq i64 %100, 1024
br i1 %101, label %102, label %69
102: ; preds = %69
%103 = add nuw nsw i64 %30, 1
%104 = icmp eq i64 %103, 32
br i1 %104, label %105, label %29
105: ; preds = %102, %142
%106 = phi i64 [ %143, %142 ], [ 0, %102 ]
%107 = phi float [ %139, %142 ], [ 0.000000e+00, %102 ]
%108 = phi float [ %135, %142 ], [ 0.000000e+00, %102 ]
%109 = shl nsw i64 %106, 10
%110 = or i64 %109, 1023
br label %111
111: ; preds = %111, %105
%112 = phi i64 [ 0, %105 ], [ %140, %111 ]
%113 = phi float [ %107, %105 ], [ %139, %111 ]
%114 = phi float [ %108, %105 ], [ %135, %111 ]
%115 = add nuw nsw i64 %112, %109
%116 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %115
%117 = load float, float* %116
%118 = fadd float %114, %117
%119 = sub nuw nsw i64 %110, %112
%120 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %119
%121 = load float, float* %120
%122 = fadd float %118, %121
%123 = fcmp ogt float %117, %113
%124 = select i1 %123, float %117, float %113
%125 = fcmp ogt float %121, %124
%126 = select i1 %125, float %121, float %124
%127 = or i64 %112, 1
%128 = add nuw nsw i64 %127, %109
%129 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %128
%130 = load float, float* %129
%131 = fadd float %122, %130
%132 = sub nuw nsw i64 %110, %127
%133 = getelementptr inbounds [32768 x float], [32768 x float]* %1, i64 0, i64 %132
%134 = load float, float* %133
%135 = fadd float %131, %134
%136 = fcmp ogt float %130, %126
%137 = select i1 %136, float %130, float %126
%138 = fcmp ogt float %134, %137
%139 = select i1 %138, float %134, float %137
%140 = add nuw nsw i64 %112, 2
%141 = icmp eq i64 %140, 1024
br i1 %141, label %142, label %111
142: ; preds = %111
%143 = add nuw nsw i64 %106, 1
%144 = icmp eq i64 %143, 32
br i1 %144, label %145, label %105
145: ; preds = %142
%146 = fcmp ole float %135, 0x4170000000000000
%147 = zext i1 %146 to i32
%148 = tail call i32 @assert(i32 %147)
%149 = fcmp oeq float %97, %135
%150 = zext i1 %149 to i32
%151 = tail call i32 @assert(i32 %150)
%152 = fcmp ole float %139, 0x4170000000000000
%153 = zext i1 %152 to i32
%154 = tail call i32 @assert(i32 %153)
%155 = fcmp oeq float %99, %139
%156 = zext i1 %155 to i32
%157 = tail call i32 @assert(i32 %156)
ret void
}