; LLVM IR from ROCm/aomp :: test/smoke/issue_001 (issue_001)

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

@.str = external hidden unnamed_addr constant [34 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [11 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = alloca [320000 x double], align 16
  %4 = alloca [320000 x double], align 16
  %5 = alloca [320000 x double], align 16
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #3
  store i32 0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2560000, ptr %3) #3
  call void @llvm.lifetime.start.p0(i64 2560000, ptr %4) #3
  call void @llvm.lifetime.start.p0(i64 2560000, ptr %5) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #3
  store i32 0, ptr %6, align 4, !tbaa !5
  br label %15

15:                                               ; preds = %29, %0
  %16 = load i32, ptr %6, align 4, !tbaa !5
  %17 = icmp slt i32 %16, 320000
  br i1 %17, label %19, label %18

18:                                               ; preds = %15
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #3
  br label %32

19:                                               ; preds = %15
  %20 = load i32, ptr %6, align 4, !tbaa !5
  %21 = sext i32 %20 to i64
  %22 = getelementptr inbounds [320000 x double], ptr %3, i64 0, i64 %21
  store double 0.000000e+00, ptr %22, align 8, !tbaa !9
  %23 = load i32, ptr %6, align 4, !tbaa !5
  %24 = sext i32 %23 to i64
  %25 = getelementptr inbounds [320000 x double], ptr %4, i64 0, i64 %24
  store double 0.000000e+00, ptr %25, align 8, !tbaa !9
  %26 = load i32, ptr %6, align 4, !tbaa !5
  %27 = sext i32 %26 to i64
  %28 = getelementptr inbounds [320000 x double], ptr %5, i64 0, i64 %27
  store double 1.000000e+00, ptr %28, align 8, !tbaa !9
  br label %29

29:                                               ; preds = %19
  %30 = load i32, ptr %6, align 4, !tbaa !5
  %31 = add nsw i32 %30, 1
  store i32 %31, ptr %6, align 4, !tbaa !5
  br label %15, !llvm.loop !11

32:                                               ; preds = %18
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #3
  store i32 32, ptr %7, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #3
  store i32 64, ptr %8, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #3
  %33 = load i32, ptr %8, align 4, !tbaa !5
  store i32 %33, ptr %9, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #3
  store i32 0, ptr %10, align 4, !tbaa !5
  br label %34

34:                                               ; preds = %76, %32
  %35 = load i32, ptr %10, align 4, !tbaa !5
  %36 = icmp slt i32 %35, 600
  br i1 %36, label %38, label %37

37:                                               ; preds = %34
  store i32 5, ptr %11, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #3
  br label %79

38:                                               ; preds = %34
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #3
  store i32 0, ptr %12, align 4, !tbaa !5
  br label %39

39:                                               ; preds = %71, %38
  %40 = load i32, ptr %12, align 4, !tbaa !5
  %41 = icmp slt i32 %40, 320000
  br i1 %41, label %43, label %42

42:                                               ; preds = %39
  store i32 8, ptr %11, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #3
  br label %75

43:                                               ; preds = %39
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #3
  %44 = load i32, ptr %12, align 4, !tbaa !5
  store i32 %44, ptr %13, align 4, !tbaa !5
  br label %45

45:                                               ; preds = %67, %43
  %46 = load i32, ptr %13, align 4, !tbaa !5
  %47 = load i32, ptr %12, align 4, !tbaa !5
  %48 = load i32, ptr %9, align 4, !tbaa !5
  %49 = add nsw i32 %47, %48
  %50 = icmp slt i32 %46, %49
  br i1 %50, label %52, label %51

51:                                               ; preds = %45
  store i32 11, ptr %11, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #3
  br label %70

52:                                               ; preds = %45
  %53 = load i32, ptr %13, align 4, !tbaa !5
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds [320000 x double], ptr %4, i64 0, i64 %54
  %56 = load double, ptr %55, align 8, !tbaa !9
  %57 = load i32, ptr %13, align 4, !tbaa !5
  %58 = sext i32 %57 to i64
  %59 = getelementptr inbounds [320000 x double], ptr %5, i64 0, i64 %58
  %60 = load double, ptr %59, align 8, !tbaa !9
  %61 = fadd double %56, %60
  %62 = load i32, ptr %13, align 4, !tbaa !5
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds [320000 x double], ptr %3, i64 0, i64 %63
  %65 = load double, ptr %64, align 8, !tbaa !9
  %66 = fadd double %65, %61
  store double %66, ptr %64, align 8, !tbaa !9
  br label %67

67:                                               ; preds = %52
  %68 = load i32, ptr %13, align 4, !tbaa !5
  %69 = add nsw i32 %68, 1
  store i32 %69, ptr %13, align 4, !tbaa !5
  br label %45, !llvm.loop !13

70:                                               ; preds = %51
  br label %71

71:                                               ; preds = %70
  %72 = load i32, ptr %9, align 4, !tbaa !5
  %73 = load i32, ptr %12, align 4, !tbaa !5
  %74 = add nsw i32 %73, %72
  store i32 %74, ptr %12, align 4, !tbaa !5
  br label %39, !llvm.loop !14

75:                                               ; preds = %42
  br label %76

76:                                               ; preds = %75
  %77 = load i32, ptr %10, align 4, !tbaa !5
  %78 = add nsw i32 %77, 1
  store i32 %78, ptr %10, align 4, !tbaa !5
  br label %34, !llvm.loop !15

79:                                               ; preds = %37
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #3
  store i32 0, ptr %14, align 4, !tbaa !5
  br label %80

80:                                               ; preds = %98, %79
  %81 = load i32, ptr %14, align 4, !tbaa !5
  %82 = icmp slt i32 %81, 320000
  br i1 %82, label %84, label %83

83:                                               ; preds = %80
  store i32 14, ptr %11, align 4
  br label %101

84:                                               ; preds = %80
  %85 = load i32, ptr %14, align 4, !tbaa !5
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds [320000 x double], ptr %3, i64 0, i64 %86
  %88 = load double, ptr %87, align 8, !tbaa !9
  %89 = fcmp une double %88, 6.000000e+02
  br i1 %89, label %90, label %97

90:                                               ; preds = %84
  %91 = load i32, ptr %14, align 4, !tbaa !5
  %92 = load i32, ptr %14, align 4, !tbaa !5
  %93 = sext i32 %92 to i64
  %94 = getelementptr inbounds [320000 x double], ptr %3, i64 0, i64 %93
  %95 = load double, ptr %94, align 8, !tbaa !9
  %96 = call i32 (ptr, ...) @printf(ptr noundef @.str, i32 noundef %91, double noundef 3.000000e+03, double noundef %95)
  store i32 1, ptr %2, align 4, !tbaa !5
  store i32 14, ptr %11, align 4
  br label %101

97:                                               ; preds = %84
  br label %98

98:                                               ; preds = %97
  %99 = load i32, ptr %14, align 4, !tbaa !5
  %100 = add nsw i32 %99, 1
  store i32 %100, ptr %14, align 4, !tbaa !5
  br label %80, !llvm.loop !16

101:                                              ; preds = %90, %83
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  br label %102

102:                                              ; preds = %101
  %103 = load i32, ptr %2, align 4, !tbaa !5
  %104 = icmp ne i32 %103, 0
  br i1 %104, label %105, label %107

105:                                              ; preds = %102
  %106 = call i32 (ptr, ...) @printf(ptr noundef @.str.1)
  store i32 1, ptr %1, align 4
  store i32 1, ptr %11, align 4
  br label %109

107:                                              ; preds = %102
  %108 = call i32 (ptr, ...) @printf(ptr noundef @.str.2)
  store i32 0, ptr %1, align 4
  store i32 1, ptr %11, align 4
  br label %109

109:                                              ; preds = %107, %105
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #3
  call void @llvm.lifetime.end.p0(i64 2560000, ptr %5) #3
  call void @llvm.lifetime.end.p0(i64 2560000, ptr %4) #3
  call void @llvm.lifetime.end.p0(i64 2560000, ptr %3) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #3
  %110 = load i32, ptr %1, align 4
  ret i32 %110
}

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

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

declare i32 @printf(ptr noundef, ...) #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 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }

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

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


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

@.str = external hidden unnamed_addr constant [34 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [11 x i8], align 1

; Function Attrs: nofree nounwind uwtable
define dso_local range(i32 0, 2) i32 @main() local_unnamed_addr #0 {
vector.ph:
  %0 = alloca [320000 x double], align 16
  %1 = alloca [320000 x double], align 16
  %2 = alloca [320000 x double], align 16
  call void @llvm.lifetime.start.p0(i64 2560000, ptr nonnull %0) #4
  call void @llvm.lifetime.start.p0(i64 2560000, ptr nonnull %1) #4
  call void @llvm.lifetime.start.p0(i64 2560000, ptr nonnull %2) #4
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(2560000) %0, i8 0, i64 2560000, i1 false), !tbaa !5
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(2560000) %1, i8 0, i64 2560000, i1 false), !tbaa !5
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next.4, %vector.body ]
  %3 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %index
  %4 = getelementptr inbounds i8, ptr %3, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %3, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %4, align 16, !tbaa !5
  %index.next = add nuw nsw i64 %index, 4
  %5 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %index.next
  %6 = getelementptr inbounds i8, ptr %5, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %5, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %6, align 16, !tbaa !5
  %index.next.1 = add nuw nsw i64 %index, 8
  %7 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %index.next.1
  %8 = getelementptr inbounds i8, ptr %7, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %7, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %8, align 16, !tbaa !5
  %index.next.2 = add nuw nsw i64 %index, 12
  %9 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %index.next.2
  %10 = getelementptr inbounds i8, ptr %9, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %9, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %10, align 16, !tbaa !5
  %index.next.3 = add nuw nsw i64 %index, 16
  %11 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %index.next.3
  %12 = getelementptr inbounds i8, ptr %11, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %11, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %12, align 16, !tbaa !5
  %index.next.4 = add nuw nsw i64 %index, 20
  %13 = icmp eq i64 %index.next.4, 320000
  br i1 %13, label %.preheader35, label %vector.body, !llvm.loop !9

.preheader35:                                     ; preds = %vector.body, %175
  %.02842 = phi i32 [ %176, %175 ], [ 0, %vector.body ]
  br label %.preheader34

.preheader34:                                     ; preds = %.preheader35, %.preheader34
  %indvars.iv47 = phi i64 [ 0, %.preheader35 ], [ %indvars.iv.next48, %.preheader34 ]
  %indvars59 = trunc i64 %indvars.iv47 to i32
  %14 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %indvars.iv47
  %15 = getelementptr inbounds i8, ptr %14, i64 16
  %wide.load = load <2 x double>, ptr %14, align 16, !tbaa !5
  %wide.load75 = load <2 x double>, ptr %15, align 16, !tbaa !5
  %16 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %indvars.iv47
  %17 = getelementptr inbounds i8, ptr %16, i64 16
  %wide.load76 = load <2 x double>, ptr %16, align 16, !tbaa !5
  %wide.load77 = load <2 x double>, ptr %17, align 16, !tbaa !5
  %18 = fadd <2 x double> %wide.load, %wide.load76
  %19 = fadd <2 x double> %wide.load75, %wide.load77
  %20 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv47
  %21 = getelementptr inbounds i8, ptr %20, i64 16
  %wide.load78 = load <2 x double>, ptr %20, align 16, !tbaa !5
  %wide.load79 = load <2 x double>, ptr %21, align 16, !tbaa !5
  %22 = fadd <2 x double> %wide.load78, %18
  %23 = fadd <2 x double> %wide.load79, %19
  store <2 x double> %22, ptr %20, align 16, !tbaa !5
  store <2 x double> %23, ptr %21, align 16, !tbaa !5
  %offset.idx.1 = or disjoint i64 %indvars.iv47, 4
  %24 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.1
  %25 = getelementptr inbounds i8, ptr %24, i64 16
  %wide.load.1 = load <2 x double>, ptr %24, align 16, !tbaa !5
  %wide.load75.1 = load <2 x double>, ptr %25, align 16, !tbaa !5
  %26 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.1
  %27 = getelementptr inbounds i8, ptr %26, i64 16
  %wide.load76.1 = load <2 x double>, ptr %26, align 16, !tbaa !5
  %wide.load77.1 = load <2 x double>, ptr %27, align 16, !tbaa !5
  %28 = fadd <2 x double> %wide.load.1, %wide.load76.1
  %29 = fadd <2 x double> %wide.load75.1, %wide.load77.1
  %30 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.1
  %31 = getelementptr inbounds i8, ptr %30, i64 16
  %wide.load78.1 = load <2 x double>, ptr %30, align 16, !tbaa !5
  %wide.load79.1 = load <2 x double>, ptr %31, align 16, !tbaa !5
  %32 = fadd <2 x double> %wide.load78.1, %28
  %33 = fadd <2 x double> %wide.load79.1, %29
  store <2 x double> %32, ptr %30, align 16, !tbaa !5
  store <2 x double> %33, ptr %31, align 16, !tbaa !5
  %offset.idx.2 = or disjoint i64 %indvars.iv47, 8
  %34 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.2
  %35 = getelementptr inbounds i8, ptr %34, i64 16
  %wide.load.2 = load <2 x double>, ptr %34, align 16, !tbaa !5
  %wide.load75.2 = load <2 x double>, ptr %35, align 16, !tbaa !5
  %36 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.2
  %37 = getelementptr inbounds i8, ptr %36, i64 16
  %wide.load76.2 = load <2 x double>, ptr %36, align 16, !tbaa !5
  %wide.load77.2 = load <2 x double>, ptr %37, align 16, !tbaa !5
  %38 = fadd <2 x double> %wide.load.2, %wide.load76.2
  %39 = fadd <2 x double> %wide.load75.2, %wide.load77.2
  %40 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.2
  %41 = getelementptr inbounds i8, ptr %40, i64 16
  %wide.load78.2 = load <2 x double>, ptr %40, align 16, !tbaa !5
  %wide.load79.2 = load <2 x double>, ptr %41, align 16, !tbaa !5
  %42 = fadd <2 x double> %wide.load78.2, %38
  %43 = fadd <2 x double> %wide.load79.2, %39
  store <2 x double> %42, ptr %40, align 16, !tbaa !5
  store <2 x double> %43, ptr %41, align 16, !tbaa !5
  %offset.idx.3 = or disjoint i64 %indvars.iv47, 12
  %44 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.3
  %45 = getelementptr inbounds i8, ptr %44, i64 16
  %wide.load.3 = load <2 x double>, ptr %44, align 16, !tbaa !5
  %wide.load75.3 = load <2 x double>, ptr %45, align 16, !tbaa !5
  %46 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.3
  %47 = getelementptr inbounds i8, ptr %46, i64 16
  %wide.load76.3 = load <2 x double>, ptr %46, align 16, !tbaa !5
  %wide.load77.3 = load <2 x double>, ptr %47, align 16, !tbaa !5
  %48 = fadd <2 x double> %wide.load.3, %wide.load76.3
  %49 = fadd <2 x double> %wide.load75.3, %wide.load77.3
  %50 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.3
  %51 = getelementptr inbounds i8, ptr %50, i64 16
  %wide.load78.3 = load <2 x double>, ptr %50, align 16, !tbaa !5
  %wide.load79.3 = load <2 x double>, ptr %51, align 16, !tbaa !5
  %52 = fadd <2 x double> %wide.load78.3, %48
  %53 = fadd <2 x double> %wide.load79.3, %49
  store <2 x double> %52, ptr %50, align 16, !tbaa !5
  store <2 x double> %53, ptr %51, align 16, !tbaa !5
  %offset.idx.4 = or disjoint i64 %indvars.iv47, 16
  %54 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.4
  %55 = getelementptr inbounds i8, ptr %54, i64 16
  %wide.load.4 = load <2 x double>, ptr %54, align 16, !tbaa !5
  %wide.load75.4 = load <2 x double>, ptr %55, align 16, !tbaa !5
  %56 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.4
  %57 = getelementptr inbounds i8, ptr %56, i64 16
  %wide.load76.4 = load <2 x double>, ptr %56, align 16, !tbaa !5
  %wide.load77.4 = load <2 x double>, ptr %57, align 16, !tbaa !5
  %58 = fadd <2 x double> %wide.load.4, %wide.load76.4
  %59 = fadd <2 x double> %wide.load75.4, %wide.load77.4
  %60 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.4
  %61 = getelementptr inbounds i8, ptr %60, i64 16
  %wide.load78.4 = load <2 x double>, ptr %60, align 16, !tbaa !5
  %wide.load79.4 = load <2 x double>, ptr %61, align 16, !tbaa !5
  %62 = fadd <2 x double> %wide.load78.4, %58
  %63 = fadd <2 x double> %wide.load79.4, %59
  store <2 x double> %62, ptr %60, align 16, !tbaa !5
  store <2 x double> %63, ptr %61, align 16, !tbaa !5
  %offset.idx.5 = or disjoint i64 %indvars.iv47, 20
  %64 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.5
  %65 = getelementptr inbounds i8, ptr %64, i64 16
  %wide.load.5 = load <2 x double>, ptr %64, align 16, !tbaa !5
  %wide.load75.5 = load <2 x double>, ptr %65, align 16, !tbaa !5
  %66 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.5
  %67 = getelementptr inbounds i8, ptr %66, i64 16
  %wide.load76.5 = load <2 x double>, ptr %66, align 16, !tbaa !5
  %wide.load77.5 = load <2 x double>, ptr %67, align 16, !tbaa !5
  %68 = fadd <2 x double> %wide.load.5, %wide.load76.5
  %69 = fadd <2 x double> %wide.load75.5, %wide.load77.5
  %70 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.5
  %71 = getelementptr inbounds i8, ptr %70, i64 16
  %wide.load78.5 = load <2 x double>, ptr %70, align 16, !tbaa !5
  %wide.load79.5 = load <2 x double>, ptr %71, align 16, !tbaa !5
  %72 = fadd <2 x double> %wide.load78.5, %68
  %73 = fadd <2 x double> %wide.load79.5, %69
  store <2 x double> %72, ptr %70, align 16, !tbaa !5
  store <2 x double> %73, ptr %71, align 16, !tbaa !5
  %offset.idx.6 = or disjoint i64 %indvars.iv47, 24
  %74 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.6
  %75 = getelementptr inbounds i8, ptr %74, i64 16
  %wide.load.6 = load <2 x double>, ptr %74, align 16, !tbaa !5
  %wide.load75.6 = load <2 x double>, ptr %75, align 16, !tbaa !5
  %76 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.6
  %77 = getelementptr inbounds i8, ptr %76, i64 16
  %wide.load76.6 = load <2 x double>, ptr %76, align 16, !tbaa !5
  %wide.load77.6 = load <2 x double>, ptr %77, align 16, !tbaa !5
  %78 = fadd <2 x double> %wide.load.6, %wide.load76.6
  %79 = fadd <2 x double> %wide.load75.6, %wide.load77.6
  %80 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.6
  %81 = getelementptr inbounds i8, ptr %80, i64 16
  %wide.load78.6 = load <2 x double>, ptr %80, align 16, !tbaa !5
  %wide.load79.6 = load <2 x double>, ptr %81, align 16, !tbaa !5
  %82 = fadd <2 x double> %wide.load78.6, %78
  %83 = fadd <2 x double> %wide.load79.6, %79
  store <2 x double> %82, ptr %80, align 16, !tbaa !5
  store <2 x double> %83, ptr %81, align 16, !tbaa !5
  %offset.idx.7 = or disjoint i64 %indvars.iv47, 28
  %84 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.7
  %85 = getelementptr inbounds i8, ptr %84, i64 16
  %wide.load.7 = load <2 x double>, ptr %84, align 16, !tbaa !5
  %wide.load75.7 = load <2 x double>, ptr %85, align 16, !tbaa !5
  %86 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.7
  %87 = getelementptr inbounds i8, ptr %86, i64 16
  %wide.load76.7 = load <2 x double>, ptr %86, align 16, !tbaa !5
  %wide.load77.7 = load <2 x double>, ptr %87, align 16, !tbaa !5
  %88 = fadd <2 x double> %wide.load.7, %wide.load76.7
  %89 = fadd <2 x double> %wide.load75.7, %wide.load77.7
  %90 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.7
  %91 = getelementptr inbounds i8, ptr %90, i64 16
  %wide.load78.7 = load <2 x double>, ptr %90, align 16, !tbaa !5
  %wide.load79.7 = load <2 x double>, ptr %91, align 16, !tbaa !5
  %92 = fadd <2 x double> %wide.load78.7, %88
  %93 = fadd <2 x double> %wide.load79.7, %89
  store <2 x double> %92, ptr %90, align 16, !tbaa !5
  store <2 x double> %93, ptr %91, align 16, !tbaa !5
  %offset.idx.8 = or disjoint i64 %indvars.iv47, 32
  %94 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.8
  %95 = getelementptr inbounds i8, ptr %94, i64 16
  %wide.load.8 = load <2 x double>, ptr %94, align 16, !tbaa !5
  %wide.load75.8 = load <2 x double>, ptr %95, align 16, !tbaa !5
  %96 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.8
  %97 = getelementptr inbounds i8, ptr %96, i64 16
  %wide.load76.8 = load <2 x double>, ptr %96, align 16, !tbaa !5
  %wide.load77.8 = load <2 x double>, ptr %97, align 16, !tbaa !5
  %98 = fadd <2 x double> %wide.load.8, %wide.load76.8
  %99 = fadd <2 x double> %wide.load75.8, %wide.load77.8
  %100 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.8
  %101 = getelementptr inbounds i8, ptr %100, i64 16
  %wide.load78.8 = load <2 x double>, ptr %100, align 16, !tbaa !5
  %wide.load79.8 = load <2 x double>, ptr %101, align 16, !tbaa !5
  %102 = fadd <2 x double> %wide.load78.8, %98
  %103 = fadd <2 x double> %wide.load79.8, %99
  store <2 x double> %102, ptr %100, align 16, !tbaa !5
  store <2 x double> %103, ptr %101, align 16, !tbaa !5
  %offset.idx.9 = or disjoint i64 %indvars.iv47, 36
  %104 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.9
  %105 = getelementptr inbounds i8, ptr %104, i64 16
  %wide.load.9 = load <2 x double>, ptr %104, align 16, !tbaa !5
  %wide.load75.9 = load <2 x double>, ptr %105, align 16, !tbaa !5
  %106 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.9
  %107 = getelementptr inbounds i8, ptr %106, i64 16
  %wide.load76.9 = load <2 x double>, ptr %106, align 16, !tbaa !5
  %wide.load77.9 = load <2 x double>, ptr %107, align 16, !tbaa !5
  %108 = fadd <2 x double> %wide.load.9, %wide.load76.9
  %109 = fadd <2 x double> %wide.load75.9, %wide.load77.9
  %110 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.9
  %111 = getelementptr inbounds i8, ptr %110, i64 16
  %wide.load78.9 = load <2 x double>, ptr %110, align 16, !tbaa !5
  %wide.load79.9 = load <2 x double>, ptr %111, align 16, !tbaa !5
  %112 = fadd <2 x double> %wide.load78.9, %108
  %113 = fadd <2 x double> %wide.load79.9, %109
  store <2 x double> %112, ptr %110, align 16, !tbaa !5
  store <2 x double> %113, ptr %111, align 16, !tbaa !5
  %offset.idx.10 = or disjoint i64 %indvars.iv47, 40
  %114 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.10
  %115 = getelementptr inbounds i8, ptr %114, i64 16
  %wide.load.10 = load <2 x double>, ptr %114, align 16, !tbaa !5
  %wide.load75.10 = load <2 x double>, ptr %115, align 16, !tbaa !5
  %116 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.10
  %117 = getelementptr inbounds i8, ptr %116, i64 16
  %wide.load76.10 = load <2 x double>, ptr %116, align 16, !tbaa !5
  %wide.load77.10 = load <2 x double>, ptr %117, align 16, !tbaa !5
  %118 = fadd <2 x double> %wide.load.10, %wide.load76.10
  %119 = fadd <2 x double> %wide.load75.10, %wide.load77.10
  %120 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.10
  %121 = getelementptr inbounds i8, ptr %120, i64 16
  %wide.load78.10 = load <2 x double>, ptr %120, align 16, !tbaa !5
  %wide.load79.10 = load <2 x double>, ptr %121, align 16, !tbaa !5
  %122 = fadd <2 x double> %wide.load78.10, %118
  %123 = fadd <2 x double> %wide.load79.10, %119
  store <2 x double> %122, ptr %120, align 16, !tbaa !5
  store <2 x double> %123, ptr %121, align 16, !tbaa !5
  %offset.idx.11 = or disjoint i64 %indvars.iv47, 44
  %124 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.11
  %125 = getelementptr inbounds i8, ptr %124, i64 16
  %wide.load.11 = load <2 x double>, ptr %124, align 16, !tbaa !5
  %wide.load75.11 = load <2 x double>, ptr %125, align 16, !tbaa !5
  %126 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.11
  %127 = getelementptr inbounds i8, ptr %126, i64 16
  %wide.load76.11 = load <2 x double>, ptr %126, align 16, !tbaa !5
  %wide.load77.11 = load <2 x double>, ptr %127, align 16, !tbaa !5
  %128 = fadd <2 x double> %wide.load.11, %wide.load76.11
  %129 = fadd <2 x double> %wide.load75.11, %wide.load77.11
  %130 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.11
  %131 = getelementptr inbounds i8, ptr %130, i64 16
  %wide.load78.11 = load <2 x double>, ptr %130, align 16, !tbaa !5
  %wide.load79.11 = load <2 x double>, ptr %131, align 16, !tbaa !5
  %132 = fadd <2 x double> %wide.load78.11, %128
  %133 = fadd <2 x double> %wide.load79.11, %129
  store <2 x double> %132, ptr %130, align 16, !tbaa !5
  store <2 x double> %133, ptr %131, align 16, !tbaa !5
  %offset.idx.12 = or disjoint i64 %indvars.iv47, 48
  %134 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.12
  %135 = getelementptr inbounds i8, ptr %134, i64 16
  %wide.load.12 = load <2 x double>, ptr %134, align 16, !tbaa !5
  %wide.load75.12 = load <2 x double>, ptr %135, align 16, !tbaa !5
  %136 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.12
  %137 = getelementptr inbounds i8, ptr %136, i64 16
  %wide.load76.12 = load <2 x double>, ptr %136, align 16, !tbaa !5
  %wide.load77.12 = load <2 x double>, ptr %137, align 16, !tbaa !5
  %138 = fadd <2 x double> %wide.load.12, %wide.load76.12
  %139 = fadd <2 x double> %wide.load75.12, %wide.load77.12
  %140 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.12
  %141 = getelementptr inbounds i8, ptr %140, i64 16
  %wide.load78.12 = load <2 x double>, ptr %140, align 16, !tbaa !5
  %wide.load79.12 = load <2 x double>, ptr %141, align 16, !tbaa !5
  %142 = fadd <2 x double> %wide.load78.12, %138
  %143 = fadd <2 x double> %wide.load79.12, %139
  store <2 x double> %142, ptr %140, align 16, !tbaa !5
  store <2 x double> %143, ptr %141, align 16, !tbaa !5
  %offset.idx.13 = or disjoint i64 %indvars.iv47, 52
  %144 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.13
  %145 = getelementptr inbounds i8, ptr %144, i64 16
  %wide.load.13 = load <2 x double>, ptr %144, align 16, !tbaa !5
  %wide.load75.13 = load <2 x double>, ptr %145, align 16, !tbaa !5
  %146 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.13
  %147 = getelementptr inbounds i8, ptr %146, i64 16
  %wide.load76.13 = load <2 x double>, ptr %146, align 16, !tbaa !5
  %wide.load77.13 = load <2 x double>, ptr %147, align 16, !tbaa !5
  %148 = fadd <2 x double> %wide.load.13, %wide.load76.13
  %149 = fadd <2 x double> %wide.load75.13, %wide.load77.13
  %150 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.13
  %151 = getelementptr inbounds i8, ptr %150, i64 16
  %wide.load78.13 = load <2 x double>, ptr %150, align 16, !tbaa !5
  %wide.load79.13 = load <2 x double>, ptr %151, align 16, !tbaa !5
  %152 = fadd <2 x double> %wide.load78.13, %148
  %153 = fadd <2 x double> %wide.load79.13, %149
  store <2 x double> %152, ptr %150, align 16, !tbaa !5
  store <2 x double> %153, ptr %151, align 16, !tbaa !5
  %offset.idx.14 = or disjoint i64 %indvars.iv47, 56
  %154 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.14
  %155 = getelementptr inbounds i8, ptr %154, i64 16
  %wide.load.14 = load <2 x double>, ptr %154, align 16, !tbaa !5
  %wide.load75.14 = load <2 x double>, ptr %155, align 16, !tbaa !5
  %156 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.14
  %157 = getelementptr inbounds i8, ptr %156, i64 16
  %wide.load76.14 = load <2 x double>, ptr %156, align 16, !tbaa !5
  %wide.load77.14 = load <2 x double>, ptr %157, align 16, !tbaa !5
  %158 = fadd <2 x double> %wide.load.14, %wide.load76.14
  %159 = fadd <2 x double> %wide.load75.14, %wide.load77.14
  %160 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.14
  %161 = getelementptr inbounds i8, ptr %160, i64 16
  %wide.load78.14 = load <2 x double>, ptr %160, align 16, !tbaa !5
  %wide.load79.14 = load <2 x double>, ptr %161, align 16, !tbaa !5
  %162 = fadd <2 x double> %wide.load78.14, %158
  %163 = fadd <2 x double> %wide.load79.14, %159
  store <2 x double> %162, ptr %160, align 16, !tbaa !5
  store <2 x double> %163, ptr %161, align 16, !tbaa !5
  %offset.idx.15 = or disjoint i64 %indvars.iv47, 60
  %164 = getelementptr inbounds [320000 x double], ptr %1, i64 0, i64 %offset.idx.15
  %165 = getelementptr inbounds i8, ptr %164, i64 16
  %wide.load.15 = load <2 x double>, ptr %164, align 16, !tbaa !5
  %wide.load75.15 = load <2 x double>, ptr %165, align 16, !tbaa !5
  %166 = getelementptr inbounds [320000 x double], ptr %2, i64 0, i64 %offset.idx.15
  %167 = getelementptr inbounds i8, ptr %166, i64 16
  %wide.load76.15 = load <2 x double>, ptr %166, align 16, !tbaa !5
  %wide.load77.15 = load <2 x double>, ptr %167, align 16, !tbaa !5
  %168 = fadd <2 x double> %wide.load.15, %wide.load76.15
  %169 = fadd <2 x double> %wide.load75.15, %wide.load77.15
  %170 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %offset.idx.15
  %171 = getelementptr inbounds i8, ptr %170, i64 16
  %wide.load78.15 = load <2 x double>, ptr %170, align 16, !tbaa !5
  %wide.load79.15 = load <2 x double>, ptr %171, align 16, !tbaa !5
  %172 = fadd <2 x double> %wide.load78.15, %168
  %173 = fadd <2 x double> %wide.load79.15, %169
  store <2 x double> %172, ptr %170, align 16, !tbaa !5
  store <2 x double> %173, ptr %171, align 16, !tbaa !5
  %indvars.iv.next48 = add nuw nsw i64 %indvars.iv47, 64
  %174 = icmp ult i32 %indvars59, 319936
  br i1 %174, label %.preheader34, label %175, !llvm.loop !13

175:                                              ; preds = %.preheader34
  %176 = add nuw nsw i32 %.02842, 1
  %exitcond60.not = icmp eq i32 %176, 600
  br i1 %exitcond60.not, label %.preheader, label %.preheader35, !llvm.loop !14

.preheader:                                       ; preds = %175, %192
  %indvars.iv61 = phi i64 [ %indvars.iv.next62.4, %192 ], [ 0, %175 ]
  %177 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv61
  %178 = load double, ptr %177, align 8, !tbaa !5
  %179 = fcmp une double %178, 6.000000e+02
  br i1 %179, label %193, label %.preheader.1

.preheader.1:                                     ; preds = %.preheader
  %indvars.iv.next62 = add nuw nsw i64 %indvars.iv61, 1
  %180 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv.next62
  %181 = load double, ptr %180, align 8, !tbaa !5
  %182 = fcmp une double %181, 6.000000e+02
  br i1 %182, label %193, label %.preheader.2

.preheader.2:                                     ; preds = %.preheader.1
  %indvars.iv.next62.1 = add nuw nsw i64 %indvars.iv61, 2
  %183 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv.next62.1
  %184 = load double, ptr %183, align 8, !tbaa !5
  %185 = fcmp une double %184, 6.000000e+02
  br i1 %185, label %193, label %.preheader.3

.preheader.3:                                     ; preds = %.preheader.2
  %indvars.iv.next62.2 = add nuw nsw i64 %indvars.iv61, 3
  %186 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv.next62.2
  %187 = load double, ptr %186, align 8, !tbaa !5
  %188 = fcmp une double %187, 6.000000e+02
  br i1 %188, label %193, label %.preheader.4

.preheader.4:                                     ; preds = %.preheader.3
  %indvars.iv.next62.3 = add nuw nsw i64 %indvars.iv61, 4
  %189 = getelementptr inbounds [320000 x double], ptr %0, i64 0, i64 %indvars.iv.next62.3
  %190 = load double, ptr %189, align 8, !tbaa !5
  %191 = fcmp une double %190, 6.000000e+02
  br i1 %191, label %193, label %192

192:                                              ; preds = %.preheader.4
  %indvars.iv.next62.4 = add nuw nsw i64 %indvars.iv61, 5
  %exitcond64.4 = icmp eq i64 %indvars.iv.next62.4, 320000
  br i1 %exitcond64.4, label %.critedge, label %.preheader, !llvm.loop !15

193:                                              ; preds = %.preheader.4, %.preheader.3, %.preheader.2, %.preheader.1, %.preheader
  %indvars.iv61.lcssa = phi i64 [ %indvars.iv61, %.preheader ], [ %indvars.iv.next62, %.preheader.1 ], [ %indvars.iv.next62.1, %.preheader.2 ], [ %indvars.iv.next62.2, %.preheader.3 ], [ %indvars.iv.next62.3, %.preheader.4 ]
  %.lcssa = phi double [ %178, %.preheader ], [ %181, %.preheader.1 ], [ %184, %.preheader.2 ], [ %187, %.preheader.3 ], [ %190, %.preheader.4 ]
  %194 = trunc nuw nsw i64 %indvars.iv61.lcssa to i32
  %195 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, i32 noundef %194, double noundef 3.000000e+03, double noundef %.lcssa)
  br label %.critedge

.critedge:                                        ; preds = %192, %193
  %.str.2.sink = phi ptr [ @.str.1, %193 ], [ @.str.2, %192 ]
  %.029 = phi i32 [ 1, %193 ], [ 0, %192 ]
  %196 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) %.str.2.sink)
  call void @llvm.lifetime.end.p0(i64 2560000, ptr nonnull %2) #4
  call void @llvm.lifetime.end.p0(i64 2560000, ptr nonnull %1) #4
  call void @llvm.lifetime.end.p0(i64 2560000, ptr nonnull %0) #4
  ret i32 %.029
}

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

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

; Function Attrs: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) local_unnamed_addr #2

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

attributes #0 = { nofree 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 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nofree 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 = { nocallback nofree nounwind willreturn memory(argmem: write) }
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 = !{!"double", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10, !11, !12}
!10 = !{!"llvm.loop.mustprogress"}
!11 = !{!"llvm.loop.isvectorized", i32 1}
!12 = !{!"llvm.loop.unroll.runtime.disable"}
!13 = distinct !{!13, !10}
!14 = distinct !{!14, !10}
!15 = distinct !{!15, !10}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopInstSimplifyPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,SROAPass,SimplifyCFGPass,TailCallElimPass