; LLVM IR from jgaeddert/liquid-dsp :: src/modem/bench (modem_demodsoft_benchmark)

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

@.str = external hidden unnamed_addr constant [98 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [47 x i8], align 1

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

44:                                               ; preds = %4
  %45 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 48, ptr noundef @.str.1)
  store i32 1, ptr %11, align 4
  br label %326

46:                                               ; preds = %4, %4, %4, %4, %4, %4, %4
  %47 = load i32, ptr %10, align 4, !tbaa !9
  %48 = shl i32 1, %47
  %49 = mul nsw i32 2, %48
  %50 = sext i32 %49 to i64
  %51 = load ptr, ptr %7, align 8, !tbaa !5
  %52 = load i64, ptr %51, align 8, !tbaa !11
  %53 = udiv i64 %52, %50
  store i64 %53, ptr %51, align 8, !tbaa !11
  br label %60

54:                                               ; preds = %4
  %55 = load i32, ptr %10, align 4, !tbaa !9
  %56 = zext i32 %55 to i64
  %57 = load ptr, ptr %7, align 8, !tbaa !5
  %58 = load i64, ptr %57, align 8, !tbaa !11
  %59 = udiv i64 %58, %56
  store i64 %59, ptr %57, align 8, !tbaa !11
  br label %60

60:                                               ; preds = %54, %46
  %61 = load ptr, ptr %7, align 8, !tbaa !5
  %62 = load i64, ptr %61, align 8, !tbaa !11
  %63 = icmp ult i64 %62, 1
  br i1 %63, label %64, label %66

64:                                               ; preds = %60
  %65 = load ptr, ptr %7, align 8, !tbaa !5
  store i64 1, ptr %65, align 8, !tbaa !11
  br label %66

66:                                               ; preds = %64, %60
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.start.p0(i64 160, ptr %13) #5
  store i64 0, ptr %12, align 8, !tbaa !11
  br label %67

67:                                               ; preds = %98, %66
  %68 = load i64, ptr %12, align 8, !tbaa !11
  %69 = icmp ult i64 %68, 20
  br i1 %69, label %70, label %101

70:                                               ; preds = %67
  %71 = load i64, ptr %12, align 8, !tbaa !11
  %72 = uitofp i64 %71 to double
  %73 = fmul double 7.000000e-02, %72
  %74 = load i64, ptr %12, align 8, !tbaa !11
  %75 = uitofp i64 %74 to double
  %76 = fmul double 0.000000e+00, %75
  %77 = fmul double 0x3FE41B2F769CF0E0, %75
  %78 = fptrunc double %76 to float
  %79 = fptrunc double %77 to float
  %80 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %81 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  store float %78, ptr %80, align 4
  store float %79, ptr %81, align 4
  %82 = load <2 x float>, ptr %14, align 4
  %83 = call <2 x float> @cexpf(<2 x float> noundef %82) #5
  store <2 x float> %83, ptr %15, align 4
  %84 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %85 = load float, ptr %84, align 4
  %86 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  %87 = load float, ptr %86, align 4
  %88 = fpext float %85 to double
  %89 = fpext float %87 to double
  %90 = fmul double %73, %88
  %91 = fmul double %73, %89
  %92 = fptrunc double %90 to float
  %93 = fptrunc double %91 to float
  %94 = load i64, ptr %12, align 8, !tbaa !11
  %95 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 %94
  %96 = getelementptr inbounds { float, float }, ptr %95, i32 0, i32 0
  %97 = getelementptr inbounds { float, float }, ptr %95, i32 0, i32 1
  store float %92, ptr %96, align 8
  store float %93, ptr %97, align 4
  br label %98

98:                                               ; preds = %70
  %99 = load i64, ptr %12, align 8, !tbaa !11
  %100 = add i64 %99, 1
  store i64 %100, ptr %12, align 8, !tbaa !11
  br label %67, !llvm.loop !13

101:                                              ; preds = %67
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #5
  %102 = load i32, ptr %10, align 4, !tbaa !9
  %103 = zext i32 %102 to i64
  %104 = call ptr @llvm.stacksave.p0()
  store ptr %104, ptr %17, align 8
  %105 = alloca i8, i64 %103, align 16
  store i64 %103, ptr %18, align 8
  %106 = load ptr, ptr %5, align 8, !tbaa !5
  %107 = call i32 @getrusage(i32 noundef 0, ptr noundef %106) #5
  store i64 0, ptr %12, align 8, !tbaa !11
  br label %108

108:                                              ; preds = %314, %101
  %109 = load i64, ptr %12, align 8, !tbaa !11
  %110 = load ptr, ptr %7, align 8, !tbaa !5
  %111 = load i64, ptr %110, align 8, !tbaa !11
  %112 = icmp ult i64 %109, %111
  br i1 %112, label %113, label %317

113:                                              ; preds = %108
  %114 = load ptr, ptr %9, align 8, !tbaa !5
  %115 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 0
  %116 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 0
  %117 = load float, ptr %116, align 16
  %118 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 1
  %119 = load float, ptr %118, align 4
  %120 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %121 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  store float %117, ptr %120, align 4
  store float %119, ptr %121, align 4
  %122 = load <2 x float>, ptr %19, align 4
  %123 = call i32 @modemcf_demodulate_soft(ptr noundef %114, <2 x float> noundef %122, ptr noundef %16, ptr noundef %105)
  %124 = load ptr, ptr %9, align 8, !tbaa !5
  %125 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 1
  %126 = getelementptr inbounds { float, float }, ptr %125, i32 0, i32 0
  %127 = load float, ptr %126, align 8
  %128 = getelementptr inbounds { float, float }, ptr %125, i32 0, i32 1
  %129 = load float, ptr %128, align 4
  %130 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 0
  %131 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 1
  store float %127, ptr %130, align 4
  store float %129, ptr %131, align 4
  %132 = load <2 x float>, ptr %20, align 4
  %133 = call i32 @modemcf_demodulate_soft(ptr noundef %124, <2 x float> noundef %132, ptr noundef %16, ptr noundef %105)
  %134 = load ptr, ptr %9, align 8, !tbaa !5
  %135 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 2
  %136 = getelementptr inbounds { float, float }, ptr %135, i32 0, i32 0
  %137 = load float, ptr %136, align 16
  %138 = getelementptr inbounds { float, float }, ptr %135, i32 0, i32 1
  %139 = load float, ptr %138, align 4
  %140 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 0
  %141 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 1
  store float %137, ptr %140, align 4
  store float %139, ptr %141, align 4
  %142 = load <2 x float>, ptr %21, align 4
  %143 = call i32 @modemcf_demodulate_soft(ptr noundef %134, <2 x float> noundef %142, ptr noundef %16, ptr noundef %105)
  %144 = load ptr, ptr %9, align 8, !tbaa !5
  %145 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 3
  %146 = getelementptr inbounds { float, float }, ptr %145, i32 0, i32 0
  %147 = load float, ptr %146, align 8
  %148 = getelementptr inbounds { float, float }, ptr %145, i32 0, i32 1
  %149 = load float, ptr %148, align 4
  %150 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 0
  %151 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 1
  store float %147, ptr %150, align 4
  store float %149, ptr %151, align 4
  %152 = load <2 x float>, ptr %22, align 4
  %153 = call i32 @modemcf_demodulate_soft(ptr noundef %144, <2 x float> noundef %152, ptr noundef %16, ptr noundef %105)
  %154 = load ptr, ptr %9, align 8, !tbaa !5
  %155 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 4
  %156 = getelementptr inbounds { float, float }, ptr %155, i32 0, i32 0
  %157 = load float, ptr %156, align 16
  %158 = getelementptr inbounds { float, float }, ptr %155, i32 0, i32 1
  %159 = load float, ptr %158, align 4
  %160 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %161 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  store float %157, ptr %160, align 4
  store float %159, ptr %161, align 4
  %162 = load <2 x float>, ptr %23, align 4
  %163 = call i32 @modemcf_demodulate_soft(ptr noundef %154, <2 x float> noundef %162, ptr noundef %16, ptr noundef %105)
  %164 = load ptr, ptr %9, align 8, !tbaa !5
  %165 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 5
  %166 = getelementptr inbounds { float, float }, ptr %165, i32 0, i32 0
  %167 = load float, ptr %166, align 8
  %168 = getelementptr inbounds { float, float }, ptr %165, i32 0, i32 1
  %169 = load float, ptr %168, align 4
  %170 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 0
  %171 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 1
  store float %167, ptr %170, align 4
  store float %169, ptr %171, align 4
  %172 = load <2 x float>, ptr %24, align 4
  %173 = call i32 @modemcf_demodulate_soft(ptr noundef %164, <2 x float> noundef %172, ptr noundef %16, ptr noundef %105)
  %174 = load ptr, ptr %9, align 8, !tbaa !5
  %175 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 6
  %176 = getelementptr inbounds { float, float }, ptr %175, i32 0, i32 0
  %177 = load float, ptr %176, align 16
  %178 = getelementptr inbounds { float, float }, ptr %175, i32 0, i32 1
  %179 = load float, ptr %178, align 4
  %180 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 0
  %181 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 1
  store float %177, ptr %180, align 4
  store float %179, ptr %181, align 4
  %182 = load <2 x float>, ptr %25, align 4
  %183 = call i32 @modemcf_demodulate_soft(ptr noundef %174, <2 x float> noundef %182, ptr noundef %16, ptr noundef %105)
  %184 = load ptr, ptr %9, align 8, !tbaa !5
  %185 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 7
  %186 = getelementptr inbounds { float, float }, ptr %185, i32 0, i32 0
  %187 = load float, ptr %186, align 8
  %188 = getelementptr inbounds { float, float }, ptr %185, i32 0, i32 1
  %189 = load float, ptr %188, align 4
  %190 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %191 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  store float %187, ptr %190, align 4
  store float %189, ptr %191, align 4
  %192 = load <2 x float>, ptr %26, align 4
  %193 = call i32 @modemcf_demodulate_soft(ptr noundef %184, <2 x float> noundef %192, ptr noundef %16, ptr noundef %105)
  %194 = load ptr, ptr %9, align 8, !tbaa !5
  %195 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 8
  %196 = getelementptr inbounds { float, float }, ptr %195, i32 0, i32 0
  %197 = load float, ptr %196, align 16
  %198 = getelementptr inbounds { float, float }, ptr %195, i32 0, i32 1
  %199 = load float, ptr %198, align 4
  %200 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 0
  %201 = getelementptr inbounds { float, float }, ptr %27, i32 0, i32 1
  store float %197, ptr %200, align 4
  store float %199, ptr %201, align 4
  %202 = load <2 x float>, ptr %27, align 4
  %203 = call i32 @modemcf_demodulate_soft(ptr noundef %194, <2 x float> noundef %202, ptr noundef %16, ptr noundef %105)
  %204 = load ptr, ptr %9, align 8, !tbaa !5
  %205 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 9
  %206 = getelementptr inbounds { float, float }, ptr %205, i32 0, i32 0
  %207 = load float, ptr %206, align 8
  %208 = getelementptr inbounds { float, float }, ptr %205, i32 0, i32 1
  %209 = load float, ptr %208, align 4
  %210 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 0
  %211 = getelementptr inbounds { float, float }, ptr %28, i32 0, i32 1
  store float %207, ptr %210, align 4
  store float %209, ptr %211, align 4
  %212 = load <2 x float>, ptr %28, align 4
  %213 = call i32 @modemcf_demodulate_soft(ptr noundef %204, <2 x float> noundef %212, ptr noundef %16, ptr noundef %105)
  %214 = load ptr, ptr %9, align 8, !tbaa !5
  %215 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 10
  %216 = getelementptr inbounds { float, float }, ptr %215, i32 0, i32 0
  %217 = load float, ptr %216, align 16
  %218 = getelementptr inbounds { float, float }, ptr %215, i32 0, i32 1
  %219 = load float, ptr %218, align 4
  %220 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 0
  %221 = getelementptr inbounds { float, float }, ptr %29, i32 0, i32 1
  store float %217, ptr %220, align 4
  store float %219, ptr %221, align 4
  %222 = load <2 x float>, ptr %29, align 4
  %223 = call i32 @modemcf_demodulate_soft(ptr noundef %214, <2 x float> noundef %222, ptr noundef %16, ptr noundef %105)
  %224 = load ptr, ptr %9, align 8, !tbaa !5
  %225 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 11
  %226 = getelementptr inbounds { float, float }, ptr %225, i32 0, i32 0
  %227 = load float, ptr %226, align 8
  %228 = getelementptr inbounds { float, float }, ptr %225, i32 0, i32 1
  %229 = load float, ptr %228, align 4
  %230 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 0
  %231 = getelementptr inbounds { float, float }, ptr %30, i32 0, i32 1
  store float %227, ptr %230, align 4
  store float %229, ptr %231, align 4
  %232 = load <2 x float>, ptr %30, align 4
  %233 = call i32 @modemcf_demodulate_soft(ptr noundef %224, <2 x float> noundef %232, ptr noundef %16, ptr noundef %105)
  %234 = load ptr, ptr %9, align 8, !tbaa !5
  %235 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 12
  %236 = getelementptr inbounds { float, float }, ptr %235, i32 0, i32 0
  %237 = load float, ptr %236, align 16
  %238 = getelementptr inbounds { float, float }, ptr %235, i32 0, i32 1
  %239 = load float, ptr %238, align 4
  %240 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 0
  %241 = getelementptr inbounds { float, float }, ptr %31, i32 0, i32 1
  store float %237, ptr %240, align 4
  store float %239, ptr %241, align 4
  %242 = load <2 x float>, ptr %31, align 4
  %243 = call i32 @modemcf_demodulate_soft(ptr noundef %234, <2 x float> noundef %242, ptr noundef %16, ptr noundef %105)
  %244 = load ptr, ptr %9, align 8, !tbaa !5
  %245 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 13
  %246 = getelementptr inbounds { float, float }, ptr %245, i32 0, i32 0
  %247 = load float, ptr %246, align 8
  %248 = getelementptr inbounds { float, float }, ptr %245, i32 0, i32 1
  %249 = load float, ptr %248, align 4
  %250 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 0
  %251 = getelementptr inbounds { float, float }, ptr %32, i32 0, i32 1
  store float %247, ptr %250, align 4
  store float %249, ptr %251, align 4
  %252 = load <2 x float>, ptr %32, align 4
  %253 = call i32 @modemcf_demodulate_soft(ptr noundef %244, <2 x float> noundef %252, ptr noundef %16, ptr noundef %105)
  %254 = load ptr, ptr %9, align 8, !tbaa !5
  %255 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 14
  %256 = getelementptr inbounds { float, float }, ptr %255, i32 0, i32 0
  %257 = load float, ptr %256, align 16
  %258 = getelementptr inbounds { float, float }, ptr %255, i32 0, i32 1
  %259 = load float, ptr %258, align 4
  %260 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 0
  %261 = getelementptr inbounds { float, float }, ptr %33, i32 0, i32 1
  store float %257, ptr %260, align 4
  store float %259, ptr %261, align 4
  %262 = load <2 x float>, ptr %33, align 4
  %263 = call i32 @modemcf_demodulate_soft(ptr noundef %254, <2 x float> noundef %262, ptr noundef %16, ptr noundef %105)
  %264 = load ptr, ptr %9, align 8, !tbaa !5
  %265 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 15
  %266 = getelementptr inbounds { float, float }, ptr %265, i32 0, i32 0
  %267 = load float, ptr %266, align 8
  %268 = getelementptr inbounds { float, float }, ptr %265, i32 0, i32 1
  %269 = load float, ptr %268, align 4
  %270 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 0
  %271 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 1
  store float %267, ptr %270, align 4
  store float %269, ptr %271, align 4
  %272 = load <2 x float>, ptr %34, align 4
  %273 = call i32 @modemcf_demodulate_soft(ptr noundef %264, <2 x float> noundef %272, ptr noundef %16, ptr noundef %105)
  %274 = load ptr, ptr %9, align 8, !tbaa !5
  %275 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 16
  %276 = getelementptr inbounds { float, float }, ptr %275, i32 0, i32 0
  %277 = load float, ptr %276, align 16
  %278 = getelementptr inbounds { float, float }, ptr %275, i32 0, i32 1
  %279 = load float, ptr %278, align 4
  %280 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 0
  %281 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 1
  store float %277, ptr %280, align 4
  store float %279, ptr %281, align 4
  %282 = load <2 x float>, ptr %35, align 4
  %283 = call i32 @modemcf_demodulate_soft(ptr noundef %274, <2 x float> noundef %282, ptr noundef %16, ptr noundef %105)
  %284 = load ptr, ptr %9, align 8, !tbaa !5
  %285 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 17
  %286 = getelementptr inbounds { float, float }, ptr %285, i32 0, i32 0
  %287 = load float, ptr %286, align 8
  %288 = getelementptr inbounds { float, float }, ptr %285, i32 0, i32 1
  %289 = load float, ptr %288, align 4
  %290 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %291 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  store float %287, ptr %290, align 4
  store float %289, ptr %291, align 4
  %292 = load <2 x float>, ptr %36, align 4
  %293 = call i32 @modemcf_demodulate_soft(ptr noundef %284, <2 x float> noundef %292, ptr noundef %16, ptr noundef %105)
  %294 = load ptr, ptr %9, align 8, !tbaa !5
  %295 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 18
  %296 = getelementptr inbounds { float, float }, ptr %295, i32 0, i32 0
  %297 = load float, ptr %296, align 16
  %298 = getelementptr inbounds { float, float }, ptr %295, i32 0, i32 1
  %299 = load float, ptr %298, align 4
  %300 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 0
  %301 = getelementptr inbounds { float, float }, ptr %37, i32 0, i32 1
  store float %297, ptr %300, align 4
  store float %299, ptr %301, align 4
  %302 = load <2 x float>, ptr %37, align 4
  %303 = call i32 @modemcf_demodulate_soft(ptr noundef %294, <2 x float> noundef %302, ptr noundef %16, ptr noundef %105)
  %304 = load ptr, ptr %9, align 8, !tbaa !5
  %305 = getelementptr inbounds [20 x { float, float }], ptr %13, i64 0, i64 19
  %306 = getelementptr inbounds { float, float }, ptr %305, i32 0, i32 0
  %307 = load float, ptr %306, align 8
  %308 = getelementptr inbounds { float, float }, ptr %305, i32 0, i32 1
  %309 = load float, ptr %308, align 4
  %310 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 0
  %311 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 1
  store float %307, ptr %310, align 4
  store float %309, ptr %311, align 4
  %312 = load <2 x float>, ptr %38, align 4
  %313 = call i32 @modemcf_demodulate_soft(ptr noundef %304, <2 x float> noundef %312, ptr noundef %16, ptr noundef %105)
  br label %314

314:                                              ; preds = %113
  %315 = load i64, ptr %12, align 8, !tbaa !11
  %316 = add i64 %315, 1
  store i64 %316, ptr %12, align 8, !tbaa !11
  br label %108, !llvm.loop !15

317:                                              ; preds = %108
  %318 = load ptr, ptr %6, align 8, !tbaa !5
  %319 = call i32 @getrusage(i32 noundef 0, ptr noundef %318) #5
  %320 = load ptr, ptr %7, align 8, !tbaa !5
  %321 = load i64, ptr %320, align 8, !tbaa !11
  %322 = mul i64 %321, 20
  store i64 %322, ptr %320, align 8, !tbaa !11
  %323 = load ptr, ptr %9, align 8, !tbaa !5
  %324 = call i32 @modemcf_destroy(ptr noundef %323)
  %325 = load ptr, ptr %17, align 8
  call void @llvm.stackrestore.p0(ptr %325)
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 160, ptr %13) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #5
  store i32 0, ptr %11, align 4
  br label %326

326:                                              ; preds = %317, %44
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #5
  %327 = load i32, ptr %11, align 4
  switch i32 %327, label %329 [
    i32 0, label %328
    i32 1, label %328
  ]

328:                                              ; preds = %326, %326
  ret void

329:                                              ; preds = %326
  unreachable
}

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

declare ptr @modemcf_create(i32 noundef) #2

declare i32 @modemcf_get_bps(ptr noundef) #2

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

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

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

; Function Attrs: nounwind
declare i32 @getrusage(i32 noundef, ptr noundef) #3

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

declare i32 @modemcf_destroy(ptr noundef) #2

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"long", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@.str = external hidden unnamed_addr constant [98 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [47 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @modemcf_demodulate_soft_bench(ptr noundef %0, ptr noundef %1, ptr nocapture noundef %2, i32 noundef %3) local_unnamed_addr #0 {
  %5 = alloca [20 x { float, float }], align 16
  %6 = alloca i32, align 4
  %7 = tail call ptr @modemcf_create(i32 noundef %3) #6
  %8 = tail call i32 @modemcf_get_bps(ptr noundef %7) #6
  switch i32 %3, label %14 [
    i32 0, label %9
    i32 45, label %11
    i32 46, label %11
    i32 47, label %11
    i32 48, label %11
    i32 49, label %11
    i32 50, label %11
    i32 52, label %11
  ]

9:                                                ; preds = %4
  %10 = tail call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 48, ptr noundef nonnull @.str.1) #6
  br label %103

11:                                               ; preds = %4, %4, %4, %4, %4, %4, %4
  %12 = shl i32 2, %8
  %13 = sext i32 %12 to i64
  br label %16

14:                                               ; preds = %4
  %15 = zext i32 %8 to i64
  br label %16

16:                                               ; preds = %14, %11
  %.sink108 = phi i64 [ %15, %14 ], [ %13, %11 ]
  %17 = load i64, ptr %2, align 8, !tbaa !5
  %18 = udiv i64 %17, %.sink108
  %spec.select = tail call i64 @llvm.umax.i64(i64 %18, i64 1)
  store i64 %spec.select, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 160, ptr nonnull %5) #6
  br label %19

19:                                               ; preds = %16, %19
  %.085 = phi i64 [ 0, %16 ], [ %31, %19 ]
  %20 = uitofp nneg i64 %.085 to double
  %21 = fmul double %20, 7.000000e-02
  %22 = fmul double %20, 0x3FE41B2F769CF0E0
  %23 = fptrunc double %22 to float
  %.sroa.041.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %23, i64 1
  %24 = tail call <2 x float> @cexpf(<2 x float> noundef %.sroa.041.4.vec.insert) #6
  %25 = getelementptr inbounds [20 x { float, float }], ptr %5, i64 0, i64 %.085
  %26 = fpext <2 x float> %24 to <2 x double>
  %27 = insertelement <2 x double> poison, double %21, i64 0
  %28 = shufflevector <2 x double> %27, <2 x double> poison, <2 x i32> zeroinitializer
  %29 = fmul <2 x double> %28, %26
  %30 = fptrunc <2 x double> %29 to <2 x float>
  store <2 x float> %30, ptr %25, align 8
  %31 = add nuw nsw i64 %.085, 1
  %exitcond.not = icmp eq i64 %31, 20
  br i1 %exitcond.not, label %32, label %19, !llvm.loop !9

32:                                               ; preds = %19
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %6) #6
  %33 = zext i32 %8 to i64
  %34 = tail call ptr @llvm.stacksave.p0()
  %35 = alloca i8, i64 %33, align 16
  %36 = tail call i32 @getrusage(i32 noundef 0, ptr noundef %0) #6
  %37 = load i64, ptr %2, align 8, !tbaa !5
  %.not = icmp eq i64 %37, 0
  br i1 %.not, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %32
  %38 = load <4 x float>, ptr %5, align 16
  %.sroa.038.4.vec.insert = shufflevector <4 x float> %38, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %39 = getelementptr inbounds i8, ptr %5, i64 8
  %40 = load <4 x float>, ptr %39, align 8
  %.sroa.036.4.vec.insert = shufflevector <4 x float> %40, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %41 = getelementptr inbounds i8, ptr %5, i64 16
  %42 = load <4 x float>, ptr %41, align 16
  %.sroa.034.4.vec.insert = shufflevector <4 x float> %42, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %43 = getelementptr inbounds i8, ptr %5, i64 24
  %44 = load <4 x float>, ptr %43, align 8
  %.sroa.032.4.vec.insert = shufflevector <4 x float> %44, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %45 = getelementptr inbounds i8, ptr %5, i64 32
  %46 = load <4 x float>, ptr %45, align 16
  %.sroa.030.4.vec.insert = shufflevector <4 x float> %46, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %47 = getelementptr inbounds i8, ptr %5, i64 40
  %48 = load <4 x float>, ptr %47, align 8
  %.sroa.028.4.vec.insert = shufflevector <4 x float> %48, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %49 = getelementptr inbounds i8, ptr %5, i64 48
  %50 = load <4 x float>, ptr %49, align 16
  %.sroa.026.4.vec.insert = shufflevector <4 x float> %50, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %51 = getelementptr inbounds i8, ptr %5, i64 56
  %52 = load <4 x float>, ptr %51, align 8
  %.sroa.024.4.vec.insert = shufflevector <4 x float> %52, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %53 = getelementptr inbounds i8, ptr %5, i64 64
  %54 = load <4 x float>, ptr %53, align 16
  %.sroa.022.4.vec.insert = shufflevector <4 x float> %54, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %55 = getelementptr inbounds i8, ptr %5, i64 72
  %56 = load <4 x float>, ptr %55, align 8
  %.sroa.020.4.vec.insert = shufflevector <4 x float> %56, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %57 = getelementptr inbounds i8, ptr %5, i64 80
  %58 = load <4 x float>, ptr %57, align 16
  %.sroa.018.4.vec.insert = shufflevector <4 x float> %58, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %59 = getelementptr inbounds i8, ptr %5, i64 88
  %60 = load <4 x float>, ptr %59, align 8
  %.sroa.016.4.vec.insert = shufflevector <4 x float> %60, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %61 = getelementptr inbounds i8, ptr %5, i64 96
  %62 = load <4 x float>, ptr %61, align 16
  %.sroa.014.4.vec.insert = shufflevector <4 x float> %62, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %63 = getelementptr inbounds i8, ptr %5, i64 104
  %64 = load <4 x float>, ptr %63, align 8
  %.sroa.012.4.vec.insert = shufflevector <4 x float> %64, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %65 = getelementptr inbounds i8, ptr %5, i64 112
  %66 = load <4 x float>, ptr %65, align 16
  %.sroa.010.4.vec.insert = shufflevector <4 x float> %66, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %67 = getelementptr inbounds i8, ptr %5, i64 120
  %68 = load <4 x float>, ptr %67, align 8
  %.sroa.08.4.vec.insert = shufflevector <4 x float> %68, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %69 = getelementptr inbounds i8, ptr %5, i64 128
  %70 = load <4 x float>, ptr %69, align 16
  %.sroa.06.4.vec.insert = shufflevector <4 x float> %70, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %71 = getelementptr inbounds i8, ptr %5, i64 136
  %72 = load <4 x float>, ptr %71, align 8
  %.sroa.04.4.vec.insert = shufflevector <4 x float> %72, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %73 = getelementptr inbounds i8, ptr %5, i64 144
  %74 = load <4 x float>, ptr %73, align 16
  %.sroa.02.4.vec.insert = shufflevector <4 x float> %74, <4 x float> poison, <2 x i32> <i32 0, i32 1>
  %.sroa.0.4.vec.insert = shufflevector <4 x float> %74, <4 x float> poison, <2 x i32> <i32 2, i32 3>
  br label %75

75:                                               ; preds = %.lr.ph, %75
  %.186 = phi i64 [ 0, %.lr.ph ], [ %96, %75 ]
  %76 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.038.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %77 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.036.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %78 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.034.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %79 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.032.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %80 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.030.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %81 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.028.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %82 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.026.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %83 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.024.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %84 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.022.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %85 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.020.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %86 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.018.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %87 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.016.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %88 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.014.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %89 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.012.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %90 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.010.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %91 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.08.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %92 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.06.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %93 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.04.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %94 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.02.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %95 = call i32 @modemcf_demodulate_soft(ptr noundef %7, <2 x float> noundef %.sroa.0.4.vec.insert, ptr noundef nonnull %6, ptr noundef nonnull %35) #6
  %96 = add nuw i64 %.186, 1
  %97 = load i64, ptr %2, align 8, !tbaa !5
  %98 = icmp ult i64 %96, %97
  br i1 %98, label %75, label %._crit_edge, !llvm.loop !11

._crit_edge:                                      ; preds = %75, %32
  %99 = call i32 @getrusage(i32 noundef 0, ptr noundef %1) #6
  %100 = load i64, ptr %2, align 8, !tbaa !5
  %101 = mul i64 %100, 20
  store i64 %101, ptr %2, align 8, !tbaa !5
  %102 = call i32 @modemcf_destroy(ptr noundef %7) #6
  call void @llvm.stackrestore.p0(ptr %34)
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %6) #6
  call void @llvm.lifetime.end.p0(i64 160, ptr nonnull %5) #6
  br label %103

103:                                              ; preds = %._crit_edge, %9
  ret void
}

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

declare ptr @modemcf_create(i32 noundef) local_unnamed_addr #2

declare i32 @modemcf_get_bps(ptr noundef) local_unnamed_addr #2

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

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

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

; Function Attrs: nounwind
declare i32 @getrusage(i32 noundef, ptr noundef) local_unnamed_addr #3

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

declare i32 @modemcf_destroy(ptr noundef) local_unnamed_addr #2

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

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"long", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = distinct !{!11, !10}


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