; LLVM IR from jgaeddert/liquid-dsp :: src/framing/src (qpilotsync)

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

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

@.str = external hidden unnamed_addr constant [83 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [59 x i8], align 1

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

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

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

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

40:                                               ; preds = %96, %3
  %41 = load i32, ptr %8, align 4, !tbaa !9
  %42 = load ptr, ptr %5, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.qpilotsync_s, ptr %42, i32 0, i32 2
  %44 = load i32, ptr %43, align 8, !tbaa !11
  %45 = icmp ult i32 %41, %44
  br i1 %45, label %46, label %99

46:                                               ; preds = %40
  %47 = load ptr, ptr %6, align 8, !tbaa !5
  %48 = load i32, ptr %8, align 4, !tbaa !9
  %49 = load ptr, ptr %5, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.qpilotsync_s, ptr %49, i32 0, i32 1
  %51 = load i32, ptr %50, align 4, !tbaa !14
  %52 = mul i32 %48, %51
  %53 = zext i32 %52 to i64
  %54 = getelementptr inbounds { float, float }, ptr %47, i64 %53
  %55 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 0
  %56 = load float, ptr %55, align 4
  %57 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 1
  %58 = load float, ptr %57, align 4
  %59 = load ptr, ptr %5, align 8, !tbaa !5
  %60 = getelementptr inbounds %struct.qpilotsync_s, ptr %59, i32 0, i32 4
  %61 = load ptr, ptr %60, align 8, !tbaa !15
  %62 = load i32, ptr %8, align 4, !tbaa !9
  %63 = zext i32 %62 to i64
  %64 = getelementptr inbounds { float, float }, ptr %61, i64 %63
  %65 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 0
  %66 = load float, ptr %65, align 4
  %67 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 1
  %68 = load float, ptr %67, align 4
  %69 = fneg float %68
  %70 = fmul float %56, %66
  %71 = fmul float %58, %69
  %72 = fmul float %56, %69
  %73 = fmul float %58, %66
  %74 = fsub float %70, %71
  %75 = fadd float %72, %73
  %76 = fcmp uno float %74, %74
  br i1 %76, label %77, label %85, !prof !16

77:                                               ; preds = %46
  %78 = fcmp uno float %75, %75
  br i1 %78, label %79, label %85, !prof !16

79:                                               ; preds = %77
  %80 = call <2 x float> @__mulsc3(float noundef %56, float noundef %58, float noundef %66, float noundef %69) #5
  store <2 x float> %80, ptr %11, align 4
  %81 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %82 = load float, ptr %81, align 4
  %83 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %84 = load float, ptr %83, align 4
  br label %85

85:                                               ; preds = %79, %77, %46
  %86 = phi float [ %74, %46 ], [ %74, %77 ], [ %82, %79 ]
  %87 = phi float [ %75, %46 ], [ %75, %77 ], [ %84, %79 ]
  %88 = load ptr, ptr %5, align 8, !tbaa !5
  %89 = getelementptr inbounds %struct.qpilotsync_s, ptr %88, i32 0, i32 6
  %90 = load ptr, ptr %89, align 8, !tbaa !17
  %91 = load i32, ptr %8, align 4, !tbaa !9
  %92 = zext i32 %91 to i64
  %93 = getelementptr inbounds { float, float }, ptr %90, i64 %92
  %94 = getelementptr inbounds { float, float }, ptr %93, i32 0, i32 0
  %95 = getelementptr inbounds { float, float }, ptr %93, i32 0, i32 1
  store float %86, ptr %94, align 4
  store float %87, ptr %95, align 4
  br label %96

96:                                               ; preds = %85
  %97 = load i32, ptr %8, align 4, !tbaa !9
  %98 = add i32 %97, 1
  store i32 %98, ptr %8, align 4, !tbaa !9
  br label %40, !llvm.loop !18

99:                                               ; preds = %40
  %100 = load ptr, ptr %5, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct.qpilotsync_s, ptr %100, i32 0, i32 8
  %102 = load ptr, ptr %101, align 8, !tbaa !20
  %103 = call i32 @fft_execute(ptr noundef %102)
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #5
  store i32 0, ptr %12, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #5
  store float 0.000000e+00, ptr %13, align 4, !tbaa !21
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %104

104:                                              ; preds = %147, %99
  %105 = load i32, ptr %8, align 4, !tbaa !9
  %106 = load ptr, ptr %5, align 8, !tbaa !5
  %107 = getelementptr inbounds %struct.qpilotsync_s, ptr %106, i32 0, i32 5
  %108 = load i32, ptr %107, align 8, !tbaa !22
  %109 = icmp ult i32 %105, %108
  br i1 %109, label %110, label %150

110:                                              ; preds = %104
  %111 = load i32, ptr %8, align 4, !tbaa !9
  %112 = icmp eq i32 %111, 0
  br i1 %112, label %130, label %113

113:                                              ; preds = %110
  %114 = load ptr, ptr %5, align 8, !tbaa !5
  %115 = getelementptr inbounds %struct.qpilotsync_s, ptr %114, i32 0, i32 7
  %116 = load ptr, ptr %115, align 8, !tbaa !23
  %117 = load i32, ptr %8, align 4, !tbaa !9
  %118 = zext i32 %117 to i64
  %119 = getelementptr inbounds { float, float }, ptr %116, i64 %118
  %120 = getelementptr inbounds { float, float }, ptr %119, i32 0, i32 0
  %121 = load float, ptr %120, align 4
  %122 = getelementptr inbounds { float, float }, ptr %119, i32 0, i32 1
  %123 = load float, ptr %122, align 4
  %124 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %125 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  store float %121, ptr %124, align 4
  store float %123, ptr %125, align 4
  %126 = load <2 x float>, ptr %14, align 4
  %127 = call float @cabsf(<2 x float> noundef %126) #5
  %128 = load float, ptr %13, align 4, !tbaa !21
  %129 = fcmp ogt float %127, %128
  br i1 %129, label %130, label %146

130:                                              ; preds = %113, %110
  %131 = load i32, ptr %8, align 4, !tbaa !9
  store i32 %131, ptr %12, align 4, !tbaa !9
  %132 = load ptr, ptr %5, align 8, !tbaa !5
  %133 = getelementptr inbounds %struct.qpilotsync_s, ptr %132, i32 0, i32 7
  %134 = load ptr, ptr %133, align 8, !tbaa !23
  %135 = load i32, ptr %8, align 4, !tbaa !9
  %136 = zext i32 %135 to i64
  %137 = getelementptr inbounds { float, float }, ptr %134, i64 %136
  %138 = getelementptr inbounds { float, float }, ptr %137, i32 0, i32 0
  %139 = load float, ptr %138, align 4
  %140 = getelementptr inbounds { float, float }, ptr %137, i32 0, i32 1
  %141 = load float, ptr %140, align 4
  %142 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %143 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  store float %139, ptr %142, align 4
  store float %141, ptr %143, align 4
  %144 = load <2 x float>, ptr %15, align 4
  %145 = call float @cabsf(<2 x float> noundef %144) #5
  store float %145, ptr %13, align 4, !tbaa !21
  br label %146

146:                                              ; preds = %130, %113
  br label %147

147:                                              ; preds = %146
  %148 = load i32, ptr %8, align 4, !tbaa !9
  %149 = add i32 %148, 1
  store i32 %149, ptr %8, align 4, !tbaa !9
  br label %104, !llvm.loop !24

150:                                              ; preds = %104
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #5
  %151 = load i32, ptr %12, align 4, !tbaa !9
  %152 = load ptr, ptr %5, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.qpilotsync_s, ptr %152, i32 0, i32 5
  %154 = load i32, ptr %153, align 8, !tbaa !22
  %155 = add i32 %151, %154
  %156 = sub i32 %155, 1
  %157 = load ptr, ptr %5, align 8, !tbaa !5
  %158 = getelementptr inbounds %struct.qpilotsync_s, ptr %157, i32 0, i32 5
  %159 = load i32, ptr %158, align 8, !tbaa !22
  %160 = urem i32 %156, %159
  store i32 %160, ptr %16, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #5
  %161 = load i32, ptr %12, align 4, !tbaa !9
  %162 = add i32 %161, 1
  %163 = load ptr, ptr %5, align 8, !tbaa !5
  %164 = getelementptr inbounds %struct.qpilotsync_s, ptr %163, i32 0, i32 5
  %165 = load i32, ptr %164, align 8, !tbaa !22
  %166 = urem i32 %162, %165
  store i32 %166, ptr %17, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #5
  %167 = load ptr, ptr %5, align 8, !tbaa !5
  %168 = getelementptr inbounds %struct.qpilotsync_s, ptr %167, i32 0, i32 7
  %169 = load ptr, ptr %168, align 8, !tbaa !23
  %170 = load i32, ptr %17, align 4, !tbaa !9
  %171 = zext i32 %170 to i64
  %172 = getelementptr inbounds { float, float }, ptr %169, i64 %171
  %173 = getelementptr inbounds { float, float }, ptr %172, i32 0, i32 0
  %174 = load float, ptr %173, align 4
  %175 = getelementptr inbounds { float, float }, ptr %172, i32 0, i32 1
  %176 = load float, ptr %175, align 4
  %177 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %178 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  store float %174, ptr %177, align 4
  store float %176, ptr %178, align 4
  %179 = load <2 x float>, ptr %19, align 4
  %180 = call float @cabsf(<2 x float> noundef %179) #5
  store float %180, ptr %18, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #5
  %181 = load ptr, ptr %5, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.qpilotsync_s, ptr %181, i32 0, i32 7
  %183 = load ptr, ptr %182, align 8, !tbaa !23
  %184 = load i32, ptr %16, align 4, !tbaa !9
  %185 = zext i32 %184 to i64
  %186 = getelementptr inbounds { float, float }, ptr %183, i64 %185
  %187 = getelementptr inbounds { float, float }, ptr %186, i32 0, i32 0
  %188 = load float, ptr %187, align 4
  %189 = getelementptr inbounds { float, float }, ptr %186, i32 0, i32 1
  %190 = load float, ptr %189, align 4
  %191 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 0
  %192 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 1
  store float %188, ptr %191, align 4
  store float %190, ptr %192, align 4
  %193 = load <2 x float>, ptr %21, align 4
  %194 = call float @cabsf(<2 x float> noundef %193) #5
  store float %194, ptr %20, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #5
  %195 = load float, ptr %18, align 4, !tbaa !21
  %196 = load float, ptr %20, align 4, !tbaa !21
  %197 = fadd float %195, %196
  %198 = load float, ptr %13, align 4, !tbaa !21
  %199 = fneg float %198
  %200 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %197, float %199)
  store float %200, ptr %22, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #5
  %201 = load float, ptr %18, align 4, !tbaa !21
  %202 = load float, ptr %20, align 4, !tbaa !21
  %203 = fsub float %201, %202
  %204 = fmul float 5.000000e-01, %203
  store float %204, ptr %23, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #5
  %205 = load float, ptr %23, align 4, !tbaa !21
  %206 = fneg float %205
  %207 = load float, ptr %22, align 4, !tbaa !21
  %208 = fmul float 2.000000e+00, %207
  %209 = fdiv float %206, %208
  store float %209, ptr %24, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #5
  %210 = load i32, ptr %12, align 4, !tbaa !9
  %211 = uitofp i32 %210 to float
  %212 = load float, ptr %24, align 4, !tbaa !21
  %213 = fadd float %211, %212
  store float %213, ptr %25, align 4, !tbaa !21
  %214 = load i32, ptr %12, align 4, !tbaa !9
  %215 = load ptr, ptr %5, align 8, !tbaa !5
  %216 = getelementptr inbounds %struct.qpilotsync_s, ptr %215, i32 0, i32 5
  %217 = load i32, ptr %216, align 8, !tbaa !22
  %218 = udiv i32 %217, 2
  %219 = icmp ugt i32 %214, %218
  br i1 %219, label %220, label %227

220:                                              ; preds = %150
  %221 = load float, ptr %25, align 4, !tbaa !21
  %222 = load ptr, ptr %5, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.qpilotsync_s, ptr %222, i32 0, i32 5
  %224 = load i32, ptr %223, align 8, !tbaa !22
  %225 = uitofp i32 %224 to float
  %226 = fsub float %221, %225
  br label %229

227:                                              ; preds = %150
  %228 = load float, ptr %25, align 4, !tbaa !21
  br label %229

229:                                              ; preds = %227, %220
  %230 = phi float [ %226, %220 ], [ %228, %227 ]
  %231 = fmul float %230, 2.000000e+00
  %232 = fpext float %231 to double
  %233 = fmul double %232, 0x400921FB54442D18
  %234 = load ptr, ptr %5, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.qpilotsync_s, ptr %234, i32 0, i32 5
  %236 = load i32, ptr %235, align 8, !tbaa !22
  %237 = load ptr, ptr %5, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.qpilotsync_s, ptr %237, i32 0, i32 1
  %239 = load i32, ptr %238, align 4, !tbaa !14
  %240 = mul i32 %236, %239
  %241 = uitofp i32 %240 to float
  %242 = fpext float %241 to double
  %243 = fdiv double %233, %242
  %244 = fptrunc double %243 to float
  %245 = load ptr, ptr %5, align 8, !tbaa !5
  %246 = getelementptr inbounds %struct.qpilotsync_s, ptr %245, i32 0, i32 9
  store float %244, ptr %246, align 8, !tbaa !25
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #5
  %247 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %248 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  store float 0.000000e+00, ptr %247, align 4
  store float 0.000000e+00, ptr %248, align 4
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %249

249:                                              ; preds = %315, %229
  %250 = load i32, ptr %8, align 4, !tbaa !9
  %251 = load ptr, ptr %5, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.qpilotsync_s, ptr %251, i32 0, i32 2
  %253 = load i32, ptr %252, align 8, !tbaa !11
  %254 = icmp ult i32 %250, %253
  br i1 %254, label %255, label %318

255:                                              ; preds = %249
  %256 = load ptr, ptr %5, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.qpilotsync_s, ptr %256, i32 0, i32 6
  %258 = load ptr, ptr %257, align 8, !tbaa !17
  %259 = load i32, ptr %8, align 4, !tbaa !9
  %260 = zext i32 %259 to i64
  %261 = getelementptr inbounds { float, float }, ptr %258, i64 %260
  %262 = getelementptr inbounds { float, float }, ptr %261, i32 0, i32 0
  %263 = load float, ptr %262, align 4
  %264 = getelementptr inbounds { float, float }, ptr %261, i32 0, i32 1
  %265 = load float, ptr %264, align 4
  %266 = load ptr, ptr %5, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.qpilotsync_s, ptr %266, i32 0, i32 9
  %268 = load float, ptr %267, align 8, !tbaa !25
  %269 = fmul float -0.000000e+00, %268
  %270 = fmul float -1.000000e+00, %268
  %271 = load i32, ptr %8, align 4, !tbaa !9
  %272 = uitofp i32 %271 to float
  %273 = fmul float %269, %272
  %274 = fmul float %270, %272
  %275 = load ptr, ptr %5, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.qpilotsync_s, ptr %275, i32 0, i32 1
  %277 = load i32, ptr %276, align 4, !tbaa !14
  %278 = uitofp i32 %277 to float
  %279 = fmul float %273, %278
  %280 = fmul float %274, %278
  %281 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %282 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  store float %279, ptr %281, align 4
  store float %280, ptr %282, align 4
  %283 = load <2 x float>, ptr %27, align 4
  %284 = call <2 x float> @cexpf(<2 x float> noundef %283) #5
  store <2 x float> %284, ptr %28, align 4
  %285 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 0
  %286 = load float, ptr %285, align 4
  %287 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 1
  %288 = load float, ptr %287, align 4
  %289 = fmul float %263, %286
  %290 = fmul float %265, %288
  %291 = fmul float %263, %288
  %292 = fmul float %265, %286
  %293 = fsub float %289, %290
  %294 = fadd float %291, %292
  %295 = fcmp uno float %293, %293
  br i1 %295, label %296, label %304, !prof !16

296:                                              ; preds = %255
  %297 = fcmp uno float %294, %294
  br i1 %297, label %298, label %304, !prof !16

298:                                              ; preds = %296
  %299 = call <2 x float> @__mulsc3(float noundef %263, float noundef %265, float noundef %286, float noundef %288) #5
  store <2 x float> %299, ptr %29, align 4
  %300 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %301 = load float, ptr %300, align 4
  %302 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  %303 = load float, ptr %302, align 4
  br label %304

304:                                              ; preds = %298, %296, %255
  %305 = phi float [ %293, %255 ], [ %293, %296 ], [ %301, %298 ]
  %306 = phi float [ %294, %255 ], [ %294, %296 ], [ %303, %298 ]
  %307 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %308 = load float, ptr %307, align 4
  %309 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  %310 = load float, ptr %309, align 4
  %311 = fadd float %308, %305
  %312 = fadd float %310, %306
  %313 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %314 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  store float %311, ptr %313, align 4
  store float %312, ptr %314, align 4
  br label %315

315:                                              ; preds = %304
  %316 = load i32, ptr %8, align 4, !tbaa !9
  %317 = add i32 %316, 1
  store i32 %317, ptr %8, align 4, !tbaa !9
  br label %249, !llvm.loop !26

318:                                              ; preds = %249
  %319 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %320 = load float, ptr %319, align 4
  %321 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  %322 = load float, ptr %321, align 4
  %323 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 0
  %324 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 1
  store float %320, ptr %323, align 4
  store float %322, ptr %324, align 4
  %325 = load <2 x float>, ptr %30, align 4
  %326 = call float @cargf(<2 x float> noundef %325) #5
  %327 = load ptr, ptr %5, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.qpilotsync_s, ptr %327, i32 0, i32 10
  store float %326, ptr %328, align 4, !tbaa !27
  %329 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %330 = load float, ptr %329, align 4
  %331 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  %332 = load float, ptr %331, align 4
  %333 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 0
  %334 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 1
  store float %330, ptr %333, align 4
  store float %332, ptr %334, align 4
  %335 = load <2 x float>, ptr %31, align 4
  %336 = call float @cabsf(<2 x float> noundef %335) #5
  %337 = load ptr, ptr %5, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.qpilotsync_s, ptr %337, i32 0, i32 2
  %339 = load i32, ptr %338, align 8, !tbaa !11
  %340 = uitofp i32 %339 to float
  %341 = fdiv float %336, %340
  %342 = load ptr, ptr %5, align 8, !tbaa !5
  %343 = getelementptr inbounds %struct.qpilotsync_s, ptr %342, i32 0, i32 11
  store float %341, ptr %343, align 8, !tbaa !28
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #5
  %344 = load ptr, ptr %5, align 8, !tbaa !5
  %345 = getelementptr inbounds %struct.qpilotsync_s, ptr %344, i32 0, i32 11
  %346 = load float, ptr %345, align 8, !tbaa !28
  %347 = fdiv float 1.000000e+00, %346
  store float %347, ptr %32, align 4, !tbaa !21
  %348 = load ptr, ptr %5, align 8, !tbaa !5
  %349 = getelementptr inbounds %struct.qpilotsync_s, ptr %348, i32 0, i32 12
  store float 0.000000e+00, ptr %349, align 4, !tbaa !29
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %350

350:                                              ; preds = %478, %318
  %351 = load i32, ptr %8, align 4, !tbaa !9
  %352 = load ptr, ptr %5, align 8, !tbaa !5
  %353 = getelementptr inbounds %struct.qpilotsync_s, ptr %352, i32 0, i32 3
  %354 = load i32, ptr %353, align 4, !tbaa !30
  %355 = icmp ult i32 %351, %354
  br i1 %355, label %356, label %481

356:                                              ; preds = %350
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #5
  %357 = load float, ptr %32, align 4, !tbaa !21
  %358 = load ptr, ptr %6, align 8, !tbaa !5
  %359 = load i32, ptr %8, align 4, !tbaa !9
  %360 = zext i32 %359 to i64
  %361 = getelementptr inbounds { float, float }, ptr %358, i64 %360
  %362 = getelementptr inbounds { float, float }, ptr %361, i32 0, i32 0
  %363 = load float, ptr %362, align 4
  %364 = getelementptr inbounds { float, float }, ptr %361, i32 0, i32 1
  %365 = load float, ptr %364, align 4
  %366 = fmul float %357, %363
  %367 = fmul float %357, %365
  %368 = load ptr, ptr %5, align 8, !tbaa !5
  %369 = getelementptr inbounds %struct.qpilotsync_s, ptr %368, i32 0, i32 9
  %370 = load float, ptr %369, align 8, !tbaa !25
  %371 = load i32, ptr %8, align 4, !tbaa !9
  %372 = uitofp i32 %371 to float
  %373 = load ptr, ptr %5, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.qpilotsync_s, ptr %373, i32 0, i32 10
  %375 = load float, ptr %374, align 4, !tbaa !27
  %376 = call float @llvm.fmuladd.f32(float %370, float %372, float %375)
  %377 = fmul float -0.000000e+00, %376
  %378 = fmul float -1.000000e+00, %376
  %379 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 0
  %380 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 1
  store float %377, ptr %379, align 4
  store float %378, ptr %380, align 4
  %381 = load <2 x float>, ptr %34, align 4
  %382 = call <2 x float> @cexpf(<2 x float> noundef %381) #5
  store <2 x float> %382, ptr %35, align 4
  %383 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 0
  %384 = load float, ptr %383, align 4
  %385 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 1
  %386 = load float, ptr %385, align 4
  %387 = fmul float %366, %384
  %388 = fmul float %367, %386
  %389 = fmul float %366, %386
  %390 = fmul float %367, %384
  %391 = fsub float %387, %388
  %392 = fadd float %389, %390
  %393 = fcmp uno float %391, %391
  br i1 %393, label %394, label %402, !prof !16

394:                                              ; preds = %356
  %395 = fcmp uno float %392, %392
  br i1 %395, label %396, label %402, !prof !16

396:                                              ; preds = %394
  %397 = call <2 x float> @__mulsc3(float noundef %366, float noundef %367, float noundef %384, float noundef %386) #5
  store <2 x float> %397, ptr %36, align 4
  %398 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %399 = load float, ptr %398, align 4
  %400 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  %401 = load float, ptr %400, align 4
  br label %402

402:                                              ; preds = %396, %394, %356
  %403 = phi float [ %391, %356 ], [ %391, %394 ], [ %399, %396 ]
  %404 = phi float [ %392, %356 ], [ %392, %394 ], [ %401, %396 ]
  %405 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %406 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  store float %403, ptr %405, align 4
  store float %404, ptr %406, align 4
  %407 = load i32, ptr %8, align 4, !tbaa !9
  %408 = load ptr, ptr %5, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.qpilotsync_s, ptr %408, i32 0, i32 1
  %410 = load i32, ptr %409, align 4, !tbaa !14
  %411 = urem i32 %407, %410
  %412 = icmp eq i32 %411, 0
  br i1 %412, label %413, label %465

413:                                              ; preds = %402
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #5
  %414 = load ptr, ptr %5, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.qpilotsync_s, ptr %414, i32 0, i32 4
  %416 = load ptr, ptr %415, align 8, !tbaa !15
  %417 = load i32, ptr %10, align 4, !tbaa !9
  %418 = zext i32 %417 to i64
  %419 = getelementptr inbounds { float, float }, ptr %416, i64 %418
  %420 = getelementptr inbounds { float, float }, ptr %419, i32 0, i32 0
  %421 = load float, ptr %420, align 4
  %422 = getelementptr inbounds { float, float }, ptr %419, i32 0, i32 1
  %423 = load float, ptr %422, align 4
  %424 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %425 = load float, ptr %424, align 4
  %426 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  %427 = load float, ptr %426, align 4
  %428 = fsub float %421, %425
  %429 = fsub float %423, %427
  %430 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %431 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  store float %428, ptr %430, align 4
  store float %429, ptr %431, align 4
  %432 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %433 = load float, ptr %432, align 4
  %434 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  %435 = load float, ptr %434, align 4
  %436 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %437 = load float, ptr %436, align 4
  %438 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  %439 = load float, ptr %438, align 4
  %440 = fneg float %439
  %441 = fmul float %433, %437
  %442 = fmul float %435, %440
  %443 = fmul float %433, %440
  %444 = fmul float %435, %437
  %445 = fsub float %441, %442
  %446 = fadd float %443, %444
  %447 = fcmp uno float %445, %445
  br i1 %447, label %448, label %456, !prof !16

448:                                              ; preds = %413
  %449 = fcmp uno float %446, %446
  br i1 %449, label %450, label %456, !prof !16

450:                                              ; preds = %448
  %451 = call <2 x float> @__mulsc3(float noundef %433, float noundef %435, float noundef %437, float noundef %440) #5
  store <2 x float> %451, ptr %38, align 4
  %452 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 0
  %453 = load float, ptr %452, align 4
  %454 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 1
  %455 = load float, ptr %454, align 4
  br label %456

456:                                              ; preds = %450, %448, %413
  %457 = phi float [ %445, %413 ], [ %445, %448 ], [ %453, %450 ]
  %458 = phi float [ %446, %413 ], [ %446, %448 ], [ %455, %450 ]
  %459 = load ptr, ptr %5, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.qpilotsync_s, ptr %459, i32 0, i32 12
  %461 = load float, ptr %460, align 4, !tbaa !29
  %462 = fadd float %461, %457
  store float %462, ptr %460, align 4, !tbaa !29
  %463 = load i32, ptr %10, align 4, !tbaa !9
  %464 = add i32 %463, 1
  store i32 %464, ptr %10, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #5
  br label %477

465:                                              ; preds = %402
  %466 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %467 = load float, ptr %466, align 4
  %468 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  %469 = load float, ptr %468, align 4
  %470 = load ptr, ptr %7, align 8, !tbaa !5
  %471 = load i32, ptr %9, align 4, !tbaa !9
  %472 = add i32 %471, 1
  store i32 %472, ptr %9, align 4, !tbaa !9
  %473 = zext i32 %471 to i64
  %474 = getelementptr inbounds { float, float }, ptr %470, i64 %473
  %475 = getelementptr inbounds { float, float }, ptr %474, i32 0, i32 0
  %476 = getelementptr inbounds { float, float }, ptr %474, i32 0, i32 1
  store float %467, ptr %475, align 4
  store float %469, ptr %476, align 4
  br label %477

477:                                              ; preds = %465, %456
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #5
  br label %478

478:                                              ; preds = %477
  %479 = load i32, ptr %8, align 4, !tbaa !9
  %480 = add i32 %479, 1
  store i32 %480, ptr %8, align 4, !tbaa !9
  br label %350, !llvm.loop !31

481:                                              ; preds = %350
  %482 = load ptr, ptr %5, align 8, !tbaa !5
  %483 = getelementptr inbounds %struct.qpilotsync_s, ptr %482, i32 0, i32 12
  %484 = load float, ptr %483, align 4, !tbaa !29
  %485 = load ptr, ptr %5, align 8, !tbaa !5
  %486 = getelementptr inbounds %struct.qpilotsync_s, ptr %485, i32 0, i32 2
  %487 = load i32, ptr %486, align 8, !tbaa !11
  %488 = uitofp i32 %487 to float
  %489 = fdiv float %484, %488
  %490 = call float @log10f(float noundef %489) #5
  %491 = fmul float 1.000000e+01, %490
  %492 = load ptr, ptr %5, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.qpilotsync_s, ptr %492, i32 0, i32 12
  store float %491, ptr %493, align 4, !tbaa !29
  %494 = load i32, ptr %9, align 4, !tbaa !9
  %495 = load ptr, ptr %5, align 8, !tbaa !5
  %496 = getelementptr inbounds %struct.qpilotsync_s, ptr %495, i32 0, i32 0
  %497 = load i32, ptr %496, align 8, !tbaa !32
  %498 = icmp ne i32 %494, %497
  br i1 %498, label %499, label %501

499:                                              ; preds = %481
  %500 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 288, ptr noundef @.str.5)
  store i32 %500, ptr %4, align 4
  store i32 1, ptr %39, align 4
  br label %510

501:                                              ; preds = %481
  %502 = load i32, ptr %10, align 4, !tbaa !9
  %503 = load ptr, ptr %5, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct.qpilotsync_s, ptr %503, i32 0, i32 2
  %505 = load i32, ptr %504, align 8, !tbaa !11
  %506 = icmp ne i32 %502, %505
  br i1 %506, label %507, label %509

507:                                              ; preds = %501
  %508 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 290, ptr noundef @.str.6)
  store i32 %508, ptr %4, align 4
  store i32 1, ptr %39, align 4
  br label %510

509:                                              ; preds = %501
  store i32 0, ptr %4, align 4
  store i32 1, ptr %39, align 4
  br label %510

510:                                              ; preds = %509, %507, %499
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #5
  %511 = load i32, ptr %4, align 4
  ret i32 %511
}

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

declare i32 @fft_execute(ptr noundef) #3

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

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

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

; Function Attrs: nounwind
declare float @log10f(float noundef) #1

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

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

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

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


; 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 [83 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [59 x i8], align 1

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

; Function Attrs: nounwind uwtable
define dso_local i32 @qpilotsync_execute(ptr nocapture noundef %0, ptr nocapture noundef readonly %1, ptr nocapture noundef writeonly %2) local_unnamed_addr #1 {
  %4 = getelementptr inbounds i8, ptr %0, i64 8
  %5 = load i32, ptr %4, align 8, !tbaa !5
  %.not155 = icmp eq i32 %5, 0
  br i1 %.not155, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %3
  %6 = getelementptr inbounds i8, ptr %0, i64 4
  %7 = getelementptr inbounds i8, ptr %0, i64 16
  %8 = getelementptr inbounds i8, ptr %0, i64 32
  br label %9

9:                                                ; preds = %.lr.ph, %36
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %36 ]
  %10 = load i32, ptr %6, align 4, !tbaa !12
  %11 = trunc nuw i64 %indvars.iv to i32
  %12 = mul i32 %10, %11
  %13 = zext i32 %12 to i64
  %14 = getelementptr inbounds { float, float }, ptr %1, i64 %13
  %15 = load ptr, ptr %7, align 8, !tbaa !13
  %16 = getelementptr inbounds { float, float }, ptr %15, i64 %indvars.iv
  %17 = load <2 x float>, ptr %14, align 4
  %18 = load <2 x float>, ptr %16, align 4
  %19 = extractelement <2 x float> %18, i64 1
  %20 = fneg float %19
  %21 = shufflevector <2 x float> %17, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %22 = fmul <2 x float> %17, %18
  %shift = shufflevector <2 x float> %22, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %23 = fadd <2 x float> %22, %shift
  %24 = extractelement <2 x float> %23, i64 0
  %25 = fmul <2 x float> %21, %18
  %shift189 = shufflevector <2 x float> %25, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %26 = fsub <2 x float> %25, %shift189
  %27 = extractelement <2 x float> %26, i64 0
  %28 = fcmp uno float %24, 0.000000e+00
  br i1 %28, label %29, label %36, !prof !14

29:                                               ; preds = %9
  %30 = fcmp uno float %27, 0.000000e+00
  br i1 %30, label %31, label %36, !prof !14

31:                                               ; preds = %29
  %32 = extractelement <2 x float> %17, i64 0
  %33 = extractelement <2 x float> %17, i64 1
  %34 = extractelement <2 x float> %18, i64 0
  %35 = tail call <2 x float> @__mulsc3(float noundef %32, float noundef %33, float noundef %34, float noundef %20) #5
  %.sroa.049.0.vec.extract = extractelement <2 x float> %35, i64 0
  %.sroa.049.4.vec.extract = extractelement <2 x float> %35, i64 1
  br label %36

36:                                               ; preds = %31, %29, %9
  %37 = phi float [ %24, %9 ], [ %24, %29 ], [ %.sroa.049.0.vec.extract, %31 ]
  %38 = phi float [ %27, %9 ], [ %27, %29 ], [ %.sroa.049.4.vec.extract, %31 ]
  %39 = load ptr, ptr %8, align 8, !tbaa !15
  %40 = getelementptr inbounds { float, float }, ptr %39, i64 %indvars.iv
  %41 = getelementptr inbounds i8, ptr %40, i64 4
  store float %37, ptr %40, align 4
  store float %38, ptr %41, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %42 = load i32, ptr %4, align 8, !tbaa !5
  %43 = zext i32 %42 to i64
  %44 = icmp ult i64 %indvars.iv.next, %43
  br i1 %44, label %9, label %._crit_edge, !llvm.loop !16

._crit_edge:                                      ; preds = %36, %3
  %45 = getelementptr inbounds i8, ptr %0, i64 48
  %46 = load ptr, ptr %45, align 8, !tbaa !18
  %47 = tail call i32 @fft_execute(ptr noundef %46) #5
  %48 = getelementptr inbounds i8, ptr %0, i64 24
  %49 = load i32, ptr %48, align 8, !tbaa !19
  %.not156 = icmp eq i32 %49, 0
  br i1 %.not156, label %._crit_edge136, label %50

50:                                               ; preds = %._crit_edge
  %51 = getelementptr inbounds i8, ptr %0, i64 40
  %.pre = load ptr, ptr %51, align 8, !tbaa !20
  %52 = load <2 x float>, ptr %.pre, align 4
  %53 = tail call float @cabsf(<2 x float> noundef %52) #5
  %.pre177 = load i32, ptr %48, align 8, !tbaa !19
  %54 = icmp ugt i32 %.pre177, 1
  br i1 %54, label %.peel.next, label %._crit_edge136

.peel.next:                                       ; preds = %50, %65
  %indvars.iv163 = phi i64 [ %indvars.iv.next164, %65 ], [ 1, %50 ]
  %.0122132 = phi i32 [ %.1123, %65 ], [ 0, %50 ]
  %.0124131 = phi float [ %.1125, %65 ], [ %53, %50 ]
  %55 = load ptr, ptr %51, align 8, !tbaa !20
  %56 = getelementptr inbounds { float, float }, ptr %55, i64 %indvars.iv163
  %57 = load <2 x float>, ptr %56, align 4
  %58 = tail call float @cabsf(<2 x float> noundef %57) #5
  %59 = fcmp ogt float %58, %.0124131
  br i1 %59, label %._crit_edge179, label %65

._crit_edge179:                                   ; preds = %.peel.next
  %60 = load ptr, ptr %51, align 8, !tbaa !20
  %61 = getelementptr inbounds { float, float }, ptr %60, i64 %indvars.iv163
  %62 = load <2 x float>, ptr %61, align 4
  %63 = tail call float @cabsf(<2 x float> noundef %62) #5
  %64 = trunc nuw i64 %indvars.iv163 to i32
  br label %65

65:                                               ; preds = %.peel.next, %._crit_edge179
  %.1125 = phi float [ %63, %._crit_edge179 ], [ %.0124131, %.peel.next ]
  %.1123 = phi i32 [ %64, %._crit_edge179 ], [ %.0122132, %.peel.next ]
  %indvars.iv.next164 = add nuw nsw i64 %indvars.iv163, 1
  %66 = load i32, ptr %48, align 8, !tbaa !19
  %67 = zext i32 %66 to i64
  %68 = icmp ult i64 %indvars.iv.next164, %67
  br i1 %68, label %.peel.next, label %._crit_edge136, !llvm.loop !21

._crit_edge136:                                   ; preds = %65, %50, %._crit_edge
  %.0124.lcssa = phi float [ 0.000000e+00, %._crit_edge ], [ %53, %50 ], [ %.1125, %65 ]
  %.0122.lcssa = phi i32 [ 0, %._crit_edge ], [ 0, %50 ], [ %.1123, %65 ]
  %.lcssa = phi i32 [ 0, %._crit_edge ], [ %.pre177, %50 ], [ %66, %65 ]
  %69 = add i32 %.0122.lcssa, -1
  %70 = add i32 %69, %.lcssa
  %71 = urem i32 %70, %.lcssa
  %72 = add i32 %.0122.lcssa, 1
  %73 = urem i32 %72, %.lcssa
  %74 = getelementptr inbounds i8, ptr %0, i64 40
  %75 = load ptr, ptr %74, align 8, !tbaa !20
  %76 = zext i32 %73 to i64
  %77 = getelementptr inbounds { float, float }, ptr %75, i64 %76
  %78 = load <2 x float>, ptr %77, align 4
  %79 = tail call float @cabsf(<2 x float> noundef %78) #5
  %80 = load ptr, ptr %74, align 8, !tbaa !20
  %81 = zext i32 %71 to i64
  %82 = getelementptr inbounds { float, float }, ptr %80, i64 %81
  %83 = load <2 x float>, ptr %82, align 4
  %84 = tail call float @cabsf(<2 x float> noundef %83) #5
  %85 = fadd float %79, %84
  %86 = fneg float %.0124.lcssa
  %87 = tail call float @llvm.fmuladd.f32(float %85, float 5.000000e-01, float %86)
  %88 = fsub float %79, %84
  %89 = fmul float %88, 5.000000e-01
  %90 = fmul float %87, 2.000000e+00
  %91 = fdiv float %89, %90
  %92 = uitofp i32 %.0122.lcssa to float
  %93 = fsub float %92, %91
  %94 = load i32, ptr %48, align 8, !tbaa !19
  %95 = lshr i32 %94, 1
  %96 = icmp ugt i32 %.0122.lcssa, %95
  %97 = uitofp i32 %94 to float
  %98 = fsub float %93, %97
  %99 = select i1 %96, float %98, float %93
  %100 = fmul float %99, 2.000000e+00
  %101 = fpext float %100 to double
  %102 = fmul double %101, 0x400921FB54442D18
  %103 = getelementptr inbounds i8, ptr %0, i64 4
  %104 = load i32, ptr %103, align 4, !tbaa !12
  %105 = mul i32 %104, %94
  %106 = uitofp i32 %105 to float
  %107 = fpext float %106 to double
  %108 = fdiv double %102, %107
  %109 = fptrunc double %108 to float
  %110 = getelementptr inbounds i8, ptr %0, i64 56
  store float %109, ptr %110, align 8, !tbaa !23
  %111 = load i32, ptr %4, align 8, !tbaa !5
  %.not157 = icmp eq i32 %111, 0
  br i1 %.not157, label %._crit_edge144, label %.lr.ph143

.lr.ph143:                                        ; preds = %._crit_edge136
  %112 = getelementptr inbounds i8, ptr %0, i64 32
  br label %113

113:                                              ; preds = %.lr.ph143, %155
  %indvars.iv167 = phi i64 [ 0, %.lr.ph143 ], [ %indvars.iv.next168, %155 ]
  %114 = phi <2 x float> [ zeroinitializer, %.lr.ph143 ], [ %157, %155 ]
  %115 = load ptr, ptr %112, align 8, !tbaa !15
  %116 = getelementptr inbounds { float, float }, ptr %115, i64 %indvars.iv167
  %117 = load float, ptr %116, align 4
  %118 = getelementptr inbounds i8, ptr %116, i64 4
  %119 = load float, ptr %118, align 4
  %120 = load float, ptr %110, align 8, !tbaa !23
  %121 = fmul float %120, -0.000000e+00
  %122 = fneg float %120
  %123 = trunc nuw i64 %indvars.iv167 to i32
  %124 = uitofp i32 %123 to float
  %125 = load i32, ptr %103, align 4, !tbaa !12
  %126 = uitofp i32 %125 to float
  %127 = insertelement <2 x float> poison, float %121, i64 0
  %128 = insertelement <2 x float> %127, float %122, i64 1
  %129 = insertelement <2 x float> poison, float %124, i64 0
  %130 = shufflevector <2 x float> %129, <2 x float> poison, <2 x i32> zeroinitializer
  %131 = fmul <2 x float> %128, %130
  %132 = insertelement <2 x float> poison, float %126, i64 0
  %133 = shufflevector <2 x float> %132, <2 x float> poison, <2 x i32> zeroinitializer
  %134 = fmul <2 x float> %131, %133
  %135 = tail call <2 x float> @cexpf(<2 x float> noundef %134) #5
  %136 = insertelement <2 x float> poison, float %117, i64 0
  %137 = shufflevector <2 x float> %136, <2 x float> poison, <2 x i32> zeroinitializer
  %138 = fmul <2 x float> %137, %135
  %139 = insertelement <2 x float> poison, float %119, i64 0
  %140 = shufflevector <2 x float> %139, <2 x float> poison, <2 x i32> zeroinitializer
  %141 = fmul <2 x float> %140, %135
  %142 = shufflevector <2 x float> %141, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %143 = fadd <2 x float> %138, %142
  %144 = fsub <2 x float> %138, %142
  %145 = shufflevector <2 x float> %144, <2 x float> %143, <2 x i32> <i32 0, i32 3>
  %146 = extractelement <2 x float> %144, i64 0
  %147 = fcmp uno float %146, 0.000000e+00
  br i1 %147, label %148, label %155, !prof !14

148:                                              ; preds = %113
  %149 = extractelement <2 x float> %143, i64 1
  %150 = fcmp uno float %149, 0.000000e+00
  br i1 %150, label %151, label %155, !prof !14

151:                                              ; preds = %148
  %152 = extractelement <2 x float> %135, i64 0
  %153 = extractelement <2 x float> %135, i64 1
  %154 = tail call <2 x float> @__mulsc3(float noundef %117, float noundef %119, float noundef %152, float noundef %153) #5
  br label %155

155:                                              ; preds = %151, %148, %113
  %156 = phi <2 x float> [ %145, %113 ], [ %145, %148 ], [ %154, %151 ]
  %157 = fadd <2 x float> %114, %156
  %indvars.iv.next168 = add nuw nsw i64 %indvars.iv167, 1
  %158 = load i32, ptr %4, align 8, !tbaa !5
  %159 = zext i32 %158 to i64
  %160 = icmp ult i64 %indvars.iv.next168, %159
  br i1 %160, label %113, label %._crit_edge144, !llvm.loop !24

._crit_edge144:                                   ; preds = %155, %._crit_edge136
  %161 = phi <2 x float> [ zeroinitializer, %._crit_edge136 ], [ %157, %155 ]
  %162 = tail call float @cargf(<2 x float> noundef %161) #5
  %163 = getelementptr inbounds i8, ptr %0, i64 60
  store float %162, ptr %163, align 4, !tbaa !25
  %164 = tail call float @cabsf(<2 x float> noundef %161) #5
  %165 = load i32, ptr %4, align 8, !tbaa !5
  %166 = uitofp i32 %165 to float
  %167 = fdiv float %164, %166
  %168 = getelementptr inbounds i8, ptr %0, i64 64
  store float %167, ptr %168, align 8, !tbaa !26
  %169 = fdiv float 1.000000e+00, %167
  %170 = getelementptr inbounds i8, ptr %0, i64 68
  store float 0.000000e+00, ptr %170, align 4, !tbaa !27
  %171 = getelementptr inbounds i8, ptr %0, i64 12
  %172 = load i32, ptr %171, align 4, !tbaa !28
  %.not158 = icmp eq i32 %172, 0
  br i1 %.not158, label %._crit_edge152, label %.lr.ph151

.lr.ph151:                                        ; preds = %._crit_edge144
  %173 = getelementptr inbounds i8, ptr %0, i64 16
  br label %174

174:                                              ; preds = %.lr.ph151, %241
  %indvars.iv170 = phi i64 [ 0, %.lr.ph151 ], [ %indvars.iv.next171, %241 ]
  %.0118148 = phi i32 [ 0, %.lr.ph151 ], [ %.1119, %241 ]
  %.0120147 = phi i32 [ 0, %.lr.ph151 ], [ %.1121, %241 ]
  %175 = getelementptr inbounds { float, float }, ptr %1, i64 %indvars.iv170
  %176 = load float, ptr %175, align 4
  %177 = getelementptr inbounds i8, ptr %175, i64 4
  %178 = load float, ptr %177, align 4
  %179 = fmul float %169, %176
  %180 = fmul float %169, %178
  %181 = load float, ptr %110, align 8, !tbaa !23
  %182 = trunc nuw i64 %indvars.iv170 to i32
  %183 = uitofp i32 %182 to float
  %184 = load float, ptr %163, align 4, !tbaa !25
  %185 = tail call float @llvm.fmuladd.f32(float %181, float %183, float %184)
  %186 = fmul float %185, -0.000000e+00
  %187 = fneg float %185
  %.sroa.06.0.vec.insert = insertelement <2 x float> poison, float %186, i64 0
  %.sroa.06.4.vec.insert = insertelement <2 x float> %.sroa.06.0.vec.insert, float %187, i64 1
  %188 = tail call <2 x float> @cexpf(<2 x float> noundef %.sroa.06.4.vec.insert) #5
  %189 = insertelement <2 x float> poison, float %179, i64 0
  %190 = shufflevector <2 x float> %189, <2 x float> poison, <2 x i32> zeroinitializer
  %191 = fmul <2 x float> %190, %188
  %192 = insertelement <2 x float> poison, float %180, i64 0
  %193 = shufflevector <2 x float> %192, <2 x float> poison, <2 x i32> zeroinitializer
  %194 = fmul <2 x float> %193, %188
  %195 = shufflevector <2 x float> %194, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %196 = fsub <2 x float> %191, %195
  %197 = fadd <2 x float> %191, %195
  %198 = shufflevector <2 x float> %196, <2 x float> %197, <2 x i32> <i32 0, i32 3>
  %199 = extractelement <2 x float> %196, i64 0
  %200 = fcmp uno float %199, 0.000000e+00
  br i1 %200, label %201, label %208, !prof !14

201:                                              ; preds = %174
  %202 = extractelement <2 x float> %197, i64 1
  %203 = fcmp uno float %202, 0.000000e+00
  br i1 %203, label %204, label %208, !prof !14

204:                                              ; preds = %201
  %205 = extractelement <2 x float> %188, i64 0
  %206 = extractelement <2 x float> %188, i64 1
  %207 = tail call <2 x float> @__mulsc3(float noundef %179, float noundef %180, float noundef %205, float noundef %206) #5
  br label %208

208:                                              ; preds = %204, %201, %174
  %209 = phi <2 x float> [ %198, %174 ], [ %198, %201 ], [ %207, %204 ]
  %210 = load i32, ptr %103, align 4, !tbaa !12
  %211 = urem i32 %182, %210
  %212 = icmp eq i32 %211, 0
  br i1 %212, label %213, label %237

213:                                              ; preds = %208
  %214 = load ptr, ptr %173, align 8, !tbaa !13
  %215 = zext i32 %.0120147 to i64
  %216 = getelementptr inbounds { float, float }, ptr %214, i64 %215
  %217 = load <2 x float>, ptr %216, align 4
  %218 = fsub <2 x float> %217, %209
  %219 = extractelement <2 x float> %218, i64 1
  %220 = fneg float %219
  %221 = fmul <2 x float> %218, %218
  %shift190 = shufflevector <2 x float> %221, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %222 = fadd <2 x float> %221, %shift190
  %223 = extractelement <2 x float> %222, i64 0
  %224 = fcmp uno float %223, 0.000000e+00
  br i1 %224, label %225, label %232, !prof !14

225:                                              ; preds = %213
  %226 = extractelement <2 x float> %218, i64 0
  %227 = fmul float %226, %219
  %228 = fsub float %227, %227
  %229 = fcmp uno float %228, 0.000000e+00
  br i1 %229, label %230, label %232, !prof !14

230:                                              ; preds = %225
  %231 = tail call <2 x float> @__mulsc3(float noundef %226, float noundef %219, float noundef %226, float noundef %220) #5
  %.sroa.0.0.vec.extract = extractelement <2 x float> %231, i64 0
  br label %232

232:                                              ; preds = %230, %225, %213
  %233 = phi float [ %223, %213 ], [ %223, %225 ], [ %.sroa.0.0.vec.extract, %230 ]
  %234 = load float, ptr %170, align 4, !tbaa !27
  %235 = fadd float %233, %234
  store float %235, ptr %170, align 4, !tbaa !27
  %236 = add i32 %.0120147, 1
  br label %241

237:                                              ; preds = %208
  %238 = add i32 %.0118148, 1
  %239 = zext i32 %.0118148 to i64
  %240 = getelementptr inbounds { float, float }, ptr %2, i64 %239
  store <2 x float> %209, ptr %240, align 4
  br label %241

241:                                              ; preds = %237, %232
  %.1121 = phi i32 [ %236, %232 ], [ %.0120147, %237 ]
  %.1119 = phi i32 [ %.0118148, %232 ], [ %238, %237 ]
  %indvars.iv.next171 = add nuw nsw i64 %indvars.iv170, 1
  %242 = load i32, ptr %171, align 4, !tbaa !28
  %243 = zext i32 %242 to i64
  %244 = icmp ult i64 %indvars.iv.next171, %243
  br i1 %244, label %174, label %._crit_edge152.loopexit, !llvm.loop !29

._crit_edge152.loopexit:                          ; preds = %241
  %.pre180 = load float, ptr %170, align 4, !tbaa !27
  %.pre181 = load i32, ptr %4, align 8, !tbaa !5
  %.pre182 = uitofp i32 %.pre181 to float
  br label %._crit_edge152

._crit_edge152:                                   ; preds = %._crit_edge152.loopexit, %._crit_edge144
  %.pre-phi = phi float [ %.pre182, %._crit_edge152.loopexit ], [ %166, %._crit_edge144 ]
  %245 = phi float [ %.pre180, %._crit_edge152.loopexit ], [ 0.000000e+00, %._crit_edge144 ]
  %.0120.lcssa = phi i32 [ %.1121, %._crit_edge152.loopexit ], [ 0, %._crit_edge144 ]
  %.0118.lcssa = phi i32 [ %.1119, %._crit_edge152.loopexit ], [ 0, %._crit_edge144 ]
  %246 = fdiv float %245, %.pre-phi
  %247 = tail call float @log10f(float noundef %246) #5
  %248 = fmul float %247, 1.000000e+01
  store float %248, ptr %170, align 4, !tbaa !27
  %249 = load i32, ptr %0, align 8, !tbaa !30
  %.not = icmp eq i32 %.0118.lcssa, %249
  br i1 %.not, label %252, label %250

250:                                              ; preds = %._crit_edge152
  %251 = tail call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 288, ptr noundef nonnull @.str.5) #5
  br label %256

252:                                              ; preds = %._crit_edge152
  %253 = load i32, ptr %4, align 8, !tbaa !5
  %.not127 = icmp eq i32 %.0120.lcssa, %253
  br i1 %.not127, label %256, label %254

254:                                              ; preds = %252
  %255 = tail call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 290, ptr noundef nonnull @.str.6) #5
  br label %256

256:                                              ; preds = %252, %254, %250
  %.0 = phi i32 [ %251, %250 ], [ %255, %254 ], [ 0, %252 ]
  ret i32 %.0
}

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

declare i32 @fft_execute(ptr noundef) local_unnamed_addr #2

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

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

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

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

declare i32 @liquid_error_fl(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) local_unnamed_addr #2

attributes #0 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { "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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 #5 = { 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, !7, i64 8}
!6 = !{!"qpilotsync_s", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !10, i64 16, !7, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !11, i64 56, !11, i64 60, !11, i64 64, !11, i64 68}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!"float", !8, i64 0}
!12 = !{!6, !7, i64 4}
!13 = !{!6, !10, i64 16}
!14 = !{!"branch_weights", i32 1, i32 1048575}
!15 = !{!6, !10, i64 32}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}
!18 = !{!6, !10, i64 48}
!19 = !{!6, !7, i64 24}
!20 = !{!6, !10, i64 40}
!21 = distinct !{!21, !17, !22}
!22 = !{!"llvm.loop.peeled.count", i32 1}
!23 = !{!6, !11, i64 56}
!24 = distinct !{!24, !17}
!25 = !{!6, !11, i64 60}
!26 = !{!6, !11, i64 64}
!27 = !{!6, !11, i64 68}
!28 = !{!6, !7, i64 12}
!29 = distinct !{!29, !17}
!30 = !{!6, !7, i64 0}


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