void reduce_flow(input, output, nx, ny) float *input, *output;
int nx, ny;
{
  float filter[3][3] = {
      {0.0625, 0.125, 0.0625}, {0.125, 0.25, 0.125}, {0.0625, 0.125, 0.0625}};
  float val;
  int i, ii, ir, j, jj, jr;
  int snx, sny, f_off, si, sj;
  int sample = 2, filter_size = 3;
  f_off = (int)floor((filter_size - 1) / 2.0);
  snx = (int)floor(nx / ((float)sample));
  sny = (int)floor(ny / ((float)sample));
  si = 0;
  for (i = 1; i < ny - 1; i = i + 2) {
    sj = 0;
    for (j = 1; j < nx - 1; j = j + 2) {
      val = 0.0;
      for (ii = 0; ii < filter_size; ii++) {
        ir = (i + ii - f_off) % ny;
        for (jj = 0; jj < filter_size; jj++) {
          jr = (j + jj - f_off) % nx;
          val += filter[ii][jj] * input[(int)(ir * nx + jr)];
        }
      }
      output[si * snx + sj] = val / 2.0;
      sj++;
    }
    si++;
  }
  if ((nx % 2) == 0) {
    for (i = 0; i < sny; i++) {
      output[(i * snx) + (snx - 1)] = output[i * snx + (snx - 2)];
    }
  }
  if ((ny % 2) == 0) {
    for (j = 0; j < snx; j++) {
      output[((sny - 1) * snx) + j] = output[(sny - 2) * snx + j];
    }
  }
}


x86 assembly (clang, -O0):
<reduce_flow>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
lea    -0x40(%rbp),%rdi
lea    0xecc(%rip),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
movl   $0x2,-0x74(%rbp)
movl   $0x3,-0x78(%rbp)
mov    -0x78(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0xe92(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
cvtsi2ssl -0x14(%rbp),%xmm0
cvtsi2ssl -0x74(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x60(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
cvtsi2ssl -0x74(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1304 <reduce_flow+0x1e4>
movl   $0x0,-0x70(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12ed <reduce_flow+0x1cd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    12a7 <reduce_flow+0x187>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
sub    -0x68(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %edx,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1294 <reduce_flow+0x174>
mov    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x5c(%rbp)
movslq -0x4c(%rbp),%rcx
lea    -0x40(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    122a <reduce_flow+0x10a>
jmp    1299 <reduce_flow+0x179>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1207 <reduce_flow+0xe7>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd48(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    11e7 <reduce_flow+0xc7>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x48(%rbp)
jmp    11c8 <reduce_flow+0xa8>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1374 <reduce_flow+0x254>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    136f <reduce_flow+0x24f>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x60(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x60(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    131f <reduce_flow+0x1ff>
jmp    1374 <reduce_flow+0x254>
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    13e0 <reduce_flow+0x2c0>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    13db <reduce_flow+0x2bb>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x60(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    138f <reduce_flow+0x26f>
jmp    13e0 <reduce_flow+0x2c0>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reduce_flow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%r12d
cvtsi2ss %edx,%xmm0
mov    %ecx,%ebx
mov    %rsi,0x10(%rsp)
mov    %rdi,%r13
mulss  0xec9(%rip),%xmm0
call   1030 <floorf@plt>
cvttss2si %xmm0,%eax
mov    %rax,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0xeac(%rip),%xmm0
call   1030 <floorf@plt>
movss  0xe9f(%rip),%xmm7
mov    %rbx,(%rsp)
cmp    $0x3,%ebx
jl     1313 <reduce_flow+0x203>
lea    -0x3(%r12),%ebp
and    $0xfffffffe,%ebp
movslq 0x8(%rsp),%rcx
mov    (%rsp),%rax
add    $0xfffffffd,%eax
shr    %eax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
shl    $0x2,%rcx
mov    %rcx,0x20(%rsp)
add    $0x2,%rbp
mov    $0x1,%r8d
xor    %r14d,%r14d
movss  0xe5a(%rip),%xmm1
xorps  %xmm2,%xmm2
movss  0xe53(%rip),%xmm3
movss  0xe4f(%rip),%xmm4
mov    0x10(%rsp),%r15
jmp    11e8 <reduce_flow+0xd8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
add    $0x2,%r8
add    0x20(%rsp),%r15
cmp    0x18(%rsp),%r14
je     1313 <reduce_flow+0x203>
cmp    $0x3,%r12d
jl     11d0 <reduce_flow+0xc0>
lea    -0x1(%r8),%eax
cltd
mov    (%rsp),%rcx
idiv   %ecx
mov    %edx,%r9d
imul   %r12d,%r9d
mov    %r8d,%eax
cltd
idiv   %ecx
mov    %edx,%r10d
imul   %r12d,%r10d
lea    0x1(%r8),%eax
cltd
idiv   %ecx
mov    %edx,%r11d
imul   %r12d,%r11d
xor    %esi,%esi
nopl   (%rax)
mov    %esi,%eax
cltd
idiv   %r12d
mov    %edx,%ecx
lea    (%rcx,%r9,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm2,%xmm5
lea    0x1(%rsi),%eax
cltd
idiv   %r12d
mov    %edx,%ebx
lea    (%rbx,%r9,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
lea    0x2(%rsi),%rdi
mov    %edi,%eax
cltd
idiv   %r12d
lea    (%rdx,%r9,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm6,%xmm5
lea    (%rcx,%r10,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
lea    (%rbx,%r10,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
lea    (%rdx,%r10,1),%eax
cltq
movss  0x0(%r13,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
add    %r11d,%ecx
movslq %ecx,%rax
movss  0x0(%r13,%rax,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm6,%xmm5
add    %r11d,%ebx
movslq %ebx,%rax
movss  0x0(%r13,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
add    %r11d,%edx
movslq %edx,%rax
movss  0x0(%r13,%rax,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm7,%xmm5
movss  %xmm5,(%r15,%rsi,2)
mov    %rdi,%rsi
cmp    %rdi,%rbp
jne    1220 <reduce_flow+0x110>
jmp    11d0 <reduce_flow+0xc0>
cvttss2si %xmm0,%r9d
test   $0x1,%r12b
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%r10
jne    142d <reduce_flow+0x31d>
test   %r9d,%r9d
jle    142d <reduce_flow+0x31d>
mov    %r9d,%r8d
cmp    $0x1,%r10d
jne    139f <reduce_flow+0x28f>
movss  -0x4(%rax),%xmm0
xor    %edx,%edx
cmp    $0x1,%r9d
je     138f <reduce_flow+0x27f>
lea    (%r10,%r10,1),%ecx
lea    (%r10,%r10,1),%esi
add    $0xffffffff,%esi
lea    -0x1(%r10),%edi
mov    %r8d,%ebx
and    $0xfffffffe,%ebx
neg    %rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movslq %edi,%rdi
movss  %xmm0,(%rax,%rdi,4)
movslq %esi,%rsi
movss  %xmm0,(%rax,%rsi,4)
add    %ecx,%esi
add    $0xfffffffffffffffe,%rdx
add    %ecx,%edi
cmp    %rdx,%rbx
jne    1370 <reduce_flow+0x260>
neg    %edx
test   $0x1,%r8b
je     142d <reduce_flow+0x31d>
imul   %r10d,%edx
jmp    141e <reduce_flow+0x30e>
xor    %edx,%edx
cmp    $0x1,%r9d
je     1405 <reduce_flow+0x2f5>
lea    (%r10,%r10,1),%esi
lea    (%r10,%r10,1),%edi
add    $0xffffffff,%edi
lea    -0x1(%r10),%ebp
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbp),%ebx
movslq %ebx,%rbx
movss  (%rax,%rbx,4),%xmm0
movslq %ebp,%rbp
movss  %xmm0,(%rax,%rbp,4)
lea    -0x1(%rdi),%ebx
movslq %ebx,%rbx
movss  (%rax,%rbx,4),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rax,%rdi,4)
add    %esi,%edi
add    $0xfffffffffffffffe,%rdx
add    %esi,%ebp
cmp    %rdx,%rcx
jne    13d0 <reduce_flow+0x2c0>
neg    %edx
test   $0x1,%r8b
je     142d <reduce_flow+0x31d>
imul   %r10d,%edx
lea    (%rdx,%r10,1),%ecx
add    $0xfffffffe,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
lea    (%rdx,%r10,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
testb  $0x1,(%rsp)
jne    15b8 <reduce_flow+0x4a8>
test   %r10d,%r10d
jle    15b8 <reduce_flow+0x4a8>
lea    -0x2(%r9),%ecx
imul   %r10d,%ecx
add    $0xffffffff,%r9d
imul   %r10d,%r9d
movslq %ecx,%r8
movslq %r9d,%r9
mov    %r10d,%ebx
cmp    $0x8,%r10d
jb     1489 <reduce_flow+0x379>
lea    (%rax,%r9,4),%rcx
lea    (%r8,%rbx,1),%rdx
lea    (%rax,%rdx,4),%rdx
cmp    %rdx,%rcx
jae    151c <reduce_flow+0x40c>
lea    (%r9,%rbx,1),%rcx
lea    (%rax,%rcx,4),%rcx
lea    (%rax,%r8,4),%rdx
cmp    %rcx,%rdx
jae    151c <reduce_flow+0x40c>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rbx,%rdi
mov    %rbx,%rcx
and    $0x3,%rcx
je     14c5 <reduce_flow+0x3b5>
lea    (%rax,%r9,4),%rdx
lea    (%rax,%r8,4),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    14b0 <reduce_flow+0x3a0>
cmp    $0x3,%rdi
jb     15b8 <reduce_flow+0x4a8>
lea    (%rax,%r9,4),%rcx
add    $0xc,%rcx
lea    (%rax,%r8,4),%rdx
add    $0xc,%rdx
nop
movss  -0xc(%rdx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rcx,%rsi,4)
movss  -0x8(%rdx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rcx,%rsi,4)
movss  -0x4(%rdx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rsi,4)
movss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    14e0 <reduce_flow+0x3d0>
jmp    15b8 <reduce_flow+0x4a8>
mov    %ebx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     15c7 <reduce_flow+0x4b7>
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rax,%r8,4),%rcx
add    $0x30,%rcx
lea    (%rax,%r9,4),%rdx
add    $0x30,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,4)
movups %xmm1,-0x20(%rdx,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,4)
movups %xmm1,(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1560 <reduce_flow+0x450>
test   $0x1,%r10b
je     15af <reduce_flow+0x49f>
lea    (%r8,%rbp,1),%rcx
movups (%rax,%rcx,4),%xmm0
movups 0x10(%rax,%rcx,4),%xmm1
add    %r9,%rbp
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
cmp    %rbx,%rsi
jne    148b <reduce_flow+0x37b>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r10b
jne    1596 <reduce_flow+0x486>
jmp    15af <reduce_flow+0x49f>

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

LLVM IR (-O2):
define void @reduce_flow(float* nocapture %0, float* nocapture %1, i32 %2, i32 %3) {
%5 = sitofp i32 %2 to float
%6 = fmul float %5, 5.000000e-01
%7 = tail call float @llvm.floor.f32(float %6)
%8 = fptosi float %7 to i32
%9 = sitofp i32 %3 to float
%10 = fmul float %9, 5.000000e-01
%11 = tail call float @llvm.floor.f32(float %10)
%12 = fptosi float %11 to i32
%13 = icmp sgt i32 %3, 2
br i1 %13, label %14, label %107
14: ; preds = %4
%15 = icmp sgt i32 %2, 2
%16 = add i32 %2, -3
%17 = lshr i32 %16, 1
%18 = add nuw i32 %17, 1
%19 = sext i32 %8 to i64
%20 = add nsw i32 %3, -3
%21 = lshr i32 %20, 1
%22 = add nuw nsw i32 %21, 1
%23 = zext i32 %22 to i64
%24 = zext i32 %18 to i64
br label %25
25: ; preds = %14, %103
%26 = phi i64 [ 0, %14 ], [ %104, %103 ]
%27 = phi i64 [ 1, %14 ], [ %105, %103 ]
br i1 %15, label %28, label %103
28: ; preds = %25
%29 = mul nsw i64 %26, %19
%30 = trunc i64 %27 to i32
%31 = add i32 %30, -1
%32 = srem i32 %31, %3
%33 = mul nsw i32 %32, %2
%34 = trunc i64 %27 to i32
%35 = srem i32 %34, %3
%36 = mul nsw i32 %35, %2
%37 = trunc i64 %27 to i32
%38 = add i32 %37, 1
%39 = srem i32 %38, %3
%40 = mul nsw i32 %39, %2
br label %41
41: ; preds = %28, %41
%42 = phi i64 [ 1, %28 ], [ %101, %41 ]
%43 = phi i64 [ 0, %28 ], [ %100, %41 ]
%44 = trunc i64 %42 to i32
%45 = add i32 %44, -1
%46 = srem i32 %45, %2
%47 = add nsw i32 %46, %33
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %0, i64 %48
%50 = load float, float* %49
%51 = tail call float @llvm.fmuladd.f32(float %50, float 6.250000e-02, float 0.000000e+00)
%52 = trunc i64 %42 to i32
%53 = srem i32 %52, %2
%54 = add nsw i32 %53, %33
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %0, i64 %55
%57 = load float, float* %56
%58 = tail call float @llvm.fmuladd.f32(float %57, float 1.250000e-01, float %51)
%59 = trunc i64 %42 to i32
%60 = add i32 %59, 1
%61 = srem i32 %60, %2
%62 = add nsw i32 %61, %33
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %0, i64 %63
%65 = load float, float* %64
%66 = tail call float @llvm.fmuladd.f32(float %65, float 6.250000e-02, float %58)
%67 = add nsw i32 %46, %36
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %0, i64 %68
%70 = load float, float* %69
%71 = tail call float @llvm.fmuladd.f32(float %70, float 1.250000e-01, float %66)
%72 = add nsw i32 %53, %36
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %0, i64 %73
%75 = load float, float* %74
%76 = tail call float @llvm.fmuladd.f32(float %75, float 2.500000e-01, float %71)
%77 = add nsw i32 %61, %36
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %0, i64 %78
%80 = load float, float* %79
%81 = tail call float @llvm.fmuladd.f32(float %80, float 1.250000e-01, float %76)
%82 = add nsw i32 %46, %40
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %0, i64 %83
%85 = load float, float* %84
%86 = tail call float @llvm.fmuladd.f32(float %85, float 6.250000e-02, float %81)
%87 = add nsw i32 %53, %40
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %0, i64 %88
%90 = load float, float* %89
%91 = tail call float @llvm.fmuladd.f32(float %90, float 1.250000e-01, float %86)
%92 = add nsw i32 %61, %40
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %0, i64 %93
%95 = load float, float* %94
%96 = tail call float @llvm.fmuladd.f32(float %95, float 6.250000e-02, float %91)
%97 = fmul float %96, 5.000000e-01
%98 = add nsw i64 %43, %29
%99 = getelementptr inbounds float, float* %1, i64 %98
store float %97, float* %99
%100 = add nuw nsw i64 %43, 1
%101 = add nuw nsw i64 %42, 2
%102 = icmp eq i64 %100, %24
br i1 %102, label %103, label %41
103: ; preds = %41, %25
%104 = add nuw nsw i64 %26, 1
%105 = add nuw nsw i64 %27, 2
%106 = icmp eq i64 %104, %23
br i1 %106, label %107, label %25
107: ; preds = %103, %4
%108 = and i32 %2, 1
%109 = icmp eq i32 %108, 0
%110 = icmp sgt i32 %12, 0
%111 = select i1 %109, i1 %110, i1 false
br i1 %111, label %112, label %199
112: ; preds = %107
%113 = zext i32 %12 to i64
%114 = icmp eq i32 %8, 1
br i1 %114, label %147, label %115
115: ; preds = %112
%116 = and i64 %113, 1
%117 = icmp eq i32 %12, 1
br i1 %117, label %186, label %118
118: ; preds = %115
%119 = and i64 %113, 4294967294
br label %120
120: ; preds = %120, %118
%121 = phi i64 [ 0, %118 ], [ %144, %120 ]
%122 = phi i64 [ 0, %118 ], [ %145, %120 ]
%123 = trunc i64 %121 to i32
%124 = mul i32 %123, %8
%125 = add i32 %124, %8
%126 = add i32 %125, -2
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %1, i64 %127
%129 = load float, float* %128
%130 = add i32 %125, -1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %1, i64 %131
store float %129, float* %132
%133 = trunc i64 %121 to i32
%134 = or i32 %133, 1
%135 = mul i32 %134, %8
%136 = add i32 %135, %8
%137 = add i32 %136, -2
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %1, i64 %138
%140 = load float, float* %139
%141 = add i32 %136, -1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %1, i64 %142
store float %140, float* %143
%144 = add nuw nsw i64 %121, 2
%145 = add i64 %122, 2
%146 = icmp eq i64 %145, %119
br i1 %146, label %184, label %120
147: ; preds = %112
%148 = getelementptr float, float* %1, i64 -1
%149 = load float, float* %148
%150 = and i64 %113, 1
%151 = icmp eq i32 %12, 1
br i1 %151, label %175, label %152
152: ; preds = %147
%153 = and i64 %113, 4294967294
br label %154
154: ; preds = %154, %152
%155 = phi i64 [ 0, %152 ], [ %170, %154 ]
%156 = phi i64 [ 0, %152 ], [ %171, %154 ]
%157 = trunc i64 %155 to i32
%158 = mul i32 %157, %8
%159 = add i32 %158, %8
%160 = add i32 %159, -1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %1, i64 %161
store float %149, float* %162
%163 = trunc i64 %155 to i32
%164 = or i32 %163, 1
%165 = mul i32 %164, %8
%166 = add i32 %165, %8
%167 = add i32 %166, -1
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %1, i64 %168
store float %149, float* %169
%170 = add nuw nsw i64 %155, 2
%171 = add i64 %156, 2
%172 = icmp eq i64 %171, %153
br i1 %172, label %173, label %154
173: ; preds = %154
%174 = trunc i64 %170 to i32
br label %175
175: ; preds = %173, %147
%176 = phi i32 [ 0, %147 ], [ %174, %173 ]
%177 = icmp eq i64 %150, 0
br i1 %177, label %199, label %178
178: ; preds = %175
%179 = mul i32 %176, %8
%180 = add i32 %179, %8
%181 = add i32 %180, -1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %1, i64 %182
store float %149, float* %183
br label %199
184: ; preds = %120
%185 = trunc i64 %144 to i32
br label %186
186: ; preds = %184, %115
%187 = phi i32 [ 0, %115 ], [ %185, %184 ]
%188 = icmp eq i64 %116, 0
br i1 %188, label %199, label %189
189: ; preds = %186
%190 = mul i32 %187, %8
%191 = add i32 %190, %8
%192 = add i32 %191, -2
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %1, i64 %193
%195 = load float, float* %194
%196 = add i32 %191, -1
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %1, i64 %197
store float %195, float* %198
br label %199
199: ; preds = %189, %186, %178, %175, %107
%200 = and i32 %3, 1
%201 = icmp eq i32 %200, 0
%202 = icmp sgt i32 %8, 0
%203 = select i1 %201, i1 %202, i1 false
br i1 %203, label %204, label %328
204: ; preds = %199
%205 = add nsw i32 %12, -2
%206 = mul nsw i32 %205, %8
%207 = add nsw i32 %12, -1
%208 = mul nsw i32 %207, %8
%209 = sext i32 %206 to i64
%210 = sext i32 %208 to i64
%211 = zext i32 %8 to i64
%212 = icmp ult i32 %8, 8
br i1 %212, label %281, label %213
213: ; preds = %204
%214 = getelementptr float, float* %1, i64 %210
%215 = add nsw i64 %210, %211
%216 = getelementptr float, float* %1, i64 %215
%217 = getelementptr float, float* %1, i64 %209
%218 = add nsw i64 %209, %211
%219 = getelementptr float, float* %1, i64 %218
%220 = icmp ult float* %214, %219
%221 = icmp ult float* %217, %216
%222 = and i1 %220, %221
br i1 %222, label %281, label %223
223: ; preds = %213
%224 = and i64 %211, 4294967288
%225 = add nsw i64 %224, -8
%226 = lshr exact i64 %225, 3
%227 = add nuw nsw i64 %226, 1
%228 = and i64 %227, 1
%229 = icmp eq i64 %225, 0
br i1 %229, label %263, label %230
230: ; preds = %223
%231 = and i64 %227, 4611686018427387902
br label %232
232: ; preds = %232, %230
%233 = phi i64 [ 0, %230 ], [ %260, %232 ]
%234 = phi i64 [ 0, %230 ], [ %261, %232 ]
%235 = add nsw i64 %233, %209
%236 = getelementptr inbounds float, float* %1, i64 %235
%237 = bitcast float* %236 to <4 x float>*
%238 = load <4 x float>, <4 x float>* %237
%239 = getelementptr inbounds float, float* %236, i64 4
%240 = bitcast float* %239 to <4 x float>*
%241 = load <4 x float>, <4 x float>* %240
%242 = add nsw i64 %233, %210
%243 = getelementptr inbounds float, float* %1, i64 %242
%244 = bitcast float* %243 to <4 x float>*
store <4 x float> %238, <4 x float>* %244
%245 = getelementptr inbounds float, float* %243, i64 4
%246 = bitcast float* %245 to <4 x float>*
store <4 x float> %241, <4 x float>* %246
%247 = or i64 %233, 8
%248 = add nsw i64 %247, %209
%249 = getelementptr inbounds float, float* %1, i64 %248
%250 = bitcast float* %249 to <4 x float>*
%251 = load <4 x float>, <4 x float>* %250
%252 = getelementptr inbounds float, float* %249, i64 4
%253 = bitcast float* %252 to <4 x float>*
%254 = load <4 x float>, <4 x float>* %253
%255 = add nsw i64 %247, %210
%256 = getelementptr inbounds float, float* %1, i64 %255
%257 = bitcast float* %256 to <4 x float>*
store <4 x float> %251, <4 x float>* %257
%258 = getelementptr inbounds float, float* %256, i64 4
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> %254, <4 x float>* %259
%260 = add nuw i64 %233, 16
%261 = add i64 %234, 2
%262 = icmp eq i64 %261, %231
br i1 %262, label %263, label %232
263: ; preds = %232, %223
%264 = phi i64 [ 0, %223 ], [ %260, %232 ]
%265 = icmp eq i64 %228, 0
br i1 %265, label %279, label %266
266: ; preds = %263
%267 = add nsw i64 %264, %209
%268 = getelementptr inbounds float, float* %1, i64 %267
%269 = bitcast float* %268 to <4 x float>*
%270 = load <4 x float>, <4 x float>* %269
%271 = getelementptr inbounds float, float* %268, i64 4
%272 = bitcast float* %271 to <4 x float>*
%273 = load <4 x float>, <4 x float>* %272
%274 = add nsw i64 %264, %210
%275 = getelementptr inbounds float, float* %1, i64 %274
%276 = bitcast float* %275 to <4 x float>*
store <4 x float> %270, <4 x float>* %276
%277 = getelementptr inbounds float, float* %275, i64 4
%278 = bitcast float* %277 to <4 x float>*
store <4 x float> %273, <4 x float>* %278
br label %279
279: ; preds = %263, %266
%280 = icmp eq i64 %224, %211
br i1 %280, label %328, label %281
281: ; preds = %213, %204, %279
%282 = phi i64 [ 0, %213 ], [ 0, %204 ], [ %224, %279 ]
%283 = xor i64 %282, -1
%284 = add nsw i64 %283, %211
%285 = and i64 %211, 3
%286 = icmp eq i64 %285, 0
br i1 %286, label %298, label %287
287: ; preds = %281, %287
%288 = phi i64 [ %295, %287 ], [ %282, %281 ]
%289 = phi i64 [ %296, %287 ], [ 0, %281 ]
%290 = add nsw i64 %288, %209
%291 = getelementptr inbounds float, float* %1, i64 %290
%292 = load float, float* %291
%293 = add nsw i64 %288, %210
%294 = getelementptr inbounds float, float* %1, i64 %293
store float %292, float* %294
%295 = add nuw nsw i64 %288, 1
%296 = add i64 %289, 1
%297 = icmp eq i64 %296, %285
br i1 %297, label %298, label %287
298: ; preds = %287, %281
%299 = phi i64 [ %282, %281 ], [ %295, %287 ]
%300 = icmp ult i64 %284, 3
br i1 %300, label %328, label %301
301: ; preds = %298, %301
%302 = phi i64 [ %326, %301 ], [ %299, %298 ]
%303 = add nsw i64 %302, %209
%304 = getelementptr inbounds float, float* %1, i64 %303
%305 = load float, float* %304
%306 = add nsw i64 %302, %210
%307 = getelementptr inbounds float, float* %1, i64 %306
store float %305, float* %307
%308 = add nuw nsw i64 %302, 1
%309 = add nsw i64 %308, %209
%310 = getelementptr inbounds float, float* %1, i64 %309
%311 = load float, float* %310
%312 = add nsw i64 %308, %210
%313 = getelementptr inbounds float, float* %1, i64 %312
store float %311, float* %313
%314 = add nuw nsw i64 %302, 2
%315 = add nsw i64 %314, %209
%316 = getelementptr inbounds float, float* %1, i64 %315
%317 = load float, float* %316
%318 = add nsw i64 %314, %210
%319 = getelementptr inbounds float, float* %1, i64 %318
store float %317, float* %319
%320 = add nuw nsw i64 %302, 3
%321 = add nsw i64 %320, %209
%322 = getelementptr inbounds float, float* %1, i64 %321
%323 = load float, float* %322
%324 = add nsw i64 %320, %210
%325 = getelementptr inbounds float, float* %1, i64 %324
store float %323, float* %325
%326 = add nuw nsw i64 %302, 4
%327 = icmp eq i64 %326, %211
br i1 %327, label %328, label %301
328: ; preds = %298, %301, %279, %199
ret void
}