#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*/ lirerr(int);
void complex_lowpass(float *zin, float *zout, int nn, int siz) {
  int i, j, k, avgnum;
  float r1, r2, t1, t2, t3;
  avgnum = nn | 1;
  if (avgnum > nn && avgnum > siz / 4)
    avgnum -= 2;
  if (avgnum < 1) {
    lirerr(1105);
    return;
  }
  t1 = 0;
  t2 = 0;
  t3 = 1.0 / avgnum;
  for (i = 0; i < avgnum; i++) {
    t1 += zin[2 * i];
    t2 += zin[2 * i + 1];
  }
  j = 1 + avgnum / 2;
  r1 = t1 * t3;
  r2 = t2 * t3;
  for (i = 0; i < j; i++) {
    zout[2 * i] = r1;
    zout[2 * i + 1] = r2;
  }
  i = 0;
  k = avgnum;
  while (k < siz) {
    t1 += zin[2 * k] - zin[2 * i];
    t2 += zin[2 * k + 1] - zin[2 * i + 1];
    zout[2 * j] = t3 * t1;
    zout[2 * j + 1] = t3 * t2;
    i++;
    j++;
    k++;
  }
  t1 *= t3;
  t2 *= t3;
  while (j < siz) {
    zout[2 * j] = t1;
    zout[2 * j + 1] = t2;
    j++;
  }
}


x86 assembly (clang, -O0):
<complex_lowpass>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1162 <complex_lowpass+0x52>
mov    -0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
cmp    %ecx,%eax
jle    1162 <complex_lowpass+0x52>
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jge    117b <complex_lowpass+0x6b>
mov    $0x451,%edi
call   1030 <lirerr@plt>
jmp    13c1 <complex_lowpass+0x2b1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2sdl -0x28(%rbp),%xmm1
movsd  0xe68(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1201 <complex_lowpass+0xf1>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ac <complex_lowpass+0x9c>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1282 <complex_lowpass+0x172>
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1237 <complex_lowpass+0x127>
movl   $0x0,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1358 <complex_lowpass+0x248>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    128f <complex_lowpass+0x17f>
movss  -0x3c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13c1 <complex_lowpass+0x2b1>
movss  -0x34(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1376 <complex_lowpass+0x266>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<complex_lowpass>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,%eax
or     $0x1,%eax
lea    0x3(%rcx),%ebp
test   %ecx,%ecx
cmovns %ecx,%ebp
sar    $0x2,%ebp
lea    -0x2(%rax),%r10d
cmp    %ebp,%eax
cmovle %eax,%r10d
cmp    %edx,%eax
cmovle %eax,%r10d
test   %r10d,%r10d
jle    1169 <complex_lowpass+0x59>
cvtsi2sd %r10d,%xmm1
movsd  0xeb4(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %r10d,%eax
lea    -0x1(%rax),%rbp
mov    %eax,%edx
and    $0x3,%edx
cmp    $0x3,%rbp
jae    117d <complex_lowpass+0x6d>
xorps  %xmm2,%xmm2
xor    %ebx,%ebx
jmp    11bc <complex_lowpass+0xac>
mov    $0x451,%edi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <lirerr@plt>
and    $0xfffffffc,%eax
xorps  %xmm2,%xmm2
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rbx,8),%xmm1
addps  %xmm2,%xmm1
movsd  0x8(%rdi,%rbx,8),%xmm2
addps  %xmm1,%xmm2
movsd  0x10(%rdi,%rbx,8),%xmm1
addps  %xmm2,%xmm1
movsd  0x18(%rdi,%rbx,8),%xmm2
addps  %xmm1,%xmm2
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1190 <complex_lowpass+0x80>
cvtsd2ss %xmm0,%xmm3
lea    (%rdi,%rbx,8),%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rbp,8),%xmm0
addps  %xmm0,%xmm2
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    11d0 <complex_lowpass+0xc0>
mov    %r10d,%r8d
shr    $0x1f,%r8d
add    %r10d,%r8d
sar    %r8d
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
mulss  %xmm3,%xmm0
lea    0x1(%r8),%r9d
cmp    $0xffffffff,%r10d
jl     12b4 <complex_lowpass+0x1a4>
mov    %r9d,%edx
cmp    $0x4,%r9d
jae    121e <complex_lowpass+0x10e>
xor    %ebx,%ebx
jmp    12a0 <complex_lowpass+0x190>
mov    %edx,%ebx
and    $0xfffffffc,%ebx
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
unpcklps %xmm5,%xmm4
lea    -0x4(%rbx),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     1519 <complex_lowpass+0x409>
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm4,(%rsi,%rax,8)
movups %xmm4,0x10(%rsi,%rax,8)
movups %xmm4,0x20(%rsi,%rax,8)
movups %xmm4,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1260 <complex_lowpass+0x150>
test   $0x1,%r11b
je     1298 <complex_lowpass+0x188>
lea    0x0(,%rax,8),%rbp
or     $0x14,%rbp
movups %xmm4,(%rsi,%rax,8)
movups %xmm4,-0x4(%rsi,%rbp,1)
cmp    %rdx,%rbx
je     12b4 <complex_lowpass+0x1a4>
nopl   (%rax)
movss  %xmm1,(%rsi,%rbx,8)
movss  %xmm0,0x4(%rsi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    12a0 <complex_lowpass+0x190>
cmp    %ecx,%r10d
jge    1337 <complex_lowpass+0x227>
mov    %ecx,%r9d
sub    %r10d,%r9d
add    %r10d,%r10d
neg    %r9
lea    (%r8,%r8,1),%r11d
xor    %ebx,%ebx
xor    %edx,%edx
nopl   (%rax)
lea    (%r10,%rdx,1),%rbp
movslq %ebp,%rbp
lea    0x1(%rbp),%eax
cltq
movsd  (%rdi,%rdx,4),%xmm0
movss  (%rdi,%rbp,4),%xmm1
movss  (%rdi,%rax,4),%xmm4
unpcklps %xmm4,%xmm1
subps  %xmm0,%xmm1
addps  %xmm1,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
lea    0x2(%r11,%rdx,1),%eax
cltq
movss  %xmm1,(%rsi,%rax,4)
mulss  %xmm3,%xmm0
lea    (%r11,%rdx,1),%eax
add    $0x3,%eax
cltq
movss  %xmm0,(%rsi,%rax,4)
add    $0x2,%rdx
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%r9
jne    12d0 <complex_lowpass+0x1c0>
sub    %ebx,%r8d
add    $0x1,%r8d
mov    %r8d,%r9d
cmp    %ecx,%r9d
jge    150e <complex_lowpass+0x3fe>
movslq %r9d,%r10
movslq %ecx,%r13
mov    %r13,%r11
sub    %r10,%r11
cmp    $0x4,%r11
jae    13c6 <complex_lowpass+0x2b6>
sub    %r10d,%ecx
mov    %r10,%rax
not    %rax
test   $0x1,%cl
je     137f <complex_lowpass+0x26f>
lea    (%r10,%r10,1),%ecx
movslq %ecx,%rcx
movss  %xmm1,(%rsi,%rcx,4)
lea    (%r10,%r10,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%r10
add    %r13,%rax
je     150e <complex_lowpass+0x3fe>
lea    (%r10,%r10,1),%eax
sub    %r10,%r13
nop
cltq
movss  %xmm1,(%rsi,%rax,4)
lea    0x1(%rax),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
lea    0x2(%rax),%ecx
movslq %ecx,%rcx
movss  %xmm1,(%rsi,%rcx,4)
lea    0x3(%rax),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
add    $0x4,%eax
add    $0xfffffffffffffffe,%r13
jne    1390 <complex_lowpass+0x280>
jmp    150e <complex_lowpass+0x3fe>
mov    %r10,%r8
not    %r8
add    %r13,%r8
lea    (%r9,%r9,1),%ebx
mov    %r8d,%ebp
add    %ebp,%ebp
setb   %r14b
lea    0x0(%rbp,%r9,2),%r12d
mov    $0x8,%edx
mov    %r8,%rax
mul    %rdx
seto   %r15b
cmp    %ebx,%r12d
jl     1352 <complex_lowpass+0x242>
test   %r14b,%r14b
jne    1352 <complex_lowpass+0x242>
shr    $0x20,%r8
jne    1352 <complex_lowpass+0x242>
lea    (%r9,%r9,1),%edx
add    $0x1,%edx
lea    0x1(%rbp,%r9,2),%ebp
cmp    %edx,%ebp
jl     1352 <complex_lowpass+0x242>
test   %r14b,%r14b
jne    1352 <complex_lowpass+0x242>
test   %r8,%r8
jne    1352 <complex_lowpass+0x242>
movslq %ebx,%r8
lea    (%rsi,%r8,4),%rbp
lea    (%rax,%rbp,1),%rdx
cmp    %rbp,%rdx
jb     1352 <complex_lowpass+0x242>
test   %r15b,%r15b
jne    1352 <complex_lowpass+0x242>
lea    (%rsi,%r8,4),%rdx
add    $0x4,%rdx
add    %rbp,%rax
add    $0x4,%rax
cmp    %rdx,%rax
jb     1352 <complex_lowpass+0x242>
test   %r15b,%r15b
jne    1352 <complex_lowpass+0x242>
mov    %r11,%r8
and    $0xfffffffffffffffc,%r8
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
unpcklps %xmm3,%xmm2
lea    -0x4(%r8),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     1532 <complex_lowpass+0x422>
mov    %r14,%rdx
and    $0xfffffffffffffffe,%rdx
add    $0xd,%ebx
xor    %eax,%eax
nopl   0x0(%rax)
lea    -0xc(%rbx),%ebp
lea    -0x8(%rbx),%edi
movslq %ebp,%rbp
movslq %edi,%rdi
movups %xmm2,-0x4(%rsi,%rbp,4)
movups %xmm2,-0x4(%rsi,%rdi,4)
lea    -0x4(%rbx),%edi
movslq %edi,%rdi
movslq %ebx,%rbx
movups %xmm2,-0x4(%rsi,%rdi,4)
movups %xmm2,-0x4(%rsi,%rbx,4)
add    $0x10,%ebx
add    $0x8,%eax
add    $0xfffffffffffffffe,%rdx
jne    14b0 <complex_lowpass+0x3a0>
test   $0x1,%r14b
je     1509 <complex_lowpass+0x3f9>
add    %eax,%r9d
lea    (%r9,%r9,1),%eax
add    $0x1,%eax
lea    0x5(%r9,%r9,1),%edx
cltq
movslq %edx,%rdx
movups %xmm2,-0x4(%rsi,%rax,4)
movups %xmm2,-0x4(%rsi,%rdx,4)
cmp    %r8,%r11
jne    152a <complex_lowpass+0x41a>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
test   $0x1,%r11b
jne    1283 <complex_lowpass+0x173>
jmp    1298 <complex_lowpass+0x188>
add    %r8,%r10
jmp    1352 <complex_lowpass+0x242>
xor    %eax,%eax
test   $0x1,%r14b
jne    14eb <complex_lowpass+0x3db>
jmp    1509 <complex_lowpass+0x3f9>

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

LLVM IR (-O2):
define void @complex_lowpass(float* nocapture %0, float* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = or i32 %2, 1
%6 = icmp sgt i32 %5, %2
%7 = sdiv i32 %3, 4
%8 = icmp sgt i32 %5, %7
%9 = and i1 %6, %8
%10 = add nsw i32 %5, -2
%11 = select i1 %9, i32 %10, i32 %5
%12 = icmp slt i32 %11, 1
br i1 %12, label %13, label %15
13: ; preds = %4
%14 = tail call i32 @lirerr(i32 1105)
br label %380
15: ; preds = %4
%16 = sitofp i32 %11 to double
%17 = fdiv double 1.000000e+00, %16
%18 = fptrunc double %17 to float
%19 = zext i32 %11 to i64
%20 = add nsw i64 %19, -1
%21 = and i64 %19, 3
%22 = icmp ult i64 %20, 3
br i1 %22, label %55, label %23
23: ; preds = %15
%24 = and i64 %19, 4294967292
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %52, %25 ]
%27 = phi <2 x float> [ zeroinitializer, %23 ], [ %51, %25 ]
%28 = phi i64 [ 0, %23 ], [ %53, %25 ]
%29 = shl nuw nsw i64 %26, 1
%30 = getelementptr inbounds float, float* %0, i64 %29
%31 = bitcast float* %30 to <2 x float>*
%32 = load <2 x float>, <2 x float>* %31
%33 = fadd <2 x float> %27, %32
%34 = shl nuw i64 %26, 1
%35 = or i64 %34, 2
%36 = getelementptr inbounds float, float* %0, i64 %35
%37 = bitcast float* %36 to <2 x float>*
%38 = load <2 x float>, <2 x float>* %37
%39 = fadd <2 x float> %33, %38
%40 = shl nuw i64 %26, 1
%41 = or i64 %40, 4
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = bitcast float* %42 to <2 x float>*
%44 = load <2 x float>, <2 x float>* %43
%45 = fadd <2 x float> %39, %44
%46 = shl nuw i64 %26, 1
%47 = or i64 %46, 6
%48 = getelementptr inbounds float, float* %0, i64 %47
%49 = bitcast float* %48 to <2 x float>*
%50 = load <2 x float>, <2 x float>* %49
%51 = fadd <2 x float> %45, %50
%52 = add nuw nsw i64 %26, 4
%53 = add i64 %28, 4
%54 = icmp eq i64 %53, %24
br i1 %54, label %55, label %25
55: ; preds = %15, %25
%56 = phi <2 x float> [ undef, %15 ], [ %51, %25 ]
%57 = phi i64 [ 0, %15 ], [ %52, %25 ]
%58 = phi <2 x float> [ zeroinitializer, %15 ], [ %51, %25 ]
br label %59
59: ; preds = %59, %55
%60 = phi i64 [ %57, %55 ], [ %68, %59 ]
%61 = phi <2 x float> [ %58, %55 ], [ %67, %59 ]
%62 = phi i64 [ 0, %55 ], [ %69, %59 ]
%63 = shl nuw nsw i64 %60, 1
%64 = getelementptr inbounds float, float* %0, i64 %63
%65 = bitcast float* %64 to <2 x float>*
%66 = load <2 x float>, <2 x float>* %65
%67 = fadd <2 x float> %61, %66
%68 = add nuw nsw i64 %60, 1
%69 = add i64 %62, 1
%70 = icmp eq i64 %69, %21
br i1 %70, label %71, label %59
71: ; preds = %59
%72 = sdiv i32 %11, 2
%73 = extractelement <2 x float> %67, i64 0
%74 = fmul float %73, %18
%75 = extractelement <2 x float> %67, i64 1
%76 = fmul float %75, %18
%77 = icmp slt i32 %11, -1
%78 = add nsw i32 %72, 1
br i1 %77, label %150, label %79
79: ; preds = %71
%80 = zext i32 %78 to i64
%81 = icmp ult i32 %78, 4
br i1 %81, label %148, label %82
82: ; preds = %79
%83 = and i64 %80, 4294967292
%84 = insertelement <2 x float> poison, float %74, i64 0
%85 = shufflevector <2 x float> %84, <2 x float> poison, <2 x i32> zeroinitializer
%86 = insertelement <2 x float> poison, float %76, i64 0
%87 = shufflevector <2 x float> %86, <2 x float> poison, <2 x i32> zeroinitializer
%88 = insertelement <2 x float> poison, float %74, i64 0
%89 = shufflevector <2 x float> %88, <2 x float> poison, <2 x i32> zeroinitializer
%90 = insertelement <2 x float> poison, float %76, i64 0
%91 = shufflevector <2 x float> %90, <2 x float> poison, <2 x i32> zeroinitializer
%92 = add nsw i64 %83, -4
%93 = lshr exact i64 %92, 2
%94 = add nuw nsw i64 %93, 1
%95 = and i64 %94, 1
%96 = icmp eq i64 %92, 0
br i1 %96, label %130, label %97
97: ; preds = %82
%98 = and i64 %94, 9223372036854775806
%99 = getelementptr inbounds float, float* %1, i64 -1
%100 = getelementptr inbounds float, float* %1, i64 -1
%101 = shufflevector <2 x float> %85, <2 x float> %87, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%102 = shufflevector <2 x float> %89, <2 x float> %91, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%103 = getelementptr inbounds float, float* %1, i64 -1
%104 = getelementptr inbounds float, float* %1, i64 -1
%105 = shufflevector <2 x float> %85, <2 x float> %87, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%106 = shufflevector <2 x float> %89, <2 x float> %91, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
br label %107
107: ; preds = %107, %97
%108 = phi i64 [ 0, %97 ], [ %127, %107 ]
%109 = phi i64 [ 0, %97 ], [ %128, %107 ]
%110 = shl nuw nsw i64 %108, 1
%111 = shl i64 %108, 1
%112 = or i64 %110, 1
%113 = or i64 %111, 5
%114 = getelementptr inbounds float, float* %99, i64 %112
%115 = bitcast float* %114 to <4 x float>*
%116 = getelementptr inbounds float, float* %100, i64 %113
%117 = bitcast float* %116 to <4 x float>*
store <4 x float> %101, <4 x float>* %115
store <4 x float> %102, <4 x float>* %117
%118 = or i64 %108, 4
%119 = shl nuw nsw i64 %118, 1
%120 = shl i64 %118, 1
%121 = or i64 %119, 1
%122 = or i64 %120, 5
%123 = getelementptr inbounds float, float* %103, i64 %121
%124 = bitcast float* %123 to <4 x float>*
%125 = getelementptr inbounds float, float* %104, i64 %122
%126 = bitcast float* %125 to <4 x float>*
store <4 x float> %105, <4 x float>* %124
store <4 x float> %106, <4 x float>* %126
%127 = add nuw i64 %108, 8
%128 = add i64 %109, 2
%129 = icmp eq i64 %128, %98
br i1 %129, label %130, label %107
130: ; preds = %107, %82
%131 = phi i64 [ 0, %82 ], [ %127, %107 ]
%132 = icmp eq i64 %95, 0
br i1 %132, label %146, label %133
133: ; preds = %130
%134 = shl nuw nsw i64 %131, 1
%135 = shl i64 %131, 1
%136 = or i64 %134, 1
%137 = or i64 %135, 5
%138 = getelementptr inbounds float, float* %1, i64 -1
%139 = getelementptr inbounds float, float* %1, i64 -1
%140 = getelementptr inbounds float, float* %138, i64 %136
%141 = bitcast float* %140 to <4 x float>*
%142 = getelementptr inbounds float, float* %139, i64 %137
%143 = bitcast float* %142 to <4 x float>*
%144 = shufflevector <2 x float> %85, <2 x float> %87, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %144, <4 x float>* %141
%145 = shufflevector <2 x float> %89, <2 x float> %91, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %145, <4 x float>* %143
br label %146
146: ; preds = %130, %133
%147 = icmp eq i64 %83, %80
br i1 %147, label %150, label %148
148: ; preds = %79, %146
%149 = phi i64 [ 0, %79 ], [ %83, %146 ]
br label %158
150: ; preds = %158, %146, %71
%151 = icmp slt i32 %11, %3
br i1 %151, label %152, label %205
152: ; preds = %150
%153 = zext i32 %72 to i64
%154 = add nuw nsw i64 %153, 1
%155 = zext i32 %11 to i64
%156 = sub i32 %3, %11
%157 = zext i32 %156 to i64
br label %166
158: ; preds = %148, %158
%159 = phi i64 [ %164, %158 ], [ %149, %148 ]
%160 = shl nuw nsw i64 %159, 1
%161 = getelementptr inbounds float, float* %1, i64 %160
store float %74, float* %161
%162 = or i64 %160, 1
%163 = getelementptr inbounds float, float* %1, i64 %162
store float %76, float* %163
%164 = add nuw nsw i64 %159, 1
%165 = icmp eq i64 %164, %80
br i1 %165, label %150, label %158
166: ; preds = %152, %166
%167 = phi i64 [ %155, %152 ], [ %200, %166 ]
%168 = phi i64 [ 0, %152 ], [ %199, %166 ]
%169 = phi i64 [ %154, %152 ], [ %201, %166 ]
%170 = phi <2 x float> [ %67, %152 ], [ %188, %166 ]
%171 = trunc i64 %167 to i32
%172 = trunc i64 %169 to i32
%173 = shl nsw i32 %171, 1
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = load float, float* %175
%177 = shl nuw nsw i64 %168, 1
%178 = getelementptr inbounds float, float* %0, i64 %177
%179 = or i32 %173, 1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float, float* %0, i64 %180
%182 = load float, float* %181
%183 = bitcast float* %178 to <2 x float>*
%184 = load <2 x float>, <2 x float>* %183
%185 = insertelement <2 x float> poison, float %176, i64 0
%186 = insertelement <2 x float> %185, float %182, i64 1
%187 = fsub <2 x float> %186, %184
%188 = fadd <2 x float> %170, %187
%189 = extractelement <2 x float> %188, i64 0
%190 = fmul float %189, %18
%191 = shl nsw i32 %172, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %1, i64 %192
store float %190, float* %193
%194 = extractelement <2 x float> %188, i64 1
%195 = fmul float %194, %18
%196 = or i32 %191, 1
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %1, i64 %197
store float %195, float* %198
%199 = add nuw nsw i64 %168, 1
%200 = add i64 %167, 1
%201 = add i64 %169, 1
%202 = icmp eq i64 %199, %157
br i1 %202, label %203, label %166
203: ; preds = %166
%204 = trunc i64 %201 to i32
br label %205
205: ; preds = %203, %150
%206 = phi float [ %195, %203 ], [ %76, %150 ]
%207 = phi float [ %190, %203 ], [ %74, %150 ]
%208 = phi i32 [ %204, %203 ], [ %78, %150 ]
%209 = icmp slt i32 %208, %3
br i1 %209, label %210, label %380
210: ; preds = %205
%211 = sext i32 %208 to i64
%212 = sext i32 %3 to i64
%213 = sub nsw i64 %212, %211
%214 = icmp ult i64 %213, 4
br i1 %214, label %342, label %215
215: ; preds = %210
%216 = xor i64 %211, -1
%217 = add nsw i64 %216, %212
%218 = shl i32 %208, 1
%219 = trunc i64 %217 to i32
%220 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %219, i32 2)
%221 = extractvalue { i32, i1 } %220, 0
%222 = extractvalue { i32, i1 } %220, 1
%223 = add i32 %218, %221
%224 = icmp slt i32 %223, %218
%225 = or i1 %224, %222
%226 = icmp ugt i64 %217, 4294967295
%227 = or i1 %225, %226
%228 = or i32 %218, 1
%229 = trunc i64 %217 to i32
%230 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %229, i32 2)
%231 = extractvalue { i32, i1 } %230, 0
%232 = extractvalue { i32, i1 } %230, 1
%233 = add i32 %228, %231
%234 = icmp slt i32 %233, %228
%235 = or i1 %234, %232
%236 = icmp ugt i64 %217, 4294967295
%237 = or i1 %235, %236
%238 = sext i32 %218 to i64
%239 = getelementptr float, float* %1, i64 %238
%240 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %217, i64 8)
%241 = extractvalue { i64, i1 } %240, 0
%242 = extractvalue { i64, i1 } %240, 1
%243 = bitcast float* %239 to i8*
%244 = getelementptr i8, i8* %243, i64 %241
%245 = icmp ult i8* %244, %243
%246 = or i1 %245, %242
%247 = or i64 %238, 1
%248 = getelementptr float, float* %1, i64 %247
%249 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %217, i64 8)
%250 = extractvalue { i64, i1 } %249, 0
%251 = extractvalue { i64, i1 } %249, 1
%252 = bitcast float* %248 to i8*
%253 = getelementptr i8, i8* %252, i64 %250
%254 = icmp ult i8* %253, %252
%255 = or i1 %254, %251
%256 = or i1 %227, %237
%257 = or i1 %256, %246
%258 = or i1 %257, %255
br i1 %258, label %342, label %259
259: ; preds = %215
%260 = and i64 %213, -4
%261 = add nsw i64 %260, %211
%262 = insertelement <2 x float> poison, float %207, i64 0
%263 = shufflevector <2 x float> %262, <2 x float> poison, <2 x i32> zeroinitializer
%264 = insertelement <2 x float> poison, float %206, i64 0
%265 = shufflevector <2 x float> %264, <2 x float> poison, <2 x i32> zeroinitializer
%266 = insertelement <2 x float> poison, float %207, i64 0
%267 = shufflevector <2 x float> %266, <2 x float> poison, <2 x i32> zeroinitializer
%268 = insertelement <2 x float> poison, float %206, i64 0
%269 = shufflevector <2 x float> %268, <2 x float> poison, <2 x i32> zeroinitializer
%270 = add nsw i64 %260, -4
%271 = lshr exact i64 %270, 2
%272 = add nuw nsw i64 %271, 1
%273 = and i64 %272, 1
%274 = icmp eq i64 %270, 0
br i1 %274, label %320, label %275
275: ; preds = %259
%276 = and i64 %272, 9223372036854775806
%277 = getelementptr inbounds float, float* %1, i64 -1
%278 = getelementptr inbounds float, float* %1, i64 -1
%279 = shufflevector <2 x float> %263, <2 x float> %265, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%280 = shufflevector <2 x float> %267, <2 x float> %269, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%281 = getelementptr inbounds float, float* %1, i64 -1
%282 = getelementptr inbounds float, float* %1, i64 -1
%283 = shufflevector <2 x float> %263, <2 x float> %265, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%284 = shufflevector <2 x float> %267, <2 x float> %269, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
br label %285
285: ; preds = %285, %275
%286 = phi i64 [ 0, %275 ], [ %315, %285 ]
%287 = phi i64 [ 0, %275 ], [ %316, %285 ]
%288 = trunc i64 %286 to i32
%289 = add i32 %208, %288
%290 = shl nsw i32 %289, 1
%291 = shl i32 %289, 1
%292 = add i32 %291, 4
%293 = or i32 %290, 1
%294 = or i32 %292, 1
%295 = sext i32 %293 to i64
%296 = sext i32 %294 to i64
%297 = getelementptr inbounds float, float* %277, i64 %295
%298 = bitcast float* %297 to <4 x float>*
%299 = getelementptr inbounds float, float* %278, i64 %296
%300 = bitcast float* %299 to <4 x float>*
store <4 x float> %279, <4 x float>* %298
store <4 x float> %280, <4 x float>* %300
%301 = trunc i64 %286 to i32
%302 = or i32 %301, 4
%303 = add i32 %208, %302
%304 = shl nsw i32 %303, 1
%305 = shl i32 %303, 1
%306 = add i32 %305, 4
%307 = or i32 %304, 1
%308 = or i32 %306, 1
%309 = sext i32 %307 to i64
%310 = sext i32 %308 to i64
%311 = getelementptr inbounds float, float* %281, i64 %309
%312 = bitcast float* %311 to <4 x float>*
%313 = getelementptr inbounds float, float* %282, i64 %310
%314 = bitcast float* %313 to <4 x float>*
store <4 x float> %283, <4 x float>* %312
store <4 x float> %284, <4 x float>* %314
%315 = add nuw i64 %286, 8
%316 = add i64 %287, 2
%317 = icmp eq i64 %316, %276
br i1 %317, label %318, label %285
318: ; preds = %285
%319 = trunc i64 %315 to i32
br label %320
320: ; preds = %318, %259
%321 = phi i32 [ 0, %259 ], [ %319, %318 ]
%322 = icmp eq i64 %273, 0
br i1 %322, label %340, label %323
323: ; preds = %320
%324 = add i32 %208, %321
%325 = shl nsw i32 %324, 1
%326 = shl i32 %324, 1
%327 = add i32 %326, 4
%328 = or i32 %325, 1
%329 = or i32 %327, 1
%330 = sext i32 %328 to i64
%331 = sext i32 %329 to i64
%332 = getelementptr inbounds float, float* %1, i64 -1
%333 = getelementptr inbounds float, float* %1, i64 -1
%334 = getelementptr inbounds float, float* %332, i64 %330
%335 = bitcast float* %334 to <4 x float>*
%336 = getelementptr inbounds float, float* %333, i64 %331
%337 = bitcast float* %336 to <4 x float>*
%338 = shufflevector <2 x float> %263, <2 x float> %265, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %338, <4 x float>* %335
%339 = shufflevector <2 x float> %267, <2 x float> %269, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %339, <4 x float>* %337
br label %340
340: ; preds = %320, %323
%341 = icmp eq i64 %213, %260
br i1 %341, label %380, label %342
342: ; preds = %215, %210, %340
%343 = phi i64 [ %211, %215 ], [ %211, %210 ], [ %261, %340 ]
%344 = sub nsw i64 %212, %343
%345 = xor i64 %343, -1
%346 = and i64 %344, 1
%347 = icmp eq i64 %346, 0
br i1 %347, label %357, label %348
348: ; preds = %342
%349 = trunc i64 %343 to i32
%350 = shl nsw i32 %349, 1
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds float, float* %1, i64 %351
store float %207, float* %352
%353 = or i32 %350, 1
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %1, i64 %354
store float %206, float* %355
%356 = add nsw i64 %343, 1
br label %357
357: ; preds = %348, %342
%358 = phi i64 [ %343, %342 ], [ %356, %348 ]
%359 = sub nsw i64 0, %212
%360 = icmp eq i64 %345, %359
br i1 %360, label %380, label %361
361: ; preds = %357, %361
%362 = phi i64 [ %378, %361 ], [ %358, %357 ]
%363 = trunc i64 %362 to i32
%364 = shl nsw i32 %363, 1
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %1, i64 %365
store float %207, float* %366
%367 = or i32 %364, 1
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %1, i64 %368
store float %206, float* %369
%370 = trunc i64 %362 to i32
%371 = shl i32 %370, 1
%372 = add i32 %371, 2
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds float, float* %1, i64 %373
store float %207, float* %374
%375 = or i32 %372, 1
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds float, float* %1, i64 %376
store float %206, float* %377
%378 = add nsw i64 %362, 2
%379 = icmp eq i64 %378, %212
br i1 %379, label %380, label %361
380: ; preds = %357, %361, %340, %205, %13
ret void
}