; LLVM IR from jgaeddert/liquid-dsp :: src/filter/src (filter_crcf)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.iirfilt_crcf_s = type { ptr, ptr, ptr, i32, i32, i32, i32, ptr, ptr, ptr, i32, float }

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

declare <2 x float> @__mulsc3(float, float, float, float)

; Function Attrs: nounwind
declare <2 x float> @cexpf(<2 x float> noundef) #1

; Function Attrs: nounwind uwtable
define dso_local i32 @iirfilt_crcf_freqresponse(ptr noundef %0, float noundef %1, ptr noundef %2) #2 {
  %4 = alloca ptr, align 8
  %5 = alloca float, align 4
  %6 = alloca ptr, align 8
  %7 = alloca i32, align 4
  %8 = alloca { float, float }, align 4
  %9 = alloca { float, float }, align 4
  %10 = alloca { float, float }, align 4
  %11 = alloca { float, float }, align 4
  %12 = alloca { float, float }, align 4
  %13 = alloca { float, float }, align 4
  %14 = alloca { float, float }, align 4
  %15 = alloca { float, float }, align 4
  %16 = alloca { float, float }, align 4
  %17 = alloca { float, float }, align 4
  %18 = alloca { float, float }, align 4
  %19 = alloca { float, float }, align 4
  %20 = alloca { float, float }, align 4
  %21 = alloca { float, float }, align 4
  %22 = alloca { float, float }, align 4
  %23 = alloca { float, float }, align 4
  %24 = alloca { float, float }, align 4
  %25 = alloca { float, float }, align 4
  %26 = alloca { float, float }, align 4
  %27 = alloca { float, float }, align 4
  %28 = alloca { float, float }, align 4
  %29 = alloca { float, float }, align 4
  %30 = alloca { float, float }, align 4
  %31 = alloca { float, float }, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store float %1, ptr %5, align 4, !tbaa !9
  store ptr %2, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #3
  %32 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %33 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float 0.000000e+00, ptr %32, align 4
  store float 0.000000e+00, ptr %33, align 4
  %34 = load ptr, ptr %4, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %34, i32 0, i32 6
  %36 = load i32, ptr %35, align 4, !tbaa !11
  %37 = icmp eq i32 %36, 0
  br i1 %37, label %38, label %150

38:                                               ; preds = %3
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #3
  %39 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %40 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  store float 0.000000e+00, ptr %39, align 4
  store float 0.000000e+00, ptr %40, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #3
  %41 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %42 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  store float 0.000000e+00, ptr %41, align 4
  store float 0.000000e+00, ptr %42, align 4
  store i32 0, ptr %7, align 4, !tbaa !14
  br label %43

43:                                               ; preds = %85, %38
  %44 = load i32, ptr %7, align 4, !tbaa !14
  %45 = load ptr, ptr %4, align 8, !tbaa !5
  %46 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %45, i32 0, i32 4
  %47 = load i32, ptr %46, align 4, !tbaa !15
  %48 = icmp ult i32 %44, %47
  br i1 %48, label %49, label %88

49:                                               ; preds = %43
  %50 = load ptr, ptr %4, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %50, i32 0, i32 0
  %52 = load ptr, ptr %51, align 8, !tbaa !16
  %53 = load i32, ptr %7, align 4, !tbaa !14
  %54 = zext i32 %53 to i64
  %55 = getelementptr inbounds float, ptr %52, i64 %54
  %56 = load float, ptr %55, align 4, !tbaa !9
  %57 = load float, ptr %5, align 4, !tbaa !9
  %58 = fpext float %57 to double
  %59 = fmul double 0.000000e+00, %58
  %60 = fmul double 0x401921FB54442D18, %58
  %61 = load i32, ptr %7, align 4, !tbaa !14
  %62 = uitofp i32 %61 to double
  %63 = fmul double %59, %62
  %64 = fmul double %60, %62
  %65 = fptrunc double %63 to float
  %66 = fptrunc double %64 to float
  %67 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %68 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  store float %65, ptr %67, align 4
  store float %66, ptr %68, align 4
  %69 = load <2 x float>, ptr %11, align 4
  %70 = call <2 x float> @cexpf(<2 x float> noundef %69) #3
  store <2 x float> %70, ptr %12, align 4
  %71 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %72 = load float, ptr %71, align 4
  %73 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %74 = load float, ptr %73, align 4
  %75 = fmul float %56, %72
  %76 = fmul float %56, %74
  %77 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %78 = load float, ptr %77, align 4
  %79 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  %80 = load float, ptr %79, align 4
  %81 = fadd float %78, %75
  %82 = fadd float %80, %76
  %83 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %84 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  store float %81, ptr %83, align 4
  store float %82, ptr %84, align 4
  br label %85

85:                                               ; preds = %49
  %86 = load i32, ptr %7, align 4, !tbaa !14
  %87 = add i32 %86, 1
  store i32 %87, ptr %7, align 4, !tbaa !14
  br label %43, !llvm.loop !17

88:                                               ; preds = %43
  store i32 0, ptr %7, align 4, !tbaa !14
  br label %89

89:                                               ; preds = %131, %88
  %90 = load i32, ptr %7, align 4, !tbaa !14
  %91 = load ptr, ptr %4, align 8, !tbaa !5
  %92 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %91, i32 0, i32 5
  %93 = load i32, ptr %92, align 8, !tbaa !19
  %94 = icmp ult i32 %90, %93
  br i1 %94, label %95, label %134

95:                                               ; preds = %89
  %96 = load ptr, ptr %4, align 8, !tbaa !5
  %97 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %96, i32 0, i32 1
  %98 = load ptr, ptr %97, align 8, !tbaa !20
  %99 = load i32, ptr %7, align 4, !tbaa !14
  %100 = zext i32 %99 to i64
  %101 = getelementptr inbounds float, ptr %98, i64 %100
  %102 = load float, ptr %101, align 4, !tbaa !9
  %103 = load float, ptr %5, align 4, !tbaa !9
  %104 = fpext float %103 to double
  %105 = fmul double 0.000000e+00, %104
  %106 = fmul double 0x401921FB54442D18, %104
  %107 = load i32, ptr %7, align 4, !tbaa !14
  %108 = uitofp i32 %107 to double
  %109 = fmul double %105, %108
  %110 = fmul double %106, %108
  %111 = fptrunc double %109 to float
  %112 = fptrunc double %110 to float
  %113 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 0
  %114 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 1
  store float %111, ptr %113, align 4
  store float %112, ptr %114, align 4
  %115 = load <2 x float>, ptr %13, align 4
  %116 = call <2 x float> @cexpf(<2 x float> noundef %115) #3
  store <2 x float> %116, ptr %14, align 4
  %117 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %118 = load float, ptr %117, align 4
  %119 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  %120 = load float, ptr %119, align 4
  %121 = fmul float %102, %118
  %122 = fmul float %102, %120
  %123 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %124 = load float, ptr %123, align 4
  %125 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %126 = load float, ptr %125, align 4
  %127 = fadd float %124, %121
  %128 = fadd float %126, %122
  %129 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %130 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  store float %127, ptr %129, align 4
  store float %128, ptr %130, align 4
  br label %131

131:                                              ; preds = %95
  %132 = load i32, ptr %7, align 4, !tbaa !14
  %133 = add i32 %132, 1
  store i32 %133, ptr %7, align 4, !tbaa !14
  br label %89, !llvm.loop !21

134:                                              ; preds = %89
  %135 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %136 = load float, ptr %135, align 4
  %137 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  %138 = load float, ptr %137, align 4
  %139 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %140 = load float, ptr %139, align 4
  %141 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %142 = load float, ptr %141, align 4
  %143 = call <2 x float> @__divsc3(float noundef %136, float noundef %138, float noundef %140, float noundef %142) #3
  store <2 x float> %143, ptr %15, align 4
  %144 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %145 = load float, ptr %144, align 4
  %146 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  %147 = load float, ptr %146, align 4
  %148 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %149 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float %145, ptr %148, align 4
  store float %147, ptr %149, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  br label %375

150:                                              ; preds = %3
  %151 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %152 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float 1.000000e+00, ptr %151, align 4
  store float 0.000000e+00, ptr %152, align 4
  store i32 0, ptr %7, align 4, !tbaa !14
  br label %153

153:                                              ; preds = %371, %150
  %154 = load i32, ptr %7, align 4, !tbaa !14
  %155 = load ptr, ptr %4, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %155, i32 0, i32 10
  %157 = load i32, ptr %156, align 8, !tbaa !22
  %158 = icmp ult i32 %154, %157
  br i1 %158, label %159, label %374

159:                                              ; preds = %153
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #3
  %160 = load ptr, ptr %4, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %160, i32 0, i32 0
  %162 = load ptr, ptr %161, align 8, !tbaa !16
  %163 = load i32, ptr %7, align 4, !tbaa !14
  %164 = mul i32 3, %163
  %165 = add i32 %164, 0
  %166 = zext i32 %165 to i64
  %167 = getelementptr inbounds float, ptr %162, i64 %166
  %168 = load float, ptr %167, align 4, !tbaa !9
  %169 = load float, ptr %5, align 4, !tbaa !9
  %170 = fpext float %169 to double
  %171 = fmul double 0.000000e+00, %170
  %172 = fmul double 0x401921FB54442D18, %170
  %173 = fmul double %171, 0.000000e+00
  %174 = fmul double %172, 0.000000e+00
  %175 = fptrunc double %173 to float
  %176 = fptrunc double %174 to float
  %177 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 0
  %178 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 1
  store float %175, ptr %177, align 4
  store float %176, ptr %178, align 4
  %179 = load <2 x float>, ptr %17, align 4
  %180 = call <2 x float> @cexpf(<2 x float> noundef %179) #3
  store <2 x float> %180, ptr %18, align 4
  %181 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 0
  %182 = load float, ptr %181, align 4
  %183 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 1
  %184 = load float, ptr %183, align 4
  %185 = fmul float %168, %182
  %186 = fmul float %168, %184
  %187 = load ptr, ptr %4, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %187, i32 0, i32 0
  %189 = load ptr, ptr %188, align 8, !tbaa !16
  %190 = load i32, ptr %7, align 4, !tbaa !14
  %191 = mul i32 3, %190
  %192 = add i32 %191, 1
  %193 = zext i32 %192 to i64
  %194 = getelementptr inbounds float, ptr %189, i64 %193
  %195 = load float, ptr %194, align 4, !tbaa !9
  %196 = load float, ptr %5, align 4, !tbaa !9
  %197 = fpext float %196 to double
  %198 = fmul double 0.000000e+00, %197
  %199 = fmul double 0x401921FB54442D18, %197
  %200 = fmul double %198, 1.000000e+00
  %201 = fmul double %199, 1.000000e+00
  %202 = fptrunc double %200 to float
  %203 = fptrunc double %201 to float
  %204 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %205 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  store float %202, ptr %204, align 4
  store float %203, ptr %205, align 4
  %206 = load <2 x float>, ptr %19, align 4
  %207 = call <2 x float> @cexpf(<2 x float> noundef %206) #3
  store <2 x float> %207, ptr %20, align 4
  %208 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 0
  %209 = load float, ptr %208, align 4
  %210 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 1
  %211 = load float, ptr %210, align 4
  %212 = fmul float %195, %209
  %213 = fmul float %195, %211
  %214 = fadd float %185, %212
  %215 = fadd float %186, %213
  %216 = load ptr, ptr %4, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %216, i32 0, i32 0
  %218 = load ptr, ptr %217, align 8, !tbaa !16
  %219 = load i32, ptr %7, align 4, !tbaa !14
  %220 = mul i32 3, %219
  %221 = add i32 %220, 2
  %222 = zext i32 %221 to i64
  %223 = getelementptr inbounds float, ptr %218, i64 %222
  %224 = load float, ptr %223, align 4, !tbaa !9
  %225 = load float, ptr %5, align 4, !tbaa !9
  %226 = fpext float %225 to double
  %227 = fmul double 0.000000e+00, %226
  %228 = fmul double 0x401921FB54442D18, %226
  %229 = fmul double %227, 2.000000e+00
  %230 = fmul double %228, 2.000000e+00
  %231 = fptrunc double %229 to float
  %232 = fptrunc double %230 to float
  %233 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 0
  %234 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 1
  store float %231, ptr %233, align 4
  store float %232, ptr %234, align 4
  %235 = load <2 x float>, ptr %21, align 4
  %236 = call <2 x float> @cexpf(<2 x float> noundef %235) #3
  store <2 x float> %236, ptr %22, align 4
  %237 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 0
  %238 = load float, ptr %237, align 4
  %239 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 1
  %240 = load float, ptr %239, align 4
  %241 = fmul float %224, %238
  %242 = fmul float %224, %240
  %243 = fadd float %214, %241
  %244 = fadd float %215, %242
  %245 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 0
  %246 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 1
  store float %243, ptr %245, align 4
  store float %244, ptr %246, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #3
  %247 = load ptr, ptr %4, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %247, i32 0, i32 1
  %249 = load ptr, ptr %248, align 8, !tbaa !20
  %250 = load i32, ptr %7, align 4, !tbaa !14
  %251 = mul i32 3, %250
  %252 = add i32 %251, 0
  %253 = zext i32 %252 to i64
  %254 = getelementptr inbounds float, ptr %249, i64 %253
  %255 = load float, ptr %254, align 4, !tbaa !9
  %256 = load float, ptr %5, align 4, !tbaa !9
  %257 = fpext float %256 to double
  %258 = fmul double 0.000000e+00, %257
  %259 = fmul double 0x401921FB54442D18, %257
  %260 = fmul double %258, 0.000000e+00
  %261 = fmul double %259, 0.000000e+00
  %262 = fptrunc double %260 to float
  %263 = fptrunc double %261 to float
  %264 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 0
  %265 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 1
  store float %262, ptr %264, align 4
  store float %263, ptr %265, align 4
  %266 = load <2 x float>, ptr %24, align 4
  %267 = call <2 x float> @cexpf(<2 x float> noundef %266) #3
  store <2 x float> %267, ptr %25, align 4
  %268 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 0
  %269 = load float, ptr %268, align 4
  %270 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 1
  %271 = load float, ptr %270, align 4
  %272 = fmul float %255, %269
  %273 = fmul float %255, %271
  %274 = load ptr, ptr %4, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %274, i32 0, i32 1
  %276 = load ptr, ptr %275, align 8, !tbaa !20
  %277 = load i32, ptr %7, align 4, !tbaa !14
  %278 = mul i32 3, %277
  %279 = add i32 %278, 1
  %280 = zext i32 %279 to i64
  %281 = getelementptr inbounds float, ptr %276, i64 %280
  %282 = load float, ptr %281, align 4, !tbaa !9
  %283 = load float, ptr %5, align 4, !tbaa !9
  %284 = fpext float %283 to double
  %285 = fmul double 0.000000e+00, %284
  %286 = fmul double 0x401921FB54442D18, %284
  %287 = fmul double %285, 1.000000e+00
  %288 = fmul double %286, 1.000000e+00
  %289 = fptrunc double %287 to float
  %290 = fptrunc double %288 to float
  %291 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %292 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  store float %289, ptr %291, align 4
  store float %290, ptr %292, align 4
  %293 = load <2 x float>, ptr %26, align 4
  %294 = call <2 x float> @cexpf(<2 x float> noundef %293) #3
  store <2 x float> %294, ptr %27, align 4
  %295 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %296 = load float, ptr %295, align 4
  %297 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  %298 = load float, ptr %297, align 4
  %299 = fmul float %282, %296
  %300 = fmul float %282, %298
  %301 = fadd float %272, %299
  %302 = fadd float %273, %300
  %303 = load ptr, ptr %4, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %303, i32 0, i32 1
  %305 = load ptr, ptr %304, align 8, !tbaa !20
  %306 = load i32, ptr %7, align 4, !tbaa !14
  %307 = mul i32 3, %306
  %308 = add i32 %307, 2
  %309 = zext i32 %308 to i64
  %310 = getelementptr inbounds float, ptr %305, i64 %309
  %311 = load float, ptr %310, align 4, !tbaa !9
  %312 = load float, ptr %5, align 4, !tbaa !9
  %313 = fpext float %312 to double
  %314 = fmul double 0.000000e+00, %313
  %315 = fmul double 0x401921FB54442D18, %313
  %316 = fmul double %314, 2.000000e+00
  %317 = fmul double %315, 2.000000e+00
  %318 = fptrunc double %316 to float
  %319 = fptrunc double %317 to float
  %320 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 0
  %321 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 1
  store float %318, ptr %320, align 4
  store float %319, ptr %321, align 4
  %322 = load <2 x float>, ptr %28, align 4
  %323 = call <2 x float> @cexpf(<2 x float> noundef %322) #3
  store <2 x float> %323, ptr %29, align 4
  %324 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %325 = load float, ptr %324, align 4
  %326 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  %327 = load float, ptr %326, align 4
  %328 = fmul float %311, %325
  %329 = fmul float %311, %327
  %330 = fadd float %301, %328
  %331 = fadd float %302, %329
  %332 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %333 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  store float %330, ptr %332, align 4
  store float %331, ptr %333, align 4
  %334 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 0
  %335 = load float, ptr %334, align 4
  %336 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 1
  %337 = load float, ptr %336, align 4
  %338 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %339 = load float, ptr %338, align 4
  %340 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  %341 = load float, ptr %340, align 4
  %342 = call <2 x float> @__divsc3(float noundef %335, float noundef %337, float noundef %339, float noundef %341) #3
  store <2 x float> %342, ptr %30, align 4
  %343 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 0
  %344 = load float, ptr %343, align 4
  %345 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 1
  %346 = load float, ptr %345, align 4
  %347 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %348 = load float, ptr %347, align 4
  %349 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %350 = load float, ptr %349, align 4
  %351 = fmul float %348, %344
  %352 = fmul float %350, %346
  %353 = fmul float %348, %346
  %354 = fmul float %350, %344
  %355 = fsub float %351, %352
  %356 = fadd float %353, %354
  %357 = fcmp uno float %355, %355
  br i1 %357, label %358, label %366, !prof !23

358:                                              ; preds = %159
  %359 = fcmp uno float %356, %356
  br i1 %359, label %360, label %366, !prof !23

360:                                              ; preds = %358
  %361 = call <2 x float> @__mulsc3(float noundef %348, float noundef %350, float noundef %344, float noundef %346) #3
  store <2 x float> %361, ptr %31, align 4
  %362 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 0
  %363 = load float, ptr %362, align 4
  %364 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 1
  %365 = load float, ptr %364, align 4
  br label %366

366:                                              ; preds = %360, %358, %159
  %367 = phi float [ %355, %159 ], [ %355, %358 ], [ %363, %360 ]
  %368 = phi float [ %356, %159 ], [ %356, %358 ], [ %365, %360 ]
  %369 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %370 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float %367, ptr %369, align 4
  store float %368, ptr %370, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #3
  br label %371

371:                                              ; preds = %366
  %372 = load i32, ptr %7, align 4, !tbaa !14
  %373 = add i32 %372, 1
  store i32 %373, ptr %7, align 4, !tbaa !14
  br label %153, !llvm.loop !24

374:                                              ; preds = %153
  br label %375

375:                                              ; preds = %374, %134
  %376 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %377 = load float, ptr %376, align 4
  %378 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %379 = load float, ptr %378, align 4
  %380 = load ptr, ptr %4, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.iirfilt_crcf_s, ptr %380, i32 0, i32 11
  %382 = load float, ptr %381, align 4, !tbaa !25
  %383 = fmul float %377, %382
  %384 = fmul float %379, %382
  %385 = load ptr, ptr %6, align 8, !tbaa !5
  %386 = getelementptr inbounds { float, float }, ptr %385, i32 0, i32 0
  %387 = getelementptr inbounds { float, float }, ptr %385, i32 0, i32 1
  store float %383, ptr %386, align 4
  store float %384, ptr %387, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #3
  ret i32 0
}

declare <2 x float> @__divsc3(float, float, float, float)

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !13, i64 36}
!12 = !{!"iirfilt_crcf_s", !6, i64 0, !6, i64 8, !6, i64 16, !13, i64 24, !13, i64 28, !13, i64 32, !13, i64 36, !6, i64 40, !6, i64 48, !6, i64 56, !13, i64 64, !10, i64 68}
!13 = !{!"int", !7, i64 0}
!14 = !{!13, !13, i64 0}
!15 = !{!12, !13, i64 28}
!16 = !{!12, !6, i64 0}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = !{!12, !13, i64 32}
!20 = !{!12, !6, i64 8}
!21 = distinct !{!21, !18}
!22 = !{!12, !13, i64 64}
!23 = !{!"branch_weights", i32 1, i32 1048575}
!24 = distinct !{!24, !18}
!25 = !{!12, !10, i64 68}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

declare <2 x float> @__mulsc3(float, float, float, float) local_unnamed_addr

; Function Attrs: nounwind
declare <2 x float> @cexpf(<2 x float> noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @iirfilt_crcf_freqresponse(ptr nocapture noundef readonly %0, float noundef %1, ptr nocapture noundef writeonly %2) local_unnamed_addr #1 {
  %4 = getelementptr inbounds i8, ptr %0, i64 36
  %5 = load i32, ptr %4, align 4, !tbaa !5
  %6 = icmp eq i32 %5, 0
  br i1 %6, label %.preheader76, label %.preheader77

.preheader77:                                     ; preds = %3
  %7 = getelementptr inbounds i8, ptr %0, i64 64
  %8 = load i32, ptr %7, align 8, !tbaa !12
  %.not = icmp eq i32 %8, 0
  br i1 %.not, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %.preheader77
  %9 = fpext float %1 to double
  %10 = insertelement <2 x double> poison, double %9, i64 0
  %11 = shufflevector <2 x double> %10, <2 x double> poison, <2 x i32> zeroinitializer
  %12 = fmul <2 x double> %11, <double 0.000000e+00, double 0x401921FB54442D18>
  %13 = fmul <2 x double> %12, zeroinitializer
  %14 = fptrunc <2 x double> %13 to <2 x float>
  %15 = fptrunc <2 x double> %12 to <2 x float>
  %16 = fmul <2 x double> %12, <double 2.000000e+00, double 2.000000e+00>
  %17 = fptrunc <2 x double> %16 to <2 x float>
  %18 = getelementptr inbounds i8, ptr %0, i64 8
  br label %77

.preheader76:                                     ; preds = %3
  %19 = getelementptr inbounds i8, ptr %0, i64 28
  %20 = load i32, ptr %19, align 4, !tbaa !13
  %.not94 = icmp eq i32 %20, 0
  br i1 %.not94, label %.preheader, label %.lr.ph85

.lr.ph85:                                         ; preds = %.preheader76
  %21 = fpext float %1 to double
  %22 = insertelement <2 x double> poison, double %21, i64 0
  %23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> zeroinitializer
  %24 = fmul <2 x double> %23, <double 0.000000e+00, double 0x401921FB54442D18>
  br label %33

.preheader:                                       ; preds = %33, %.preheader76
  %25 = phi <2 x float> [ zeroinitializer, %.preheader76 ], [ %48, %33 ]
  %26 = getelementptr inbounds i8, ptr %0, i64 32
  %27 = load i32, ptr %26, align 8, !tbaa !14
  %.not95 = icmp eq i32 %27, 0
  br i1 %.not95, label %._crit_edge, label %.lr.ph91

.lr.ph91:                                         ; preds = %.preheader
  %28 = getelementptr inbounds i8, ptr %0, i64 8
  %29 = fpext float %1 to double
  %30 = insertelement <2 x double> poison, double %29, i64 0
  %31 = shufflevector <2 x double> %30, <2 x double> poison, <2 x i32> zeroinitializer
  %32 = fmul <2 x double> %31, <double 0.000000e+00, double 0x401921FB54442D18>
  br label %52

33:                                               ; preds = %.lr.ph85, %33
  %indvars.iv102 = phi i64 [ 0, %.lr.ph85 ], [ %indvars.iv.next103, %33 ]
  %34 = phi <2 x float> [ zeroinitializer, %.lr.ph85 ], [ %48, %33 ]
  %35 = load ptr, ptr %0, align 8, !tbaa !15
  %36 = getelementptr inbounds float, ptr %35, i64 %indvars.iv102
  %37 = load float, ptr %36, align 4, !tbaa !16
  %38 = trunc nuw i64 %indvars.iv102 to i32
  %39 = uitofp i32 %38 to double
  %40 = insertelement <2 x double> poison, double %39, i64 0
  %41 = shufflevector <2 x double> %40, <2 x double> poison, <2 x i32> zeroinitializer
  %42 = fmul <2 x double> %24, %41
  %43 = fptrunc <2 x double> %42 to <2 x float>
  %44 = tail call <2 x float> @cexpf(<2 x float> noundef %43) #2
  %45 = insertelement <2 x float> poison, float %37, i64 0
  %46 = shufflevector <2 x float> %45, <2 x float> poison, <2 x i32> zeroinitializer
  %47 = fmul <2 x float> %46, %44
  %48 = fadd <2 x float> %34, %47
  %indvars.iv.next103 = add nuw nsw i64 %indvars.iv102, 1
  %49 = load i32, ptr %19, align 4, !tbaa !13
  %50 = zext i32 %49 to i64
  %51 = icmp ult i64 %indvars.iv.next103, %50
  br i1 %51, label %33, label %.preheader, !llvm.loop !17

52:                                               ; preds = %.lr.ph91, %52
  %indvars.iv105 = phi i64 [ 0, %.lr.ph91 ], [ %indvars.iv.next106, %52 ]
  %53 = phi <2 x float> [ zeroinitializer, %.lr.ph91 ], [ %67, %52 ]
  %54 = load ptr, ptr %28, align 8, !tbaa !19
  %55 = getelementptr inbounds float, ptr %54, i64 %indvars.iv105
  %56 = load float, ptr %55, align 4, !tbaa !16
  %57 = trunc nuw i64 %indvars.iv105 to i32
  %58 = uitofp i32 %57 to double
  %59 = insertelement <2 x double> poison, double %58, i64 0
  %60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
  %61 = fmul <2 x double> %32, %60
  %62 = fptrunc <2 x double> %61 to <2 x float>
  %63 = tail call <2 x float> @cexpf(<2 x float> noundef %62) #2
  %64 = insertelement <2 x float> poison, float %56, i64 0
  %65 = shufflevector <2 x float> %64, <2 x float> poison, <2 x i32> zeroinitializer
  %66 = fmul <2 x float> %65, %63
  %67 = fadd <2 x float> %53, %66
  %indvars.iv.next106 = add nuw nsw i64 %indvars.iv105, 1
  %68 = load i32, ptr %26, align 8, !tbaa !14
  %69 = zext i32 %68 to i64
  %70 = icmp ult i64 %indvars.iv.next106, %69
  br i1 %70, label %52, label %._crit_edge, !llvm.loop !20

._crit_edge:                                      ; preds = %52, %.preheader
  %71 = phi <2 x float> [ zeroinitializer, %.preheader ], [ %67, %52 ]
  %72 = extractelement <2 x float> %71, i64 0
  %73 = extractelement <2 x float> %71, i64 1
  %74 = extractelement <2 x float> %25, i64 0
  %75 = extractelement <2 x float> %25, i64 1
  %76 = tail call <2 x float> @__divsc3(float noundef %74, float noundef %75, float noundef %72, float noundef %73) #2
  br label %.loopexit

77:                                               ; preds = %.lr.ph, %150
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %150 ]
  %78 = phi <2 x float> [ <float 1.000000e+00, float 0.000000e+00>, %.lr.ph ], [ %151, %150 ]
  %79 = load ptr, ptr %0, align 8, !tbaa !15
  %80 = trunc nuw i64 %indvars.iv to i32
  %81 = mul i32 %80, 3
  %82 = zext i32 %81 to i64
  %83 = getelementptr inbounds float, ptr %79, i64 %82
  %84 = load float, ptr %83, align 4, !tbaa !16
  %85 = tail call <2 x float> @cexpf(<2 x float> noundef %14) #2
  %.sroa.018.0.vec.extract = extractelement <2 x float> %85, i64 0
  %.sroa.018.4.vec.extract = extractelement <2 x float> %85, i64 1
  %86 = fmul float %84, %.sroa.018.0.vec.extract
  %87 = fmul float %84, %.sroa.018.4.vec.extract
  %88 = load ptr, ptr %0, align 8, !tbaa !15
  %89 = add i32 %81, 1
  %90 = zext i32 %89 to i64
  %91 = getelementptr inbounds float, ptr %88, i64 %90
  %92 = load float, ptr %91, align 4, !tbaa !16
  %93 = tail call <2 x float> @cexpf(<2 x float> noundef %15) #2
  %.sroa.015.0.vec.extract = extractelement <2 x float> %93, i64 0
  %.sroa.015.4.vec.extract = extractelement <2 x float> %93, i64 1
  %94 = fmul float %92, %.sroa.015.0.vec.extract
  %95 = fmul float %92, %.sroa.015.4.vec.extract
  %96 = fadd float %86, %94
  %97 = fadd float %87, %95
  %98 = load ptr, ptr %0, align 8, !tbaa !15
  %99 = add i32 %81, 2
  %100 = zext i32 %99 to i64
  %101 = getelementptr inbounds float, ptr %98, i64 %100
  %102 = load float, ptr %101, align 4, !tbaa !16
  %103 = tail call <2 x float> @cexpf(<2 x float> noundef %17) #2
  %.sroa.012.0.vec.extract = extractelement <2 x float> %103, i64 0
  %.sroa.012.4.vec.extract = extractelement <2 x float> %103, i64 1
  %104 = fmul float %102, %.sroa.012.0.vec.extract
  %105 = fmul float %102, %.sroa.012.4.vec.extract
  %106 = fadd float %96, %104
  %107 = fadd float %97, %105
  %108 = load ptr, ptr %18, align 8, !tbaa !19
  %109 = getelementptr inbounds float, ptr %108, i64 %82
  %110 = load float, ptr %109, align 4, !tbaa !16
  %111 = tail call <2 x float> @cexpf(<2 x float> noundef %14) #2
  %.sroa.08.0.vec.extract = extractelement <2 x float> %111, i64 0
  %.sroa.08.4.vec.extract = extractelement <2 x float> %111, i64 1
  %112 = fmul float %110, %.sroa.08.0.vec.extract
  %113 = fmul float %110, %.sroa.08.4.vec.extract
  %114 = load ptr, ptr %18, align 8, !tbaa !19
  %115 = getelementptr inbounds float, ptr %114, i64 %90
  %116 = load float, ptr %115, align 4, !tbaa !16
  %117 = tail call <2 x float> @cexpf(<2 x float> noundef %15) #2
  %.sroa.05.0.vec.extract = extractelement <2 x float> %117, i64 0
  %.sroa.05.4.vec.extract = extractelement <2 x float> %117, i64 1
  %118 = fmul float %116, %.sroa.05.0.vec.extract
  %119 = fmul float %116, %.sroa.05.4.vec.extract
  %120 = fadd float %112, %118
  %121 = fadd float %113, %119
  %122 = load ptr, ptr %18, align 8, !tbaa !19
  %123 = getelementptr inbounds float, ptr %122, i64 %100
  %124 = load float, ptr %123, align 4, !tbaa !16
  %125 = tail call <2 x float> @cexpf(<2 x float> noundef %17) #2
  %.sroa.02.0.vec.extract = extractelement <2 x float> %125, i64 0
  %.sroa.02.4.vec.extract = extractelement <2 x float> %125, i64 1
  %126 = fmul float %124, %.sroa.02.0.vec.extract
  %127 = fmul float %124, %.sroa.02.4.vec.extract
  %128 = fadd float %120, %126
  %129 = fadd float %121, %127
  %130 = tail call <2 x float> @__divsc3(float noundef %106, float noundef %107, float noundef %128, float noundef %129) #2
  %131 = shufflevector <2 x float> %78, <2 x float> poison, <2 x i32> zeroinitializer
  %132 = fmul <2 x float> %131, %130
  %133 = shufflevector <2 x float> %78, <2 x float> poison, <2 x i32> <i32 1, i32 1>
  %134 = fmul <2 x float> %133, %130
  %135 = shufflevector <2 x float> %134, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %136 = fsub <2 x float> %132, %135
  %137 = fadd <2 x float> %132, %135
  %138 = shufflevector <2 x float> %136, <2 x float> %137, <2 x i32> <i32 0, i32 3>
  %139 = extractelement <2 x float> %136, i64 0
  %140 = fcmp uno float %139, 0.000000e+00
  br i1 %140, label %141, label %150, !prof !21

141:                                              ; preds = %77
  %142 = extractelement <2 x float> %137, i64 1
  %143 = fcmp uno float %142, 0.000000e+00
  br i1 %143, label %144, label %150, !prof !21

144:                                              ; preds = %141
  %145 = extractelement <2 x float> %130, i64 0
  %146 = extractelement <2 x float> %130, i64 1
  %147 = extractelement <2 x float> %78, i64 0
  %148 = extractelement <2 x float> %78, i64 1
  %149 = tail call <2 x float> @__mulsc3(float noundef %147, float noundef %148, float noundef %145, float noundef %146) #2
  br label %150

150:                                              ; preds = %144, %141, %77
  %151 = phi <2 x float> [ %138, %77 ], [ %138, %141 ], [ %149, %144 ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %152 = load i32, ptr %7, align 8, !tbaa !12
  %153 = zext i32 %152 to i64
  %154 = icmp ult i64 %indvars.iv.next, %153
  br i1 %154, label %77, label %.loopexit, !llvm.loop !22

.loopexit:                                        ; preds = %150, %.preheader77, %._crit_edge
  %155 = phi <2 x float> [ %76, %._crit_edge ], [ <float 1.000000e+00, float 0.000000e+00>, %.preheader77 ], [ %151, %150 ]
  %156 = getelementptr inbounds i8, ptr %0, i64 68
  %157 = load float, ptr %156, align 4, !tbaa !23
  %158 = insertelement <2 x float> poison, float %157, i64 0
  %159 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> zeroinitializer
  %160 = fmul <2 x float> %155, %159
  store <2 x float> %160, ptr %2, align 4
  ret i32 0
}

declare <2 x float> @__divsc3(float, float, float, float) local_unnamed_addr

attributes #0 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !10, i64 36}
!6 = !{!"iirfilt_crcf_s", !7, i64 0, !7, i64 8, !7, i64 16, !10, i64 24, !10, i64 28, !10, i64 32, !10, i64 36, !7, i64 40, !7, i64 48, !7, i64 56, !10, i64 64, !11, i64 68}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"float", !8, i64 0}
!12 = !{!6, !10, i64 64}
!13 = !{!6, !10, i64 28}
!14 = !{!6, !10, i64 32}
!15 = !{!6, !7, i64 0}
!16 = !{!11, !11, i64 0}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = !{!6, !7, i64 8}
!20 = distinct !{!20, !18}
!21 = !{!"branch_weights", i32 1, i32 1048575}
!22 = distinct !{!22, !18}
!23 = !{!6, !11, i64 68}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass