; LLVM IR from jgaeddert/liquid-dsp :: sandbox (iirfilt_intdiff_test)

; 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"

@.str = external hidden unnamed_addr constant [23 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [69 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [67 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [67 x i8], align 1
@.str.33 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.34 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.35 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.36 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.37 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.38 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.39 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [71 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [77 x i8], align 1
@.str.50 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [58 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @main(i32 noundef %0, ptr noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca [8 x { float, float }], align 16
  %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 [8 x { float, float }], align 16
  %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
  %32 = alloca { float, float }, align 4
  %33 = alloca { float, float }, align 4
  %34 = alloca [12 x float], align 16
  %35 = alloca [12 x float], align 16
  %36 = alloca { float, float }, align 4
  %37 = alloca ptr, align 8
  %38 = alloca [8 x { float, float }], align 16
  %39 = alloca { float, float }, align 4
  %40 = alloca { float, float }, align 4
  %41 = alloca { float, float }, align 4
  %42 = alloca { float, float }, align 4
  %43 = alloca { float, float }, align 4
  %44 = alloca { float, float }, align 4
  %45 = alloca { float, float }, align 4
  %46 = alloca { float, float }, align 4
  %47 = alloca { float, float }, align 4
  %48 = alloca { float, float }, align 4
  %49 = alloca { float, float }, align 4
  %50 = alloca { float, float }, align 4
  %51 = alloca [8 x { float, float }], align 16
  %52 = alloca { float, float }, align 4
  %53 = alloca { float, float }, align 4
  %54 = alloca { float, float }, align 4
  %55 = alloca { float, float }, align 4
  %56 = alloca { float, float }, align 4
  %57 = alloca { float, float }, align 4
  %58 = alloca { float, float }, align 4
  %59 = alloca { float, float }, align 4
  %60 = alloca { float, float }, align 4
  %61 = alloca { float, float }, align 4
  %62 = alloca { float, float }, align 4
  %63 = alloca { float, float }, align 4
  %64 = alloca { float, float }, align 4
  %65 = alloca [12 x float], align 16
  %66 = alloca [12 x float], align 16
  %67 = alloca { float, float }, align 4
  %68 = alloca ptr, align 8
  %69 = alloca ptr, align 8
  %70 = alloca i64, align 8
  %71 = alloca i64, align 8
  %72 = alloca i64, align 8
  %73 = alloca float, align 4
  %74 = alloca float, align 4
  %75 = alloca float, align 4
  %76 = alloca i32, align 4
  %77 = alloca float, align 4
  %78 = alloca { float, float }, align 4
  %79 = alloca { float, float }, align 4
  %80 = alloca ptr, align 8
  %81 = alloca i32, align 4
  %82 = alloca i64, align 8
  %83 = alloca i64, align 8
  %84 = alloca i64, align 8
  %85 = alloca i64, align 8
  %86 = alloca float, align 4
  store i32 0, ptr %3, align 4
  store i32 %0, ptr %4, align 4, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  store i32 801, ptr %6, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %7) #6
  %87 = getelementptr inbounds { float, float }, ptr %7, i32 0, i32 0
  %88 = getelementptr inbounds { float, float }, ptr %7, i32 0, i32 1
  store float 0xBFF2D03C80000000, ptr %87, align 8
  store float 0.000000e+00, ptr %88, align 4
  %89 = getelementptr inbounds { float, float }, ptr %7, i64 1
  %90 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %91 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float -0.000000e+00, ptr %90, align 4
  store float 0xC001781080000000, ptr %91, align 4
  %92 = load <2 x float>, ptr %8, align 4
  %93 = call <2 x float> @cexpf(<2 x float> noundef %92) #6
  store <2 x float> %93, ptr %9, align 4
  %94 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %95 = load float, ptr %94, align 4
  %96 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %97 = load float, ptr %96, align 4
  %98 = fpext float %95 to double
  %99 = fpext float %97 to double
  %100 = fmul double 3.371020e+00, %98
  %101 = fmul double 3.371020e+00, %99
  %102 = fptrunc double %100 to float
  %103 = fptrunc double %101 to float
  %104 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 0
  %105 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 1
  store float %102, ptr %104, align 8
  store float %103, ptr %105, align 4
  %106 = getelementptr inbounds { float, float }, ptr %7, i64 2
  %107 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %108 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  store float 0.000000e+00, ptr %107, align 4
  store float 0x4001781080000000, ptr %108, align 4
  %109 = load <2 x float>, ptr %10, align 4
  %110 = call <2 x float> @cexpf(<2 x float> noundef %109) #6
  store <2 x float> %110, ptr %11, align 4
  %111 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %112 = load float, ptr %111, align 4
  %113 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %114 = load float, ptr %113, align 4
  %115 = fpext float %112 to double
  %116 = fpext float %114 to double
  %117 = fmul double 3.371020e+00, %115
  %118 = fmul double 3.371020e+00, %116
  %119 = fptrunc double %117 to float
  %120 = fptrunc double %118 to float
  %121 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 0
  %122 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 1
  store float %119, ptr %121, align 8
  store float %120, ptr %122, align 4
  %123 = getelementptr inbounds { float, float }, ptr %7, i64 3
  %124 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %125 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  store float -0.000000e+00, ptr %124, align 4
  store float 0xBFF69C0360000000, ptr %125, align 4
  %126 = load <2 x float>, ptr %12, align 4
  %127 = call <2 x float> @cexpf(<2 x float> noundef %126) #6
  store <2 x float> %127, ptr %13, align 4
  %128 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 0
  %129 = load float, ptr %128, align 4
  %130 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 1
  %131 = load float, ptr %130, align 4
  %132 = fpext float %129 to double
  %133 = fpext float %131 to double
  %134 = fmul double 4.549710e+00, %132
  %135 = fmul double 4.549710e+00, %133
  %136 = fptrunc double %134 to float
  %137 = fptrunc double %135 to float
  %138 = getelementptr inbounds { float, float }, ptr %123, i32 0, i32 0
  %139 = getelementptr inbounds { float, float }, ptr %123, i32 0, i32 1
  store float %136, ptr %138, align 8
  store float %137, ptr %139, align 4
  %140 = getelementptr inbounds { float, float }, ptr %7, i64 4
  %141 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %142 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  store float 0.000000e+00, ptr %141, align 4
  store float 0x3FF69C0360000000, ptr %142, align 4
  %143 = load <2 x float>, ptr %14, align 4
  %144 = call <2 x float> @cexpf(<2 x float> noundef %143) #6
  store <2 x float> %144, ptr %15, align 4
  %145 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %146 = load float, ptr %145, align 4
  %147 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  %148 = load float, ptr %147, align 4
  %149 = fpext float %146 to double
  %150 = fpext float %148 to double
  %151 = fmul double 4.549710e+00, %149
  %152 = fmul double 4.549710e+00, %150
  %153 = fptrunc double %151 to float
  %154 = fptrunc double %152 to float
  %155 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 0
  %156 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 1
  store float %153, ptr %155, align 8
  store float %154, ptr %156, align 4
  %157 = getelementptr inbounds { float, float }, ptr %7, i64 5
  %158 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 0
  %159 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 1
  store float -0.000000e+00, ptr %158, align 4
  store float 0xBFE6647580000000, ptr %159, align 4
  %160 = load <2 x float>, ptr %16, align 4
  %161 = call <2 x float> @cexpf(<2 x float> noundef %160) #6
  store <2 x float> %161, ptr %17, align 4
  %162 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 0
  %163 = load float, ptr %162, align 4
  %164 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 1
  %165 = load float, ptr %164, align 4
  %166 = fpext float %163 to double
  %167 = fpext float %165 to double
  %168 = fmul double 0x4014E55757D5A9EB, %166
  %169 = fmul double 0x4014E55757D5A9EB, %167
  %170 = fptrunc double %168 to float
  %171 = fptrunc double %169 to float
  %172 = getelementptr inbounds { float, float }, ptr %157, i32 0, i32 0
  %173 = getelementptr inbounds { float, float }, ptr %157, i32 0, i32 1
  store float %170, ptr %172, align 8
  store float %171, ptr %173, align 4
  %174 = getelementptr inbounds { float, float }, ptr %7, i64 6
  %175 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 0
  %176 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 1
  store float 0.000000e+00, ptr %175, align 4
  store float 0x3FE6647580000000, ptr %176, align 4
  %177 = load <2 x float>, ptr %18, align 4
  %178 = call <2 x float> @cexpf(<2 x float> noundef %177) #6
  store <2 x float> %178, ptr %19, align 4
  %179 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %180 = load float, ptr %179, align 4
  %181 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  %182 = load float, ptr %181, align 4
  %183 = fpext float %180 to double
  %184 = fpext float %182 to double
  %185 = fmul double 0x4014E55757D5A9EB, %183
  %186 = fmul double 0x4014E55757D5A9EB, %184
  %187 = fptrunc double %185 to float
  %188 = fptrunc double %186 to float
  %189 = getelementptr inbounds { float, float }, ptr %174, i32 0, i32 0
  %190 = getelementptr inbounds { float, float }, ptr %174, i32 0, i32 1
  store float %187, ptr %189, align 8
  store float %188, ptr %190, align 4
  %191 = getelementptr inbounds { float, float }, ptr %7, i64 7
  %192 = getelementptr inbounds { float, float }, ptr %191, i32 0, i32 0
  %193 = getelementptr inbounds { float, float }, ptr %191, i32 0, i32 1
  store float 0x4015C664A0000000, ptr %192, align 8
  store float 0.000000e+00, ptr %193, align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr %20) #6
  %194 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 0
  %195 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 1
  store float 0xBFE293A600000000, ptr %194, align 8
  store float 0.000000e+00, ptr %195, align 4
  %196 = getelementptr inbounds { float, float }, ptr %20, i64 1
  %197 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 0
  %198 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 1
  store float -0.000000e+00, ptr %197, align 4
  store float 0xBFFFDCA160000000, ptr %198, align 4
  %199 = load <2 x float>, ptr %21, align 4
  %200 = call <2 x float> @cexpf(<2 x float> noundef %199) #6
  store <2 x float> %200, ptr %22, align 4
  %201 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 0
  %202 = load float, ptr %201, align 4
  %203 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 1
  %204 = load float, ptr %203, align 4
  %205 = fmul float 0x3FCDD99100000000, %202
  %206 = fmul float 0x3FCDD99100000000, %204
  %207 = getelementptr inbounds { float, float }, ptr %196, i32 0, i32 0
  %208 = getelementptr inbounds { float, float }, ptr %196, i32 0, i32 1
  store float %205, ptr %207, align 8
  store float %206, ptr %208, align 4
  %209 = getelementptr inbounds { float, float }, ptr %20, i64 2
  %210 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %211 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  store float 0.000000e+00, ptr %210, align 4
  store float 0x3FFFDCA160000000, ptr %211, align 4
  %212 = load <2 x float>, ptr %23, align 4
  %213 = call <2 x float> @cexpf(<2 x float> noundef %212) #6
  store <2 x float> %213, ptr %24, align 4
  %214 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 0
  %215 = load float, ptr %214, align 4
  %216 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 1
  %217 = load float, ptr %216, align 4
  %218 = fmul float 0x3FCDD99100000000, %215
  %219 = fmul float 0x3FCDD99100000000, %217
  %220 = getelementptr inbounds { float, float }, ptr %209, i32 0, i32 0
  %221 = getelementptr inbounds { float, float }, ptr %209, i32 0, i32 1
  store float %218, ptr %220, align 8
  store float %219, ptr %221, align 4
  %222 = getelementptr inbounds { float, float }, ptr %20, i64 3
  %223 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 0
  %224 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 1
  store float -0.000000e+00, ptr %223, align 4
  store float 0xBFF28689A0000000, ptr %224, align 4
  %225 = load <2 x float>, ptr %25, align 4
  %226 = call <2 x float> @cexpf(<2 x float> noundef %225) #6
  store <2 x float> %226, ptr %26, align 4
  %227 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %228 = load float, ptr %227, align 4
  %229 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  %230 = load float, ptr %229, align 4
  %231 = fmul float 0x3FC73A96E0000000, %228
  %232 = fmul float 0x3FC73A96E0000000, %230
  %233 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 0
  %234 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 1
  store float %231, ptr %233, align 8
  store float %232, ptr %234, align 4
  %235 = getelementptr inbounds { float, float }, ptr %20, i64 4
  %236 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %237 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  store float 0.000000e+00, ptr %236, align 4
  store float 0x3FF28689A0000000, ptr %237, align 4
  %238 = load <2 x float>, ptr %27, align 4
  %239 = call <2 x float> @cexpf(<2 x float> noundef %238) #6
  store <2 x float> %239, ptr %28, align 4
  %240 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 0
  %241 = load float, ptr %240, align 4
  %242 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 1
  %243 = load float, ptr %242, align 4
  %244 = fmul float 0x3FC73A96E0000000, %241
  %245 = fmul float 0x3FC73A96E0000000, %243
  %246 = getelementptr inbounds { float, float }, ptr %235, i32 0, i32 0
  %247 = getelementptr inbounds { float, float }, ptr %235, i32 0, i32 1
  store float %244, ptr %246, align 8
  store float %245, ptr %247, align 4
  %248 = getelementptr inbounds { float, float }, ptr %20, i64 5
  %249 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %250 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  store float -0.000000e+00, ptr %249, align 4
  store float 0xBFD8751720000000, ptr %250, align 4
  %251 = load <2 x float>, ptr %29, align 4
  %252 = call <2 x float> @cexpf(<2 x float> noundef %251) #6
  store <2 x float> %252, ptr %30, align 4
  %253 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 0
  %254 = load float, ptr %253, align 4
  %255 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 1
  %256 = load float, ptr %255, align 4
  %257 = fmul float 0x3FC502B9E0000000, %254
  %258 = fmul float 0x3FC502B9E0000000, %256
  %259 = getelementptr inbounds { float, float }, ptr %248, i32 0, i32 0
  %260 = getelementptr inbounds { float, float }, ptr %248, i32 0, i32 1
  store float %257, ptr %259, align 8
  store float %258, ptr %260, align 4
  %261 = getelementptr inbounds { float, float }, ptr %20, i64 6
  %262 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 0
  %263 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 1
  store float 0.000000e+00, ptr %262, align 4
  store float 0x3FD8751720000000, ptr %263, align 4
  %264 = load <2 x float>, ptr %31, align 4
  %265 = call <2 x float> @cexpf(<2 x float> noundef %264) #6
  store <2 x float> %265, ptr %32, align 4
  %266 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %267 = load float, ptr %266, align 4
  %268 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  %269 = load float, ptr %268, align 4
  %270 = fmul float 0x3FC502B9E0000000, %267
  %271 = fmul float 0x3FC502B9E0000000, %269
  %272 = getelementptr inbounds { float, float }, ptr %261, i32 0, i32 0
  %273 = getelementptr inbounds { float, float }, ptr %261, i32 0, i32 1
  store float %270, ptr %272, align 8
  store float %271, ptr %273, align 4
  %274 = getelementptr inbounds { float, float }, ptr %20, i64 7
  %275 = getelementptr inbounds { float, float }, ptr %274, i32 0, i32 0
  %276 = getelementptr inbounds { float, float }, ptr %274, i32 0, i32 1
  store float 1.000000e+00, ptr %275, align 8
  store float 0.000000e+00, ptr %276, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %277 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %278 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  store float 0xBEF3D72880000000, ptr %277, align 4
  store float 0.000000e+00, ptr %278, align 4
  call void @llvm.lifetime.start.p0(i64 48, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 48, ptr %35) #6
  %279 = getelementptr inbounds [8 x { float, float }], ptr %7, i64 0, i64 0
  %280 = getelementptr inbounds [8 x { float, float }], ptr %20, i64 0, i64 0
  %281 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %282 = load float, ptr %281, align 4
  %283 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  %284 = load float, ptr %283, align 4
  %285 = getelementptr inbounds [12 x float], ptr %34, i64 0, i64 0
  %286 = getelementptr inbounds [12 x float], ptr %35, i64 0, i64 0
  %287 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %288 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  store float %282, ptr %287, align 4
  store float %284, ptr %288, align 4
  %289 = load <2 x float>, ptr %36, align 4
  %290 = call i32 @iirdes_dzpk2sosf(ptr noundef %279, ptr noundef %280, i32 noundef 8, <2 x float> noundef %289, ptr noundef %285, ptr noundef %286)
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %291 = getelementptr inbounds [12 x float], ptr %34, i64 0, i64 0
  %292 = getelementptr inbounds [12 x float], ptr %35, i64 0, i64 0
  %293 = call ptr @iirfilt_crcf_create_sos(ptr noundef %291, ptr noundef %292, i32 noundef 4)
  store ptr %293, ptr %37, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 64, ptr %38) #6
  %294 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 0
  %295 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 1
  store float 0xBFFB3DBF40000000, ptr %294, align 8
  store float 0.000000e+00, ptr %295, align 4
  %296 = getelementptr inbounds { float, float }, ptr %38, i64 1
  %297 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 0
  %298 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 1
  store float -0.000000e+00, ptr %297, align 4
  store float 0xC00EEA05C0000000, ptr %298, align 4
  %299 = load <2 x float>, ptr %39, align 4
  %300 = call <2 x float> @cexpf(<2 x float> noundef %299) #6
  store <2 x float> %300, ptr %40, align 4
  %301 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 0
  %302 = load float, ptr %301, align 4
  %303 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 1
  %304 = load float, ptr %303, align 4
  %305 = fmul float 0x4017827140000000, %302
  %306 = fmul float 0x4017827140000000, %304
  %307 = getelementptr inbounds { float, float }, ptr %296, i32 0, i32 0
  %308 = getelementptr inbounds { float, float }, ptr %296, i32 0, i32 1
  store float %305, ptr %307, align 8
  store float %306, ptr %308, align 4
  %309 = getelementptr inbounds { float, float }, ptr %38, i64 2
  %310 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 0
  %311 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 1
  store float 0.000000e+00, ptr %310, align 4
  store float 0x400EEA05C0000000, ptr %311, align 4
  %312 = load <2 x float>, ptr %41, align 4
  %313 = call <2 x float> @cexpf(<2 x float> noundef %312) #6
  store <2 x float> %313, ptr %42, align 4
  %314 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 0
  %315 = load float, ptr %314, align 4
  %316 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 1
  %317 = load float, ptr %316, align 4
  %318 = fmul float 0x4017827140000000, %315
  %319 = fmul float 0x4017827140000000, %317
  %320 = getelementptr inbounds { float, float }, ptr %309, i32 0, i32 0
  %321 = getelementptr inbounds { float, float }, ptr %309, i32 0, i32 1
  store float %318, ptr %320, align 8
  store float %319, ptr %321, align 4
  %322 = getelementptr inbounds { float, float }, ptr %38, i64 3
  %323 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 0
  %324 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 1
  store float -0.000000e+00, ptr %323, align 4
  store float 0xC004308820000000, ptr %324, align 4
  %325 = load <2 x float>, ptr %43, align 4
  %326 = call <2 x float> @cexpf(<2 x float> noundef %325) #6
  store <2 x float> %326, ptr %44, align 4
  %327 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 0
  %328 = load float, ptr %327, align 4
  %329 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 1
  %330 = load float, ptr %329, align 4
  %331 = fmul float 0x4010CA28C0000000, %328
  %332 = fmul float 0x4010CA28C0000000, %330
  %333 = getelementptr inbounds { float, float }, ptr %322, i32 0, i32 0
  %334 = getelementptr inbounds { float, float }, ptr %322, i32 0, i32 1
  store float %331, ptr %333, align 8
  store float %332, ptr %334, align 4
  %335 = getelementptr inbounds { float, float }, ptr %38, i64 4
  %336 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 0
  %337 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 1
  store float 0.000000e+00, ptr %336, align 4
  store float 0x4004308820000000, ptr %337, align 4
  %338 = load <2 x float>, ptr %45, align 4
  %339 = call <2 x float> @cexpf(<2 x float> noundef %338) #6
  store <2 x float> %339, ptr %46, align 4
  %340 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 0
  %341 = load float, ptr %340, align 4
  %342 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 1
  %343 = load float, ptr %342, align 4
  %344 = fmul float 0x4010CA28C0000000, %341
  %345 = fmul float 0x4010CA28C0000000, %343
  %346 = getelementptr inbounds { float, float }, ptr %335, i32 0, i32 0
  %347 = getelementptr inbounds { float, float }, ptr %335, i32 0, i32 1
  store float %344, ptr %346, align 8
  store float %345, ptr %347, align 4
  %348 = getelementptr inbounds { float, float }, ptr %38, i64 5
  %349 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 0
  %350 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 1
  store float -0.000000e+00, ptr %349, align 4
  store float 0xBFF2ADBCA0000000, ptr %350, align 4
  %351 = load <2 x float>, ptr %47, align 4
  %352 = call <2 x float> @cexpf(<2 x float> noundef %351) #6
  store <2 x float> %352, ptr %48, align 4
  %353 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 0
  %354 = load float, ptr %353, align 4
  %355 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 1
  %356 = load float, ptr %355, align 4
  %357 = fmul float 0x401566B0E0000000, %354
  %358 = fmul float 0x401566B0E0000000, %356
  %359 = getelementptr inbounds { float, float }, ptr %348, i32 0, i32 0
  %360 = getelementptr inbounds { float, float }, ptr %348, i32 0, i32 1
  store float %357, ptr %359, align 8
  store float %358, ptr %360, align 4
  %361 = getelementptr inbounds { float, float }, ptr %38, i64 6
  %362 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 0
  %363 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 1
  store float 0.000000e+00, ptr %362, align 4
  store float 0x3FF2ADBCA0000000, ptr %363, align 4
  %364 = load <2 x float>, ptr %49, align 4
  %365 = call <2 x float> @cexpf(<2 x float> noundef %364) #6
  store <2 x float> %365, ptr %50, align 4
  %366 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 0
  %367 = load float, ptr %366, align 4
  %368 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 1
  %369 = load float, ptr %368, align 4
  %370 = fmul float 0x401566B0E0000000, %367
  %371 = fmul float 0x401566B0E0000000, %369
  %372 = getelementptr inbounds { float, float }, ptr %361, i32 0, i32 0
  %373 = getelementptr inbounds { float, float }, ptr %361, i32 0, i32 1
  store float %370, ptr %372, align 8
  store float %371, ptr %373, align 4
  %374 = getelementptr inbounds { float, float }, ptr %38, i64 7
  %375 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 0
  %376 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 1
  store float 1.000000e+00, ptr %375, align 8
  store float 0.000000e+00, ptr %376, align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr %51) #6
  %377 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 0
  %378 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 1
  store float 0xBFEB204E60000000, ptr %377, align 8
  store float 0.000000e+00, ptr %378, align 4
  %379 = getelementptr inbounds { float, float }, ptr %51, i64 1
  %380 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 0
  %381 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 1
  store float -0.000000e+00, ptr %380, align 4
  store float 0xC001869640000000, ptr %381, align 4
  %382 = load <2 x float>, ptr %52, align 4
  %383 = call <2 x float> @cexpf(<2 x float> noundef %382) #6
  store <2 x float> %383, ptr %53, align 4
  %384 = getelementptr inbounds { float, float }, ptr %53, i32 0, i32 0
  %385 = load float, ptr %384, align 4
  %386 = getelementptr inbounds { float, float }, ptr %53, i32 0, i32 1
  %387 = load float, ptr %386, align 4
  %388 = fmul float 0x3FD3241880000000, %385
  %389 = fmul float 0x3FD3241880000000, %387
  %390 = getelementptr inbounds { float, float }, ptr %379, i32 0, i32 0
  %391 = getelementptr inbounds { float, float }, ptr %379, i32 0, i32 1
  store float %388, ptr %390, align 8
  store float %389, ptr %391, align 4
  %392 = getelementptr inbounds { float, float }, ptr %51, i64 2
  %393 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 0
  %394 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 1
  store float 0.000000e+00, ptr %393, align 4
  store float 0x4001869640000000, ptr %394, align 4
  %395 = load <2 x float>, ptr %54, align 4
  %396 = call <2 x float> @cexpf(<2 x float> noundef %395) #6
  store <2 x float> %396, ptr %55, align 4
  %397 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 0
  %398 = load float, ptr %397, align 4
  %399 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 1
  %400 = load float, ptr %399, align 4
  %401 = fmul float 0x3FD3241880000000, %398
  %402 = fmul float 0x3FD3241880000000, %400
  %403 = getelementptr inbounds { float, float }, ptr %392, i32 0, i32 0
  %404 = getelementptr inbounds { float, float }, ptr %392, i32 0, i32 1
  store float %401, ptr %403, align 8
  store float %402, ptr %404, align 4
  %405 = getelementptr inbounds { float, float }, ptr %51, i64 3
  %406 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 0
  %407 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 1
  store float -0.000000e+00, ptr %406, align 4
  store float 0xBFF6C3FDA0000000, ptr %407, align 4
  %408 = load <2 x float>, ptr %56, align 4
  %409 = call <2 x float> @cexpf(<2 x float> noundef %408) #6
  store <2 x float> %409, ptr %57, align 4
  %410 = getelementptr inbounds { float, float }, ptr %57, i32 0, i32 0
  %411 = load float, ptr %410, align 4
  %412 = getelementptr inbounds { float, float }, ptr %57, i32 0, i32 1
  %413 = load float, ptr %412, align 4
  %414 = fmul float 0x3FCC933780000000, %411
  %415 = fmul float 0x3FCC933780000000, %413
  %416 = getelementptr inbounds { float, float }, ptr %405, i32 0, i32 0
  %417 = getelementptr inbounds { float, float }, ptr %405, i32 0, i32 1
  store float %414, ptr %416, align 8
  store float %415, ptr %417, align 4
  %418 = getelementptr inbounds { float, float }, ptr %51, i64 4
  %419 = getelementptr inbounds { float, float }, ptr %58, i32 0, i32 0
  %420 = getelementptr inbounds { float, float }, ptr %58, i32 0, i32 1
  store float 0.000000e+00, ptr %419, align 4
  store float 0x3FF6C3FDA0000000, ptr %420, align 4
  %421 = load <2 x float>, ptr %58, align 4
  %422 = call <2 x float> @cexpf(<2 x float> noundef %421) #6
  store <2 x float> %422, ptr %59, align 4
  %423 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 0
  %424 = load float, ptr %423, align 4
  %425 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 1
  %426 = load float, ptr %425, align 4
  %427 = fmul float 0x3FCC933780000000, %424
  %428 = fmul float 0x3FCC933780000000, %426
  %429 = getelementptr inbounds { float, float }, ptr %418, i32 0, i32 0
  %430 = getelementptr inbounds { float, float }, ptr %418, i32 0, i32 1
  store float %427, ptr %429, align 8
  store float %428, ptr %430, align 4
  %431 = getelementptr inbounds { float, float }, ptr %51, i64 5
  %432 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 0
  %433 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 1
  store float -0.000000e+00, ptr %432, align 4
  store float 0xBFE6A0BE00000000, ptr %433, align 4
  %434 = load <2 x float>, ptr %60, align 4
  %435 = call <2 x float> @cexpf(<2 x float> noundef %434) #6
  store <2 x float> %435, ptr %61, align 4
  %436 = getelementptr inbounds { float, float }, ptr %61, i32 0, i32 0
  %437 = load float, ptr %436, align 4
  %438 = getelementptr inbounds { float, float }, ptr %61, i32 0, i32 1
  %439 = load float, ptr %438, align 4
  %440 = fmul float 0x3FC9122B80000000, %437
  %441 = fmul float 0x3FC9122B80000000, %439
  %442 = getelementptr inbounds { float, float }, ptr %431, i32 0, i32 0
  %443 = getelementptr inbounds { float, float }, ptr %431, i32 0, i32 1
  store float %440, ptr %442, align 8
  store float %441, ptr %443, align 4
  %444 = getelementptr inbounds { float, float }, ptr %51, i64 6
  %445 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 0
  %446 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 1
  store float 0.000000e+00, ptr %445, align 4
  store float 0x3FE6A0BE00000000, ptr %446, align 4
  %447 = load <2 x float>, ptr %62, align 4
  %448 = call <2 x float> @cexpf(<2 x float> noundef %447) #6
  store <2 x float> %448, ptr %63, align 4
  %449 = getelementptr inbounds { float, float }, ptr %63, i32 0, i32 0
  %450 = load float, ptr %449, align 4
  %451 = getelementptr inbounds { float, float }, ptr %63, i32 0, i32 1
  %452 = load float, ptr %451, align 4
  %453 = fmul float 0x3FC9122B80000000, %450
  %454 = fmul float 0x3FC9122B80000000, %452
  %455 = getelementptr inbounds { float, float }, ptr %444, i32 0, i32 0
  %456 = getelementptr inbounds { float, float }, ptr %444, i32 0, i32 1
  store float %453, ptr %455, align 8
  store float %454, ptr %456, align 4
  %457 = getelementptr inbounds { float, float }, ptr %51, i64 7
  %458 = getelementptr inbounds { float, float }, ptr %457, i32 0, i32 0
  %459 = getelementptr inbounds { float, float }, ptr %457, i32 0, i32 1
  store float 0x3FC8245540000000, ptr %458, align 8
  store float 0.000000e+00, ptr %459, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %64) #6
  %460 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 0
  %461 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 1
  store float 0x3EF5EB9FC0000000, ptr %460, align 4
  store float 0.000000e+00, ptr %461, align 4
  call void @llvm.lifetime.start.p0(i64 48, ptr %65) #6
  call void @llvm.lifetime.start.p0(i64 48, ptr %66) #6
  %462 = getelementptr inbounds [8 x { float, float }], ptr %38, i64 0, i64 0
  %463 = getelementptr inbounds [8 x { float, float }], ptr %51, i64 0, i64 0
  %464 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 0
  %465 = load float, ptr %464, align 4
  %466 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 1
  %467 = load float, ptr %466, align 4
  %468 = getelementptr inbounds [12 x float], ptr %65, i64 0, i64 0
  %469 = getelementptr inbounds [12 x float], ptr %66, i64 0, i64 0
  %470 = getelementptr inbounds { float, float }, ptr %67, i32 0, i32 0
  %471 = getelementptr inbounds { float, float }, ptr %67, i32 0, i32 1
  store float %465, ptr %470, align 4
  store float %467, ptr %471, align 4
  %472 = load <2 x float>, ptr %67, align 4
  %473 = call i32 @iirdes_dzpk2sosf(ptr noundef %462, ptr noundef %463, i32 noundef 8, <2 x float> noundef %472, ptr noundef %468, ptr noundef %469)
  call void @llvm.lifetime.start.p0(i64 8, ptr %68) #6
  %474 = getelementptr inbounds [12 x float], ptr %65, i64 0, i64 0
  %475 = getelementptr inbounds [12 x float], ptr %66, i64 0, i64 0
  %476 = call ptr @iirfilt_crcf_create_sos(ptr noundef %474, ptr noundef %475, i32 noundef 4)
  store ptr %476, ptr %68, align 8, !tbaa !9
  %477 = load i32, ptr %6, align 4, !tbaa !5
  %478 = zext i32 %477 to i64
  %479 = call ptr @llvm.stacksave.p0()
  store ptr %479, ptr %69, align 8
  %480 = alloca { float, float }, i64 %478, align 16
  store i64 %478, ptr %70, align 8
  %481 = load i32, ptr %6, align 4, !tbaa !5
  %482 = zext i32 %481 to i64
  %483 = alloca { float, float }, i64 %482, align 16
  store i64 %482, ptr %71, align 8
  %484 = load i32, ptr %6, align 4, !tbaa !5
  %485 = zext i32 %484 to i64
  %486 = alloca { float, float }, i64 %485, align 16
  store i64 %485, ptr %72, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #6
  store float 0.000000e+00, ptr %73, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #6
  store float 1.000000e+00, ptr %74, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #6
  %487 = load float, ptr %74, align 4, !tbaa !11
  %488 = load float, ptr %73, align 4, !tbaa !11
  %489 = fsub float %487, %488
  %490 = load i32, ptr %6, align 4, !tbaa !5
  %491 = sub i32 %490, 1
  %492 = uitofp i32 %491 to float
  %493 = fdiv float %489, %492
  store float %493, ptr %75, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #6
  store i32 0, ptr %76, align 4, !tbaa !5
  br label %494

494:                                              ; preds = %578, %2
  %495 = load i32, ptr %76, align 4, !tbaa !5
  %496 = load i32, ptr %6, align 4, !tbaa !5
  %497 = icmp ult i32 %495, %496
  br i1 %497, label %498, label %581

498:                                              ; preds = %494
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #6
  %499 = load float, ptr %73, align 4, !tbaa !11
  %500 = load float, ptr %75, align 4, !tbaa !11
  %501 = load i32, ptr %76, align 4, !tbaa !5
  %502 = uitofp i32 %501 to float
  %503 = call float @llvm.fmuladd.f32(float %500, float %502, float %499)
  store float %503, ptr %77, align 4, !tbaa !11
  %504 = load float, ptr %77, align 4, !tbaa !11
  %505 = fpext float %504 to double
  %506 = call double @llvm.fmuladd.f64(double 0x4039C2D4CFF9149E, double %505, double 0.000000e+00)
  %507 = fptrunc double %506 to float
  %508 = call float @cosf(float noundef %507) #6
  %509 = fpext float %508 to double
  %510 = load float, ptr %77, align 4, !tbaa !11
  %511 = fpext float %510 to double
  %512 = call double @llvm.fmuladd.f64(double 0x4045AD4F2BE133B2, double %511, double 0x3FECCCCCC0000000)
  %513 = fptrunc double %512 to float
  %514 = call float @cosf(float noundef %513) #6
  %515 = fpext float %514 to double
  %516 = fmul double 4.000000e-01, %515
  %517 = call double @llvm.fmuladd.f64(double 2.000000e-01, double %509, double %516)
  %518 = load float, ptr %77, align 4, !tbaa !11
  %519 = fpext float %518 to double
  %520 = call double @llvm.fmuladd.f64(double 0x404E7933EFC5DD13, double %519, double 0x3FC99999A0000000)
  %521 = fptrunc double %520 to float
  %522 = call float @cosf(float noundef %521) #6
  %523 = fpext float %522 to double
  %524 = call double @llvm.fmuladd.f64(double 0x3FE6666666666666, double %523, double %517)
  %525 = load float, ptr %77, align 4, !tbaa !11
  %526 = fpext float %525 to double
  %527 = fmul double 0x403921FB54442D18, %526
  %528 = fptrunc double %527 to float
  %529 = call float @cosf(float noundef %528) #6
  %530 = fmul float 0.000000e+00, %529
  %531 = fmul float 1.000000e+00, %529
  %532 = fpext float %530 to double
  %533 = fpext float %531 to double
  %534 = fadd double %524, %532
  %535 = fptrunc double %534 to float
  %536 = fptrunc double %533 to float
  %537 = load i32, ptr %76, align 4, !tbaa !5
  %538 = zext i32 %537 to i64
  %539 = getelementptr inbounds { float, float }, ptr %480, i64 %538
  %540 = getelementptr inbounds { float, float }, ptr %539, i32 0, i32 0
  %541 = getelementptr inbounds { float, float }, ptr %539, i32 0, i32 1
  store float %535, ptr %540, align 8
  store float %536, ptr %541, align 4
  %542 = load ptr, ptr %37, align 8, !tbaa !9
  %543 = load i32, ptr %76, align 4, !tbaa !5
  %544 = zext i32 %543 to i64
  %545 = getelementptr inbounds { float, float }, ptr %480, i64 %544
  %546 = getelementptr inbounds { float, float }, ptr %545, i32 0, i32 0
  %547 = load float, ptr %546, align 8
  %548 = getelementptr inbounds { float, float }, ptr %545, i32 0, i32 1
  %549 = load float, ptr %548, align 4
  %550 = load float, ptr %75, align 4, !tbaa !11
  %551 = fmul float %547, %550
  %552 = fmul float %549, %550
  %553 = load i32, ptr %76, align 4, !tbaa !5
  %554 = zext i32 %553 to i64
  %555 = getelementptr inbounds { float, float }, ptr %483, i64 %554
  %556 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 0
  %557 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 1
  store float %551, ptr %556, align 4
  store float %552, ptr %557, align 4
  %558 = load <2 x float>, ptr %78, align 4
  %559 = call i32 @iirfilt_crcf_execute(ptr noundef %542, <2 x float> noundef %558, ptr noundef %555)
  %560 = load ptr, ptr %68, align 8, !tbaa !9
  %561 = load i32, ptr %76, align 4, !tbaa !5
  %562 = zext i32 %561 to i64
  %563 = getelementptr inbounds { float, float }, ptr %483, i64 %562
  %564 = getelementptr inbounds { float, float }, ptr %563, i32 0, i32 0
  %565 = load float, ptr %564, align 8
  %566 = getelementptr inbounds { float, float }, ptr %563, i32 0, i32 1
  %567 = load float, ptr %566, align 4
  %568 = load float, ptr %75, align 4, !tbaa !11
  %569 = fdiv float %565, %568
  %570 = fdiv float %567, %568
  %571 = load i32, ptr %76, align 4, !tbaa !5
  %572 = zext i32 %571 to i64
  %573 = getelementptr inbounds { float, float }, ptr %486, i64 %572
  %574 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 0
  %575 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 1
  store float %569, ptr %574, align 4
  store float %570, ptr %575, align 4
  %576 = load <2 x float>, ptr %79, align 4
  %577 = call i32 @iirfilt_crcf_execute(ptr noundef %560, <2 x float> noundef %576, ptr noundef %573)
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #6
  br label %578

578:                                              ; preds = %498
  %579 = load i32, ptr %76, align 4, !tbaa !5
  %580 = add i32 %579, 1
  store i32 %580, ptr %76, align 4, !tbaa !5
  br label %494, !llvm.loop !13

581:                                              ; preds = %494
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #6
  %582 = call noalias ptr @fopen(ptr noundef @.str, ptr noundef @.str.1)
  store ptr %582, ptr %80, align 8, !tbaa !9
  %583 = load ptr, ptr %80, align 8, !tbaa !9
  %584 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %583, ptr noundef @.str.2, ptr noundef @.str) #6
  %585 = load ptr, ptr %80, align 8, !tbaa !9
  %586 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %585, ptr noundef @.str.3) #6
  %587 = load ptr, ptr %80, align 8, !tbaa !9
  %588 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %587, ptr noundef @.str.4) #6
  %589 = load ptr, ptr %80, align 8, !tbaa !9
  %590 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %589, ptr noundef @.str.5) #6
  %591 = load ptr, ptr %80, align 8, !tbaa !9
  %592 = load i32, ptr %6, align 4, !tbaa !5
  %593 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %591, ptr noundef @.str.6, i32 noundef %592) #6
  %594 = load ptr, ptr %80, align 8, !tbaa !9
  %595 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %594, ptr noundef @.str.7) #6
  %596 = load ptr, ptr %80, align 8, !tbaa !9
  %597 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %596, ptr noundef @.str.8) #6
  %598 = load ptr, ptr %80, align 8, !tbaa !9
  %599 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %598, ptr noundef @.str.9) #6
  store i32 0, ptr %76, align 4, !tbaa !5
  br label %600

600:                                              ; preds = %667, %581
  %601 = load i32, ptr %76, align 4, !tbaa !5
  %602 = load i32, ptr %6, align 4, !tbaa !5
  %603 = icmp ult i32 %601, %602
  br i1 %603, label %604, label %670

604:                                              ; preds = %600
  %605 = load ptr, ptr %80, align 8, !tbaa !9
  %606 = load i32, ptr %76, align 4, !tbaa !5
  %607 = add i32 %606, 1
  %608 = load i32, ptr %76, align 4, !tbaa !5
  %609 = zext i32 %608 to i64
  %610 = getelementptr inbounds { float, float }, ptr %480, i64 %609
  %611 = getelementptr inbounds { float, float }, ptr %610, i32 0, i32 0
  %612 = load float, ptr %611, align 8
  %613 = getelementptr inbounds { float, float }, ptr %610, i32 0, i32 1
  %614 = load float, ptr %613, align 4
  %615 = fpext float %612 to double
  %616 = load i32, ptr %76, align 4, !tbaa !5
  %617 = zext i32 %616 to i64
  %618 = getelementptr inbounds { float, float }, ptr %480, i64 %617
  %619 = getelementptr inbounds { float, float }, ptr %618, i32 0, i32 0
  %620 = load float, ptr %619, align 8
  %621 = getelementptr inbounds { float, float }, ptr %618, i32 0, i32 1
  %622 = load float, ptr %621, align 4
  %623 = fpext float %622 to double
  %624 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %605, ptr noundef @.str.10, i32 noundef %607, double noundef %615, double noundef %623) #6
  %625 = load ptr, ptr %80, align 8, !tbaa !9
  %626 = load i32, ptr %76, align 4, !tbaa !5
  %627 = add i32 %626, 1
  %628 = load i32, ptr %76, align 4, !tbaa !5
  %629 = zext i32 %628 to i64
  %630 = getelementptr inbounds { float, float }, ptr %483, i64 %629
  %631 = getelementptr inbounds { float, float }, ptr %630, i32 0, i32 0
  %632 = load float, ptr %631, align 8
  %633 = getelementptr inbounds { float, float }, ptr %630, i32 0, i32 1
  %634 = load float, ptr %633, align 4
  %635 = fpext float %632 to double
  %636 = load i32, ptr %76, align 4, !tbaa !5
  %637 = zext i32 %636 to i64
  %638 = getelementptr inbounds { float, float }, ptr %483, i64 %637
  %639 = getelementptr inbounds { float, float }, ptr %638, i32 0, i32 0
  %640 = load float, ptr %639, align 8
  %641 = getelementptr inbounds { float, float }, ptr %638, i32 0, i32 1
  %642 = load float, ptr %641, align 4
  %643 = fpext float %642 to double
  %644 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %625, ptr noundef @.str.11, i32 noundef %627, double noundef %635, double noundef %643) #6
  %645 = load ptr, ptr %80, align 8, !tbaa !9
  %646 = load i32, ptr %76, align 4, !tbaa !5
  %647 = add i32 %646, 1
  %648 = load i32, ptr %76, align 4, !tbaa !5
  %649 = zext i32 %648 to i64
  %650 = getelementptr inbounds { float, float }, ptr %486, i64 %649
  %651 = getelementptr inbounds { float, float }, ptr %650, i32 0, i32 0
  %652 = load float, ptr %651, align 8
  %653 = getelementptr inbounds { float, float }, ptr %650, i32 0, i32 1
  %654 = load float, ptr %653, align 4
  %655 = fpext float %652 to double
  %656 = load i32, ptr %76, align 4, !tbaa !5
  %657 = zext i32 %656 to i64
  %658 = getelementptr inbounds { float, float }, ptr %486, i64 %657
  %659 = getelementptr inbounds { float, float }, ptr %658, i32 0, i32 0
  %660 = load float, ptr %659, align 8
  %661 = getelementptr inbounds { float, float }, ptr %658, i32 0, i32 1
  %662 = load float, ptr %661, align 4
  %663 = fpext float %662 to double
  %664 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %645, ptr noundef @.str.12, i32 noundef %647, double noundef %655, double noundef %663) #6
  %665 = load ptr, ptr %80, align 8, !tbaa !9
  %666 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %665, ptr noundef @.str.13) #6
  br label %667

667:                                              ; preds = %604
  %668 = load i32, ptr %76, align 4, !tbaa !5
  %669 = add i32 %668, 1
  store i32 %669, ptr %76, align 4, !tbaa !5
  br label %600, !llvm.loop !15

670:                                              ; preds = %600
  %671 = load ptr, ptr %80, align 8, !tbaa !9
  %672 = load float, ptr %73, align 4, !tbaa !11
  %673 = fpext float %672 to double
  %674 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %671, ptr noundef @.str.14, double noundef %673) #6
  %675 = load ptr, ptr %80, align 8, !tbaa !9
  %676 = load float, ptr %74, align 4, !tbaa !11
  %677 = fpext float %676 to double
  %678 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %675, ptr noundef @.str.15, double noundef %677) #6
  %679 = load ptr, ptr %80, align 8, !tbaa !9
  %680 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %679, ptr noundef @.str.16) #6
  %681 = load ptr, ptr %80, align 8, !tbaa !9
  %682 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %681, ptr noundef @.str.17) #6
  %683 = load ptr, ptr %80, align 8, !tbaa !9
  %684 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %683, ptr noundef @.str.18) #6
  %685 = load ptr, ptr %80, align 8, !tbaa !9
  %686 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %685, ptr noundef @.str.19) #6
  %687 = load ptr, ptr %80, align 8, !tbaa !9
  %688 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %687, ptr noundef @.str.20) #6
  %689 = load ptr, ptr %80, align 8, !tbaa !9
  %690 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %689, ptr noundef @.str.21) #6
  %691 = load ptr, ptr %80, align 8, !tbaa !9
  %692 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %691, ptr noundef @.str.22) #6
  %693 = load ptr, ptr %80, align 8, !tbaa !9
  %694 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %693, ptr noundef @.str.23) #6
  %695 = load ptr, ptr %80, align 8, !tbaa !9
  %696 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %695, ptr noundef @.str.24) #6
  %697 = load ptr, ptr %80, align 8, !tbaa !9
  %698 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %697, ptr noundef @.str.25) #6
  %699 = load ptr, ptr %80, align 8, !tbaa !9
  %700 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %699, ptr noundef @.str.26) #6
  %701 = load ptr, ptr %80, align 8, !tbaa !9
  %702 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %701, ptr noundef @.str.27) #6
  %703 = load ptr, ptr %80, align 8, !tbaa !9
  %704 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %703, ptr noundef @.str.28) #6
  %705 = load ptr, ptr %80, align 8, !tbaa !9
  %706 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %705, ptr noundef @.str.29) #6
  %707 = load ptr, ptr %80, align 8, !tbaa !9
  %708 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %707, ptr noundef @.str.30) #6
  %709 = load ptr, ptr %80, align 8, !tbaa !9
  %710 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %709, ptr noundef @.str.25) #6
  %711 = load ptr, ptr %80, align 8, !tbaa !9
  %712 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %711, ptr noundef @.str.31) #6
  %713 = load ptr, ptr %80, align 8, !tbaa !9
  %714 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %713, ptr noundef @.str.32) #6
  %715 = load ptr, ptr %80, align 8, !tbaa !9
  %716 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %715, ptr noundef @.str.23) #6
  %717 = load ptr, ptr %80, align 8, !tbaa !9
  %718 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %717, ptr noundef @.str.33) #6
  %719 = load ptr, ptr %80, align 8, !tbaa !9
  %720 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %719, ptr noundef @.str.25) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #6
  store i32 256, ptr %81, align 4, !tbaa !5
  %721 = load i32, ptr %81, align 4, !tbaa !5
  %722 = zext i32 %721 to i64
  %723 = alloca { float, float }, i64 %722, align 16
  store i64 %722, ptr %82, align 8
  %724 = load i32, ptr %81, align 4, !tbaa !5
  %725 = zext i32 %724 to i64
  %726 = alloca { float, float }, i64 %725, align 16
  store i64 %725, ptr %83, align 8
  %727 = load i32, ptr %81, align 4, !tbaa !5
  %728 = zext i32 %727 to i64
  %729 = alloca float, i64 %728, align 16
  store i64 %728, ptr %84, align 8
  %730 = load i32, ptr %81, align 4, !tbaa !5
  %731 = zext i32 %730 to i64
  %732 = alloca float, i64 %731, align 16
  store i64 %731, ptr %85, align 8
  store i32 0, ptr %76, align 4, !tbaa !5
  br label %733

733:                                              ; preds = %769, %670
  %734 = load i32, ptr %76, align 4, !tbaa !5
  %735 = load i32, ptr %81, align 4, !tbaa !5
  %736 = icmp ult i32 %734, %735
  br i1 %736, label %737, label %772

737:                                              ; preds = %733
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #6
  %738 = load i32, ptr %76, align 4, !tbaa !5
  %739 = uitofp i32 %738 to float
  %740 = fmul float 5.000000e-01, %739
  %741 = load i32, ptr %81, align 4, !tbaa !5
  %742 = uitofp i32 %741 to float
  %743 = fdiv float %740, %742
  %744 = fadd float 0x3F1A36E2E0000000, %743
  store float %744, ptr %86, align 4, !tbaa !11
  %745 = load ptr, ptr %37, align 8, !tbaa !9
  %746 = load float, ptr %86, align 4, !tbaa !11
  %747 = load i32, ptr %76, align 4, !tbaa !5
  %748 = zext i32 %747 to i64
  %749 = getelementptr inbounds { float, float }, ptr %723, i64 %748
  %750 = call i32 @iirfilt_crcf_freqresponse(ptr noundef %745, float noundef %746, ptr noundef %749)
  %751 = load ptr, ptr %68, align 8, !tbaa !9
  %752 = load float, ptr %86, align 4, !tbaa !11
  %753 = load i32, ptr %76, align 4, !tbaa !5
  %754 = zext i32 %753 to i64
  %755 = getelementptr inbounds { float, float }, ptr %726, i64 %754
  %756 = call i32 @iirfilt_crcf_freqresponse(ptr noundef %751, float noundef %752, ptr noundef %755)
  %757 = load ptr, ptr %37, align 8, !tbaa !9
  %758 = load float, ptr %86, align 4, !tbaa !11
  %759 = call float @iirfilt_crcf_groupdelay(ptr noundef %757, float noundef %758)
  %760 = load i32, ptr %76, align 4, !tbaa !5
  %761 = zext i32 %760 to i64
  %762 = getelementptr inbounds float, ptr %729, i64 %761
  store float %759, ptr %762, align 4, !tbaa !11
  %763 = load ptr, ptr %68, align 8, !tbaa !9
  %764 = load float, ptr %86, align 4, !tbaa !11
  %765 = call float @iirfilt_crcf_groupdelay(ptr noundef %763, float noundef %764)
  %766 = load i32, ptr %76, align 4, !tbaa !5
  %767 = zext i32 %766 to i64
  %768 = getelementptr inbounds float, ptr %732, i64 %767
  store float %765, ptr %768, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  br label %769

769:                                              ; preds = %737
  %770 = load i32, ptr %76, align 4, !tbaa !5
  %771 = add i32 %770, 1
  store i32 %771, ptr %76, align 4, !tbaa !5
  br label %733, !llvm.loop !16

772:                                              ; preds = %733
  %773 = load ptr, ptr %80, align 8, !tbaa !9
  %774 = load i32, ptr %81, align 4, !tbaa !5
  %775 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %773, ptr noundef @.str.34, i32 noundef %774) #6
  %776 = load ptr, ptr %80, align 8, !tbaa !9
  %777 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %776, ptr noundef @.str.35) #6
  %778 = load ptr, ptr %80, align 8, !tbaa !9
  %779 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %778, ptr noundef @.str.36) #6
  %780 = load ptr, ptr %80, align 8, !tbaa !9
  %781 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %780, ptr noundef @.str.37) #6
  %782 = load ptr, ptr %80, align 8, !tbaa !9
  %783 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %782, ptr noundef @.str.38) #6
  store i32 0, ptr %76, align 4, !tbaa !5
  br label %784

784:                                              ; preds = %849, %772
  %785 = load i32, ptr %76, align 4, !tbaa !5
  %786 = load i32, ptr %81, align 4, !tbaa !5
  %787 = icmp ult i32 %785, %786
  br i1 %787, label %788, label %852

788:                                              ; preds = %784
  %789 = load ptr, ptr %80, align 8, !tbaa !9
  %790 = load i32, ptr %76, align 4, !tbaa !5
  %791 = add i32 %790, 1
  %792 = load i32, ptr %76, align 4, !tbaa !5
  %793 = zext i32 %792 to i64
  %794 = getelementptr inbounds { float, float }, ptr %723, i64 %793
  %795 = getelementptr inbounds { float, float }, ptr %794, i32 0, i32 0
  %796 = load float, ptr %795, align 8
  %797 = getelementptr inbounds { float, float }, ptr %794, i32 0, i32 1
  %798 = load float, ptr %797, align 4
  %799 = fpext float %796 to double
  %800 = load i32, ptr %76, align 4, !tbaa !5
  %801 = zext i32 %800 to i64
  %802 = getelementptr inbounds { float, float }, ptr %723, i64 %801
  %803 = getelementptr inbounds { float, float }, ptr %802, i32 0, i32 0
  %804 = load float, ptr %803, align 8
  %805 = getelementptr inbounds { float, float }, ptr %802, i32 0, i32 1
  %806 = load float, ptr %805, align 4
  %807 = fpext float %806 to double
  %808 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %789, ptr noundef @.str.39, i32 noundef %791, double noundef %799, double noundef %807) #6
  %809 = load ptr, ptr %80, align 8, !tbaa !9
  %810 = load i32, ptr %76, align 4, !tbaa !5
  %811 = add i32 %810, 1
  %812 = load i32, ptr %76, align 4, !tbaa !5
  %813 = zext i32 %812 to i64
  %814 = getelementptr inbounds { float, float }, ptr %726, i64 %813
  %815 = getelementptr inbounds { float, float }, ptr %814, i32 0, i32 0
  %816 = load float, ptr %815, align 8
  %817 = getelementptr inbounds { float, float }, ptr %814, i32 0, i32 1
  %818 = load float, ptr %817, align 4
  %819 = fpext float %816 to double
  %820 = load i32, ptr %76, align 4, !tbaa !5
  %821 = zext i32 %820 to i64
  %822 = getelementptr inbounds { float, float }, ptr %726, i64 %821
  %823 = getelementptr inbounds { float, float }, ptr %822, i32 0, i32 0
  %824 = load float, ptr %823, align 8
  %825 = getelementptr inbounds { float, float }, ptr %822, i32 0, i32 1
  %826 = load float, ptr %825, align 4
  %827 = fpext float %826 to double
  %828 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %809, ptr noundef @.str.40, i32 noundef %811, double noundef %819, double noundef %827) #6
  %829 = load ptr, ptr %80, align 8, !tbaa !9
  %830 = load i32, ptr %76, align 4, !tbaa !5
  %831 = add i32 %830, 1
  %832 = load i32, ptr %76, align 4, !tbaa !5
  %833 = zext i32 %832 to i64
  %834 = getelementptr inbounds float, ptr %729, i64 %833
  %835 = load float, ptr %834, align 4, !tbaa !11
  %836 = fpext float %835 to double
  %837 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %829, ptr noundef @.str.41, i32 noundef %831, double noundef %836) #6
  %838 = load ptr, ptr %80, align 8, !tbaa !9
  %839 = load i32, ptr %76, align 4, !tbaa !5
  %840 = add i32 %839, 1
  %841 = load i32, ptr %76, align 4, !tbaa !5
  %842 = zext i32 %841 to i64
  %843 = getelementptr inbounds float, ptr %732, i64 %842
  %844 = load float, ptr %843, align 4, !tbaa !11
  %845 = fpext float %844 to double
  %846 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %838, ptr noundef @.str.42, i32 noundef %840, double noundef %845) #6
  %847 = load ptr, ptr %80, align 8, !tbaa !9
  %848 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %847, ptr noundef @.str.13) #6
  br label %849

849:                                              ; preds = %788
  %850 = load i32, ptr %76, align 4, !tbaa !5
  %851 = add i32 %850, 1
  store i32 %851, ptr %76, align 4, !tbaa !5
  br label %784, !llvm.loop !17

852:                                              ; preds = %784
  %853 = load ptr, ptr %80, align 8, !tbaa !9
  %854 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %853, ptr noundef @.str.43) #6
  %855 = load ptr, ptr %80, align 8, !tbaa !9
  %856 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %855, ptr noundef @.str.20) #6
  %857 = load ptr, ptr %80, align 8, !tbaa !9
  %858 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %857, ptr noundef @.str.44) #6
  %859 = load ptr, ptr %80, align 8, !tbaa !9
  %860 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %859, ptr noundef @.str.45) #6
  %861 = load ptr, ptr %80, align 8, !tbaa !9
  %862 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %861, ptr noundef @.str.46) #6
  %863 = load ptr, ptr %80, align 8, !tbaa !9
  %864 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %863, ptr noundef @.str.47) #6
  %865 = load ptr, ptr %80, align 8, !tbaa !9
  %866 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %865, ptr noundef @.str.48) #6
  %867 = load ptr, ptr %80, align 8, !tbaa !9
  %868 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %867, ptr noundef @.str.25) #6
  %869 = load ptr, ptr %80, align 8, !tbaa !9
  %870 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %869, ptr noundef @.str.49) #6
  %871 = load ptr, ptr %80, align 8, !tbaa !9
  %872 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %871, ptr noundef @.str.50) #6
  %873 = load ptr, ptr %80, align 8, !tbaa !9
  %874 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %873, ptr noundef @.str.51) #6
  %875 = load ptr, ptr %80, align 8, !tbaa !9
  %876 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %875, ptr noundef @.str.52) #6
  %877 = load ptr, ptr %80, align 8, !tbaa !9
  %878 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %877, ptr noundef @.str.53) #6
  %879 = load ptr, ptr %80, align 8, !tbaa !9
  %880 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %879, ptr noundef @.str.54) #6
  %881 = load ptr, ptr %80, align 8, !tbaa !9
  %882 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %881, ptr noundef @.str.55) #6
  %883 = load ptr, ptr %80, align 8, !tbaa !9
  %884 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %883, ptr noundef @.str.25) #6
  %885 = load ptr, ptr %80, align 8, !tbaa !9
  %886 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %885, ptr noundef @.str.56) #6
  %887 = load ptr, ptr %80, align 8, !tbaa !9
  %888 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %887, ptr noundef @.str.50) #6
  %889 = load ptr, ptr %80, align 8, !tbaa !9
  %890 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %889, ptr noundef @.str.57) #6
  %891 = load ptr, ptr %80, align 8, !tbaa !9
  %892 = call i32 @fclose(ptr noundef %891)
  %893 = call i32 (ptr, ...) @printf(ptr noundef @.str.58, ptr noundef @.str)
  %894 = load ptr, ptr %37, align 8, !tbaa !9
  %895 = call i32 @iirfilt_crcf_destroy(ptr noundef %894)
  %896 = load ptr, ptr %68, align 8, !tbaa !9
  %897 = call i32 @iirfilt_crcf_destroy(ptr noundef %896)
  %898 = call i32 (ptr, ...) @printf(ptr noundef @.str.59)
  store i32 0, ptr %3, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #6
  %899 = load ptr, ptr %69, align 8
  call void @llvm.stackrestore.p0(ptr %899)
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 48, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 48, ptr %65) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %51) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 48, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 48, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %7) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  %900 = load i32, ptr %3, align 4
  ret i32 %900
}

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

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

declare i32 @iirdes_dzpk2sosf(ptr noundef, ptr noundef, i32 noundef, <2 x float> noundef, ptr noundef, ptr noundef) #3

declare ptr @iirfilt_crcf_create_sos(ptr noundef, ptr noundef, i32 noundef) #3

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #4

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #5

; Function Attrs: nounwind
declare float @cosf(float noundef) #2

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #5

declare i32 @iirfilt_crcf_execute(ptr noundef, <2 x float> noundef, ptr noundef) #3

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

declare noalias ptr @fopen(ptr noundef, ptr noundef) #3

; Function Attrs: nounwind
declare i32 @fprintf(ptr noundef, ptr noundef, ...) #2

declare i32 @iirfilt_crcf_freqresponse(ptr noundef, float noundef, ptr noundef) #3

declare float @iirfilt_crcf_groupdelay(ptr noundef, float noundef) #3

declare i32 @fclose(ptr noundef) #3

declare i32 @printf(ptr noundef, ...) #3

declare i32 @iirfilt_crcf_destroy(ptr noundef) #3

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #4

attributes #0 = { 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 #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 #3 = { "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 #4 = { nocallback nofree nosync nounwind willreturn }
attributes #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}
!17 = distinct !{!17, !14}


; 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"

@.str = external hidden unnamed_addr constant [23 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [69 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [67 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [67 x i8], align 1
@.str.33 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.34 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.35 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.36 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.37 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.38 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.39 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [71 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [77 x i8], align 1
@.str.50 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [58 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @main(i32 noundef %0, ptr nocapture noundef readnone %1) local_unnamed_addr #0 {
  %3 = alloca [8 x { float, float }], align 16
  %4 = alloca [8 x { float, float }], align 16
  %5 = alloca [12 x float], align 16
  %6 = alloca [12 x float], align 16
  %7 = alloca [8 x { float, float }], align 16
  %8 = alloca [8 x { float, float }], align 16
  %9 = alloca [12 x float], align 16
  %10 = alloca [12 x float], align 16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #8
  store <2 x float> <float 0xBFF2D03C80000000, float 0.000000e+00>, ptr %3, align 16
  %11 = getelementptr inbounds i8, ptr %3, i64 8
  %12 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xC001781080000000>) #8
  %13 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x4001781080000000>) #8
  %14 = shufflevector <2 x float> %12, <2 x float> %13, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %15 = fpext <4 x float> %14 to <4 x double>
  %16 = fmul <4 x double> %15, <double 3.371020e+00, double 3.371020e+00, double 3.371020e+00, double 3.371020e+00>
  %17 = fptrunc <4 x double> %16 to <4 x float>
  store <4 x float> %17, ptr %11, align 8
  %18 = getelementptr inbounds i8, ptr %3, i64 24
  %19 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFF69C0360000000>) #8
  %20 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FF69C0360000000>) #8
  %21 = shufflevector <2 x float> %19, <2 x float> %20, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %22 = fpext <4 x float> %21 to <4 x double>
  %23 = fmul <4 x double> %22, <double 4.549710e+00, double 4.549710e+00, double 4.549710e+00, double 4.549710e+00>
  %24 = fptrunc <4 x double> %23 to <4 x float>
  store <4 x float> %24, ptr %18, align 8
  %25 = getelementptr inbounds i8, ptr %3, i64 40
  %26 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFE6647580000000>) #8
  %27 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FE6647580000000>) #8
  %28 = shufflevector <2 x float> %26, <2 x float> %27, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %29 = fpext <4 x float> %28 to <4 x double>
  %30 = fmul <4 x double> %29, <double 0x4014E55757D5A9EB, double 0x4014E55757D5A9EB, double 0x4014E55757D5A9EB, double 0x4014E55757D5A9EB>
  %31 = fptrunc <4 x double> %30 to <4 x float>
  store <4 x float> %31, ptr %25, align 8
  %32 = getelementptr inbounds i8, ptr %3, i64 56
  store <2 x float> <float 0x4015C664A0000000, float 0.000000e+00>, ptr %32, align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #8
  store <2 x float> <float 0xBFE293A600000000, float 0.000000e+00>, ptr %4, align 16
  %33 = getelementptr inbounds i8, ptr %4, i64 8
  %34 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFFFDCA160000000>) #8
  %35 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FFFDCA160000000>) #8
  %36 = shufflevector <2 x float> %34, <2 x float> %35, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %37 = fmul <4 x float> %36, <float 0x3FCDD99100000000, float 0x3FCDD99100000000, float 0x3FCDD99100000000, float 0x3FCDD99100000000>
  store <4 x float> %37, ptr %33, align 8
  %38 = getelementptr inbounds i8, ptr %4, i64 24
  %39 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFF28689A0000000>) #8
  %40 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FF28689A0000000>) #8
  %41 = shufflevector <2 x float> %39, <2 x float> %40, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %42 = fmul <4 x float> %41, <float 0x3FC73A96E0000000, float 0x3FC73A96E0000000, float 0x3FC73A96E0000000, float 0x3FC73A96E0000000>
  store <4 x float> %42, ptr %38, align 8
  %43 = getelementptr inbounds i8, ptr %4, i64 40
  %44 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFD8751720000000>) #8
  %45 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FD8751720000000>) #8
  %46 = shufflevector <2 x float> %44, <2 x float> %45, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %47 = fmul <4 x float> %46, <float 0x3FC502B9E0000000, float 0x3FC502B9E0000000, float 0x3FC502B9E0000000, float 0x3FC502B9E0000000>
  store <4 x float> %47, ptr %43, align 8
  %48 = getelementptr inbounds i8, ptr %4, i64 56
  store <2 x float> <float 1.000000e+00, float 0.000000e+00>, ptr %48, align 8
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %5) #8
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %6) #8
  %49 = call i32 @iirdes_dzpk2sosf(ptr noundef nonnull %3, ptr noundef nonnull %4, i32 noundef 8, <2 x float> noundef <float 0xBEF3D72880000000, float 0.000000e+00>, ptr noundef nonnull %5, ptr noundef nonnull %6) #8
  %50 = call ptr @iirfilt_crcf_create_sos(ptr noundef nonnull %5, ptr noundef nonnull %6, i32 noundef 4) #8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %7) #8
  store <2 x float> <float 0xBFFB3DBF40000000, float 0.000000e+00>, ptr %7, align 16
  %51 = getelementptr inbounds i8, ptr %7, i64 8
  %52 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xC00EEA05C0000000>) #8
  %53 = fmul <2 x float> %52, <float 0x4017827140000000, float 0x4017827140000000>
  store <2 x float> %53, ptr %51, align 8
  %54 = getelementptr inbounds i8, ptr %7, i64 16
  %55 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x400EEA05C0000000>) #8
  %56 = fmul <2 x float> %55, <float 0x4017827140000000, float 0x4017827140000000>
  store <2 x float> %56, ptr %54, align 16
  %57 = getelementptr inbounds i8, ptr %7, i64 24
  %58 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xC004308820000000>) #8
  %59 = fmul <2 x float> %58, <float 0x4010CA28C0000000, float 0x4010CA28C0000000>
  store <2 x float> %59, ptr %57, align 8
  %60 = getelementptr inbounds i8, ptr %7, i64 32
  %61 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x4004308820000000>) #8
  %62 = fmul <2 x float> %61, <float 0x4010CA28C0000000, float 0x4010CA28C0000000>
  store <2 x float> %62, ptr %60, align 16
  %63 = getelementptr inbounds i8, ptr %7, i64 40
  %64 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFF2ADBCA0000000>) #8
  %65 = fmul <2 x float> %64, <float 0x401566B0E0000000, float 0x401566B0E0000000>
  store <2 x float> %65, ptr %63, align 8
  %66 = getelementptr inbounds i8, ptr %7, i64 48
  %67 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FF2ADBCA0000000>) #8
  %68 = fmul <2 x float> %67, <float 0x401566B0E0000000, float 0x401566B0E0000000>
  store <2 x float> %68, ptr %66, align 16
  %69 = getelementptr inbounds i8, ptr %7, i64 56
  store <2 x float> <float 1.000000e+00, float 0.000000e+00>, ptr %69, align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %8) #8
  store <2 x float> <float 0xBFEB204E60000000, float 0.000000e+00>, ptr %8, align 16
  %70 = getelementptr inbounds i8, ptr %8, i64 8
  %71 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xC001869640000000>) #8
  %72 = fmul <2 x float> %71, <float 0x3FD3241880000000, float 0x3FD3241880000000>
  store <2 x float> %72, ptr %70, align 8
  %73 = getelementptr inbounds i8, ptr %8, i64 16
  %74 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x4001869640000000>) #8
  %75 = fmul <2 x float> %74, <float 0x3FD3241880000000, float 0x3FD3241880000000>
  store <2 x float> %75, ptr %73, align 16
  %76 = getelementptr inbounds i8, ptr %8, i64 24
  %77 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFF6C3FDA0000000>) #8
  %78 = fmul <2 x float> %77, <float 0x3FCC933780000000, float 0x3FCC933780000000>
  store <2 x float> %78, ptr %76, align 8
  %79 = getelementptr inbounds i8, ptr %8, i64 32
  %80 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FF6C3FDA0000000>) #8
  %81 = fmul <2 x float> %80, <float 0x3FCC933780000000, float 0x3FCC933780000000>
  store <2 x float> %81, ptr %79, align 16
  %82 = getelementptr inbounds i8, ptr %8, i64 40
  %83 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFE6A0BE00000000>) #8
  %84 = fmul <2 x float> %83, <float 0x3FC9122B80000000, float 0x3FC9122B80000000>
  store <2 x float> %84, ptr %82, align 8
  %85 = getelementptr inbounds i8, ptr %8, i64 48
  %86 = call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FE6A0BE00000000>) #8
  %87 = fmul <2 x float> %86, <float 0x3FC9122B80000000, float 0x3FC9122B80000000>
  store <2 x float> %87, ptr %85, align 16
  %88 = getelementptr inbounds i8, ptr %8, i64 56
  store <2 x float> <float 0x3FC8245540000000, float 0.000000e+00>, ptr %88, align 8
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %9) #8
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %10) #8
  %89 = call i32 @iirdes_dzpk2sosf(ptr noundef nonnull %7, ptr noundef nonnull %8, i32 noundef 8, <2 x float> noundef <float 0x3EF5EB9FC0000000, float 0.000000e+00>, ptr noundef nonnull %9, ptr noundef nonnull %10) #8
  %90 = call ptr @iirfilt_crcf_create_sos(ptr noundef nonnull %9, ptr noundef nonnull %10, i32 noundef 4) #8
  %91 = call ptr @llvm.stacksave.p0()
  %92 = alloca [801 x { float, float }], align 16
  %93 = alloca [801 x { float, float }], align 16
  %94 = alloca [801 x { float, float }], align 16
  br label %95

95:                                               ; preds = %2, %95
  %indvars.iv = phi i64 [ 0, %2 ], [ %indvars.iv.next, %95 ]
  %96 = trunc nuw nsw i64 %indvars.iv to i32
  %97 = uitofp nneg i32 %96 to float
  %98 = call float @llvm.fmuladd.f32(float %97, float 0x3F547AE140000000, float 0.000000e+00)
  %99 = fpext float %98 to double
  %100 = call double @llvm.fmuladd.f64(double %99, double 0x4039C2D4CFF9149E, double 0.000000e+00)
  %101 = fptrunc double %100 to float
  %102 = call float @cosf(float noundef %101) #8
  %103 = fpext float %102 to double
  %104 = call double @llvm.fmuladd.f64(double %99, double 0x4045AD4F2BE133B2, double 0x3FECCCCCC0000000)
  %105 = fptrunc double %104 to float
  %106 = call float @cosf(float noundef %105) #8
  %107 = fpext float %106 to double
  %108 = fmul double %107, 4.000000e-01
  %109 = call double @llvm.fmuladd.f64(double %103, double 2.000000e-01, double %108)
  %110 = call double @llvm.fmuladd.f64(double %99, double 0x404E7933EFC5DD13, double 0x3FC99999A0000000)
  %111 = fptrunc double %110 to float
  %112 = call float @cosf(float noundef %111) #8
  %113 = fpext float %112 to double
  %114 = call double @llvm.fmuladd.f64(double %113, double 0x3FE6666666666666, double %109)
  %115 = fmul double %99, 0x403921FB54442D18
  %116 = fptrunc double %115 to float
  %117 = call float @cosf(float noundef %116) #8
  %118 = fmul float %117, 0.000000e+00
  %119 = fpext float %118 to double
  %120 = fadd double %114, %119
  %121 = fptrunc double %120 to float
  %122 = getelementptr inbounds { float, float }, ptr %92, i64 %indvars.iv
  %123 = getelementptr inbounds i8, ptr %122, i64 4
  store float %121, ptr %122, align 8
  store float %117, ptr %123, align 4
  %124 = insertelement <2 x float> poison, float %121, i64 0
  %125 = insertelement <2 x float> %124, float %117, i64 1
  %126 = fmul <2 x float> %125, <float 0x3F547AE140000000, float 0x3F547AE140000000>
  %127 = getelementptr inbounds { float, float }, ptr %93, i64 %indvars.iv
  %128 = call i32 @iirfilt_crcf_execute(ptr noundef %50, <2 x float> noundef %126, ptr noundef nonnull %127) #8
  %129 = load <2 x float>, ptr %127, align 8
  %130 = fdiv <2 x float> %129, <float 0x3F547AE140000000, float 0x3F547AE140000000>
  %131 = getelementptr inbounds { float, float }, ptr %94, i64 %indvars.iv
  %132 = call i32 @iirfilt_crcf_execute(ptr noundef %90, <2 x float> noundef %130, ptr noundef nonnull %131) #8
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, 801
  br i1 %exitcond.not, label %133, label %95, !llvm.loop !5

133:                                              ; preds = %95
  %134 = call noalias ptr @fopen(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1)
  %135 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str) #8
  %136 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.3) #8
  %137 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.4) #8
  %138 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.5) #8
  %139 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.6, i32 noundef 801) #8
  %140 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.7) #8
  %141 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.8) #8
  %142 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.9) #8
  br label %143

143:                                              ; preds = %133, %143
  %indvars.iv230 = phi i64 [ 0, %133 ], [ %indvars.iv.next231, %143 ]
  %indvars.iv.next231 = add nuw nsw i64 %indvars.iv230, 1
  %144 = getelementptr inbounds { float, float }, ptr %92, i64 %indvars.iv230
  %145 = load float, ptr %144, align 8
  %146 = getelementptr inbounds i8, ptr %144, i64 4
  %147 = fpext float %145 to double
  %148 = load float, ptr %146, align 4
  %149 = fpext float %148 to double
  %150 = trunc nuw nsw i64 %indvars.iv.next231 to i32
  %151 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.10, i32 noundef %150, double noundef %147, double noundef %149) #8
  %152 = getelementptr inbounds { float, float }, ptr %93, i64 %indvars.iv230
  %153 = load float, ptr %152, align 8
  %154 = getelementptr inbounds i8, ptr %152, i64 4
  %155 = fpext float %153 to double
  %156 = load float, ptr %154, align 4
  %157 = fpext float %156 to double
  %158 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.11, i32 noundef %150, double noundef %155, double noundef %157) #8
  %159 = getelementptr inbounds { float, float }, ptr %94, i64 %indvars.iv230
  %160 = load float, ptr %159, align 8
  %161 = getelementptr inbounds i8, ptr %159, i64 4
  %162 = fpext float %160 to double
  %163 = load float, ptr %161, align 4
  %164 = fpext float %163 to double
  %165 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.12, i32 noundef %150, double noundef %162, double noundef %164) #8
  %166 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.13) #8
  %exitcond233.not = icmp eq i64 %indvars.iv.next231, 801
  br i1 %exitcond233.not, label %167, label %143, !llvm.loop !7

167:                                              ; preds = %143
  %168 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.14, double noundef 0.000000e+00) #8
  %169 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.15, double noundef 1.000000e+00) #8
  %170 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.16) #8
  %171 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.17) #8
  %172 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.18) #8
  %173 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.19) #8
  %174 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.20) #8
  %175 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.21) #8
  %176 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.22) #8
  %177 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.23) #8
  %178 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.24) #8
  %179 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.25) #8
  %180 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.26) #8
  %181 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.27) #8
  %182 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.28) #8
  %183 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.29) #8
  %184 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.30) #8
  %185 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.25) #8
  %186 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.31) #8
  %187 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.32) #8
  %188 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.23) #8
  %189 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.33) #8
  %190 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.25) #8
  %191 = alloca [256 x { float, float }], align 16
  %192 = alloca [256 x { float, float }], align 16
  %193 = alloca [256 x float], align 16
  %194 = alloca [256 x float], align 16
  br label %195

195:                                              ; preds = %167, %195
  %indvars.iv234 = phi i64 [ 0, %167 ], [ %indvars.iv.next235, %195 ]
  %196 = trunc nuw nsw i64 %indvars.iv234 to i32
  %197 = uitofp nneg i32 %196 to float
  %198 = fmul float %197, 5.000000e-01
  %199 = fmul float %198, 3.906250e-03
  %200 = fadd float %199, 0x3F1A36E2E0000000
  %201 = getelementptr inbounds { float, float }, ptr %191, i64 %indvars.iv234
  %202 = call i32 @iirfilt_crcf_freqresponse(ptr noundef %50, float noundef %200, ptr noundef nonnull %201) #8
  %203 = getelementptr inbounds { float, float }, ptr %192, i64 %indvars.iv234
  %204 = call i32 @iirfilt_crcf_freqresponse(ptr noundef %90, float noundef %200, ptr noundef nonnull %203) #8
  %205 = call float @iirfilt_crcf_groupdelay(ptr noundef %50, float noundef %200) #8
  %206 = getelementptr inbounds float, ptr %193, i64 %indvars.iv234
  store float %205, ptr %206, align 4, !tbaa !8
  %207 = call float @iirfilt_crcf_groupdelay(ptr noundef %90, float noundef %200) #8
  %208 = getelementptr inbounds float, ptr %194, i64 %indvars.iv234
  store float %207, ptr %208, align 4, !tbaa !8
  %indvars.iv.next235 = add nuw nsw i64 %indvars.iv234, 1
  %exitcond237.not = icmp eq i64 %indvars.iv.next235, 256
  br i1 %exitcond237.not, label %209, label %195, !llvm.loop !12

209:                                              ; preds = %195
  %210 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.34, i32 noundef 256) #8
  %211 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.35) #8
  %212 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.36) #8
  %213 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.37) #8
  %214 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.38) #8
  br label %215

215:                                              ; preds = %209, %215
  %indvars.iv238 = phi i64 [ 0, %209 ], [ %indvars.iv.next239, %215 ]
  %indvars.iv.next239 = add nuw nsw i64 %indvars.iv238, 1
  %216 = getelementptr inbounds { float, float }, ptr %191, i64 %indvars.iv238
  %217 = load float, ptr %216, align 8
  %218 = getelementptr inbounds i8, ptr %216, i64 4
  %219 = fpext float %217 to double
  %220 = load float, ptr %218, align 4
  %221 = fpext float %220 to double
  %222 = trunc nuw nsw i64 %indvars.iv.next239 to i32
  %223 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.39, i32 noundef %222, double noundef %219, double noundef %221) #8
  %224 = getelementptr inbounds { float, float }, ptr %192, i64 %indvars.iv238
  %225 = load float, ptr %224, align 8
  %226 = getelementptr inbounds i8, ptr %224, i64 4
  %227 = fpext float %225 to double
  %228 = load float, ptr %226, align 4
  %229 = fpext float %228 to double
  %230 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.40, i32 noundef %222, double noundef %227, double noundef %229) #8
  %231 = getelementptr inbounds float, ptr %193, i64 %indvars.iv238
  %232 = load float, ptr %231, align 4, !tbaa !8
  %233 = fpext float %232 to double
  %234 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.41, i32 noundef %222, double noundef %233) #8
  %235 = getelementptr inbounds float, ptr %194, i64 %indvars.iv238
  %236 = load float, ptr %235, align 4, !tbaa !8
  %237 = fpext float %236 to double
  %238 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.42, i32 noundef %222, double noundef %237) #8
  %239 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.13) #8
  %exitcond241.not = icmp eq i64 %indvars.iv.next239, 256
  br i1 %exitcond241.not, label %240, label %215, !llvm.loop !13

240:                                              ; preds = %215
  %241 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.43) #8
  %242 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.20) #8
  %243 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.44) #8
  %244 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.45) #8
  %245 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.46) #8
  %246 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.47) #8
  %247 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.48) #8
  %248 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.25) #8
  %249 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.49) #8
  %250 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.50) #8
  %251 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.51) #8
  %252 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.52) #8
  %253 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.53) #8
  %254 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.54) #8
  %255 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.55) #8
  %256 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.25) #8
  %257 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.56) #8
  %258 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.50) #8
  %259 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %134, ptr noundef nonnull @.str.57) #8
  %260 = call i32 @fclose(ptr noundef %134)
  %261 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.58, ptr noundef nonnull @.str)
  %262 = call i32 @iirfilt_crcf_destroy(ptr noundef %50) #8
  %263 = call i32 @iirfilt_crcf_destroy(ptr noundef %90) #8
  %264 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.59)
  call void @llvm.stackrestore.p0(ptr %91)
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %9) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %8) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %7) #8
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %6) #8
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %5) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #8
  ret i32 0
}

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

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

declare i32 @iirdes_dzpk2sosf(ptr noundef, ptr noundef, i32 noundef, <2 x float> noundef, ptr noundef, ptr noundef) local_unnamed_addr #3

declare ptr @iirfilt_crcf_create_sos(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #4

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #5

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare float @cosf(float noundef) local_unnamed_addr #6

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #5

declare i32 @iirfilt_crcf_execute(ptr noundef, <2 x float> noundef, ptr noundef) local_unnamed_addr #3

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

; Function Attrs: nofree nounwind
declare noalias noundef ptr @fopen(ptr nocapture noundef readonly, ptr nocapture noundef readonly) local_unnamed_addr #7

; Function Attrs: nofree nounwind
declare noundef i32 @fprintf(ptr nocapture noundef, ptr nocapture noundef readonly, ...) local_unnamed_addr #7

declare i32 @iirfilt_crcf_freqresponse(ptr noundef, float noundef, ptr noundef) local_unnamed_addr #3

declare float @iirfilt_crcf_groupdelay(ptr noundef, float noundef) local_unnamed_addr #3

; Function Attrs: nofree nounwind
declare noundef i32 @fclose(ptr nocapture noundef) local_unnamed_addr #7

; Function Attrs: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) local_unnamed_addr #7

declare i32 @iirfilt_crcf_destroy(ptr noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #4

attributes #0 = { 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 #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 #3 = { "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 #4 = { mustprogress nocallback nofree nosync nounwind willreturn }
attributes #5 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { mustprogress nofree nounwind willreturn memory(write) "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 #7 = { nofree 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 #8 = { 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 = distinct !{!5, !6}
!6 = !{!"llvm.loop.mustprogress"}
!7 = distinct !{!7, !6}
!8 = !{!9, !9, i64 0}
!9 = !{!"float", !10, i64 0}
!10 = !{!"omnipotent char", !11, i64 0}
!11 = !{!"Simple C/C++ TBAA"}
!12 = distinct !{!12, !6}
!13 = distinct !{!13, !6}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LoopRotatePass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass