; LLVM IR from bohanwang/libpgo :: src/core/solidDeformationModel (elasticModelVolumeMaterial)

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

%"class.pgo::SolidDeformationModel::ElasticModelVolumeMaterial" = type { %"class.pgo::SolidDeformationModel::ElasticModel.base", double }
%"class.pgo::SolidDeformationModel::ElasticModel.base" = type <{ ptr, i8 }>

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

declare noundef double @_ZN3pgo21NonlinearOptimization11Determinant4Dim33detEPKd(ptr noundef) #1

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

declare void @_ZN3pgo21NonlinearOptimization11Determinant4Dim38ddetA_dAEPKdPd(ptr noundef, ptr noundef) #1

; Function Attrs: mustprogress uwtable
define dso_local void @_ZNK3pgo21SolidDeformationModel26ElasticModelVolumeMaterial12compute_dPdFEPKdS3_S3_S3_S3_Pd(ptr noundef nonnull align 8 dereferenceable(24) %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6) unnamed_addr #2 align 2 {
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca double, align 8
  %16 = alloca [9 x double], align 16
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  store ptr %0, ptr %8, align 8, !tbaa !5
  store ptr %1, ptr %9, align 8, !tbaa !5
  store ptr %2, ptr %10, align 8, !tbaa !5
  store ptr %3, ptr %11, align 8, !tbaa !5
  store ptr %4, ptr %12, align 8, !tbaa !5
  store ptr %5, ptr %13, align 8, !tbaa !5
  store ptr %6, ptr %14, align 8, !tbaa !5
  %22 = load ptr, ptr %8, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #4
  %23 = load ptr, ptr %10, align 8, !tbaa !5
  %24 = call noundef double @_ZN3pgo21NonlinearOptimization11Determinant4Dim33detEPKd(ptr noundef %23)
  store double %24, ptr %15, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 72, ptr %16) #4
  %25 = load ptr, ptr %10, align 8, !tbaa !5
  %26 = getelementptr inbounds [9 x double], ptr %16, i64 0, i64 0
  call void @_ZN3pgo21NonlinearOptimization11Determinant4Dim38ddetA_dAEPKdPd(ptr noundef %25, ptr noundef %26)
  %27 = load ptr, ptr %10, align 8, !tbaa !5
  %28 = load ptr, ptr %14, align 8, !tbaa !5
  call void @_ZN3pgo21NonlinearOptimization11Determinant4Dim310d2detA_dA2EPKdPd(ptr noundef %27, ptr noundef %28)
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  store i32 0, ptr %17, align 4, !tbaa !11
  br label %29

29:                                               ; preds = %42, %7
  %30 = load i32, ptr %17, align 4, !tbaa !11
  %31 = icmp slt i32 %30, 81
  br i1 %31, label %33, label %32

32:                                               ; preds = %29
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  br label %45

33:                                               ; preds = %29
  %34 = load double, ptr %15, align 8, !tbaa !9
  %35 = fsub double %34, 1.000000e+00
  %36 = load ptr, ptr %14, align 8, !tbaa !5
  %37 = load i32, ptr %17, align 4, !tbaa !11
  %38 = sext i32 %37 to i64
  %39 = getelementptr inbounds double, ptr %36, i64 %38
  %40 = load double, ptr %39, align 8, !tbaa !9
  %41 = fmul double %40, %35
  store double %41, ptr %39, align 8, !tbaa !9
  br label %42

42:                                               ; preds = %33
  %43 = load i32, ptr %17, align 4, !tbaa !11
  %44 = add nsw i32 %43, 1
  store i32 %44, ptr %17, align 4, !tbaa !11
  br label %29, !llvm.loop !13

45:                                               ; preds = %32
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #4
  store i32 0, ptr %18, align 4, !tbaa !11
  br label %46

46:                                               ; preds = %77, %45
  %47 = load i32, ptr %18, align 4, !tbaa !11
  %48 = icmp slt i32 %47, 9
  br i1 %48, label %50, label %49

49:                                               ; preds = %46
  store i32 5, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  br label %80

50:                                               ; preds = %46
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #4
  store i32 0, ptr %20, align 4, !tbaa !11
  br label %51

51:                                               ; preds = %73, %50
  %52 = load i32, ptr %20, align 4, !tbaa !11
  %53 = icmp slt i32 %52, 9
  br i1 %53, label %55, label %54

54:                                               ; preds = %51
  store i32 8, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #4
  br label %76

55:                                               ; preds = %51
  %56 = load i32, ptr %18, align 4, !tbaa !11
  %57 = sext i32 %56 to i64
  %58 = getelementptr inbounds [9 x double], ptr %16, i64 0, i64 %57
  %59 = load double, ptr %58, align 8, !tbaa !9
  %60 = load i32, ptr %20, align 4, !tbaa !11
  %61 = sext i32 %60 to i64
  %62 = getelementptr inbounds [9 x double], ptr %16, i64 0, i64 %61
  %63 = load double, ptr %62, align 8, !tbaa !9
  %64 = load ptr, ptr %14, align 8, !tbaa !5
  %65 = load i32, ptr %18, align 4, !tbaa !11
  %66 = mul nsw i32 %65, 9
  %67 = load i32, ptr %20, align 4, !tbaa !11
  %68 = add nsw i32 %66, %67
  %69 = sext i32 %68 to i64
  %70 = getelementptr inbounds double, ptr %64, i64 %69
  %71 = load double, ptr %70, align 8, !tbaa !9
  %72 = call double @llvm.fmuladd.f64(double %59, double %63, double %71)
  store double %72, ptr %70, align 8, !tbaa !9
  br label %73

73:                                               ; preds = %55
  %74 = load i32, ptr %20, align 4, !tbaa !11
  %75 = add nsw i32 %74, 1
  store i32 %75, ptr %20, align 4, !tbaa !11
  br label %51, !llvm.loop !15

76:                                               ; preds = %54
  br label %77

77:                                               ; preds = %76
  %78 = load i32, ptr %18, align 4, !tbaa !11
  %79 = add nsw i32 %78, 1
  store i32 %79, ptr %18, align 4, !tbaa !11
  br label %46, !llvm.loop !16

80:                                               ; preds = %49
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #4
  store i32 0, ptr %21, align 4, !tbaa !11
  br label %81

81:                                               ; preds = %94, %80
  %82 = load i32, ptr %21, align 4, !tbaa !11
  %83 = icmp slt i32 %82, 81
  br i1 %83, label %85, label %84

84:                                               ; preds = %81
  store i32 11, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #4
  br label %97

85:                                               ; preds = %81
  %86 = getelementptr inbounds %"class.pgo::SolidDeformationModel::ElasticModelVolumeMaterial", ptr %22, i32 0, i32 1
  %87 = load double, ptr %86, align 8, !tbaa !17
  %88 = load ptr, ptr %14, align 8, !tbaa !5
  %89 = load i32, ptr %21, align 4, !tbaa !11
  %90 = sext i32 %89 to i64
  %91 = getelementptr inbounds double, ptr %88, i64 %90
  %92 = load double, ptr %91, align 8, !tbaa !9
  %93 = fmul double %92, %87
  store double %93, ptr %91, align 8, !tbaa !9
  br label %94

94:                                               ; preds = %85
  %95 = load i32, ptr %21, align 4, !tbaa !11
  %96 = add nsw i32 %95, 1
  store i32 %96, ptr %21, align 4, !tbaa !11
  br label %81, !llvm.loop !21

97:                                               ; preds = %84
  call void @llvm.lifetime.end.p0(i64 72, ptr %16) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #4
  ret void
}

declare void @_ZN3pgo21NonlinearOptimization11Determinant4Dim310d2detA_dA2EPKdPd(ptr noundef, ptr noundef) #1

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #3

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 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 #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}
!17 = !{!18, !10, i64 16}
!18 = !{!"_ZTSN3pgo21SolidDeformationModel26ElasticModelVolumeMaterialE", !19, i64 0, !10, i64 16}
!19 = !{!"_ZTSN3pgo21SolidDeformationModel12ElasticModelE", !20, i64 8}
!20 = !{!"bool", !7, i64 0}
!21 = distinct !{!21, !14}


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

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

declare noundef double @_ZN3pgo21NonlinearOptimization11Determinant4Dim33detEPKd(ptr noundef) local_unnamed_addr #1

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

declare void @_ZN3pgo21NonlinearOptimization11Determinant4Dim38ddetA_dAEPKdPd(ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: mustprogress uwtable
define dso_local void @_ZNK3pgo21SolidDeformationModel26ElasticModelVolumeMaterial12compute_dPdFEPKdS3_S3_S3_S3_Pd(ptr nocapture noundef nonnull readonly align 8 dereferenceable(24) %0, ptr nocapture noundef readnone %1, ptr noundef %2, ptr nocapture noundef readnone %3, ptr nocapture noundef readnone %4, ptr nocapture noundef readnone %5, ptr noundef %6) unnamed_addr #2 align 2 {
vector.ph:
  %7 = alloca [9 x double], align 16
  %8 = tail call noundef double @_ZN3pgo21NonlinearOptimization11Determinant4Dim33detEPKd(ptr noundef %2)
  call void @llvm.lifetime.start.p0(i64 72, ptr nonnull %7) #5
  call void @_ZN3pgo21NonlinearOptimization11Determinant4Dim38ddetA_dAEPKdPd(ptr noundef %2, ptr noundef nonnull %7)
  call void @_ZN3pgo21NonlinearOptimization11Determinant4Dim310d2detA_dA2EPKdPd(ptr noundef %2, ptr noundef %6)
  %9 = fadd double %8, -1.000000e+00
  %broadcast.splatinsert = insertelement <2 x double> poison, double %9, i64 0
  %broadcast.splat = shufflevector <2 x double> %broadcast.splatinsert, <2 x double> poison, <2 x i32> zeroinitializer
  %10 = getelementptr inbounds i8, ptr %6, i64 16
  %wide.load = load <2 x double>, ptr %6, align 8, !tbaa !5
  %wide.load73 = load <2 x double>, ptr %10, align 8, !tbaa !5
  %11 = fmul <2 x double> %broadcast.splat, %wide.load
  %12 = fmul <2 x double> %broadcast.splat, %wide.load73
  store <2 x double> %11, ptr %6, align 8, !tbaa !5
  store <2 x double> %12, ptr %10, align 8, !tbaa !5
  %13 = getelementptr inbounds i8, ptr %6, i64 32
  %14 = getelementptr inbounds i8, ptr %6, i64 48
  %wide.load.1 = load <2 x double>, ptr %13, align 8, !tbaa !5
  %wide.load73.1 = load <2 x double>, ptr %14, align 8, !tbaa !5
  %15 = fmul <2 x double> %broadcast.splat, %wide.load.1
  %16 = fmul <2 x double> %broadcast.splat, %wide.load73.1
  store <2 x double> %15, ptr %13, align 8, !tbaa !5
  store <2 x double> %16, ptr %14, align 8, !tbaa !5
  %17 = getelementptr inbounds i8, ptr %6, i64 64
  %18 = getelementptr inbounds i8, ptr %6, i64 80
  %wide.load.2 = load <2 x double>, ptr %17, align 8, !tbaa !5
  %wide.load73.2 = load <2 x double>, ptr %18, align 8, !tbaa !5
  %19 = fmul <2 x double> %broadcast.splat, %wide.load.2
  %20 = fmul <2 x double> %broadcast.splat, %wide.load73.2
  store <2 x double> %19, ptr %17, align 8, !tbaa !5
  store <2 x double> %20, ptr %18, align 8, !tbaa !5
  %21 = getelementptr inbounds i8, ptr %6, i64 96
  %22 = getelementptr inbounds i8, ptr %6, i64 112
  %wide.load.3 = load <2 x double>, ptr %21, align 8, !tbaa !5
  %wide.load73.3 = load <2 x double>, ptr %22, align 8, !tbaa !5
  %23 = fmul <2 x double> %broadcast.splat, %wide.load.3
  %24 = fmul <2 x double> %broadcast.splat, %wide.load73.3
  store <2 x double> %23, ptr %21, align 8, !tbaa !5
  store <2 x double> %24, ptr %22, align 8, !tbaa !5
  %25 = getelementptr inbounds i8, ptr %6, i64 128
  %26 = getelementptr inbounds i8, ptr %6, i64 144
  %wide.load.4 = load <2 x double>, ptr %25, align 8, !tbaa !5
  %wide.load73.4 = load <2 x double>, ptr %26, align 8, !tbaa !5
  %27 = fmul <2 x double> %broadcast.splat, %wide.load.4
  %28 = fmul <2 x double> %broadcast.splat, %wide.load73.4
  store <2 x double> %27, ptr %25, align 8, !tbaa !5
  store <2 x double> %28, ptr %26, align 8, !tbaa !5
  %29 = getelementptr inbounds i8, ptr %6, i64 160
  %30 = getelementptr inbounds i8, ptr %6, i64 176
  %wide.load.5 = load <2 x double>, ptr %29, align 8, !tbaa !5
  %wide.load73.5 = load <2 x double>, ptr %30, align 8, !tbaa !5
  %31 = fmul <2 x double> %broadcast.splat, %wide.load.5
  %32 = fmul <2 x double> %broadcast.splat, %wide.load73.5
  store <2 x double> %31, ptr %29, align 8, !tbaa !5
  store <2 x double> %32, ptr %30, align 8, !tbaa !5
  %33 = getelementptr inbounds i8, ptr %6, i64 192
  %34 = getelementptr inbounds i8, ptr %6, i64 208
  %wide.load.6 = load <2 x double>, ptr %33, align 8, !tbaa !5
  %wide.load73.6 = load <2 x double>, ptr %34, align 8, !tbaa !5
  %35 = fmul <2 x double> %broadcast.splat, %wide.load.6
  %36 = fmul <2 x double> %broadcast.splat, %wide.load73.6
  store <2 x double> %35, ptr %33, align 8, !tbaa !5
  store <2 x double> %36, ptr %34, align 8, !tbaa !5
  %37 = getelementptr inbounds i8, ptr %6, i64 224
  %38 = getelementptr inbounds i8, ptr %6, i64 240
  %wide.load.7 = load <2 x double>, ptr %37, align 8, !tbaa !5
  %wide.load73.7 = load <2 x double>, ptr %38, align 8, !tbaa !5
  %39 = fmul <2 x double> %broadcast.splat, %wide.load.7
  %40 = fmul <2 x double> %broadcast.splat, %wide.load73.7
  store <2 x double> %39, ptr %37, align 8, !tbaa !5
  store <2 x double> %40, ptr %38, align 8, !tbaa !5
  %41 = getelementptr inbounds i8, ptr %6, i64 256
  %42 = getelementptr inbounds i8, ptr %6, i64 272
  %wide.load.8 = load <2 x double>, ptr %41, align 8, !tbaa !5
  %wide.load73.8 = load <2 x double>, ptr %42, align 8, !tbaa !5
  %43 = fmul <2 x double> %broadcast.splat, %wide.load.8
  %44 = fmul <2 x double> %broadcast.splat, %wide.load73.8
  store <2 x double> %43, ptr %41, align 8, !tbaa !5
  store <2 x double> %44, ptr %42, align 8, !tbaa !5
  %45 = getelementptr inbounds i8, ptr %6, i64 288
  %46 = getelementptr inbounds i8, ptr %6, i64 304
  %wide.load.9 = load <2 x double>, ptr %45, align 8, !tbaa !5
  %wide.load73.9 = load <2 x double>, ptr %46, align 8, !tbaa !5
  %47 = fmul <2 x double> %broadcast.splat, %wide.load.9
  %48 = fmul <2 x double> %broadcast.splat, %wide.load73.9
  store <2 x double> %47, ptr %45, align 8, !tbaa !5
  store <2 x double> %48, ptr %46, align 8, !tbaa !5
  %49 = getelementptr inbounds i8, ptr %6, i64 320
  %50 = getelementptr inbounds i8, ptr %6, i64 336
  %wide.load.10 = load <2 x double>, ptr %49, align 8, !tbaa !5
  %wide.load73.10 = load <2 x double>, ptr %50, align 8, !tbaa !5
  %51 = fmul <2 x double> %broadcast.splat, %wide.load.10
  %52 = fmul <2 x double> %broadcast.splat, %wide.load73.10
  store <2 x double> %51, ptr %49, align 8, !tbaa !5
  store <2 x double> %52, ptr %50, align 8, !tbaa !5
  %53 = getelementptr inbounds i8, ptr %6, i64 352
  %54 = getelementptr inbounds i8, ptr %6, i64 368
  %wide.load.11 = load <2 x double>, ptr %53, align 8, !tbaa !5
  %wide.load73.11 = load <2 x double>, ptr %54, align 8, !tbaa !5
  %55 = fmul <2 x double> %broadcast.splat, %wide.load.11
  %56 = fmul <2 x double> %broadcast.splat, %wide.load73.11
  store <2 x double> %55, ptr %53, align 8, !tbaa !5
  store <2 x double> %56, ptr %54, align 8, !tbaa !5
  %57 = getelementptr inbounds i8, ptr %6, i64 384
  %58 = getelementptr inbounds i8, ptr %6, i64 400
  %wide.load.12 = load <2 x double>, ptr %57, align 8, !tbaa !5
  %wide.load73.12 = load <2 x double>, ptr %58, align 8, !tbaa !5
  %59 = fmul <2 x double> %broadcast.splat, %wide.load.12
  %60 = fmul <2 x double> %broadcast.splat, %wide.load73.12
  store <2 x double> %59, ptr %57, align 8, !tbaa !5
  store <2 x double> %60, ptr %58, align 8, !tbaa !5
  %61 = getelementptr inbounds i8, ptr %6, i64 416
  %62 = getelementptr inbounds i8, ptr %6, i64 432
  %wide.load.13 = load <2 x double>, ptr %61, align 8, !tbaa !5
  %wide.load73.13 = load <2 x double>, ptr %62, align 8, !tbaa !5
  %63 = fmul <2 x double> %broadcast.splat, %wide.load.13
  %64 = fmul <2 x double> %broadcast.splat, %wide.load73.13
  store <2 x double> %63, ptr %61, align 8, !tbaa !5
  store <2 x double> %64, ptr %62, align 8, !tbaa !5
  %65 = getelementptr inbounds i8, ptr %6, i64 448
  %66 = getelementptr inbounds i8, ptr %6, i64 464
  %wide.load.14 = load <2 x double>, ptr %65, align 8, !tbaa !5
  %wide.load73.14 = load <2 x double>, ptr %66, align 8, !tbaa !5
  %67 = fmul <2 x double> %broadcast.splat, %wide.load.14
  %68 = fmul <2 x double> %broadcast.splat, %wide.load73.14
  store <2 x double> %67, ptr %65, align 8, !tbaa !5
  store <2 x double> %68, ptr %66, align 8, !tbaa !5
  %69 = getelementptr inbounds i8, ptr %6, i64 480
  %70 = getelementptr inbounds i8, ptr %6, i64 496
  %wide.load.15 = load <2 x double>, ptr %69, align 8, !tbaa !5
  %wide.load73.15 = load <2 x double>, ptr %70, align 8, !tbaa !5
  %71 = fmul <2 x double> %broadcast.splat, %wide.load.15
  %72 = fmul <2 x double> %broadcast.splat, %wide.load73.15
  store <2 x double> %71, ptr %69, align 8, !tbaa !5
  store <2 x double> %72, ptr %70, align 8, !tbaa !5
  %73 = getelementptr inbounds i8, ptr %6, i64 512
  %74 = getelementptr inbounds i8, ptr %6, i64 528
  %wide.load.16 = load <2 x double>, ptr %73, align 8, !tbaa !5
  %wide.load73.16 = load <2 x double>, ptr %74, align 8, !tbaa !5
  %75 = fmul <2 x double> %broadcast.splat, %wide.load.16
  %76 = fmul <2 x double> %broadcast.splat, %wide.load73.16
  store <2 x double> %75, ptr %73, align 8, !tbaa !5
  store <2 x double> %76, ptr %74, align 8, !tbaa !5
  %77 = getelementptr inbounds i8, ptr %6, i64 544
  %78 = getelementptr inbounds i8, ptr %6, i64 560
  %wide.load.17 = load <2 x double>, ptr %77, align 8, !tbaa !5
  %wide.load73.17 = load <2 x double>, ptr %78, align 8, !tbaa !5
  %79 = fmul <2 x double> %broadcast.splat, %wide.load.17
  %80 = fmul <2 x double> %broadcast.splat, %wide.load73.17
  store <2 x double> %79, ptr %77, align 8, !tbaa !5
  store <2 x double> %80, ptr %78, align 8, !tbaa !5
  %81 = getelementptr inbounds i8, ptr %6, i64 576
  %82 = getelementptr inbounds i8, ptr %6, i64 592
  %wide.load.18 = load <2 x double>, ptr %81, align 8, !tbaa !5
  %wide.load73.18 = load <2 x double>, ptr %82, align 8, !tbaa !5
  %83 = fmul <2 x double> %broadcast.splat, %wide.load.18
  %84 = fmul <2 x double> %broadcast.splat, %wide.load73.18
  store <2 x double> %83, ptr %81, align 8, !tbaa !5
  store <2 x double> %84, ptr %82, align 8, !tbaa !5
  %85 = getelementptr inbounds i8, ptr %6, i64 608
  %86 = getelementptr inbounds i8, ptr %6, i64 624
  %wide.load.19 = load <2 x double>, ptr %85, align 8, !tbaa !5
  %wide.load73.19 = load <2 x double>, ptr %86, align 8, !tbaa !5
  %87 = fmul <2 x double> %broadcast.splat, %wide.load.19
  %88 = fmul <2 x double> %broadcast.splat, %wide.load73.19
  store <2 x double> %87, ptr %85, align 8, !tbaa !5
  store <2 x double> %88, ptr %86, align 8, !tbaa !5
  %89 = getelementptr inbounds i8, ptr %6, i64 640
  %90 = load double, ptr %89, align 8, !tbaa !5
  %91 = fmul double %9, %90
  store double %91, ptr %89, align 8, !tbaa !5
  %invariant.gep71 = getelementptr inbounds i8, ptr %6, i64 64
  %invariant.gep67 = getelementptr inbounds i8, ptr %6, i64 48
  %invariant.gep63 = getelementptr inbounds i8, ptr %6, i64 32
  %invariant.gep59 = getelementptr inbounds i8, ptr %6, i64 16
  %.phi.trans.insert57 = getelementptr inbounds i8, ptr %7, i64 64
  %.pre58 = load double, ptr %.phi.trans.insert57, align 16, !tbaa !5
  %.phi.trans.insert53 = getelementptr inbounds i8, ptr %7, i64 48
  %92 = load <2 x double>, ptr %.phi.trans.insert53, align 16, !tbaa !5
  %.phi.trans.insert49 = getelementptr inbounds i8, ptr %7, i64 32
  %93 = load <2 x double>, ptr %.phi.trans.insert49, align 16, !tbaa !5
  %.phi.trans.insert45 = getelementptr inbounds i8, ptr %7, i64 16
  %94 = load <2 x double>, ptr %.phi.trans.insert45, align 16, !tbaa !5
  %95 = load <2 x double>, ptr %7, align 16, !tbaa !5
  %96 = load double, ptr %7, align 16, !tbaa !5
  %97 = load <2 x double>, ptr %6, align 8, !tbaa !5
  %98 = insertelement <2 x double> poison, double %96, i64 0
  %99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> zeroinitializer
  %100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %95, <2 x double> %97)
  store <2 x double> %100, ptr %6, align 8, !tbaa !5
  %101 = load <2 x double>, ptr %invariant.gep59, align 8, !tbaa !5
  %102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %94, <2 x double> %101)
  store <2 x double> %102, ptr %invariant.gep59, align 8, !tbaa !5
  %103 = load <2 x double>, ptr %invariant.gep63, align 8, !tbaa !5
  %104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %93, <2 x double> %103)
  store <2 x double> %104, ptr %invariant.gep63, align 8, !tbaa !5
  %105 = load <2 x double>, ptr %invariant.gep67, align 8, !tbaa !5
  %106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %92, <2 x double> %105)
  store <2 x double> %106, ptr %invariant.gep67, align 8, !tbaa !5
  %107 = load double, ptr %invariant.gep71, align 8, !tbaa !5
  %108 = call double @llvm.fmuladd.f64(double %96, double %.pre58, double %107)
  store double %108, ptr %invariant.gep71, align 8, !tbaa !5
  %109 = getelementptr inbounds i8, ptr %7, i64 8
  %110 = load double, ptr %109, align 8, !tbaa !5
  %111 = getelementptr inbounds i8, ptr %6, i64 72
  %112 = load <2 x double>, ptr %111, align 8, !tbaa !5
  %113 = insertelement <2 x double> poison, double %110, i64 0
  %114 = shufflevector <2 x double> %113, <2 x double> poison, <2 x i32> zeroinitializer
  %115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %95, <2 x double> %112)
  store <2 x double> %115, ptr %111, align 8, !tbaa !5
  %gep60.1 = getelementptr inbounds i8, ptr %6, i64 88
  %116 = load <2 x double>, ptr %gep60.1, align 8, !tbaa !5
  %117 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %94, <2 x double> %116)
  store <2 x double> %117, ptr %gep60.1, align 8, !tbaa !5
  %gep64.1 = getelementptr inbounds i8, ptr %6, i64 104
  %118 = load <2 x double>, ptr %gep64.1, align 8, !tbaa !5
  %119 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %93, <2 x double> %118)
  store <2 x double> %119, ptr %gep64.1, align 8, !tbaa !5
  %gep68.1 = getelementptr inbounds i8, ptr %6, i64 120
  %120 = load <2 x double>, ptr %gep68.1, align 8, !tbaa !5
  %121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %92, <2 x double> %120)
  store <2 x double> %121, ptr %gep68.1, align 8, !tbaa !5
  %gep72.1 = getelementptr inbounds i8, ptr %6, i64 136
  %122 = load double, ptr %gep72.1, align 8, !tbaa !5
  %123 = call double @llvm.fmuladd.f64(double %110, double %.pre58, double %122)
  store double %123, ptr %gep72.1, align 8, !tbaa !5
  %124 = getelementptr inbounds i8, ptr %7, i64 16
  %125 = load double, ptr %124, align 16, !tbaa !5
  %126 = getelementptr inbounds i8, ptr %6, i64 144
  %127 = load <2 x double>, ptr %126, align 8, !tbaa !5
  %128 = insertelement <2 x double> poison, double %125, i64 0
  %129 = shufflevector <2 x double> %128, <2 x double> poison, <2 x i32> zeroinitializer
  %130 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %129, <2 x double> %95, <2 x double> %127)
  store <2 x double> %130, ptr %126, align 8, !tbaa !5
  %gep60.2 = getelementptr inbounds i8, ptr %6, i64 160
  %131 = load <2 x double>, ptr %gep60.2, align 8, !tbaa !5
  %132 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %129, <2 x double> %94, <2 x double> %131)
  store <2 x double> %132, ptr %gep60.2, align 8, !tbaa !5
  %gep64.2 = getelementptr inbounds i8, ptr %6, i64 176
  %133 = load <2 x double>, ptr %gep64.2, align 8, !tbaa !5
  %134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %129, <2 x double> %93, <2 x double> %133)
  store <2 x double> %134, ptr %gep64.2, align 8, !tbaa !5
  %gep68.2 = getelementptr inbounds i8, ptr %6, i64 192
  %135 = load <2 x double>, ptr %gep68.2, align 8, !tbaa !5
  %136 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %129, <2 x double> %92, <2 x double> %135)
  store <2 x double> %136, ptr %gep68.2, align 8, !tbaa !5
  %gep72.2 = getelementptr inbounds i8, ptr %6, i64 208
  %137 = load double, ptr %gep72.2, align 8, !tbaa !5
  %138 = call double @llvm.fmuladd.f64(double %125, double %.pre58, double %137)
  store double %138, ptr %gep72.2, align 8, !tbaa !5
  %139 = getelementptr inbounds i8, ptr %7, i64 24
  %140 = load double, ptr %139, align 8, !tbaa !5
  %141 = getelementptr inbounds i8, ptr %6, i64 216
  %142 = load <2 x double>, ptr %141, align 8, !tbaa !5
  %143 = insertelement <2 x double> poison, double %140, i64 0
  %144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
  %145 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %95, <2 x double> %142)
  store <2 x double> %145, ptr %141, align 8, !tbaa !5
  %gep60.3 = getelementptr inbounds i8, ptr %6, i64 232
  %146 = load <2 x double>, ptr %gep60.3, align 8, !tbaa !5
  %147 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %94, <2 x double> %146)
  store <2 x double> %147, ptr %gep60.3, align 8, !tbaa !5
  %gep64.3 = getelementptr inbounds i8, ptr %6, i64 248
  %148 = load <2 x double>, ptr %gep64.3, align 8, !tbaa !5
  %149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %93, <2 x double> %148)
  store <2 x double> %149, ptr %gep64.3, align 8, !tbaa !5
  %gep68.3 = getelementptr inbounds i8, ptr %6, i64 264
  %150 = load <2 x double>, ptr %gep68.3, align 8, !tbaa !5
  %151 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %92, <2 x double> %150)
  store <2 x double> %151, ptr %gep68.3, align 8, !tbaa !5
  %gep72.3 = getelementptr inbounds i8, ptr %6, i64 280
  %152 = load double, ptr %gep72.3, align 8, !tbaa !5
  %153 = call double @llvm.fmuladd.f64(double %140, double %.pre58, double %152)
  store double %153, ptr %gep72.3, align 8, !tbaa !5
  %154 = getelementptr inbounds i8, ptr %7, i64 32
  %155 = load double, ptr %154, align 16, !tbaa !5
  %156 = getelementptr inbounds i8, ptr %6, i64 288
  %157 = load <2 x double>, ptr %156, align 8, !tbaa !5
  %158 = insertelement <2 x double> poison, double %155, i64 0
  %159 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> zeroinitializer
  %160 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %95, <2 x double> %157)
  store <2 x double> %160, ptr %156, align 8, !tbaa !5
  %gep60.4 = getelementptr inbounds i8, ptr %6, i64 304
  %161 = load <2 x double>, ptr %gep60.4, align 8, !tbaa !5
  %162 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %94, <2 x double> %161)
  store <2 x double> %162, ptr %gep60.4, align 8, !tbaa !5
  %gep64.4 = getelementptr inbounds i8, ptr %6, i64 320
  %163 = load <2 x double>, ptr %gep64.4, align 8, !tbaa !5
  %164 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %93, <2 x double> %163)
  store <2 x double> %164, ptr %gep64.4, align 8, !tbaa !5
  %gep68.4 = getelementptr inbounds i8, ptr %6, i64 336
  %165 = load <2 x double>, ptr %gep68.4, align 8, !tbaa !5
  %166 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %92, <2 x double> %165)
  store <2 x double> %166, ptr %gep68.4, align 8, !tbaa !5
  %gep72.4 = getelementptr inbounds i8, ptr %6, i64 352
  %167 = load double, ptr %gep72.4, align 8, !tbaa !5
  %168 = call double @llvm.fmuladd.f64(double %155, double %.pre58, double %167)
  store double %168, ptr %gep72.4, align 8, !tbaa !5
  %169 = getelementptr inbounds i8, ptr %7, i64 40
  %170 = load double, ptr %169, align 8, !tbaa !5
  %171 = getelementptr inbounds i8, ptr %6, i64 360
  %172 = load <2 x double>, ptr %171, align 8, !tbaa !5
  %173 = insertelement <2 x double> poison, double %170, i64 0
  %174 = shufflevector <2 x double> %173, <2 x double> poison, <2 x i32> zeroinitializer
  %175 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %95, <2 x double> %172)
  store <2 x double> %175, ptr %171, align 8, !tbaa !5
  %gep60.5 = getelementptr inbounds i8, ptr %6, i64 376
  %176 = load <2 x double>, ptr %gep60.5, align 8, !tbaa !5
  %177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %94, <2 x double> %176)
  store <2 x double> %177, ptr %gep60.5, align 8, !tbaa !5
  %gep64.5 = getelementptr inbounds i8, ptr %6, i64 392
  %178 = load <2 x double>, ptr %gep64.5, align 8, !tbaa !5
  %179 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %93, <2 x double> %178)
  store <2 x double> %179, ptr %gep64.5, align 8, !tbaa !5
  %gep68.5 = getelementptr inbounds i8, ptr %6, i64 408
  %180 = load <2 x double>, ptr %gep68.5, align 8, !tbaa !5
  %181 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %92, <2 x double> %180)
  store <2 x double> %181, ptr %gep68.5, align 8, !tbaa !5
  %gep72.5 = getelementptr inbounds i8, ptr %6, i64 424
  %182 = load double, ptr %gep72.5, align 8, !tbaa !5
  %183 = call double @llvm.fmuladd.f64(double %170, double %.pre58, double %182)
  store double %183, ptr %gep72.5, align 8, !tbaa !5
  %184 = getelementptr inbounds i8, ptr %7, i64 48
  %185 = load double, ptr %184, align 16, !tbaa !5
  %186 = getelementptr inbounds i8, ptr %6, i64 432
  %187 = load <2 x double>, ptr %186, align 8, !tbaa !5
  %188 = insertelement <2 x double> poison, double %185, i64 0
  %189 = shufflevector <2 x double> %188, <2 x double> poison, <2 x i32> zeroinitializer
  %190 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> %95, <2 x double> %187)
  store <2 x double> %190, ptr %186, align 8, !tbaa !5
  %gep60.6 = getelementptr inbounds i8, ptr %6, i64 448
  %191 = load <2 x double>, ptr %gep60.6, align 8, !tbaa !5
  %192 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> %94, <2 x double> %191)
  store <2 x double> %192, ptr %gep60.6, align 8, !tbaa !5
  %gep64.6 = getelementptr inbounds i8, ptr %6, i64 464
  %193 = load <2 x double>, ptr %gep64.6, align 8, !tbaa !5
  %194 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> %93, <2 x double> %193)
  store <2 x double> %194, ptr %gep64.6, align 8, !tbaa !5
  %gep68.6 = getelementptr inbounds i8, ptr %6, i64 480
  %195 = load <2 x double>, ptr %gep68.6, align 8, !tbaa !5
  %196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> %92, <2 x double> %195)
  store <2 x double> %196, ptr %gep68.6, align 8, !tbaa !5
  %gep72.6 = getelementptr inbounds i8, ptr %6, i64 496
  %197 = load double, ptr %gep72.6, align 8, !tbaa !5
  %198 = call double @llvm.fmuladd.f64(double %185, double %.pre58, double %197)
  store double %198, ptr %gep72.6, align 8, !tbaa !5
  %199 = getelementptr inbounds i8, ptr %7, i64 56
  %200 = load double, ptr %199, align 8, !tbaa !5
  %201 = getelementptr inbounds i8, ptr %6, i64 504
  %202 = load <2 x double>, ptr %201, align 8, !tbaa !5
  %203 = insertelement <2 x double> poison, double %200, i64 0
  %204 = shufflevector <2 x double> %203, <2 x double> poison, <2 x i32> zeroinitializer
  %205 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %95, <2 x double> %202)
  store <2 x double> %205, ptr %201, align 8, !tbaa !5
  %gep60.7 = getelementptr inbounds i8, ptr %6, i64 520
  %206 = load <2 x double>, ptr %gep60.7, align 8, !tbaa !5
  %207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %94, <2 x double> %206)
  store <2 x double> %207, ptr %gep60.7, align 8, !tbaa !5
  %gep64.7 = getelementptr inbounds i8, ptr %6, i64 536
  %208 = load <2 x double>, ptr %gep64.7, align 8, !tbaa !5
  %209 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %93, <2 x double> %208)
  store <2 x double> %209, ptr %gep64.7, align 8, !tbaa !5
  %gep68.7 = getelementptr inbounds i8, ptr %6, i64 552
  %210 = load <2 x double>, ptr %gep68.7, align 8, !tbaa !5
  %211 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %92, <2 x double> %210)
  store <2 x double> %211, ptr %gep68.7, align 8, !tbaa !5
  %gep72.7 = getelementptr inbounds i8, ptr %6, i64 568
  %212 = load double, ptr %gep72.7, align 8, !tbaa !5
  %213 = call double @llvm.fmuladd.f64(double %200, double %.pre58, double %212)
  store double %213, ptr %gep72.7, align 8, !tbaa !5
  %214 = getelementptr inbounds i8, ptr %7, i64 64
  %215 = load double, ptr %214, align 16, !tbaa !5
  %216 = getelementptr inbounds i8, ptr %6, i64 576
  %217 = load <2 x double>, ptr %216, align 8, !tbaa !5
  %218 = insertelement <2 x double> poison, double %215, i64 0
  %219 = shufflevector <2 x double> %218, <2 x double> poison, <2 x i32> zeroinitializer
  %220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %95, <2 x double> %217)
  store <2 x double> %220, ptr %216, align 8, !tbaa !5
  %gep60.8 = getelementptr inbounds i8, ptr %6, i64 592
  %221 = load <2 x double>, ptr %gep60.8, align 8, !tbaa !5
  %222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %94, <2 x double> %221)
  store <2 x double> %222, ptr %gep60.8, align 8, !tbaa !5
  %gep64.8 = getelementptr inbounds i8, ptr %6, i64 608
  %223 = load <2 x double>, ptr %gep64.8, align 8, !tbaa !5
  %224 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %93, <2 x double> %223)
  store <2 x double> %224, ptr %gep64.8, align 8, !tbaa !5
  %gep68.8 = getelementptr inbounds i8, ptr %6, i64 624
  %225 = load <2 x double>, ptr %gep68.8, align 8, !tbaa !5
  %226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %92, <2 x double> %225)
  store <2 x double> %226, ptr %gep68.8, align 8, !tbaa !5
  %gep72.8 = getelementptr inbounds i8, ptr %6, i64 640
  %227 = load double, ptr %gep72.8, align 8, !tbaa !5
  %228 = call double @llvm.fmuladd.f64(double %215, double %.pre58, double %227)
  store double %228, ptr %gep72.8, align 8, !tbaa !5
  %229 = getelementptr inbounds i8, ptr %0, i64 16
  %scevgep = getelementptr i8, ptr %6, i64 648
  %scevgep74 = getelementptr inbounds i8, ptr %0, i64 24
  %bound0 = icmp ule ptr %scevgep74, %6
  %bound1 = icmp uge ptr %229, %scevgep
  %found.conflict.not = or i1 %bound0, %bound1
  br i1 %found.conflict.not, label %vector.body79, label %scalar.ph76.prol.preheader

scalar.ph76.prol.preheader:                       ; preds = %vector.ph, %vector.body79
  %indvars.iv40.ph = phi i64 [ 0, %vector.ph ], [ 80, %vector.body79 ]
  br label %scalar.ph76.prol

scalar.ph76.prol:                                 ; preds = %scalar.ph76.prol, %scalar.ph76.prol.preheader
  %indvars.iv40.prol = phi i64 [ %indvars.iv.next41.prol, %scalar.ph76.prol ], [ %indvars.iv40.ph, %scalar.ph76.prol.preheader ]
  %prol.iter = phi i64 [ %prol.iter.next, %scalar.ph76.prol ], [ 0, %scalar.ph76.prol.preheader ]
  %230 = load double, ptr %229, align 8, !tbaa !9
  %231 = getelementptr inbounds double, ptr %6, i64 %indvars.iv40.prol
  %232 = load double, ptr %231, align 8, !tbaa !5
  %233 = fmul double %230, %232
  store double %233, ptr %231, align 8, !tbaa !5
  %indvars.iv.next41.prol = add nuw nsw i64 %indvars.iv40.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter, 0
  br i1 %prol.iter.cmp.not, label %scalar.ph76.prol.loopexit, label %scalar.ph76.prol, !llvm.loop !13

scalar.ph76.prol.loopexit:                        ; preds = %scalar.ph76.prol
  br i1 %found.conflict.not, label %.loopexit, label %scalar.ph76.preheader.new

scalar.ph76.preheader.new:                        ; preds = %scalar.ph76.prol.loopexit
  %invariant.gep = getelementptr i8, ptr %6, i64 8
  %invariant.gep88 = getelementptr i8, ptr %6, i64 16
  %invariant.gep90 = getelementptr i8, ptr %6, i64 24
  br label %scalar.ph76

vector.body79:                                    ; preds = %vector.ph
  %234 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85 = insertelement <2 x double> poison, double %234, i64 0
  %broadcast.splat86 = shufflevector <2 x double> %broadcast.splatinsert85, <2 x double> poison, <2 x i32> zeroinitializer
  %235 = getelementptr inbounds i8, ptr %6, i64 16
  %wide.load81 = load <2 x double>, ptr %6, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82 = load <2 x double>, ptr %235, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %236 = fmul <2 x double> %broadcast.splat86, %wide.load81
  %237 = fmul <2 x double> %broadcast.splat86, %wide.load82
  store <2 x double> %236, ptr %6, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %237, ptr %235, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %238 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.1 = insertelement <2 x double> poison, double %238, i64 0
  %broadcast.splat86.1 = shufflevector <2 x double> %broadcast.splatinsert85.1, <2 x double> poison, <2 x i32> zeroinitializer
  %239 = getelementptr inbounds i8, ptr %6, i64 32
  %240 = getelementptr inbounds i8, ptr %6, i64 48
  %wide.load81.1 = load <2 x double>, ptr %239, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.1 = load <2 x double>, ptr %240, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %241 = fmul <2 x double> %broadcast.splat86.1, %wide.load81.1
  %242 = fmul <2 x double> %broadcast.splat86.1, %wide.load82.1
  store <2 x double> %241, ptr %239, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %242, ptr %240, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %243 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.2 = insertelement <2 x double> poison, double %243, i64 0
  %broadcast.splat86.2 = shufflevector <2 x double> %broadcast.splatinsert85.2, <2 x double> poison, <2 x i32> zeroinitializer
  %244 = getelementptr inbounds i8, ptr %6, i64 64
  %245 = getelementptr inbounds i8, ptr %6, i64 80
  %wide.load81.2 = load <2 x double>, ptr %244, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.2 = load <2 x double>, ptr %245, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %246 = fmul <2 x double> %broadcast.splat86.2, %wide.load81.2
  %247 = fmul <2 x double> %broadcast.splat86.2, %wide.load82.2
  store <2 x double> %246, ptr %244, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %247, ptr %245, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %248 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.3 = insertelement <2 x double> poison, double %248, i64 0
  %broadcast.splat86.3 = shufflevector <2 x double> %broadcast.splatinsert85.3, <2 x double> poison, <2 x i32> zeroinitializer
  %249 = getelementptr inbounds i8, ptr %6, i64 96
  %250 = getelementptr inbounds i8, ptr %6, i64 112
  %wide.load81.3 = load <2 x double>, ptr %249, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.3 = load <2 x double>, ptr %250, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %251 = fmul <2 x double> %broadcast.splat86.3, %wide.load81.3
  %252 = fmul <2 x double> %broadcast.splat86.3, %wide.load82.3
  store <2 x double> %251, ptr %249, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %252, ptr %250, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %253 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.4 = insertelement <2 x double> poison, double %253, i64 0
  %broadcast.splat86.4 = shufflevector <2 x double> %broadcast.splatinsert85.4, <2 x double> poison, <2 x i32> zeroinitializer
  %254 = getelementptr inbounds i8, ptr %6, i64 128
  %255 = getelementptr inbounds i8, ptr %6, i64 144
  %wide.load81.4 = load <2 x double>, ptr %254, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.4 = load <2 x double>, ptr %255, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %256 = fmul <2 x double> %broadcast.splat86.4, %wide.load81.4
  %257 = fmul <2 x double> %broadcast.splat86.4, %wide.load82.4
  store <2 x double> %256, ptr %254, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %257, ptr %255, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %258 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.5 = insertelement <2 x double> poison, double %258, i64 0
  %broadcast.splat86.5 = shufflevector <2 x double> %broadcast.splatinsert85.5, <2 x double> poison, <2 x i32> zeroinitializer
  %259 = getelementptr inbounds i8, ptr %6, i64 160
  %260 = getelementptr inbounds i8, ptr %6, i64 176
  %wide.load81.5 = load <2 x double>, ptr %259, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.5 = load <2 x double>, ptr %260, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %261 = fmul <2 x double> %broadcast.splat86.5, %wide.load81.5
  %262 = fmul <2 x double> %broadcast.splat86.5, %wide.load82.5
  store <2 x double> %261, ptr %259, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %262, ptr %260, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %263 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.6 = insertelement <2 x double> poison, double %263, i64 0
  %broadcast.splat86.6 = shufflevector <2 x double> %broadcast.splatinsert85.6, <2 x double> poison, <2 x i32> zeroinitializer
  %264 = getelementptr inbounds i8, ptr %6, i64 192
  %265 = getelementptr inbounds i8, ptr %6, i64 208
  %wide.load81.6 = load <2 x double>, ptr %264, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.6 = load <2 x double>, ptr %265, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %266 = fmul <2 x double> %broadcast.splat86.6, %wide.load81.6
  %267 = fmul <2 x double> %broadcast.splat86.6, %wide.load82.6
  store <2 x double> %266, ptr %264, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %267, ptr %265, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %268 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.7 = insertelement <2 x double> poison, double %268, i64 0
  %broadcast.splat86.7 = shufflevector <2 x double> %broadcast.splatinsert85.7, <2 x double> poison, <2 x i32> zeroinitializer
  %269 = getelementptr inbounds i8, ptr %6, i64 224
  %270 = getelementptr inbounds i8, ptr %6, i64 240
  %wide.load81.7 = load <2 x double>, ptr %269, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.7 = load <2 x double>, ptr %270, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %271 = fmul <2 x double> %broadcast.splat86.7, %wide.load81.7
  %272 = fmul <2 x double> %broadcast.splat86.7, %wide.load82.7
  store <2 x double> %271, ptr %269, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %272, ptr %270, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %273 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.8 = insertelement <2 x double> poison, double %273, i64 0
  %broadcast.splat86.8 = shufflevector <2 x double> %broadcast.splatinsert85.8, <2 x double> poison, <2 x i32> zeroinitializer
  %274 = getelementptr inbounds i8, ptr %6, i64 256
  %275 = getelementptr inbounds i8, ptr %6, i64 272
  %wide.load81.8 = load <2 x double>, ptr %274, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.8 = load <2 x double>, ptr %275, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %276 = fmul <2 x double> %broadcast.splat86.8, %wide.load81.8
  %277 = fmul <2 x double> %broadcast.splat86.8, %wide.load82.8
  store <2 x double> %276, ptr %274, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %277, ptr %275, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %278 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.9 = insertelement <2 x double> poison, double %278, i64 0
  %broadcast.splat86.9 = shufflevector <2 x double> %broadcast.splatinsert85.9, <2 x double> poison, <2 x i32> zeroinitializer
  %279 = getelementptr inbounds i8, ptr %6, i64 288
  %280 = getelementptr inbounds i8, ptr %6, i64 304
  %wide.load81.9 = load <2 x double>, ptr %279, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.9 = load <2 x double>, ptr %280, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %281 = fmul <2 x double> %broadcast.splat86.9, %wide.load81.9
  %282 = fmul <2 x double> %broadcast.splat86.9, %wide.load82.9
  store <2 x double> %281, ptr %279, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %282, ptr %280, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %283 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.10 = insertelement <2 x double> poison, double %283, i64 0
  %broadcast.splat86.10 = shufflevector <2 x double> %broadcast.splatinsert85.10, <2 x double> poison, <2 x i32> zeroinitializer
  %284 = getelementptr inbounds i8, ptr %6, i64 320
  %285 = getelementptr inbounds i8, ptr %6, i64 336
  %wide.load81.10 = load <2 x double>, ptr %284, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.10 = load <2 x double>, ptr %285, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %286 = fmul <2 x double> %broadcast.splat86.10, %wide.load81.10
  %287 = fmul <2 x double> %broadcast.splat86.10, %wide.load82.10
  store <2 x double> %286, ptr %284, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %287, ptr %285, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %288 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.11 = insertelement <2 x double> poison, double %288, i64 0
  %broadcast.splat86.11 = shufflevector <2 x double> %broadcast.splatinsert85.11, <2 x double> poison, <2 x i32> zeroinitializer
  %289 = getelementptr inbounds i8, ptr %6, i64 352
  %290 = getelementptr inbounds i8, ptr %6, i64 368
  %wide.load81.11 = load <2 x double>, ptr %289, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.11 = load <2 x double>, ptr %290, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %291 = fmul <2 x double> %broadcast.splat86.11, %wide.load81.11
  %292 = fmul <2 x double> %broadcast.splat86.11, %wide.load82.11
  store <2 x double> %291, ptr %289, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %292, ptr %290, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %293 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.12 = insertelement <2 x double> poison, double %293, i64 0
  %broadcast.splat86.12 = shufflevector <2 x double> %broadcast.splatinsert85.12, <2 x double> poison, <2 x i32> zeroinitializer
  %294 = getelementptr inbounds i8, ptr %6, i64 384
  %295 = getelementptr inbounds i8, ptr %6, i64 400
  %wide.load81.12 = load <2 x double>, ptr %294, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.12 = load <2 x double>, ptr %295, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %296 = fmul <2 x double> %broadcast.splat86.12, %wide.load81.12
  %297 = fmul <2 x double> %broadcast.splat86.12, %wide.load82.12
  store <2 x double> %296, ptr %294, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %297, ptr %295, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %298 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.13 = insertelement <2 x double> poison, double %298, i64 0
  %broadcast.splat86.13 = shufflevector <2 x double> %broadcast.splatinsert85.13, <2 x double> poison, <2 x i32> zeroinitializer
  %299 = getelementptr inbounds i8, ptr %6, i64 416
  %300 = getelementptr inbounds i8, ptr %6, i64 432
  %wide.load81.13 = load <2 x double>, ptr %299, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.13 = load <2 x double>, ptr %300, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %301 = fmul <2 x double> %broadcast.splat86.13, %wide.load81.13
  %302 = fmul <2 x double> %broadcast.splat86.13, %wide.load82.13
  store <2 x double> %301, ptr %299, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %302, ptr %300, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %303 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.14 = insertelement <2 x double> poison, double %303, i64 0
  %broadcast.splat86.14 = shufflevector <2 x double> %broadcast.splatinsert85.14, <2 x double> poison, <2 x i32> zeroinitializer
  %304 = getelementptr inbounds i8, ptr %6, i64 448
  %305 = getelementptr inbounds i8, ptr %6, i64 464
  %wide.load81.14 = load <2 x double>, ptr %304, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.14 = load <2 x double>, ptr %305, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %306 = fmul <2 x double> %broadcast.splat86.14, %wide.load81.14
  %307 = fmul <2 x double> %broadcast.splat86.14, %wide.load82.14
  store <2 x double> %306, ptr %304, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %307, ptr %305, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %308 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.15 = insertelement <2 x double> poison, double %308, i64 0
  %broadcast.splat86.15 = shufflevector <2 x double> %broadcast.splatinsert85.15, <2 x double> poison, <2 x i32> zeroinitializer
  %309 = getelementptr inbounds i8, ptr %6, i64 480
  %310 = getelementptr inbounds i8, ptr %6, i64 496
  %wide.load81.15 = load <2 x double>, ptr %309, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.15 = load <2 x double>, ptr %310, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %311 = fmul <2 x double> %broadcast.splat86.15, %wide.load81.15
  %312 = fmul <2 x double> %broadcast.splat86.15, %wide.load82.15
  store <2 x double> %311, ptr %309, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %312, ptr %310, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %313 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.16 = insertelement <2 x double> poison, double %313, i64 0
  %broadcast.splat86.16 = shufflevector <2 x double> %broadcast.splatinsert85.16, <2 x double> poison, <2 x i32> zeroinitializer
  %314 = getelementptr inbounds i8, ptr %6, i64 512
  %315 = getelementptr inbounds i8, ptr %6, i64 528
  %wide.load81.16 = load <2 x double>, ptr %314, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.16 = load <2 x double>, ptr %315, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %316 = fmul <2 x double> %broadcast.splat86.16, %wide.load81.16
  %317 = fmul <2 x double> %broadcast.splat86.16, %wide.load82.16
  store <2 x double> %316, ptr %314, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %317, ptr %315, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %318 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.17 = insertelement <2 x double> poison, double %318, i64 0
  %broadcast.splat86.17 = shufflevector <2 x double> %broadcast.splatinsert85.17, <2 x double> poison, <2 x i32> zeroinitializer
  %319 = getelementptr inbounds i8, ptr %6, i64 544
  %320 = getelementptr inbounds i8, ptr %6, i64 560
  %wide.load81.17 = load <2 x double>, ptr %319, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.17 = load <2 x double>, ptr %320, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %321 = fmul <2 x double> %broadcast.splat86.17, %wide.load81.17
  %322 = fmul <2 x double> %broadcast.splat86.17, %wide.load82.17
  store <2 x double> %321, ptr %319, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %322, ptr %320, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %323 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.18 = insertelement <2 x double> poison, double %323, i64 0
  %broadcast.splat86.18 = shufflevector <2 x double> %broadcast.splatinsert85.18, <2 x double> poison, <2 x i32> zeroinitializer
  %324 = getelementptr inbounds i8, ptr %6, i64 576
  %325 = getelementptr inbounds i8, ptr %6, i64 592
  %wide.load81.18 = load <2 x double>, ptr %324, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.18 = load <2 x double>, ptr %325, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %326 = fmul <2 x double> %broadcast.splat86.18, %wide.load81.18
  %327 = fmul <2 x double> %broadcast.splat86.18, %wide.load82.18
  store <2 x double> %326, ptr %324, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %327, ptr %325, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %328 = load double, ptr %229, align 8, !tbaa !9, !alias.scope !15
  %broadcast.splatinsert85.19 = insertelement <2 x double> poison, double %328, i64 0
  %broadcast.splat86.19 = shufflevector <2 x double> %broadcast.splatinsert85.19, <2 x double> poison, <2 x i32> zeroinitializer
  %329 = getelementptr inbounds i8, ptr %6, i64 608
  %330 = getelementptr inbounds i8, ptr %6, i64 624
  %wide.load81.19 = load <2 x double>, ptr %329, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %wide.load82.19 = load <2 x double>, ptr %330, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  %331 = fmul <2 x double> %broadcast.splat86.19, %wide.load81.19
  %332 = fmul <2 x double> %broadcast.splat86.19, %wide.load82.19
  store <2 x double> %331, ptr %329, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  store <2 x double> %332, ptr %330, align 8, !tbaa !5, !alias.scope !18, !noalias !15
  br label %scalar.ph76.prol.preheader

.loopexit:                                        ; preds = %scalar.ph76, %scalar.ph76.prol.loopexit
  call void @llvm.lifetime.end.p0(i64 72, ptr nonnull %7) #5
  ret void

scalar.ph76:                                      ; preds = %scalar.ph76, %scalar.ph76.preheader.new
  %indvars.iv40 = phi i64 [ %indvars.iv.next41.prol, %scalar.ph76.preheader.new ], [ %indvars.iv.next41.3, %scalar.ph76 ]
  %333 = load double, ptr %229, align 8, !tbaa !9
  %334 = getelementptr inbounds double, ptr %6, i64 %indvars.iv40
  %335 = load double, ptr %334, align 8, !tbaa !5
  %336 = fmul double %333, %335
  store double %336, ptr %334, align 8, !tbaa !5
  %337 = load double, ptr %229, align 8, !tbaa !9
  %gep = getelementptr double, ptr %invariant.gep, i64 %indvars.iv40
  %338 = load double, ptr %gep, align 8, !tbaa !5
  %339 = fmul double %337, %338
  store double %339, ptr %gep, align 8, !tbaa !5
  %340 = load double, ptr %229, align 8, !tbaa !9
  %gep89 = getelementptr double, ptr %invariant.gep88, i64 %indvars.iv40
  %341 = load double, ptr %gep89, align 8, !tbaa !5
  %342 = fmul double %340, %341
  store double %342, ptr %gep89, align 8, !tbaa !5
  %343 = load double, ptr %229, align 8, !tbaa !9
  %gep91 = getelementptr double, ptr %invariant.gep90, i64 %indvars.iv40
  %344 = load double, ptr %gep91, align 8, !tbaa !5
  %345 = fmul double %343, %344
  store double %345, ptr %gep91, align 8, !tbaa !5
  %indvars.iv.next41.3 = add nuw nsw i64 %indvars.iv40, 4
  %exitcond43.not.3 = icmp eq i64 %indvars.iv.next41.3, 81
  br i1 %exitcond43.not.3, label %.loopexit, label %scalar.ph76, !llvm.loop !20
}

declare void @_ZN3pgo21NonlinearOptimization11Determinant4Dim310d2detA_dA2EPKdPd(ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #3

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 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 #3 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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 = !{!6, !6, i64 0}
!6 = !{!"double", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !6, i64 16}
!10 = !{!"_ZTSN3pgo21SolidDeformationModel26ElasticModelVolumeMaterialE", !11, i64 0, !6, i64 16}
!11 = !{!"_ZTSN3pgo21SolidDeformationModel12ElasticModelE", !12, i64 8}
!12 = !{!"bool", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.unroll.disable"}
!15 = !{!16}
!16 = distinct !{!16, !17}
!17 = distinct !{!17, !"LVerDomain"}
!18 = !{!19}
!19 = distinct !{!19, !17}
!20 = distinct !{!20, !21, !22}
!21 = !{!"llvm.loop.mustprogress"}
!22 = !{!"llvm.loop.isvectorized", i32 1}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,LCSSAPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass