; LLVM IR from ubaldot/defrecs :: stm32f4x/ADC_Readings/Drivers/CMSIS/DSP/Source/QuaternionMathFunctions (f32)

; 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 memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

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

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

; 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
define dso_local void @arm_quaternion_normalize_f32(ptr noundef %0, ptr noundef %1, i32 noundef %2) #3 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca float, align 4
  %8 = alloca i32, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  store i32 %2, ptr %6, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #4
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %9

9:                                                ; preds = %136, %3
  %10 = load i32, ptr %8, align 4, !tbaa !9
  %11 = load i32, ptr %6, align 4, !tbaa !9
  %12 = icmp ult i32 %10, %11
  br i1 %12, label %13, label %139

13:                                               ; preds = %9
  %14 = load ptr, ptr %4, align 8, !tbaa !5
  %15 = load i32, ptr %8, align 4, !tbaa !9
  %16 = mul i32 4, %15
  %17 = add i32 %16, 0
  %18 = zext i32 %17 to i64
  %19 = getelementptr inbounds float, ptr %14, i64 %18
  %20 = load float, ptr %19, align 4, !tbaa !11
  %21 = load ptr, ptr %4, align 8, !tbaa !5
  %22 = load i32, ptr %8, align 4, !tbaa !9
  %23 = mul i32 4, %22
  %24 = add i32 %23, 0
  %25 = zext i32 %24 to i64
  %26 = getelementptr inbounds float, ptr %21, i64 %25
  %27 = load float, ptr %26, align 4, !tbaa !11
  %28 = load ptr, ptr %4, align 8, !tbaa !5
  %29 = load i32, ptr %8, align 4, !tbaa !9
  %30 = mul i32 4, %29
  %31 = add i32 %30, 1
  %32 = zext i32 %31 to i64
  %33 = getelementptr inbounds float, ptr %28, i64 %32
  %34 = load float, ptr %33, align 4, !tbaa !11
  %35 = load ptr, ptr %4, align 8, !tbaa !5
  %36 = load i32, ptr %8, align 4, !tbaa !9
  %37 = mul i32 4, %36
  %38 = add i32 %37, 1
  %39 = zext i32 %38 to i64
  %40 = getelementptr inbounds float, ptr %35, i64 %39
  %41 = load float, ptr %40, align 4, !tbaa !11
  %42 = fmul float %34, %41
  %43 = call float @llvm.fmuladd.f32(float %20, float %27, float %42)
  %44 = load ptr, ptr %4, align 8, !tbaa !5
  %45 = load i32, ptr %8, align 4, !tbaa !9
  %46 = mul i32 4, %45
  %47 = add i32 %46, 2
  %48 = zext i32 %47 to i64
  %49 = getelementptr inbounds float, ptr %44, i64 %48
  %50 = load float, ptr %49, align 4, !tbaa !11
  %51 = load ptr, ptr %4, align 8, !tbaa !5
  %52 = load i32, ptr %8, align 4, !tbaa !9
  %53 = mul i32 4, %52
  %54 = add i32 %53, 2
  %55 = zext i32 %54 to i64
  %56 = getelementptr inbounds float, ptr %51, i64 %55
  %57 = load float, ptr %56, align 4, !tbaa !11
  %58 = call float @llvm.fmuladd.f32(float %50, float %57, float %43)
  %59 = load ptr, ptr %4, align 8, !tbaa !5
  %60 = load i32, ptr %8, align 4, !tbaa !9
  %61 = mul i32 4, %60
  %62 = add i32 %61, 3
  %63 = zext i32 %62 to i64
  %64 = getelementptr inbounds float, ptr %59, i64 %63
  %65 = load float, ptr %64, align 4, !tbaa !11
  %66 = load ptr, ptr %4, align 8, !tbaa !5
  %67 = load i32, ptr %8, align 4, !tbaa !9
  %68 = mul i32 4, %67
  %69 = add i32 %68, 3
  %70 = zext i32 %69 to i64
  %71 = getelementptr inbounds float, ptr %66, i64 %70
  %72 = load float, ptr %71, align 4, !tbaa !11
  %73 = call float @llvm.fmuladd.f32(float %65, float %72, float %58)
  store float %73, ptr %7, align 4, !tbaa !11
  %74 = load float, ptr %7, align 4, !tbaa !11
  %75 = call float @sqrtf(float noundef %74) #4
  store float %75, ptr %7, align 4, !tbaa !11
  %76 = load ptr, ptr %4, align 8, !tbaa !5
  %77 = load i32, ptr %8, align 4, !tbaa !9
  %78 = mul i32 4, %77
  %79 = add i32 %78, 0
  %80 = zext i32 %79 to i64
  %81 = getelementptr inbounds float, ptr %76, i64 %80
  %82 = load float, ptr %81, align 4, !tbaa !11
  %83 = load float, ptr %7, align 4, !tbaa !11
  %84 = fdiv float %82, %83
  %85 = load ptr, ptr %5, align 8, !tbaa !5
  %86 = load i32, ptr %8, align 4, !tbaa !9
  %87 = mul i32 4, %86
  %88 = add i32 %87, 0
  %89 = zext i32 %88 to i64
  %90 = getelementptr inbounds float, ptr %85, i64 %89
  store float %84, ptr %90, align 4, !tbaa !11
  %91 = load ptr, ptr %4, align 8, !tbaa !5
  %92 = load i32, ptr %8, align 4, !tbaa !9
  %93 = mul i32 4, %92
  %94 = add i32 %93, 1
  %95 = zext i32 %94 to i64
  %96 = getelementptr inbounds float, ptr %91, i64 %95
  %97 = load float, ptr %96, align 4, !tbaa !11
  %98 = load float, ptr %7, align 4, !tbaa !11
  %99 = fdiv float %97, %98
  %100 = load ptr, ptr %5, align 8, !tbaa !5
  %101 = load i32, ptr %8, align 4, !tbaa !9
  %102 = mul i32 4, %101
  %103 = add i32 %102, 1
  %104 = zext i32 %103 to i64
  %105 = getelementptr inbounds float, ptr %100, i64 %104
  store float %99, ptr %105, align 4, !tbaa !11
  %106 = load ptr, ptr %4, align 8, !tbaa !5
  %107 = load i32, ptr %8, align 4, !tbaa !9
  %108 = mul i32 4, %107
  %109 = add i32 %108, 2
  %110 = zext i32 %109 to i64
  %111 = getelementptr inbounds float, ptr %106, i64 %110
  %112 = load float, ptr %111, align 4, !tbaa !11
  %113 = load float, ptr %7, align 4, !tbaa !11
  %114 = fdiv float %112, %113
  %115 = load ptr, ptr %5, align 8, !tbaa !5
  %116 = load i32, ptr %8, align 4, !tbaa !9
  %117 = mul i32 4, %116
  %118 = add i32 %117, 2
  %119 = zext i32 %118 to i64
  %120 = getelementptr inbounds float, ptr %115, i64 %119
  store float %114, ptr %120, align 4, !tbaa !11
  %121 = load ptr, ptr %4, align 8, !tbaa !5
  %122 = load i32, ptr %8, align 4, !tbaa !9
  %123 = mul i32 4, %122
  %124 = add i32 %123, 3
  %125 = zext i32 %124 to i64
  %126 = getelementptr inbounds float, ptr %121, i64 %125
  %127 = load float, ptr %126, align 4, !tbaa !11
  %128 = load float, ptr %7, align 4, !tbaa !11
  %129 = fdiv float %127, %128
  %130 = load ptr, ptr %5, align 8, !tbaa !5
  %131 = load i32, ptr %8, align 4, !tbaa !9
  %132 = mul i32 4, %131
  %133 = add i32 %132, 3
  %134 = zext i32 %133 to i64
  %135 = getelementptr inbounds float, ptr %130, i64 %134
  store float %129, ptr %135, align 4, !tbaa !11
  br label %136

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

139:                                              ; preds = %9
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #4
  ret void
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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 = { 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 = !{!"float", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}


; 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 speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #0

; Function Attrs: nofree norecurse nosync nounwind memory(argmem: readwrite) uwtable
define dso_local void @arm_quaternion_normalize_f32(ptr nocapture noundef readonly %0, ptr nocapture noundef writeonly %1, i32 noundef %2) local_unnamed_addr #1 {
  %.not = icmp eq i32 %2, 0
  br i1 %.not, label %._crit_edge, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %3
  %wide.trip.count = zext i32 %2 to i64
  %min.iters.check = icmp ult i32 %2, 4
  br i1 %min.iters.check, label %.lr.ph.preheader57, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %.lr.ph.preheader
  %4 = add nsw i64 %wide.trip.count, -1
  %5 = icmp ugt i64 %4, 4294967295
  %scevgep = getelementptr i8, ptr %1, i64 8
  %mul.result = shl nsw i64 %4, 4
  %6 = getelementptr i8, ptr %scevgep, i64 %mul.result
  %7 = icmp ult ptr %6, %scevgep
  %scevgep41 = getelementptr i8, ptr %1, i64 12
  %mul.result43 = shl nsw i64 %4, 4
  %8 = getelementptr i8, ptr %scevgep41, i64 %mul.result43
  %9 = icmp ult ptr %8, %scevgep41
  %scevgep45 = getelementptr i8, ptr %1, i64 4
  %mul.result47 = shl nsw i64 %4, 4
  %10 = getelementptr i8, ptr %scevgep45, i64 %mul.result47
  %11 = icmp ult ptr %10, %scevgep45
  %mul.result50 = shl nsw i64 %4, 4
  %12 = getelementptr i8, ptr %1, i64 %mul.result50
  %13 = icmp ult ptr %12, %1
  %14 = or i1 %7, %5
  %15 = or i1 %9, %14
  %16 = or i1 %11, %15
  %17 = or i1 %13, %16
  br i1 %17, label %.lr.ph.preheader57, label %vector.memcheck

vector.memcheck:                                  ; preds = %vector.scevcheck
  %18 = shl nuw nsw i64 %wide.trip.count, 4
  %scevgep52 = getelementptr i8, ptr %1, i64 %18
  %scevgep53 = getelementptr i8, ptr %0, i64 %18
  %bound0 = icmp ugt ptr %scevgep53, %1
  %bound1 = icmp ugt ptr %scevgep52, %0
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph.preheader57, label %vector.ph

vector.ph:                                        ; preds = %vector.memcheck
  %n.vec = and i64 %wide.trip.count, 4294967292
  %invariant.gep = getelementptr i8, ptr %1, i64 -12
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %19 = trunc i64 %index to i32
  %20 = shl i32 %19, 2
  %21 = shl i32 %19, 2
  %22 = shl i32 %19, 2
  %23 = shl i32 %19, 2
  %24 = zext i32 %20 to i64
  %25 = getelementptr inbounds float, ptr %0, i64 %24
  %wide.vec = load <16 x float>, ptr %25, align 4, !tbaa !5
  %strided.vec = shufflevector <16 x float> %wide.vec, <16 x float> poison, <4 x i32> <i32 0, i32 4, i32 8, i32 12>
  %strided.vec54 = shufflevector <16 x float> %wide.vec, <16 x float> poison, <4 x i32> <i32 1, i32 5, i32 9, i32 13>
  %strided.vec55 = shufflevector <16 x float> %wide.vec, <16 x float> poison, <4 x i32> <i32 2, i32 6, i32 10, i32 14>
  %strided.vec56 = shufflevector <16 x float> %wide.vec, <16 x float> poison, <4 x i32> <i32 3, i32 7, i32 11, i32 15>
  %26 = or disjoint i32 %20, 1
  %27 = or disjoint i32 %21, 5
  %28 = or disjoint i32 %22, 9
  %29 = or disjoint i32 %23, 13
  %30 = zext i32 %26 to i64
  %31 = zext i32 %27 to i64
  %32 = zext i32 %28 to i64
  %33 = zext i32 %29 to i64
  %34 = getelementptr inbounds float, ptr %0, i64 %30
  %35 = getelementptr inbounds float, ptr %0, i64 %31
  %36 = getelementptr inbounds float, ptr %0, i64 %32
  %37 = getelementptr inbounds float, ptr %0, i64 %33
  %38 = load float, ptr %34, align 4, !tbaa !5, !alias.scope !9
  %39 = load float, ptr %35, align 4, !tbaa !5, !alias.scope !9
  %40 = load float, ptr %36, align 4, !tbaa !5, !alias.scope !9
  %41 = load float, ptr %37, align 4, !tbaa !5, !alias.scope !9
  %42 = insertelement <4 x float> poison, float %38, i64 0
  %43 = insertelement <4 x float> %42, float %39, i64 1
  %44 = insertelement <4 x float> %43, float %40, i64 2
  %45 = insertelement <4 x float> %44, float %41, i64 3
  %46 = fmul <4 x float> %45, %45
  %47 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %strided.vec, <4 x float> %strided.vec, <4 x float> %46)
  %48 = or disjoint i32 %20, 2
  %49 = or disjoint i32 %21, 6
  %50 = or disjoint i32 %22, 10
  %51 = or disjoint i32 %23, 14
  %52 = zext i32 %48 to i64
  %53 = zext i32 %49 to i64
  %54 = zext i32 %50 to i64
  %55 = zext i32 %51 to i64
  %56 = getelementptr inbounds float, ptr %0, i64 %52
  %57 = getelementptr inbounds float, ptr %0, i64 %53
  %58 = getelementptr inbounds float, ptr %0, i64 %54
  %59 = getelementptr inbounds float, ptr %0, i64 %55
  %60 = load float, ptr %56, align 4, !tbaa !5, !alias.scope !9
  %61 = load float, ptr %57, align 4, !tbaa !5, !alias.scope !9
  %62 = load float, ptr %58, align 4, !tbaa !5, !alias.scope !9
  %63 = load float, ptr %59, align 4, !tbaa !5, !alias.scope !9
  %64 = insertelement <4 x float> poison, float %60, i64 0
  %65 = insertelement <4 x float> %64, float %61, i64 1
  %66 = insertelement <4 x float> %65, float %62, i64 2
  %67 = insertelement <4 x float> %66, float %63, i64 3
  %68 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %67, <4 x float> %67, <4 x float> %47)
  %69 = or disjoint i32 %20, 3
  %70 = or disjoint i32 %21, 7
  %71 = or disjoint i32 %22, 11
  %72 = or disjoint i32 %23, 15
  %73 = zext i32 %69 to i64
  %74 = zext i32 %70 to i64
  %75 = zext i32 %71 to i64
  %76 = zext i32 %72 to i64
  %77 = getelementptr inbounds float, ptr %0, i64 %73
  %78 = getelementptr inbounds float, ptr %0, i64 %74
  %79 = getelementptr inbounds float, ptr %0, i64 %75
  %80 = getelementptr inbounds float, ptr %0, i64 %76
  %81 = load float, ptr %77, align 4, !tbaa !5, !alias.scope !9
  %82 = load float, ptr %78, align 4, !tbaa !5, !alias.scope !9
  %83 = load float, ptr %79, align 4, !tbaa !5, !alias.scope !9
  %84 = load float, ptr %80, align 4, !tbaa !5, !alias.scope !9
  %85 = insertelement <4 x float> poison, float %81, i64 0
  %86 = insertelement <4 x float> %85, float %82, i64 1
  %87 = insertelement <4 x float> %86, float %83, i64 2
  %88 = insertelement <4 x float> %87, float %84, i64 3
  %89 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %88, <4 x float> %88, <4 x float> %68)
  %90 = tail call <4 x float> @llvm.sqrt.v4f32(<4 x float> %89)
  %91 = fdiv <4 x float> %strided.vec, %90
  %92 = fdiv <4 x float> %strided.vec54, %90
  %93 = fdiv <4 x float> %strided.vec55, %90
  %94 = fdiv <4 x float> %strided.vec56, %90
  %gep = getelementptr float, ptr %invariant.gep, i64 %73
  %95 = shufflevector <4 x float> %91, <4 x float> %92, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %96 = shufflevector <4 x float> %93, <4 x float> %94, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec = shufflevector <8 x float> %95, <8 x float> %96, <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.vec, ptr %gep, align 4, !tbaa !5
  %index.next = add nuw i64 %index, 4
  %97 = icmp eq i64 %index.next, %n.vec
  br i1 %97, label %middle.block, label %vector.body, !llvm.loop !12

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %._crit_edge, label %.lr.ph.preheader57

.lr.ph.preheader57:                               ; preds = %middle.block, %vector.memcheck, %vector.scevcheck, %.lr.ph.preheader
  %indvars.iv.ph = phi i64 [ 0, %vector.memcheck ], [ 0, %vector.scevcheck ], [ 0, %.lr.ph.preheader ], [ %n.vec, %middle.block ]
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader57, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %indvars.iv.ph, %.lr.ph.preheader57 ]
  %98 = trunc nuw i64 %indvars.iv to i32
  %99 = shl i32 %98, 2
  %100 = zext i32 %99 to i64
  %101 = getelementptr inbounds float, ptr %0, i64 %100
  %102 = load float, ptr %101, align 4, !tbaa !5
  %103 = or disjoint i32 %99, 1
  %104 = zext i32 %103 to i64
  %105 = getelementptr inbounds float, ptr %0, i64 %104
  %106 = load float, ptr %105, align 4, !tbaa !5
  %107 = fmul float %106, %106
  %108 = tail call float @llvm.fmuladd.f32(float %102, float %102, float %107)
  %109 = or disjoint i32 %99, 2
  %110 = zext i32 %109 to i64
  %111 = getelementptr inbounds float, ptr %0, i64 %110
  %112 = load float, ptr %111, align 4, !tbaa !5
  %113 = tail call float @llvm.fmuladd.f32(float %112, float %112, float %108)
  %114 = or disjoint i32 %99, 3
  %115 = zext i32 %114 to i64
  %116 = getelementptr inbounds float, ptr %0, i64 %115
  %117 = load float, ptr %116, align 4, !tbaa !5
  %118 = tail call float @llvm.fmuladd.f32(float %117, float %117, float %113)
  %sqrt = tail call float @llvm.sqrt.f32(float %118)
  %119 = fdiv float %102, %sqrt
  %120 = getelementptr inbounds float, ptr %1, i64 %100
  store float %119, ptr %120, align 4, !tbaa !5
  %121 = load float, ptr %105, align 4, !tbaa !5
  %122 = fdiv float %121, %sqrt
  %123 = getelementptr inbounds float, ptr %1, i64 %104
  store float %122, ptr %123, align 4, !tbaa !5
  %124 = load float, ptr %111, align 4, !tbaa !5
  %125 = fdiv float %124, %sqrt
  %126 = getelementptr inbounds float, ptr %1, i64 %110
  store float %125, ptr %126, align 4, !tbaa !5
  %127 = load float, ptr %116, align 4, !tbaa !5
  %128 = fdiv float %127, %sqrt
  %129 = getelementptr inbounds float, ptr %1, i64 %115
  store float %128, ptr %129, align 4, !tbaa !5
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge, label %.lr.ph, !llvm.loop !16

._crit_edge:                                      ; preds = %.lr.ph, %middle.block, %3
  ret void
}

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #2

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) #2

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

!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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10}
!10 = distinct !{!10, !11}
!11 = distinct !{!11, !"LVerDomain"}
!12 = distinct !{!12, !13, !14, !15}
!13 = !{!"llvm.loop.mustprogress"}
!14 = !{!"llvm.loop.isvectorized", i32 1}
!15 = !{!"llvm.loop.unroll.runtime.disable"}
!16 = distinct !{!16, !13, !14}


; Effective O3 passes: AggressiveInstCombinePass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass