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

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

; 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

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

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

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #2

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

declare i32 @fft_execute(ptr noundef) #3

; Function Attrs: nounwind uwtable
define dso_local i32 @qdetector_cccf_execute_align(ptr noundef %0, <2 x float> noundef %1) #4 {
  %3 = alloca i32, align 4
  %4 = alloca { float, float }, align 4
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca { float, float }, align 4
  %9 = alloca float, align 4
  %10 = alloca { float, float }, align 4
  %11 = alloca float, align 4
  %12 = alloca { float, float }, align 4
  %13 = alloca float, align 4
  %14 = alloca { float, float }, align 4
  %15 = alloca 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
  %21 = alloca i32, align 4
  %22 = alloca float, align 4
  %23 = alloca { float, float }, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca float, align 4
  %27 = alloca { float, float }, align 4
  %28 = alloca float, align 4
  %29 = alloca { float, float }, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca { float, float }, align 4
  %33 = alloca { float, float }, align 4
  %34 = alloca { float, float }, align 4
  %35 = alloca { float, float }, align 4
  %36 = alloca { float, float }, align 4
  store <2 x float> %1, ptr %4, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  %37 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %38 = load float, ptr %37, align 4
  %39 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %40 = load float, ptr %39, align 4
  %41 = load ptr, ptr %5, align 8, !tbaa !5
  %42 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %41, i32 0, i32 4
  %43 = load ptr, ptr %42, align 8, !tbaa !9
  %44 = load ptr, ptr %5, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %44, i32 0, i32 11
  %46 = load i32, ptr %45, align 8, !tbaa !13
  %47 = add i32 %46, 1
  store i32 %47, ptr %45, align 8, !tbaa !13
  %48 = zext i32 %46 to i64
  %49 = getelementptr inbounds { float, float }, ptr %43, i64 %48
  %50 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 0
  %51 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 1
  store float %38, ptr %50, align 4
  store float %40, ptr %51, align 4
  %52 = load ptr, ptr %5, align 8, !tbaa !5
  %53 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %52, i32 0, i32 11
  %54 = load i32, ptr %53, align 8, !tbaa !13
  %55 = load ptr, ptr %5, align 8, !tbaa !5
  %56 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %55, i32 0, i32 8
  %57 = load i32, ptr %56, align 8, !tbaa !14
  %58 = icmp ult i32 %54, %57
  br i1 %58, label %59, label %60

59:                                               ; preds = %2
  store i32 0, ptr %3, align 4
  br label %552

60:                                               ; preds = %2
  %61 = load ptr, ptr %5, align 8, !tbaa !5
  %62 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %61, i32 0, i32 9
  %63 = load ptr, ptr %62, align 8, !tbaa !15
  %64 = call i32 @fft_execute(ptr noundef %63)
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  store i32 0, ptr %6, align 4, !tbaa !16
  br label %65

65:                                               ; preds = %132, %60
  %66 = load i32, ptr %6, align 4, !tbaa !16
  %67 = load ptr, ptr %5, align 8, !tbaa !5
  %68 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %67, i32 0, i32 8
  %69 = load i32, ptr %68, align 8, !tbaa !14
  %70 = icmp ult i32 %66, %69
  br i1 %70, label %71, label %135

71:                                               ; preds = %65
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #6
  %72 = load i32, ptr %6, align 4, !tbaa !16
  %73 = load ptr, ptr %5, align 8, !tbaa !5
  %74 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %73, i32 0, i32 8
  %75 = load i32, ptr %74, align 8, !tbaa !14
  %76 = add i32 %72, %75
  %77 = load ptr, ptr %5, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %77, i32 0, i32 19
  %79 = load i32, ptr %78, align 8, !tbaa !17
  %80 = sub i32 %76, %79
  %81 = load ptr, ptr %5, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %81, i32 0, i32 8
  %83 = load i32, ptr %82, align 8, !tbaa !14
  %84 = urem i32 %80, %83
  store i32 %84, ptr %7, align 4, !tbaa !16
  %85 = load ptr, ptr %5, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %85, i32 0, i32 5
  %87 = load ptr, ptr %86, align 8, !tbaa !18
  %88 = load i32, ptr %6, align 4, !tbaa !16
  %89 = zext i32 %88 to i64
  %90 = getelementptr inbounds { float, float }, ptr %87, i64 %89
  %91 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 0
  %92 = load float, ptr %91, align 4
  %93 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 1
  %94 = load float, ptr %93, align 4
  %95 = load ptr, ptr %5, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %95, i32 0, i32 2
  %97 = load ptr, ptr %96, align 8, !tbaa !19
  %98 = load i32, ptr %7, align 4, !tbaa !16
  %99 = zext i32 %98 to i64
  %100 = getelementptr inbounds { float, float }, ptr %97, i64 %99
  %101 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 0
  %102 = load float, ptr %101, align 4
  %103 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 1
  %104 = load float, ptr %103, align 4
  %105 = fneg float %104
  %106 = fmul float %92, %102
  %107 = fmul float %94, %105
  %108 = fmul float %92, %105
  %109 = fmul float %94, %102
  %110 = fsub float %106, %107
  %111 = fadd float %108, %109
  %112 = fcmp uno float %110, %110
  br i1 %112, label %113, label %121, !prof !20

113:                                              ; preds = %71
  %114 = fcmp uno float %111, %111
  br i1 %114, label %115, label %121, !prof !20

115:                                              ; preds = %113
  %116 = call <2 x float> @__mulsc3(float noundef %92, float noundef %94, float noundef %102, float noundef %105) #6
  store <2 x float> %116, ptr %8, align 4
  %117 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %118 = load float, ptr %117, align 4
  %119 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %120 = load float, ptr %119, align 4
  br label %121

121:                                              ; preds = %115, %113, %71
  %122 = phi float [ %110, %71 ], [ %110, %113 ], [ %118, %115 ]
  %123 = phi float [ %111, %71 ], [ %111, %113 ], [ %120, %115 ]
  %124 = load ptr, ptr %5, align 8, !tbaa !5
  %125 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %124, i32 0, i32 6
  %126 = load ptr, ptr %125, align 8, !tbaa !21
  %127 = load i32, ptr %6, align 4, !tbaa !16
  %128 = zext i32 %127 to i64
  %129 = getelementptr inbounds { float, float }, ptr %126, i64 %128
  %130 = getelementptr inbounds { float, float }, ptr %129, i32 0, i32 0
  %131 = getelementptr inbounds { float, float }, ptr %129, i32 0, i32 1
  store float %122, ptr %130, align 4
  store float %123, ptr %131, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #6
  br label %132

132:                                              ; preds = %121
  %133 = load i32, ptr %6, align 4, !tbaa !16
  %134 = add i32 %133, 1
  store i32 %134, ptr %6, align 4, !tbaa !16
  br label %65, !llvm.loop !22

135:                                              ; preds = %65
  %136 = load ptr, ptr %5, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %136, i32 0, i32 10
  %138 = load ptr, ptr %137, align 8, !tbaa !24
  %139 = call i32 @fft_execute(ptr noundef %138)
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #6
  %140 = load ptr, ptr %5, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %140, i32 0, i32 7
  %142 = load ptr, ptr %141, align 8, !tbaa !25
  %143 = load ptr, ptr %5, align 8, !tbaa !5
  %144 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %143, i32 0, i32 8
  %145 = load i32, ptr %144, align 8, !tbaa !14
  %146 = sub i32 %145, 1
  %147 = zext i32 %146 to i64
  %148 = getelementptr inbounds { float, float }, ptr %142, i64 %147
  %149 = getelementptr inbounds { float, float }, ptr %148, i32 0, i32 0
  %150 = load float, ptr %149, align 4
  %151 = getelementptr inbounds { float, float }, ptr %148, i32 0, i32 1
  %152 = load float, ptr %151, align 4
  %153 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %154 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  store float %150, ptr %153, align 4
  store float %152, ptr %154, align 4
  %155 = load <2 x float>, ptr %10, align 4
  %156 = call float @cabsf(<2 x float> noundef %155) #6
  store float %156, ptr %9, align 4, !tbaa !26
  %157 = load float, ptr %9, align 4, !tbaa !26
  %158 = call float @sqrtf(float noundef %157) #6
  store float %158, ptr %9, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  %159 = load ptr, ptr %5, align 8, !tbaa !5
  %160 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %159, i32 0, i32 7
  %161 = load ptr, ptr %160, align 8, !tbaa !25
  %162 = getelementptr inbounds { float, float }, ptr %161, i64 0
  %163 = getelementptr inbounds { float, float }, ptr %162, i32 0, i32 0
  %164 = load float, ptr %163, align 4
  %165 = getelementptr inbounds { float, float }, ptr %162, i32 0, i32 1
  %166 = load float, ptr %165, align 4
  %167 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %168 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  store float %164, ptr %167, align 4
  store float %166, ptr %168, align 4
  %169 = load <2 x float>, ptr %12, align 4
  %170 = call float @cabsf(<2 x float> noundef %169) #6
  store float %170, ptr %11, align 4, !tbaa !26
  %171 = load float, ptr %11, align 4, !tbaa !26
  %172 = call float @sqrtf(float noundef %171) #6
  store float %172, ptr %11, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %173 = load ptr, ptr %5, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %173, i32 0, i32 7
  %175 = load ptr, ptr %174, align 8, !tbaa !25
  %176 = getelementptr inbounds { float, float }, ptr %175, i64 1
  %177 = getelementptr inbounds { float, float }, ptr %176, i32 0, i32 0
  %178 = load float, ptr %177, align 4
  %179 = getelementptr inbounds { float, float }, ptr %176, i32 0, i32 1
  %180 = load float, ptr %179, align 4
  %181 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %182 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  store float %178, ptr %181, align 4
  store float %180, ptr %182, align 4
  %183 = load <2 x float>, ptr %14, align 4
  %184 = call float @cabsf(<2 x float> noundef %183) #6
  store float %184, ptr %13, align 4, !tbaa !26
  %185 = load float, ptr %13, align 4, !tbaa !26
  %186 = call float @sqrtf(float noundef %185) #6
  store float %186, ptr %13, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #6
  %187 = load float, ptr %13, align 4, !tbaa !26
  %188 = load float, ptr %9, align 4, !tbaa !26
  %189 = fadd float %187, %188
  %190 = load float, ptr %11, align 4, !tbaa !26
  %191 = fneg float %190
  %192 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %189, float %191)
  store float %192, ptr %15, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %193 = load float, ptr %13, align 4, !tbaa !26
  %194 = load float, ptr %9, align 4, !tbaa !26
  %195 = fsub float %193, %194
  %196 = fmul float 5.000000e-01, %195
  store float %196, ptr %16, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %197 = load float, ptr %11, align 4, !tbaa !26
  store float %197, ptr %17, align 4, !tbaa !26
  %198 = load float, ptr %16, align 4, !tbaa !26
  %199 = fneg float %198
  %200 = load float, ptr %15, align 4, !tbaa !26
  %201 = fmul float 2.000000e+00, %200
  %202 = fdiv float %199, %201
  %203 = load ptr, ptr %5, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %203, i32 0, i32 20
  store float %202, ptr %204, align 4, !tbaa !27
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  %205 = load float, ptr %15, align 4, !tbaa !26
  %206 = load ptr, ptr %5, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %206, i32 0, i32 20
  %208 = load float, ptr %207, align 4, !tbaa !27
  %209 = fmul float %205, %208
  %210 = load ptr, ptr %5, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %210, i32 0, i32 20
  %212 = load float, ptr %211, align 4, !tbaa !27
  %213 = load float, ptr %16, align 4, !tbaa !26
  %214 = load ptr, ptr %5, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %214, i32 0, i32 20
  %216 = load float, ptr %215, align 4, !tbaa !27
  %217 = fmul float %213, %216
  %218 = call float @llvm.fmuladd.f32(float %209, float %212, float %217)
  %219 = load float, ptr %17, align 4, !tbaa !26
  %220 = fadd float %218, %219
  store float %220, ptr %18, align 4, !tbaa !26
  %221 = load float, ptr %18, align 4, !tbaa !26
  %222 = load float, ptr %18, align 4, !tbaa !26
  %223 = fmul float %221, %222
  %224 = load ptr, ptr %5, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %224, i32 0, i32 8
  %226 = load i32, ptr %225, align 8, !tbaa !14
  %227 = uitofp i32 %226 to float
  %228 = load ptr, ptr %5, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %228, i32 0, i32 3
  %230 = load float, ptr %229, align 8, !tbaa !28
  %231 = fmul float %227, %230
  %232 = fdiv float %223, %231
  %233 = load ptr, ptr %5, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %233, i32 0, i32 21
  store float %232, ptr %234, align 8, !tbaa !29
  %235 = load ptr, ptr %5, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %235, i32 0, i32 7
  %237 = load ptr, ptr %236, align 8, !tbaa !25
  %238 = load ptr, ptr %5, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %238, i32 0, i32 4
  %240 = load ptr, ptr %239, align 8, !tbaa !9
  %241 = load ptr, ptr %5, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %241, i32 0, i32 8
  %243 = load i32, ptr %242, align 8, !tbaa !14
  %244 = zext i32 %243 to i64
  %245 = mul i64 %244, 8
  call void @llvm.memmove.p0.p0.i64(ptr align 4 %237, ptr align 4 %240, i64 %245, i1 false)
  store i32 0, ptr %6, align 4, !tbaa !16
  br label %246

246:                                              ; preds = %304, %135
  %247 = load i32, ptr %6, align 4, !tbaa !16
  %248 = load ptr, ptr %5, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %248, i32 0, i32 8
  %250 = load i32, ptr %249, align 8, !tbaa !14
  %251 = icmp ult i32 %247, %250
  br i1 %251, label %252, label %307

252:                                              ; preds = %246
  %253 = load i32, ptr %6, align 4, !tbaa !16
  %254 = load ptr, ptr %5, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %254, i32 0, i32 0
  %256 = load i32, ptr %255, align 8, !tbaa !30
  %257 = icmp ult i32 %253, %256
  br i1 %257, label %258, label %270

258:                                              ; preds = %252
  %259 = load ptr, ptr %5, align 8, !tbaa !5
  %260 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %259, i32 0, i32 1
  %261 = load ptr, ptr %260, align 8, !tbaa !31
  %262 = load i32, ptr %6, align 4, !tbaa !16
  %263 = zext i32 %262 to i64
  %264 = getelementptr inbounds { float, float }, ptr %261, i64 %263
  %265 = getelementptr inbounds { float, float }, ptr %264, i32 0, i32 0
  %266 = load float, ptr %265, align 4
  %267 = getelementptr inbounds { float, float }, ptr %264, i32 0, i32 1
  %268 = load float, ptr %267, align 4
  %269 = fneg float %268
  br label %271

270:                                              ; preds = %252
  br label %271

271:                                              ; preds = %270, %258
  %272 = phi float [ %266, %258 ], [ 0.000000e+00, %270 ]
  %273 = phi float [ %269, %258 ], [ 0.000000e+00, %270 ]
  %274 = load ptr, ptr %5, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %274, i32 0, i32 4
  %276 = load ptr, ptr %275, align 8, !tbaa !9
  %277 = load i32, ptr %6, align 4, !tbaa !16
  %278 = zext i32 %277 to i64
  %279 = getelementptr inbounds { float, float }, ptr %276, i64 %278
  %280 = getelementptr inbounds { float, float }, ptr %279, i32 0, i32 0
  %281 = load float, ptr %280, align 4
  %282 = getelementptr inbounds { float, float }, ptr %279, i32 0, i32 1
  %283 = load float, ptr %282, align 4
  %284 = fmul float %281, %272
  %285 = fmul float %283, %273
  %286 = fmul float %281, %273
  %287 = fmul float %283, %272
  %288 = fsub float %284, %285
  %289 = fadd float %286, %287
  %290 = fcmp uno float %288, %288
  br i1 %290, label %291, label %299, !prof !20

291:                                              ; preds = %271
  %292 = fcmp uno float %289, %289
  br i1 %292, label %293, label %299, !prof !20

293:                                              ; preds = %291
  %294 = call <2 x float> @__mulsc3(float noundef %281, float noundef %283, float noundef %272, float noundef %273) #6
  store <2 x float> %294, ptr %19, align 4
  %295 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %296 = load float, ptr %295, align 4
  %297 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  %298 = load float, ptr %297, align 4
  br label %299

299:                                              ; preds = %293, %291, %271
  %300 = phi float [ %288, %271 ], [ %288, %291 ], [ %296, %293 ]
  %301 = phi float [ %289, %271 ], [ %289, %291 ], [ %298, %293 ]
  %302 = getelementptr inbounds { float, float }, ptr %279, i32 0, i32 0
  %303 = getelementptr inbounds { float, float }, ptr %279, i32 0, i32 1
  store float %300, ptr %302, align 4
  store float %301, ptr %303, align 4
  br label %304

304:                                              ; preds = %299
  %305 = load i32, ptr %6, align 4, !tbaa !16
  %306 = add i32 %305, 1
  store i32 %306, ptr %6, align 4, !tbaa !16
  br label %246, !llvm.loop !32

307:                                              ; preds = %246
  %308 = load ptr, ptr %5, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %308, i32 0, i32 9
  %310 = load ptr, ptr %309, align 8, !tbaa !15
  %311 = call i32 @fft_execute(ptr noundef %310)
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  store float 0.000000e+00, ptr %20, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  store i32 0, ptr %21, align 4, !tbaa !16
  store i32 0, ptr %6, align 4, !tbaa !16
  br label %312

312:                                              ; preds = %340, %307
  %313 = load i32, ptr %6, align 4, !tbaa !16
  %314 = load ptr, ptr %5, align 8, !tbaa !5
  %315 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %314, i32 0, i32 8
  %316 = load i32, ptr %315, align 8, !tbaa !14
  %317 = icmp ult i32 %313, %316
  br i1 %317, label %318, label %343

318:                                              ; preds = %312
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %319 = load ptr, ptr %5, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %319, i32 0, i32 5
  %321 = load ptr, ptr %320, align 8, !tbaa !18
  %322 = load i32, ptr %6, align 4, !tbaa !16
  %323 = zext i32 %322 to i64
  %324 = getelementptr inbounds { float, float }, ptr %321, i64 %323
  %325 = getelementptr inbounds { float, float }, ptr %324, i32 0, i32 0
  %326 = load float, ptr %325, align 4
  %327 = getelementptr inbounds { float, float }, ptr %324, i32 0, i32 1
  %328 = load float, ptr %327, align 4
  %329 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %330 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  store float %326, ptr %329, align 4
  store float %328, ptr %330, align 4
  %331 = load <2 x float>, ptr %23, align 4
  %332 = call float @cabsf(<2 x float> noundef %331) #6
  store float %332, ptr %22, align 4, !tbaa !26
  %333 = load float, ptr %22, align 4, !tbaa !26
  %334 = load float, ptr %20, align 4, !tbaa !26
  %335 = fcmp ogt float %333, %334
  br i1 %335, label %336, label %339

336:                                              ; preds = %318
  %337 = load float, ptr %22, align 4, !tbaa !26
  store float %337, ptr %20, align 4, !tbaa !26
  %338 = load i32, ptr %6, align 4, !tbaa !16
  store i32 %338, ptr %21, align 4, !tbaa !16
  br label %339

339:                                              ; preds = %336, %318
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  br label %340

340:                                              ; preds = %339
  %341 = load i32, ptr %6, align 4, !tbaa !16
  %342 = add i32 %341, 1
  store i32 %342, ptr %6, align 4, !tbaa !16
  br label %312, !llvm.loop !33

343:                                              ; preds = %312
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %344 = load i32, ptr %21, align 4, !tbaa !16
  %345 = load ptr, ptr %5, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %345, i32 0, i32 8
  %347 = load i32, ptr %346, align 8, !tbaa !14
  %348 = add i32 %344, %347
  %349 = sub i32 %348, 1
  %350 = load ptr, ptr %5, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %350, i32 0, i32 8
  %352 = load i32, ptr %351, align 8, !tbaa !14
  %353 = urem i32 %349, %352
  store i32 %353, ptr %24, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  %354 = load i32, ptr %21, align 4, !tbaa !16
  %355 = add i32 %354, 1
  %356 = load ptr, ptr %5, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %356, i32 0, i32 8
  %358 = load i32, ptr %357, align 8, !tbaa !14
  %359 = urem i32 %355, %358
  store i32 %359, ptr %25, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %360 = load ptr, ptr %5, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %360, i32 0, i32 5
  %362 = load ptr, ptr %361, align 8, !tbaa !18
  %363 = load i32, ptr %24, align 4, !tbaa !16
  %364 = zext i32 %363 to i64
  %365 = getelementptr inbounds { float, float }, ptr %362, i64 %364
  %366 = getelementptr inbounds { float, float }, ptr %365, i32 0, i32 0
  %367 = load float, ptr %366, align 4
  %368 = getelementptr inbounds { float, float }, ptr %365, i32 0, i32 1
  %369 = load float, ptr %368, align 4
  %370 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %371 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  store float %367, ptr %370, align 4
  store float %369, ptr %371, align 4
  %372 = load <2 x float>, ptr %27, align 4
  %373 = call float @cabsf(<2 x float> noundef %372) #6
  store float %373, ptr %26, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %374 = load ptr, ptr %5, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %374, i32 0, i32 5
  %376 = load ptr, ptr %375, align 8, !tbaa !18
  %377 = load i32, ptr %25, align 4, !tbaa !16
  %378 = zext i32 %377 to i64
  %379 = getelementptr inbounds { float, float }, ptr %376, i64 %378
  %380 = getelementptr inbounds { float, float }, ptr %379, i32 0, i32 0
  %381 = load float, ptr %380, align 4
  %382 = getelementptr inbounds { float, float }, ptr %379, i32 0, i32 1
  %383 = load float, ptr %382, align 4
  %384 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %385 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  store float %381, ptr %384, align 4
  store float %383, ptr %385, align 4
  %386 = load <2 x float>, ptr %29, align 4
  %387 = call float @cabsf(<2 x float> noundef %386) #6
  store float %387, ptr %28, align 4, !tbaa !26
  %388 = load float, ptr %28, align 4, !tbaa !26
  %389 = load float, ptr %26, align 4, !tbaa !26
  %390 = fadd float %388, %389
  %391 = load float, ptr %20, align 4, !tbaa !26
  %392 = fneg float %391
  %393 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %390, float %392)
  store float %393, ptr %15, align 4, !tbaa !26
  %394 = load float, ptr %28, align 4, !tbaa !26
  %395 = load float, ptr %26, align 4, !tbaa !26
  %396 = fsub float %394, %395
  %397 = fmul float 5.000000e-01, %396
  store float %397, ptr %16, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %398 = load float, ptr %16, align 4, !tbaa !26
  %399 = fneg float %398
  %400 = load float, ptr %15, align 4, !tbaa !26
  %401 = fmul float 2.000000e+00, %400
  %402 = fdiv float %399, %401
  store float %402, ptr %30, align 4, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %403 = load i32, ptr %21, align 4, !tbaa !16
  %404 = uitofp i32 %403 to float
  %405 = load float, ptr %30, align 4, !tbaa !26
  %406 = fadd float %404, %405
  store float %406, ptr %31, align 4, !tbaa !26
  %407 = load i32, ptr %21, align 4, !tbaa !16
  %408 = load ptr, ptr %5, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %408, i32 0, i32 8
  %410 = load i32, ptr %409, align 8, !tbaa !14
  %411 = udiv i32 %410, 2
  %412 = icmp ugt i32 %407, %411
  br i1 %412, label %413, label %420

413:                                              ; preds = %343
  %414 = load float, ptr %31, align 4, !tbaa !26
  %415 = load ptr, ptr %5, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %415, i32 0, i32 8
  %417 = load i32, ptr %416, align 8, !tbaa !14
  %418 = uitofp i32 %417 to float
  %419 = fsub float %414, %418
  br label %422

420:                                              ; preds = %343
  %421 = load float, ptr %31, align 4, !tbaa !26
  br label %422

422:                                              ; preds = %420, %413
  %423 = phi float [ %419, %413 ], [ %421, %420 ]
  %424 = fmul float %423, 2.000000e+00
  %425 = fpext float %424 to double
  %426 = fmul double %425, 0x400921FB54442D18
  %427 = load ptr, ptr %5, align 8, !tbaa !5
  %428 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %427, i32 0, i32 8
  %429 = load i32, ptr %428, align 8, !tbaa !14
  %430 = uitofp i32 %429 to float
  %431 = fpext float %430 to double
  %432 = fdiv double %426, %431
  %433 = fptrunc double %432 to float
  %434 = load ptr, ptr %5, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %434, i32 0, i32 22
  store float %433, ptr %435, align 4, !tbaa !34
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  %436 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %437 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  store float 0.000000e+00, ptr %436, align 4
  store float 0.000000e+00, ptr %437, align 4
  store i32 0, ptr %6, align 4, !tbaa !16
  br label %438

438:                                              ; preds = %498, %422
  %439 = load i32, ptr %6, align 4, !tbaa !16
  %440 = load ptr, ptr %5, align 8, !tbaa !5
  %441 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %440, i32 0, i32 0
  %442 = load i32, ptr %441, align 8, !tbaa !30
  %443 = icmp ult i32 %439, %442
  br i1 %443, label %444, label %501

444:                                              ; preds = %438
  %445 = load ptr, ptr %5, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %445, i32 0, i32 4
  %447 = load ptr, ptr %446, align 8, !tbaa !9
  %448 = load i32, ptr %6, align 4, !tbaa !16
  %449 = zext i32 %448 to i64
  %450 = getelementptr inbounds { float, float }, ptr %447, i64 %449
  %451 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 0
  %452 = load float, ptr %451, align 4
  %453 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 1
  %454 = load float, ptr %453, align 4
  %455 = load ptr, ptr %5, align 8, !tbaa !5
  %456 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %455, i32 0, i32 22
  %457 = load float, ptr %456, align 4, !tbaa !34
  %458 = fmul float -0.000000e+00, %457
  %459 = fmul float -1.000000e+00, %457
  %460 = load i32, ptr %6, align 4, !tbaa !16
  %461 = uitofp i32 %460 to float
  %462 = fmul float %458, %461
  %463 = fmul float %459, %461
  %464 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %465 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  store float %462, ptr %464, align 4
  store float %463, ptr %465, align 4
  %466 = load <2 x float>, ptr %33, align 4
  %467 = call <2 x float> @cexpf(<2 x float> noundef %466) #6
  store <2 x float> %467, ptr %34, align 4
  %468 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 0
  %469 = load float, ptr %468, align 4
  %470 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 1
  %471 = load float, ptr %470, align 4
  %472 = fmul float %452, %469
  %473 = fmul float %454, %471
  %474 = fmul float %452, %471
  %475 = fmul float %454, %469
  %476 = fsub float %472, %473
  %477 = fadd float %474, %475
  %478 = fcmp uno float %476, %476
  br i1 %478, label %479, label %487, !prof !20

479:                                              ; preds = %444
  %480 = fcmp uno float %477, %477
  br i1 %480, label %481, label %487, !prof !20

481:                                              ; preds = %479
  %482 = call <2 x float> @__mulsc3(float noundef %452, float noundef %454, float noundef %469, float noundef %471) #6
  store <2 x float> %482, ptr %35, align 4
  %483 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 0
  %484 = load float, ptr %483, align 4
  %485 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 1
  %486 = load float, ptr %485, align 4
  br label %487

487:                                              ; preds = %481, %479, %444
  %488 = phi float [ %476, %444 ], [ %476, %479 ], [ %484, %481 ]
  %489 = phi float [ %477, %444 ], [ %477, %479 ], [ %486, %481 ]
  %490 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %491 = load float, ptr %490, align 4
  %492 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  %493 = load float, ptr %492, align 4
  %494 = fadd float %491, %488
  %495 = fadd float %493, %489
  %496 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %497 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  store float %494, ptr %496, align 4
  store float %495, ptr %497, align 4
  br label %498

498:                                              ; preds = %487
  %499 = load i32, ptr %6, align 4, !tbaa !16
  %500 = add i32 %499, 1
  store i32 %500, ptr %6, align 4, !tbaa !16
  br label %438, !llvm.loop !35

501:                                              ; preds = %438
  %502 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %503 = load float, ptr %502, align 4
  %504 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  %505 = load float, ptr %504, align 4
  %506 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %507 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  store float %503, ptr %506, align 4
  store float %505, ptr %507, align 4
  %508 = load <2 x float>, ptr %36, align 4
  %509 = call float @cargf(<2 x float> noundef %508) #6
  %510 = load ptr, ptr %5, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %510, i32 0, i32 23
  store float %509, ptr %511, align 8, !tbaa !36
  %512 = load ptr, ptr %5, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %512, i32 0, i32 25
  store i32 1, ptr %513, align 8, !tbaa !37
  %514 = load ptr, ptr %5, align 8, !tbaa !5
  %515 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %514, i32 0, i32 4
  %516 = load ptr, ptr %515, align 8, !tbaa !9
  %517 = load ptr, ptr %5, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %517, i32 0, i32 7
  %519 = load ptr, ptr %518, align 8, !tbaa !25
  %520 = load ptr, ptr %5, align 8, !tbaa !5
  %521 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %520, i32 0, i32 8
  %522 = load i32, ptr %521, align 8, !tbaa !14
  %523 = udiv i32 %522, 2
  %524 = zext i32 %523 to i64
  %525 = getelementptr inbounds { float, float }, ptr %519, i64 %524
  %526 = load ptr, ptr %5, align 8, !tbaa !5
  %527 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %526, i32 0, i32 8
  %528 = load i32, ptr %527, align 8, !tbaa !14
  %529 = udiv i32 %528, 2
  %530 = zext i32 %529 to i64
  %531 = mul i64 %530, 8
  call void @llvm.memmove.p0.p0.i64(ptr align 4 %516, ptr align 4 %525, i64 %531, i1 false)
  %532 = load ptr, ptr %5, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %532, i32 0, i32 24
  store i32 0, ptr %533, align 4, !tbaa !38
  %534 = load ptr, ptr %5, align 8, !tbaa !5
  %535 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %534, i32 0, i32 4
  %536 = load ptr, ptr %535, align 8, !tbaa !9
  %537 = load ptr, ptr %5, align 8, !tbaa !5
  %538 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %537, i32 0, i32 8
  %539 = load i32, ptr %538, align 8, !tbaa !14
  %540 = udiv i32 %539, 2
  %541 = call float @liquid_sumsqcf(ptr noundef %536, i32 noundef %540)
  %542 = load ptr, ptr %5, align 8, !tbaa !5
  %543 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %542, i32 0, i32 16
  store float %541, ptr %543, align 4, !tbaa !39
  %544 = load ptr, ptr %5, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %544, i32 0, i32 17
  store float 0.000000e+00, ptr %545, align 8, !tbaa !40
  %546 = load ptr, ptr %5, align 8, !tbaa !5
  %547 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %546, i32 0, i32 8
  %548 = load i32, ptr %547, align 8, !tbaa !14
  %549 = udiv i32 %548, 2
  %550 = load ptr, ptr %5, align 8, !tbaa !5
  %551 = getelementptr inbounds %struct.qdetector_cccf_s, ptr %550, i32 0, i32 11
  store i32 %549, ptr %551, align 8, !tbaa !13
  store i32 0, ptr %3, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  br label %552

552:                                              ; preds = %501, %59
  %553 = load i32, ptr %3, align 4
  ret i32 %553
}

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

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

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

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 nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind 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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 32}
!10 = !{!"qdetector_cccf_s", !11, i64 0, !6, i64 8, !6, i64 16, !12, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !11, i64 64, !6, i64 72, !6, i64 80, !11, i64 88, !12, i64 92, !12, i64 96, !11, i64 100, !11, i64 104, !12, i64 108, !12, i64 112, !12, i64 116, !11, i64 120, !12, i64 124, !12, i64 128, !12, i64 132, !12, i64 136, !11, i64 140, !11, i64 144}
!11 = !{!"int", !7, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!10, !11, i64 88}
!14 = !{!10, !11, i64 64}
!15 = !{!10, !6, i64 72}
!16 = !{!11, !11, i64 0}
!17 = !{!10, !11, i64 120}
!18 = !{!10, !6, i64 40}
!19 = !{!10, !6, i64 16}
!20 = !{!"branch_weights", i32 1, i32 1048575}
!21 = !{!10, !6, i64 48}
!22 = distinct !{!22, !23}
!23 = !{!"llvm.loop.mustprogress"}
!24 = !{!10, !6, i64 80}
!25 = !{!10, !6, i64 56}
!26 = !{!12, !12, i64 0}
!27 = !{!10, !12, i64 124}
!28 = !{!10, !12, i64 24}
!29 = !{!10, !12, i64 128}
!30 = !{!10, !11, i64 0}
!31 = !{!10, !6, i64 8}
!32 = distinct !{!32, !23}
!33 = distinct !{!33, !23}
!34 = !{!10, !12, i64 132}
!35 = distinct !{!35, !23}
!36 = !{!10, !12, i64 136}
!37 = !{!10, !11, i64 144}
!38 = !{!10, !11, i64 140}
!39 = !{!10, !12, i64 108}
!40 = !{!10, !12, i64 112}


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

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

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

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

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #1

declare float @liquid_sumsqcf(ptr noundef, i32 noundef) local_unnamed_addr #2

declare i32 @fft_execute(ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @qdetector_cccf_execute_align(ptr nocapture noundef %0, <2 x float> noundef %1) local_unnamed_addr #3 {
  %3 = getelementptr inbounds i8, ptr %0, i64 32
  %4 = load ptr, ptr %3, align 8, !tbaa !5
  %5 = getelementptr inbounds i8, ptr %0, i64 88
  %6 = load i32, ptr %5, align 8, !tbaa !12
  %7 = add i32 %6, 1
  store i32 %7, ptr %5, align 8, !tbaa !12
  %8 = zext i32 %6 to i64
  %9 = getelementptr inbounds { float, float }, ptr %4, i64 %8
  store <2 x float> %1, ptr %9, align 4
  %10 = load i32, ptr %5, align 8, !tbaa !12
  %11 = getelementptr inbounds i8, ptr %0, i64 64
  %12 = load i32, ptr %11, align 8, !tbaa !13
  %13 = icmp ult i32 %10, %12
  br i1 %13, label %262, label %14

14:                                               ; preds = %2
  %15 = getelementptr inbounds i8, ptr %0, i64 72
  %16 = load ptr, ptr %15, align 8, !tbaa !14
  %17 = tail call i32 @fft_execute(ptr noundef %16) #6
  %18 = load i32, ptr %11, align 8, !tbaa !13
  %.not = icmp eq i32 %18, 0
  br i1 %.not, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %14
  %19 = getelementptr inbounds i8, ptr %0, i64 120
  %20 = getelementptr inbounds i8, ptr %0, i64 40
  %21 = getelementptr inbounds i8, ptr %0, i64 16
  %22 = getelementptr inbounds i8, ptr %0, i64 48
  br label %23

23:                                               ; preds = %.lr.ph, %54
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %54 ]
  %24 = phi i32 [ %18, %.lr.ph ], [ %60, %54 ]
  %25 = trunc nuw i64 %indvars.iv to i32
  %26 = add i32 %24, %25
  %27 = load i32, ptr %19, align 8, !tbaa !15
  %28 = sub i32 %26, %27
  %29 = urem i32 %28, %24
  %30 = load ptr, ptr %20, align 8, !tbaa !16
  %31 = getelementptr inbounds { float, float }, ptr %30, i64 %indvars.iv
  %32 = load ptr, ptr %21, align 8, !tbaa !17
  %33 = zext i32 %29 to i64
  %34 = getelementptr inbounds { float, float }, ptr %32, i64 %33
  %35 = load <2 x float>, ptr %31, align 4
  %36 = load <2 x float>, ptr %34, align 4
  %37 = extractelement <2 x float> %36, i64 1
  %38 = fneg float %37
  %39 = shufflevector <2 x float> %35, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %40 = fmul <2 x float> %35, %36
  %shift = shufflevector <2 x float> %40, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %41 = fadd <2 x float> %40, %shift
  %42 = extractelement <2 x float> %41, i64 0
  %43 = fmul <2 x float> %39, %36
  %shift186 = shufflevector <2 x float> %43, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %44 = fsub <2 x float> %43, %shift186
  %45 = extractelement <2 x float> %44, i64 0
  %46 = fcmp uno float %42, 0.000000e+00
  br i1 %46, label %47, label %54, !prof !18

47:                                               ; preds = %23
  %48 = fcmp uno float %45, 0.000000e+00
  br i1 %48, label %49, label %54, !prof !18

49:                                               ; preds = %47
  %50 = extractelement <2 x float> %35, i64 0
  %51 = extractelement <2 x float> %35, i64 1
  %52 = extractelement <2 x float> %36, i64 0
  %53 = tail call <2 x float> @__mulsc3(float noundef %50, float noundef %51, float noundef %52, float noundef %38) #6
  %.sroa.055.0.vec.extract = extractelement <2 x float> %53, i64 0
  %.sroa.055.4.vec.extract = extractelement <2 x float> %53, i64 1
  br label %54

54:                                               ; preds = %49, %47, %23
  %55 = phi float [ %42, %23 ], [ %42, %47 ], [ %.sroa.055.0.vec.extract, %49 ]
  %56 = phi float [ %45, %23 ], [ %45, %47 ], [ %.sroa.055.4.vec.extract, %49 ]
  %57 = load ptr, ptr %22, align 8, !tbaa !19
  %58 = getelementptr inbounds { float, float }, ptr %57, i64 %indvars.iv
  %59 = getelementptr inbounds i8, ptr %58, i64 4
  store float %55, ptr %58, align 4
  store float %56, ptr %59, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %60 = load i32, ptr %11, align 8, !tbaa !13
  %61 = zext i32 %60 to i64
  %62 = icmp ult i64 %indvars.iv.next, %61
  br i1 %62, label %23, label %._crit_edge, !llvm.loop !20

._crit_edge:                                      ; preds = %54, %14
  %63 = getelementptr inbounds i8, ptr %0, i64 80
  %64 = load ptr, ptr %63, align 8, !tbaa !22
  %65 = tail call i32 @fft_execute(ptr noundef %64) #6
  %66 = getelementptr inbounds i8, ptr %0, i64 56
  %67 = load ptr, ptr %66, align 8, !tbaa !23
  %68 = load i32, ptr %11, align 8, !tbaa !13
  %69 = add i32 %68, -1
  %70 = zext i32 %69 to i64
  %71 = getelementptr inbounds { float, float }, ptr %67, i64 %70
  %72 = load <2 x float>, ptr %71, align 4
  %73 = tail call float @cabsf(<2 x float> noundef %72) #6
  %74 = tail call float @sqrtf(float noundef %73) #6
  %75 = load ptr, ptr %66, align 8, !tbaa !23
  %76 = load <2 x float>, ptr %75, align 4
  %77 = tail call float @cabsf(<2 x float> noundef %76) #6
  %78 = tail call float @sqrtf(float noundef %77) #6
  %79 = load ptr, ptr %66, align 8, !tbaa !23
  %80 = getelementptr inbounds i8, ptr %79, i64 8
  %81 = load <2 x float>, ptr %80, align 4
  %82 = tail call float @cabsf(<2 x float> noundef %81) #6
  %83 = tail call float @sqrtf(float noundef %82) #6
  %84 = fadd float %74, %83
  %85 = fneg float %78
  %86 = tail call float @llvm.fmuladd.f32(float %84, float 5.000000e-01, float %85)
  %87 = fsub float %83, %74
  %88 = fmul float %87, 5.000000e-01
  %89 = fneg float %88
  %90 = fmul float %86, 2.000000e+00
  %91 = fdiv float %89, %90
  %92 = getelementptr inbounds i8, ptr %0, i64 124
  store float %91, ptr %92, align 4, !tbaa !24
  %93 = fmul float %86, %91
  %94 = fmul float %88, %91
  %95 = tail call float @llvm.fmuladd.f32(float %93, float %91, float %94)
  %96 = fadd float %78, %95
  %97 = fmul float %96, %96
  %98 = load i32, ptr %11, align 8, !tbaa !13
  %99 = uitofp i32 %98 to float
  %100 = getelementptr inbounds i8, ptr %0, i64 24
  %101 = load float, ptr %100, align 8, !tbaa !25
  %102 = fmul float %101, %99
  %103 = fdiv float %97, %102
  %104 = getelementptr inbounds i8, ptr %0, i64 128
  store float %103, ptr %104, align 8, !tbaa !26
  %105 = load ptr, ptr %66, align 8, !tbaa !23
  %106 = load ptr, ptr %3, align 8, !tbaa !5
  %107 = zext i32 %98 to i64
  %108 = shl nuw nsw i64 %107, 3
  tail call void @llvm.memmove.p0.p0.i64(ptr align 4 %105, ptr align 4 %106, i64 %108, i1 false)
  %109 = load i32, ptr %11, align 8, !tbaa !13
  %.not164 = icmp eq i32 %109, 0
  br i1 %.not164, label %._crit_edge147, label %.lr.ph146

.lr.ph146:                                        ; preds = %._crit_edge
  %110 = getelementptr inbounds i8, ptr %0, i64 8
  br label %111

111:                                              ; preds = %.lr.ph146, %141
  %indvars.iv171 = phi i64 [ 0, %.lr.ph146 ], [ %indvars.iv.next172, %141 ]
  %112 = load i32, ptr %0, align 8, !tbaa !27
  %113 = zext i32 %112 to i64
  %114 = icmp ult i64 %indvars.iv171, %113
  br i1 %114, label %115, label %122

115:                                              ; preds = %111
  %116 = load ptr, ptr %110, align 8, !tbaa !28
  %117 = getelementptr inbounds { float, float }, ptr %116, i64 %indvars.iv171
  %118 = load float, ptr %117, align 4
  %119 = getelementptr inbounds i8, ptr %117, i64 4
  %120 = load float, ptr %119, align 4
  %121 = fneg float %120
  br label %122

122:                                              ; preds = %111, %115
  %123 = phi float [ %118, %115 ], [ 0.000000e+00, %111 ]
  %124 = phi float [ %121, %115 ], [ 0.000000e+00, %111 ]
  %125 = load ptr, ptr %3, align 8, !tbaa !5
  %126 = getelementptr inbounds { float, float }, ptr %125, i64 %indvars.iv171
  %127 = load float, ptr %126, align 4
  %128 = getelementptr inbounds i8, ptr %126, i64 4
  %129 = load float, ptr %128, align 4
  %130 = fmul float %123, %127
  %131 = fmul float %124, %129
  %132 = fmul float %124, %127
  %133 = fmul float %123, %129
  %134 = fsub float %130, %131
  %135 = fadd float %132, %133
  %136 = fcmp uno float %134, 0.000000e+00
  br i1 %136, label %137, label %141, !prof !18

137:                                              ; preds = %122
  %138 = fcmp uno float %135, 0.000000e+00
  br i1 %138, label %139, label %141, !prof !18

139:                                              ; preds = %137
  %140 = tail call <2 x float> @__mulsc3(float noundef %127, float noundef %129, float noundef %123, float noundef %124) #6
  %.sroa.030.0.vec.extract = extractelement <2 x float> %140, i64 0
  %.sroa.030.4.vec.extract = extractelement <2 x float> %140, i64 1
  br label %141

141:                                              ; preds = %139, %137, %122
  %142 = phi float [ %134, %122 ], [ %134, %137 ], [ %.sroa.030.0.vec.extract, %139 ]
  %143 = phi float [ %135, %122 ], [ %135, %137 ], [ %.sroa.030.4.vec.extract, %139 ]
  store float %142, ptr %126, align 4
  store float %143, ptr %128, align 4
  %indvars.iv.next172 = add nuw nsw i64 %indvars.iv171, 1
  %144 = load i32, ptr %11, align 8, !tbaa !13
  %145 = zext i32 %144 to i64
  %146 = icmp ult i64 %indvars.iv.next172, %145
  br i1 %146, label %111, label %._crit_edge147, !llvm.loop !29

._crit_edge147:                                   ; preds = %141, %._crit_edge
  %147 = load ptr, ptr %15, align 8, !tbaa !14
  %148 = tail call i32 @fft_execute(ptr noundef %147) #6
  %149 = load i32, ptr %11, align 8, !tbaa !13
  %.not165 = icmp eq i32 %149, 0
  br i1 %.not165, label %._crit_edge153, label %.lr.ph152

.lr.ph152:                                        ; preds = %._crit_edge147
  %150 = getelementptr inbounds i8, ptr %0, i64 40
  br label %151

151:                                              ; preds = %.lr.ph152, %151
  %indvars.iv174 = phi i64 [ 0, %.lr.ph152 ], [ %indvars.iv.next175, %151 ]
  %.0137149 = phi float [ 0.000000e+00, %.lr.ph152 ], [ %.1138, %151 ]
  %.0139148 = phi i32 [ 0, %.lr.ph152 ], [ %.1140, %151 ]
  %152 = load ptr, ptr %150, align 8, !tbaa !16
  %153 = getelementptr inbounds { float, float }, ptr %152, i64 %indvars.iv174
  %154 = load <2 x float>, ptr %153, align 4
  %155 = tail call float @cabsf(<2 x float> noundef %154) #6
  %156 = fcmp ogt float %155, %.0137149
  %157 = trunc nuw i64 %indvars.iv174 to i32
  %.1140 = select i1 %156, i32 %157, i32 %.0139148
  %.1138 = select i1 %156, float %155, float %.0137149
  %indvars.iv.next175 = add nuw nsw i64 %indvars.iv174, 1
  %158 = load i32, ptr %11, align 8, !tbaa !13
  %159 = zext i32 %158 to i64
  %160 = icmp ult i64 %indvars.iv.next175, %159
  br i1 %160, label %151, label %._crit_edge153, !llvm.loop !30

._crit_edge153:                                   ; preds = %151, %._crit_edge147
  %.0139.lcssa = phi i32 [ 0, %._crit_edge147 ], [ %.1140, %151 ]
  %.0137.lcssa = phi float [ 0.000000e+00, %._crit_edge147 ], [ %.1138, %151 ]
  %.lcssa = phi i32 [ 0, %._crit_edge147 ], [ %158, %151 ]
  %161 = add i32 %.0139.lcssa, -1
  %162 = add i32 %161, %.lcssa
  %163 = urem i32 %162, %.lcssa
  %164 = add i32 %.0139.lcssa, 1
  %165 = urem i32 %164, %.lcssa
  %166 = getelementptr inbounds i8, ptr %0, i64 40
  %167 = load ptr, ptr %166, align 8, !tbaa !16
  %168 = zext i32 %163 to i64
  %169 = getelementptr inbounds { float, float }, ptr %167, i64 %168
  %170 = load <2 x float>, ptr %169, align 4
  %171 = tail call float @cabsf(<2 x float> noundef %170) #6
  %172 = load ptr, ptr %166, align 8, !tbaa !16
  %173 = zext i32 %165 to i64
  %174 = getelementptr inbounds { float, float }, ptr %172, i64 %173
  %175 = load <2 x float>, ptr %174, align 4
  %176 = tail call float @cabsf(<2 x float> noundef %175) #6
  %177 = fadd float %171, %176
  %178 = fneg float %.0137.lcssa
  %179 = tail call float @llvm.fmuladd.f32(float %177, float 5.000000e-01, float %178)
  %180 = fsub float %176, %171
  %181 = fmul float %180, 5.000000e-01
  %182 = fmul float %179, 2.000000e+00
  %183 = fdiv float %181, %182
  %184 = uitofp i32 %.0139.lcssa to float
  %185 = fsub float %184, %183
  %186 = load i32, ptr %11, align 8, !tbaa !13
  %187 = lshr i32 %186, 1
  %188 = icmp ugt i32 %.0139.lcssa, %187
  %189 = uitofp i32 %186 to float
  %190 = fsub float %185, %189
  %191 = select i1 %188, float %190, float %185
  %192 = fmul float %191, 2.000000e+00
  %193 = fpext float %192 to double
  %194 = fmul double %193, 0x400921FB54442D18
  %195 = fpext float %189 to double
  %196 = fdiv double %194, %195
  %197 = fptrunc double %196 to float
  %198 = getelementptr inbounds i8, ptr %0, i64 132
  store float %197, ptr %198, align 4, !tbaa !31
  %199 = load i32, ptr %0, align 8, !tbaa !27
  %.not166 = icmp eq i32 %199, 0
  br i1 %.not166, label %._crit_edge161, label %.lr.ph160

.lr.ph160:                                        ; preds = %._crit_edge153, %236
  %indvars.iv177 = phi i64 [ %indvars.iv.next178, %236 ], [ 0, %._crit_edge153 ]
  %200 = phi <2 x float> [ %238, %236 ], [ zeroinitializer, %._crit_edge153 ]
  %201 = load ptr, ptr %3, align 8, !tbaa !5
  %202 = getelementptr inbounds { float, float }, ptr %201, i64 %indvars.iv177
  %203 = load float, ptr %202, align 4
  %204 = getelementptr inbounds i8, ptr %202, i64 4
  %205 = load float, ptr %204, align 4
  %206 = load float, ptr %198, align 4, !tbaa !31
  %207 = fmul float %206, -0.000000e+00
  %208 = fneg float %206
  %209 = trunc nuw i64 %indvars.iv177 to i32
  %210 = uitofp i32 %209 to float
  %211 = insertelement <2 x float> poison, float %207, i64 0
  %212 = insertelement <2 x float> %211, float %208, i64 1
  %213 = insertelement <2 x float> poison, float %210, i64 0
  %214 = shufflevector <2 x float> %213, <2 x float> poison, <2 x i32> zeroinitializer
  %215 = fmul <2 x float> %212, %214
  %216 = tail call <2 x float> @cexpf(<2 x float> noundef %215) #6
  %217 = insertelement <2 x float> poison, float %203, i64 0
  %218 = shufflevector <2 x float> %217, <2 x float> poison, <2 x i32> zeroinitializer
  %219 = fmul <2 x float> %218, %216
  %220 = insertelement <2 x float> poison, float %205, i64 0
  %221 = shufflevector <2 x float> %220, <2 x float> poison, <2 x i32> zeroinitializer
  %222 = fmul <2 x float> %221, %216
  %223 = shufflevector <2 x float> %222, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %224 = fadd <2 x float> %219, %223
  %225 = fsub <2 x float> %219, %223
  %226 = shufflevector <2 x float> %225, <2 x float> %224, <2 x i32> <i32 0, i32 3>
  %227 = extractelement <2 x float> %225, i64 0
  %228 = fcmp uno float %227, 0.000000e+00
  br i1 %228, label %229, label %236, !prof !18

229:                                              ; preds = %.lr.ph160
  %230 = extractelement <2 x float> %224, i64 1
  %231 = fcmp uno float %230, 0.000000e+00
  br i1 %231, label %232, label %236, !prof !18

232:                                              ; preds = %229
  %233 = extractelement <2 x float> %216, i64 0
  %234 = extractelement <2 x float> %216, i64 1
  %235 = tail call <2 x float> @__mulsc3(float noundef %203, float noundef %205, float noundef %233, float noundef %234) #6
  br label %236

236:                                              ; preds = %232, %229, %.lr.ph160
  %237 = phi <2 x float> [ %226, %.lr.ph160 ], [ %226, %229 ], [ %235, %232 ]
  %238 = fadd <2 x float> %200, %237
  %indvars.iv.next178 = add nuw nsw i64 %indvars.iv177, 1
  %239 = load i32, ptr %0, align 8, !tbaa !27
  %240 = zext i32 %239 to i64
  %241 = icmp ult i64 %indvars.iv.next178, %240
  br i1 %241, label %.lr.ph160, label %._crit_edge161, !llvm.loop !32

._crit_edge161:                                   ; preds = %236, %._crit_edge153
  %242 = phi <2 x float> [ zeroinitializer, %._crit_edge153 ], [ %238, %236 ]
  %243 = tail call float @cargf(<2 x float> noundef %242) #6
  %244 = getelementptr inbounds i8, ptr %0, i64 136
  store float %243, ptr %244, align 8, !tbaa !33
  %245 = getelementptr inbounds i8, ptr %0, i64 144
  store i32 1, ptr %245, align 8, !tbaa !34
  %246 = load ptr, ptr %3, align 8, !tbaa !5
  %247 = load ptr, ptr %66, align 8, !tbaa !23
  %248 = load i32, ptr %11, align 8, !tbaa !13
  %249 = lshr i32 %248, 1
  %250 = zext nneg i32 %249 to i64
  %251 = getelementptr inbounds { float, float }, ptr %247, i64 %250
  %252 = shl nuw nsw i64 %250, 3
  tail call void @llvm.memmove.p0.p0.i64(ptr align 4 %246, ptr align 4 %251, i64 %252, i1 false)
  %253 = getelementptr inbounds i8, ptr %0, i64 140
  store i32 0, ptr %253, align 4, !tbaa !35
  %254 = load ptr, ptr %3, align 8, !tbaa !5
  %255 = load i32, ptr %11, align 8, !tbaa !13
  %256 = lshr i32 %255, 1
  %257 = tail call float @liquid_sumsqcf(ptr noundef %254, i32 noundef %256) #6
  %258 = getelementptr inbounds i8, ptr %0, i64 108
  store float %257, ptr %258, align 4, !tbaa !36
  %259 = getelementptr inbounds i8, ptr %0, i64 112
  store float 0.000000e+00, ptr %259, align 8, !tbaa !37
  %260 = load i32, ptr %11, align 8, !tbaa !13
  %261 = lshr i32 %260, 1
  store i32 %261, ptr %5, align 8, !tbaa !12
  br label %262

262:                                              ; preds = %2, %._crit_edge161
  ret i32 0
}

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

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

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

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 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #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, !10, i64 32}
!6 = !{!"qdetector_cccf_s", !7, i64 0, !10, i64 8, !10, i64 16, !11, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !7, i64 64, !10, i64 72, !10, i64 80, !7, i64 88, !11, i64 92, !11, i64 96, !7, i64 100, !7, i64 104, !11, i64 108, !11, i64 112, !11, i64 116, !7, i64 120, !11, i64 124, !11, i64 128, !11, i64 132, !11, i64 136, !7, i64 140, !7, i64 144}
!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 88}
!13 = !{!6, !7, i64 64}
!14 = !{!6, !10, i64 72}
!15 = !{!6, !7, i64 120}
!16 = !{!6, !10, i64 40}
!17 = !{!6, !10, i64 16}
!18 = !{!"branch_weights", i32 1, i32 1048575}
!19 = !{!6, !10, i64 48}
!20 = distinct !{!20, !21}
!21 = !{!"llvm.loop.mustprogress"}
!22 = !{!6, !10, i64 80}
!23 = !{!6, !10, i64 56}
!24 = !{!6, !11, i64 124}
!25 = !{!6, !11, i64 24}
!26 = !{!6, !11, i64 128}
!27 = !{!6, !7, i64 0}
!28 = !{!6, !10, i64 8}
!29 = distinct !{!29, !21}
!30 = distinct !{!30, !21}
!31 = !{!6, !11, i64 132}
!32 = distinct !{!32, !21}
!33 = !{!6, !11, i64 136}
!34 = !{!6, !7, i64 144}
!35 = !{!6, !7, i64 140}
!36 = !{!6, !11, i64 108}
!37 = !{!6, !11, i64 112}


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