#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 */
void neuralops_avgpool2d_fwd(size_t batch_sz, size_t in_width, size_t in_height,
                             size_t chan, const float *in_buf, float *out_buf,
                             size_t pool_w, size_t pool_h) {
  size_t out_width = (in_width + pool_w - 1) / pool_w;
  size_t out_height = (in_height + pool_h - 1) / pool_h;
  float normalizer = 1.0f / ((float)(pool_w * pool_h));
  size_t p = 0;
  for (size_t idx = 0; idx < batch_sz; idx += 1) {
    for (size_t a = 0; a < chan; a += 1) {
      for (size_t y = 0; y < out_height; y += 1) {
        for (size_t x = 0; x < out_width; x += 1) {
          float pool_value = 0.0f;
          for (size_t v = 0; v < pool_h; v += 1) {
            for (size_t u = 0; u < pool_w; u += 1) {
              pool_value += in_buf[x * pool_w + u +
                                   in_width * (y * pool_h + v +
                                               in_height * (a + chan * idx))];
            }
          }
          out_buf[p] = normalizer * pool_value;
          p += 1;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<neuralops_avgpool2d_fwd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
lea    -0x1(%rax,%rcx,1),%rax
xor    %edx,%edx
mov    %rdx,-0x98(%rbp)
div    %rcx
mov    -0x98(%rbp),%rdx
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
lea    -0x1(%rax,%rcx,1),%rax
div    %rcx
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
imul   %rcx,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x90(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x8c(%rbp)
ff
js     11b1 <neuralops_avgpool2d_fwd+0xb1>
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm1
ff
movss  0xe3f(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    135d <neuralops_avgpool2d_fwd+0x25d>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1347 <neuralops_avgpool2d_fwd+0x247>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1331 <neuralops_avgpool2d_fwd+0x231>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    131b <neuralops_avgpool2d_fwd+0x21b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movq   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%rax
cmp    0x18(%rbp),%rax
jae    12e7 <neuralops_avgpool2d_fwd+0x1e7>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    0x10(%rbp),%rax
jae    12d1 <neuralops_avgpool2d_fwd+0x1d1>
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%rcx
imul   0x10(%rbp),%rcx
add    -0x88(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    -0x68(%rbp),%rsi
imul   0x18(%rbp),%rsi
add    -0x80(%rbp),%rsi
mov    -0x18(%rbp),%rdi
mov    -0x60(%rbp),%r8
mov    -0x20(%rbp),%r9
imul   -0x58(%rbp),%r9
add    %r9,%r8
imul   %r8,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1253 <neuralops_avgpool2d_fwd+0x153>
jmp    12d6 <neuralops_avgpool2d_fwd+0x1d6>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    123a <neuralops_avgpool2d_fwd+0x13a>
movss  -0x44(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    121c <neuralops_avgpool2d_fwd+0x11c>
jmp    1320 <neuralops_avgpool2d_fwd+0x220>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1206 <neuralops_avgpool2d_fwd+0x106>
jmp    1336 <neuralops_avgpool2d_fwd+0x236>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11f0 <neuralops_avgpool2d_fwd+0xf0>
jmp    134c <neuralops_avgpool2d_fwd+0x24c>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11da <neuralops_avgpool2d_fwd+0xda>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<neuralops_avgpool2d_fwd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,-0x80(%rsp)
mov    %rcx,-0x78(%rsp)
mov    %rdx,%r8
mov    %rdi,-0x70(%rsp)
mov    0x68(%rsp),%rdx
mov    0x60(%rsp),%rdi
mov    %rdx,%rax
imul   %rdi,%rax
test   %rax,%rax
js     114d <neuralops_avgpool2d_fwd+0x4d>
cvtsi2ss %rax,%xmm1
cmpq   $0x0,-0x70(%rsp)
jne    116e <neuralops_avgpool2d_fwd+0x6e>
jmp    1410 <neuralops_avgpool2d_fwd+0x310>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
cvtsi2ss %rax,%xmm1
addss  %xmm1,%xmm1
cmpq   $0x0,-0x70(%rsp)
je     1410 <neuralops_avgpool2d_fwd+0x310>
lea    (%rsi,%rdi,1),%r9
add    $0xffffffffffffffff,%r9
lea    (%r8,%rdx,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rdx,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
mov    %rax,-0x40(%rsp)
je     119c <neuralops_avgpool2d_fwd+0x9c>
xor    %edx,%edx
div    %rcx
mov    %rax,%rbx
jmp    11a2 <neuralops_avgpool2d_fwd+0xa2>
xor    %edx,%edx
div    %ecx
mov    %eax,%ebx
movss  0xe56(%rip),%xmm0
mov    %r9,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     11c0 <neuralops_avgpool2d_fwd+0xc0>
mov    %r9,%rax
xor    %edx,%edx
div    %rdi
jmp    11c7 <neuralops_avgpool2d_fwd+0xc7>
mov    %r9d,%eax
xor    %edx,%edx
div    %edi
cmp    $0x2,%rax
mov    $0x1,%edx
cmovb  %rdx,%rax
mov    %rax,0x10(%rsp)
cmp    $0x2,%rbx
cmovae %rbx,%rdx
mov    %rdx,-0x20(%rsp)
divss  %xmm1,%xmm0
lea    -0x1(%rdi),%r14
mov    %edi,%ebx
and    $0x3,%ebx
mov    %rdi,%rbp
and    $0xfffffffffffffffc,%rbp
mov    -0x80(%rsp),%rax
add    $0xc,%rax
mov    %rax,-0x68(%rsp)
mov    -0x78(%rsp),%rax
imul   %r8,%rax
imul   %rsi,%rax
shl    $0x2,%rax
mov    %rax,-0x48(%rsp)
imul   %rsi,%r8
shl    $0x2,%r8
mov    %r8,-0x38(%rsp)
mov    0x68(%rsp),%rax
imul   %rsi,%rax
shl    $0x2,%rax
mov    %rax,-0x28(%rsp)
lea    0x0(,%rdi,4),%rax
mov    %rax,0x8(%rsp)
shl    $0x2,%rsi
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
xor    %ecx,%ecx
mov    %r9,-0x18(%rsp)
jmp    128b <neuralops_avgpool2d_fwd+0x18b>
xchg   %ax,%ax
mov    -0x60(%rsp),%r8
add    $0x1,%r8
mov    -0x48(%rsp),%rax
add    %rax,-0x68(%rsp)
add    %rax,-0x80(%rsp)
mov    %r8,%rax
mov    %r8,-0x60(%rsp)
cmp    -0x70(%rsp),%r8
je     1410 <neuralops_avgpool2d_fwd+0x310>
cmpq   $0x0,-0x78(%rsp)
je     1260 <neuralops_avgpool2d_fwd+0x160>
mov    -0x80(%rsp),%rax
mov    -0x68(%rsp),%rdx
mov    %rdx,-0x58(%rsp)
mov    0x68(%rsp),%r15
xor    %edx,%edx
mov    %rdx,-0x50(%rsp)
jmp    12da <neuralops_avgpool2d_fwd+0x1da>
mov    -0x50(%rsp),%r10
add    $0x1,%r10
mov    -0x38(%rsp),%r8
add    %r8,-0x58(%rsp)
mov    -0x30(%rsp),%rax
add    %r8,%rax
mov    %r10,%rdx
mov    %r10,-0x50(%rsp)
cmp    -0x78(%rsp),%r10
je     1260 <neuralops_avgpool2d_fwd+0x160>
cmp    %r15,-0x40(%rsp)
mov    %rax,-0x30(%rsp)
jb     12b0 <neuralops_avgpool2d_fwd+0x1b0>
mov    %rax,%r12
mov    -0x58(%rsp),%r11
xor    %edx,%edx
jmp    1329 <neuralops_avgpool2d_fwd+0x229>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rsp),%rdx
add    $0x1,%rdx
mov    -0x28(%rsp),%rax
mov    (%rsp),%r11
add    %rax,%r11
mov    -0x10(%rsp),%r12
add    %rax,%r12
cmp    -0x20(%rsp),%rdx
mov    -0x18(%rsp),%r9
je     12b0 <neuralops_avgpool2d_fwd+0x1b0>
cmp    %rdi,%r9
mov    %r11,(%rsp)
mov    %rdx,-0x8(%rsp)
mov    %r12,-0x10(%rsp)
jb     1300 <neuralops_avgpool2d_fwd+0x200>
xor    %r13d,%r13d
jmp    137d <neuralops_avgpool2d_fwd+0x27d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulss  %xmm0,%xmm1
mov    0x18(%rsp),%rax
mov    0x20(%rsp),%rcx
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0x1,%r13
mov    0x8(%rsp),%rax
add    %rax,%r11
add    %rax,%r12
cmp    0x10(%rsp),%r13
je     1300 <neuralops_avgpool2d_fwd+0x200>
test   %r15,%r15
mov    %rcx,0x20(%rsp)
xorps  %xmm1,%xmm1
je     1350 <neuralops_avgpool2d_fwd+0x250>
mov    %r12,%r10
mov    %r11,%rcx
xor    %r8d,%r8d
jmp    13b4 <neuralops_avgpool2d_fwd+0x2b4>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
add    %rsi,%rcx
add    %rsi,%r10
cmp    %r15,%r8
mov    0x60(%rsp),%rdi
je     1350 <neuralops_avgpool2d_fwd+0x250>
test   %rdi,%rdi
je     13a0 <neuralops_avgpool2d_fwd+0x2a0>
xor    %r9d,%r9d
cmp    $0x3,%r14
jb     13f4 <neuralops_avgpool2d_fwd+0x2f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addss  -0xc(%rcx,%r9,4),%xmm1
addss  -0x8(%rcx,%r9,4),%xmm1
addss  -0x4(%rcx,%r9,4),%xmm1
addss  (%rcx,%r9,4),%xmm1
add    $0x4,%r9
cmp    %r9,%rbp
jne    13d0 <neuralops_avgpool2d_fwd+0x2d0>
test   %rbx,%rbx
je     13a0 <neuralops_avgpool2d_fwd+0x2a0>
lea    (%r10,%r9,4),%rax
xor    %edi,%edi
nop
addss  (%rax,%rdi,4),%xmm1
add    $0x1,%rdi
cmp    %rdi,%rbx
jne    1400 <neuralops_avgpool2d_fwd+0x300>
jmp    13a0 <neuralops_avgpool2d_fwd+0x2a0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @neuralops_avgpool2d_fwd(i64 %0, i64 %1, i64 %2, i64 %3, float* %4, float* %5, i64 %6, i64 %7) {
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca float*
%14 = alloca float*
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca float
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca float
%26 = alloca i64
%27 = alloca i64
store i64 %0, i64* %9
store i64 %1, i64* %10
store i64 %2, i64* %11
store i64 %3, i64* %12
store float* %4, float** %13
store float* %5, float** %14
store i64 %6, i64* %15
store i64 %7, i64* %16
%28 = load i64, i64* %10
%29 = load i64, i64* %15
%30 = add i64 %28, %29
%31 = sub i64 %30, 1
%32 = load i64, i64* %15
%33 = udiv i64 %31, %32
store i64 %33, i64* %17
%34 = load i64, i64* %11
%35 = load i64, i64* %16
%36 = add i64 %34, %35
%37 = sub i64 %36, 1
%38 = load i64, i64* %16
%39 = udiv i64 %37, %38
store i64 %39, i64* %18
%40 = load i64, i64* %15
%41 = load i64, i64* %16
%42 = mul i64 %40, %41
%43 = uitofp i64 %42 to float
%44 = fdiv float 1.000000e+00, %43
store float %44, float* %19
store i64 0, i64* %20
store i64 0, i64* %21
br label %45
45: ; preds = %129, %8
%46 = load i64, i64* %21
%47 = load i64, i64* %9
%48 = icmp ult i64 %46, %47
br i1 %48, label %49, label %132
49: ; preds = %45
store i64 0, i64* %22
br label %50
50: ; preds = %125, %49
%51 = load i64, i64* %22
%52 = load i64, i64* %12
%53 = icmp ult i64 %51, %52
br i1 %53, label %54, label %128
54: ; preds = %50
store i64 0, i64* %23
br label %55
55: ; preds = %121, %54
%56 = load i64, i64* %23
%57 = load i64, i64* %18
%58 = icmp ult i64 %56, %57
br i1 %58, label %59, label %124
59: ; preds = %55
store i64 0, i64* %24
br label %60
60: ; preds = %117, %59
%61 = load i64, i64* %24
%62 = load i64, i64* %17
%63 = icmp ult i64 %61, %62
br i1 %63, label %64, label %120
64: ; preds = %60
store float 0.000000e+00, float* %25
store i64 0, i64* %26
br label %65
65: ; preds = %105, %64
%66 = load i64, i64* %26
%67 = load i64, i64* %16
%68 = icmp ult i64 %66, %67
br i1 %68, label %69, label %108
69: ; preds = %65
store i64 0, i64* %27
br label %70
70: ; preds = %101, %69
%71 = load i64, i64* %27
%72 = load i64, i64* %15
%73 = icmp ult i64 %71, %72
br i1 %73, label %74, label %104
74: ; preds = %70
%75 = load float*, float** %13
%76 = load i64, i64* %24
%77 = load i64, i64* %15
%78 = mul i64 %76, %77
%79 = load i64, i64* %27
%80 = add i64 %78, %79
%81 = load i64, i64* %10
%82 = load i64, i64* %23
%83 = load i64, i64* %16
%84 = mul i64 %82, %83
%85 = load i64, i64* %26
%86 = add i64 %84, %85
%87 = load i64, i64* %11
%88 = load i64, i64* %22
%89 = load i64, i64* %12
%90 = load i64, i64* %21
%91 = mul i64 %89, %90
%92 = add i64 %88, %91
%93 = mul i64 %87, %92
%94 = add i64 %86, %93
%95 = mul i64 %81, %94
%96 = add i64 %80, %95
%97 = getelementptr inbounds float, float* %75, i64 %96
%98 = load float, float* %97
%99 = load float, float* %25
%100 = fadd float %99, %98
store float %100, float* %25
br label %101
101: ; preds = %74
%102 = load i64, i64* %27
%103 = add i64 %102, 1
store i64 %103, i64* %27
br label %70
104: ; preds = %70
br label %105
105: ; preds = %104
%106 = load i64, i64* %26
%107 = add i64 %106, 1
store i64 %107, i64* %26
br label %65
108: ; preds = %65
%109 = load float, float* %19
%110 = load float, float* %25
%111 = fmul float %109, %110
%112 = load float*, float** %14
%113 = load i64, i64* %20
%114 = getelementptr inbounds float, float* %112, i64 %113
store float %111, float* %114
%115 = load i64, i64* %20
%116 = add i64 %115, 1
store i64 %116, i64* %20
br label %117
117: ; preds = %108
%118 = load i64, i64* %24
%119 = add i64 %118, 1
store i64 %119, i64* %24
br label %60
120: ; preds = %60
br label %121
121: ; preds = %120
%122 = load i64, i64* %23
%123 = add i64 %122, 1
store i64 %123, i64* %23
br label %55
124: ; preds = %55
br label %125
125: ; preds = %124
%126 = load i64, i64* %22
%127 = add i64 %126, 1
store i64 %127, i64* %22
br label %50
128: ; preds = %50
br label %129
129: ; preds = %128
%130 = load i64, i64* %21
%131 = add i64 %130, 1
store i64 %131, i64* %21
br label %45
132: ; preds = %45
ret void
}

LLVM IR (-O2):
define void @neuralops_avgpool2d_fwd(i64 %0, i64 %1, i64 %2, i64 %3, float* nocapture %4, float* nocapture writeonly %5, i64 %6, i64 %7) {
%9 = add i64 %1, -1
%10 = add i64 %9, %6
%11 = add i64 %2, -1
%12 = add i64 %11, %7
%13 = mul i64 %7, %6
%14 = uitofp i64 %13 to float
%15 = fdiv float 1.000000e+00, %14
%16 = icmp eq i64 %0, 0
br i1 %16, label %37, label %17
17: ; preds = %8
%18 = udiv i64 %12, %7
%19 = udiv i64 %10, %6
%20 = icmp eq i64 %3, 0
%21 = icmp ult i64 %12, %7
%22 = icmp ult i64 %10, %6
%23 = icmp eq i64 %7, 0
%24 = icmp eq i64 %6, 0
%25 = call i64 @llvm.umax.i64(i64 %19, i64 1)
%26 = call i64 @llvm.umax.i64(i64 %18, i64 1)
%27 = add i64 %6, -1
%28 = and i64 %6, 3
%29 = icmp ult i64 %27, 3
%30 = and i64 %6, -4
%31 = icmp eq i64 %28, 0
br label %32
32: ; preds = %17, %44
%33 = phi i64 [ 0, %17 ], [ %46, %44 ]
%34 = phi i64 [ 0, %17 ], [ %45, %44 ]
br i1 %20, label %44, label %35
35: ; preds = %32
%36 = mul i64 %33, %3
br label %38
37: ; preds = %44, %8
ret void
38: ; preds = %35, %54
%39 = phi i64 [ 0, %35 ], [ %56, %54 ]
%40 = phi i64 [ %34, %35 ], [ %55, %54 ]
br i1 %21, label %54, label %41
41: ; preds = %38
%42 = add i64 %39, %36
%43 = mul i64 %42, %2
br label %48
44: ; preds = %54, %32
%45 = phi i64 [ %34, %32 ], [ %55, %54 ]
%46 = add nuw i64 %33, 1
%47 = icmp eq i64 %46, %0
br i1 %47, label %37, label %32
48: ; preds = %41, %63
%49 = phi i64 [ 0, %41 ], [ %65, %63 ]
%50 = phi i64 [ %40, %41 ], [ %64, %63 ]
br i1 %22, label %63, label %51
51: ; preds = %48
%52 = mul i64 %49, %7
%53 = add i64 %52, %43
br label %58
54: ; preds = %63, %38
%55 = phi i64 [ %40, %38 ], [ %64, %63 ]
%56 = add nuw i64 %39, 1
%57 = icmp eq i64 %56, %3
br i1 %57, label %44, label %38
58: ; preds = %51, %74
%59 = phi i64 [ 0, %51 ], [ %79, %74 ]
%60 = phi i64 [ %50, %51 ], [ %78, %74 ]
br i1 %23, label %74, label %61
61: ; preds = %58
%62 = mul i64 %59, %6
br label %67
63: ; preds = %74, %48
%64 = phi i64 [ %50, %48 ], [ %78, %74 ]
%65 = add nuw i64 %49, 1
%66 = icmp eq i64 %65, %26
br i1 %66, label %54, label %48
67: ; preds = %61, %96
%68 = phi i64 [ 0, %61 ], [ %98, %96 ]
%69 = phi float [ 0.000000e+00, %61 ], [ %97, %96 ]
br i1 %24, label %96, label %70
70: ; preds = %67
%71 = add i64 %53, %68
%72 = mul i64 %71, %1
%73 = add i64 %72, %62
br i1 %29, label %81, label %100
74: ; preds = %96, %58
%75 = phi float [ 0.000000e+00, %58 ], [ %97, %96 ]
%76 = fmul float %15, %75
%77 = getelementptr inbounds float, float* %5, i64 %60
store float %76, float* %77
%78 = add i64 %60, 1
%79 = add nuw i64 %59, 1
%80 = icmp eq i64 %79, %25
br i1 %80, label %63, label %58
81: ; preds = %100, %70
%82 = phi float [ undef, %70 ], [ %122, %100 ]
%83 = phi i64 [ 0, %70 ], [ %123, %100 ]
%84 = phi float [ %69, %70 ], [ %122, %100 ]
br i1 %31, label %96, label %85
85: ; preds = %81, %85
%86 = phi i64 [ %93, %85 ], [ %83, %81 ]
%87 = phi float [ %92, %85 ], [ %84, %81 ]
%88 = phi i64 [ %94, %85 ], [ 0, %81 ]
%89 = add i64 %73, %86
%90 = getelementptr inbounds float, float* %4, i64 %89
%91 = load float, float* %90
%92 = fadd float %87, %91
%93 = add nuw i64 %86, 1
%94 = add i64 %88, 1
%95 = icmp eq i64 %94, %28
br i1 %95, label %96, label %85
96: ; preds = %81, %85, %67
%97 = phi float [ %69, %67 ], [ %82, %81 ], [ %92, %85 ]
%98 = add nuw i64 %68, 1
%99 = icmp eq i64 %98, %7
br i1 %99, label %74, label %67
100: ; preds = %70, %100
%101 = phi i64 [ %123, %100 ], [ 0, %70 ]
%102 = phi float [ %122, %100 ], [ %69, %70 ]
%103 = phi i64 [ %124, %100 ], [ 0, %70 ]
%104 = add i64 %73, %101
%105 = getelementptr inbounds float, float* %4, i64 %104
%106 = load float, float* %105
%107 = fadd float %102, %106
%108 = or i64 %101, 1
%109 = add i64 %73, %108
%110 = getelementptr inbounds float, float* %4, i64 %109
%111 = load float, float* %110
%112 = fadd float %107, %111
%113 = or i64 %101, 2
%114 = add i64 %73, %113
%115 = getelementptr inbounds float, float* %4, i64 %114
%116 = load float, float* %115
%117 = fadd float %112, %116
%118 = or i64 %101, 3
%119 = add i64 %73, %118
%120 = getelementptr inbounds float, float* %4, i64 %119
%121 = load float, float* %120
%122 = fadd float %117, %121
%123 = add nuw i64 %101, 4
%124 = add i64 %103, 4
%125 = icmp eq i64 %124, %30
br i1 %125, label %81, label %100
}