; LLVM IR from jgaeddert/liquid-dsp :: src/multichannel/src (ofdmframesync)

; 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.ofdmframesync_s = type { i32, i32, i32, ptr, i32, i32, i32, i32, i32, i32, float, float, float, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, float, ptr, ptr, ptr, ptr, ptr, ptr, i32, ptr, ptr, float, float, i32, i32, i32, { float, float }, { float, float }, float, float, ptr, ptr }

@.str = external hidden unnamed_addr constant [91 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [64 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 float @cosf(float noundef) #1

; Function Attrs: nounwind
declare float @sinf(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: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #2

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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @ofdmframesync_rxsymbol(ptr noundef %0) #3 {
  %2 = alloca i32, align 4
  %3 = alloca ptr, align 8
  %4 = alloca i32, align 4
  %5 = alloca { float, float }, align 4
  %6 = alloca ptr, align 8
  %7 = alloca i64, align 8
  %8 = alloca i64, align 8
  %9 = alloca [2 x float], align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca { float, float }, align 4
  %13 = alloca i32, align 4
  %14 = alloca { float, float }, align 4
  %15 = alloca { float, float }, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca { float, float }, align 4
  %20 = alloca float, align 4
  store ptr %0, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #6
  store i32 0, ptr %4, align 4, !tbaa !9
  br label %21

21:                                               ; preds = %68, %1
  %22 = load i32, ptr %4, align 4, !tbaa !9
  %23 = load ptr, ptr %3, align 8, !tbaa !5
  %24 = getelementptr inbounds %struct.ofdmframesync_s, ptr %23, i32 0, i32 0
  %25 = load i32, ptr %24, align 8, !tbaa !11
  %26 = icmp ult i32 %22, %25
  br i1 %26, label %27, label %71

27:                                               ; preds = %21
  %28 = load ptr, ptr %3, align 8, !tbaa !5
  %29 = getelementptr inbounds %struct.ofdmframesync_s, ptr %28, i32 0, i32 27
  %30 = load ptr, ptr %29, align 8, !tbaa !14
  %31 = load i32, ptr %4, align 4, !tbaa !9
  %32 = zext i32 %31 to i64
  %33 = getelementptr inbounds { float, float }, ptr %30, i64 %32
  %34 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %35 = load float, ptr %34, align 4
  %36 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  %37 = load float, ptr %36, align 4
  %38 = load ptr, ptr %3, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.ofdmframesync_s, ptr %38, i32 0, i32 14
  %40 = load ptr, ptr %39, align 8, !tbaa !15
  %41 = load i32, ptr %4, align 4, !tbaa !9
  %42 = zext i32 %41 to i64
  %43 = getelementptr inbounds { float, float }, ptr %40, i64 %42
  %44 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 0
  %45 = load float, ptr %44, align 4
  %46 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 1
  %47 = load float, ptr %46, align 4
  %48 = fmul float %45, %35
  %49 = fmul float %47, %37
  %50 = fmul float %45, %37
  %51 = fmul float %47, %35
  %52 = fsub float %48, %49
  %53 = fadd float %50, %51
  %54 = fcmp uno float %52, %52
  br i1 %54, label %55, label %63, !prof !16

55:                                               ; preds = %27
  %56 = fcmp uno float %53, %53
  br i1 %56, label %57, label %63, !prof !16

57:                                               ; preds = %55
  %58 = call <2 x float> @__mulsc3(float noundef %45, float noundef %47, float noundef %35, float noundef %37) #6
  store <2 x float> %58, ptr %5, align 4
  %59 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %60 = load float, ptr %59, align 4
  %61 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %62 = load float, ptr %61, align 4
  br label %63

63:                                               ; preds = %57, %55, %27
  %64 = phi float [ %52, %27 ], [ %52, %55 ], [ %60, %57 ]
  %65 = phi float [ %53, %27 ], [ %53, %55 ], [ %62, %57 ]
  %66 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 0
  %67 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 1
  store float %64, ptr %66, align 4
  store float %65, ptr %67, align 4
  br label %68

68:                                               ; preds = %63
  %69 = load i32, ptr %4, align 4, !tbaa !9
  %70 = add i32 %69, 1
  store i32 %70, ptr %4, align 4, !tbaa !9
  br label %21, !llvm.loop !17

71:                                               ; preds = %21
  %72 = load ptr, ptr %3, align 8, !tbaa !5
  %73 = getelementptr inbounds %struct.ofdmframesync_s, ptr %72, i32 0, i32 6
  %74 = load i32, ptr %73, align 8, !tbaa !19
  %75 = zext i32 %74 to i64
  %76 = call ptr @llvm.stacksave.p0()
  store ptr %76, ptr %6, align 8
  %77 = alloca float, i64 %75, align 16
  store i64 %75, ptr %7, align 8
  %78 = load ptr, ptr %3, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.ofdmframesync_s, ptr %78, i32 0, i32 6
  %80 = load i32, ptr %79, align 8, !tbaa !19
  %81 = zext i32 %80 to i64
  %82 = alloca float, i64 %81, align 16
  store i64 %81, ptr %8, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  store i32 0, ptr %10, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %83 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %84 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  store float 1.000000e+00, ptr %83, align 4
  store float 0.000000e+00, ptr %84, align 4
  store i32 0, ptr %4, align 4, !tbaa !9
  br label %85

85:                                               ; preds = %192, %71
  %86 = load i32, ptr %4, align 4, !tbaa !9
  %87 = load ptr, ptr %3, align 8, !tbaa !5
  %88 = getelementptr inbounds %struct.ofdmframesync_s, ptr %87, i32 0, i32 0
  %89 = load i32, ptr %88, align 8, !tbaa !11
  %90 = icmp ult i32 %86, %89
  br i1 %90, label %91, label %195

91:                                               ; preds = %85
  %92 = load i32, ptr %4, align 4, !tbaa !9
  %93 = load ptr, ptr %3, align 8, !tbaa !5
  %94 = getelementptr inbounds %struct.ofdmframesync_s, ptr %93, i32 0, i32 1
  %95 = load i32, ptr %94, align 4, !tbaa !20
  %96 = add i32 %92, %95
  %97 = load ptr, ptr %3, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.ofdmframesync_s, ptr %97, i32 0, i32 0
  %99 = load i32, ptr %98, align 8, !tbaa !11
  %100 = urem i32 %96, %99
  store i32 %100, ptr %11, align 4, !tbaa !9
  %101 = load ptr, ptr %3, align 8, !tbaa !5
  %102 = getelementptr inbounds %struct.ofdmframesync_s, ptr %101, i32 0, i32 3
  %103 = load ptr, ptr %102, align 8, !tbaa !21
  %104 = load i32, ptr %11, align 4, !tbaa !9
  %105 = zext i32 %104 to i64
  %106 = getelementptr inbounds i8, ptr %103, i64 %105
  %107 = load i8, ptr %106, align 1, !tbaa !22
  %108 = zext i8 %107 to i32
  %109 = icmp eq i32 %108, 1
  br i1 %109, label %110, label %191

110:                                              ; preds = %91
  %111 = load i32, ptr %10, align 4, !tbaa !9
  %112 = load ptr, ptr %3, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.ofdmframesync_s, ptr %112, i32 0, i32 6
  %114 = load i32, ptr %113, align 8, !tbaa !19
  %115 = icmp eq i32 %111, %114
  br i1 %115, label %116, label %118

116:                                              ; preds = %110
  %117 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 1052, ptr noundef @.str.14)
  store i32 %117, ptr %2, align 4
  store i32 1, ptr %13, align 4
  br label %364

118:                                              ; preds = %110
  %119 = load ptr, ptr %3, align 8, !tbaa !5
  %120 = getelementptr inbounds %struct.ofdmframesync_s, ptr %119, i32 0, i32 30
  %121 = load ptr, ptr %120, align 8, !tbaa !23
  %122 = call i32 @msequence_advance(ptr noundef %121)
  %123 = icmp ne i32 %122, 0
  %124 = zext i1 %123 to i64
  %125 = select i1 %123, float 1.000000e+00, float -1.000000e+00
  %126 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %127 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  store float %125, ptr %126, align 4
  store float 0.000000e+00, ptr %127, align 4
  %128 = load i32, ptr %11, align 4, !tbaa !9
  %129 = load ptr, ptr %3, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.ofdmframesync_s, ptr %129, i32 0, i32 1
  %131 = load i32, ptr %130, align 4, !tbaa !20
  %132 = icmp ugt i32 %128, %131
  br i1 %132, label %133, label %141

133:                                              ; preds = %118
  %134 = load i32, ptr %11, align 4, !tbaa !9
  %135 = uitofp i32 %134 to float
  %136 = load ptr, ptr %3, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.ofdmframesync_s, ptr %136, i32 0, i32 0
  %138 = load i32, ptr %137, align 8, !tbaa !11
  %139 = uitofp i32 %138 to float
  %140 = fsub float %135, %139
  br label %144

141:                                              ; preds = %118
  %142 = load i32, ptr %11, align 4, !tbaa !9
  %143 = uitofp i32 %142 to float
  br label %144

144:                                              ; preds = %141, %133
  %145 = phi float [ %140, %133 ], [ %143, %141 ]
  %146 = load i32, ptr %10, align 4, !tbaa !9
  %147 = zext i32 %146 to i64
  %148 = getelementptr inbounds float, ptr %77, i64 %147
  store float %145, ptr %148, align 4, !tbaa !24
  %149 = load ptr, ptr %3, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct.ofdmframesync_s, ptr %149, i32 0, i32 14
  %151 = load ptr, ptr %150, align 8, !tbaa !15
  %152 = load i32, ptr %11, align 4, !tbaa !9
  %153 = zext i32 %152 to i64
  %154 = getelementptr inbounds { float, float }, ptr %151, i64 %153
  %155 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 0
  %156 = load float, ptr %155, align 4
  %157 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 1
  %158 = load float, ptr %157, align 4
  %159 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %160 = load float, ptr %159, align 4
  %161 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %162 = load float, ptr %161, align 4
  %163 = fneg float %162
  %164 = fmul float %156, %160
  %165 = fmul float %158, %163
  %166 = fmul float %156, %163
  %167 = fmul float %158, %160
  %168 = fsub float %164, %165
  %169 = fadd float %166, %167
  %170 = fcmp uno float %168, %168
  br i1 %170, label %171, label %179, !prof !16

171:                                              ; preds = %144
  %172 = fcmp uno float %169, %169
  br i1 %172, label %173, label %179, !prof !16

173:                                              ; preds = %171
  %174 = call <2 x float> @__mulsc3(float noundef %156, float noundef %158, float noundef %160, float noundef %163) #6
  store <2 x float> %174, ptr %14, align 4
  %175 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %176 = load float, ptr %175, align 4
  %177 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  %178 = load float, ptr %177, align 4
  br label %179

179:                                              ; preds = %173, %171, %144
  %180 = phi float [ %168, %144 ], [ %168, %171 ], [ %176, %173 ]
  %181 = phi float [ %169, %144 ], [ %169, %171 ], [ %178, %173 ]
  %182 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %183 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  store float %180, ptr %182, align 4
  store float %181, ptr %183, align 4
  %184 = load <2 x float>, ptr %15, align 4
  %185 = call float @cargf(<2 x float> noundef %184) #6
  %186 = load i32, ptr %10, align 4, !tbaa !9
  %187 = zext i32 %186 to i64
  %188 = getelementptr inbounds float, ptr %82, i64 %187
  store float %185, ptr %188, align 4, !tbaa !24
  %189 = load i32, ptr %10, align 4, !tbaa !9
  %190 = add i32 %189, 1
  store i32 %190, ptr %10, align 4, !tbaa !9
  br label %191

191:                                              ; preds = %179, %91
  br label %192

192:                                              ; preds = %191
  %193 = load i32, ptr %4, align 4, !tbaa !9
  %194 = add i32 %193, 1
  store i32 %194, ptr %4, align 4, !tbaa !9
  br label %85, !llvm.loop !25

195:                                              ; preds = %85
  %196 = load i32, ptr %10, align 4, !tbaa !9
  %197 = load ptr, ptr %3, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct.ofdmframesync_s, ptr %197, i32 0, i32 6
  %199 = load i32, ptr %198, align 8, !tbaa !19
  %200 = icmp ne i32 %196, %199
  br i1 %200, label %201, label %203

201:                                              ; preds = %195
  %202 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 1072, ptr noundef @.str.14)
  store i32 %202, ptr %2, align 4
  store i32 1, ptr %13, align 4
  br label %364

203:                                              ; preds = %195
  %204 = load ptr, ptr %3, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.ofdmframesync_s, ptr %204, i32 0, i32 6
  %206 = load i32, ptr %205, align 8, !tbaa !19
  call void @liquid_unwrap_phase(ptr noundef %82, i32 noundef %206)
  %207 = load ptr, ptr %3, align 8, !tbaa !5
  %208 = getelementptr inbounds %struct.ofdmframesync_s, ptr %207, i32 0, i32 6
  %209 = load i32, ptr %208, align 8, !tbaa !19
  %210 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 0
  %211 = call i32 @polyf_fit(ptr noundef %77, ptr noundef %82, i32 noundef %209, ptr noundef %210, i32 noundef 2)
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  store float 0x3FD3333340000000, ptr %16, align 4, !tbaa !24
  %212 = load float, ptr %16, align 4, !tbaa !24
  %213 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 1
  %214 = load float, ptr %213, align 4, !tbaa !24
  %215 = load float, ptr %16, align 4, !tbaa !24
  %216 = fsub float 1.000000e+00, %215
  %217 = load ptr, ptr %3, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct.ofdmframesync_s, ptr %217, i32 0, i32 32
  %219 = load float, ptr %218, align 4, !tbaa !26
  %220 = fmul float %216, %219
  %221 = call float @llvm.fmuladd.f32(float %212, float %214, float %220)
  %222 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 1
  store float %221, ptr %222, align 4, !tbaa !24
  %223 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 1
  %224 = load float, ptr %223, align 4, !tbaa !24
  %225 = load ptr, ptr %3, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.ofdmframesync_s, ptr %225, i32 0, i32 32
  store float %224, ptr %226, align 4, !tbaa !26
  store i32 0, ptr %4, align 4, !tbaa !9
  br label %227

227:                                              ; preds = %314, %203
  %228 = load i32, ptr %4, align 4, !tbaa !9
  %229 = load ptr, ptr %3, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.ofdmframesync_s, ptr %229, i32 0, i32 0
  %231 = load i32, ptr %230, align 8, !tbaa !11
  %232 = icmp ult i32 %228, %231
  br i1 %232, label %233, label %317

233:                                              ; preds = %227
  %234 = load ptr, ptr %3, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.ofdmframesync_s, ptr %234, i32 0, i32 3
  %236 = load ptr, ptr %235, align 8, !tbaa !21
  %237 = load i32, ptr %4, align 4, !tbaa !9
  %238 = zext i32 %237 to i64
  %239 = getelementptr inbounds i8, ptr %236, i64 %238
  %240 = load i8, ptr %239, align 1, !tbaa !22
  %241 = zext i8 %240 to i32
  %242 = icmp eq i32 %241, 0
  br i1 %242, label %243, label %252

243:                                              ; preds = %233
  %244 = load ptr, ptr %3, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.ofdmframesync_s, ptr %244, i32 0, i32 14
  %246 = load ptr, ptr %245, align 8, !tbaa !15
  %247 = load i32, ptr %4, align 4, !tbaa !9
  %248 = zext i32 %247 to i64
  %249 = getelementptr inbounds { float, float }, ptr %246, i64 %248
  %250 = getelementptr inbounds { float, float }, ptr %249, i32 0, i32 0
  %251 = getelementptr inbounds { float, float }, ptr %249, i32 0, i32 1
  store float 0.000000e+00, ptr %250, align 4
  store float 0.000000e+00, ptr %251, align 4
  br label %313

252:                                              ; preds = %233
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %253 = load i32, ptr %4, align 4, !tbaa !9
  %254 = load ptr, ptr %3, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.ofdmframesync_s, ptr %254, i32 0, i32 1
  %256 = load i32, ptr %255, align 4, !tbaa !20
  %257 = icmp ugt i32 %253, %256
  br i1 %257, label %258, label %266

258:                                              ; preds = %252
  %259 = load i32, ptr %4, align 4, !tbaa !9
  %260 = uitofp i32 %259 to float
  %261 = load ptr, ptr %3, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.ofdmframesync_s, ptr %261, i32 0, i32 0
  %263 = load i32, ptr %262, align 8, !tbaa !11
  %264 = uitofp i32 %263 to float
  %265 = fsub float %260, %264
  br label %269

266:                                              ; preds = %252
  %267 = load i32, ptr %4, align 4, !tbaa !9
  %268 = uitofp i32 %267 to float
  br label %269

269:                                              ; preds = %266, %258
  %270 = phi float [ %265, %258 ], [ %268, %266 ]
  store float %270, ptr %17, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  %271 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 0
  %272 = load float, ptr %17, align 4, !tbaa !24
  %273 = call float @polyf_val(ptr noundef %271, i32 noundef 2, float noundef %272)
  store float %273, ptr %18, align 4, !tbaa !24
  %274 = load float, ptr %18, align 4, !tbaa !24
  %275 = fneg float %274
  %276 = call float @cosf(float noundef %275) #6
  %277 = load float, ptr %18, align 4, !tbaa !24
  %278 = fneg float %277
  %279 = call float @sinf(float noundef %278) #6
  %280 = fmul float 0.000000e+00, %279
  %281 = fmul float 1.000000e+00, %279
  %282 = fadd float %276, %280
  %283 = load ptr, ptr %3, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.ofdmframesync_s, ptr %283, i32 0, i32 14
  %285 = load ptr, ptr %284, align 8, !tbaa !15
  %286 = load i32, ptr %4, align 4, !tbaa !9
  %287 = zext i32 %286 to i64
  %288 = getelementptr inbounds { float, float }, ptr %285, i64 %287
  %289 = getelementptr inbounds { float, float }, ptr %288, i32 0, i32 0
  %290 = load float, ptr %289, align 4
  %291 = getelementptr inbounds { float, float }, ptr %288, i32 0, i32 1
  %292 = load float, ptr %291, align 4
  %293 = fmul float %290, %282
  %294 = fmul float %292, %281
  %295 = fmul float %290, %281
  %296 = fmul float %292, %282
  %297 = fsub float %293, %294
  %298 = fadd float %295, %296
  %299 = fcmp uno float %297, %297
  br i1 %299, label %300, label %308, !prof !16

300:                                              ; preds = %269
  %301 = fcmp uno float %298, %298
  br i1 %301, label %302, label %308, !prof !16

302:                                              ; preds = %300
  %303 = call <2 x float> @__mulsc3(float noundef %290, float noundef %292, float noundef %282, float noundef %281) #6
  store <2 x float> %303, ptr %19, align 4
  %304 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %305 = load float, ptr %304, align 4
  %306 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  %307 = load float, ptr %306, align 4
  br label %308

308:                                              ; preds = %302, %300, %269
  %309 = phi float [ %297, %269 ], [ %297, %300 ], [ %305, %302 ]
  %310 = phi float [ %298, %269 ], [ %298, %300 ], [ %307, %302 ]
  %311 = getelementptr inbounds { float, float }, ptr %288, i32 0, i32 0
  %312 = getelementptr inbounds { float, float }, ptr %288, i32 0, i32 1
  store float %309, ptr %311, align 4
  store float %310, ptr %312, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  br label %313

313:                                              ; preds = %308, %243
  br label %314

314:                                              ; preds = %313
  %315 = load i32, ptr %4, align 4, !tbaa !9
  %316 = add i32 %315, 1
  store i32 %316, ptr %4, align 4, !tbaa !9
  br label %227, !llvm.loop !27

317:                                              ; preds = %227
  %318 = load ptr, ptr %3, align 8, !tbaa !5
  %319 = getelementptr inbounds %struct.ofdmframesync_s, ptr %318, i32 0, i32 34
  %320 = load i32, ptr %319, align 4, !tbaa !28
  %321 = icmp ugt i32 %320, 0
  br i1 %321, label %322, label %355

322:                                              ; preds = %317
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  %323 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 0
  %324 = load float, ptr %323, align 4, !tbaa !24
  %325 = load ptr, ptr %3, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.ofdmframesync_s, ptr %325, i32 0, i32 31
  %327 = load float, ptr %326, align 8, !tbaa !29
  %328 = fsub float %324, %327
  store float %328, ptr %20, align 4, !tbaa !24
  br label %329

329:                                              ; preds = %333, %322
  %330 = load float, ptr %20, align 4, !tbaa !24
  %331 = fpext float %330 to double
  %332 = fcmp ogt double %331, 0x400921FB54442D18
  br i1 %332, label %333, label %338

333:                                              ; preds = %329
  %334 = load float, ptr %20, align 4, !tbaa !24
  %335 = fpext float %334 to double
  %336 = fsub double %335, 0x3FE45F306DC9C883
  %337 = fptrunc double %336 to float
  store float %337, ptr %20, align 4, !tbaa !24
  br label %329, !llvm.loop !30

338:                                              ; preds = %329
  br label %339

339:                                              ; preds = %343, %338
  %340 = load float, ptr %20, align 4, !tbaa !24
  %341 = fpext float %340 to double
  %342 = fcmp olt double %341, 0xC00921FB54442D18
  br i1 %342, label %343, label %348

343:                                              ; preds = %339
  %344 = load float, ptr %20, align 4, !tbaa !24
  %345 = fpext float %344 to double
  %346 = fadd double %345, 0x3FE45F306DC9C883
  %347 = fptrunc double %346 to float
  store float %347, ptr %20, align 4, !tbaa !24
  br label %339, !llvm.loop !31

348:                                              ; preds = %339
  %349 = load ptr, ptr %3, align 8, !tbaa !5
  %350 = getelementptr inbounds %struct.ofdmframesync_s, ptr %349, i32 0, i32 29
  %351 = load ptr, ptr %350, align 8, !tbaa !32
  %352 = load float, ptr %20, align 4, !tbaa !24
  %353 = fmul float 0x3F50624DE0000000, %352
  %354 = call i32 @nco_crcf_adjust_frequency(ptr noundef %351, float noundef %353)
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  br label %355

355:                                              ; preds = %348, %317
  %356 = getelementptr inbounds [2 x float], ptr %9, i64 0, i64 0
  %357 = load float, ptr %356, align 4, !tbaa !24
  %358 = load ptr, ptr %3, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.ofdmframesync_s, ptr %358, i32 0, i32 31
  store float %357, ptr %359, align 8, !tbaa !29
  %360 = load ptr, ptr %3, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.ofdmframesync_s, ptr %360, i32 0, i32 34
  %362 = load i32, ptr %361, align 4, !tbaa !28
  %363 = add i32 %362, 1
  store i32 %363, ptr %361, align 4, !tbaa !28
  store i32 0, ptr %2, align 4
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  br label %364

364:                                              ; preds = %355, %201, %116
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #6
  %365 = load ptr, ptr %6, align 8
  call void @llvm.stackrestore.p0(ptr %365)
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #6
  %366 = load i32, ptr %2, align 4
  ret i32 %366
}

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

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

declare void @liquid_unwrap_phase(ptr noundef, i32 noundef) #5

declare i32 @polyf_fit(ptr noundef, ptr noundef, i32 noundef, ptr noundef, i32 noundef) #5

declare float @polyf_val(ptr noundef, i32 noundef, float noundef) #5

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

declare i32 @msequence_advance(ptr noundef) #5

declare i32 @nco_crcf_adjust_frequency(ptr noundef, float noundef) #5

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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 #4 = { nocallback nofree nosync nounwind willreturn }
attributes #5 = { "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 }

!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 0}
!12 = !{!"ofdmframesync_s", !10, i64 0, !10, i64 4, !10, i64 8, !6, i64 16, !10, i64 24, !10, i64 28, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !13, i64 48, !13, i64 52, !13, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !13, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !6, i64 160, !6, i64 168, !6, i64 176, !10, i64 184, !6, i64 192, !6, i64 200, !13, i64 208, !13, i64 212, !10, i64 216, !10, i64 220, !10, i64 224, !7, i64 228, !7, i64 236, !13, i64 244, !13, i64 248, !6, i64 256, !6, i64 264}
!13 = !{!"float", !7, i64 0}
!14 = !{!12, !6, i64 176}
!15 = !{!12, !6, i64 72}
!16 = !{!"branch_weights", i32 1, i32 1048575}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = !{!12, !10, i64 32}
!20 = !{!12, !10, i64 4}
!21 = !{!12, !6, i64 16}
!22 = !{!7, !7, i64 0}
!23 = !{!12, !6, i64 200}
!24 = !{!13, !13, i64 0}
!25 = distinct !{!25, !18}
!26 = !{!12, !13, i64 212}
!27 = distinct !{!27, !18}
!28 = !{!12, !10, i64 220}
!29 = !{!12, !13, i64 208}
!30 = distinct !{!30, !18}
!31 = distinct !{!31, !18}
!32 = !{!12, !6, i64 192}


; 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 [91 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [64 x i8], align 1

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

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

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @ofdmframesync_rxsymbol(ptr nocapture noundef %0) local_unnamed_addr #4 {
  %2 = alloca [2 x float], align 4
  %3 = load i32, ptr %0, align 8, !tbaa !5
  %.not102 = icmp eq i32 %3, 0
  br i1 %.not102, label %._crit_edge.thread, label %.lr.ph

._crit_edge.thread:                               ; preds = %1
  %4 = getelementptr inbounds i8, ptr %0, i64 32
  %5 = load i32, ptr %4, align 8, !tbaa !12
  %6 = zext i32 %5 to i64
  %7 = alloca float, i64 %6, align 16
  %8 = alloca float, i64 %6, align 16
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %2) #6
  br label %._crit_edge91

.lr.ph:                                           ; preds = %1
  %9 = getelementptr inbounds i8, ptr %0, i64 176
  %10 = getelementptr inbounds i8, ptr %0, i64 72
  br label %11

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

27:                                               ; preds = %11
  %28 = fcmp uno float %25, 0.000000e+00
  br i1 %28, label %29, label %35, !prof !15

29:                                               ; preds = %27
  %30 = extractelement <2 x float> %17, i64 0
  %31 = extractelement <2 x float> %17, i64 1
  %32 = extractelement <2 x float> %18, i64 0
  %33 = extractelement <2 x float> %18, i64 1
  %34 = tail call <2 x float> @__mulsc3(float noundef %32, float noundef %33, float noundef %30, float noundef %31) #6
  %.sroa.024.0.vec.extract = extractelement <2 x float> %34, i64 0
  %.sroa.024.4.vec.extract = extractelement <2 x float> %34, i64 1
  br label %35

35:                                               ; preds = %29, %27, %11
  %36 = phi float [ %23, %11 ], [ %23, %27 ], [ %.sroa.024.0.vec.extract, %29 ]
  %37 = phi float [ %25, %11 ], [ %25, %27 ], [ %.sroa.024.4.vec.extract, %29 ]
  store float %36, ptr %15, align 4
  store float %37, ptr %16, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %38 = load i32, ptr %0, align 8, !tbaa !5
  %39 = zext i32 %38 to i64
  %40 = icmp ult i64 %indvars.iv.next, %39
  br i1 %40, label %11, label %._crit_edge, !llvm.loop !16

._crit_edge:                                      ; preds = %35
  %41 = getelementptr inbounds i8, ptr %0, i64 32
  %42 = load i32, ptr %41, align 8, !tbaa !12
  %43 = zext i32 %42 to i64
  %44 = alloca float, i64 %43, align 16
  %45 = alloca float, i64 %43, align 16
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %2) #6
  %.not103 = icmp eq i32 %38, 0
  br i1 %.not103, label %._crit_edge91, label %.lr.ph90

.lr.ph90:                                         ; preds = %._crit_edge
  %46 = getelementptr inbounds i8, ptr %0, i64 4
  %47 = getelementptr inbounds i8, ptr %0, i64 16
  %48 = getelementptr inbounds i8, ptr %0, i64 200
  %49 = getelementptr inbounds i8, ptr %0, i64 72
  br label %50

50:                                               ; preds = %.lr.ph90, %105
  %51 = phi i32 [ %38, %.lr.ph90 ], [ %106, %105 ]
  %.17388 = phi i32 [ 0, %.lr.ph90 ], [ %107, %105 ]
  %.07487 = phi i32 [ 0, %.lr.ph90 ], [ %.175, %105 ]
  %52 = load i32, ptr %46, align 4, !tbaa !18
  %53 = add i32 %52, %.17388
  %54 = urem i32 %53, %51
  %55 = load ptr, ptr %47, align 8, !tbaa !19
  %56 = zext i32 %54 to i64
  %57 = getelementptr inbounds i8, ptr %55, i64 %56
  %58 = load i8, ptr %57, align 1, !tbaa !20
  %59 = icmp eq i8 %58, 1
  br i1 %59, label %60, label %105

60:                                               ; preds = %50
  %61 = load i32, ptr %41, align 8, !tbaa !12
  %62 = icmp eq i32 %.07487, %61
  br i1 %62, label %63, label %65

63:                                               ; preds = %60
  %64 = tail call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 1052, ptr noundef nonnull @.str.14) #6
  br label %204

65:                                               ; preds = %60
  %66 = load ptr, ptr %48, align 8, !tbaa !21
  %67 = tail call i32 @msequence_advance(ptr noundef %66) #6
  %.not84 = icmp eq i32 %67, 0
  %68 = select i1 %.not84, float -1.000000e+00, float 1.000000e+00
  %69 = load i32, ptr %46, align 4, !tbaa !18
  %70 = icmp ugt i32 %54, %69
  %71 = uitofp i32 %54 to float
  br i1 %70, label %72, label %76

72:                                               ; preds = %65
  %73 = load i32, ptr %0, align 8, !tbaa !5
  %74 = uitofp i32 %73 to float
  %75 = fsub float %71, %74
  br label %76

76:                                               ; preds = %65, %72
  %77 = phi float [ %75, %72 ], [ %71, %65 ]
  %78 = zext i32 %.07487 to i64
  %79 = getelementptr inbounds float, ptr %44, i64 %78
  store float %77, ptr %79, align 4, !tbaa !22
  %80 = load ptr, ptr %49, align 8, !tbaa !14
  %81 = getelementptr inbounds { float, float }, ptr %80, i64 %56
  %82 = load <2 x float>, ptr %81, align 4
  %83 = fmul <2 x float> %82, zeroinitializer
  %84 = shufflevector <2 x float> %83, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %85 = insertelement <2 x float> poison, float %68, i64 0
  %86 = shufflevector <2 x float> %85, <2 x float> poison, <2 x i32> zeroinitializer
  %87 = fmul <2 x float> %86, %82
  %88 = fadd <2 x float> %87, %84
  %89 = fsub <2 x float> %87, %84
  %90 = shufflevector <2 x float> %88, <2 x float> %89, <2 x i32> <i32 0, i32 3>
  %91 = extractelement <2 x float> %88, i64 0
  %92 = fcmp uno float %91, 0.000000e+00
  br i1 %92, label %93, label %100, !prof !15

93:                                               ; preds = %76
  %94 = extractelement <2 x float> %89, i64 1
  %95 = fcmp uno float %94, 0.000000e+00
  br i1 %95, label %96, label %100, !prof !15

96:                                               ; preds = %93
  %97 = extractelement <2 x float> %82, i64 0
  %98 = extractelement <2 x float> %82, i64 1
  %99 = tail call <2 x float> @__mulsc3(float noundef %97, float noundef %98, float noundef %68, float noundef -0.000000e+00) #6
  br label %100

100:                                              ; preds = %96, %93, %76
  %101 = phi <2 x float> [ %90, %76 ], [ %90, %93 ], [ %99, %96 ]
  %102 = tail call float @cargf(<2 x float> noundef %101) #6
  %103 = getelementptr inbounds float, ptr %45, i64 %78
  store float %102, ptr %103, align 4, !tbaa !22
  %104 = add i32 %.07487, 1
  %.pre = load i32, ptr %0, align 8, !tbaa !5
  br label %105

105:                                              ; preds = %50, %100
  %106 = phi i32 [ %.pre, %100 ], [ %51, %50 ]
  %.175 = phi i32 [ %104, %100 ], [ %.07487, %50 ]
  %107 = add nuw i32 %.17388, 1
  %108 = icmp ult i32 %107, %106
  br i1 %108, label %50, label %._crit_edge91.loopexit, !llvm.loop !23

._crit_edge91.loopexit:                           ; preds = %105
  %.pre110 = load i32, ptr %41, align 8, !tbaa !12
  br label %._crit_edge91

._crit_edge91:                                    ; preds = %._crit_edge.thread, %._crit_edge91.loopexit, %._crit_edge
  %109 = phi ptr [ %45, %._crit_edge ], [ %45, %._crit_edge91.loopexit ], [ %8, %._crit_edge.thread ]
  %110 = phi ptr [ %44, %._crit_edge ], [ %44, %._crit_edge91.loopexit ], [ %7, %._crit_edge.thread ]
  %111 = phi ptr [ %41, %._crit_edge ], [ %41, %._crit_edge91.loopexit ], [ %4, %._crit_edge.thread ]
  %112 = phi i32 [ %42, %._crit_edge ], [ %.pre110, %._crit_edge91.loopexit ], [ %5, %._crit_edge.thread ]
  %.074.lcssa = phi i32 [ 0, %._crit_edge ], [ %.175, %._crit_edge91.loopexit ], [ 0, %._crit_edge.thread ]
  %.not = icmp eq i32 %.074.lcssa, %112
  br i1 %.not, label %115, label %113

113:                                              ; preds = %._crit_edge91
  %114 = tail call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 1072, ptr noundef nonnull @.str.14) #6
  br label %204

115:                                              ; preds = %._crit_edge91
  call void @liquid_unwrap_phase(ptr noundef nonnull %109, i32 noundef %112) #6
  %116 = load i32, ptr %111, align 8, !tbaa !12
  %117 = call i32 @polyf_fit(ptr noundef nonnull %110, ptr noundef nonnull %109, i32 noundef %116, ptr noundef nonnull %2, i32 noundef 2) #6
  %118 = getelementptr inbounds i8, ptr %2, i64 4
  %119 = load float, ptr %118, align 4, !tbaa !22
  %120 = getelementptr inbounds i8, ptr %0, i64 212
  %121 = load float, ptr %120, align 4, !tbaa !24
  %122 = fmul float %121, 0x3FE6666660000000
  %123 = call float @llvm.fmuladd.f32(float %119, float 0x3FD3333340000000, float %122)
  store float %123, ptr %118, align 4, !tbaa !22
  store float %123, ptr %120, align 4, !tbaa !24
  %124 = load i32, ptr %0, align 8, !tbaa !5
  %.not104 = icmp eq i32 %124, 0
  br i1 %.not104, label %._crit_edge95, label %.lr.ph94

.lr.ph94:                                         ; preds = %115
  %125 = getelementptr inbounds i8, ptr %0, i64 16
  %126 = getelementptr inbounds i8, ptr %0, i64 4
  %127 = getelementptr inbounds i8, ptr %0, i64 72
  br label %128

128:                                              ; preds = %.lr.ph94, %171
  %indvars.iv107 = phi i64 [ 0, %.lr.ph94 ], [ %indvars.iv.next108, %171 ]
  %129 = phi i32 [ %124, %.lr.ph94 ], [ %172, %171 ]
  %130 = load ptr, ptr %125, align 8, !tbaa !19
  %131 = getelementptr inbounds i8, ptr %130, i64 %indvars.iv107
  %132 = load i8, ptr %131, align 1, !tbaa !20
  %133 = icmp eq i8 %132, 0
  br i1 %133, label %134, label %137

134:                                              ; preds = %128
  %135 = load ptr, ptr %127, align 8, !tbaa !14
  %136 = getelementptr inbounds { float, float }, ptr %135, i64 %indvars.iv107
  store <2 x float> zeroinitializer, ptr %136, align 4
  br label %171

137:                                              ; preds = %128
  %138 = load i32, ptr %126, align 4, !tbaa !18
  %139 = zext i32 %138 to i64
  %140 = icmp ugt i64 %indvars.iv107, %139
  %141 = trunc nuw i64 %indvars.iv107 to i32
  %142 = uitofp i32 %141 to float
  %143 = uitofp i32 %129 to float
  %144 = select i1 %140, float %143, float 0.000000e+00
  %145 = fsub float %142, %144
  %146 = call float @polyf_val(ptr noundef nonnull %2, i32 noundef 2, float noundef %145) #6
  %147 = fneg float %146
  %148 = call float @cosf(float noundef %147) #6
  %149 = call float @sinf(float noundef %147) #6
  %150 = fmul float %149, 0.000000e+00
  %151 = fadd float %148, %150
  %152 = load ptr, ptr %127, align 8, !tbaa !14
  %153 = getelementptr inbounds { float, float }, ptr %152, i64 %indvars.iv107
  %154 = load float, ptr %153, align 4
  %155 = getelementptr inbounds i8, ptr %153, i64 4
  %156 = load float, ptr %155, align 4
  %157 = fmul float %154, %151
  %158 = fmul float %149, %156
  %159 = fmul float %149, %154
  %160 = fmul float %151, %156
  %161 = fsub float %157, %158
  %162 = fadd float %159, %160
  %163 = fcmp uno float %161, 0.000000e+00
  br i1 %163, label %164, label %168, !prof !15

164:                                              ; preds = %137
  %165 = fcmp uno float %162, 0.000000e+00
  br i1 %165, label %166, label %168, !prof !15

166:                                              ; preds = %164
  %167 = call <2 x float> @__mulsc3(float noundef %154, float noundef %156, float noundef %151, float noundef %149) #6
  %.sroa.0.0.vec.extract = extractelement <2 x float> %167, i64 0
  %.sroa.0.4.vec.extract = extractelement <2 x float> %167, i64 1
  br label %168

168:                                              ; preds = %166, %164, %137
  %169 = phi float [ %161, %137 ], [ %161, %164 ], [ %.sroa.0.0.vec.extract, %166 ]
  %170 = phi float [ %162, %137 ], [ %162, %164 ], [ %.sroa.0.4.vec.extract, %166 ]
  store float %169, ptr %153, align 4
  store float %170, ptr %155, align 4
  br label %171

171:                                              ; preds = %134, %168
  %indvars.iv.next108 = add nuw nsw i64 %indvars.iv107, 1
  %172 = load i32, ptr %0, align 8, !tbaa !5
  %173 = zext i32 %172 to i64
  %174 = icmp ult i64 %indvars.iv.next108, %173
  br i1 %174, label %128, label %._crit_edge95, !llvm.loop !25

._crit_edge95:                                    ; preds = %171, %115
  %175 = getelementptr inbounds i8, ptr %0, i64 220
  %176 = load i32, ptr %175, align 4, !tbaa !26
  %.not83 = icmp eq i32 %176, 0
  br i1 %.not83, label %200, label %177

177:                                              ; preds = %._crit_edge95
  %178 = load float, ptr %2, align 4, !tbaa !22
  %179 = getelementptr inbounds i8, ptr %0, i64 208
  %180 = load float, ptr %179, align 8, !tbaa !27
  %181 = fsub float %178, %180
  %182 = fpext float %181 to double
  %183 = fcmp ogt double %182, 0x400921FB54442D18
  br i1 %183, label %.lr.ph97, label %.preheader

.preheader:                                       ; preds = %.lr.ph97, %177
  %.pre-phi = phi double [ %182, %177 ], [ %188, %.lr.ph97 ]
  %.0.lcssa = phi float [ %181, %177 ], [ %187, %.lr.ph97 ]
  %184 = fcmp olt double %.pre-phi, 0xC00921FB54442D18
  br i1 %184, label %.lr.ph99, label %._crit_edge100

.lr.ph97:                                         ; preds = %177, %.lr.ph97
  %185 = phi double [ %188, %.lr.ph97 ], [ %182, %177 ]
  %186 = fadd double %185, 0xBFE45F306DC9C883
  %187 = fptrunc double %186 to float
  %188 = fpext float %187 to double
  %189 = fcmp ogt double %188, 0x400921FB54442D18
  br i1 %189, label %.lr.ph97, label %.preheader, !llvm.loop !28

.lr.ph99:                                         ; preds = %.preheader, %.lr.ph99
  %190 = phi double [ %193, %.lr.ph99 ], [ %.pre-phi, %.preheader ]
  %191 = fadd double %190, 0x3FE45F306DC9C883
  %192 = fptrunc double %191 to float
  %193 = fpext float %192 to double
  %194 = fcmp olt double %193, 0xC00921FB54442D18
  br i1 %194, label %.lr.ph99, label %._crit_edge100, !llvm.loop !29

._crit_edge100:                                   ; preds = %.lr.ph99, %.preheader
  %.1.lcssa = phi float [ %.0.lcssa, %.preheader ], [ %192, %.lr.ph99 ]
  %195 = getelementptr inbounds i8, ptr %0, i64 192
  %196 = load ptr, ptr %195, align 8, !tbaa !30
  %197 = fmul float %.1.lcssa, 0x3F50624DE0000000
  %198 = call i32 @nco_crcf_adjust_frequency(ptr noundef %196, float noundef %197) #6
  %.pre111 = load i32, ptr %175, align 4, !tbaa !26
  %199 = add i32 %.pre111, 1
  br label %200

200:                                              ; preds = %._crit_edge100, %._crit_edge95
  %201 = phi i32 [ %199, %._crit_edge100 ], [ 1, %._crit_edge95 ]
  %202 = load float, ptr %2, align 4, !tbaa !22
  %203 = getelementptr inbounds i8, ptr %0, i64 208
  store float %202, ptr %203, align 8, !tbaa !27
  store i32 %201, ptr %175, align 4, !tbaa !26
  br label %204

204:                                              ; preds = %200, %113, %63
  %.071 = phi i32 [ %64, %63 ], [ %114, %113 ], [ 0, %200 ]
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %2) #6
  ret i32 %.071
}

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

declare void @liquid_unwrap_phase(ptr noundef, i32 noundef) local_unnamed_addr #5

declare i32 @polyf_fit(ptr noundef, ptr noundef, i32 noundef, ptr noundef, i32 noundef) local_unnamed_addr #5

declare float @polyf_val(ptr noundef, i32 noundef, float noundef) local_unnamed_addr #5

declare i32 @msequence_advance(ptr noundef) local_unnamed_addr #5

declare i32 @nco_crcf_adjust_frequency(ptr noundef, float noundef) local_unnamed_addr #5

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 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 #5 = { "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 }

!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 0}
!6 = !{!"ofdmframesync_s", !7, i64 0, !7, i64 4, !7, i64 8, !10, i64 16, !7, i64 24, !7, i64 28, !7, i64 32, !7, i64 36, !7, i64 40, !7, i64 44, !11, i64 48, !11, i64 52, !11, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !11, i64 128, !10, i64 136, !10, i64 144, !10, i64 152, !10, i64 160, !10, i64 168, !10, i64 176, !7, i64 184, !10, i64 192, !10, i64 200, !11, i64 208, !11, i64 212, !7, i64 216, !7, i64 220, !7, i64 224, !8, i64 228, !8, i64 236, !11, i64 244, !11, i64 248, !10, i64 256, !10, i64 264}
!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 32}
!13 = !{!6, !10, i64 176}
!14 = !{!6, !10, i64 72}
!15 = !{!"branch_weights", i32 1, i32 1048575}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}
!18 = !{!6, !7, i64 4}
!19 = !{!6, !10, i64 16}
!20 = !{!8, !8, i64 0}
!21 = !{!6, !10, i64 200}
!22 = !{!11, !11, i64 0}
!23 = distinct !{!23, !17}
!24 = !{!6, !11, i64 212}
!25 = distinct !{!25, !17}
!26 = !{!6, !7, i64 220}
!27 = !{!6, !11, i64 208}
!28 = distinct !{!28, !17}
!29 = distinct !{!29, !17}
!30 = !{!6, !10, i64 192}


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