; LLVM IR from jgaeddert/liquid-dsp :: src/filter/src (bessel)

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

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @fpoly_bessel_roots_orchard(i32 noundef %0, ptr noundef %1) #3 {
  %3 = alloca i32, align 4
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i64, align 8
  %7 = alloca i64, align 8
  %8 = alloca i64, align 8
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca i32, align 4
  store i32 %0, ptr %3, align 4, !tbaa !5
  store ptr %1, ptr %4, align 8, !tbaa !9
  %18 = load i32, ptr %3, align 4, !tbaa !5
  %19 = zext i32 %18 to i64
  %20 = call ptr @llvm.stacksave.p0()
  store ptr %20, ptr %5, align 8
  %21 = alloca { float, float }, i64 %19, align 16
  store i64 %19, ptr %6, align 8
  %22 = load i32, ptr %3, align 4, !tbaa !5
  %23 = zext i32 %22 to i64
  %24 = alloca { float, float }, i64 %23, align 16
  store i64 %23, ptr %7, align 8
  %25 = load i32, ptr %3, align 4, !tbaa !5
  %26 = zext i32 %25 to i64
  %27 = alloca { float, float }, i64 %26, align 16
  store i64 %26, ptr %8, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  store i32 1, ptr %9, align 4, !tbaa !5
  br label %28

28:                                               ; preds = %183, %2
  %29 = load i32, ptr %9, align 4, !tbaa !5
  %30 = load i32, ptr %3, align 4, !tbaa !5
  %31 = icmp ult i32 %29, %30
  br i1 %31, label %32, label %186

32:                                               ; preds = %28
  %33 = load i32, ptr %9, align 4, !tbaa !5
  %34 = urem i32 %33, 2
  store i32 %34, ptr %11, align 4, !tbaa !5
  %35 = load i32, ptr %9, align 4, !tbaa !5
  %36 = load i32, ptr %11, align 4, !tbaa !5
  %37 = add i32 %35, %36
  %38 = udiv i32 %37, 2
  store i32 %38, ptr %12, align 4, !tbaa !5
  %39 = load i32, ptr %9, align 4, !tbaa !5
  %40 = icmp eq i32 %39, 1
  br i1 %40, label %41, label %48

41:                                               ; preds = %32
  %42 = getelementptr inbounds { float, float }, ptr %24, i64 0
  %43 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 0
  %44 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 1
  store float -1.000000e+00, ptr %43, align 16
  store float 0.000000e+00, ptr %44, align 4
  %45 = getelementptr inbounds { float, float }, ptr %27, i64 0
  %46 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 0
  %47 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 1
  store float -1.000000e+00, ptr %46, align 16
  store float 0.000000e+00, ptr %47, align 4
  br label %174

48:                                               ; preds = %32
  %49 = load i32, ptr %9, align 4, !tbaa !5
  %50 = icmp eq i32 %49, 2
  br i1 %50, label %51, label %62

51:                                               ; preds = %48
  %52 = getelementptr inbounds { float, float }, ptr %24, i64 0
  %53 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 0
  %54 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 1
  store float -1.000000e+00, ptr %53, align 16
  store float 0.000000e+00, ptr %54, align 4
  %55 = call float @sqrtf(float noundef 3.000000e+00) #6
  %56 = fmul float 0.000000e+00, %55
  %57 = fmul float 5.000000e-01, %55
  %58 = fadd float -1.500000e+00, %56
  %59 = getelementptr inbounds { float, float }, ptr %27, i64 0
  %60 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 0
  %61 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 1
  store float %58, ptr %60, align 16
  store float %57, ptr %61, align 4
  br label %173

62:                                               ; preds = %48
  %63 = load i32, ptr %11, align 4, !tbaa !5
  %64 = icmp ne i32 %63, 0
  br i1 %64, label %65, label %81

65:                                               ; preds = %62
  %66 = getelementptr inbounds { float, float }, ptr %24, i64 0
  %67 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 0
  %68 = load float, ptr %67, align 16
  %69 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 1
  %70 = load float, ptr %69, align 4
  %71 = getelementptr inbounds { float, float }, ptr %21, i64 0
  %72 = getelementptr inbounds { float, float }, ptr %71, i32 0, i32 0
  %73 = load float, ptr %72, align 16
  %74 = getelementptr inbounds { float, float }, ptr %71, i32 0, i32 1
  %75 = load float, ptr %74, align 4
  %76 = fneg float %73
  %77 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %68, float %76)
  %78 = getelementptr inbounds { float, float }, ptr %27, i64 0
  %79 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 0
  %80 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 1
  store float %77, ptr %79, align 16
  store float 0.000000e+00, ptr %80, align 4
  br label %100

81:                                               ; preds = %62
  %82 = getelementptr inbounds { float, float }, ptr %24, i64 0
  %83 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 0
  %84 = load float, ptr %83, align 16
  %85 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 1
  %86 = load float, ptr %85, align 4
  %87 = fmul float 2.000000e+00, %84
  %88 = fmul float 2.000000e+00, %86
  %89 = getelementptr inbounds { float, float }, ptr %21, i64 0
  %90 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 0
  %91 = load float, ptr %90, align 16
  %92 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 1
  %93 = load float, ptr %92, align 4
  %94 = fneg float %93
  %95 = fsub float %87, %91
  %96 = fsub float %88, %94
  %97 = getelementptr inbounds { float, float }, ptr %27, i64 0
  %98 = getelementptr inbounds { float, float }, ptr %97, i32 0, i32 0
  %99 = getelementptr inbounds { float, float }, ptr %97, i32 0, i32 1
  store float %95, ptr %98, align 16
  store float %96, ptr %99, align 4
  br label %100

100:                                              ; preds = %81, %65
  store i32 1, ptr %10, align 4, !tbaa !5
  br label %101

101:                                              ; preds = %132, %100
  %102 = load i32, ptr %10, align 4, !tbaa !5
  %103 = load i32, ptr %12, align 4, !tbaa !5
  %104 = icmp ult i32 %102, %103
  br i1 %104, label %105, label %135

105:                                              ; preds = %101
  %106 = load i32, ptr %10, align 4, !tbaa !5
  %107 = load i32, ptr %11, align 4, !tbaa !5
  %108 = sub i32 %106, %107
  %109 = zext i32 %108 to i64
  %110 = getelementptr inbounds { float, float }, ptr %24, i64 %109
  %111 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 0
  %112 = load float, ptr %111, align 8
  %113 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 1
  %114 = load float, ptr %113, align 4
  %115 = fmul float 2.000000e+00, %112
  %116 = fmul float 2.000000e+00, %114
  %117 = load i32, ptr %10, align 4, !tbaa !5
  %118 = sub i32 %117, 1
  %119 = zext i32 %118 to i64
  %120 = getelementptr inbounds { float, float }, ptr %21, i64 %119
  %121 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 0
  %122 = load float, ptr %121, align 8
  %123 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 1
  %124 = load float, ptr %123, align 4
  %125 = fsub float %115, %122
  %126 = fsub float %116, %124
  %127 = load i32, ptr %10, align 4, !tbaa !5
  %128 = zext i32 %127 to i64
  %129 = getelementptr inbounds { float, float }, ptr %27, 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 %125, ptr %130, align 8
  store float %126, ptr %131, align 4
  br label %132

132:                                              ; preds = %105
  %133 = load i32, ptr %10, align 4, !tbaa !5
  %134 = add i32 %133, 1
  store i32 %134, ptr %10, align 4, !tbaa !5
  br label %101, !llvm.loop !11

135:                                              ; preds = %101
  store i32 0, ptr %10, align 4, !tbaa !5
  br label %136

136:                                              ; preds = %169, %135
  %137 = load i32, ptr %10, align 4, !tbaa !5
  %138 = load i32, ptr %12, align 4, !tbaa !5
  %139 = icmp ult i32 %137, %138
  br i1 %139, label %140, label %172

140:                                              ; preds = %136
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %141 = load i32, ptr %10, align 4, !tbaa !5
  %142 = zext i32 %141 to i64
  %143 = getelementptr inbounds { float, float }, ptr %27, i64 %142
  %144 = getelementptr inbounds { float, float }, ptr %143, i32 0, i32 0
  %145 = load float, ptr %144, align 8
  %146 = getelementptr inbounds { float, float }, ptr %143, i32 0, i32 1
  %147 = load float, ptr %146, align 4
  store float %145, ptr %13, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  %148 = load i32, ptr %10, align 4, !tbaa !5
  %149 = zext i32 %148 to i64
  %150 = getelementptr inbounds { float, float }, ptr %27, i64 %149
  %151 = getelementptr inbounds { float, float }, ptr %150, i32 0, i32 0
  %152 = load float, ptr %151, align 8
  %153 = getelementptr inbounds { float, float }, ptr %150, i32 0, i32 1
  %154 = load float, ptr %153, align 4
  store float %154, ptr %14, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %155 = load i32, ptr %9, align 4, !tbaa !5
  %156 = load float, ptr %13, align 4, !tbaa !13
  %157 = load float, ptr %14, align 4, !tbaa !13
  %158 = call i32 @fpoly_bessel_roots_orchard_recursion(i32 noundef %155, float noundef %156, float noundef %157, ptr noundef %15, ptr noundef %16)
  %159 = load float, ptr %15, align 4, !tbaa !13
  %160 = load float, ptr %16, align 4, !tbaa !13
  %161 = fmul float 0.000000e+00, %160
  %162 = fmul float 1.000000e+00, %160
  %163 = fadd float %159, %161
  %164 = load i32, ptr %10, align 4, !tbaa !5
  %165 = zext i32 %164 to i64
  %166 = getelementptr inbounds { float, float }, ptr %27, i64 %165
  %167 = getelementptr inbounds { float, float }, ptr %166, i32 0, i32 0
  %168 = getelementptr inbounds { float, float }, ptr %166, i32 0, i32 1
  store float %163, ptr %167, align 8
  store float %162, ptr %168, align 4
  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 %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  br label %169

169:                                              ; preds = %140
  %170 = load i32, ptr %10, align 4, !tbaa !5
  %171 = add i32 %170, 1
  store i32 %171, ptr %10, align 4, !tbaa !5
  br label %136, !llvm.loop !15

172:                                              ; preds = %136
  br label %173

173:                                              ; preds = %172, %51
  br label %174

174:                                              ; preds = %173, %41
  %175 = load i32, ptr %12, align 4, !tbaa !5
  %176 = load i32, ptr %11, align 4, !tbaa !5
  %177 = sub i32 %175, %176
  %178 = zext i32 %177 to i64
  %179 = mul i64 %178, 8
  call void @llvm.memmove.p0.p0.i64(ptr align 16 %21, ptr align 16 %24, i64 %179, i1 false)
  %180 = load i32, ptr %12, align 4, !tbaa !5
  %181 = zext i32 %180 to i64
  %182 = mul i64 %181, 8
  call void @llvm.memmove.p0.p0.i64(ptr align 16 %24, ptr align 16 %27, i64 %182, i1 false)
  br label %183

183:                                              ; preds = %174
  %184 = load i32, ptr %9, align 4, !tbaa !5
  %185 = add i32 %184, 1
  store i32 %185, ptr %9, align 4, !tbaa !5
  br label %28, !llvm.loop !16

186:                                              ; preds = %28
  %187 = load i32, ptr %3, align 4, !tbaa !5
  %188 = urem i32 %187, 2
  store i32 %188, ptr %11, align 4, !tbaa !5
  %189 = load i32, ptr %3, align 4, !tbaa !5
  %190 = load i32, ptr %11, align 4, !tbaa !5
  %191 = sub i32 %189, %190
  %192 = udiv i32 %191, 2
  store i32 %192, ptr %12, align 4, !tbaa !5
  store i32 0, ptr %9, align 4, !tbaa !5
  br label %193

193:                                              ; preds = %233, %186
  %194 = load i32, ptr %9, align 4, !tbaa !5
  %195 = load i32, ptr %12, align 4, !tbaa !5
  %196 = icmp ult i32 %194, %195
  br i1 %196, label %197, label %236

197:                                              ; preds = %193
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %198 = load i32, ptr %12, align 4, !tbaa !5
  %199 = load i32, ptr %9, align 4, !tbaa !5
  %200 = sub i32 %198, %199
  %201 = sub i32 %200, 1
  store i32 %201, ptr %17, align 4, !tbaa !5
  %202 = load i32, ptr %17, align 4, !tbaa !5
  %203 = zext i32 %202 to i64
  %204 = getelementptr inbounds { float, float }, ptr %27, i64 %203
  %205 = getelementptr inbounds { float, float }, ptr %204, i32 0, i32 0
  %206 = load float, ptr %205, align 8
  %207 = getelementptr inbounds { float, float }, ptr %204, i32 0, i32 1
  %208 = load float, ptr %207, align 4
  %209 = load ptr, ptr %4, align 8, !tbaa !9
  %210 = load i32, ptr %9, align 4, !tbaa !5
  %211 = mul i32 2, %210
  %212 = add i32 %211, 0
  %213 = zext i32 %212 to i64
  %214 = getelementptr inbounds { float, float }, ptr %209, i64 %213
  %215 = getelementptr inbounds { float, float }, ptr %214, i32 0, i32 0
  %216 = getelementptr inbounds { float, float }, ptr %214, i32 0, i32 1
  store float %206, ptr %215, align 4
  store float %208, ptr %216, align 4
  %217 = load i32, ptr %17, align 4, !tbaa !5
  %218 = zext i32 %217 to i64
  %219 = getelementptr inbounds { float, float }, ptr %27, i64 %218
  %220 = getelementptr inbounds { float, float }, ptr %219, i32 0, i32 0
  %221 = load float, ptr %220, align 8
  %222 = getelementptr inbounds { float, float }, ptr %219, i32 0, i32 1
  %223 = load float, ptr %222, align 4
  %224 = fneg float %223
  %225 = load ptr, ptr %4, align 8, !tbaa !9
  %226 = load i32, ptr %9, align 4, !tbaa !5
  %227 = mul i32 2, %226
  %228 = add i32 %227, 1
  %229 = zext i32 %228 to i64
  %230 = getelementptr inbounds { float, float }, ptr %225, i64 %229
  %231 = getelementptr inbounds { float, float }, ptr %230, i32 0, i32 0
  %232 = getelementptr inbounds { float, float }, ptr %230, i32 0, i32 1
  store float %221, ptr %231, align 4
  store float %224, ptr %232, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  br label %233

233:                                              ; preds = %197
  %234 = load i32, ptr %9, align 4, !tbaa !5
  %235 = add i32 %234, 1
  store i32 %235, ptr %9, align 4, !tbaa !5
  br label %193, !llvm.loop !17

236:                                              ; preds = %193
  %237 = load i32, ptr %11, align 4, !tbaa !5
  %238 = icmp ne i32 %237, 0
  br i1 %238, label %239, label %252

239:                                              ; preds = %236
  %240 = getelementptr inbounds { float, float }, ptr %27, i64 0
  %241 = getelementptr inbounds { float, float }, ptr %240, i32 0, i32 0
  %242 = load float, ptr %241, align 16
  %243 = getelementptr inbounds { float, float }, ptr %240, i32 0, i32 1
  %244 = load float, ptr %243, align 4
  %245 = load ptr, ptr %4, align 8, !tbaa !9
  %246 = load i32, ptr %3, align 4, !tbaa !5
  %247 = sub i32 %246, 1
  %248 = zext i32 %247 to i64
  %249 = getelementptr inbounds { float, float }, ptr %245, i64 %248
  %250 = getelementptr inbounds { float, float }, ptr %249, i32 0, i32 0
  %251 = getelementptr inbounds { float, float }, ptr %249, i32 0, i32 1
  store float %242, ptr %250, align 4
  store float %244, ptr %251, align 4
  br label %252

252:                                              ; preds = %239, %236
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #6
  %253 = load ptr, ptr %5, align 8
  call void @llvm.stackrestore.p0(ptr %253)
  ret i32 0
}

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @fpoly_bessel_roots_orchard_recursion(i32 noundef, float noundef, float noundef, ptr noundef, ptr noundef) #3

; 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) #5

attributes #0 = { nocallback nofree nosync nounwind willreturn }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 #3 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}
!13 = !{!14, !14, i64 0}
!14 = !{!"float", !7, i64 0}
!15 = distinct !{!15, !12}
!16 = distinct !{!16, !12}
!17 = distinct !{!17, !12}


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

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

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

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @fpoly_bessel_roots_orchard(i32 noundef %0, ptr nocapture noundef writeonly %1) local_unnamed_addr #1 {
  %3 = alloca float, align 4
  %4 = alloca float, align 4
  %5 = zext i32 %0 to i64
  %6 = alloca { float, float }, i64 %5, align 16
  %7 = alloca { float, float }, i64 %5, align 16
  %8 = alloca { float, float }, i64 %5, align 16
  %9 = icmp ugt i32 %0, 1
  br i1 %9, label %.lr.ph59, label %._crit_edge63

.lr.ph59:                                         ; preds = %2
  %10 = getelementptr inbounds i8, ptr %7, i64 4
  %11 = getelementptr inbounds i8, ptr %8, i64 4
  %12 = getelementptr inbounds i8, ptr %6, i64 4
  %invariant.gep = getelementptr i8, ptr %6, i64 -8
  %invariant.gep98 = getelementptr i8, ptr %6, i64 -8
  br label %13

13:                                               ; preds = %.lr.ph59, %.loopexit
  %indvar = phi i1 [ false, %.lr.ph59 ], [ %indvar.next, %.loopexit ]
  %.057 = phi i32 [ 1, %.lr.ph59 ], [ %72, %.loopexit ]
  %14 = xor i1 %indvar, true
  %15 = zext i1 %14 to i32
  %16 = add i32 %.057, %15
  %17 = lshr i32 %16, 1
  %18 = call i32 @llvm.umax.i32(i32 %17, i32 2)
  %umax = zext nneg i32 %18 to i64
  %19 = add nsw i64 %umax, -1
  %20 = and i32 %.057, 1
  %21 = add nuw i32 %20, %.057
  %22 = lshr i32 %21, 1
  switch i32 %.057, label %24 [
    i32 1, label %.loopexit.sink.split
    i32 2, label %23
  ]

23:                                               ; preds = %13
  br label %.loopexit.sink.split

24:                                               ; preds = %13
  %.not53 = icmp eq i32 %20, 0
  %25 = load float, ptr %7, align 16
  br i1 %.not53, label %30, label %26

26:                                               ; preds = %24
  %27 = load float, ptr %6, align 16
  %28 = fneg float %27
  %29 = call float @llvm.fmuladd.f32(float %25, float 2.000000e+00, float %28)
  br label %38

30:                                               ; preds = %24
  %31 = load float, ptr %10, align 4
  %32 = fmul float %25, 2.000000e+00
  %33 = fmul float %31, 2.000000e+00
  %34 = load float, ptr %6, align 16
  %35 = load float, ptr %12, align 4
  %36 = fsub float %32, %34
  %37 = fadd float %33, %35
  br label %38

38:                                               ; preds = %30, %26
  %storemerge74 = phi float [ %29, %26 ], [ %36, %30 ]
  %storemerge = phi float [ 0.000000e+00, %26 ], [ %37, %30 ]
  store float %storemerge74, ptr %8, align 16
  store float %storemerge, ptr %11, align 4
  %39 = icmp ugt i32 %21, 3
  br i1 %39, label %.lr.ph.preheader, label %.preheader

.lr.ph.preheader:                                 ; preds = %38
  %40 = zext nneg i32 %20 to i64
  %41 = zext nneg i32 %22 to i64
  %min.iters.check = icmp ult i32 %16, 10
  br i1 %min.iters.check, label %.lr.ph.preheader97, label %vector.ph

.lr.ph.preheader97:                               ; preds = %middle.block, %.lr.ph.preheader
  %indvars.iv.ph = phi i64 [ 1, %.lr.ph.preheader ], [ %ind.end, %middle.block ]
  br label %.lr.ph

vector.ph:                                        ; preds = %.lr.ph.preheader
  %n.vec = and i64 %19, -4
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %offset.idx = or disjoint i64 %index, 1
  %42 = sub nuw nsw i64 %offset.idx, %40
  %43 = getelementptr inbounds { float, float }, ptr %7, i64 %42
  %wide.vec = load <8 x float>, ptr %43, align 8
  %gep = getelementptr { float, float }, ptr %invariant.gep, i64 %offset.idx
  %wide.vec78 = load <8 x float>, ptr %gep, align 16
  %44 = getelementptr inbounds { float, float }, ptr %8, i64 %offset.idx
  %45 = fmul <8 x float> %wide.vec, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
  %interleaved.vec = fsub <8 x float> %45, %wide.vec78
  store <8 x float> %interleaved.vec, ptr %44, align 8
  %index.next = add nuw i64 %index, 4
  %46 = icmp eq i64 %index.next, %n.vec
  br i1 %46, label %middle.block, label %vector.body, !llvm.loop !5

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %19, %n.vec
  br i1 %cmp.n, label %.preheader, label %.lr.ph.preheader97

.preheader:                                       ; preds = %.lr.ph, %middle.block, %38
  %.not64 = icmp ult i32 %21, 2
  br i1 %.not64, label %.loopexit, label %.lr.ph56.preheader

.lr.ph56.preheader:                               ; preds = %.preheader
  %47 = zext nneg i32 %22 to i64
  br label %.lr.ph56

.lr.ph:                                           ; preds = %.lr.ph.preheader97, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %indvars.iv.ph, %.lr.ph.preheader97 ]
  %48 = sub nsw i64 %indvars.iv, %40
  %49 = getelementptr inbounds { float, float }, ptr %7, i64 %48
  %gep99 = getelementptr { float, float }, ptr %invariant.gep98, i64 %indvars.iv
  %50 = getelementptr inbounds { float, float }, ptr %8, i64 %indvars.iv
  %51 = load <2 x float>, ptr %49, align 8
  %52 = fmul <2 x float> %51, <float 2.000000e+00, float 2.000000e+00>
  %53 = load <2 x float>, ptr %gep99, align 8
  %54 = fsub <2 x float> %52, %53
  store <2 x float> %54, ptr %50, align 8
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %55 = icmp ult i64 %indvars.iv.next, %41
  br i1 %55, label %.lr.ph, label %.preheader, !llvm.loop !9

.lr.ph56:                                         ; preds = %.lr.ph56.preheader, %.lr.ph56
  %indvars.iv67 = phi i64 [ 0, %.lr.ph56.preheader ], [ %indvars.iv.next68, %.lr.ph56 ]
  %56 = getelementptr inbounds { float, float }, ptr %8, i64 %indvars.iv67
  %57 = load float, ptr %56, align 8
  %58 = getelementptr inbounds i8, ptr %56, i64 4
  %59 = load float, ptr %58, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %3) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %4) #5
  %60 = call i32 @fpoly_bessel_roots_orchard_recursion(i32 noundef %.057, float noundef %57, float noundef %59, ptr noundef nonnull %3, ptr noundef nonnull %4)
  %61 = load float, ptr %3, align 4, !tbaa !10
  %62 = load float, ptr %4, align 4, !tbaa !10
  %63 = fmul float %62, 0.000000e+00
  %64 = fadd float %61, %63
  store float %64, ptr %56, align 8
  store float %62, ptr %58, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %4) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %3) #5
  %indvars.iv.next68 = add nuw nsw i64 %indvars.iv67, 1
  %65 = icmp ult i64 %indvars.iv.next68, %47
  br i1 %65, label %.lr.ph56, label %.loopexit, !llvm.loop !14

.loopexit.sink.split:                             ; preds = %13, %23
  %66 = phi <2 x float> [ <float -1.500000e+00, float 0x3FEBB67AE0000000>, %23 ], [ <float -1.000000e+00, float 0.000000e+00>, %13 ]
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %7, align 16
  store <2 x float> %66, ptr %8, align 16
  br label %.loopexit

.loopexit:                                        ; preds = %.lr.ph56, %.loopexit.sink.split, %.preheader
  %67 = sub nsw i32 %22, %20
  %68 = zext i32 %67 to i64
  %69 = shl nuw nsw i64 %68, 3
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %6, ptr nonnull align 16 %7, i64 %69, i1 false)
  %70 = zext nneg i32 %22 to i64
  %71 = shl nuw nsw i64 %70, 3
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %7, ptr nonnull align 16 %8, i64 %71, i1 false)
  %72 = add nuw i32 %.057, 1
  %exitcond.not = icmp eq i32 %72, %0
  %indvar.next = xor i1 %indvar, true
  br i1 %exitcond.not, label %._crit_edge, label %13, !llvm.loop !15

._crit_edge:                                      ; preds = %.loopexit
  %73 = and i32 %0, 1
  %74 = lshr i32 %0, 1
  %wide.trip.count = zext nneg i32 %74 to i64
  %min.iters.check83 = icmp ult i32 %0, 16
  br i1 %min.iters.check83, label %.lr.ph62.preheader, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %._crit_edge
  %75 = add nsw i64 %wide.trip.count, -1
  %76 = add nsw i32 %74, -1
  %77 = trunc nsw i64 %75 to i32
  %78 = icmp ult i32 %76, %77
  %79 = icmp ugt i64 %75, 4294967295
  %80 = or i1 %78, %79
  br i1 %80, label %.lr.ph62.preheader, label %vector.ph84

vector.ph84:                                      ; preds = %vector.scevcheck
  %n.vec86 = and i64 %wide.trip.count, 2147483644
  %invariant.gep100 = getelementptr i8, ptr %8, i64 -24
  %invariant.gep102 = getelementptr i8, ptr %1, i64 -12
  br label %vector.body88

vector.body88:                                    ; preds = %vector.body88, %vector.ph84
  %index89 = phi i64 [ 0, %vector.ph84 ], [ %index.next95, %vector.body88 ]
  %81 = trunc i64 %index89 to i32
  %82 = xor i32 %81, -1
  %83 = add nsw i32 %74, %82
  %84 = zext i32 %83 to i64
  %gep101 = getelementptr { float, float }, ptr %invariant.gep100, i64 %84
  %wide.vec90 = load <8 x float>, ptr %gep101, align 8
  %strided.vec91 = shufflevector <8 x float> %wide.vec90, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %reverse = shufflevector <4 x float> %strided.vec91, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
  %strided.vec92 = shufflevector <8 x float> %wide.vec90, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %reverse93 = shufflevector <4 x float> %strided.vec92, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
  %85 = shl nuw i64 %index89, 1
  %86 = fneg <4 x float> %reverse93
  %87 = or disjoint i64 %85, 1
  %gep103 = getelementptr { float, float }, ptr %invariant.gep102, i64 %87, i32 1
  %88 = shufflevector <4 x float> %reverse, <4 x float> %reverse93, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %89 = shufflevector <4 x float> %reverse, <4 x float> %86, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec94 = shufflevector <8 x float> %88, <8 x float> %89, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
  store <16 x float> %interleaved.vec94, ptr %gep103, align 4
  %index.next95 = add nuw i64 %index89, 4
  %90 = icmp eq i64 %index.next95, %n.vec86
  br i1 %90, label %middle.block81, label %vector.body88, !llvm.loop !16

middle.block81:                                   ; preds = %vector.body88
  %cmp.n96 = icmp eq i64 %n.vec86, %wide.trip.count
  br i1 %cmp.n96, label %._crit_edge63, label %.lr.ph62.preheader

.lr.ph62.preheader:                               ; preds = %middle.block81, %vector.scevcheck, %._crit_edge
  %indvars.iv70.ph = phi i64 [ 0, %vector.scevcheck ], [ 0, %._crit_edge ], [ %n.vec86, %middle.block81 ]
  %xtraiter = and i64 %wide.trip.count, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.lr.ph62.prol.loopexit, label %.lr.ph62.prol

.lr.ph62.prol:                                    ; preds = %.lr.ph62.preheader
  %91 = trunc nuw nsw i64 %indvars.iv70.ph to i32
  %92 = xor i32 %91, -1
  %93 = add nsw i32 %74, %92
  %94 = zext i32 %93 to i64
  %95 = getelementptr inbounds { float, float }, ptr %8, i64 %94
  %96 = shl nuw nsw i64 %indvars.iv70.ph, 1
  %97 = getelementptr inbounds { float, float }, ptr %1, i64 %96
  %98 = load <2 x float>, ptr %95, align 8
  store <2 x float> %98, ptr %97, align 4
  %99 = extractelement <2 x float> %98, i64 1
  %100 = fneg float %99
  %101 = or disjoint i64 %96, 1
  %102 = getelementptr inbounds { float, float }, ptr %1, i64 %101
  %103 = getelementptr inbounds i8, ptr %102, i64 4
  %104 = extractelement <2 x float> %98, i64 0
  store float %104, ptr %102, align 4
  store float %100, ptr %103, align 4
  %indvars.iv.next71.prol = or disjoint i64 %indvars.iv70.ph, 1
  br label %.lr.ph62.prol.loopexit

.lr.ph62.prol.loopexit:                           ; preds = %.lr.ph62.prol, %.lr.ph62.preheader
  %indvars.iv70.unr = phi i64 [ %indvars.iv70.ph, %.lr.ph62.preheader ], [ %indvars.iv.next71.prol, %.lr.ph62.prol ]
  %105 = add nsw i64 %wide.trip.count, -1
  %106 = icmp eq i64 %indvars.iv70.ph, %105
  br i1 %106, label %._crit_edge63, label %.lr.ph62

.lr.ph62:                                         ; preds = %.lr.ph62.prol.loopexit, %.lr.ph62
  %indvars.iv70 = phi i64 [ %indvars.iv.next71.1, %.lr.ph62 ], [ %indvars.iv70.unr, %.lr.ph62.prol.loopexit ]
  %107 = trunc nuw nsw i64 %indvars.iv70 to i32
  %108 = xor i32 %107, -1
  %109 = add nsw i32 %74, %108
  %110 = zext i32 %109 to i64
  %111 = getelementptr inbounds { float, float }, ptr %8, i64 %110
  %112 = shl nuw i64 %indvars.iv70, 1
  %113 = getelementptr inbounds { float, float }, ptr %1, i64 %112
  %114 = load <2 x float>, ptr %111, align 8
  store <2 x float> %114, ptr %113, align 4
  %115 = extractelement <2 x float> %114, i64 1
  %116 = fneg float %115
  %117 = or disjoint i64 %112, 1
  %118 = getelementptr inbounds { float, float }, ptr %1, i64 %117
  %119 = getelementptr inbounds i8, ptr %118, i64 4
  %120 = extractelement <2 x float> %114, i64 0
  store float %120, ptr %118, align 4
  store float %116, ptr %119, align 4
  %indvars.iv.next71 = add nuw nsw i64 %indvars.iv70, 1
  %121 = trunc nuw nsw i64 %indvars.iv.next71 to i32
  %122 = xor i32 %121, -1
  %123 = add nsw i32 %74, %122
  %124 = zext i32 %123 to i64
  %125 = getelementptr inbounds { float, float }, ptr %8, i64 %124
  %126 = shl nuw i64 %indvars.iv.next71, 1
  %127 = getelementptr inbounds { float, float }, ptr %1, i64 %126
  %128 = load <2 x float>, ptr %125, align 8
  store <2 x float> %128, ptr %127, align 4
  %129 = extractelement <2 x float> %128, i64 1
  %130 = fneg float %129
  %131 = or disjoint i64 %126, 1
  %132 = getelementptr inbounds { float, float }, ptr %1, i64 %131
  %133 = getelementptr inbounds i8, ptr %132, i64 4
  %134 = extractelement <2 x float> %128, i64 0
  store float %134, ptr %132, align 4
  store float %130, ptr %133, align 4
  %indvars.iv.next71.1 = add nuw nsw i64 %indvars.iv70, 2
  %exitcond73.not.1 = icmp eq i64 %indvars.iv.next71.1, %wide.trip.count
  br i1 %exitcond73.not.1, label %._crit_edge63, label %.lr.ph62, !llvm.loop !17

._crit_edge63:                                    ; preds = %.lr.ph62.prol.loopexit, %.lr.ph62, %middle.block81, %2
  %135 = phi i32 [ %0, %2 ], [ %73, %middle.block81 ], [ %73, %.lr.ph62 ], [ %73, %.lr.ph62.prol.loopexit ]
  %.not = icmp eq i32 %135, 0
  br i1 %.not, label %141, label %136

136:                                              ; preds = %._crit_edge63
  %137 = add nsw i32 %0, -1
  %138 = zext i32 %137 to i64
  %139 = getelementptr inbounds { float, float }, ptr %1, i64 %138
  %140 = load <2 x float>, ptr %8, align 16
  store <2 x float> %140, ptr %139, align 4
  br label %141

141:                                              ; preds = %136, %._crit_edge63
  ret i32 0
}

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @fpoly_bessel_roots_orchard_recursion(i32 noundef, float noundef, float noundef, ptr noundef, ptr noundef) local_unnamed_addr #1

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

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

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

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

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


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass