; LLVM IR from jgaeddert/liquid-dsp :: src/fft/src (fftf)

; 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.fftplan_s = type { i32, ptr, ptr, i32, i32, i32, i32, ptr, ptr, ptr, %union.anon }
%union.anon = type { %struct.anon.1 }
%struct.anon.1 = type { i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }

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

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @fft_execute(ptr noundef) #1

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

; Function Attrs: nounwind uwtable
define dso_local i32 @fft_execute_mixed_radix(ptr noundef %0) #2 {
  %2 = alloca ptr, align 8
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca { float, float }, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #4
  %12 = load ptr, ptr %2, align 8, !tbaa !5
  %13 = getelementptr inbounds %struct.fftplan_s, ptr %12, i32 0, i32 10
  %14 = getelementptr inbounds %struct.anon.1, ptr %13, i32 0, i32 0
  %15 = load i32, ptr %14, align 8, !tbaa !9
  store i32 %15, ptr %3, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #4
  %16 = load ptr, ptr %2, align 8, !tbaa !5
  %17 = getelementptr inbounds %struct.fftplan_s, ptr %16, i32 0, i32 10
  %18 = getelementptr inbounds %struct.anon.1, ptr %17, i32 0, i32 1
  %19 = load i32, ptr %18, align 4, !tbaa !9
  store i32 %19, ptr %4, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #4
  %20 = load ptr, ptr %2, align 8, !tbaa !5
  %21 = getelementptr inbounds %struct.fftplan_s, ptr %20, i32 0, i32 10
  %22 = getelementptr inbounds %struct.anon.1, ptr %21, i32 0, i32 3
  %23 = load ptr, ptr %22, align 8, !tbaa !9
  store ptr %23, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #4
  %24 = load ptr, ptr %2, align 8, !tbaa !5
  %25 = getelementptr inbounds %struct.fftplan_s, ptr %24, i32 0, i32 10
  %26 = getelementptr inbounds %struct.anon.1, ptr %25, i32 0, i32 4
  %27 = load ptr, ptr %26, align 8, !tbaa !9
  store ptr %27, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #4
  %28 = load ptr, ptr %2, align 8, !tbaa !5
  %29 = getelementptr inbounds %struct.fftplan_s, ptr %28, i32 0, i32 10
  %30 = getelementptr inbounds %struct.anon.1, ptr %29, i32 0, i32 2
  %31 = load ptr, ptr %30, align 8, !tbaa !9
  store ptr %31, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #4
  %32 = load ptr, ptr %2, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.fftplan_s, ptr %32, i32 0, i32 10
  %34 = getelementptr inbounds %struct.anon.1, ptr %33, i32 0, i32 5
  %35 = load ptr, ptr %34, align 8, !tbaa !9
  store ptr %35, ptr %8, align 8, !tbaa !5
  %36 = load ptr, ptr %7, align 8, !tbaa !5
  %37 = load ptr, ptr %2, align 8, !tbaa !5
  %38 = getelementptr inbounds %struct.fftplan_s, ptr %37, i32 0, i32 1
  %39 = load ptr, ptr %38, align 8, !tbaa !12
  %40 = load ptr, ptr %2, align 8, !tbaa !5
  %41 = getelementptr inbounds %struct.fftplan_s, ptr %40, i32 0, i32 0
  %42 = load i32, ptr %41, align 8, !tbaa !14
  %43 = zext i32 %42 to i64
  %44 = mul i64 %43, 8
  call void @llvm.memmove.p0.p0.i64(ptr align 4 %36, ptr align 4 %39, i64 %44, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #4
  store i32 0, ptr %9, align 4, !tbaa !10
  br label %45

45:                                               ; preds = %137, %1
  %46 = load i32, ptr %9, align 4, !tbaa !10
  %47 = load i32, ptr %4, align 4, !tbaa !10
  %48 = icmp ult i32 %46, %47
  br i1 %48, label %49, label %140

49:                                               ; preds = %45
  store i32 0, ptr %10, align 4, !tbaa !10
  br label %50

50:                                               ; preds = %73, %49
  %51 = load i32, ptr %10, align 4, !tbaa !10
  %52 = load i32, ptr %3, align 4, !tbaa !10
  %53 = icmp ult i32 %51, %52
  br i1 %53, label %54, label %76

54:                                               ; preds = %50
  %55 = load ptr, ptr %7, align 8, !tbaa !5
  %56 = load i32, ptr %4, align 4, !tbaa !10
  %57 = load i32, ptr %10, align 4, !tbaa !10
  %58 = mul i32 %56, %57
  %59 = load i32, ptr %9, align 4, !tbaa !10
  %60 = add i32 %58, %59
  %61 = zext i32 %60 to i64
  %62 = getelementptr inbounds { float, float }, ptr %55, i64 %61
  %63 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 0
  %64 = load float, ptr %63, align 4
  %65 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 1
  %66 = load float, ptr %65, align 4
  %67 = load ptr, ptr %5, align 8, !tbaa !5
  %68 = load i32, ptr %10, align 4, !tbaa !10
  %69 = zext i32 %68 to i64
  %70 = getelementptr inbounds { float, float }, ptr %67, i64 %69
  %71 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 0
  %72 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 1
  store float %64, ptr %71, align 4
  store float %66, ptr %72, align 4
  br label %73

73:                                               ; preds = %54
  %74 = load i32, ptr %10, align 4, !tbaa !10
  %75 = add i32 %74, 1
  store i32 %75, ptr %10, align 4, !tbaa !10
  br label %50, !llvm.loop !15

76:                                               ; preds = %50
  %77 = load ptr, ptr %2, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.fftplan_s, ptr %77, i32 0, i32 10
  %79 = getelementptr inbounds %struct.anon.1, ptr %78, i32 0, i32 6
  %80 = load ptr, ptr %79, align 8, !tbaa !9
  %81 = call i32 @fft_execute(ptr noundef %80)
  store i32 0, ptr %10, align 4, !tbaa !10
  br label %82

82:                                               ; preds = %133, %76
  %83 = load i32, ptr %10, align 4, !tbaa !10
  %84 = load i32, ptr %3, align 4, !tbaa !10
  %85 = icmp ult i32 %83, %84
  br i1 %85, label %86, label %136

86:                                               ; preds = %82
  %87 = load ptr, ptr %6, align 8, !tbaa !5
  %88 = load i32, ptr %10, align 4, !tbaa !10
  %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 %8, align 8, !tbaa !5
  %96 = load i32, ptr %9, align 4, !tbaa !10
  %97 = load i32, ptr %10, align 4, !tbaa !10
  %98 = mul i32 %96, %97
  %99 = zext i32 %98 to i64
  %100 = getelementptr inbounds { float, float }, ptr %95, 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 = fmul float %92, %102
  %106 = fmul float %94, %104
  %107 = fmul float %92, %104
  %108 = fmul float %94, %102
  %109 = fsub float %105, %106
  %110 = fadd float %107, %108
  %111 = fcmp uno float %109, %109
  br i1 %111, label %112, label %120, !prof !17

112:                                              ; preds = %86
  %113 = fcmp uno float %110, %110
  br i1 %113, label %114, label %120, !prof !17

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

120:                                              ; preds = %114, %112, %86
  %121 = phi float [ %109, %86 ], [ %109, %112 ], [ %117, %114 ]
  %122 = phi float [ %110, %86 ], [ %110, %112 ], [ %119, %114 ]
  %123 = load ptr, ptr %7, align 8, !tbaa !5
  %124 = load i32, ptr %4, align 4, !tbaa !10
  %125 = load i32, ptr %10, align 4, !tbaa !10
  %126 = mul i32 %124, %125
  %127 = load i32, ptr %9, align 4, !tbaa !10
  %128 = add i32 %126, %127
  %129 = zext i32 %128 to i64
  %130 = getelementptr inbounds { float, float }, ptr %123, i64 %129
  %131 = getelementptr inbounds { float, float }, ptr %130, i32 0, i32 0
  %132 = getelementptr inbounds { float, float }, ptr %130, i32 0, i32 1
  store float %121, ptr %131, align 4
  store float %122, ptr %132, align 4
  br label %133

133:                                              ; preds = %120
  %134 = load i32, ptr %10, align 4, !tbaa !10
  %135 = add i32 %134, 1
  store i32 %135, ptr %10, align 4, !tbaa !10
  br label %82, !llvm.loop !18

136:                                              ; preds = %82
  br label %137

137:                                              ; preds = %136
  %138 = load i32, ptr %9, align 4, !tbaa !10
  %139 = add i32 %138, 1
  store i32 %139, ptr %9, align 4, !tbaa !10
  br label %45, !llvm.loop !19

140:                                              ; preds = %45
  store i32 0, ptr %9, align 4, !tbaa !10
  br label %141

141:                                              ; preds = %207, %140
  %142 = load i32, ptr %9, align 4, !tbaa !10
  %143 = load i32, ptr %3, align 4, !tbaa !10
  %144 = icmp ult i32 %142, %143
  br i1 %144, label %145, label %210

145:                                              ; preds = %141
  store i32 0, ptr %10, align 4, !tbaa !10
  br label %146

146:                                              ; preds = %169, %145
  %147 = load i32, ptr %10, align 4, !tbaa !10
  %148 = load i32, ptr %4, align 4, !tbaa !10
  %149 = icmp ult i32 %147, %148
  br i1 %149, label %150, label %172

150:                                              ; preds = %146
  %151 = load ptr, ptr %7, align 8, !tbaa !5
  %152 = load i32, ptr %4, align 4, !tbaa !10
  %153 = load i32, ptr %9, align 4, !tbaa !10
  %154 = mul i32 %152, %153
  %155 = load i32, ptr %10, align 4, !tbaa !10
  %156 = add i32 %154, %155
  %157 = zext i32 %156 to i64
  %158 = getelementptr inbounds { float, float }, ptr %151, i64 %157
  %159 = getelementptr inbounds { float, float }, ptr %158, i32 0, i32 0
  %160 = load float, ptr %159, align 4
  %161 = getelementptr inbounds { float, float }, ptr %158, i32 0, i32 1
  %162 = load float, ptr %161, align 4
  %163 = load ptr, ptr %5, align 8, !tbaa !5
  %164 = load i32, ptr %10, align 4, !tbaa !10
  %165 = zext i32 %164 to i64
  %166 = getelementptr inbounds { float, float }, ptr %163, 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 %160, ptr %167, align 4
  store float %162, ptr %168, align 4
  br label %169

169:                                              ; preds = %150
  %170 = load i32, ptr %10, align 4, !tbaa !10
  %171 = add i32 %170, 1
  store i32 %171, ptr %10, align 4, !tbaa !10
  br label %146, !llvm.loop !20

172:                                              ; preds = %146
  %173 = load ptr, ptr %2, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.fftplan_s, ptr %173, i32 0, i32 10
  %175 = getelementptr inbounds %struct.anon.1, ptr %174, i32 0, i32 7
  %176 = load ptr, ptr %175, align 8, !tbaa !9
  %177 = call i32 @fft_execute(ptr noundef %176)
  store i32 0, ptr %10, align 4, !tbaa !10
  br label %178

178:                                              ; preds = %203, %172
  %179 = load i32, ptr %10, align 4, !tbaa !10
  %180 = load i32, ptr %4, align 4, !tbaa !10
  %181 = icmp ult i32 %179, %180
  br i1 %181, label %182, label %206

182:                                              ; preds = %178
  %183 = load ptr, ptr %6, align 8, !tbaa !5
  %184 = load i32, ptr %10, align 4, !tbaa !10
  %185 = zext i32 %184 to i64
  %186 = getelementptr inbounds { float, float }, ptr %183, i64 %185
  %187 = getelementptr inbounds { float, float }, ptr %186, i32 0, i32 0
  %188 = load float, ptr %187, align 4
  %189 = getelementptr inbounds { float, float }, ptr %186, i32 0, i32 1
  %190 = load float, ptr %189, align 4
  %191 = load ptr, ptr %2, align 8, !tbaa !5
  %192 = getelementptr inbounds %struct.fftplan_s, ptr %191, i32 0, i32 2
  %193 = load ptr, ptr %192, align 8, !tbaa !21
  %194 = load i32, ptr %10, align 4, !tbaa !10
  %195 = load i32, ptr %3, align 4, !tbaa !10
  %196 = mul i32 %194, %195
  %197 = load i32, ptr %9, align 4, !tbaa !10
  %198 = add i32 %196, %197
  %199 = zext i32 %198 to i64
  %200 = getelementptr inbounds { float, float }, ptr %193, i64 %199
  %201 = getelementptr inbounds { float, float }, ptr %200, i32 0, i32 0
  %202 = getelementptr inbounds { float, float }, ptr %200, i32 0, i32 1
  store float %188, ptr %201, align 4
  store float %190, ptr %202, align 4
  br label %203

203:                                              ; preds = %182
  %204 = load i32, ptr %10, align 4, !tbaa !10
  %205 = add i32 %204, 1
  store i32 %205, ptr %10, align 4, !tbaa !10
  br label %178, !llvm.loop !22

206:                                              ; preds = %178
  br label %207

207:                                              ; preds = %206
  %208 = load i32, ptr %9, align 4, !tbaa !10
  %209 = add i32 %208, 1
  store i32 %209, ptr %9, align 4, !tbaa !10
  br label %141, !llvm.loop !23

210:                                              ; preds = %141
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #4
  ret i32 0
}

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

attributes #0 = { 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 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { 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 = !{!7, !7, i64 0}
!10 = !{!11, !11, i64 0}
!11 = !{!"int", !7, i64 0}
!12 = !{!13, !6, i64 8}
!13 = !{!"fftplan_s", !11, i64 0, !6, i64 8, !6, i64 16, !11, i64 24, !11, i64 28, !11, i64 32, !11, i64 36, !6, i64 40, !6, i64 48, !6, i64 56, !7, i64 64}
!14 = !{!13, !11, i64 0}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = !{!"branch_weights", i32 1, i32 1048575}
!18 = distinct !{!18, !16}
!19 = distinct !{!19, !16}
!20 = distinct !{!20, !16}
!21 = !{!13, !6, i64 16}
!22 = distinct !{!22, !16}
!23 = distinct !{!23, !16}


; 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 uwtable
declare dso_local i32 @fft_execute(ptr noundef) local_unnamed_addr #0

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

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @fft_execute_mixed_radix(ptr nocapture noundef readonly %0) local_unnamed_addr #1 {
  %2 = getelementptr inbounds i8, ptr %0, i64 64
  %3 = load i32, ptr %2, align 8, !tbaa !5
  %.fr90 = freeze i32 %3
  %4 = getelementptr inbounds i8, ptr %0, i64 68
  %5 = load i32, ptr %4, align 4, !tbaa !5
  %.fr = freeze i32 %5
  %6 = getelementptr inbounds i8, ptr %0, i64 80
  %7 = load ptr, ptr %6, align 8, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %0, i64 88
  %9 = load ptr, ptr %8, align 8, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %0, i64 72
  %11 = load ptr, ptr %10, align 8, !tbaa !5
  %12 = getelementptr inbounds i8, ptr %0, i64 96
  %13 = load ptr, ptr %12, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %0, i64 8
  %15 = load ptr, ptr %14, align 8, !tbaa !8
  %16 = load i32, ptr %0, align 8, !tbaa !12
  %17 = zext i32 %16 to i64
  %18 = shl nuw nsw i64 %17, 3
  tail call void @llvm.memmove.p0.p0.i64(ptr align 4 %11, ptr align 4 %15, i64 %18, i1 false)
  %.not = icmp eq i32 %.fr, 0
  %.not92132 = icmp eq i32 %.fr90, 0
  br i1 %.not, label %.preheader61.thread, label %.preheader62.lr.ph

.preheader62.lr.ph:                               ; preds = %1
  %19 = getelementptr inbounds i8, ptr %0, i64 104
  br i1 %.not92132, label %.preheader62, label %.preheader62.us.preheader

.preheader62.us.preheader:                        ; preds = %.preheader62.lr.ph
  %wide.trip.count = zext i32 %.fr90 to i64
  %20 = add nsw i64 %wide.trip.count, -1
  %21 = shl nuw nsw i64 %wide.trip.count, 3
  %scevgep = getelementptr i8, ptr %7, i64 %21
  %22 = add i32 %.fr, -1
  %23 = zext i32 %22 to i64
  %24 = add nuw nsw i64 %wide.trip.count, %23
  %25 = shl nuw nsw i64 %24, 3
  %scevgep137 = getelementptr i8, ptr %11, i64 %25
  %min.iters.check = icmp ult i32 %.fr90, 10
  %ident.check = icmp ne i32 %.fr, 1
  %26 = trunc i64 %20 to i32
  %27 = icmp ugt i64 %20, 4294967295
  %bound0 = icmp ult ptr %7, %scevgep137
  %bound1 = icmp ult ptr %11, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  %n.vec = and i64 %wide.trip.count, 4294967292
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  %xtraiter = and i64 %wide.trip.count, 3
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br label %.lr.ph.us.preheader

.lr.ph.us.preheader:                              ; preds = %._crit_edge67.us, %.preheader62.us.preheader
  %.068.us = phi i32 [ %115, %._crit_edge67.us ], [ 0, %.preheader62.us.preheader ]
  br i1 %min.iters.check, label %.lr.ph.us.preheader173, label %vector.scevcheck

.lr.ph.us.preheader173:                           ; preds = %vector.scevcheck, %middle.block, %.lr.ph.us.preheader
  %indvars.iv.ph = phi i64 [ 0, %vector.scevcheck ], [ 0, %.lr.ph.us.preheader ], [ %n.vec, %middle.block ]
  br i1 %lcmp.mod.not, label %.lr.ph.us.prol.loopexit, label %.lr.ph.us.prol

.lr.ph.us.prol:                                   ; preds = %.lr.ph.us.preheader173, %.lr.ph.us.prol
  %indvars.iv.prol = phi i64 [ %indvars.iv.next.prol, %.lr.ph.us.prol ], [ %indvars.iv.ph, %.lr.ph.us.preheader173 ]
  %prol.iter = phi i64 [ %prol.iter.next, %.lr.ph.us.prol ], [ 0, %.lr.ph.us.preheader173 ]
  %28 = trunc nuw i64 %indvars.iv.prol to i32
  %29 = mul i32 %.fr, %28
  %30 = add i32 %29, %.068.us
  %31 = zext i32 %30 to i64
  %32 = getelementptr inbounds { float, float }, ptr %11, i64 %31
  %33 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.prol
  %34 = load <2 x float>, ptr %32, align 4
  store <2 x float> %34, ptr %33, align 4
  %indvars.iv.next.prol = add nuw nsw i64 %indvars.iv.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %.lr.ph.us.prol.loopexit, label %.lr.ph.us.prol, !llvm.loop !13

.lr.ph.us.prol.loopexit:                          ; preds = %.lr.ph.us.prol, %.lr.ph.us.preheader173
  %indvars.iv.unr = phi i64 [ %indvars.iv.ph, %.lr.ph.us.preheader173 ], [ %indvars.iv.next.prol, %.lr.ph.us.prol ]
  %35 = sub nsw i64 %indvars.iv.ph, %wide.trip.count
  %36 = icmp ugt i64 %35, -4
  br i1 %36, label %.lr.ph66.us, label %.lr.ph.us

vector.scevcheck:                                 ; preds = %.lr.ph.us.preheader
  %37 = xor i32 %.068.us, -1
  %38 = icmp ult i32 %37, %26
  %39 = or i1 %38, %27
  %40 = or i1 %ident.check, %39
  %brmerge = select i1 %40, i1 true, i1 %found.conflict
  br i1 %brmerge, label %.lr.ph.us.preheader173, label %vector.body

vector.body:                                      ; preds = %vector.scevcheck, %vector.body
  %index = phi i64 [ %index.next, %vector.body ], [ 0, %vector.scevcheck ]
  %41 = or disjoint i64 %index, 2
  %42 = trunc i64 %index to i32
  %43 = or disjoint i32 %42, 2
  %44 = add i32 %.068.us, %42
  %45 = add i32 %43, %.068.us
  %46 = zext i32 %44 to i64
  %47 = zext i32 %45 to i64
  %48 = getelementptr inbounds { float, float }, ptr %11, i64 %46
  %49 = getelementptr inbounds { float, float }, ptr %11, i64 %47
  %wide.vec = load <4 x float>, ptr %48, align 4
  %wide.vec138 = load <4 x float>, ptr %49, align 4
  %50 = getelementptr inbounds { float, float }, ptr %7, i64 %index
  %51 = getelementptr inbounds { float, float }, ptr %7, i64 %41
  store <4 x float> %wide.vec, ptr %50, align 4
  store <4 x float> %wide.vec138, ptr %51, align 4
  %index.next = add nuw i64 %index, 4
  %52 = icmp eq i64 %index.next, %n.vec
  br i1 %52, label %middle.block, label %vector.body, !llvm.loop !15

middle.block:                                     ; preds = %vector.body
  br i1 %cmp.n, label %.lr.ph66.us, label %.lr.ph.us.preheader173

.lr.ph66.us:                                      ; preds = %.lr.ph.us.prol.loopexit, %.lr.ph.us, %middle.block
  %53 = load ptr, ptr %19, align 8, !tbaa !5
  %54 = tail call i32 @fft_execute(ptr noundef %53)
  br label %55

55:                                               ; preds = %.lr.ph66.us, %79
  %indvars.iv100 = phi i64 [ 0, %.lr.ph66.us ], [ %indvars.iv.next101, %79 ]
  %56 = getelementptr inbounds { float, float }, ptr %9, i64 %indvars.iv100
  %57 = trunc nuw i64 %indvars.iv100 to i32
  %58 = mul i32 %.068.us, %57
  %59 = zext i32 %58 to i64
  %60 = getelementptr inbounds { float, float }, ptr %13, i64 %59
  %61 = load <2 x float>, ptr %56, align 4
  %62 = load <2 x float>, ptr %60, align 4
  %63 = fmul <2 x float> %61, %62
  %64 = shufflevector <2 x float> %61, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %65 = fmul <2 x float> %64, %62
  %shift = shufflevector <2 x float> %63, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %66 = fsub <2 x float> %63, %shift
  %67 = extractelement <2 x float> %66, i64 0
  %shift171 = shufflevector <2 x float> %65, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %68 = fadd <2 x float> %65, %shift171
  %69 = extractelement <2 x float> %68, i64 0
  %70 = fcmp uno float %67, 0.000000e+00
  br i1 %70, label %71, label %79, !prof !19

71:                                               ; preds = %55
  %72 = fcmp uno float %69, 0.000000e+00
  br i1 %72, label %73, label %79, !prof !19

73:                                               ; preds = %71
  %74 = extractelement <2 x float> %61, i64 0
  %75 = extractelement <2 x float> %61, i64 1
  %76 = extractelement <2 x float> %62, i64 0
  %77 = extractelement <2 x float> %62, i64 1
  %78 = tail call <2 x float> @__mulsc3(float noundef %74, float noundef %75, float noundef %76, float noundef %77) #3
  %.sroa.0.0.vec.extract.us = extractelement <2 x float> %78, i64 0
  %.sroa.0.4.vec.extract.us = extractelement <2 x float> %78, i64 1
  br label %79

79:                                               ; preds = %73, %71, %55
  %80 = phi float [ %67, %55 ], [ %67, %71 ], [ %.sroa.0.0.vec.extract.us, %73 ]
  %81 = phi float [ %69, %55 ], [ %69, %71 ], [ %.sroa.0.4.vec.extract.us, %73 ]
  %82 = mul i32 %.fr, %57
  %83 = add i32 %82, %.068.us
  %84 = zext i32 %83 to i64
  %85 = getelementptr inbounds { float, float }, ptr %11, i64 %84
  %86 = getelementptr inbounds i8, ptr %85, i64 4
  store float %80, ptr %85, align 4
  store float %81, ptr %86, align 4
  %indvars.iv.next101 = add nuw nsw i64 %indvars.iv100, 1
  %exitcond104.not = icmp eq i64 %indvars.iv.next101, %wide.trip.count
  br i1 %exitcond104.not, label %._crit_edge67.us, label %55, !llvm.loop !20

.lr.ph.us:                                        ; preds = %.lr.ph.us.prol.loopexit, %.lr.ph.us
  %indvars.iv = phi i64 [ %indvars.iv.next.3, %.lr.ph.us ], [ %indvars.iv.unr, %.lr.ph.us.prol.loopexit ]
  %87 = trunc nuw i64 %indvars.iv to i32
  %88 = mul i32 %.fr, %87
  %89 = add i32 %88, %.068.us
  %90 = zext i32 %89 to i64
  %91 = getelementptr inbounds { float, float }, ptr %11, i64 %90
  %92 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv
  %93 = load <2 x float>, ptr %91, align 4
  store <2 x float> %93, ptr %92, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %94 = trunc nuw i64 %indvars.iv.next to i32
  %95 = mul i32 %.fr, %94
  %96 = add i32 %95, %.068.us
  %97 = zext i32 %96 to i64
  %98 = getelementptr inbounds { float, float }, ptr %11, i64 %97
  %99 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next
  %100 = load <2 x float>, ptr %98, align 4
  store <2 x float> %100, ptr %99, align 4
  %indvars.iv.next.1 = add nuw nsw i64 %indvars.iv, 2
  %101 = trunc nuw i64 %indvars.iv.next.1 to i32
  %102 = mul i32 %.fr, %101
  %103 = add i32 %102, %.068.us
  %104 = zext i32 %103 to i64
  %105 = getelementptr inbounds { float, float }, ptr %11, i64 %104
  %106 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next.1
  %107 = load <2 x float>, ptr %105, align 4
  store <2 x float> %107, ptr %106, align 4
  %indvars.iv.next.2 = add nuw nsw i64 %indvars.iv, 3
  %108 = trunc nuw i64 %indvars.iv.next.2 to i32
  %109 = mul i32 %.fr, %108
  %110 = add i32 %109, %.068.us
  %111 = zext i32 %110 to i64
  %112 = getelementptr inbounds { float, float }, ptr %11, i64 %111
  %113 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next.2
  %114 = load <2 x float>, ptr %112, align 4
  store <2 x float> %114, ptr %113, align 4
  %indvars.iv.next.3 = add nuw nsw i64 %indvars.iv, 4
  %exitcond.not.3 = icmp eq i64 %indvars.iv.next.3, %wide.trip.count
  br i1 %exitcond.not.3, label %.lr.ph66.us, label %.lr.ph.us, !llvm.loop !21

._crit_edge67.us:                                 ; preds = %79
  %115 = add nuw i32 %.068.us, 1
  %exitcond105.not = icmp eq i32 %115, %.fr
  br i1 %exitcond105.not, label %.preheader61, label %.lr.ph.us.preheader, !llvm.loop !22

.preheader62:                                     ; preds = %.preheader62.lr.ph, %.preheader62
  %.068 = phi i32 [ %118, %.preheader62 ], [ 0, %.preheader62.lr.ph ]
  %116 = load ptr, ptr %19, align 8, !tbaa !5
  %117 = tail call i32 @fft_execute(ptr noundef %116)
  %118 = add nuw i32 %.068, 1
  %exitcond114.not = icmp eq i32 %118, %.fr
  br i1 %exitcond114.not, label %.preheader61, label %.preheader62, !llvm.loop !22

.preheader61:                                     ; preds = %._crit_edge67.us, %.preheader62
  %.not92 = icmp eq i32 %.fr90, 0
  br i1 %.not92, label %._crit_edge80, label %.preheader.lr.ph

.preheader61.thread:                              ; preds = %1
  br i1 %.not92132, label %._crit_edge80, label %.preheader.lr.ph.thread

.preheader.lr.ph.thread:                          ; preds = %.preheader61.thread
  %119 = getelementptr inbounds i8, ptr %0, i64 112
  br label %.preheader.preheader

.preheader.lr.ph:                                 ; preds = %.preheader61
  %120 = getelementptr inbounds i8, ptr %0, i64 112
  %121 = getelementptr inbounds i8, ptr %0, i64 16
  br i1 %.not, label %.preheader.preheader, label %.preheader.us.preheader

.preheader.us.preheader:                          ; preds = %.preheader.lr.ph
  %wide.trip.count118 = zext i32 %.fr to i64
  %122 = add nsw i64 %wide.trip.count118, -1
  %123 = shl nuw nsw i64 %wide.trip.count118, 3
  %scevgep145 = getelementptr i8, ptr %7, i64 %123
  %scevgep147 = getelementptr i8, ptr %11, i64 %123
  %min.iters.check154 = icmp ult i32 %.fr, 8
  %124 = trunc i64 %122 to i32
  %125 = icmp ugt i64 %122, 4294967295
  %n.vec157 = and i64 %wide.trip.count118, 4294967292
  %cmp.n170 = icmp eq i64 %n.vec157, %wide.trip.count118
  %xtraiter175 = and i64 %wide.trip.count118, 3
  %lcmp.mod176.not = icmp eq i64 %xtraiter175, 0
  %xtraiter178 = and i64 %wide.trip.count118, 1
  %126 = icmp eq i64 %122, 0
  %unroll_iter = and i64 %wide.trip.count118, 4294967294
  %lcmp.mod179.not = icmp eq i64 %xtraiter178, 0
  br label %.lr.ph.us81

.lr.ph77.us:                                      ; preds = %scalar.ph153.prol.loopexit, %scalar.ph153, %middle.block152
  %127 = load ptr, ptr %120, align 8, !tbaa !5
  %128 = tail call i32 @fft_execute(ptr noundef %127)
  br i1 %126, label %._crit_edge78.us.unr-lcssa, label %.lr.ph77.us.new

.lr.ph77.us.new:                                  ; preds = %.lr.ph77.us, %.lr.ph77.us.new
  %indvars.iv120 = phi i64 [ %indvars.iv.next121.1, %.lr.ph77.us.new ], [ 0, %.lr.ph77.us ]
  %niter = phi i64 [ %niter.next.1, %.lr.ph77.us.new ], [ 0, %.lr.ph77.us ]
  %129 = getelementptr inbounds { float, float }, ptr %9, i64 %indvars.iv120
  %130 = load ptr, ptr %121, align 8, !tbaa !23
  %131 = trunc nuw i64 %indvars.iv120 to i32
  %132 = mul i32 %.fr90, %131
  %133 = add i32 %132, %.179.us
  %134 = zext i32 %133 to i64
  %135 = getelementptr inbounds { float, float }, ptr %130, i64 %134
  %136 = load <2 x float>, ptr %129, align 4
  store <2 x float> %136, ptr %135, align 4
  %indvars.iv.next121 = or disjoint i64 %indvars.iv120, 1
  %137 = getelementptr inbounds { float, float }, ptr %9, i64 %indvars.iv.next121
  %138 = load ptr, ptr %121, align 8, !tbaa !23
  %139 = trunc nuw i64 %indvars.iv.next121 to i32
  %140 = mul i32 %.fr90, %139
  %141 = add i32 %140, %.179.us
  %142 = zext i32 %141 to i64
  %143 = getelementptr inbounds { float, float }, ptr %138, i64 %142
  %144 = load <2 x float>, ptr %137, align 4
  store <2 x float> %144, ptr %143, align 4
  %indvars.iv.next121.1 = add nuw nsw i64 %indvars.iv120, 2
  %niter.next.1 = add i64 %niter, 2
  %niter.ncmp.1 = icmp eq i64 %niter.next.1, %unroll_iter
  br i1 %niter.ncmp.1, label %._crit_edge78.us.unr-lcssa, label %.lr.ph77.us.new, !llvm.loop !24

scalar.ph153:                                     ; preds = %scalar.ph153.prol.loopexit, %scalar.ph153
  %indvars.iv115 = phi i64 [ %indvars.iv.next116.3, %scalar.ph153 ], [ %indvars.iv115.unr, %scalar.ph153.prol.loopexit ]
  %145 = trunc nuw i64 %indvars.iv115 to i32
  %146 = add i32 %172, %145
  %147 = zext i32 %146 to i64
  %148 = getelementptr inbounds { float, float }, ptr %11, i64 %147
  %149 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv115
  %150 = load <2 x float>, ptr %148, align 4
  store <2 x float> %150, ptr %149, align 4
  %indvars.iv.next116 = add nuw nsw i64 %indvars.iv115, 1
  %151 = trunc nuw i64 %indvars.iv.next116 to i32
  %152 = add i32 %172, %151
  %153 = zext i32 %152 to i64
  %154 = getelementptr inbounds { float, float }, ptr %11, i64 %153
  %155 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next116
  %156 = load <2 x float>, ptr %154, align 4
  store <2 x float> %156, ptr %155, align 4
  %indvars.iv.next116.1 = add nuw nsw i64 %indvars.iv115, 2
  %157 = trunc nuw i64 %indvars.iv.next116.1 to i32
  %158 = add i32 %172, %157
  %159 = zext i32 %158 to i64
  %160 = getelementptr inbounds { float, float }, ptr %11, i64 %159
  %161 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next116.1
  %162 = load <2 x float>, ptr %160, align 4
  store <2 x float> %162, ptr %161, align 4
  %indvars.iv.next116.2 = add nuw nsw i64 %indvars.iv115, 3
  %163 = trunc nuw i64 %indvars.iv.next116.2 to i32
  %164 = add i32 %172, %163
  %165 = zext i32 %164 to i64
  %166 = getelementptr inbounds { float, float }, ptr %11, i64 %165
  %167 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next116.2
  %168 = load <2 x float>, ptr %166, align 4
  store <2 x float> %168, ptr %167, align 4
  %indvars.iv.next116.3 = add nuw nsw i64 %indvars.iv115, 4
  %exitcond119.not.3 = icmp eq i64 %indvars.iv.next116.3, %wide.trip.count118
  br i1 %exitcond119.not.3, label %.lr.ph77.us, label %scalar.ph153, !llvm.loop !25

.lr.ph.us81:                                      ; preds = %._crit_edge78.us, %.preheader.us.preheader
  %.179.us = phi i32 [ %205, %._crit_edge78.us ], [ 0, %.preheader.us.preheader ]
  %169 = mul i32 %.fr, %.179.us
  %170 = zext i32 %169 to i64
  %171 = shl nuw nsw i64 %170, 3
  %scevgep146 = getelementptr i8, ptr %11, i64 %171
  %scevgep148 = getelementptr i8, ptr %scevgep147, i64 %171
  %172 = mul i32 %.179.us, %.fr
  br i1 %min.iters.check154, label %scalar.ph153.preheader, label %vector.scevcheck143

scalar.ph153.preheader:                           ; preds = %middle.block152, %vector.memcheck144, %vector.scevcheck143, %.lr.ph.us81
  %indvars.iv115.ph = phi i64 [ 0, %vector.memcheck144 ], [ 0, %vector.scevcheck143 ], [ 0, %.lr.ph.us81 ], [ %n.vec157, %middle.block152 ]
  br i1 %lcmp.mod176.not, label %scalar.ph153.prol.loopexit, label %scalar.ph153.prol

scalar.ph153.prol:                                ; preds = %scalar.ph153.preheader, %scalar.ph153.prol
  %indvars.iv115.prol = phi i64 [ %indvars.iv.next116.prol, %scalar.ph153.prol ], [ %indvars.iv115.ph, %scalar.ph153.preheader ]
  %prol.iter177 = phi i64 [ %prol.iter177.next, %scalar.ph153.prol ], [ 0, %scalar.ph153.preheader ]
  %173 = trunc nuw i64 %indvars.iv115.prol to i32
  %174 = add i32 %172, %173
  %175 = zext i32 %174 to i64
  %176 = getelementptr inbounds { float, float }, ptr %11, i64 %175
  %177 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv115.prol
  %178 = load <2 x float>, ptr %176, align 4
  store <2 x float> %178, ptr %177, align 4
  %indvars.iv.next116.prol = add nuw nsw i64 %indvars.iv115.prol, 1
  %prol.iter177.next = add i64 %prol.iter177, 1
  %prol.iter177.cmp.not = icmp eq i64 %prol.iter177.next, %xtraiter175
  br i1 %prol.iter177.cmp.not, label %scalar.ph153.prol.loopexit, label %scalar.ph153.prol, !llvm.loop !26

scalar.ph153.prol.loopexit:                       ; preds = %scalar.ph153.prol, %scalar.ph153.preheader
  %indvars.iv115.unr = phi i64 [ %indvars.iv115.ph, %scalar.ph153.preheader ], [ %indvars.iv.next116.prol, %scalar.ph153.prol ]
  %179 = sub nsw i64 %indvars.iv115.ph, %wide.trip.count118
  %180 = icmp ugt i64 %179, -4
  br i1 %180, label %.lr.ph77.us, label %scalar.ph153

vector.scevcheck143:                              ; preds = %.lr.ph.us81
  %181 = mul i32 %.fr, %.179.us
  %182 = xor i32 %181, -1
  %183 = icmp ult i32 %182, %124
  %184 = or i1 %183, %125
  br i1 %184, label %scalar.ph153.preheader, label %vector.memcheck144

vector.memcheck144:                               ; preds = %vector.scevcheck143
  %bound0149 = icmp ult ptr %7, %scevgep148
  %bound1150 = icmp ult ptr %scevgep146, %scevgep145
  %found.conflict151 = and i1 %bound0149, %bound1150
  br i1 %found.conflict151, label %scalar.ph153.preheader, label %vector.body159

vector.body159:                                   ; preds = %vector.memcheck144, %vector.body159
  %index160 = phi i64 [ %index.next169, %vector.body159 ], [ 0, %vector.memcheck144 ]
  %185 = or disjoint i64 %index160, 2
  %186 = trunc i64 %index160 to i32
  %187 = or disjoint i32 %186, 2
  %188 = add i32 %172, %186
  %189 = add i32 %172, %187
  %190 = zext i32 %188 to i64
  %191 = zext i32 %189 to i64
  %192 = getelementptr inbounds { float, float }, ptr %11, i64 %190
  %193 = getelementptr inbounds { float, float }, ptr %11, i64 %191
  %wide.vec161 = load <4 x float>, ptr %192, align 4
  %wide.vec162 = load <4 x float>, ptr %193, align 4
  %194 = getelementptr inbounds { float, float }, ptr %7, i64 %index160
  %195 = getelementptr inbounds { float, float }, ptr %7, i64 %185
  store <4 x float> %wide.vec161, ptr %194, align 4
  store <4 x float> %wide.vec162, ptr %195, align 4
  %index.next169 = add nuw i64 %index160, 4
  %196 = icmp eq i64 %index.next169, %n.vec157
  br i1 %196, label %middle.block152, label %vector.body159, !llvm.loop !27

middle.block152:                                  ; preds = %vector.body159
  br i1 %cmp.n170, label %.lr.ph77.us, label %scalar.ph153.preheader

._crit_edge78.us.unr-lcssa:                       ; preds = %.lr.ph77.us.new, %.lr.ph77.us
  %indvars.iv120.unr = phi i64 [ 0, %.lr.ph77.us ], [ %indvars.iv.next121.1, %.lr.ph77.us.new ]
  br i1 %lcmp.mod179.not, label %._crit_edge78.us, label %._crit_edge78.us.epilog-lcssa

._crit_edge78.us.epilog-lcssa:                    ; preds = %._crit_edge78.us.unr-lcssa
  %197 = getelementptr inbounds { float, float }, ptr %9, i64 %indvars.iv120.unr
  %198 = load ptr, ptr %121, align 8, !tbaa !23
  %199 = trunc nuw i64 %indvars.iv120.unr to i32
  %200 = mul i32 %.fr90, %199
  %201 = add i32 %200, %.179.us
  %202 = zext i32 %201 to i64
  %203 = getelementptr inbounds { float, float }, ptr %198, i64 %202
  %204 = load <2 x float>, ptr %197, align 4
  store <2 x float> %204, ptr %203, align 4
  br label %._crit_edge78.us

._crit_edge78.us:                                 ; preds = %._crit_edge78.us.unr-lcssa, %._crit_edge78.us.epilog-lcssa
  %205 = add nuw i32 %.179.us, 1
  %exitcond125.not = icmp eq i32 %205, %.fr90
  br i1 %exitcond125.not, label %._crit_edge80, label %.lr.ph.us81, !llvm.loop !28

.preheader.preheader:                             ; preds = %.preheader.lr.ph, %.preheader.lr.ph.thread
  %206 = phi ptr [ %119, %.preheader.lr.ph.thread ], [ %120, %.preheader.lr.ph ]
  br label %.preheader

.preheader:                                       ; preds = %.preheader.preheader, %.preheader
  %.179 = phi i32 [ %209, %.preheader ], [ 0, %.preheader.preheader ]
  %207 = load ptr, ptr %206, align 8, !tbaa !5
  %208 = tail call i32 @fft_execute(ptr noundef %207)
  %209 = add nuw i32 %.179, 1
  %exitcond130.not = icmp eq i32 %209, %.fr90
  br i1 %exitcond130.not, label %._crit_edge80, label %.preheader, !llvm.loop !28

._crit_edge80:                                    ; preds = %._crit_edge78.us, %.preheader, %.preheader61.thread, %.preheader61
  ret i32 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) #2

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


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