; LLVM IR from jgaeddert/liquid-dsp :: sandbox (firpfbch_analysis_equivalence_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 [14 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [99 x i8], align 1
@__PRETTY_FUNCTION__.main = external hidden unnamed_addr constant [11 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca i64, align 8
  %11 = alloca i64, align 8
  %12 = alloca i64, align 8
  %13 = alloca i32, align 4
  %14 = alloca i64, align 8
  %15 = alloca i64, align 8
  %16 = alloca i64, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca i64, align 8
  %20 = alloca i64, align 8
  %21 = alloca i64, align 8
  %22 = alloca i64, align 8
  %23 = alloca i64, align 8
  %24 = alloca { float, float }, align 4
  %25 = alloca { float, float }, align 4
  %26 = alloca i32, align 4
  %27 = alloca { float, float }, align 4
  %28 = alloca ptr, align 8
  %29 = alloca { float, float }, align 4
  %30 = alloca float, align 4
  %31 = alloca i32, align 4
  %32 = alloca { float, float }, align 4
  %33 = alloca { float, float }, align 4
  %34 = alloca { float, float }, align 4
  %35 = alloca { float, float }, align 4
  %36 = alloca i64, align 8
  %37 = alloca { float, float }, align 4
  %38 = alloca { float, float }, align 4
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #6
  store i32 4, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #6
  store i32 5, ptr %3, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #6
  store i32 12, ptr %4, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #6
  %39 = load i32, ptr %2, align 4, !tbaa !5
  %40 = load i32, ptr %4, align 4, !tbaa !5
  %41 = mul i32 %39, %40
  store i32 %41, ptr %5, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  %42 = load i32, ptr %3, align 4, !tbaa !5
  %43 = mul i32 2, %42
  %44 = load i32, ptr %2, align 4, !tbaa !5
  %45 = mul i32 %43, %44
  store i32 %45, ptr %8, align 4, !tbaa !5
  %46 = load i32, ptr %8, align 4, !tbaa !5
  %47 = zext i32 %46 to i64
  %48 = call ptr @llvm.stacksave.p0()
  store ptr %48, ptr %9, align 8
  %49 = alloca float, i64 %47, align 16
  store i64 %47, ptr %10, align 8
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %50

50:                                               ; preds = %59, %0
  %51 = load i32, ptr %6, align 4, !tbaa !5
  %52 = load i32, ptr %8, align 4, !tbaa !5
  %53 = icmp ult i32 %51, %52
  br i1 %53, label %54, label %62

54:                                               ; preds = %50
  %55 = call float (...) @randnf()
  %56 = load i32, ptr %6, align 4, !tbaa !5
  %57 = zext i32 %56 to i64
  %58 = getelementptr inbounds float, ptr %49, i64 %57
  store float %55, ptr %58, align 4, !tbaa !9
  br label %59

59:                                               ; preds = %54
  %60 = load i32, ptr %6, align 4, !tbaa !5
  %61 = add i32 %60, 1
  store i32 %61, ptr %6, align 4, !tbaa !5
  br label %50, !llvm.loop !11

62:                                               ; preds = %50
  %63 = load i32, ptr %2, align 4, !tbaa !5
  %64 = zext i32 %63 to i64
  %65 = alloca ptr, i64 %64, align 16
  store i64 %64, ptr %11, align 8
  %66 = load i32, ptr %2, align 4, !tbaa !5
  %67 = zext i32 %66 to i64
  %68 = alloca ptr, i64 %67, align 16
  store i64 %67, ptr %12, align 8
  %69 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %70

70:                                               ; preds = %82, %62
  %71 = load i32, ptr %6, align 4, !tbaa !5
  %72 = load i32, ptr %8, align 4, !tbaa !5
  %73 = icmp ult i32 %71, %72
  br i1 %73, label %74, label %85

74:                                               ; preds = %70
  %75 = load i32, ptr %6, align 4, !tbaa !5
  %76 = load i32, ptr %6, align 4, !tbaa !5
  %77 = zext i32 %76 to i64
  %78 = getelementptr inbounds float, ptr %49, i64 %77
  %79 = load float, ptr %78, align 4, !tbaa !9
  %80 = fpext float %79 to double
  %81 = call i32 (ptr, ...) @printf(ptr noundef @.str.1, i32 noundef %75, double noundef %80)
  br label %82

82:                                               ; preds = %74
  %83 = load i32, ptr %6, align 4, !tbaa !5
  %84 = add i32 %83, 1
  store i32 %84, ptr %6, align 4, !tbaa !5
  br label %70, !llvm.loop !13

85:                                               ; preds = %70
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %86 = load i32, ptr %3, align 4, !tbaa !5
  %87 = mul i32 2, %86
  store i32 %87, ptr %13, align 4, !tbaa !5
  %88 = load i32, ptr %13, align 4, !tbaa !5
  %89 = zext i32 %88 to i64
  %90 = alloca float, i64 %89, align 16
  store i64 %89, ptr %14, align 8
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %91

91:                                               ; preds = %147, %85
  %92 = load i32, ptr %6, align 4, !tbaa !5
  %93 = load i32, ptr %2, align 4, !tbaa !5
  %94 = icmp ult i32 %92, %93
  br i1 %94, label %95, label %150

95:                                               ; preds = %91
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %96

96:                                               ; preds = %115, %95
  %97 = load i32, ptr %7, align 4, !tbaa !5
  %98 = load i32, ptr %13, align 4, !tbaa !5
  %99 = icmp ult i32 %97, %98
  br i1 %99, label %100, label %118

100:                                              ; preds = %96
  %101 = load i32, ptr %7, align 4, !tbaa !5
  %102 = load i32, ptr %2, align 4, !tbaa !5
  %103 = mul i32 %101, %102
  %104 = load i32, ptr %6, align 4, !tbaa !5
  %105 = add i32 %103, %104
  %106 = zext i32 %105 to i64
  %107 = getelementptr inbounds float, ptr %49, i64 %106
  %108 = load float, ptr %107, align 4, !tbaa !9
  %109 = load i32, ptr %13, align 4, !tbaa !5
  %110 = load i32, ptr %7, align 4, !tbaa !5
  %111 = sub i32 %109, %110
  %112 = sub i32 %111, 1
  %113 = zext i32 %112 to i64
  %114 = getelementptr inbounds float, ptr %90, i64 %113
  store float %108, ptr %114, align 4, !tbaa !9
  br label %115

115:                                              ; preds = %100
  %116 = load i32, ptr %7, align 4, !tbaa !5
  %117 = add i32 %116, 1
  store i32 %117, ptr %7, align 4, !tbaa !5
  br label %96, !llvm.loop !14

118:                                              ; preds = %96
  %119 = load i32, ptr %13, align 4, !tbaa !5
  %120 = call ptr @dotprod_crcf_create(ptr noundef %90, i32 noundef %119)
  %121 = load i32, ptr %6, align 4, !tbaa !5
  %122 = zext i32 %121 to i64
  %123 = getelementptr inbounds ptr, ptr %65, i64 %122
  store ptr %120, ptr %123, align 8, !tbaa !15
  %124 = load i32, ptr %13, align 4, !tbaa !5
  %125 = call ptr @windowcf_create(i32 noundef %124)
  %126 = load i32, ptr %6, align 4, !tbaa !5
  %127 = zext i32 %126 to i64
  %128 = getelementptr inbounds ptr, ptr %68, i64 %127
  store ptr %125, ptr %128, align 8, !tbaa !15
  %129 = load i32, ptr %6, align 4, !tbaa !5
  %130 = call i32 (ptr, ...) @printf(ptr noundef @.str.2, i32 noundef %129)
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %131

131:                                              ; preds = %143, %118
  %132 = load i32, ptr %7, align 4, !tbaa !5
  %133 = load i32, ptr %13, align 4, !tbaa !5
  %134 = icmp ult i32 %132, %133
  br i1 %134, label %135, label %146

135:                                              ; preds = %131
  %136 = load i32, ptr %7, align 4, !tbaa !5
  %137 = load i32, ptr %7, align 4, !tbaa !5
  %138 = zext i32 %137 to i64
  %139 = getelementptr inbounds float, ptr %90, i64 %138
  %140 = load float, ptr %139, align 4, !tbaa !9
  %141 = fpext float %140 to double
  %142 = call i32 (ptr, ...) @printf(ptr noundef @.str.1, i32 noundef %136, double noundef %141)
  br label %143

143:                                              ; preds = %135
  %144 = load i32, ptr %7, align 4, !tbaa !5
  %145 = add i32 %144, 1
  store i32 %145, ptr %7, align 4, !tbaa !5
  br label %131, !llvm.loop !17

146:                                              ; preds = %131
  br label %147

147:                                              ; preds = %146
  %148 = load i32, ptr %6, align 4, !tbaa !5
  %149 = add i32 %148, 1
  store i32 %149, ptr %6, align 4, !tbaa !5
  br label %91, !llvm.loop !18

150:                                              ; preds = %91
  %151 = load i32, ptr %2, align 4, !tbaa !5
  %152 = zext i32 %151 to i64
  %153 = alloca { float, float }, i64 %152, align 16
  store i64 %152, ptr %15, align 8
  %154 = load i32, ptr %2, align 4, !tbaa !5
  %155 = zext i32 %154 to i64
  %156 = alloca { float, float }, i64 %155, align 16
  store i64 %155, ptr %16, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  %157 = load i32, ptr %2, align 4, !tbaa !5
  %158 = call ptr @fft_create_plan(i32 noundef %157, ptr noundef %156, ptr noundef %153, i32 noundef 1, i32 noundef 0)
  store ptr %158, ptr %17, align 8, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  %159 = load i32, ptr %8, align 4, !tbaa !5
  %160 = call ptr @firfilt_crcf_create(ptr noundef %49, i32 noundef %159)
  store ptr %160, ptr %18, align 8, !tbaa !15
  %161 = load i32, ptr %5, align 4, !tbaa !5
  %162 = zext i32 %161 to i64
  %163 = alloca { float, float }, i64 %162, align 16
  store i64 %162, ptr %19, align 8
  %164 = load i32, ptr %4, align 4, !tbaa !5
  %165 = zext i32 %164 to i64
  %166 = load i32, ptr %2, align 4, !tbaa !5
  %167 = zext i32 %166 to i64
  %168 = mul nuw i64 %165, %167
  %169 = alloca { float, float }, i64 %168, align 16
  store i64 %165, ptr %20, align 8
  store i64 %167, ptr %21, align 8
  %170 = load i32, ptr %4, align 4, !tbaa !5
  %171 = zext i32 %170 to i64
  %172 = load i32, ptr %2, align 4, !tbaa !5
  %173 = zext i32 %172 to i64
  %174 = mul nuw i64 %171, %173
  %175 = alloca { float, float }, i64 %174, align 16
  store i64 %171, ptr %22, align 8
  store i64 %173, ptr %23, align 8
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %176

176:                                              ; preds = %208, %150
  %177 = load i32, ptr %6, align 4, !tbaa !5
  %178 = load i32, ptr %5, align 4, !tbaa !5
  %179 = icmp ult i32 %177, %178
  br i1 %179, label %180, label %211

180:                                              ; preds = %176
  %181 = call float (...) @randnf()
  %182 = call float (...) @randf()
  %183 = fmul float 0.000000e+00, %182
  %184 = fmul float 1.000000e+00, %182
  %185 = fmul float %183, 2.000000e+00
  %186 = fmul float %184, 2.000000e+00
  %187 = fpext float %185 to double
  %188 = fpext float %186 to double
  %189 = fmul double %187, 0x400921FB54442D18
  %190 = fmul double %188, 0x400921FB54442D18
  %191 = fptrunc double %189 to float
  %192 = fptrunc double %190 to float
  %193 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 0
  %194 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 1
  store float %191, ptr %193, align 4
  store float %192, ptr %194, align 4
  %195 = load <2 x float>, ptr %24, align 4
  %196 = call <2 x float> @cexpf(<2 x float> noundef %195) #6
  store <2 x float> %196, ptr %25, align 4
  %197 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 0
  %198 = load float, ptr %197, align 4
  %199 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 1
  %200 = load float, ptr %199, align 4
  %201 = fmul float %181, %198
  %202 = fmul float %181, %200
  %203 = load i32, ptr %6, align 4, !tbaa !5
  %204 = zext i32 %203 to i64
  %205 = getelementptr inbounds { float, float }, ptr %163, i64 %204
  %206 = getelementptr inbounds { float, float }, ptr %205, i32 0, i32 0
  %207 = getelementptr inbounds { float, float }, ptr %205, i32 0, i32 1
  store float %201, ptr %206, align 8
  store float %202, ptr %207, align 4
  br label %208

208:                                              ; preds = %180
  %209 = load i32, ptr %6, align 4, !tbaa !5
  %210 = add i32 %209, 1
  store i32 %210, ptr %6, align 4, !tbaa !5
  br label %176, !llvm.loop !19

211:                                              ; preds = %176
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %212 = load i32, ptr %2, align 4, !tbaa !5
  %213 = sub i32 %212, 1
  store i32 %213, ptr %26, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %214

214:                                              ; preds = %312, %211
  %215 = load i32, ptr %6, align 4, !tbaa !5
  %216 = load i32, ptr %4, align 4, !tbaa !5
  %217 = icmp ult i32 %215, %216
  br i1 %217, label %218, label %315

218:                                              ; preds = %214
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %219

219:                                              ; preds = %255, %218
  %220 = load i32, ptr %7, align 4, !tbaa !5
  %221 = load i32, ptr %2, align 4, !tbaa !5
  %222 = icmp ult i32 %220, %221
  br i1 %222, label %223, label %258

223:                                              ; preds = %219
  %224 = load i32, ptr %6, align 4, !tbaa !5
  %225 = load i32, ptr %2, align 4, !tbaa !5
  %226 = mul i32 %224, %225
  %227 = load i32, ptr %7, align 4, !tbaa !5
  %228 = add i32 %226, %227
  %229 = zext i32 %228 to i64
  %230 = getelementptr inbounds { float, float }, ptr %163, i64 %229
  %231 = getelementptr inbounds { float, float }, ptr %230, i32 0, i32 0
  %232 = load float, ptr %231, align 8
  %233 = getelementptr inbounds { float, float }, ptr %230, i32 0, i32 1
  %234 = load float, ptr %233, align 4
  %235 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %236 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  store float %232, ptr %235, align 4
  store float %234, ptr %236, align 4
  %237 = load i32, ptr %26, align 4, !tbaa !5
  %238 = zext i32 %237 to i64
  %239 = getelementptr inbounds ptr, ptr %68, i64 %238
  %240 = load ptr, ptr %239, align 8, !tbaa !15
  %241 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %242 = load float, ptr %241, align 4
  %243 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  %244 = load float, ptr %243, align 4
  %245 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %246 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  store float %242, ptr %245, align 4
  store float %244, ptr %246, align 4
  %247 = load <2 x float>, ptr %29, align 4
  %248 = call i32 @windowcf_push(ptr noundef %240, <2 x float> noundef %247)
  %249 = load i32, ptr %26, align 4, !tbaa !5
  %250 = load i32, ptr %2, align 4, !tbaa !5
  %251 = add i32 %249, %250
  %252 = sub i32 %251, 1
  %253 = load i32, ptr %2, align 4, !tbaa !5
  %254 = urem i32 %252, %253
  store i32 %254, ptr %26, align 4, !tbaa !5
  br label %255

255:                                              ; preds = %223
  %256 = load i32, ptr %7, align 4, !tbaa !5
  %257 = add i32 %256, 1
  store i32 %257, ptr %7, align 4, !tbaa !5
  br label %219, !llvm.loop !20

258:                                              ; preds = %219
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %259

259:                                              ; preds = %281, %258
  %260 = load i32, ptr %7, align 4, !tbaa !5
  %261 = load i32, ptr %2, align 4, !tbaa !5
  %262 = icmp ult i32 %260, %261
  br i1 %262, label %263, label %284

263:                                              ; preds = %259
  %264 = load i32, ptr %7, align 4, !tbaa !5
  %265 = zext i32 %264 to i64
  %266 = getelementptr inbounds ptr, ptr %68, i64 %265
  %267 = load ptr, ptr %266, align 8, !tbaa !15
  %268 = call i32 @windowcf_read(ptr noundef %267, ptr noundef %28)
  %269 = load i32, ptr %7, align 4, !tbaa !5
  %270 = zext i32 %269 to i64
  %271 = getelementptr inbounds ptr, ptr %65, i64 %270
  %272 = load ptr, ptr %271, align 8, !tbaa !15
  %273 = load ptr, ptr %28, align 8, !tbaa !15
  %274 = load i32, ptr %2, align 4, !tbaa !5
  %275 = load i32, ptr %7, align 4, !tbaa !5
  %276 = sub i32 %274, %275
  %277 = sub i32 %276, 1
  %278 = zext i32 %277 to i64
  %279 = getelementptr inbounds { float, float }, ptr %156, i64 %278
  %280 = call i32 @dotprod_crcf_execute(ptr noundef %272, ptr noundef %273, ptr noundef %279)
  br label %281

281:                                              ; preds = %263
  %282 = load i32, ptr %7, align 4, !tbaa !5
  %283 = add i32 %282, 1
  store i32 %283, ptr %7, align 4, !tbaa !5
  br label %259, !llvm.loop !21

284:                                              ; preds = %259
  %285 = load ptr, ptr %17, align 8, !tbaa !15
  %286 = call i32 @fft_execute(ptr noundef %285)
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %287

287:                                              ; preds = %308, %284
  %288 = load i32, ptr %7, align 4, !tbaa !5
  %289 = load i32, ptr %2, align 4, !tbaa !5
  %290 = icmp ult i32 %288, %289
  br i1 %290, label %291, label %311

291:                                              ; preds = %287
  %292 = load i32, ptr %7, align 4, !tbaa !5
  %293 = zext i32 %292 to i64
  %294 = getelementptr inbounds { float, float }, ptr %153, i64 %293
  %295 = getelementptr inbounds { float, float }, ptr %294, i32 0, i32 0
  %296 = load float, ptr %295, align 8
  %297 = getelementptr inbounds { float, float }, ptr %294, i32 0, i32 1
  %298 = load float, ptr %297, align 4
  %299 = load i32, ptr %6, align 4, !tbaa !5
  %300 = zext i32 %299 to i64
  %301 = mul nsw i64 %300, %167
  %302 = getelementptr inbounds { float, float }, ptr %169, i64 %301
  %303 = load i32, ptr %7, align 4, !tbaa !5
  %304 = zext i32 %303 to i64
  %305 = getelementptr inbounds { float, float }, ptr %302, i64 %304
  %306 = getelementptr inbounds { float, float }, ptr %305, i32 0, i32 0
  %307 = getelementptr inbounds { float, float }, ptr %305, i32 0, i32 1
  store float %296, ptr %306, align 8
  store float %298, ptr %307, align 4
  br label %308

308:                                              ; preds = %291
  %309 = load i32, ptr %7, align 4, !tbaa !5
  %310 = add i32 %309, 1
  store i32 %310, ptr %7, align 4, !tbaa !5
  br label %287, !llvm.loop !22

311:                                              ; preds = %287
  br label %312

312:                                              ; preds = %311
  %313 = load i32, ptr %6, align 4, !tbaa !5
  %314 = add i32 %313, 1
  store i32 %314, ptr %6, align 4, !tbaa !5
  br label %214, !llvm.loop !23

315:                                              ; preds = %214
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  store i32 0, ptr %31, align 4, !tbaa !5
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %316

316:                                              ; preds = %416, %315
  %317 = load i32, ptr %6, align 4, !tbaa !5
  %318 = load i32, ptr %2, align 4, !tbaa !5
  %319 = icmp ult i32 %317, %318
  br i1 %319, label %320, label %419

320:                                              ; preds = %316
  %321 = load ptr, ptr %18, align 8, !tbaa !15
  %322 = call i32 @firfilt_crcf_reset(ptr noundef %321)
  %323 = load i32, ptr %6, align 4, !tbaa !5
  %324 = uitofp i32 %323 to float
  %325 = fpext float %324 to double
  %326 = fmul double 0x401921FB54442D18, %325
  %327 = load i32, ptr %2, align 4, !tbaa !5
  %328 = uitofp i32 %327 to float
  %329 = fpext float %328 to double
  %330 = fdiv double %326, %329
  %331 = fptrunc double %330 to float
  store float %331, ptr %30, align 4, !tbaa !9
  store i32 0, ptr %31, align 4, !tbaa !5
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %332

332:                                              ; preds = %406, %320
  %333 = load i32, ptr %7, align 4, !tbaa !5
  %334 = load i32, ptr %5, align 4, !tbaa !5
  %335 = icmp ult i32 %333, %334
  br i1 %335, label %336, label %409

336:                                              ; preds = %332
  %337 = load ptr, ptr %18, align 8, !tbaa !15
  %338 = load i32, ptr %7, align 4, !tbaa !5
  %339 = zext i32 %338 to i64
  %340 = getelementptr inbounds { float, float }, ptr %163, i64 %339
  %341 = getelementptr inbounds { float, float }, ptr %340, i32 0, i32 0
  %342 = load float, ptr %341, align 8
  %343 = getelementptr inbounds { float, float }, ptr %340, i32 0, i32 1
  %344 = load float, ptr %343, align 4
  %345 = load i32, ptr %7, align 4, !tbaa !5
  %346 = uitofp i32 %345 to float
  %347 = fmul float -0.000000e+00, %346
  %348 = fmul float -1.000000e+00, %346
  %349 = load float, ptr %30, align 4, !tbaa !9
  %350 = fmul float %347, %349
  %351 = fmul float %348, %349
  %352 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %353 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  store float %350, ptr %352, align 4
  store float %351, ptr %353, align 4
  %354 = load <2 x float>, ptr %32, align 4
  %355 = call <2 x float> @cexpf(<2 x float> noundef %354) #6
  store <2 x float> %355, ptr %33, align 4
  %356 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %357 = load float, ptr %356, align 4
  %358 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  %359 = load float, ptr %358, align 4
  %360 = fmul float %342, %357
  %361 = fmul float %344, %359
  %362 = fmul float %342, %359
  %363 = fmul float %344, %357
  %364 = fsub float %360, %361
  %365 = fadd float %362, %363
  %366 = fcmp uno float %364, %364
  br i1 %366, label %367, label %375, !prof !24

367:                                              ; preds = %336
  %368 = fcmp uno float %365, %365
  br i1 %368, label %369, label %375, !prof !24

369:                                              ; preds = %367
  %370 = call <2 x float> @__mulsc3(float noundef %342, float noundef %344, float noundef %357, float noundef %359) #6
  store <2 x float> %370, ptr %34, align 4
  %371 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 0
  %372 = load float, ptr %371, align 4
  %373 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 1
  %374 = load float, ptr %373, align 4
  br label %375

375:                                              ; preds = %369, %367, %336
  %376 = phi float [ %364, %336 ], [ %364, %367 ], [ %372, %369 ]
  %377 = phi float [ %365, %336 ], [ %365, %367 ], [ %374, %369 ]
  %378 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 0
  %379 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 1
  store float %376, ptr %378, align 4
  store float %377, ptr %379, align 4
  %380 = load <2 x float>, ptr %35, align 4
  %381 = call i32 @firfilt_crcf_push(ptr noundef %337, <2 x float> noundef %380)
  %382 = load i32, ptr %31, align 4, !tbaa !5
  %383 = load i32, ptr %4, align 4, !tbaa !5
  %384 = icmp ult i32 %382, %383
  br i1 %384, label %385, label %386

385:                                              ; preds = %375
  br label %387

386:                                              ; preds = %375
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.4, i32 noundef 152, ptr noundef @__PRETTY_FUNCTION__.main) #7
  unreachable

387:                                              ; preds = %385
  %388 = load i32, ptr %7, align 4, !tbaa !5
  %389 = add i32 %388, 1
  %390 = load i32, ptr %2, align 4, !tbaa !5
  %391 = urem i32 %389, %390
  %392 = icmp eq i32 %391, 0
  br i1 %392, label %393, label %405

393:                                              ; preds = %387
  %394 = load ptr, ptr %18, align 8, !tbaa !15
  %395 = load i32, ptr %31, align 4, !tbaa !5
  %396 = zext i32 %395 to i64
  %397 = mul nsw i64 %396, %173
  %398 = getelementptr inbounds { float, float }, ptr %175, i64 %397
  %399 = load i32, ptr %6, align 4, !tbaa !5
  %400 = zext i32 %399 to i64
  %401 = getelementptr inbounds { float, float }, ptr %398, i64 %400
  %402 = call i32 @firfilt_crcf_execute(ptr noundef %394, ptr noundef %401)
  %403 = load i32, ptr %31, align 4, !tbaa !5
  %404 = add i32 %403, 1
  store i32 %404, ptr %31, align 4, !tbaa !5
  br label %405

405:                                              ; preds = %393, %387
  br label %406

406:                                              ; preds = %405
  %407 = load i32, ptr %7, align 4, !tbaa !5
  %408 = add i32 %407, 1
  store i32 %408, ptr %7, align 4, !tbaa !5
  br label %332, !llvm.loop !25

409:                                              ; preds = %332
  %410 = load i32, ptr %31, align 4, !tbaa !5
  %411 = load i32, ptr %4, align 4, !tbaa !5
  %412 = icmp eq i32 %410, %411
  br i1 %412, label %413, label %414

413:                                              ; preds = %409
  br label %415

414:                                              ; preds = %409
  call void @__assert_fail(ptr noundef @.str.5, ptr noundef @.str.4, i32 noundef 158, ptr noundef @__PRETTY_FUNCTION__.main) #7
  unreachable

415:                                              ; preds = %413
  br label %416

416:                                              ; preds = %415
  %417 = load i32, ptr %6, align 4, !tbaa !5
  %418 = add i32 %417, 1
  store i32 %418, ptr %6, align 4, !tbaa !5
  br label %316, !llvm.loop !26

419:                                              ; preds = %316
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %420

420:                                              ; preds = %435, %419
  %421 = load i32, ptr %6, align 4, !tbaa !5
  %422 = load i32, ptr %2, align 4, !tbaa !5
  %423 = icmp ult i32 %421, %422
  br i1 %423, label %424, label %438

424:                                              ; preds = %420
  %425 = load i32, ptr %6, align 4, !tbaa !5
  %426 = zext i32 %425 to i64
  %427 = getelementptr inbounds ptr, ptr %65, i64 %426
  %428 = load ptr, ptr %427, align 8, !tbaa !15
  %429 = call i32 @dotprod_crcf_destroy(ptr noundef %428)
  %430 = load i32, ptr %6, align 4, !tbaa !5
  %431 = zext i32 %430 to i64
  %432 = getelementptr inbounds ptr, ptr %68, i64 %431
  %433 = load ptr, ptr %432, align 8, !tbaa !15
  %434 = call i32 @windowcf_destroy(ptr noundef %433)
  br label %435

435:                                              ; preds = %424
  %436 = load i32, ptr %6, align 4, !tbaa !5
  %437 = add i32 %436, 1
  store i32 %437, ptr %6, align 4, !tbaa !5
  br label %420, !llvm.loop !27

438:                                              ; preds = %420
  %439 = load ptr, ptr %17, align 8, !tbaa !15
  %440 = call i32 @fft_destroy_plan(ptr noundef %439)
  %441 = load ptr, ptr %18, align 8, !tbaa !15
  %442 = call i32 @firfilt_crcf_destroy(ptr noundef %441)
  %443 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  %444 = call i32 (ptr, ...) @printf(ptr noundef @.str.7)
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %445

445:                                              ; preds = %487, %438
  %446 = load i32, ptr %6, align 4, !tbaa !5
  %447 = load i32, ptr %4, align 4, !tbaa !5
  %448 = icmp ult i32 %446, %447
  br i1 %448, label %449, label %490

449:                                              ; preds = %445
  %450 = load i32, ptr %6, align 4, !tbaa !5
  %451 = call i32 (ptr, ...) @printf(ptr noundef @.str.8, i32 noundef %450)
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %452

452:                                              ; preds = %482, %449
  %453 = load i32, ptr %7, align 4, !tbaa !5
  %454 = load i32, ptr %2, align 4, !tbaa !5
  %455 = icmp ult i32 %453, %454
  br i1 %455, label %456, label %485

456:                                              ; preds = %452
  %457 = load i32, ptr %6, align 4, !tbaa !5
  %458 = zext i32 %457 to i64
  %459 = mul nsw i64 %458, %167
  %460 = getelementptr inbounds { float, float }, ptr %169, i64 %459
  %461 = load i32, ptr %7, align 4, !tbaa !5
  %462 = zext i32 %461 to i64
  %463 = getelementptr inbounds { float, float }, ptr %460, i64 %462
  %464 = getelementptr inbounds { float, float }, ptr %463, i32 0, i32 0
  %465 = load float, ptr %464, align 8
  %466 = getelementptr inbounds { float, float }, ptr %463, i32 0, i32 1
  %467 = load float, ptr %466, align 4
  %468 = fpext float %465 to double
  %469 = load i32, ptr %6, align 4, !tbaa !5
  %470 = zext i32 %469 to i64
  %471 = mul nsw i64 %470, %167
  %472 = getelementptr inbounds { float, float }, ptr %169, i64 %471
  %473 = load i32, ptr %7, align 4, !tbaa !5
  %474 = zext i32 %473 to i64
  %475 = getelementptr inbounds { float, float }, ptr %472, i64 %474
  %476 = getelementptr inbounds { float, float }, ptr %475, i32 0, i32 0
  %477 = load float, ptr %476, align 8
  %478 = getelementptr inbounds { float, float }, ptr %475, i32 0, i32 1
  %479 = load float, ptr %478, align 4
  %480 = fpext float %479 to double
  %481 = call i32 (ptr, ...) @printf(ptr noundef @.str.9, double noundef %468, double noundef %480)
  br label %482

482:                                              ; preds = %456
  %483 = load i32, ptr %7, align 4, !tbaa !5
  %484 = add i32 %483, 1
  store i32 %484, ptr %7, align 4, !tbaa !5
  br label %452, !llvm.loop !28

485:                                              ; preds = %452
  %486 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  br label %487

487:                                              ; preds = %485
  %488 = load i32, ptr %6, align 4, !tbaa !5
  %489 = add i32 %488, 1
  store i32 %489, ptr %6, align 4, !tbaa !5
  br label %445, !llvm.loop !29

490:                                              ; preds = %445
  %491 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  %492 = call i32 (ptr, ...) @printf(ptr noundef @.str.10)
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %493

493:                                              ; preds = %535, %490
  %494 = load i32, ptr %6, align 4, !tbaa !5
  %495 = load i32, ptr %4, align 4, !tbaa !5
  %496 = icmp ult i32 %494, %495
  br i1 %496, label %497, label %538

497:                                              ; preds = %493
  %498 = load i32, ptr %6, align 4, !tbaa !5
  %499 = call i32 (ptr, ...) @printf(ptr noundef @.str.8, i32 noundef %498)
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %500

500:                                              ; preds = %530, %497
  %501 = load i32, ptr %7, align 4, !tbaa !5
  %502 = load i32, ptr %2, align 4, !tbaa !5
  %503 = icmp ult i32 %501, %502
  br i1 %503, label %504, label %533

504:                                              ; preds = %500
  %505 = load i32, ptr %6, align 4, !tbaa !5
  %506 = zext i32 %505 to i64
  %507 = mul nsw i64 %506, %173
  %508 = getelementptr inbounds { float, float }, ptr %175, i64 %507
  %509 = load i32, ptr %7, align 4, !tbaa !5
  %510 = zext i32 %509 to i64
  %511 = getelementptr inbounds { float, float }, ptr %508, i64 %510
  %512 = getelementptr inbounds { float, float }, ptr %511, i32 0, i32 0
  %513 = load float, ptr %512, align 8
  %514 = getelementptr inbounds { float, float }, ptr %511, i32 0, i32 1
  %515 = load float, ptr %514, align 4
  %516 = fpext float %513 to double
  %517 = load i32, ptr %6, align 4, !tbaa !5
  %518 = zext i32 %517 to i64
  %519 = mul nsw i64 %518, %173
  %520 = getelementptr inbounds { float, float }, ptr %175, i64 %519
  %521 = load i32, ptr %7, align 4, !tbaa !5
  %522 = zext i32 %521 to i64
  %523 = getelementptr inbounds { float, float }, ptr %520, i64 %522
  %524 = getelementptr inbounds { float, float }, ptr %523, i32 0, i32 0
  %525 = load float, ptr %524, align 8
  %526 = getelementptr inbounds { float, float }, ptr %523, i32 0, i32 1
  %527 = load float, ptr %526, align 4
  %528 = fpext float %527 to double
  %529 = call i32 (ptr, ...) @printf(ptr noundef @.str.9, double noundef %516, double noundef %528)
  br label %530

530:                                              ; preds = %504
  %531 = load i32, ptr %7, align 4, !tbaa !5
  %532 = add i32 %531, 1
  store i32 %532, ptr %7, align 4, !tbaa !5
  br label %500, !llvm.loop !30

533:                                              ; preds = %500
  %534 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  br label %535

535:                                              ; preds = %533
  %536 = load i32, ptr %6, align 4, !tbaa !5
  %537 = add i32 %536, 1
  store i32 %537, ptr %6, align 4, !tbaa !5
  br label %493, !llvm.loop !31

538:                                              ; preds = %493
  %539 = load i32, ptr %2, align 4, !tbaa !5
  %540 = zext i32 %539 to i64
  %541 = alloca float, i64 %540, align 16
  store i64 %540, ptr %36, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %542

542:                                              ; preds = %624, %538
  %543 = load i32, ptr %6, align 4, !tbaa !5
  %544 = load i32, ptr %2, align 4, !tbaa !5
  %545 = icmp ult i32 %543, %544
  br i1 %545, label %546, label %627

546:                                              ; preds = %542
  %547 = load i32, ptr %6, align 4, !tbaa !5
  %548 = zext i32 %547 to i64
  %549 = getelementptr inbounds float, ptr %541, i64 %548
  store float 0.000000e+00, ptr %549, align 4, !tbaa !9
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %550

550:                                              ; preds = %613, %546
  %551 = load i32, ptr %7, align 4, !tbaa !5
  %552 = load i32, ptr %4, align 4, !tbaa !5
  %553 = icmp ult i32 %551, %552
  br i1 %553, label %554, label %616

554:                                              ; preds = %550
  %555 = load i32, ptr %7, align 4, !tbaa !5
  %556 = zext i32 %555 to i64
  %557 = mul nsw i64 %556, %167
  %558 = getelementptr inbounds { float, float }, ptr %169, i64 %557
  %559 = load i32, ptr %6, align 4, !tbaa !5
  %560 = zext i32 %559 to i64
  %561 = getelementptr inbounds { float, float }, ptr %558, i64 %560
  %562 = getelementptr inbounds { float, float }, ptr %561, i32 0, i32 0
  %563 = load float, ptr %562, align 8
  %564 = getelementptr inbounds { float, float }, ptr %561, i32 0, i32 1
  %565 = load float, ptr %564, align 4
  %566 = load i32, ptr %7, align 4, !tbaa !5
  %567 = zext i32 %566 to i64
  %568 = mul nsw i64 %567, %173
  %569 = getelementptr inbounds { float, float }, ptr %175, i64 %568
  %570 = load i32, ptr %6, align 4, !tbaa !5
  %571 = zext i32 %570 to i64
  %572 = getelementptr inbounds { float, float }, ptr %569, i64 %571
  %573 = getelementptr inbounds { float, float }, ptr %572, i32 0, i32 0
  %574 = load float, ptr %573, align 8
  %575 = getelementptr inbounds { float, float }, ptr %572, i32 0, i32 1
  %576 = load float, ptr %575, align 4
  %577 = fsub float %563, %574
  %578 = fsub float %565, %576
  %579 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %580 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  store float %577, ptr %579, align 4
  store float %578, ptr %580, align 4
  %581 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %582 = load float, ptr %581, align 4
  %583 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  %584 = load float, ptr %583, align 4
  %585 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %586 = load float, ptr %585, align 4
  %587 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  %588 = load float, ptr %587, align 4
  %589 = fneg float %588
  %590 = fmul float %582, %586
  %591 = fmul float %584, %589
  %592 = fmul float %582, %589
  %593 = fmul float %584, %586
  %594 = fsub float %590, %591
  %595 = fadd float %592, %593
  %596 = fcmp uno float %594, %594
  br i1 %596, label %597, label %605, !prof !24

597:                                              ; preds = %554
  %598 = fcmp uno float %595, %595
  br i1 %598, label %599, label %605, !prof !24

599:                                              ; preds = %597
  %600 = call <2 x float> @__mulsc3(float noundef %582, float noundef %584, float noundef %586, float noundef %589) #6
  store <2 x float> %600, ptr %38, align 4
  %601 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 0
  %602 = load float, ptr %601, align 4
  %603 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 1
  %604 = load float, ptr %603, align 4
  br label %605

605:                                              ; preds = %599, %597, %554
  %606 = phi float [ %594, %554 ], [ %594, %597 ], [ %602, %599 ]
  %607 = phi float [ %595, %554 ], [ %595, %597 ], [ %604, %599 ]
  %608 = load i32, ptr %6, align 4, !tbaa !5
  %609 = zext i32 %608 to i64
  %610 = getelementptr inbounds float, ptr %541, i64 %609
  %611 = load float, ptr %610, align 4, !tbaa !9
  %612 = fadd float %611, %606
  store float %612, ptr %610, align 4, !tbaa !9
  br label %613

613:                                              ; preds = %605
  %614 = load i32, ptr %7, align 4, !tbaa !5
  %615 = add i32 %614, 1
  store i32 %615, ptr %7, align 4, !tbaa !5
  br label %550, !llvm.loop !32

616:                                              ; preds = %550
  %617 = load i32, ptr %4, align 4, !tbaa !5
  %618 = uitofp i32 %617 to float
  %619 = load i32, ptr %6, align 4, !tbaa !5
  %620 = zext i32 %619 to i64
  %621 = getelementptr inbounds float, ptr %541, i64 %620
  %622 = load float, ptr %621, align 4, !tbaa !9
  %623 = fdiv float %622, %618
  store float %623, ptr %621, align 4, !tbaa !9
  br label %624

624:                                              ; preds = %616
  %625 = load i32, ptr %6, align 4, !tbaa !5
  %626 = add i32 %625, 1
  store i32 %626, ptr %6, align 4, !tbaa !5
  br label %542, !llvm.loop !33

627:                                              ; preds = %542
  %628 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  %629 = call i32 (ptr, ...) @printf(ptr noundef @.str.11)
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %630

630:                                              ; preds = %642, %627
  %631 = load i32, ptr %6, align 4, !tbaa !5
  %632 = load i32, ptr %2, align 4, !tbaa !5
  %633 = icmp ult i32 %631, %632
  br i1 %633, label %634, label %645

634:                                              ; preds = %630
  %635 = load i32, ptr %6, align 4, !tbaa !5
  %636 = zext i32 %635 to i64
  %637 = getelementptr inbounds float, ptr %541, i64 %636
  %638 = load float, ptr %637, align 4, !tbaa !9
  %639 = fpext float %638 to double
  %640 = call double @sqrt(double noundef %639) #6
  %641 = call i32 (ptr, ...) @printf(ptr noundef @.str.12, double noundef %640)
  br label %642

642:                                              ; preds = %634
  %643 = load i32, ptr %6, align 4, !tbaa !5
  %644 = add i32 %643, 1
  store i32 %644, ptr %6, align 4, !tbaa !5
  br label %630, !llvm.loop !34

645:                                              ; preds = %630
  %646 = call i32 (ptr, ...) @printf(ptr noundef @.str.6)
  %647 = call i32 (ptr, ...) @printf(ptr noundef @.str.13)
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  %648 = load ptr, ptr %9, align 8
  call void @llvm.stackrestore.p0(ptr %648)
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #6
  %649 = load i32, ptr %1, align 4
  ret i32 %649
}

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

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

declare float @randnf(...) #3

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

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

declare ptr @windowcf_create(i32 noundef) #3

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

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

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

declare float @randf(...) #3

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

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

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

declare i32 @fft_execute(ptr noundef) #3

declare i32 @firfilt_crcf_reset(ptr noundef) #3

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

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

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #5

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

declare i32 @dotprod_crcf_destroy(ptr noundef) #3

declare i32 @windowcf_destroy(ptr noundef) #3

declare i32 @fft_destroy_plan(ptr noundef) #3

declare i32 @firfilt_crcf_destroy(ptr noundef) #3

; Function Attrs: nounwind
declare double @sqrt(double noundef) #4

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

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

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 = { nocallback nofree nosync nounwind willreturn }
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 = { 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 #5 = { noreturn 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 #6 = { nounwind }
attributes #7 = { noreturn 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 = !{!"float", !7, i64 0}
!11 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}
!13 = distinct !{!13, !12}
!14 = distinct !{!14, !12}
!15 = !{!16, !16, i64 0}
!16 = !{!"any pointer", !7, i64 0}
!17 = distinct !{!17, !12}
!18 = distinct !{!18, !12}
!19 = distinct !{!19, !12}
!20 = distinct !{!20, !12}
!21 = distinct !{!21, !12}
!22 = distinct !{!22, !12}
!23 = distinct !{!23, !12}
!24 = !{!"branch_weights", i32 1, i32 1048575}
!25 = distinct !{!25, !12}
!26 = distinct !{!26, !12}
!27 = distinct !{!27, !12}
!28 = distinct !{!28, !12}
!29 = distinct !{!29, !12}
!30 = distinct !{!30, !12}
!31 = distinct !{!31, !12}
!32 = distinct !{!32, !12}
!33 = distinct !{!33, !12}
!34 = distinct !{!34, !12}


; 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 [14 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [99 x i8], align 1
@__PRETTY_FUNCTION__.main = external hidden unnamed_addr constant [11 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @main() local_unnamed_addr #0 {
.preheader183:
  %0 = alloca ptr, align 8
  %1 = alloca [40 x float], align 16
  %2 = tail call float (...) @randnf() #7
  store float %2, ptr %1, align 16, !tbaa !5
  %3 = tail call float (...) @randnf() #7
  %4 = getelementptr inbounds i8, ptr %1, i64 4
  store float %3, ptr %4, align 4, !tbaa !5
  %5 = tail call float (...) @randnf() #7
  %6 = getelementptr inbounds i8, ptr %1, i64 8
  store float %5, ptr %6, align 8, !tbaa !5
  %7 = tail call float (...) @randnf() #7
  %8 = getelementptr inbounds i8, ptr %1, i64 12
  store float %7, ptr %8, align 4, !tbaa !5
  %9 = tail call float (...) @randnf() #7
  %10 = getelementptr inbounds i8, ptr %1, i64 16
  store float %9, ptr %10, align 16, !tbaa !5
  %11 = tail call float (...) @randnf() #7
  %12 = getelementptr inbounds i8, ptr %1, i64 20
  store float %11, ptr %12, align 4, !tbaa !5
  %13 = tail call float (...) @randnf() #7
  %14 = getelementptr inbounds i8, ptr %1, i64 24
  store float %13, ptr %14, align 8, !tbaa !5
  %15 = tail call float (...) @randnf() #7
  %16 = getelementptr inbounds i8, ptr %1, i64 28
  store float %15, ptr %16, align 4, !tbaa !5
  %17 = tail call float (...) @randnf() #7
  %18 = getelementptr inbounds i8, ptr %1, i64 32
  store float %17, ptr %18, align 16, !tbaa !5
  %19 = tail call float (...) @randnf() #7
  %20 = getelementptr inbounds i8, ptr %1, i64 36
  store float %19, ptr %20, align 4, !tbaa !5
  %21 = tail call float (...) @randnf() #7
  %22 = getelementptr inbounds i8, ptr %1, i64 40
  store float %21, ptr %22, align 8, !tbaa !5
  %23 = tail call float (...) @randnf() #7
  %24 = getelementptr inbounds i8, ptr %1, i64 44
  store float %23, ptr %24, align 4, !tbaa !5
  %25 = tail call float (...) @randnf() #7
  %26 = getelementptr inbounds i8, ptr %1, i64 48
  store float %25, ptr %26, align 16, !tbaa !5
  %27 = tail call float (...) @randnf() #7
  %28 = getelementptr inbounds i8, ptr %1, i64 52
  store float %27, ptr %28, align 4, !tbaa !5
  %29 = tail call float (...) @randnf() #7
  %30 = getelementptr inbounds i8, ptr %1, i64 56
  store float %29, ptr %30, align 8, !tbaa !5
  %31 = tail call float (...) @randnf() #7
  %32 = getelementptr inbounds i8, ptr %1, i64 60
  store float %31, ptr %32, align 4, !tbaa !5
  %33 = tail call float (...) @randnf() #7
  %34 = getelementptr inbounds i8, ptr %1, i64 64
  store float %33, ptr %34, align 16, !tbaa !5
  %35 = tail call float (...) @randnf() #7
  %36 = getelementptr inbounds i8, ptr %1, i64 68
  store float %35, ptr %36, align 4, !tbaa !5
  %37 = tail call float (...) @randnf() #7
  %38 = getelementptr inbounds i8, ptr %1, i64 72
  store float %37, ptr %38, align 8, !tbaa !5
  %39 = tail call float (...) @randnf() #7
  %40 = getelementptr inbounds i8, ptr %1, i64 76
  store float %39, ptr %40, align 4, !tbaa !5
  %41 = tail call float (...) @randnf() #7
  %42 = getelementptr inbounds i8, ptr %1, i64 80
  store float %41, ptr %42, align 16, !tbaa !5
  %43 = tail call float (...) @randnf() #7
  %44 = getelementptr inbounds i8, ptr %1, i64 84
  store float %43, ptr %44, align 4, !tbaa !5
  %45 = tail call float (...) @randnf() #7
  %46 = getelementptr inbounds i8, ptr %1, i64 88
  store float %45, ptr %46, align 8, !tbaa !5
  %47 = tail call float (...) @randnf() #7
  %48 = getelementptr inbounds i8, ptr %1, i64 92
  store float %47, ptr %48, align 4, !tbaa !5
  %49 = tail call float (...) @randnf() #7
  %50 = getelementptr inbounds i8, ptr %1, i64 96
  store float %49, ptr %50, align 16, !tbaa !5
  %51 = tail call float (...) @randnf() #7
  %52 = getelementptr inbounds i8, ptr %1, i64 100
  store float %51, ptr %52, align 4, !tbaa !5
  %53 = tail call float (...) @randnf() #7
  %54 = getelementptr inbounds i8, ptr %1, i64 104
  store float %53, ptr %54, align 8, !tbaa !5
  %55 = tail call float (...) @randnf() #7
  %56 = getelementptr inbounds i8, ptr %1, i64 108
  store float %55, ptr %56, align 4, !tbaa !5
  %57 = tail call float (...) @randnf() #7
  %58 = getelementptr inbounds i8, ptr %1, i64 112
  store float %57, ptr %58, align 16, !tbaa !5
  %59 = tail call float (...) @randnf() #7
  %60 = getelementptr inbounds i8, ptr %1, i64 116
  store float %59, ptr %60, align 4, !tbaa !5
  %61 = tail call float (...) @randnf() #7
  %62 = getelementptr inbounds i8, ptr %1, i64 120
  store float %61, ptr %62, align 8, !tbaa !5
  %63 = tail call float (...) @randnf() #7
  %64 = getelementptr inbounds i8, ptr %1, i64 124
  store float %63, ptr %64, align 4, !tbaa !5
  %65 = tail call float (...) @randnf() #7
  %66 = getelementptr inbounds i8, ptr %1, i64 128
  store float %65, ptr %66, align 16, !tbaa !5
  %67 = tail call float (...) @randnf() #7
  %68 = getelementptr inbounds i8, ptr %1, i64 132
  store float %67, ptr %68, align 4, !tbaa !5
  %69 = tail call float (...) @randnf() #7
  %70 = getelementptr inbounds i8, ptr %1, i64 136
  store float %69, ptr %70, align 8, !tbaa !5
  %71 = tail call float (...) @randnf() #7
  %72 = getelementptr inbounds i8, ptr %1, i64 140
  store float %71, ptr %72, align 4, !tbaa !5
  %73 = tail call float (...) @randnf() #7
  %74 = getelementptr inbounds i8, ptr %1, i64 144
  store float %73, ptr %74, align 16, !tbaa !5
  %75 = tail call float (...) @randnf() #7
  %76 = getelementptr inbounds i8, ptr %1, i64 148
  store float %75, ptr %76, align 4, !tbaa !5
  %77 = tail call float (...) @randnf() #7
  %78 = getelementptr inbounds i8, ptr %1, i64 152
  store float %77, ptr %78, align 8, !tbaa !5
  %79 = tail call float (...) @randnf() #7
  %80 = getelementptr inbounds i8, ptr %1, i64 156
  store float %79, ptr %80, align 4, !tbaa !5
  %81 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %82 = load float, ptr %1, align 16, !tbaa !5
  %83 = fpext float %82 to double
  %84 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 0, double noundef %83)
  %85 = load float, ptr %4, align 4, !tbaa !5
  %86 = fpext float %85 to double
  %87 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 1, double noundef %86)
  %88 = load float, ptr %6, align 8, !tbaa !5
  %89 = fpext float %88 to double
  %90 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 2, double noundef %89)
  %91 = load float, ptr %8, align 4, !tbaa !5
  %92 = fpext float %91 to double
  %93 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 3, double noundef %92)
  %94 = load float, ptr %10, align 16, !tbaa !5
  %95 = fpext float %94 to double
  %96 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 4, double noundef %95)
  %97 = load float, ptr %12, align 4, !tbaa !5
  %98 = fpext float %97 to double
  %99 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 5, double noundef %98)
  %100 = load float, ptr %14, align 8, !tbaa !5
  %101 = fpext float %100 to double
  %102 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 6, double noundef %101)
  %103 = load float, ptr %16, align 4, !tbaa !5
  %104 = fpext float %103 to double
  %105 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 7, double noundef %104)
  %106 = load float, ptr %18, align 16, !tbaa !5
  %107 = fpext float %106 to double
  %108 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 8, double noundef %107)
  %109 = load float, ptr %20, align 4, !tbaa !5
  %110 = fpext float %109 to double
  %111 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 9, double noundef %110)
  %112 = load float, ptr %22, align 8, !tbaa !5
  %113 = fpext float %112 to double
  %114 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 10, double noundef %113)
  %115 = load float, ptr %24, align 4, !tbaa !5
  %116 = fpext float %115 to double
  %117 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 11, double noundef %116)
  %118 = load float, ptr %26, align 16, !tbaa !5
  %119 = fpext float %118 to double
  %120 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 12, double noundef %119)
  %121 = load float, ptr %28, align 4, !tbaa !5
  %122 = fpext float %121 to double
  %123 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 13, double noundef %122)
  %124 = load float, ptr %30, align 8, !tbaa !5
  %125 = fpext float %124 to double
  %126 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 14, double noundef %125)
  %127 = load float, ptr %32, align 4, !tbaa !5
  %128 = fpext float %127 to double
  %129 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 15, double noundef %128)
  %130 = load float, ptr %34, align 16, !tbaa !5
  %131 = fpext float %130 to double
  %132 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 16, double noundef %131)
  %133 = load float, ptr %36, align 4, !tbaa !5
  %134 = fpext float %133 to double
  %135 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 17, double noundef %134)
  %136 = load float, ptr %38, align 8, !tbaa !5
  %137 = fpext float %136 to double
  %138 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 18, double noundef %137)
  %139 = load float, ptr %40, align 4, !tbaa !5
  %140 = fpext float %139 to double
  %141 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 19, double noundef %140)
  %142 = load float, ptr %42, align 16, !tbaa !5
  %143 = fpext float %142 to double
  %144 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 20, double noundef %143)
  %145 = load float, ptr %44, align 4, !tbaa !5
  %146 = fpext float %145 to double
  %147 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 21, double noundef %146)
  %148 = load float, ptr %46, align 8, !tbaa !5
  %149 = fpext float %148 to double
  %150 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 22, double noundef %149)
  %151 = load float, ptr %48, align 4, !tbaa !5
  %152 = fpext float %151 to double
  %153 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 23, double noundef %152)
  %154 = load float, ptr %50, align 16, !tbaa !5
  %155 = fpext float %154 to double
  %156 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 24, double noundef %155)
  %157 = load float, ptr %52, align 4, !tbaa !5
  %158 = fpext float %157 to double
  %159 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 25, double noundef %158)
  %160 = load float, ptr %54, align 8, !tbaa !5
  %161 = fpext float %160 to double
  %162 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 26, double noundef %161)
  %163 = load float, ptr %56, align 4, !tbaa !5
  %164 = fpext float %163 to double
  %165 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 27, double noundef %164)
  %166 = load float, ptr %58, align 16, !tbaa !5
  %167 = fpext float %166 to double
  %168 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 28, double noundef %167)
  %169 = load float, ptr %60, align 4, !tbaa !5
  %170 = fpext float %169 to double
  %171 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 29, double noundef %170)
  %172 = load float, ptr %62, align 8, !tbaa !5
  %173 = fpext float %172 to double
  %174 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 30, double noundef %173)
  %175 = load float, ptr %64, align 4, !tbaa !5
  %176 = fpext float %175 to double
  %177 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 31, double noundef %176)
  %178 = load float, ptr %66, align 16, !tbaa !5
  %179 = fpext float %178 to double
  %180 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 32, double noundef %179)
  %181 = load float, ptr %68, align 4, !tbaa !5
  %182 = fpext float %181 to double
  %183 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 33, double noundef %182)
  %184 = load float, ptr %70, align 8, !tbaa !5
  %185 = fpext float %184 to double
  %186 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 34, double noundef %185)
  %187 = load float, ptr %72, align 4, !tbaa !5
  %188 = fpext float %187 to double
  %189 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 35, double noundef %188)
  %190 = load float, ptr %74, align 16, !tbaa !5
  %191 = fpext float %190 to double
  %192 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 36, double noundef %191)
  %193 = load float, ptr %76, align 4, !tbaa !5
  %194 = fpext float %193 to double
  %195 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 37, double noundef %194)
  %196 = load float, ptr %78, align 8, !tbaa !5
  %197 = fpext float %196 to double
  %198 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 38, double noundef %197)
  %199 = load float, ptr %80, align 4, !tbaa !5
  %200 = fpext float %199 to double
  %201 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 39, double noundef %200)
  %202 = alloca [10 x float], align 16
  %invariant.gep314 = getelementptr inbounds i8, ptr %1, i64 144
  %203 = getelementptr inbounds i8, ptr %202, i64 4
  %invariant.gep312 = getelementptr inbounds i8, ptr %1, i64 128
  %204 = getelementptr inbounds i8, ptr %202, i64 8
  %invariant.gep310 = getelementptr inbounds i8, ptr %1, i64 112
  %205 = getelementptr inbounds i8, ptr %202, i64 12
  %invariant.gep308 = getelementptr inbounds i8, ptr %1, i64 96
  %206 = getelementptr inbounds i8, ptr %202, i64 16
  %invariant.gep306 = getelementptr inbounds i8, ptr %1, i64 80
  %207 = getelementptr inbounds i8, ptr %202, i64 20
  %invariant.gep304 = getelementptr inbounds i8, ptr %1, i64 64
  %208 = getelementptr inbounds i8, ptr %202, i64 24
  %invariant.gep302 = getelementptr inbounds i8, ptr %1, i64 48
  %209 = getelementptr inbounds i8, ptr %202, i64 28
  %invariant.gep300 = getelementptr inbounds i8, ptr %1, i64 32
  %210 = getelementptr inbounds i8, ptr %202, i64 32
  %invariant.gep = getelementptr inbounds i8, ptr %1, i64 16
  %211 = getelementptr inbounds i8, ptr %202, i64 36
  %212 = load float, ptr %1, align 16, !tbaa !5
  store float %212, ptr %211, align 4, !tbaa !5
  %213 = load float, ptr %invariant.gep, align 16, !tbaa !5
  store float %213, ptr %210, align 16, !tbaa !5
  %214 = load float, ptr %invariant.gep300, align 16, !tbaa !5
  store float %214, ptr %209, align 4, !tbaa !5
  %215 = load float, ptr %invariant.gep302, align 16, !tbaa !5
  store float %215, ptr %208, align 8, !tbaa !5
  %216 = load float, ptr %invariant.gep304, align 16, !tbaa !5
  store float %216, ptr %207, align 4, !tbaa !5
  %217 = load float, ptr %invariant.gep306, align 16, !tbaa !5
  store float %217, ptr %206, align 16, !tbaa !5
  %218 = load float, ptr %invariant.gep308, align 16, !tbaa !5
  store float %218, ptr %205, align 4, !tbaa !5
  %219 = load float, ptr %invariant.gep310, align 16, !tbaa !5
  store float %219, ptr %204, align 8, !tbaa !5
  %220 = load float, ptr %invariant.gep312, align 16, !tbaa !5
  store float %220, ptr %203, align 4, !tbaa !5
  %221 = load float, ptr %invariant.gep314, align 16, !tbaa !5
  store float %221, ptr %202, align 16, !tbaa !5
  %222 = call ptr @dotprod_crcf_create(ptr noundef nonnull %202, i32 noundef 10) #7
  %223 = call ptr @windowcf_create(i32 noundef 10) #7
  %224 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 0)
  %225 = load float, ptr %202, align 16, !tbaa !5
  %226 = fpext float %225 to double
  %227 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 0, double noundef %226)
  %228 = load float, ptr %203, align 4, !tbaa !5
  %229 = fpext float %228 to double
  %230 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 1, double noundef %229)
  %231 = load float, ptr %204, align 8, !tbaa !5
  %232 = fpext float %231 to double
  %233 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 2, double noundef %232)
  %234 = load float, ptr %205, align 4, !tbaa !5
  %235 = fpext float %234 to double
  %236 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 3, double noundef %235)
  %237 = load float, ptr %206, align 16, !tbaa !5
  %238 = fpext float %237 to double
  %239 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 4, double noundef %238)
  %240 = load float, ptr %207, align 4, !tbaa !5
  %241 = fpext float %240 to double
  %242 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 5, double noundef %241)
  %243 = load float, ptr %208, align 8, !tbaa !5
  %244 = fpext float %243 to double
  %245 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 6, double noundef %244)
  %246 = load float, ptr %209, align 4, !tbaa !5
  %247 = fpext float %246 to double
  %248 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 7, double noundef %247)
  %249 = load float, ptr %210, align 16, !tbaa !5
  %250 = fpext float %249 to double
  %251 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 8, double noundef %250)
  %252 = load float, ptr %211, align 4, !tbaa !5
  %253 = fpext float %252 to double
  %254 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 9, double noundef %253)
  %255 = getelementptr inbounds i8, ptr %1, i64 4
  %256 = load float, ptr %255, align 4, !tbaa !5
  store float %256, ptr %211, align 4, !tbaa !5
  %gep299.1 = getelementptr inbounds i8, ptr %1, i64 20
  %257 = load float, ptr %gep299.1, align 4, !tbaa !5
  store float %257, ptr %210, align 16, !tbaa !5
  %gep301.1 = getelementptr inbounds i8, ptr %1, i64 36
  %258 = load float, ptr %gep301.1, align 4, !tbaa !5
  store float %258, ptr %209, align 4, !tbaa !5
  %gep303.1 = getelementptr inbounds i8, ptr %1, i64 52
  %259 = load float, ptr %gep303.1, align 4, !tbaa !5
  store float %259, ptr %208, align 8, !tbaa !5
  %gep305.1 = getelementptr inbounds i8, ptr %1, i64 68
  %260 = load float, ptr %gep305.1, align 4, !tbaa !5
  store float %260, ptr %207, align 4, !tbaa !5
  %gep307.1 = getelementptr inbounds i8, ptr %1, i64 84
  %261 = load float, ptr %gep307.1, align 4, !tbaa !5
  store float %261, ptr %206, align 16, !tbaa !5
  %gep309.1 = getelementptr inbounds i8, ptr %1, i64 100
  %262 = load float, ptr %gep309.1, align 4, !tbaa !5
  store float %262, ptr %205, align 4, !tbaa !5
  %gep311.1 = getelementptr inbounds i8, ptr %1, i64 116
  %263 = load float, ptr %gep311.1, align 4, !tbaa !5
  store float %263, ptr %204, align 8, !tbaa !5
  %gep313.1 = getelementptr inbounds i8, ptr %1, i64 132
  %264 = load float, ptr %gep313.1, align 4, !tbaa !5
  store float %264, ptr %203, align 4, !tbaa !5
  %gep315.1 = getelementptr inbounds i8, ptr %1, i64 148
  %265 = load float, ptr %gep315.1, align 4, !tbaa !5
  store float %265, ptr %202, align 16, !tbaa !5
  %266 = call ptr @dotprod_crcf_create(ptr noundef nonnull %202, i32 noundef 10) #7
  %267 = call ptr @windowcf_create(i32 noundef 10) #7
  %268 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 1)
  %269 = load float, ptr %202, align 16, !tbaa !5
  %270 = fpext float %269 to double
  %271 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 0, double noundef %270)
  %272 = load float, ptr %203, align 4, !tbaa !5
  %273 = fpext float %272 to double
  %274 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 1, double noundef %273)
  %275 = load float, ptr %204, align 8, !tbaa !5
  %276 = fpext float %275 to double
  %277 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 2, double noundef %276)
  %278 = load float, ptr %205, align 4, !tbaa !5
  %279 = fpext float %278 to double
  %280 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 3, double noundef %279)
  %281 = load float, ptr %206, align 16, !tbaa !5
  %282 = fpext float %281 to double
  %283 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 4, double noundef %282)
  %284 = load float, ptr %207, align 4, !tbaa !5
  %285 = fpext float %284 to double
  %286 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 5, double noundef %285)
  %287 = load float, ptr %208, align 8, !tbaa !5
  %288 = fpext float %287 to double
  %289 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 6, double noundef %288)
  %290 = load float, ptr %209, align 4, !tbaa !5
  %291 = fpext float %290 to double
  %292 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 7, double noundef %291)
  %293 = load float, ptr %210, align 16, !tbaa !5
  %294 = fpext float %293 to double
  %295 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 8, double noundef %294)
  %296 = load float, ptr %211, align 4, !tbaa !5
  %297 = fpext float %296 to double
  %298 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 9, double noundef %297)
  %299 = getelementptr inbounds i8, ptr %1, i64 8
  %300 = load float, ptr %299, align 8, !tbaa !5
  store float %300, ptr %211, align 4, !tbaa !5
  %gep299.2 = getelementptr inbounds i8, ptr %1, i64 24
  %301 = load float, ptr %gep299.2, align 8, !tbaa !5
  store float %301, ptr %210, align 16, !tbaa !5
  %gep301.2 = getelementptr inbounds i8, ptr %1, i64 40
  %302 = load float, ptr %gep301.2, align 8, !tbaa !5
  store float %302, ptr %209, align 4, !tbaa !5
  %gep303.2 = getelementptr inbounds i8, ptr %1, i64 56
  %303 = load float, ptr %gep303.2, align 8, !tbaa !5
  store float %303, ptr %208, align 8, !tbaa !5
  %gep305.2 = getelementptr inbounds i8, ptr %1, i64 72
  %304 = load float, ptr %gep305.2, align 8, !tbaa !5
  store float %304, ptr %207, align 4, !tbaa !5
  %gep307.2 = getelementptr inbounds i8, ptr %1, i64 88
  %305 = load float, ptr %gep307.2, align 8, !tbaa !5
  store float %305, ptr %206, align 16, !tbaa !5
  %gep309.2 = getelementptr inbounds i8, ptr %1, i64 104
  %306 = load float, ptr %gep309.2, align 8, !tbaa !5
  store float %306, ptr %205, align 4, !tbaa !5
  %gep311.2 = getelementptr inbounds i8, ptr %1, i64 120
  %307 = load float, ptr %gep311.2, align 8, !tbaa !5
  store float %307, ptr %204, align 8, !tbaa !5
  %gep313.2 = getelementptr inbounds i8, ptr %1, i64 136
  %308 = load float, ptr %gep313.2, align 8, !tbaa !5
  store float %308, ptr %203, align 4, !tbaa !5
  %gep315.2 = getelementptr inbounds i8, ptr %1, i64 152
  %309 = load float, ptr %gep315.2, align 8, !tbaa !5
  store float %309, ptr %202, align 16, !tbaa !5
  %310 = call ptr @dotprod_crcf_create(ptr noundef nonnull %202, i32 noundef 10) #7
  %311 = call ptr @windowcf_create(i32 noundef 10) #7
  %312 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 2)
  %313 = load float, ptr %202, align 16, !tbaa !5
  %314 = fpext float %313 to double
  %315 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 0, double noundef %314)
  %316 = load float, ptr %203, align 4, !tbaa !5
  %317 = fpext float %316 to double
  %318 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 1, double noundef %317)
  %319 = load float, ptr %204, align 8, !tbaa !5
  %320 = fpext float %319 to double
  %321 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 2, double noundef %320)
  %322 = load float, ptr %205, align 4, !tbaa !5
  %323 = fpext float %322 to double
  %324 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 3, double noundef %323)
  %325 = load float, ptr %206, align 16, !tbaa !5
  %326 = fpext float %325 to double
  %327 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 4, double noundef %326)
  %328 = load float, ptr %207, align 4, !tbaa !5
  %329 = fpext float %328 to double
  %330 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 5, double noundef %329)
  %331 = load float, ptr %208, align 8, !tbaa !5
  %332 = fpext float %331 to double
  %333 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 6, double noundef %332)
  %334 = load float, ptr %209, align 4, !tbaa !5
  %335 = fpext float %334 to double
  %336 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 7, double noundef %335)
  %337 = load float, ptr %210, align 16, !tbaa !5
  %338 = fpext float %337 to double
  %339 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 8, double noundef %338)
  %340 = load float, ptr %211, align 4, !tbaa !5
  %341 = fpext float %340 to double
  %342 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 9, double noundef %341)
  %343 = getelementptr inbounds i8, ptr %1, i64 12
  %344 = load float, ptr %343, align 4, !tbaa !5
  store float %344, ptr %211, align 4, !tbaa !5
  %gep299.3 = getelementptr inbounds i8, ptr %1, i64 28
  %345 = load float, ptr %gep299.3, align 4, !tbaa !5
  store float %345, ptr %210, align 16, !tbaa !5
  %gep301.3 = getelementptr inbounds i8, ptr %1, i64 44
  %346 = load float, ptr %gep301.3, align 4, !tbaa !5
  store float %346, ptr %209, align 4, !tbaa !5
  %gep303.3 = getelementptr inbounds i8, ptr %1, i64 60
  %347 = load float, ptr %gep303.3, align 4, !tbaa !5
  store float %347, ptr %208, align 8, !tbaa !5
  %gep305.3 = getelementptr inbounds i8, ptr %1, i64 76
  %348 = load float, ptr %gep305.3, align 4, !tbaa !5
  store float %348, ptr %207, align 4, !tbaa !5
  %gep307.3 = getelementptr inbounds i8, ptr %1, i64 92
  %349 = load float, ptr %gep307.3, align 4, !tbaa !5
  store float %349, ptr %206, align 16, !tbaa !5
  %gep309.3 = getelementptr inbounds i8, ptr %1, i64 108
  %350 = load float, ptr %gep309.3, align 4, !tbaa !5
  store float %350, ptr %205, align 4, !tbaa !5
  %gep311.3 = getelementptr inbounds i8, ptr %1, i64 124
  %351 = load float, ptr %gep311.3, align 4, !tbaa !5
  store float %351, ptr %204, align 8, !tbaa !5
  %gep313.3 = getelementptr inbounds i8, ptr %1, i64 140
  %352 = load float, ptr %gep313.3, align 4, !tbaa !5
  store float %352, ptr %203, align 4, !tbaa !5
  %gep315.3 = getelementptr inbounds i8, ptr %1, i64 156
  %353 = load float, ptr %gep315.3, align 4, !tbaa !5
  store float %353, ptr %202, align 16, !tbaa !5
  %354 = call ptr @dotprod_crcf_create(ptr noundef nonnull %202, i32 noundef 10) #7
  %355 = call ptr @windowcf_create(i32 noundef 10) #7
  %356 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 3)
  %357 = load float, ptr %202, align 16, !tbaa !5
  %358 = fpext float %357 to double
  %359 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 0, double noundef %358)
  %360 = load float, ptr %203, align 4, !tbaa !5
  %361 = fpext float %360 to double
  %362 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 1, double noundef %361)
  %363 = load float, ptr %204, align 8, !tbaa !5
  %364 = fpext float %363 to double
  %365 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 2, double noundef %364)
  %366 = load float, ptr %205, align 4, !tbaa !5
  %367 = fpext float %366 to double
  %368 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 3, double noundef %367)
  %369 = load float, ptr %206, align 16, !tbaa !5
  %370 = fpext float %369 to double
  %371 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 4, double noundef %370)
  %372 = load float, ptr %207, align 4, !tbaa !5
  %373 = fpext float %372 to double
  %374 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 5, double noundef %373)
  %375 = load float, ptr %208, align 8, !tbaa !5
  %376 = fpext float %375 to double
  %377 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 6, double noundef %376)
  %378 = load float, ptr %209, align 4, !tbaa !5
  %379 = fpext float %378 to double
  %380 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 7, double noundef %379)
  %381 = load float, ptr %210, align 16, !tbaa !5
  %382 = fpext float %381 to double
  %383 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 8, double noundef %382)
  %384 = load float, ptr %211, align 4, !tbaa !5
  %385 = fpext float %384 to double
  %386 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, i32 noundef 9, double noundef %385)
  %387 = alloca [4 x { float, float }], align 16
  %388 = alloca [4 x { float, float }], align 16
  %389 = call ptr @fft_create_plan(i32 noundef 4, ptr noundef nonnull %388, ptr noundef nonnull %387, i32 noundef 1, i32 noundef 0) #7
  %390 = call ptr @firfilt_crcf_create(ptr noundef nonnull %1, i32 noundef 40) #7
  %391 = alloca [48 x { float, float }], align 16
  %392 = alloca [48 x { float, float }], align 16
  %393 = alloca [48 x { float, float }], align 16
  br label %394

394:                                              ; preds = %.preheader183, %394
  %indvars.iv217 = phi i64 [ 0, %.preheader183 ], [ %indvars.iv.next218, %394 ]
  %395 = call float (...) @randnf() #7
  %396 = call float (...) @randf() #7
  %397 = fmul float %396, 0.000000e+00
  %398 = insertelement <2 x float> poison, float %397, i64 0
  %399 = insertelement <2 x float> %398, float %396, i64 1
  %400 = fmul <2 x float> %399, <float 2.000000e+00, float 2.000000e+00>
  %401 = fpext <2 x float> %400 to <2 x double>
  %402 = fmul <2 x double> %401, <double 0x400921FB54442D18, double 0x400921FB54442D18>
  %403 = fptrunc <2 x double> %402 to <2 x float>
  %404 = call <2 x float> @cexpf(<2 x float> noundef %403) #7
  %405 = getelementptr inbounds { float, float }, ptr %391, i64 %indvars.iv217
  %406 = insertelement <2 x float> poison, float %395, i64 0
  %407 = shufflevector <2 x float> %406, <2 x float> poison, <2 x i32> zeroinitializer
  %408 = fmul <2 x float> %407, %404
  store <2 x float> %408, ptr %405, align 8
  %indvars.iv.next218 = add nuw nsw i64 %indvars.iv217, 1
  %exitcond220.not = icmp eq i64 %indvars.iv.next218, 48
  br i1 %exitcond220.not, label %409, label %394, !llvm.loop !9

409:                                              ; preds = %394
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %0) #7
  %410 = getelementptr inbounds i8, ptr %388, i64 24
  %411 = getelementptr inbounds i8, ptr %388, i64 16
  %412 = getelementptr inbounds i8, ptr %388, i64 8
  %413 = getelementptr inbounds i8, ptr %387, i64 16
  br label %.preheader182

.preheader182:                                    ; preds = %409, %.preheader182
  %indvars.iv233 = phi i64 [ 0, %409 ], [ %indvars.iv.next234, %.preheader182 ]
  %414 = shl nuw nsw i64 %indvars.iv233, 2
  %415 = getelementptr inbounds { float, float }, ptr %391, i64 %414
  %416 = load <2 x float>, ptr %415, align 16
  %417 = call i32 @windowcf_push(ptr noundef %355, <2 x float> noundef %416) #7
  %418 = or disjoint i64 %414, 1
  %419 = getelementptr inbounds { float, float }, ptr %391, i64 %418
  %420 = load <2 x float>, ptr %419, align 8
  %421 = call i32 @windowcf_push(ptr noundef %311, <2 x float> noundef %420) #7
  %422 = or disjoint i64 %414, 2
  %423 = getelementptr inbounds { float, float }, ptr %391, i64 %422
  %424 = load <2 x float>, ptr %423, align 16
  %425 = call i32 @windowcf_push(ptr noundef %267, <2 x float> noundef %424) #7
  %426 = or disjoint i64 %414, 3
  %427 = getelementptr inbounds { float, float }, ptr %391, i64 %426
  %428 = load <2 x float>, ptr %427, align 8
  %429 = call i32 @windowcf_push(ptr noundef %223, <2 x float> noundef %428) #7
  %430 = call i32 @windowcf_read(ptr noundef %223, ptr noundef nonnull %0) #7
  %431 = load ptr, ptr %0, align 8, !tbaa !11
  %432 = call i32 @dotprod_crcf_execute(ptr noundef %222, ptr noundef %431, ptr noundef nonnull %410) #7
  %433 = call i32 @windowcf_read(ptr noundef %267, ptr noundef nonnull %0) #7
  %434 = load ptr, ptr %0, align 8, !tbaa !11
  %435 = call i32 @dotprod_crcf_execute(ptr noundef %266, ptr noundef %434, ptr noundef nonnull %411) #7
  %436 = call i32 @windowcf_read(ptr noundef %311, ptr noundef nonnull %0) #7
  %437 = load ptr, ptr %0, align 8, !tbaa !11
  %438 = call i32 @dotprod_crcf_execute(ptr noundef %310, ptr noundef %437, ptr noundef nonnull %412) #7
  %439 = call i32 @windowcf_read(ptr noundef %355, ptr noundef nonnull %0) #7
  %440 = load ptr, ptr %0, align 8, !tbaa !11
  %441 = call i32 @dotprod_crcf_execute(ptr noundef %354, ptr noundef %440, ptr noundef nonnull %388) #7
  %442 = call i32 @fft_execute(ptr noundef %389) #7
  %443 = getelementptr inbounds { float, float }, ptr %392, i64 %414
  %444 = load <4 x float>, ptr %387, align 16
  store <4 x float> %444, ptr %443, align 16
  %445 = getelementptr inbounds i8, ptr %443, i64 16
  %446 = load <4 x float>, ptr %413, align 16
  store <4 x float> %446, ptr %445, align 16
  %indvars.iv.next234 = add nuw nsw i64 %indvars.iv233, 1
  %exitcond236.not = icmp eq i64 %indvars.iv.next234, 12
  br i1 %exitcond236.not, label %.preheader180.preheader, label %.preheader182, !llvm.loop !13

.preheader180.preheader:                          ; preds = %.preheader182
  %447 = call i32 @firfilt_crcf_reset(ptr noundef %390) #7
  br label %580

.preheader180.1:                                  ; preds = %614
  %448 = call i32 @firfilt_crcf_reset(ptr noundef %390) #7
  %invariant.gep.1 = getelementptr inbounds i8, ptr %393, i64 8
  br label %449

449:                                              ; preds = %485, %.preheader180.1
  %indvars.iv237.1 = phi i64 [ 0, %.preheader180.1 ], [ %indvars.iv.next238.1, %485 ]
  %.0178197.1 = phi i32 [ 0, %.preheader180.1 ], [ %.1179.1, %485 ]
  %450 = getelementptr inbounds { float, float }, ptr %391, i64 %indvars.iv237.1
  %451 = trunc nuw nsw i64 %indvars.iv237.1 to i32
  %452 = uitofp nneg i32 %451 to float
  %453 = fmul float %452, 0xBFF921FB60000000
  %.sroa.08.4.vec.insert.1 = insertelement <2 x float> <float -0.000000e+00, float poison>, float %453, i64 1
  %454 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.08.4.vec.insert.1) #7
  %455 = load <2 x float>, ptr %450, align 8
  %456 = fmul <2 x float> %455, %454
  %457 = shufflevector <2 x float> %454, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %458 = fmul <2 x float> %455, %457
  %shift = shufflevector <2 x float> %456, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %459 = fsub <2 x float> %456, %shift
  %460 = extractelement <2 x float> %459, i64 0
  %shift322 = shufflevector <2 x float> %458, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %461 = fadd <2 x float> %458, %shift322
  %462 = extractelement <2 x float> %461, i64 0
  %463 = fcmp uno float %460, 0.000000e+00
  br i1 %463, label %464, label %472, !prof !14

464:                                              ; preds = %449
  %465 = fcmp uno float %462, 0.000000e+00
  br i1 %465, label %466, label %472, !prof !14

466:                                              ; preds = %464
  %467 = extractelement <2 x float> %455, i64 0
  %468 = extractelement <2 x float> %455, i64 1
  %469 = extractelement <2 x float> %454, i64 0
  %470 = extractelement <2 x float> %454, i64 1
  %471 = call <2 x float> @__mulsc3(float noundef %467, float noundef %468, float noundef %469, float noundef %470) #7
  %.sroa.06.0.vec.extract.1 = extractelement <2 x float> %471, i64 0
  %.sroa.06.4.vec.extract.1 = extractelement <2 x float> %471, i64 1
  br label %472

472:                                              ; preds = %466, %464, %449
  %473 = phi float [ %460, %449 ], [ %460, %464 ], [ %.sroa.06.0.vec.extract.1, %466 ]
  %474 = phi float [ %462, %449 ], [ %462, %464 ], [ %.sroa.06.4.vec.extract.1, %466 ]
  %.sroa.04.0.vec.insert.1 = insertelement <2 x float> poison, float %473, i64 0
  %.sroa.04.4.vec.insert.1 = insertelement <2 x float> %.sroa.04.0.vec.insert.1, float %474, i64 1
  %475 = call i32 @firfilt_crcf_push(ptr noundef %390, <2 x float> noundef %.sroa.04.4.vec.insert.1) #7
  %476 = icmp ult i32 %.0178197.1, 12
  br i1 %476, label %477, label %.loopexit

477:                                              ; preds = %472
  %indvars.iv.next238.1 = add nuw nsw i64 %indvars.iv237.1, 1
  %478 = and i64 %indvars.iv.next238.1, 3
  %479 = icmp eq i64 %478, 0
  br i1 %479, label %480, label %485

480:                                              ; preds = %477
  %481 = shl nuw nsw i32 %.0178197.1, 2
  %482 = zext nneg i32 %481 to i64
  %gep.1 = getelementptr inbounds { float, float }, ptr %invariant.gep.1, i64 %482
  %483 = call i32 @firfilt_crcf_execute(ptr noundef %390, ptr noundef nonnull %gep.1) #7
  %484 = add nuw nsw i32 %.0178197.1, 1
  br label %485

485:                                              ; preds = %480, %477
  %.1179.1 = phi i32 [ %484, %480 ], [ %.0178197.1, %477 ]
  %exitcond240.1.not = icmp eq i64 %indvars.iv.next238.1, 48
  br i1 %exitcond240.1.not, label %486, label %449, !llvm.loop !15

486:                                              ; preds = %485
  %487 = icmp eq i32 %.1179.1, 12
  br i1 %487, label %.preheader180.2, label %616

.preheader180.2:                                  ; preds = %486
  %488 = call i32 @firfilt_crcf_reset(ptr noundef %390) #7
  %invariant.gep.2 = getelementptr inbounds i8, ptr %393, i64 16
  br label %489

489:                                              ; preds = %525, %.preheader180.2
  %indvars.iv237.2 = phi i64 [ 0, %.preheader180.2 ], [ %indvars.iv.next238.2, %525 ]
  %.0178197.2 = phi i32 [ 0, %.preheader180.2 ], [ %.1179.2, %525 ]
  %490 = getelementptr inbounds { float, float }, ptr %391, i64 %indvars.iv237.2
  %491 = trunc nuw nsw i64 %indvars.iv237.2 to i32
  %492 = uitofp nneg i32 %491 to float
  %493 = fmul float %492, 0xC00921FB60000000
  %.sroa.08.4.vec.insert.2 = insertelement <2 x float> <float -0.000000e+00, float poison>, float %493, i64 1
  %494 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.08.4.vec.insert.2) #7
  %495 = load <2 x float>, ptr %490, align 8
  %496 = fmul <2 x float> %495, %494
  %497 = shufflevector <2 x float> %494, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %498 = fmul <2 x float> %495, %497
  %shift323 = shufflevector <2 x float> %496, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %499 = fsub <2 x float> %496, %shift323
  %500 = extractelement <2 x float> %499, i64 0
  %shift324 = shufflevector <2 x float> %498, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %501 = fadd <2 x float> %498, %shift324
  %502 = extractelement <2 x float> %501, i64 0
  %503 = fcmp uno float %500, 0.000000e+00
  br i1 %503, label %504, label %512, !prof !14

504:                                              ; preds = %489
  %505 = fcmp uno float %502, 0.000000e+00
  br i1 %505, label %506, label %512, !prof !14

506:                                              ; preds = %504
  %507 = extractelement <2 x float> %495, i64 0
  %508 = extractelement <2 x float> %495, i64 1
  %509 = extractelement <2 x float> %494, i64 0
  %510 = extractelement <2 x float> %494, i64 1
  %511 = call <2 x float> @__mulsc3(float noundef %507, float noundef %508, float noundef %509, float noundef %510) #7
  %.sroa.06.0.vec.extract.2 = extractelement <2 x float> %511, i64 0
  %.sroa.06.4.vec.extract.2 = extractelement <2 x float> %511, i64 1
  br label %512

512:                                              ; preds = %506, %504, %489
  %513 = phi float [ %500, %489 ], [ %500, %504 ], [ %.sroa.06.0.vec.extract.2, %506 ]
  %514 = phi float [ %502, %489 ], [ %502, %504 ], [ %.sroa.06.4.vec.extract.2, %506 ]
  %.sroa.04.0.vec.insert.2 = insertelement <2 x float> poison, float %513, i64 0
  %.sroa.04.4.vec.insert.2 = insertelement <2 x float> %.sroa.04.0.vec.insert.2, float %514, i64 1
  %515 = call i32 @firfilt_crcf_push(ptr noundef %390, <2 x float> noundef %.sroa.04.4.vec.insert.2) #7
  %516 = icmp ult i32 %.0178197.2, 12
  br i1 %516, label %517, label %.loopexit

517:                                              ; preds = %512
  %indvars.iv.next238.2 = add nuw nsw i64 %indvars.iv237.2, 1
  %518 = and i64 %indvars.iv.next238.2, 3
  %519 = icmp eq i64 %518, 0
  br i1 %519, label %520, label %525

520:                                              ; preds = %517
  %521 = shl nuw nsw i32 %.0178197.2, 2
  %522 = zext nneg i32 %521 to i64
  %gep.2 = getelementptr inbounds { float, float }, ptr %invariant.gep.2, i64 %522
  %523 = call i32 @firfilt_crcf_execute(ptr noundef %390, ptr noundef nonnull %gep.2) #7
  %524 = add nuw nsw i32 %.0178197.2, 1
  br label %525

525:                                              ; preds = %520, %517
  %.1179.2 = phi i32 [ %524, %520 ], [ %.0178197.2, %517 ]
  %exitcond240.2.not = icmp eq i64 %indvars.iv.next238.2, 48
  br i1 %exitcond240.2.not, label %526, label %489, !llvm.loop !15

526:                                              ; preds = %525
  %527 = icmp eq i32 %.1179.2, 12
  br i1 %527, label %.preheader180.3, label %616

.preheader180.3:                                  ; preds = %526
  %528 = call i32 @firfilt_crcf_reset(ptr noundef %390) #7
  %invariant.gep.3 = getelementptr inbounds i8, ptr %393, i64 24
  br label %529

529:                                              ; preds = %565, %.preheader180.3
  %indvars.iv237.3 = phi i64 [ 0, %.preheader180.3 ], [ %indvars.iv.next238.3, %565 ]
  %.0178197.3 = phi i32 [ 0, %.preheader180.3 ], [ %.1179.3, %565 ]
  %530 = getelementptr inbounds { float, float }, ptr %391, i64 %indvars.iv237.3
  %531 = trunc nuw nsw i64 %indvars.iv237.3 to i32
  %532 = uitofp nneg i32 %531 to float
  %533 = fmul float %532, 0xC012D97C80000000
  %.sroa.08.4.vec.insert.3 = insertelement <2 x float> <float -0.000000e+00, float poison>, float %533, i64 1
  %534 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.08.4.vec.insert.3) #7
  %535 = load <2 x float>, ptr %530, align 8
  %536 = fmul <2 x float> %535, %534
  %537 = shufflevector <2 x float> %534, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %538 = fmul <2 x float> %535, %537
  %shift325 = shufflevector <2 x float> %536, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %539 = fsub <2 x float> %536, %shift325
  %540 = extractelement <2 x float> %539, i64 0
  %shift326 = shufflevector <2 x float> %538, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %541 = fadd <2 x float> %538, %shift326
  %542 = extractelement <2 x float> %541, i64 0
  %543 = fcmp uno float %540, 0.000000e+00
  br i1 %543, label %544, label %552, !prof !14

544:                                              ; preds = %529
  %545 = fcmp uno float %542, 0.000000e+00
  br i1 %545, label %546, label %552, !prof !14

546:                                              ; preds = %544
  %547 = extractelement <2 x float> %535, i64 0
  %548 = extractelement <2 x float> %535, i64 1
  %549 = extractelement <2 x float> %534, i64 0
  %550 = extractelement <2 x float> %534, i64 1
  %551 = call <2 x float> @__mulsc3(float noundef %547, float noundef %548, float noundef %549, float noundef %550) #7
  %.sroa.06.0.vec.extract.3 = extractelement <2 x float> %551, i64 0
  %.sroa.06.4.vec.extract.3 = extractelement <2 x float> %551, i64 1
  br label %552

552:                                              ; preds = %546, %544, %529
  %553 = phi float [ %540, %529 ], [ %540, %544 ], [ %.sroa.06.0.vec.extract.3, %546 ]
  %554 = phi float [ %542, %529 ], [ %542, %544 ], [ %.sroa.06.4.vec.extract.3, %546 ]
  %.sroa.04.0.vec.insert.3 = insertelement <2 x float> poison, float %553, i64 0
  %.sroa.04.4.vec.insert.3 = insertelement <2 x float> %.sroa.04.0.vec.insert.3, float %554, i64 1
  %555 = call i32 @firfilt_crcf_push(ptr noundef %390, <2 x float> noundef %.sroa.04.4.vec.insert.3) #7
  %556 = icmp ult i32 %.0178197.3, 12
  br i1 %556, label %557, label %.loopexit

557:                                              ; preds = %552
  %indvars.iv.next238.3 = add nuw nsw i64 %indvars.iv237.3, 1
  %558 = and i64 %indvars.iv.next238.3, 3
  %559 = icmp eq i64 %558, 0
  br i1 %559, label %560, label %565

560:                                              ; preds = %557
  %561 = shl nuw nsw i32 %.0178197.3, 2
  %562 = zext nneg i32 %561 to i64
  %gep.3 = getelementptr inbounds { float, float }, ptr %invariant.gep.3, i64 %562
  %563 = call i32 @firfilt_crcf_execute(ptr noundef %390, ptr noundef nonnull %gep.3) #7
  %564 = add nuw nsw i32 %.0178197.3, 1
  br label %565

565:                                              ; preds = %560, %557
  %.1179.3 = phi i32 [ %564, %560 ], [ %.0178197.3, %557 ]
  %exitcond240.3.not = icmp eq i64 %indvars.iv.next238.3, 48
  br i1 %exitcond240.3.not, label %566, label %529, !llvm.loop !15

566:                                              ; preds = %565
  %567 = icmp eq i32 %.1179.3, 12
  br i1 %567, label %.preheader.preheader, label %616

.preheader.preheader:                             ; preds = %566
  %568 = call i32 @dotprod_crcf_destroy(ptr noundef %222) #7
  %569 = call i32 @windowcf_destroy(ptr noundef %223) #7
  %570 = call i32 @dotprod_crcf_destroy(ptr noundef %266) #7
  %571 = call i32 @windowcf_destroy(ptr noundef %267) #7
  %572 = call i32 @dotprod_crcf_destroy(ptr noundef %310) #7
  %573 = call i32 @windowcf_destroy(ptr noundef %311) #7
  %574 = call i32 @dotprod_crcf_destroy(ptr noundef %354) #7
  %575 = call i32 @windowcf_destroy(ptr noundef %355) #7
  %576 = call i32 @fft_destroy_plan(ptr noundef %389) #7
  %577 = call i32 @firfilt_crcf_destroy(ptr noundef %390) #7
  %578 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %579 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.7)
  br label %617

580:                                              ; preds = %.preheader180.preheader, %613
  %indvars.iv237 = phi i64 [ 0, %.preheader180.preheader ], [ %indvars.iv.next238, %613 ]
  %.0178197 = phi i32 [ 0, %.preheader180.preheader ], [ %.1179, %613 ]
  %581 = getelementptr inbounds { float, float }, ptr %391, i64 %indvars.iv237
  %582 = call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float -0.000000e+00>) #7
  %583 = load <2 x float>, ptr %581, align 8
  %584 = fmul <2 x float> %583, %582
  %585 = shufflevector <2 x float> %582, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %586 = fmul <2 x float> %583, %585
  %shift327 = shufflevector <2 x float> %584, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %587 = fsub <2 x float> %584, %shift327
  %588 = extractelement <2 x float> %587, i64 0
  %shift328 = shufflevector <2 x float> %586, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %589 = fadd <2 x float> %586, %shift328
  %590 = extractelement <2 x float> %589, i64 0
  %591 = fcmp uno float %588, 0.000000e+00
  br i1 %591, label %592, label %600, !prof !14

592:                                              ; preds = %580
  %593 = fcmp uno float %590, 0.000000e+00
  br i1 %593, label %594, label %600, !prof !14

594:                                              ; preds = %592
  %595 = extractelement <2 x float> %583, i64 0
  %596 = extractelement <2 x float> %583, i64 1
  %597 = extractelement <2 x float> %582, i64 0
  %598 = extractelement <2 x float> %582, i64 1
  %599 = call <2 x float> @__mulsc3(float noundef %595, float noundef %596, float noundef %597, float noundef %598) #7
  %.sroa.06.0.vec.extract = extractelement <2 x float> %599, i64 0
  %.sroa.06.4.vec.extract = extractelement <2 x float> %599, i64 1
  br label %600

600:                                              ; preds = %594, %592, %580
  %601 = phi float [ %588, %580 ], [ %588, %592 ], [ %.sroa.06.0.vec.extract, %594 ]
  %602 = phi float [ %590, %580 ], [ %590, %592 ], [ %.sroa.06.4.vec.extract, %594 ]
  %.sroa.04.0.vec.insert = insertelement <2 x float> poison, float %601, i64 0
  %.sroa.04.4.vec.insert = insertelement <2 x float> %.sroa.04.0.vec.insert, float %602, i64 1
  %603 = call i32 @firfilt_crcf_push(ptr noundef %390, <2 x float> noundef %.sroa.04.4.vec.insert) #7
  %604 = icmp ult i32 %.0178197, 12
  br i1 %604, label %605, label %.loopexit

.loopexit:                                        ; preds = %600, %472, %512, %552
  call void @__assert_fail(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.4, i32 noundef 152, ptr noundef nonnull @__PRETTY_FUNCTION__.main) #8
  unreachable

605:                                              ; preds = %600
  %indvars.iv.next238 = add nuw nsw i64 %indvars.iv237, 1
  %606 = and i64 %indvars.iv.next238, 3
  %607 = icmp eq i64 %606, 0
  br i1 %607, label %608, label %613

608:                                              ; preds = %605
  %609 = shl nuw nsw i32 %.0178197, 2
  %610 = zext nneg i32 %609 to i64
  %gep = getelementptr inbounds { float, float }, ptr %393, i64 %610
  %611 = call i32 @firfilt_crcf_execute(ptr noundef %390, ptr noundef nonnull %gep) #7
  %612 = add nuw nsw i32 %.0178197, 1
  br label %613

613:                                              ; preds = %605, %608
  %.1179 = phi i32 [ %612, %608 ], [ %.0178197, %605 ]
  %exitcond240.not = icmp eq i64 %indvars.iv.next238, 48
  br i1 %exitcond240.not, label %614, label %580, !llvm.loop !15

614:                                              ; preds = %613
  %615 = icmp eq i32 %.1179, 12
  br i1 %615, label %.preheader180.1, label %616

616:                                              ; preds = %566, %526, %486, %614
  call void @__assert_fail(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.4, i32 noundef 158, ptr noundef nonnull @__PRETTY_FUNCTION__.main) #8
  unreachable

617:                                              ; preds = %.preheader.preheader, %617
  %indvars.iv256 = phi i64 [ 0, %.preheader.preheader ], [ %indvars.iv.next257, %617 ]
  %618 = trunc nuw nsw i64 %indvars.iv256 to i32
  %619 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.8, i32 noundef %618)
  %.idx = shl nsw i64 %indvars.iv256, 5
  %620 = getelementptr inbounds i8, ptr %392, i64 %.idx
  %621 = load float, ptr %620, align 16
  %622 = getelementptr inbounds i8, ptr %620, i64 4
  %623 = fpext float %621 to double
  %624 = load float, ptr %622, align 4
  %625 = fpext float %624 to double
  %626 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %623, double noundef %625)
  %627 = getelementptr inbounds i8, ptr %620, i64 8
  %628 = load float, ptr %627, align 8
  %629 = getelementptr inbounds i8, ptr %620, i64 12
  %630 = fpext float %628 to double
  %631 = load float, ptr %629, align 4
  %632 = fpext float %631 to double
  %633 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %630, double noundef %632)
  %634 = getelementptr inbounds i8, ptr %620, i64 16
  %635 = load float, ptr %634, align 16
  %636 = getelementptr inbounds i8, ptr %620, i64 20
  %637 = fpext float %635 to double
  %638 = load float, ptr %636, align 4
  %639 = fpext float %638 to double
  %640 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %637, double noundef %639)
  %641 = getelementptr inbounds i8, ptr %620, i64 24
  %642 = load float, ptr %641, align 8
  %643 = getelementptr inbounds i8, ptr %620, i64 28
  %644 = fpext float %642 to double
  %645 = load float, ptr %643, align 4
  %646 = fpext float %645 to double
  %647 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %644, double noundef %646)
  %648 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %indvars.iv.next257 = add nuw nsw i64 %indvars.iv256, 1
  %exitcond259.not = icmp eq i64 %indvars.iv.next257, 12
  br i1 %exitcond259.not, label %649, label %617, !llvm.loop !16

649:                                              ; preds = %617
  %650 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %651 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.10)
  br label %652

652:                                              ; preds = %649, %652
  %indvars.iv264 = phi i64 [ 0, %649 ], [ %indvars.iv.next265, %652 ]
  %653 = trunc nuw nsw i64 %indvars.iv264 to i32
  %654 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.8, i32 noundef %653)
  %.idx292 = shl nsw i64 %indvars.iv264, 5
  %655 = getelementptr inbounds i8, ptr %393, i64 %.idx292
  %656 = load float, ptr %655, align 16
  %657 = getelementptr inbounds i8, ptr %655, i64 4
  %658 = fpext float %656 to double
  %659 = load float, ptr %657, align 4
  %660 = fpext float %659 to double
  %661 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %658, double noundef %660)
  %662 = getelementptr inbounds i8, ptr %655, i64 8
  %663 = load float, ptr %662, align 8
  %664 = getelementptr inbounds i8, ptr %655, i64 12
  %665 = fpext float %663 to double
  %666 = load float, ptr %664, align 4
  %667 = fpext float %666 to double
  %668 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %665, double noundef %667)
  %669 = getelementptr inbounds i8, ptr %655, i64 16
  %670 = load float, ptr %669, align 16
  %671 = getelementptr inbounds i8, ptr %655, i64 20
  %672 = fpext float %670 to double
  %673 = load float, ptr %671, align 4
  %674 = fpext float %673 to double
  %675 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %672, double noundef %674)
  %676 = getelementptr inbounds i8, ptr %655, i64 24
  %677 = load float, ptr %676, align 8
  %678 = getelementptr inbounds i8, ptr %655, i64 28
  %679 = fpext float %677 to double
  %680 = load float, ptr %678, align 4
  %681 = fpext float %680 to double
  %682 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, double noundef %679, double noundef %681)
  %683 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %indvars.iv.next265 = add nuw nsw i64 %indvars.iv264, 1
  %exitcond267.not = icmp eq i64 %indvars.iv.next265, 12
  br i1 %exitcond267.not, label %.preheader, label %652, !llvm.loop !17

.preheader:                                       ; preds = %652
  %684 = load <2 x float>, ptr %392, align 16
  %685 = load <2 x float>, ptr %393, align 16
  %686 = fsub <2 x float> %684, %685
  %687 = extractelement <2 x float> %686, i64 1
  %688 = fneg float %687
  %689 = fmul <2 x float> %686, %686
  %shift329 = shufflevector <2 x float> %689, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %690 = fadd <2 x float> %689, %shift329
  %691 = extractelement <2 x float> %690, i64 0
  %692 = fcmp uno float %691, 0.000000e+00
  br i1 %692, label %693, label %.preheader.1, !prof !14

693:                                              ; preds = %.preheader
  %694 = extractelement <2 x float> %686, i64 0
  %695 = fmul float %694, %687
  %696 = fsub float %695, %695
  %697 = fcmp uno float %696, 0.000000e+00
  br i1 %697, label %698, label %.preheader.1, !prof !14

698:                                              ; preds = %693
  %699 = call <2 x float> @__mulsc3(float noundef %694, float noundef %687, float noundef %694, float noundef %688) #7
  %.sroa.0.0.vec.extract = extractelement <2 x float> %699, i64 0
  br label %.preheader.1

.preheader.1:                                     ; preds = %698, %693, %.preheader
  %700 = phi float [ %691, %.preheader ], [ %691, %693 ], [ %.sroa.0.0.vec.extract, %698 ]
  %gep206.1341 = getelementptr inbounds i8, ptr %392, i64 32
  %gep208.1342 = getelementptr inbounds i8, ptr %393, i64 32
  %701 = load <2 x float>, ptr %gep206.1341, align 16
  %702 = load <2 x float>, ptr %gep208.1342, align 16
  %703 = fsub <2 x float> %701, %702
  %704 = extractelement <2 x float> %703, i64 1
  %705 = fneg float %704
  %706 = fmul <2 x float> %703, %703
  %shift329.1 = shufflevector <2 x float> %706, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %707 = fadd <2 x float> %706, %shift329.1
  %708 = extractelement <2 x float> %707, i64 0
  %709 = fcmp uno float %708, 0.000000e+00
  br i1 %709, label %710, label %.preheader.2, !prof !14

710:                                              ; preds = %.preheader.1
  %711 = extractelement <2 x float> %703, i64 0
  %712 = fmul float %711, %704
  %713 = fsub float %712, %712
  %714 = fcmp uno float %713, 0.000000e+00
  br i1 %714, label %715, label %.preheader.2, !prof !14

715:                                              ; preds = %710
  %716 = call <2 x float> @__mulsc3(float noundef %711, float noundef %704, float noundef %711, float noundef %705) #7
  %.sroa.0.0.vec.extract.1343 = extractelement <2 x float> %716, i64 0
  br label %.preheader.2

.preheader.2:                                     ; preds = %715, %710, %.preheader.1
  %717 = phi float [ %708, %.preheader.1 ], [ %708, %710 ], [ %.sroa.0.0.vec.extract.1343, %715 ]
  %gep206.2346 = getelementptr inbounds i8, ptr %392, i64 64
  %gep208.2347 = getelementptr inbounds i8, ptr %393, i64 64
  %718 = load <2 x float>, ptr %gep206.2346, align 16
  %719 = load <2 x float>, ptr %gep208.2347, align 16
  %720 = fsub <2 x float> %718, %719
  %721 = extractelement <2 x float> %720, i64 1
  %722 = fneg float %721
  %723 = fmul <2 x float> %720, %720
  %shift329.2 = shufflevector <2 x float> %723, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %724 = fadd <2 x float> %723, %shift329.2
  %725 = extractelement <2 x float> %724, i64 0
  %726 = fcmp uno float %725, 0.000000e+00
  br i1 %726, label %727, label %.preheader.3, !prof !14

727:                                              ; preds = %.preheader.2
  %728 = extractelement <2 x float> %720, i64 0
  %729 = fmul float %728, %721
  %730 = fsub float %729, %729
  %731 = fcmp uno float %730, 0.000000e+00
  br i1 %731, label %732, label %.preheader.3, !prof !14

732:                                              ; preds = %727
  %733 = call <2 x float> @__mulsc3(float noundef %728, float noundef %721, float noundef %728, float noundef %722) #7
  %.sroa.0.0.vec.extract.2348 = extractelement <2 x float> %733, i64 0
  br label %.preheader.3

.preheader.3:                                     ; preds = %732, %727, %.preheader.2
  %734 = phi float [ %725, %.preheader.2 ], [ %725, %727 ], [ %.sroa.0.0.vec.extract.2348, %732 ]
  %gep206.3351 = getelementptr inbounds i8, ptr %392, i64 96
  %gep208.3352 = getelementptr inbounds i8, ptr %393, i64 96
  %735 = load <2 x float>, ptr %gep206.3351, align 16
  %736 = load <2 x float>, ptr %gep208.3352, align 16
  %737 = fsub <2 x float> %735, %736
  %738 = extractelement <2 x float> %737, i64 1
  %739 = fneg float %738
  %740 = fmul <2 x float> %737, %737
  %shift329.3 = shufflevector <2 x float> %740, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %741 = fadd <2 x float> %740, %shift329.3
  %742 = extractelement <2 x float> %741, i64 0
  %743 = fcmp uno float %742, 0.000000e+00
  br i1 %743, label %744, label %.preheader.4, !prof !14

744:                                              ; preds = %.preheader.3
  %745 = extractelement <2 x float> %737, i64 0
  %746 = fmul float %745, %738
  %747 = fsub float %746, %746
  %748 = fcmp uno float %747, 0.000000e+00
  br i1 %748, label %749, label %.preheader.4, !prof !14

749:                                              ; preds = %744
  %750 = call <2 x float> @__mulsc3(float noundef %745, float noundef %738, float noundef %745, float noundef %739) #7
  %.sroa.0.0.vec.extract.3353 = extractelement <2 x float> %750, i64 0
  br label %.preheader.4

.preheader.4:                                     ; preds = %749, %744, %.preheader.3
  %751 = phi float [ %742, %.preheader.3 ], [ %742, %744 ], [ %.sroa.0.0.vec.extract.3353, %749 ]
  %gep206.4 = getelementptr inbounds i8, ptr %392, i64 128
  %gep208.4 = getelementptr inbounds i8, ptr %393, i64 128
  %752 = load <2 x float>, ptr %gep206.4, align 16
  %753 = load <2 x float>, ptr %gep208.4, align 16
  %754 = fsub <2 x float> %752, %753
  %755 = extractelement <2 x float> %754, i64 1
  %756 = fneg float %755
  %757 = fmul <2 x float> %754, %754
  %shift329.4 = shufflevector <2 x float> %757, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %758 = fadd <2 x float> %757, %shift329.4
  %759 = extractelement <2 x float> %758, i64 0
  %760 = fcmp uno float %759, 0.000000e+00
  br i1 %760, label %761, label %.preheader.5, !prof !14

761:                                              ; preds = %.preheader.4
  %762 = extractelement <2 x float> %754, i64 0
  %763 = fmul float %762, %755
  %764 = fsub float %763, %763
  %765 = fcmp uno float %764, 0.000000e+00
  br i1 %765, label %766, label %.preheader.5, !prof !14

766:                                              ; preds = %761
  %767 = call <2 x float> @__mulsc3(float noundef %762, float noundef %755, float noundef %762, float noundef %756) #7
  %.sroa.0.0.vec.extract.4 = extractelement <2 x float> %767, i64 0
  br label %.preheader.5

.preheader.5:                                     ; preds = %766, %761, %.preheader.4
  %768 = phi float [ %759, %.preheader.4 ], [ %759, %761 ], [ %.sroa.0.0.vec.extract.4, %766 ]
  %gep206.5 = getelementptr inbounds i8, ptr %392, i64 160
  %gep208.5 = getelementptr inbounds i8, ptr %393, i64 160
  %769 = load <2 x float>, ptr %gep206.5, align 16
  %770 = load <2 x float>, ptr %gep208.5, align 16
  %771 = fsub <2 x float> %769, %770
  %772 = extractelement <2 x float> %771, i64 1
  %773 = fneg float %772
  %774 = fmul <2 x float> %771, %771
  %shift329.5 = shufflevector <2 x float> %774, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %775 = fadd <2 x float> %774, %shift329.5
  %776 = extractelement <2 x float> %775, i64 0
  %777 = fcmp uno float %776, 0.000000e+00
  br i1 %777, label %778, label %.preheader.6, !prof !14

778:                                              ; preds = %.preheader.5
  %779 = extractelement <2 x float> %771, i64 0
  %780 = fmul float %779, %772
  %781 = fsub float %780, %780
  %782 = fcmp uno float %781, 0.000000e+00
  br i1 %782, label %783, label %.preheader.6, !prof !14

783:                                              ; preds = %778
  %784 = call <2 x float> @__mulsc3(float noundef %779, float noundef %772, float noundef %779, float noundef %773) #7
  %.sroa.0.0.vec.extract.5 = extractelement <2 x float> %784, i64 0
  br label %.preheader.6

.preheader.6:                                     ; preds = %783, %778, %.preheader.5
  %785 = phi float [ %776, %.preheader.5 ], [ %776, %778 ], [ %.sroa.0.0.vec.extract.5, %783 ]
  %gep206.6 = getelementptr inbounds i8, ptr %392, i64 192
  %gep208.6 = getelementptr inbounds i8, ptr %393, i64 192
  %786 = load <2 x float>, ptr %gep206.6, align 16
  %787 = load <2 x float>, ptr %gep208.6, align 16
  %788 = fsub <2 x float> %786, %787
  %789 = extractelement <2 x float> %788, i64 1
  %790 = fneg float %789
  %791 = fmul <2 x float> %788, %788
  %shift329.6 = shufflevector <2 x float> %791, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %792 = fadd <2 x float> %791, %shift329.6
  %793 = extractelement <2 x float> %792, i64 0
  %794 = fcmp uno float %793, 0.000000e+00
  br i1 %794, label %795, label %.preheader.7, !prof !14

795:                                              ; preds = %.preheader.6
  %796 = extractelement <2 x float> %788, i64 0
  %797 = fmul float %796, %789
  %798 = fsub float %797, %797
  %799 = fcmp uno float %798, 0.000000e+00
  br i1 %799, label %800, label %.preheader.7, !prof !14

800:                                              ; preds = %795
  %801 = call <2 x float> @__mulsc3(float noundef %796, float noundef %789, float noundef %796, float noundef %790) #7
  %.sroa.0.0.vec.extract.6 = extractelement <2 x float> %801, i64 0
  br label %.preheader.7

.preheader.7:                                     ; preds = %800, %795, %.preheader.6
  %802 = phi float [ %793, %.preheader.6 ], [ %793, %795 ], [ %.sroa.0.0.vec.extract.6, %800 ]
  %gep206.7 = getelementptr inbounds i8, ptr %392, i64 224
  %gep208.7 = getelementptr inbounds i8, ptr %393, i64 224
  %803 = load <2 x float>, ptr %gep206.7, align 16
  %804 = load <2 x float>, ptr %gep208.7, align 16
  %805 = fsub <2 x float> %803, %804
  %806 = extractelement <2 x float> %805, i64 1
  %807 = fneg float %806
  %808 = fmul <2 x float> %805, %805
  %shift329.7 = shufflevector <2 x float> %808, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %809 = fadd <2 x float> %808, %shift329.7
  %810 = extractelement <2 x float> %809, i64 0
  %811 = fcmp uno float %810, 0.000000e+00
  br i1 %811, label %812, label %.preheader.8, !prof !14

812:                                              ; preds = %.preheader.7
  %813 = extractelement <2 x float> %805, i64 0
  %814 = fmul float %813, %806
  %815 = fsub float %814, %814
  %816 = fcmp uno float %815, 0.000000e+00
  br i1 %816, label %817, label %.preheader.8, !prof !14

817:                                              ; preds = %812
  %818 = call <2 x float> @__mulsc3(float noundef %813, float noundef %806, float noundef %813, float noundef %807) #7
  %.sroa.0.0.vec.extract.7 = extractelement <2 x float> %818, i64 0
  br label %.preheader.8

.preheader.8:                                     ; preds = %817, %812, %.preheader.7
  %819 = phi float [ %810, %.preheader.7 ], [ %810, %812 ], [ %.sroa.0.0.vec.extract.7, %817 ]
  %gep206.8 = getelementptr inbounds i8, ptr %392, i64 256
  %gep208.8 = getelementptr inbounds i8, ptr %393, i64 256
  %820 = load <2 x float>, ptr %gep206.8, align 16
  %821 = load <2 x float>, ptr %gep208.8, align 16
  %822 = fsub <2 x float> %820, %821
  %823 = extractelement <2 x float> %822, i64 1
  %824 = fneg float %823
  %825 = fmul <2 x float> %822, %822
  %shift329.8 = shufflevector <2 x float> %825, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %826 = fadd <2 x float> %825, %shift329.8
  %827 = extractelement <2 x float> %826, i64 0
  %828 = fcmp uno float %827, 0.000000e+00
  br i1 %828, label %829, label %.preheader.9, !prof !14

829:                                              ; preds = %.preheader.8
  %830 = extractelement <2 x float> %822, i64 0
  %831 = fmul float %830, %823
  %832 = fsub float %831, %831
  %833 = fcmp uno float %832, 0.000000e+00
  br i1 %833, label %834, label %.preheader.9, !prof !14

834:                                              ; preds = %829
  %835 = call <2 x float> @__mulsc3(float noundef %830, float noundef %823, float noundef %830, float noundef %824) #7
  %.sroa.0.0.vec.extract.8 = extractelement <2 x float> %835, i64 0
  br label %.preheader.9

.preheader.9:                                     ; preds = %834, %829, %.preheader.8
  %836 = phi float [ %827, %.preheader.8 ], [ %827, %829 ], [ %.sroa.0.0.vec.extract.8, %834 ]
  %gep206.9 = getelementptr inbounds i8, ptr %392, i64 288
  %gep208.9 = getelementptr inbounds i8, ptr %393, i64 288
  %837 = load <2 x float>, ptr %gep206.9, align 16
  %838 = load <2 x float>, ptr %gep208.9, align 16
  %839 = fsub <2 x float> %837, %838
  %840 = extractelement <2 x float> %839, i64 1
  %841 = fneg float %840
  %842 = fmul <2 x float> %839, %839
  %shift329.9 = shufflevector <2 x float> %842, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %843 = fadd <2 x float> %842, %shift329.9
  %844 = extractelement <2 x float> %843, i64 0
  %845 = fcmp uno float %844, 0.000000e+00
  br i1 %845, label %846, label %.preheader.10, !prof !14

846:                                              ; preds = %.preheader.9
  %847 = extractelement <2 x float> %839, i64 0
  %848 = fmul float %847, %840
  %849 = fsub float %848, %848
  %850 = fcmp uno float %849, 0.000000e+00
  br i1 %850, label %851, label %.preheader.10, !prof !14

851:                                              ; preds = %846
  %852 = call <2 x float> @__mulsc3(float noundef %847, float noundef %840, float noundef %847, float noundef %841) #7
  %.sroa.0.0.vec.extract.9 = extractelement <2 x float> %852, i64 0
  br label %.preheader.10

.preheader.10:                                    ; preds = %851, %846, %.preheader.9
  %853 = phi float [ %844, %.preheader.9 ], [ %844, %846 ], [ %.sroa.0.0.vec.extract.9, %851 ]
  %gep206.10 = getelementptr inbounds i8, ptr %392, i64 320
  %gep208.10 = getelementptr inbounds i8, ptr %393, i64 320
  %854 = load <2 x float>, ptr %gep206.10, align 16
  %855 = load <2 x float>, ptr %gep208.10, align 16
  %856 = fsub <2 x float> %854, %855
  %857 = extractelement <2 x float> %856, i64 1
  %858 = fneg float %857
  %859 = fmul <2 x float> %856, %856
  %shift329.10 = shufflevector <2 x float> %859, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %860 = fadd <2 x float> %859, %shift329.10
  %861 = extractelement <2 x float> %860, i64 0
  %862 = fcmp uno float %861, 0.000000e+00
  br i1 %862, label %863, label %.preheader.11, !prof !14

863:                                              ; preds = %.preheader.10
  %864 = extractelement <2 x float> %856, i64 0
  %865 = fmul float %864, %857
  %866 = fsub float %865, %865
  %867 = fcmp uno float %866, 0.000000e+00
  br i1 %867, label %868, label %.preheader.11, !prof !14

868:                                              ; preds = %863
  %869 = call <2 x float> @__mulsc3(float noundef %864, float noundef %857, float noundef %864, float noundef %858) #7
  %.sroa.0.0.vec.extract.10 = extractelement <2 x float> %869, i64 0
  br label %.preheader.11

.preheader.11:                                    ; preds = %868, %863, %.preheader.10
  %870 = phi float [ %861, %.preheader.10 ], [ %861, %863 ], [ %.sroa.0.0.vec.extract.10, %868 ]
  %gep206.11 = getelementptr inbounds i8, ptr %392, i64 352
  %gep208.11 = getelementptr inbounds i8, ptr %393, i64 352
  %871 = load <2 x float>, ptr %gep206.11, align 16
  %872 = load <2 x float>, ptr %gep208.11, align 16
  %873 = fsub <2 x float> %871, %872
  %874 = extractelement <2 x float> %873, i64 1
  %875 = fneg float %874
  %876 = fmul <2 x float> %873, %873
  %shift329.11 = shufflevector <2 x float> %876, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %877 = fadd <2 x float> %876, %shift329.11
  %878 = extractelement <2 x float> %877, i64 0
  %879 = fcmp uno float %878, 0.000000e+00
  br i1 %879, label %880, label %887, !prof !14

880:                                              ; preds = %.preheader.11
  %881 = extractelement <2 x float> %873, i64 0
  %882 = fmul float %881, %874
  %883 = fsub float %882, %882
  %884 = fcmp uno float %883, 0.000000e+00
  br i1 %884, label %885, label %887, !prof !14

885:                                              ; preds = %880
  %886 = call <2 x float> @__mulsc3(float noundef %881, float noundef %874, float noundef %881, float noundef %875) #7
  %.sroa.0.0.vec.extract.11 = extractelement <2 x float> %886, i64 0
  br label %887

887:                                              ; preds = %.preheader.11, %880, %885
  %888 = phi float [ %878, %.preheader.11 ], [ %878, %880 ], [ %.sroa.0.0.vec.extract.11, %885 ]
  %invariant.gep205.1 = getelementptr inbounds i8, ptr %392, i64 8
  %889 = load <2 x float>, ptr %invariant.gep205.1, align 8
  %890 = load <2 x float>, ptr %invariant.gep.1, align 8
  %891 = fsub <2 x float> %889, %890
  %892 = extractelement <2 x float> %891, i64 1
  %893 = fneg float %892
  %894 = fmul <2 x float> %891, %891
  %shift330 = shufflevector <2 x float> %894, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %895 = fadd <2 x float> %894, %shift330
  %896 = extractelement <2 x float> %895, i64 0
  %897 = fcmp uno float %896, 0.000000e+00
  br i1 %897, label %898, label %905, !prof !14

898:                                              ; preds = %887
  %899 = extractelement <2 x float> %891, i64 0
  %900 = fmul float %899, %892
  %901 = fsub float %900, %900
  %902 = fcmp uno float %901, 0.000000e+00
  br i1 %902, label %903, label %905, !prof !14

903:                                              ; preds = %898
  %904 = call <2 x float> @__mulsc3(float noundef %899, float noundef %892, float noundef %899, float noundef %893) #7
  %.sroa.0.0.vec.extract.1 = extractelement <2 x float> %904, i64 0
  br label %905

905:                                              ; preds = %903, %898, %887
  %906 = phi float [ %896, %887 ], [ %896, %898 ], [ %.sroa.0.0.vec.extract.1, %903 ]
  %gep206.1.1 = getelementptr inbounds i8, ptr %392, i64 40
  %gep208.1.1 = getelementptr inbounds i8, ptr %393, i64 40
  %907 = load <2 x float>, ptr %gep206.1.1, align 8
  %908 = load <2 x float>, ptr %gep208.1.1, align 8
  %909 = fsub <2 x float> %907, %908
  %910 = extractelement <2 x float> %909, i64 1
  %911 = fneg float %910
  %912 = fmul <2 x float> %909, %909
  %shift330.1 = shufflevector <2 x float> %912, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %913 = fadd <2 x float> %912, %shift330.1
  %914 = extractelement <2 x float> %913, i64 0
  %915 = fcmp uno float %914, 0.000000e+00
  br i1 %915, label %916, label %923, !prof !14

916:                                              ; preds = %905
  %917 = extractelement <2 x float> %909, i64 0
  %918 = fmul float %917, %910
  %919 = fsub float %918, %918
  %920 = fcmp uno float %919, 0.000000e+00
  br i1 %920, label %921, label %923, !prof !14

921:                                              ; preds = %916
  %922 = call <2 x float> @__mulsc3(float noundef %917, float noundef %910, float noundef %917, float noundef %911) #7
  %.sroa.0.0.vec.extract.1.1 = extractelement <2 x float> %922, i64 0
  br label %923

923:                                              ; preds = %921, %916, %905
  %924 = phi float [ %914, %905 ], [ %914, %916 ], [ %.sroa.0.0.vec.extract.1.1, %921 ]
  %gep206.1.2 = getelementptr inbounds i8, ptr %392, i64 72
  %gep208.1.2 = getelementptr inbounds i8, ptr %393, i64 72
  %925 = load <2 x float>, ptr %gep206.1.2, align 8
  %926 = load <2 x float>, ptr %gep208.1.2, align 8
  %927 = fsub <2 x float> %925, %926
  %928 = extractelement <2 x float> %927, i64 1
  %929 = fneg float %928
  %930 = fmul <2 x float> %927, %927
  %shift330.2 = shufflevector <2 x float> %930, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %931 = fadd <2 x float> %930, %shift330.2
  %932 = extractelement <2 x float> %931, i64 0
  %933 = fcmp uno float %932, 0.000000e+00
  br i1 %933, label %934, label %941, !prof !14

934:                                              ; preds = %923
  %935 = extractelement <2 x float> %927, i64 0
  %936 = fmul float %935, %928
  %937 = fsub float %936, %936
  %938 = fcmp uno float %937, 0.000000e+00
  br i1 %938, label %939, label %941, !prof !14

939:                                              ; preds = %934
  %940 = call <2 x float> @__mulsc3(float noundef %935, float noundef %928, float noundef %935, float noundef %929) #7
  %.sroa.0.0.vec.extract.1.2 = extractelement <2 x float> %940, i64 0
  br label %941

941:                                              ; preds = %939, %934, %923
  %942 = phi float [ %932, %923 ], [ %932, %934 ], [ %.sroa.0.0.vec.extract.1.2, %939 ]
  %gep206.1.3 = getelementptr inbounds i8, ptr %392, i64 104
  %gep208.1.3 = getelementptr inbounds i8, ptr %393, i64 104
  %943 = load <2 x float>, ptr %gep206.1.3, align 8
  %944 = load <2 x float>, ptr %gep208.1.3, align 8
  %945 = fsub <2 x float> %943, %944
  %946 = extractelement <2 x float> %945, i64 1
  %947 = fneg float %946
  %948 = fmul <2 x float> %945, %945
  %shift330.3 = shufflevector <2 x float> %948, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %949 = fadd <2 x float> %948, %shift330.3
  %950 = extractelement <2 x float> %949, i64 0
  %951 = fcmp uno float %950, 0.000000e+00
  br i1 %951, label %952, label %959, !prof !14

952:                                              ; preds = %941
  %953 = extractelement <2 x float> %945, i64 0
  %954 = fmul float %953, %946
  %955 = fsub float %954, %954
  %956 = fcmp uno float %955, 0.000000e+00
  br i1 %956, label %957, label %959, !prof !14

957:                                              ; preds = %952
  %958 = call <2 x float> @__mulsc3(float noundef %953, float noundef %946, float noundef %953, float noundef %947) #7
  %.sroa.0.0.vec.extract.1.3 = extractelement <2 x float> %958, i64 0
  br label %959

959:                                              ; preds = %957, %952, %941
  %960 = phi float [ %950, %941 ], [ %950, %952 ], [ %.sroa.0.0.vec.extract.1.3, %957 ]
  %gep206.1.4 = getelementptr inbounds i8, ptr %392, i64 136
  %gep208.1.4 = getelementptr inbounds i8, ptr %393, i64 136
  %961 = load <2 x float>, ptr %gep206.1.4, align 8
  %962 = load <2 x float>, ptr %gep208.1.4, align 8
  %963 = fsub <2 x float> %961, %962
  %964 = extractelement <2 x float> %963, i64 1
  %965 = fneg float %964
  %966 = fmul <2 x float> %963, %963
  %shift330.4 = shufflevector <2 x float> %966, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %967 = fadd <2 x float> %966, %shift330.4
  %968 = extractelement <2 x float> %967, i64 0
  %969 = fcmp uno float %968, 0.000000e+00
  br i1 %969, label %970, label %977, !prof !14

970:                                              ; preds = %959
  %971 = extractelement <2 x float> %963, i64 0
  %972 = fmul float %971, %964
  %973 = fsub float %972, %972
  %974 = fcmp uno float %973, 0.000000e+00
  br i1 %974, label %975, label %977, !prof !14

975:                                              ; preds = %970
  %976 = call <2 x float> @__mulsc3(float noundef %971, float noundef %964, float noundef %971, float noundef %965) #7
  %.sroa.0.0.vec.extract.1.4 = extractelement <2 x float> %976, i64 0
  br label %977

977:                                              ; preds = %975, %970, %959
  %978 = phi float [ %968, %959 ], [ %968, %970 ], [ %.sroa.0.0.vec.extract.1.4, %975 ]
  %gep206.1.5 = getelementptr inbounds i8, ptr %392, i64 168
  %gep208.1.5 = getelementptr inbounds i8, ptr %393, i64 168
  %979 = load <2 x float>, ptr %gep206.1.5, align 8
  %980 = load <2 x float>, ptr %gep208.1.5, align 8
  %981 = fsub <2 x float> %979, %980
  %982 = extractelement <2 x float> %981, i64 1
  %983 = fneg float %982
  %984 = fmul <2 x float> %981, %981
  %shift330.5 = shufflevector <2 x float> %984, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %985 = fadd <2 x float> %984, %shift330.5
  %986 = extractelement <2 x float> %985, i64 0
  %987 = fcmp uno float %986, 0.000000e+00
  br i1 %987, label %988, label %995, !prof !14

988:                                              ; preds = %977
  %989 = extractelement <2 x float> %981, i64 0
  %990 = fmul float %989, %982
  %991 = fsub float %990, %990
  %992 = fcmp uno float %991, 0.000000e+00
  br i1 %992, label %993, label %995, !prof !14

993:                                              ; preds = %988
  %994 = call <2 x float> @__mulsc3(float noundef %989, float noundef %982, float noundef %989, float noundef %983) #7
  %.sroa.0.0.vec.extract.1.5 = extractelement <2 x float> %994, i64 0
  br label %995

995:                                              ; preds = %993, %988, %977
  %996 = phi float [ %986, %977 ], [ %986, %988 ], [ %.sroa.0.0.vec.extract.1.5, %993 ]
  %gep206.1.6 = getelementptr inbounds i8, ptr %392, i64 200
  %gep208.1.6 = getelementptr inbounds i8, ptr %393, i64 200
  %997 = load <2 x float>, ptr %gep206.1.6, align 8
  %998 = load <2 x float>, ptr %gep208.1.6, align 8
  %999 = fsub <2 x float> %997, %998
  %1000 = extractelement <2 x float> %999, i64 1
  %1001 = fneg float %1000
  %1002 = fmul <2 x float> %999, %999
  %shift330.6 = shufflevector <2 x float> %1002, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1003 = fadd <2 x float> %1002, %shift330.6
  %1004 = extractelement <2 x float> %1003, i64 0
  %1005 = fcmp uno float %1004, 0.000000e+00
  br i1 %1005, label %1006, label %1013, !prof !14

1006:                                             ; preds = %995
  %1007 = extractelement <2 x float> %999, i64 0
  %1008 = fmul float %1007, %1000
  %1009 = fsub float %1008, %1008
  %1010 = fcmp uno float %1009, 0.000000e+00
  br i1 %1010, label %1011, label %1013, !prof !14

1011:                                             ; preds = %1006
  %1012 = call <2 x float> @__mulsc3(float noundef %1007, float noundef %1000, float noundef %1007, float noundef %1001) #7
  %.sroa.0.0.vec.extract.1.6 = extractelement <2 x float> %1012, i64 0
  br label %1013

1013:                                             ; preds = %1011, %1006, %995
  %1014 = phi float [ %1004, %995 ], [ %1004, %1006 ], [ %.sroa.0.0.vec.extract.1.6, %1011 ]
  %gep206.1.7 = getelementptr inbounds i8, ptr %392, i64 232
  %gep208.1.7 = getelementptr inbounds i8, ptr %393, i64 232
  %1015 = load <2 x float>, ptr %gep206.1.7, align 8
  %1016 = load <2 x float>, ptr %gep208.1.7, align 8
  %1017 = fsub <2 x float> %1015, %1016
  %1018 = extractelement <2 x float> %1017, i64 1
  %1019 = fneg float %1018
  %1020 = fmul <2 x float> %1017, %1017
  %shift330.7 = shufflevector <2 x float> %1020, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1021 = fadd <2 x float> %1020, %shift330.7
  %1022 = extractelement <2 x float> %1021, i64 0
  %1023 = fcmp uno float %1022, 0.000000e+00
  br i1 %1023, label %1024, label %1031, !prof !14

1024:                                             ; preds = %1013
  %1025 = extractelement <2 x float> %1017, i64 0
  %1026 = fmul float %1025, %1018
  %1027 = fsub float %1026, %1026
  %1028 = fcmp uno float %1027, 0.000000e+00
  br i1 %1028, label %1029, label %1031, !prof !14

1029:                                             ; preds = %1024
  %1030 = call <2 x float> @__mulsc3(float noundef %1025, float noundef %1018, float noundef %1025, float noundef %1019) #7
  %.sroa.0.0.vec.extract.1.7 = extractelement <2 x float> %1030, i64 0
  br label %1031

1031:                                             ; preds = %1029, %1024, %1013
  %1032 = phi float [ %1022, %1013 ], [ %1022, %1024 ], [ %.sroa.0.0.vec.extract.1.7, %1029 ]
  %gep206.1.8 = getelementptr inbounds i8, ptr %392, i64 264
  %gep208.1.8 = getelementptr inbounds i8, ptr %393, i64 264
  %1033 = load <2 x float>, ptr %gep206.1.8, align 8
  %1034 = load <2 x float>, ptr %gep208.1.8, align 8
  %1035 = fsub <2 x float> %1033, %1034
  %1036 = extractelement <2 x float> %1035, i64 1
  %1037 = fneg float %1036
  %1038 = fmul <2 x float> %1035, %1035
  %shift330.8 = shufflevector <2 x float> %1038, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1039 = fadd <2 x float> %1038, %shift330.8
  %1040 = extractelement <2 x float> %1039, i64 0
  %1041 = fcmp uno float %1040, 0.000000e+00
  br i1 %1041, label %1042, label %1049, !prof !14

1042:                                             ; preds = %1031
  %1043 = extractelement <2 x float> %1035, i64 0
  %1044 = fmul float %1043, %1036
  %1045 = fsub float %1044, %1044
  %1046 = fcmp uno float %1045, 0.000000e+00
  br i1 %1046, label %1047, label %1049, !prof !14

1047:                                             ; preds = %1042
  %1048 = call <2 x float> @__mulsc3(float noundef %1043, float noundef %1036, float noundef %1043, float noundef %1037) #7
  %.sroa.0.0.vec.extract.1.8 = extractelement <2 x float> %1048, i64 0
  br label %1049

1049:                                             ; preds = %1047, %1042, %1031
  %1050 = phi float [ %1040, %1031 ], [ %1040, %1042 ], [ %.sroa.0.0.vec.extract.1.8, %1047 ]
  %gep206.1.9 = getelementptr inbounds i8, ptr %392, i64 296
  %gep208.1.9 = getelementptr inbounds i8, ptr %393, i64 296
  %1051 = load <2 x float>, ptr %gep206.1.9, align 8
  %1052 = load <2 x float>, ptr %gep208.1.9, align 8
  %1053 = fsub <2 x float> %1051, %1052
  %1054 = extractelement <2 x float> %1053, i64 1
  %1055 = fneg float %1054
  %1056 = fmul <2 x float> %1053, %1053
  %shift330.9 = shufflevector <2 x float> %1056, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1057 = fadd <2 x float> %1056, %shift330.9
  %1058 = extractelement <2 x float> %1057, i64 0
  %1059 = fcmp uno float %1058, 0.000000e+00
  br i1 %1059, label %1060, label %1067, !prof !14

1060:                                             ; preds = %1049
  %1061 = extractelement <2 x float> %1053, i64 0
  %1062 = fmul float %1061, %1054
  %1063 = fsub float %1062, %1062
  %1064 = fcmp uno float %1063, 0.000000e+00
  br i1 %1064, label %1065, label %1067, !prof !14

1065:                                             ; preds = %1060
  %1066 = call <2 x float> @__mulsc3(float noundef %1061, float noundef %1054, float noundef %1061, float noundef %1055) #7
  %.sroa.0.0.vec.extract.1.9 = extractelement <2 x float> %1066, i64 0
  br label %1067

1067:                                             ; preds = %1065, %1060, %1049
  %1068 = phi float [ %1058, %1049 ], [ %1058, %1060 ], [ %.sroa.0.0.vec.extract.1.9, %1065 ]
  %gep206.1.10 = getelementptr inbounds i8, ptr %392, i64 328
  %gep208.1.10 = getelementptr inbounds i8, ptr %393, i64 328
  %1069 = load <2 x float>, ptr %gep206.1.10, align 8
  %1070 = load <2 x float>, ptr %gep208.1.10, align 8
  %1071 = fsub <2 x float> %1069, %1070
  %1072 = extractelement <2 x float> %1071, i64 1
  %1073 = fneg float %1072
  %1074 = fmul <2 x float> %1071, %1071
  %shift330.10 = shufflevector <2 x float> %1074, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1075 = fadd <2 x float> %1074, %shift330.10
  %1076 = extractelement <2 x float> %1075, i64 0
  %1077 = fcmp uno float %1076, 0.000000e+00
  br i1 %1077, label %1078, label %1085, !prof !14

1078:                                             ; preds = %1067
  %1079 = extractelement <2 x float> %1071, i64 0
  %1080 = fmul float %1079, %1072
  %1081 = fsub float %1080, %1080
  %1082 = fcmp uno float %1081, 0.000000e+00
  br i1 %1082, label %1083, label %1085, !prof !14

1083:                                             ; preds = %1078
  %1084 = call <2 x float> @__mulsc3(float noundef %1079, float noundef %1072, float noundef %1079, float noundef %1073) #7
  %.sroa.0.0.vec.extract.1.10 = extractelement <2 x float> %1084, i64 0
  br label %1085

1085:                                             ; preds = %1083, %1078, %1067
  %1086 = phi float [ %1076, %1067 ], [ %1076, %1078 ], [ %.sroa.0.0.vec.extract.1.10, %1083 ]
  %gep206.1.11 = getelementptr inbounds i8, ptr %392, i64 360
  %gep208.1.11 = getelementptr inbounds i8, ptr %393, i64 360
  %1087 = load <2 x float>, ptr %gep206.1.11, align 8
  %1088 = load <2 x float>, ptr %gep208.1.11, align 8
  %1089 = fsub <2 x float> %1087, %1088
  %1090 = extractelement <2 x float> %1089, i64 1
  %1091 = fneg float %1090
  %1092 = fmul <2 x float> %1089, %1089
  %shift330.11 = shufflevector <2 x float> %1092, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1093 = fadd <2 x float> %1092, %shift330.11
  %1094 = extractelement <2 x float> %1093, i64 0
  %1095 = fcmp uno float %1094, 0.000000e+00
  br i1 %1095, label %1096, label %1103, !prof !14

1096:                                             ; preds = %1085
  %1097 = extractelement <2 x float> %1089, i64 0
  %1098 = fmul float %1097, %1090
  %1099 = fsub float %1098, %1098
  %1100 = fcmp uno float %1099, 0.000000e+00
  br i1 %1100, label %1101, label %1103, !prof !14

1101:                                             ; preds = %1096
  %1102 = call <2 x float> @__mulsc3(float noundef %1097, float noundef %1090, float noundef %1097, float noundef %1091) #7
  %.sroa.0.0.vec.extract.1.11 = extractelement <2 x float> %1102, i64 0
  br label %1103

1103:                                             ; preds = %1085, %1096, %1101
  %1104 = phi float [ %1094, %1085 ], [ %1094, %1096 ], [ %.sroa.0.0.vec.extract.1.11, %1101 ]
  %invariant.gep205.2 = getelementptr inbounds i8, ptr %392, i64 16
  %1105 = load <2 x float>, ptr %invariant.gep205.2, align 16
  %1106 = load <2 x float>, ptr %invariant.gep.2, align 16
  %1107 = fsub <2 x float> %1105, %1106
  %1108 = extractelement <2 x float> %1107, i64 1
  %1109 = fneg float %1108
  %1110 = fmul <2 x float> %1107, %1107
  %shift331 = shufflevector <2 x float> %1110, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1111 = fadd <2 x float> %1110, %shift331
  %1112 = extractelement <2 x float> %1111, i64 0
  %1113 = fcmp uno float %1112, 0.000000e+00
  br i1 %1113, label %1114, label %1121, !prof !14

1114:                                             ; preds = %1103
  %1115 = extractelement <2 x float> %1107, i64 0
  %1116 = fmul float %1115, %1108
  %1117 = fsub float %1116, %1116
  %1118 = fcmp uno float %1117, 0.000000e+00
  br i1 %1118, label %1119, label %1121, !prof !14

1119:                                             ; preds = %1114
  %1120 = call <2 x float> @__mulsc3(float noundef %1115, float noundef %1108, float noundef %1115, float noundef %1109) #7
  %.sroa.0.0.vec.extract.2 = extractelement <2 x float> %1120, i64 0
  br label %1121

1121:                                             ; preds = %1119, %1114, %1103
  %1122 = phi float [ %1112, %1103 ], [ %1112, %1114 ], [ %.sroa.0.0.vec.extract.2, %1119 ]
  %gep206.2.1 = getelementptr inbounds i8, ptr %392, i64 48
  %gep208.2.1 = getelementptr inbounds i8, ptr %393, i64 48
  %1123 = load <2 x float>, ptr %gep206.2.1, align 16
  %1124 = load <2 x float>, ptr %gep208.2.1, align 16
  %1125 = fsub <2 x float> %1123, %1124
  %1126 = extractelement <2 x float> %1125, i64 1
  %1127 = fneg float %1126
  %1128 = fmul <2 x float> %1125, %1125
  %shift331.1 = shufflevector <2 x float> %1128, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1129 = fadd <2 x float> %1128, %shift331.1
  %1130 = extractelement <2 x float> %1129, i64 0
  %1131 = fcmp uno float %1130, 0.000000e+00
  br i1 %1131, label %1132, label %1139, !prof !14

1132:                                             ; preds = %1121
  %1133 = extractelement <2 x float> %1125, i64 0
  %1134 = fmul float %1133, %1126
  %1135 = fsub float %1134, %1134
  %1136 = fcmp uno float %1135, 0.000000e+00
  br i1 %1136, label %1137, label %1139, !prof !14

1137:                                             ; preds = %1132
  %1138 = call <2 x float> @__mulsc3(float noundef %1133, float noundef %1126, float noundef %1133, float noundef %1127) #7
  %.sroa.0.0.vec.extract.2.1 = extractelement <2 x float> %1138, i64 0
  br label %1139

1139:                                             ; preds = %1137, %1132, %1121
  %1140 = phi float [ %1130, %1121 ], [ %1130, %1132 ], [ %.sroa.0.0.vec.extract.2.1, %1137 ]
  %gep206.2.2 = getelementptr inbounds i8, ptr %392, i64 80
  %gep208.2.2 = getelementptr inbounds i8, ptr %393, i64 80
  %1141 = load <2 x float>, ptr %gep206.2.2, align 16
  %1142 = load <2 x float>, ptr %gep208.2.2, align 16
  %1143 = fsub <2 x float> %1141, %1142
  %1144 = extractelement <2 x float> %1143, i64 1
  %1145 = fneg float %1144
  %1146 = fmul <2 x float> %1143, %1143
  %shift331.2 = shufflevector <2 x float> %1146, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1147 = fadd <2 x float> %1146, %shift331.2
  %1148 = extractelement <2 x float> %1147, i64 0
  %1149 = fcmp uno float %1148, 0.000000e+00
  br i1 %1149, label %1150, label %1157, !prof !14

1150:                                             ; preds = %1139
  %1151 = extractelement <2 x float> %1143, i64 0
  %1152 = fmul float %1151, %1144
  %1153 = fsub float %1152, %1152
  %1154 = fcmp uno float %1153, 0.000000e+00
  br i1 %1154, label %1155, label %1157, !prof !14

1155:                                             ; preds = %1150
  %1156 = call <2 x float> @__mulsc3(float noundef %1151, float noundef %1144, float noundef %1151, float noundef %1145) #7
  %.sroa.0.0.vec.extract.2.2 = extractelement <2 x float> %1156, i64 0
  br label %1157

1157:                                             ; preds = %1155, %1150, %1139
  %1158 = phi float [ %1148, %1139 ], [ %1148, %1150 ], [ %.sroa.0.0.vec.extract.2.2, %1155 ]
  %gep206.2.3 = getelementptr inbounds i8, ptr %392, i64 112
  %gep208.2.3 = getelementptr inbounds i8, ptr %393, i64 112
  %1159 = load <2 x float>, ptr %gep206.2.3, align 16
  %1160 = load <2 x float>, ptr %gep208.2.3, align 16
  %1161 = fsub <2 x float> %1159, %1160
  %1162 = extractelement <2 x float> %1161, i64 1
  %1163 = fneg float %1162
  %1164 = fmul <2 x float> %1161, %1161
  %shift331.3 = shufflevector <2 x float> %1164, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1165 = fadd <2 x float> %1164, %shift331.3
  %1166 = extractelement <2 x float> %1165, i64 0
  %1167 = fcmp uno float %1166, 0.000000e+00
  br i1 %1167, label %1168, label %1175, !prof !14

1168:                                             ; preds = %1157
  %1169 = extractelement <2 x float> %1161, i64 0
  %1170 = fmul float %1169, %1162
  %1171 = fsub float %1170, %1170
  %1172 = fcmp uno float %1171, 0.000000e+00
  br i1 %1172, label %1173, label %1175, !prof !14

1173:                                             ; preds = %1168
  %1174 = call <2 x float> @__mulsc3(float noundef %1169, float noundef %1162, float noundef %1169, float noundef %1163) #7
  %.sroa.0.0.vec.extract.2.3 = extractelement <2 x float> %1174, i64 0
  br label %1175

1175:                                             ; preds = %1173, %1168, %1157
  %1176 = phi float [ %1166, %1157 ], [ %1166, %1168 ], [ %.sroa.0.0.vec.extract.2.3, %1173 ]
  %gep206.2.4 = getelementptr inbounds i8, ptr %392, i64 144
  %gep208.2.4 = getelementptr inbounds i8, ptr %393, i64 144
  %1177 = load <2 x float>, ptr %gep206.2.4, align 16
  %1178 = load <2 x float>, ptr %gep208.2.4, align 16
  %1179 = fsub <2 x float> %1177, %1178
  %1180 = extractelement <2 x float> %1179, i64 1
  %1181 = fneg float %1180
  %1182 = fmul <2 x float> %1179, %1179
  %shift331.4 = shufflevector <2 x float> %1182, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1183 = fadd <2 x float> %1182, %shift331.4
  %1184 = extractelement <2 x float> %1183, i64 0
  %1185 = fcmp uno float %1184, 0.000000e+00
  br i1 %1185, label %1186, label %1193, !prof !14

1186:                                             ; preds = %1175
  %1187 = extractelement <2 x float> %1179, i64 0
  %1188 = fmul float %1187, %1180
  %1189 = fsub float %1188, %1188
  %1190 = fcmp uno float %1189, 0.000000e+00
  br i1 %1190, label %1191, label %1193, !prof !14

1191:                                             ; preds = %1186
  %1192 = call <2 x float> @__mulsc3(float noundef %1187, float noundef %1180, float noundef %1187, float noundef %1181) #7
  %.sroa.0.0.vec.extract.2.4 = extractelement <2 x float> %1192, i64 0
  br label %1193

1193:                                             ; preds = %1191, %1186, %1175
  %1194 = phi float [ %1184, %1175 ], [ %1184, %1186 ], [ %.sroa.0.0.vec.extract.2.4, %1191 ]
  %gep206.2.5 = getelementptr inbounds i8, ptr %392, i64 176
  %gep208.2.5 = getelementptr inbounds i8, ptr %393, i64 176
  %1195 = load <2 x float>, ptr %gep206.2.5, align 16
  %1196 = load <2 x float>, ptr %gep208.2.5, align 16
  %1197 = fsub <2 x float> %1195, %1196
  %1198 = extractelement <2 x float> %1197, i64 1
  %1199 = fneg float %1198
  %1200 = fmul <2 x float> %1197, %1197
  %shift331.5 = shufflevector <2 x float> %1200, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1201 = fadd <2 x float> %1200, %shift331.5
  %1202 = extractelement <2 x float> %1201, i64 0
  %1203 = fcmp uno float %1202, 0.000000e+00
  br i1 %1203, label %1204, label %1211, !prof !14

1204:                                             ; preds = %1193
  %1205 = extractelement <2 x float> %1197, i64 0
  %1206 = fmul float %1205, %1198
  %1207 = fsub float %1206, %1206
  %1208 = fcmp uno float %1207, 0.000000e+00
  br i1 %1208, label %1209, label %1211, !prof !14

1209:                                             ; preds = %1204
  %1210 = call <2 x float> @__mulsc3(float noundef %1205, float noundef %1198, float noundef %1205, float noundef %1199) #7
  %.sroa.0.0.vec.extract.2.5 = extractelement <2 x float> %1210, i64 0
  br label %1211

1211:                                             ; preds = %1209, %1204, %1193
  %1212 = phi float [ %1202, %1193 ], [ %1202, %1204 ], [ %.sroa.0.0.vec.extract.2.5, %1209 ]
  %gep206.2.6 = getelementptr inbounds i8, ptr %392, i64 208
  %gep208.2.6 = getelementptr inbounds i8, ptr %393, i64 208
  %1213 = load <2 x float>, ptr %gep206.2.6, align 16
  %1214 = load <2 x float>, ptr %gep208.2.6, align 16
  %1215 = fsub <2 x float> %1213, %1214
  %1216 = extractelement <2 x float> %1215, i64 1
  %1217 = fneg float %1216
  %1218 = fmul <2 x float> %1215, %1215
  %shift331.6 = shufflevector <2 x float> %1218, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1219 = fadd <2 x float> %1218, %shift331.6
  %1220 = extractelement <2 x float> %1219, i64 0
  %1221 = fcmp uno float %1220, 0.000000e+00
  br i1 %1221, label %1222, label %1229, !prof !14

1222:                                             ; preds = %1211
  %1223 = extractelement <2 x float> %1215, i64 0
  %1224 = fmul float %1223, %1216
  %1225 = fsub float %1224, %1224
  %1226 = fcmp uno float %1225, 0.000000e+00
  br i1 %1226, label %1227, label %1229, !prof !14

1227:                                             ; preds = %1222
  %1228 = call <2 x float> @__mulsc3(float noundef %1223, float noundef %1216, float noundef %1223, float noundef %1217) #7
  %.sroa.0.0.vec.extract.2.6 = extractelement <2 x float> %1228, i64 0
  br label %1229

1229:                                             ; preds = %1227, %1222, %1211
  %1230 = phi float [ %1220, %1211 ], [ %1220, %1222 ], [ %.sroa.0.0.vec.extract.2.6, %1227 ]
  %gep206.2.7 = getelementptr inbounds i8, ptr %392, i64 240
  %gep208.2.7 = getelementptr inbounds i8, ptr %393, i64 240
  %1231 = load <2 x float>, ptr %gep206.2.7, align 16
  %1232 = load <2 x float>, ptr %gep208.2.7, align 16
  %1233 = fsub <2 x float> %1231, %1232
  %1234 = extractelement <2 x float> %1233, i64 1
  %1235 = fneg float %1234
  %1236 = fmul <2 x float> %1233, %1233
  %shift331.7 = shufflevector <2 x float> %1236, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1237 = fadd <2 x float> %1236, %shift331.7
  %1238 = extractelement <2 x float> %1237, i64 0
  %1239 = fcmp uno float %1238, 0.000000e+00
  br i1 %1239, label %1240, label %1247, !prof !14

1240:                                             ; preds = %1229
  %1241 = extractelement <2 x float> %1233, i64 0
  %1242 = fmul float %1241, %1234
  %1243 = fsub float %1242, %1242
  %1244 = fcmp uno float %1243, 0.000000e+00
  br i1 %1244, label %1245, label %1247, !prof !14

1245:                                             ; preds = %1240
  %1246 = call <2 x float> @__mulsc3(float noundef %1241, float noundef %1234, float noundef %1241, float noundef %1235) #7
  %.sroa.0.0.vec.extract.2.7 = extractelement <2 x float> %1246, i64 0
  br label %1247

1247:                                             ; preds = %1245, %1240, %1229
  %1248 = phi float [ %1238, %1229 ], [ %1238, %1240 ], [ %.sroa.0.0.vec.extract.2.7, %1245 ]
  %gep206.2.8 = getelementptr inbounds i8, ptr %392, i64 272
  %gep208.2.8 = getelementptr inbounds i8, ptr %393, i64 272
  %1249 = load <2 x float>, ptr %gep206.2.8, align 16
  %1250 = load <2 x float>, ptr %gep208.2.8, align 16
  %1251 = fsub <2 x float> %1249, %1250
  %1252 = extractelement <2 x float> %1251, i64 1
  %1253 = fneg float %1252
  %1254 = fmul <2 x float> %1251, %1251
  %shift331.8 = shufflevector <2 x float> %1254, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1255 = fadd <2 x float> %1254, %shift331.8
  %1256 = extractelement <2 x float> %1255, i64 0
  %1257 = fcmp uno float %1256, 0.000000e+00
  br i1 %1257, label %1258, label %1265, !prof !14

1258:                                             ; preds = %1247
  %1259 = extractelement <2 x float> %1251, i64 0
  %1260 = fmul float %1259, %1252
  %1261 = fsub float %1260, %1260
  %1262 = fcmp uno float %1261, 0.000000e+00
  br i1 %1262, label %1263, label %1265, !prof !14

1263:                                             ; preds = %1258
  %1264 = call <2 x float> @__mulsc3(float noundef %1259, float noundef %1252, float noundef %1259, float noundef %1253) #7
  %.sroa.0.0.vec.extract.2.8 = extractelement <2 x float> %1264, i64 0
  br label %1265

1265:                                             ; preds = %1263, %1258, %1247
  %1266 = phi float [ %1256, %1247 ], [ %1256, %1258 ], [ %.sroa.0.0.vec.extract.2.8, %1263 ]
  %gep206.2.9 = getelementptr inbounds i8, ptr %392, i64 304
  %gep208.2.9 = getelementptr inbounds i8, ptr %393, i64 304
  %1267 = load <2 x float>, ptr %gep206.2.9, align 16
  %1268 = load <2 x float>, ptr %gep208.2.9, align 16
  %1269 = fsub <2 x float> %1267, %1268
  %1270 = extractelement <2 x float> %1269, i64 1
  %1271 = fneg float %1270
  %1272 = fmul <2 x float> %1269, %1269
  %shift331.9 = shufflevector <2 x float> %1272, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1273 = fadd <2 x float> %1272, %shift331.9
  %1274 = extractelement <2 x float> %1273, i64 0
  %1275 = fcmp uno float %1274, 0.000000e+00
  br i1 %1275, label %1276, label %1283, !prof !14

1276:                                             ; preds = %1265
  %1277 = extractelement <2 x float> %1269, i64 0
  %1278 = fmul float %1277, %1270
  %1279 = fsub float %1278, %1278
  %1280 = fcmp uno float %1279, 0.000000e+00
  br i1 %1280, label %1281, label %1283, !prof !14

1281:                                             ; preds = %1276
  %1282 = call <2 x float> @__mulsc3(float noundef %1277, float noundef %1270, float noundef %1277, float noundef %1271) #7
  %.sroa.0.0.vec.extract.2.9 = extractelement <2 x float> %1282, i64 0
  br label %1283

1283:                                             ; preds = %1281, %1276, %1265
  %1284 = phi float [ %1274, %1265 ], [ %1274, %1276 ], [ %.sroa.0.0.vec.extract.2.9, %1281 ]
  %gep206.2.10 = getelementptr inbounds i8, ptr %392, i64 336
  %gep208.2.10 = getelementptr inbounds i8, ptr %393, i64 336
  %1285 = load <2 x float>, ptr %gep206.2.10, align 16
  %1286 = load <2 x float>, ptr %gep208.2.10, align 16
  %1287 = fsub <2 x float> %1285, %1286
  %1288 = extractelement <2 x float> %1287, i64 1
  %1289 = fneg float %1288
  %1290 = fmul <2 x float> %1287, %1287
  %shift331.10 = shufflevector <2 x float> %1290, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1291 = fadd <2 x float> %1290, %shift331.10
  %1292 = extractelement <2 x float> %1291, i64 0
  %1293 = fcmp uno float %1292, 0.000000e+00
  br i1 %1293, label %1294, label %1301, !prof !14

1294:                                             ; preds = %1283
  %1295 = extractelement <2 x float> %1287, i64 0
  %1296 = fmul float %1295, %1288
  %1297 = fsub float %1296, %1296
  %1298 = fcmp uno float %1297, 0.000000e+00
  br i1 %1298, label %1299, label %1301, !prof !14

1299:                                             ; preds = %1294
  %1300 = call <2 x float> @__mulsc3(float noundef %1295, float noundef %1288, float noundef %1295, float noundef %1289) #7
  %.sroa.0.0.vec.extract.2.10 = extractelement <2 x float> %1300, i64 0
  br label %1301

1301:                                             ; preds = %1299, %1294, %1283
  %1302 = phi float [ %1292, %1283 ], [ %1292, %1294 ], [ %.sroa.0.0.vec.extract.2.10, %1299 ]
  %gep206.2.11 = getelementptr inbounds i8, ptr %392, i64 368
  %gep208.2.11 = getelementptr inbounds i8, ptr %393, i64 368
  %1303 = load <2 x float>, ptr %gep206.2.11, align 16
  %1304 = load <2 x float>, ptr %gep208.2.11, align 16
  %1305 = fsub <2 x float> %1303, %1304
  %1306 = extractelement <2 x float> %1305, i64 1
  %1307 = fneg float %1306
  %1308 = fmul <2 x float> %1305, %1305
  %shift331.11 = shufflevector <2 x float> %1308, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1309 = fadd <2 x float> %1308, %shift331.11
  %1310 = extractelement <2 x float> %1309, i64 0
  %1311 = fcmp uno float %1310, 0.000000e+00
  br i1 %1311, label %1312, label %1319, !prof !14

1312:                                             ; preds = %1301
  %1313 = extractelement <2 x float> %1305, i64 0
  %1314 = fmul float %1313, %1306
  %1315 = fsub float %1314, %1314
  %1316 = fcmp uno float %1315, 0.000000e+00
  br i1 %1316, label %1317, label %1319, !prof !14

1317:                                             ; preds = %1312
  %1318 = call <2 x float> @__mulsc3(float noundef %1313, float noundef %1306, float noundef %1313, float noundef %1307) #7
  %.sroa.0.0.vec.extract.2.11 = extractelement <2 x float> %1318, i64 0
  br label %1319

1319:                                             ; preds = %1301, %1312, %1317
  %1320 = phi float [ %1310, %1301 ], [ %1310, %1312 ], [ %.sroa.0.0.vec.extract.2.11, %1317 ]
  %invariant.gep205.3 = getelementptr inbounds i8, ptr %392, i64 24
  %1321 = load <2 x float>, ptr %invariant.gep205.3, align 8
  %1322 = load <2 x float>, ptr %invariant.gep.3, align 8
  %1323 = fsub <2 x float> %1321, %1322
  %1324 = extractelement <2 x float> %1323, i64 1
  %1325 = fneg float %1324
  %1326 = fmul <2 x float> %1323, %1323
  %shift332 = shufflevector <2 x float> %1326, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1327 = fadd <2 x float> %1326, %shift332
  %1328 = extractelement <2 x float> %1327, i64 0
  %1329 = fcmp uno float %1328, 0.000000e+00
  br i1 %1329, label %1330, label %1337, !prof !14

1330:                                             ; preds = %1319
  %1331 = extractelement <2 x float> %1323, i64 0
  %1332 = fmul float %1331, %1324
  %1333 = fsub float %1332, %1332
  %1334 = fcmp uno float %1333, 0.000000e+00
  br i1 %1334, label %1335, label %1337, !prof !14

1335:                                             ; preds = %1330
  %1336 = call <2 x float> @__mulsc3(float noundef %1331, float noundef %1324, float noundef %1331, float noundef %1325) #7
  %.sroa.0.0.vec.extract.3 = extractelement <2 x float> %1336, i64 0
  br label %1337

1337:                                             ; preds = %1335, %1330, %1319
  %1338 = phi float [ %1328, %1319 ], [ %1328, %1330 ], [ %.sroa.0.0.vec.extract.3, %1335 ]
  %gep206.3.1 = getelementptr inbounds i8, ptr %392, i64 56
  %gep208.3.1 = getelementptr inbounds i8, ptr %393, i64 56
  %1339 = load <2 x float>, ptr %gep206.3.1, align 8
  %1340 = load <2 x float>, ptr %gep208.3.1, align 8
  %1341 = fsub <2 x float> %1339, %1340
  %1342 = extractelement <2 x float> %1341, i64 1
  %1343 = fneg float %1342
  %1344 = fmul <2 x float> %1341, %1341
  %shift332.1 = shufflevector <2 x float> %1344, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1345 = fadd <2 x float> %1344, %shift332.1
  %1346 = extractelement <2 x float> %1345, i64 0
  %1347 = fcmp uno float %1346, 0.000000e+00
  br i1 %1347, label %1348, label %1355, !prof !14

1348:                                             ; preds = %1337
  %1349 = extractelement <2 x float> %1341, i64 0
  %1350 = fmul float %1349, %1342
  %1351 = fsub float %1350, %1350
  %1352 = fcmp uno float %1351, 0.000000e+00
  br i1 %1352, label %1353, label %1355, !prof !14

1353:                                             ; preds = %1348
  %1354 = call <2 x float> @__mulsc3(float noundef %1349, float noundef %1342, float noundef %1349, float noundef %1343) #7
  %.sroa.0.0.vec.extract.3.1 = extractelement <2 x float> %1354, i64 0
  br label %1355

1355:                                             ; preds = %1353, %1348, %1337
  %1356 = phi float [ %1346, %1337 ], [ %1346, %1348 ], [ %.sroa.0.0.vec.extract.3.1, %1353 ]
  %gep206.3.2 = getelementptr inbounds i8, ptr %392, i64 88
  %gep208.3.2 = getelementptr inbounds i8, ptr %393, i64 88
  %1357 = load <2 x float>, ptr %gep206.3.2, align 8
  %1358 = load <2 x float>, ptr %gep208.3.2, align 8
  %1359 = fsub <2 x float> %1357, %1358
  %1360 = extractelement <2 x float> %1359, i64 1
  %1361 = fneg float %1360
  %1362 = fmul <2 x float> %1359, %1359
  %shift332.2 = shufflevector <2 x float> %1362, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1363 = fadd <2 x float> %1362, %shift332.2
  %1364 = extractelement <2 x float> %1363, i64 0
  %1365 = fcmp uno float %1364, 0.000000e+00
  br i1 %1365, label %1366, label %1373, !prof !14

1366:                                             ; preds = %1355
  %1367 = extractelement <2 x float> %1359, i64 0
  %1368 = fmul float %1367, %1360
  %1369 = fsub float %1368, %1368
  %1370 = fcmp uno float %1369, 0.000000e+00
  br i1 %1370, label %1371, label %1373, !prof !14

1371:                                             ; preds = %1366
  %1372 = call <2 x float> @__mulsc3(float noundef %1367, float noundef %1360, float noundef %1367, float noundef %1361) #7
  %.sroa.0.0.vec.extract.3.2 = extractelement <2 x float> %1372, i64 0
  br label %1373

1373:                                             ; preds = %1371, %1366, %1355
  %1374 = phi float [ %1364, %1355 ], [ %1364, %1366 ], [ %.sroa.0.0.vec.extract.3.2, %1371 ]
  %gep206.3.3 = getelementptr inbounds i8, ptr %392, i64 120
  %gep208.3.3 = getelementptr inbounds i8, ptr %393, i64 120
  %1375 = load <2 x float>, ptr %gep206.3.3, align 8
  %1376 = load <2 x float>, ptr %gep208.3.3, align 8
  %1377 = fsub <2 x float> %1375, %1376
  %1378 = extractelement <2 x float> %1377, i64 1
  %1379 = fneg float %1378
  %1380 = fmul <2 x float> %1377, %1377
  %shift332.3 = shufflevector <2 x float> %1380, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1381 = fadd <2 x float> %1380, %shift332.3
  %1382 = extractelement <2 x float> %1381, i64 0
  %1383 = fcmp uno float %1382, 0.000000e+00
  br i1 %1383, label %1384, label %1391, !prof !14

1384:                                             ; preds = %1373
  %1385 = extractelement <2 x float> %1377, i64 0
  %1386 = fmul float %1385, %1378
  %1387 = fsub float %1386, %1386
  %1388 = fcmp uno float %1387, 0.000000e+00
  br i1 %1388, label %1389, label %1391, !prof !14

1389:                                             ; preds = %1384
  %1390 = call <2 x float> @__mulsc3(float noundef %1385, float noundef %1378, float noundef %1385, float noundef %1379) #7
  %.sroa.0.0.vec.extract.3.3 = extractelement <2 x float> %1390, i64 0
  br label %1391

1391:                                             ; preds = %1389, %1384, %1373
  %1392 = phi float [ %1382, %1373 ], [ %1382, %1384 ], [ %.sroa.0.0.vec.extract.3.3, %1389 ]
  %gep206.3.4 = getelementptr inbounds i8, ptr %392, i64 152
  %gep208.3.4 = getelementptr inbounds i8, ptr %393, i64 152
  %1393 = load <2 x float>, ptr %gep206.3.4, align 8
  %1394 = load <2 x float>, ptr %gep208.3.4, align 8
  %1395 = fsub <2 x float> %1393, %1394
  %1396 = extractelement <2 x float> %1395, i64 1
  %1397 = fneg float %1396
  %1398 = fmul <2 x float> %1395, %1395
  %shift332.4 = shufflevector <2 x float> %1398, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1399 = fadd <2 x float> %1398, %shift332.4
  %1400 = extractelement <2 x float> %1399, i64 0
  %1401 = fcmp uno float %1400, 0.000000e+00
  br i1 %1401, label %1402, label %1409, !prof !14

1402:                                             ; preds = %1391
  %1403 = extractelement <2 x float> %1395, i64 0
  %1404 = fmul float %1403, %1396
  %1405 = fsub float %1404, %1404
  %1406 = fcmp uno float %1405, 0.000000e+00
  br i1 %1406, label %1407, label %1409, !prof !14

1407:                                             ; preds = %1402
  %1408 = call <2 x float> @__mulsc3(float noundef %1403, float noundef %1396, float noundef %1403, float noundef %1397) #7
  %.sroa.0.0.vec.extract.3.4 = extractelement <2 x float> %1408, i64 0
  br label %1409

1409:                                             ; preds = %1407, %1402, %1391
  %1410 = phi float [ %1400, %1391 ], [ %1400, %1402 ], [ %.sroa.0.0.vec.extract.3.4, %1407 ]
  %gep206.3.5 = getelementptr inbounds i8, ptr %392, i64 184
  %gep208.3.5 = getelementptr inbounds i8, ptr %393, i64 184
  %1411 = load <2 x float>, ptr %gep206.3.5, align 8
  %1412 = load <2 x float>, ptr %gep208.3.5, align 8
  %1413 = fsub <2 x float> %1411, %1412
  %1414 = extractelement <2 x float> %1413, i64 1
  %1415 = fneg float %1414
  %1416 = fmul <2 x float> %1413, %1413
  %shift332.5 = shufflevector <2 x float> %1416, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1417 = fadd <2 x float> %1416, %shift332.5
  %1418 = extractelement <2 x float> %1417, i64 0
  %1419 = fcmp uno float %1418, 0.000000e+00
  br i1 %1419, label %1420, label %1427, !prof !14

1420:                                             ; preds = %1409
  %1421 = extractelement <2 x float> %1413, i64 0
  %1422 = fmul float %1421, %1414
  %1423 = fsub float %1422, %1422
  %1424 = fcmp uno float %1423, 0.000000e+00
  br i1 %1424, label %1425, label %1427, !prof !14

1425:                                             ; preds = %1420
  %1426 = call <2 x float> @__mulsc3(float noundef %1421, float noundef %1414, float noundef %1421, float noundef %1415) #7
  %.sroa.0.0.vec.extract.3.5 = extractelement <2 x float> %1426, i64 0
  br label %1427

1427:                                             ; preds = %1425, %1420, %1409
  %1428 = phi float [ %1418, %1409 ], [ %1418, %1420 ], [ %.sroa.0.0.vec.extract.3.5, %1425 ]
  %gep206.3.6 = getelementptr inbounds i8, ptr %392, i64 216
  %gep208.3.6 = getelementptr inbounds i8, ptr %393, i64 216
  %1429 = load <2 x float>, ptr %gep206.3.6, align 8
  %1430 = load <2 x float>, ptr %gep208.3.6, align 8
  %1431 = fsub <2 x float> %1429, %1430
  %1432 = extractelement <2 x float> %1431, i64 1
  %1433 = fneg float %1432
  %1434 = fmul <2 x float> %1431, %1431
  %shift332.6 = shufflevector <2 x float> %1434, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1435 = fadd <2 x float> %1434, %shift332.6
  %1436 = extractelement <2 x float> %1435, i64 0
  %1437 = fcmp uno float %1436, 0.000000e+00
  br i1 %1437, label %1438, label %1445, !prof !14

1438:                                             ; preds = %1427
  %1439 = extractelement <2 x float> %1431, i64 0
  %1440 = fmul float %1439, %1432
  %1441 = fsub float %1440, %1440
  %1442 = fcmp uno float %1441, 0.000000e+00
  br i1 %1442, label %1443, label %1445, !prof !14

1443:                                             ; preds = %1438
  %1444 = call <2 x float> @__mulsc3(float noundef %1439, float noundef %1432, float noundef %1439, float noundef %1433) #7
  %.sroa.0.0.vec.extract.3.6 = extractelement <2 x float> %1444, i64 0
  br label %1445

1445:                                             ; preds = %1443, %1438, %1427
  %1446 = phi float [ %1436, %1427 ], [ %1436, %1438 ], [ %.sroa.0.0.vec.extract.3.6, %1443 ]
  %gep206.3.7 = getelementptr inbounds i8, ptr %392, i64 248
  %gep208.3.7 = getelementptr inbounds i8, ptr %393, i64 248
  %1447 = load <2 x float>, ptr %gep206.3.7, align 8
  %1448 = load <2 x float>, ptr %gep208.3.7, align 8
  %1449 = fsub <2 x float> %1447, %1448
  %1450 = extractelement <2 x float> %1449, i64 1
  %1451 = fneg float %1450
  %1452 = fmul <2 x float> %1449, %1449
  %shift332.7 = shufflevector <2 x float> %1452, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1453 = fadd <2 x float> %1452, %shift332.7
  %1454 = extractelement <2 x float> %1453, i64 0
  %1455 = fcmp uno float %1454, 0.000000e+00
  br i1 %1455, label %1456, label %1463, !prof !14

1456:                                             ; preds = %1445
  %1457 = extractelement <2 x float> %1449, i64 0
  %1458 = fmul float %1457, %1450
  %1459 = fsub float %1458, %1458
  %1460 = fcmp uno float %1459, 0.000000e+00
  br i1 %1460, label %1461, label %1463, !prof !14

1461:                                             ; preds = %1456
  %1462 = call <2 x float> @__mulsc3(float noundef %1457, float noundef %1450, float noundef %1457, float noundef %1451) #7
  %.sroa.0.0.vec.extract.3.7 = extractelement <2 x float> %1462, i64 0
  br label %1463

1463:                                             ; preds = %1461, %1456, %1445
  %1464 = phi float [ %1454, %1445 ], [ %1454, %1456 ], [ %.sroa.0.0.vec.extract.3.7, %1461 ]
  %gep206.3.8 = getelementptr inbounds i8, ptr %392, i64 280
  %gep208.3.8 = getelementptr inbounds i8, ptr %393, i64 280
  %1465 = load <2 x float>, ptr %gep206.3.8, align 8
  %1466 = load <2 x float>, ptr %gep208.3.8, align 8
  %1467 = fsub <2 x float> %1465, %1466
  %1468 = extractelement <2 x float> %1467, i64 1
  %1469 = fneg float %1468
  %1470 = fmul <2 x float> %1467, %1467
  %shift332.8 = shufflevector <2 x float> %1470, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1471 = fadd <2 x float> %1470, %shift332.8
  %1472 = extractelement <2 x float> %1471, i64 0
  %1473 = fcmp uno float %1472, 0.000000e+00
  br i1 %1473, label %1474, label %1481, !prof !14

1474:                                             ; preds = %1463
  %1475 = extractelement <2 x float> %1467, i64 0
  %1476 = fmul float %1475, %1468
  %1477 = fsub float %1476, %1476
  %1478 = fcmp uno float %1477, 0.000000e+00
  br i1 %1478, label %1479, label %1481, !prof !14

1479:                                             ; preds = %1474
  %1480 = call <2 x float> @__mulsc3(float noundef %1475, float noundef %1468, float noundef %1475, float noundef %1469) #7
  %.sroa.0.0.vec.extract.3.8 = extractelement <2 x float> %1480, i64 0
  br label %1481

1481:                                             ; preds = %1479, %1474, %1463
  %1482 = phi float [ %1472, %1463 ], [ %1472, %1474 ], [ %.sroa.0.0.vec.extract.3.8, %1479 ]
  %gep206.3.9 = getelementptr inbounds i8, ptr %392, i64 312
  %gep208.3.9 = getelementptr inbounds i8, ptr %393, i64 312
  %1483 = load <2 x float>, ptr %gep206.3.9, align 8
  %1484 = load <2 x float>, ptr %gep208.3.9, align 8
  %1485 = fsub <2 x float> %1483, %1484
  %1486 = extractelement <2 x float> %1485, i64 1
  %1487 = fneg float %1486
  %1488 = fmul <2 x float> %1485, %1485
  %shift332.9 = shufflevector <2 x float> %1488, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1489 = fadd <2 x float> %1488, %shift332.9
  %1490 = extractelement <2 x float> %1489, i64 0
  %1491 = fcmp uno float %1490, 0.000000e+00
  br i1 %1491, label %1492, label %1499, !prof !14

1492:                                             ; preds = %1481
  %1493 = extractelement <2 x float> %1485, i64 0
  %1494 = fmul float %1493, %1486
  %1495 = fsub float %1494, %1494
  %1496 = fcmp uno float %1495, 0.000000e+00
  br i1 %1496, label %1497, label %1499, !prof !14

1497:                                             ; preds = %1492
  %1498 = call <2 x float> @__mulsc3(float noundef %1493, float noundef %1486, float noundef %1493, float noundef %1487) #7
  %.sroa.0.0.vec.extract.3.9 = extractelement <2 x float> %1498, i64 0
  br label %1499

1499:                                             ; preds = %1497, %1492, %1481
  %1500 = phi float [ %1490, %1481 ], [ %1490, %1492 ], [ %.sroa.0.0.vec.extract.3.9, %1497 ]
  %gep206.3.10 = getelementptr inbounds i8, ptr %392, i64 344
  %gep208.3.10 = getelementptr inbounds i8, ptr %393, i64 344
  %1501 = load <2 x float>, ptr %gep206.3.10, align 8
  %1502 = load <2 x float>, ptr %gep208.3.10, align 8
  %1503 = fsub <2 x float> %1501, %1502
  %1504 = extractelement <2 x float> %1503, i64 1
  %1505 = fneg float %1504
  %1506 = fmul <2 x float> %1503, %1503
  %shift332.10 = shufflevector <2 x float> %1506, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1507 = fadd <2 x float> %1506, %shift332.10
  %1508 = extractelement <2 x float> %1507, i64 0
  %1509 = fcmp uno float %1508, 0.000000e+00
  br i1 %1509, label %1510, label %1517, !prof !14

1510:                                             ; preds = %1499
  %1511 = extractelement <2 x float> %1503, i64 0
  %1512 = fmul float %1511, %1504
  %1513 = fsub float %1512, %1512
  %1514 = fcmp uno float %1513, 0.000000e+00
  br i1 %1514, label %1515, label %1517, !prof !14

1515:                                             ; preds = %1510
  %1516 = call <2 x float> @__mulsc3(float noundef %1511, float noundef %1504, float noundef %1511, float noundef %1505) #7
  %.sroa.0.0.vec.extract.3.10 = extractelement <2 x float> %1516, i64 0
  br label %1517

1517:                                             ; preds = %1515, %1510, %1499
  %1518 = phi float [ %1508, %1499 ], [ %1508, %1510 ], [ %.sroa.0.0.vec.extract.3.10, %1515 ]
  %gep206.3.11 = getelementptr inbounds i8, ptr %392, i64 376
  %gep208.3.11 = getelementptr inbounds i8, ptr %393, i64 376
  %1519 = load <2 x float>, ptr %gep206.3.11, align 8
  %1520 = load <2 x float>, ptr %gep208.3.11, align 8
  %1521 = fsub <2 x float> %1519, %1520
  %1522 = extractelement <2 x float> %1521, i64 1
  %1523 = fneg float %1522
  %1524 = fmul <2 x float> %1521, %1521
  %shift332.11 = shufflevector <2 x float> %1524, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %1525 = fadd <2 x float> %1524, %shift332.11
  %1526 = extractelement <2 x float> %1525, i64 0
  %1527 = fcmp uno float %1526, 0.000000e+00
  br i1 %1527, label %1528, label %1535, !prof !14

1528:                                             ; preds = %1517
  %1529 = extractelement <2 x float> %1521, i64 0
  %1530 = fmul float %1529, %1522
  %1531 = fsub float %1530, %1530
  %1532 = fcmp uno float %1531, 0.000000e+00
  br i1 %1532, label %1533, label %1535, !prof !14

1533:                                             ; preds = %1528
  %1534 = call <2 x float> @__mulsc3(float noundef %1529, float noundef %1522, float noundef %1529, float noundef %1523) #7
  %.sroa.0.0.vec.extract.3.11 = extractelement <2 x float> %1534, i64 0
  br label %1535

1535:                                             ; preds = %1533, %1528, %1517
  %1536 = phi float [ %1526, %1517 ], [ %1526, %1528 ], [ %.sroa.0.0.vec.extract.3.11, %1533 ]
  %1537 = fadd float %1338, 0.000000e+00
  %1538 = fadd float %1356, %1537
  %1539 = fadd float %1374, %1538
  %1540 = fadd float %1392, %1539
  %1541 = fadd float %1410, %1540
  %1542 = fadd float %1428, %1541
  %1543 = fadd float %1446, %1542
  %1544 = fadd float %1464, %1543
  %1545 = fadd float %1482, %1544
  %1546 = fadd float %1500, %1545
  %1547 = fadd float %1518, %1546
  %1548 = fadd float %1122, 0.000000e+00
  %1549 = fadd float %1140, %1548
  %1550 = fadd float %1158, %1549
  %1551 = fadd float %1176, %1550
  %1552 = fadd float %1194, %1551
  %1553 = fadd float %1212, %1552
  %1554 = fadd float %1230, %1553
  %1555 = fadd float %1248, %1554
  %1556 = fadd float %1266, %1555
  %1557 = fadd float %1284, %1556
  %1558 = fadd float %1302, %1557
  %1559 = fadd float %1320, %1558
  %1560 = fadd float %906, 0.000000e+00
  %1561 = fadd float %924, %1560
  %1562 = fadd float %942, %1561
  %1563 = fadd float %960, %1562
  %1564 = fadd float %978, %1563
  %1565 = fadd float %996, %1564
  %1566 = fadd float %1014, %1565
  %1567 = fadd float %1032, %1566
  %1568 = fadd float %1050, %1567
  %1569 = fadd float %1068, %1568
  %1570 = fadd float %1086, %1569
  %1571 = fadd float %1104, %1570
  %1572 = fadd float %700, 0.000000e+00
  %1573 = fadd float %717, %1572
  %1574 = fadd float %734, %1573
  %1575 = fadd float %751, %1574
  %1576 = fadd float %768, %1575
  %1577 = fadd float %785, %1576
  %1578 = fadd float %802, %1577
  %1579 = fadd float %819, %1578
  %1580 = fadd float %836, %1579
  %1581 = fadd float %853, %1580
  %1582 = fadd float %870, %1581
  %1583 = fadd float %888, %1582
  %1584 = fadd float %1536, %1547
  %1585 = fdiv float %1559, 1.200000e+01
  %1586 = fdiv float %1571, 1.200000e+01
  %1587 = fdiv float %1583, 1.200000e+01
  %1588 = fdiv float %1584, 1.200000e+01
  %1589 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %1590 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.11)
  %1591 = fpext float %1587 to double
  %1592 = call double @sqrt(double noundef %1591) #7
  %1593 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.12, double noundef %1592)
  %1594 = fpext float %1586 to double
  %1595 = call double @sqrt(double noundef %1594) #7
  %1596 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.12, double noundef %1595)
  %1597 = fpext float %1585 to double
  %1598 = call double @sqrt(double noundef %1597) #7
  %1599 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.12, double noundef %1598)
  %1600 = fpext float %1588 to double
  %1601 = call double @sqrt(double noundef %1600) #7
  %1602 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.12, double noundef %1601)
  %1603 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6)
  %1604 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.13)
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %0) #7
  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

declare float @randnf(...) local_unnamed_addr #2

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

declare ptr @dotprod_crcf_create(ptr noundef, i32 noundef) local_unnamed_addr #2

declare ptr @windowcf_create(i32 noundef) local_unnamed_addr #2

declare ptr @fft_create_plan(i32 noundef, ptr noundef, ptr noundef, i32 noundef, i32 noundef) local_unnamed_addr #2

declare ptr @firfilt_crcf_create(ptr noundef, i32 noundef) local_unnamed_addr #2

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

declare float @randf(...) local_unnamed_addr #2

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

declare i32 @windowcf_read(ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @dotprod_crcf_execute(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @fft_execute(ptr noundef) local_unnamed_addr #2

declare i32 @firfilt_crcf_reset(ptr noundef) local_unnamed_addr #2

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

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

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #5

declare i32 @firfilt_crcf_execute(ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @dotprod_crcf_destroy(ptr noundef) local_unnamed_addr #2

declare i32 @windowcf_destroy(ptr noundef) local_unnamed_addr #2

declare i32 @fft_destroy_plan(ptr noundef) local_unnamed_addr #2

declare i32 @firfilt_crcf_destroy(ptr noundef) local_unnamed_addr #2

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

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

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 = { "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 = { 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 #4 = { 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 #5 = { noreturn 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 #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 = { nounwind }
attributes #8 = { noreturn 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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = !{!12, !12, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = distinct !{!13, !10}
!14 = !{!"branch_weights", i32 1, i32 1048575}
!15 = distinct !{!15, !10}
!16 = distinct !{!16, !10}
!17 = distinct !{!17, !10}


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