#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*/ bfdesign(float, float, float, float, int *, float *);
int /*<<< orphan*/ bflowpass(int, float, int, float *, float *);
float cos(float);
int /*<<< orphan*/ ints8r(int, float, float, float *, double, double, int,
                          float *, float *);
int /*<<< orphan*/ printf(char *, float, float, ...);
int main(int argc, char *argv[]) {
  float fpasshi, apasshi, fstophi, astophi;
  int npoleshi;
  float f3dbhi;
  int sampRate = 4000;
  float nyq = 0.5 * sampRate;
  int resampRate = 250;
  fpasshi = (float)resampRate / (float)sampRate;
  fstophi = 1.2 * fpasshi;
  apasshi = 0.95;
  astophi = 0.05;
  printf("f = %f %f a =%f %f\n", fpasshi, fstophi, apasshi, astophi);
  bfdesign(fpasshi, apasshi, fstophi, astophi, &npoleshi, &f3dbhi);
  printf("npoles = %d f3db = %f\n", npoleshi, f3dbhi);
  float t[4000], p[4000], q[4000];
  float dt = 1 / (float)sampRate;
  int i, n = 4000;
  float M = 1.;
  float w1 = 2 * (3.141592653589793) * 10;
  float w2 = 2 * (3.141592653589793) * 1000;
  for (i = 0; i < n; i++) {
    t[i] = i * dt;
    p[i] = cos(w1 * t[i] + (w2 - w1) * t[i] * t[i] / (2. * M));
  }
  bflowpass(npoleshi, f3dbhi, n, p, q);
  for (i = 0; i < n; i++)
    printf("%f %f %f\n", t[i], p[i], q[i]);
  int nt_in, nt;
  float dt_in, tmin_in, t2[4000], r[4000];
  nt_in = 4000;
  dt_in = dt;
  tmin_in = 0.;
  dt = dt * 8;
  nt = 4000 / 8;
  t2[0] = tmin_in;
  for (i = 0; i < nt; i++)
    t2[i] = dt * i;
  ints8r(nt_in, dt_in, tmin_in, q, 0.0, 0.0, nt, t2, r);
  for (i = 0; i < nt; i++)
    printf("%f %f\n", t2[i], r[i]);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x138f0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xfa0,-0x2c(%rbp)
cvtsi2sdl -0x2c(%rbp),%xmm1
movsd  0xea3(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0xfa,-0x34(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe63(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xe46(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xe35(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x20(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xe31(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
movss  -0x14(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
lea    -0x24(%rbp),%rdi
lea    -0x28(%rbp),%rsi
call   1050 <bfdesign@plt>
cvtsi2ssl -0x24(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
lea    0xe0c(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
cvtsi2ssl -0x2c(%rbp),%xmm1
movss  0xdbc(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0xbbc4(%rbp)
ff
movl   $0xfa0,-0xbbcc(%rbp)
movss  0xd9e(%rip),%xmm0
movss  %xmm0,-0xbbd0(%rbp)
ff
movss  0xd8a(%rip),%xmm0
movss  %xmm0,-0xbbd4(%rbp)
ff
movss  0xd76(%rip),%xmm0
movss  %xmm0,-0xbbd8(%rbp)
ff
movl   $0x0,-0xbbc8(%rbp)
mov    -0xbbc8(%rbp),%eax
cmp    -0xbbcc(%rbp),%eax
jge    136b <main+0x21b>
cvtsi2ssl -0xbbc8(%rbp),%xmm0
ff
mulss  -0xbbc4(%rbp),%xmm0
ff
movslq -0xbbc8(%rbp),%rax
movss  %xmm0,-0x3ec0(%rbp,%rax,4)
ff ff
movss  -0xbbd4(%rbp),%xmm0
ff
movslq -0xbbc8(%rbp),%rax
mulss  -0x3ec0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movss  -0xbbd8(%rbp),%xmm1
ff
subss  -0xbbd4(%rbp),%xmm1
ff
movslq -0xbbc8(%rbp),%rax
mulss  -0x3ec0(%rbp,%rax,4),%xmm1
ff ff
movslq -0xbbc8(%rbp),%rax
mulss  -0x3ec0(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
movss  -0xbbd0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm3
movsd  0xcf6(%rip),%xmm2
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1060 <cos@plt>
movslq -0xbbc8(%rbp),%rax
movss  %xmm0,-0x7d40(%rbp,%rax,4)
ff ff
mov    -0xbbc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbbc8(%rbp)
jmp    129c <main+0x14c>
mov    -0x24(%rbp),%edi
movss  -0x28(%rbp),%xmm0
mov    -0xbbcc(%rbp),%esi
lea    -0x7d40(%rbp),%rdx
lea    -0xbbc0(%rbp),%rcx
call   1070 <bflowpass@plt>
movl   $0x0,-0xbbc8(%rbp)
mov    -0xbbc8(%rbp),%eax
cmp    -0xbbcc(%rbp),%eax
jge    13fe <main+0x2ae>
movslq -0xbbc8(%rbp),%rax
movss  -0x3ec0(%rbp,%rax,4),%xmm0
ff ff
movslq -0xbbc8(%rbp),%rax
movss  -0x7d40(%rbp,%rax,4),%xmm1
ff ff
movslq -0xbbc8(%rbp),%rax
movss  -0xbbc0(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
lea    0xc78(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0xbbc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbbc8(%rbp)
jmp    1396 <main+0x246>
movl   $0xfa0,-0xbbdc(%rbp)
movss  -0xbbc4(%rbp),%xmm0
ff
movss  %xmm0,-0xbbe4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xbbe8(%rbp)
ff
movss  0xbe9(%rip),%xmm0
mulss  -0xbbc4(%rbp),%xmm0
ff
movss  %xmm0,-0xbbc4(%rbp)
ff
movl   $0x1f4,-0xbbe0(%rbp)
movss  -0xbbe8(%rbp),%xmm0
ff
movss  %xmm0,-0xfa70(%rbp)
ff
movl   $0x0,-0xbbc8(%rbp)
mov    -0xbbc8(%rbp),%eax
cmp    -0xbbe0(%rbp),%eax
jge    14a9 <main+0x359>
movss  -0xbbc4(%rbp),%xmm0
ff
cvtsi2ssl -0xbbc8(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movslq -0xbbc8(%rbp),%rax
movss  %xmm0,-0xfa70(%rbp,%rax,4)
ff ff
mov    -0xbbc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbbc8(%rbp)
jmp    145f <main+0x30f>
mov    -0xbbdc(%rbp),%edi
movss  -0xbbe4(%rbp),%xmm0
ff
movss  -0xbbe8(%rbp),%xmm1
ff
lea    -0xbbc0(%rbp),%rsi
mov    -0xbbe0(%rbp),%edx
lea    -0xfa70(%rbp),%rcx
lea    -0x138f0(%rbp),%r8
xorps  %xmm3,%xmm3
movaps %xmm3,%xmm2
call   1040 <ints8r@plt>
movl   $0x0,-0xbbc8(%rbp)
mov    -0xbbc8(%rbp),%eax
cmp    -0xbbe0(%rbp),%eax
jge    1543 <main+0x3f3>
movslq -0xbbc8(%rbp),%rax
movss  -0xfa70(%rbp,%rax,4),%xmm0
ff ff
movslq -0xbbc8(%rbp),%rax
movss  -0x138f0(%rbp,%rax,4),%xmm1
fe ff
lea    0xb36(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
mov    -0xbbc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbbc8(%rbp)
jmp    14ef <main+0x39f>
mov    -0x4(%rbp),%eax
add    $0x138f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x13898,%rsp
lea    0xf4f(%rip),%rdi
movss  0xe97(%rip),%xmm0
movss  0xe93(%rip),%xmm1
movsd  0xea7(%rip),%xmm2
movsd  0xea7(%rip),%xmm3
mov    $0x4,%al
call   1030 <printf@plt>
movss  0xe78(%rip),%xmm1
movss  0xe74(%rip),%xmm3
lea    0xc(%rsp),%rdi
lea    0x8(%rsp),%rsi
movss  0xe56(%rip),%xmm0
movss  0xe52(%rip),%xmm2
call   1050 <bfdesign@plt>
xorps  %xmm0,%xmm0
cvtsi2ssl 0xc(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
lea    0xef7(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0xe21(%rip),%xmm0
movss  %xmm0,0xfa10(%rsp,%rbx,4)
movaps %xmm0,%xmm1
mulss  0xe15(%rip),%xmm1
mulss  %xmm0,%xmm1
mulss  0xe05(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  0xe11(%rip),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   1060 <cos@plt>
movss  %xmm0,0x7d10(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0xfa0,%rbx
jne    11e0 <main+0x90>
mov    0xc(%rsp),%edi
movss  0x8(%rsp),%xmm0
lea    0x7d10(%rsp),%rdx
lea    0x3e90(%rsp),%rcx
mov    $0xfa0,%esi
call   1070 <bflowpass@plt>
xor    %ebx,%ebx
lea    0xe69(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0xfa10(%rsp,%rbx,4),%xmm0
movss  0x7d10(%rsp,%rbx,4),%xmm1
movss  0x3e90(%rsp,%rbx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rdi
mov    $0x3,%al
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    $0xfa0,%rbx
jne    1280 <main+0x130>
movl   $0x0,0x10(%rsp)
movdqa 0xd7a(%rip),%xmm0
mov    $0xc,%eax
movdqa 0xd7d(%rip),%xmm1
movaps 0xd86(%rip),%xmm2
movdqa 0xd8e(%rip),%xmm3
movdqa 0xd96(%rip),%xmm4
movdqa 0xd9e(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
cvtdq2ps %xmm0,%xmm7
cvtdq2ps %xmm6,%xmm6
mulps  %xmm2,%xmm7
mulps  %xmm2,%xmm6
movaps %xmm7,-0x20(%rsp,%rax,4)
movaps %xmm6,-0x10(%rsp,%rax,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
cvtdq2ps %xmm6,%xmm6
cvtdq2ps %xmm7,%xmm7
mulps  %xmm2,%xmm6
mulps  %xmm2,%xmm7
movaps %xmm6,(%rsp,%rax,4)
movaps %xmm7,0x10(%rsp,%rax,4)
paddd  %xmm5,%xmm0
add    $0x10,%rax
cmp    $0x1fc,%rax
jne    1300 <main+0x1b0>
movaps 0xd46(%rip),%xmm0
movaps %xmm0,0x7d0(%rsp)
movss  0xca6(%rip),%xmm0
lea    0x3e90(%rsp),%rsi
lea    0x10(%rsp),%rcx
lea    0xbb90(%rsp),%r8
pxor   %xmm1,%xmm1
xorps  %xmm2,%xmm2
pxor   %xmm3,%xmm3
mov    $0xfa0,%edi
mov    $0x1f4,%edx
call   1040 <ints8r@plt>
xor    %ebx,%ebx
lea    0xd3c(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x10(%rsp,%rbx,4),%xmm0
movd   0xbb90(%rsp,%rbx,4),%xmm1
mov    %r14,%rdi
mov    $0x2,%al
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    13b0 <main+0x260>
xor    %eax,%eax
add    $0x13898,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
@.str = [20 x i8] c"f = %f %f a =%f %f\0A\00"
@.str.1 = [23 x i8] c"npoles = %d f3db = %f\0A\00"
@.str.2 = [10 x i8] c"%f %f %f\0A\00"
@.str.3 = [7 x i8] c"%f %f\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca i32
%4 = alloca float
%5 = alloca [4000 x float]
%6 = alloca [4000 x float]
%7 = alloca [4000 x float]
%8 = alloca [4000 x float]
%9 = alloca [4000 x float]
%10 = bitcast i32* %3 to i8*
%11 = bitcast float* %4 to i8*
%12 = tail call i32 (i8*, float, float, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0), float 6.250000e-02, float 0x3FB3333340000000, double 0x3FEE666660000000, double 0x3FA99999A0000000)
%13 = call i32 @bfdesign(float 6.250000e-02, float 0x3FEE666660000000, float 0x3FB3333340000000, float 0x3FA99999A0000000, i32* %3, float* %4)
%14 = load i32, i32* %3
%15 = sitofp i32 %14 to float
%16 = load float, float* %4
%17 = call i32 (i8*, float, float, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0), float %15, float %16)
%18 = bitcast [4000 x float]* %5 to i8*
%19 = bitcast [4000 x float]* %6 to i8*
%20 = bitcast [4000 x float]* %7 to i8*
br label %21
21: ; preds = %2, %21
%22 = phi i64 [ 0, %2 ], [ %37, %21 ]
%23 = trunc i64 %22 to i32
%24 = sitofp i32 %23 to float
%25 = fmul float %24, 0x3F30624DE0000000
%26 = getelementptr inbounds [4000 x float], [4000 x float]* %5, i64 0, i64 %22
store float %25, float* %26
%27 = fmul float %25, 0x404F6A7A20000000
%28 = fpext float %27 to double
%29 = fmul float %25, 0x40B84C5A80000000
%30 = fmul float %25, %29
%31 = fpext float %30 to double
%32 = fmul double %31, 5.000000e-01
%33 = fadd double %32, %28
%34 = fptrunc double %33 to float
%35 = call float @cos(float %34)
%36 = getelementptr inbounds [4000 x float], [4000 x float]* %6, i64 0, i64 %22
store float %35, float* %36
%37 = add nuw nsw i64 %22, 1
%38 = icmp eq i64 %37, 4000
br i1 %38, label %39, label %21
39: ; preds = %21
%40 = load i32, i32* %3
%41 = load float, float* %4
%42 = getelementptr inbounds [4000 x float], [4000 x float]* %6, i64 0, i64 0
%43 = getelementptr inbounds [4000 x float], [4000 x float]* %7, i64 0, i64 0
%44 = call i32 @bflowpass(i32 %40, float %41, i32 4000, float* %42, float* %43)
br label %45
45: ; preds = %39, %45
%46 = phi i64 [ 0, %39 ], [ %55, %45 ]
%47 = getelementptr inbounds [4000 x float], [4000 x float]* %5, i64 0, i64 %46
%48 = load float, float* %47
%49 = getelementptr inbounds [4000 x float], [4000 x float]* %6, i64 0, i64 %46
%50 = load float, float* %49
%51 = getelementptr inbounds [4000 x float], [4000 x float]* %7, i64 0, i64 %46
%52 = load float, float* %51
%53 = fpext float %52 to double
%54 = call i32 (i8*, float, float, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), float %48, float %50, double %53)
%55 = add nuw nsw i64 %46, 1
%56 = icmp eq i64 %55, 4000
br i1 %56, label %57, label %45
57: ; preds = %45
%58 = bitcast [4000 x float]* %8 to i8*
%59 = bitcast [4000 x float]* %9 to i8*
%60 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 0
store float 0.000000e+00, float* %60
br label %61
61: ; preds = %61, %57
%62 = phi i64 [ 0, %57 ], [ %84, %61 ]
%63 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %57 ], [ %85, %61 ]
%64 = add <4 x i32> %63, <i32 4, i32 4, i32 4, i32 4>
%65 = sitofp <4 x i32> %63 to <4 x float>
%66 = sitofp <4 x i32> %64 to <4 x float>
%67 = fmul <4 x float> %65, <float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000>
%68 = fmul <4 x float> %66, <float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000>
%69 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 %62
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %67, <4 x float>* %70
%71 = getelementptr inbounds float, float* %69, i64 4
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %68, <4 x float>* %72
%73 = or i64 %62, 8
%74 = add <4 x i32> %63, <i32 8, i32 8, i32 8, i32 8>
%75 = add <4 x i32> %63, <i32 12, i32 12, i32 12, i32 12>
%76 = sitofp <4 x i32> %74 to <4 x float>
%77 = sitofp <4 x i32> %75 to <4 x float>
%78 = fmul <4 x float> %76, <float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000>
%79 = fmul <4 x float> %77, <float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000, float 0x3F60624DE0000000>
%80 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 %73
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %78, <4 x float>* %81
%82 = getelementptr inbounds float, float* %80, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %79, <4 x float>* %83
%84 = add nuw nsw i64 %62, 16
%85 = add <4 x i32> %63, <i32 16, i32 16, i32 16, i32 16>
%86 = icmp eq i64 %84, 496
br i1 %86, label %87, label %61
87: ; preds = %61
%88 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 496
store float 0x3FEFBE76E0000000, float* %88
%89 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 497
store float 0x3FEFCED920000000, float* %89
%90 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 498
store float 0x3FEFDF3B80000000, float* %90
%91 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 499
store float 0x3FEFEF9DC0000000, float* %91
%92 = getelementptr inbounds [4000 x float], [4000 x float]* %9, i64 0, i64 0
%93 = call i32 @ints8r(i32 4000, float 0x3F30624DE0000000, float 0.000000e+00, float* %43, double 0.000000e+00, double 0.000000e+00, i32 500, float* %60, float* %92)
br label %94
94: ; preds = %87, %94
%95 = phi i64 [ 0, %87 ], [ %101, %94 ]
%96 = getelementptr inbounds [4000 x float], [4000 x float]* %8, i64 0, i64 %95
%97 = load float, float* %96
%98 = getelementptr inbounds [4000 x float], [4000 x float]* %9, i64 0, i64 %95
%99 = load float, float* %98
%100 = call i32 (i8*, float, float, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), float %97, float %99)
%101 = add nuw nsw i64 %95, 1
%102 = icmp eq i64 %101, 500
br i1 %102, label %103, label %94
103: ; preds = %94
ret i32 0
}