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

; 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 [16 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.4 = 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 [960 x double], align 16
  %4 = alloca [960 x double], align 16
  %5 = alloca [960 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 7680, ptr %3) #3
  call void @llvm.lifetime.start.p0(i64 7680, ptr %4) #3
  call void @llvm.lifetime.start.p0(i64 7680, 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, 960
  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 [960 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 [960 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 [960 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 = %102, %32
  %35 = load i32, ptr %10, align 4, !tbaa !5
  %36 = icmp slt i32 %35, 1
  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 %105

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 = %97, %38
  %40 = load i32, ptr %12, align 4, !tbaa !5
  %41 = icmp slt i32 %40, 256
  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 %101

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 = %86, %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 %89

52:                                               ; preds = %45
  %53 = load i32, ptr %13, align 4, !tbaa !5
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds [960 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 [960 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 [960 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
  %67 = load i32, ptr %13, align 4, !tbaa !5
  %68 = load i32, ptr %12, align 4, !tbaa !5
  %69 = add nsw i32 %68, 3
  %70 = icmp slt i32 %67, %69
  br i1 %70, label %71, label %85

71:                                               ; preds = %52
  %72 = load i32, ptr %13, align 4, !tbaa !5
  %73 = sext i32 %72 to i64
  %74 = getelementptr inbounds [960 x double], ptr %4, i64 0, i64 %73
  %75 = load double, ptr %74, align 8, !tbaa !9
  %76 = load i32, ptr %13, align 4, !tbaa !5
  %77 = sext i32 %76 to i64
  %78 = getelementptr inbounds [960 x double], ptr %5, i64 0, i64 %77
  %79 = load double, ptr %78, align 8, !tbaa !9
  %80 = load i32, ptr %13, align 4, !tbaa !5
  %81 = sext i32 %80 to i64
  %82 = getelementptr inbounds [960 x double], ptr %3, i64 0, i64 %81
  %83 = load double, ptr %82, align 8, !tbaa !9
  %84 = call i32 (ptr, ...) @printf(ptr noundef @.str, double noundef %75, double noundef %79, double noundef %83)
  br label %85

85:                                               ; preds = %71, %52
  br label %86

86:                                               ; preds = %85
  %87 = load i32, ptr %13, align 4, !tbaa !5
  %88 = add nsw i32 %87, 1
  store i32 %88, ptr %13, align 4, !tbaa !5
  br label %45, !llvm.loop !13

89:                                               ; preds = %51
  %90 = getelementptr inbounds [960 x double], ptr %4, i64 0, i64 5
  %91 = load double, ptr %90, align 8, !tbaa !9
  %92 = getelementptr inbounds [960 x double], ptr %5, i64 0, i64 5
  %93 = load double, ptr %92, align 8, !tbaa !9
  %94 = getelementptr inbounds [960 x double], ptr %3, i64 0, i64 5
  %95 = load double, ptr %94, align 8, !tbaa !9
  %96 = call i32 (ptr, ...) @printf(ptr noundef @.str.1, double noundef %91, double noundef %93, double noundef %95)
  br label %97

97:                                               ; preds = %89
  %98 = load i32, ptr %9, align 4, !tbaa !5
  %99 = load i32, ptr %12, align 4, !tbaa !5
  %100 = add nsw i32 %99, %98
  store i32 %100, ptr %12, align 4, !tbaa !5
  br label %39, !llvm.loop !14

101:                                              ; preds = %42
  br label %102

102:                                              ; preds = %101
  %103 = load i32, ptr %10, align 4, !tbaa !5
  %104 = add nsw i32 %103, 1
  store i32 %104, ptr %10, align 4, !tbaa !5
  br label %34, !llvm.loop !15

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

106:                                              ; preds = %124, %105
  %107 = load i32, ptr %14, align 4, !tbaa !5
  %108 = icmp slt i32 %107, 256
  br i1 %108, label %110, label %109

109:                                              ; preds = %106
  store i32 14, ptr %11, align 4
  br label %127

110:                                              ; preds = %106
  %111 = load i32, ptr %14, align 4, !tbaa !5
  %112 = sext i32 %111 to i64
  %113 = getelementptr inbounds [960 x double], ptr %3, i64 0, i64 %112
  %114 = load double, ptr %113, align 8, !tbaa !9
  %115 = fcmp une double %114, 1.000000e+00
  br i1 %115, label %116, label %123

116:                                              ; preds = %110
  %117 = load i32, ptr %14, align 4, !tbaa !5
  %118 = load i32, ptr %14, align 4, !tbaa !5
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds [960 x double], ptr %3, i64 0, i64 %119
  %121 = load double, ptr %120, align 8, !tbaa !9
  %122 = call i32 (ptr, ...) @printf(ptr noundef @.str.2, i32 noundef %117, double noundef 1.000000e+00, double noundef %121)
  store i32 1, ptr %2, align 4, !tbaa !5
  store i32 14, ptr %11, align 4
  br label %127

123:                                              ; preds = %110
  br label %124

124:                                              ; preds = %123
  %125 = load i32, ptr %14, align 4, !tbaa !5
  %126 = add nsw i32 %125, 1
  store i32 %126, ptr %14, align 4, !tbaa !5
  br label %106, !llvm.loop !16

127:                                              ; preds = %116, %109
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  br label %128

128:                                              ; preds = %127
  %129 = load i32, ptr %2, align 4, !tbaa !5
  %130 = icmp ne i32 %129, 0
  br i1 %130, label %131, label %133

131:                                              ; preds = %128
  %132 = call i32 (ptr, ...) @printf(ptr noundef @.str.3)
  store i32 1, ptr %1, align 4
  store i32 1, ptr %11, align 4
  br label %135

133:                                              ; preds = %128
  %134 = call i32 (ptr, ...) @printf(ptr noundef @.str.4)
  store i32 0, ptr %1, align 4
  store i32 1, ptr %11, align 4
  br label %135

135:                                              ; preds = %133, %131
  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 7680, ptr %5) #3
  call void @llvm.lifetime.end.p0(i64 7680, ptr %4) #3
  call void @llvm.lifetime.end.p0(i64 7680, ptr %3) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #3
  %136 = load i32, ptr %1, align 4
  ret i32 %136
}

; 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 [16 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.4 = 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 [960 x double], align 16
  %1 = alloca [960 x double], align 16
  call void @llvm.lifetime.start.p0(i64 7680, ptr nonnull %0) #4
  call void @llvm.lifetime.start.p0(i64 7680, ptr nonnull %1) #4
  %2 = getelementptr inbounds i8, ptr %0, i64 16
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(7680) %2, i8 0, i64 7664, i1 false), !tbaa !5
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next.5, %vector.body ]
  %3 = getelementptr inbounds [960 x double], ptr %1, 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 = or disjoint i64 %index, 4
  %5 = getelementptr inbounds [960 x double], ptr %1, 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 [960 x double], ptr %1, 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 [960 x double], ptr %1, 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 [960 x double], ptr %1, 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 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next.4
  %14 = getelementptr inbounds i8, ptr %13, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %13, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %14, align 16, !tbaa !5
  %index.next.5 = add nuw nsw i64 %index, 24
  %15 = icmp eq i64 %index.next.5, 960
  br i1 %15, label %.peel.next62, label %vector.body, !llvm.loop !9

.peel.next62:                                     ; preds = %vector.body
  %16 = getelementptr inbounds i8, ptr %1, i64 40
  %17 = load double, ptr %16, align 8
  %18 = getelementptr inbounds i8, ptr %0, i64 40
  %19 = load double, ptr %1, align 16, !tbaa !5
  %20 = fadd double %19, 0.000000e+00
  store double %20, ptr %0, align 16, !tbaa !5
  %21 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %19, double noundef %20)
  %22 = getelementptr inbounds i8, ptr %1, i64 8
  %23 = load double, ptr %22, align 8, !tbaa !5
  %24 = fadd double %23, 0.000000e+00
  %25 = getelementptr inbounds i8, ptr %0, i64 8
  store double %24, ptr %25, align 8, !tbaa !5
  %26 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %23, double noundef %24)
  %27 = getelementptr inbounds i8, ptr %1, i64 16
  %28 = load double, ptr %27, align 16, !tbaa !5
  %29 = fadd double %28, 0.000000e+00
  %30 = getelementptr inbounds i8, ptr %0, i64 16
  store double %29, ptr %30, align 16, !tbaa !5
  %31 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %28, double noundef %29)
  %32 = getelementptr inbounds i8, ptr %1, i64 24
  %33 = getelementptr inbounds i8, ptr %1, i64 40
  %wide.load98 = load <2 x double>, ptr %32, align 8, !tbaa !5
  %wide.load99 = load <2 x double>, ptr %33, align 8, !tbaa !5
  %34 = fadd <2 x double> %wide.load98, zeroinitializer
  %35 = fadd <2 x double> %wide.load99, zeroinitializer
  %36 = getelementptr inbounds i8, ptr %0, i64 24
  %37 = getelementptr inbounds i8, ptr %0, i64 40
  %wide.load100 = load <2 x double>, ptr %36, align 8, !tbaa !5
  %wide.load101 = load <2 x double>, ptr %37, align 8, !tbaa !5
  %38 = fadd <2 x double> %wide.load100, %34
  %39 = fadd <2 x double> %wide.load101, %35
  store <2 x double> %38, ptr %36, align 8, !tbaa !5
  store <2 x double> %39, ptr %37, align 8, !tbaa !5
  %40 = getelementptr inbounds i8, ptr %1, i64 56
  %41 = getelementptr inbounds i8, ptr %1, i64 72
  %wide.load98.1 = load <2 x double>, ptr %40, align 8, !tbaa !5
  %wide.load99.1 = load <2 x double>, ptr %41, align 8, !tbaa !5
  %42 = fadd <2 x double> %wide.load98.1, zeroinitializer
  %43 = fadd <2 x double> %wide.load99.1, zeroinitializer
  %44 = getelementptr inbounds i8, ptr %0, i64 56
  %45 = getelementptr inbounds i8, ptr %0, i64 72
  %wide.load100.1 = load <2 x double>, ptr %44, align 8, !tbaa !5
  %wide.load101.1 = load <2 x double>, ptr %45, align 8, !tbaa !5
  %46 = fadd <2 x double> %wide.load100.1, %42
  %47 = fadd <2 x double> %wide.load101.1, %43
  store <2 x double> %46, ptr %44, align 8, !tbaa !5
  store <2 x double> %47, ptr %45, align 8, !tbaa !5
  %48 = getelementptr inbounds i8, ptr %1, i64 88
  %49 = getelementptr inbounds i8, ptr %1, i64 104
  %wide.load98.2 = load <2 x double>, ptr %48, align 8, !tbaa !5
  %wide.load99.2 = load <2 x double>, ptr %49, align 8, !tbaa !5
  %50 = fadd <2 x double> %wide.load98.2, zeroinitializer
  %51 = fadd <2 x double> %wide.load99.2, zeroinitializer
  %52 = getelementptr inbounds i8, ptr %0, i64 88
  %53 = getelementptr inbounds i8, ptr %0, i64 104
  %wide.load100.2 = load <2 x double>, ptr %52, align 8, !tbaa !5
  %wide.load101.2 = load <2 x double>, ptr %53, align 8, !tbaa !5
  %54 = fadd <2 x double> %wide.load100.2, %50
  %55 = fadd <2 x double> %wide.load101.2, %51
  store <2 x double> %54, ptr %52, align 8, !tbaa !5
  store <2 x double> %55, ptr %53, align 8, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %1, i64 120
  %57 = getelementptr inbounds i8, ptr %1, i64 136
  %wide.load98.3 = load <2 x double>, ptr %56, align 8, !tbaa !5
  %wide.load99.3 = load <2 x double>, ptr %57, align 8, !tbaa !5
  %58 = fadd <2 x double> %wide.load98.3, zeroinitializer
  %59 = fadd <2 x double> %wide.load99.3, zeroinitializer
  %60 = getelementptr inbounds i8, ptr %0, i64 120
  %61 = getelementptr inbounds i8, ptr %0, i64 136
  %wide.load100.3 = load <2 x double>, ptr %60, align 8, !tbaa !5
  %wide.load101.3 = load <2 x double>, ptr %61, align 8, !tbaa !5
  %62 = fadd <2 x double> %wide.load100.3, %58
  %63 = fadd <2 x double> %wide.load101.3, %59
  store <2 x double> %62, ptr %60, align 8, !tbaa !5
  store <2 x double> %63, ptr %61, align 8, !tbaa !5
  %64 = getelementptr inbounds i8, ptr %1, i64 152
  %65 = getelementptr inbounds i8, ptr %1, i64 168
  %wide.load98.4 = load <2 x double>, ptr %64, align 8, !tbaa !5
  %wide.load99.4 = load <2 x double>, ptr %65, align 8, !tbaa !5
  %66 = fadd <2 x double> %wide.load98.4, zeroinitializer
  %67 = fadd <2 x double> %wide.load99.4, zeroinitializer
  %68 = getelementptr inbounds i8, ptr %0, i64 152
  %69 = getelementptr inbounds i8, ptr %0, i64 168
  %wide.load100.4 = load <2 x double>, ptr %68, align 8, !tbaa !5
  %wide.load101.4 = load <2 x double>, ptr %69, align 8, !tbaa !5
  %70 = fadd <2 x double> %wide.load100.4, %66
  %71 = fadd <2 x double> %wide.load101.4, %67
  store <2 x double> %70, ptr %68, align 8, !tbaa !5
  store <2 x double> %71, ptr %69, align 8, !tbaa !5
  %72 = getelementptr inbounds i8, ptr %1, i64 184
  %73 = getelementptr inbounds i8, ptr %1, i64 200
  %wide.load98.5 = load <2 x double>, ptr %72, align 8, !tbaa !5
  %wide.load99.5 = load <2 x double>, ptr %73, align 8, !tbaa !5
  %74 = fadd <2 x double> %wide.load98.5, zeroinitializer
  %75 = fadd <2 x double> %wide.load99.5, zeroinitializer
  %76 = getelementptr inbounds i8, ptr %0, i64 184
  %77 = getelementptr inbounds i8, ptr %0, i64 200
  %wide.load100.5 = load <2 x double>, ptr %76, align 8, !tbaa !5
  %wide.load101.5 = load <2 x double>, ptr %77, align 8, !tbaa !5
  %78 = fadd <2 x double> %wide.load100.5, %74
  %79 = fadd <2 x double> %wide.load101.5, %75
  store <2 x double> %78, ptr %76, align 8, !tbaa !5
  store <2 x double> %79, ptr %77, align 8, !tbaa !5
  %80 = getelementptr inbounds i8, ptr %1, i64 216
  %81 = getelementptr inbounds i8, ptr %1, i64 232
  %wide.load98.6 = load <2 x double>, ptr %80, align 8, !tbaa !5
  %wide.load99.6 = load <2 x double>, ptr %81, align 8, !tbaa !5
  %82 = fadd <2 x double> %wide.load98.6, zeroinitializer
  %83 = fadd <2 x double> %wide.load99.6, zeroinitializer
  %84 = getelementptr inbounds i8, ptr %0, i64 216
  %85 = getelementptr inbounds i8, ptr %0, i64 232
  %wide.load100.6 = load <2 x double>, ptr %84, align 8, !tbaa !5
  %wide.load101.6 = load <2 x double>, ptr %85, align 8, !tbaa !5
  %86 = fadd <2 x double> %wide.load100.6, %82
  %87 = fadd <2 x double> %wide.load101.6, %83
  store <2 x double> %86, ptr %84, align 8, !tbaa !5
  store <2 x double> %87, ptr %85, align 8, !tbaa !5
  %88 = getelementptr inbounds i8, ptr %1, i64 248
  %89 = getelementptr inbounds i8, ptr %1, i64 264
  %wide.load98.7 = load <2 x double>, ptr %88, align 8, !tbaa !5
  %wide.load99.7 = load <2 x double>, ptr %89, align 8, !tbaa !5
  %90 = fadd <2 x double> %wide.load98.7, zeroinitializer
  %91 = fadd <2 x double> %wide.load99.7, zeroinitializer
  %92 = getelementptr inbounds i8, ptr %0, i64 248
  %93 = getelementptr inbounds i8, ptr %0, i64 264
  %wide.load100.7 = load <2 x double>, ptr %92, align 8, !tbaa !5
  %wide.load101.7 = load <2 x double>, ptr %93, align 8, !tbaa !5
  %94 = fadd <2 x double> %wide.load100.7, %90
  %95 = fadd <2 x double> %wide.load101.7, %91
  store <2 x double> %94, ptr %92, align 8, !tbaa !5
  store <2 x double> %95, ptr %93, align 8, !tbaa !5
  %96 = getelementptr inbounds i8, ptr %1, i64 280
  %97 = getelementptr inbounds i8, ptr %1, i64 296
  %wide.load98.8 = load <2 x double>, ptr %96, align 8, !tbaa !5
  %wide.load99.8 = load <2 x double>, ptr %97, align 8, !tbaa !5
  %98 = fadd <2 x double> %wide.load98.8, zeroinitializer
  %99 = fadd <2 x double> %wide.load99.8, zeroinitializer
  %100 = getelementptr inbounds i8, ptr %0, i64 280
  %101 = getelementptr inbounds i8, ptr %0, i64 296
  %wide.load100.8 = load <2 x double>, ptr %100, align 8, !tbaa !5
  %wide.load101.8 = load <2 x double>, ptr %101, align 8, !tbaa !5
  %102 = fadd <2 x double> %wide.load100.8, %98
  %103 = fadd <2 x double> %wide.load101.8, %99
  store <2 x double> %102, ptr %100, align 8, !tbaa !5
  store <2 x double> %103, ptr %101, align 8, !tbaa !5
  %104 = getelementptr inbounds i8, ptr %1, i64 312
  %105 = getelementptr inbounds i8, ptr %1, i64 328
  %wide.load98.9 = load <2 x double>, ptr %104, align 8, !tbaa !5
  %wide.load99.9 = load <2 x double>, ptr %105, align 8, !tbaa !5
  %106 = fadd <2 x double> %wide.load98.9, zeroinitializer
  %107 = fadd <2 x double> %wide.load99.9, zeroinitializer
  %108 = getelementptr inbounds i8, ptr %0, i64 312
  %109 = getelementptr inbounds i8, ptr %0, i64 328
  %wide.load100.9 = load <2 x double>, ptr %108, align 8, !tbaa !5
  %wide.load101.9 = load <2 x double>, ptr %109, align 8, !tbaa !5
  %110 = fadd <2 x double> %wide.load100.9, %106
  %111 = fadd <2 x double> %wide.load101.9, %107
  store <2 x double> %110, ptr %108, align 8, !tbaa !5
  store <2 x double> %111, ptr %109, align 8, !tbaa !5
  %112 = getelementptr inbounds i8, ptr %1, i64 344
  %113 = getelementptr inbounds i8, ptr %1, i64 360
  %wide.load98.10 = load <2 x double>, ptr %112, align 8, !tbaa !5
  %wide.load99.10 = load <2 x double>, ptr %113, align 8, !tbaa !5
  %114 = fadd <2 x double> %wide.load98.10, zeroinitializer
  %115 = fadd <2 x double> %wide.load99.10, zeroinitializer
  %116 = getelementptr inbounds i8, ptr %0, i64 344
  %117 = getelementptr inbounds i8, ptr %0, i64 360
  %wide.load100.10 = load <2 x double>, ptr %116, align 8, !tbaa !5
  %wide.load101.10 = load <2 x double>, ptr %117, align 8, !tbaa !5
  %118 = fadd <2 x double> %wide.load100.10, %114
  %119 = fadd <2 x double> %wide.load101.10, %115
  store <2 x double> %118, ptr %116, align 8, !tbaa !5
  store <2 x double> %119, ptr %117, align 8, !tbaa !5
  %120 = getelementptr inbounds i8, ptr %1, i64 376
  %121 = getelementptr inbounds i8, ptr %1, i64 392
  %wide.load98.11 = load <2 x double>, ptr %120, align 8, !tbaa !5
  %wide.load99.11 = load <2 x double>, ptr %121, align 8, !tbaa !5
  %122 = fadd <2 x double> %wide.load98.11, zeroinitializer
  %123 = fadd <2 x double> %wide.load99.11, zeroinitializer
  %124 = getelementptr inbounds i8, ptr %0, i64 376
  %125 = getelementptr inbounds i8, ptr %0, i64 392
  %wide.load100.11 = load <2 x double>, ptr %124, align 8, !tbaa !5
  %wide.load101.11 = load <2 x double>, ptr %125, align 8, !tbaa !5
  %126 = fadd <2 x double> %wide.load100.11, %122
  %127 = fadd <2 x double> %wide.load101.11, %123
  store <2 x double> %126, ptr %124, align 8, !tbaa !5
  store <2 x double> %127, ptr %125, align 8, !tbaa !5
  %128 = getelementptr inbounds i8, ptr %1, i64 408
  %129 = getelementptr inbounds i8, ptr %1, i64 424
  %wide.load98.12 = load <2 x double>, ptr %128, align 8, !tbaa !5
  %wide.load99.12 = load <2 x double>, ptr %129, align 8, !tbaa !5
  %130 = fadd <2 x double> %wide.load98.12, zeroinitializer
  %131 = fadd <2 x double> %wide.load99.12, zeroinitializer
  %132 = getelementptr inbounds i8, ptr %0, i64 408
  %133 = getelementptr inbounds i8, ptr %0, i64 424
  %wide.load100.12 = load <2 x double>, ptr %132, align 8, !tbaa !5
  %wide.load101.12 = load <2 x double>, ptr %133, align 8, !tbaa !5
  %134 = fadd <2 x double> %wide.load100.12, %130
  %135 = fadd <2 x double> %wide.load101.12, %131
  store <2 x double> %134, ptr %132, align 8, !tbaa !5
  store <2 x double> %135, ptr %133, align 8, !tbaa !5
  %136 = getelementptr inbounds i8, ptr %1, i64 440
  %137 = getelementptr inbounds i8, ptr %1, i64 456
  %wide.load98.13 = load <2 x double>, ptr %136, align 8, !tbaa !5
  %wide.load99.13 = load <2 x double>, ptr %137, align 8, !tbaa !5
  %138 = fadd <2 x double> %wide.load98.13, zeroinitializer
  %139 = fadd <2 x double> %wide.load99.13, zeroinitializer
  %140 = getelementptr inbounds i8, ptr %0, i64 440
  %141 = getelementptr inbounds i8, ptr %0, i64 456
  %wide.load100.13 = load <2 x double>, ptr %140, align 8, !tbaa !5
  %wide.load101.13 = load <2 x double>, ptr %141, align 8, !tbaa !5
  %142 = fadd <2 x double> %wide.load100.13, %138
  %143 = fadd <2 x double> %wide.load101.13, %139
  store <2 x double> %142, ptr %140, align 8, !tbaa !5
  store <2 x double> %143, ptr %141, align 8, !tbaa !5
  %144 = getelementptr inbounds i8, ptr %1, i64 472
  %145 = getelementptr inbounds i8, ptr %1, i64 488
  %wide.load98.14 = load <2 x double>, ptr %144, align 8, !tbaa !5
  %wide.load99.14 = load <2 x double>, ptr %145, align 8, !tbaa !5
  %146 = fadd <2 x double> %wide.load98.14, zeroinitializer
  %147 = fadd <2 x double> %wide.load99.14, zeroinitializer
  %148 = getelementptr inbounds i8, ptr %0, i64 472
  %149 = getelementptr inbounds i8, ptr %0, i64 488
  %wide.load100.14 = load <2 x double>, ptr %148, align 8, !tbaa !5
  %wide.load101.14 = load <2 x double>, ptr %149, align 8, !tbaa !5
  %150 = fadd <2 x double> %wide.load100.14, %146
  %151 = fadd <2 x double> %wide.load101.14, %147
  store <2 x double> %150, ptr %148, align 8, !tbaa !5
  store <2 x double> %151, ptr %149, align 8, !tbaa !5
  %152 = getelementptr inbounds i8, ptr %1, i64 504
  %153 = load double, ptr %152, align 8, !tbaa !5
  %154 = fadd double %153, 0.000000e+00
  %155 = getelementptr inbounds i8, ptr %0, i64 504
  %156 = load double, ptr %155, align 8, !tbaa !5
  %157 = fadd double %156, %154
  store double %157, ptr %155, align 8, !tbaa !5
  %.phi.trans.insert = getelementptr inbounds i8, ptr %0, i64 512
  %.pre77 = load double, ptr %.phi.trans.insert, align 16, !tbaa !5
  %.pre = load double, ptr %18, align 8, !tbaa !5
  %158 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, double noundef 0.000000e+00, double noundef %17, double noundef %.pre)
  %159 = getelementptr inbounds i8, ptr %1, i64 512
  %160 = load double, ptr %159, align 16, !tbaa !5
  %161 = fadd double %160, 0.000000e+00
  %162 = getelementptr inbounds i8, ptr %0, i64 512
  %163 = fadd double %.pre77, %161
  store double %163, ptr %162, align 16, !tbaa !5
  %164 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %160, double noundef %163)
  %165 = getelementptr inbounds i8, ptr %1, i64 520
  %166 = load double, ptr %165, align 8, !tbaa !5
  %167 = fadd double %166, 0.000000e+00
  %168 = getelementptr inbounds i8, ptr %0, i64 520
  %169 = load double, ptr %168, align 8, !tbaa !5
  %170 = fadd double %169, %167
  store double %170, ptr %168, align 8, !tbaa !5
  %171 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %166, double noundef %170)
  %172 = getelementptr inbounds i8, ptr %1, i64 528
  %173 = load double, ptr %172, align 16, !tbaa !5
  %174 = fadd double %173, 0.000000e+00
  %175 = getelementptr inbounds i8, ptr %0, i64 528
  %176 = load double, ptr %175, align 16, !tbaa !5
  %177 = fadd double %176, %174
  store double %177, ptr %175, align 16, !tbaa !5
  %178 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %173, double noundef %177)
  %179 = getelementptr inbounds i8, ptr %1, i64 536
  %180 = getelementptr inbounds i8, ptr %1, i64 552
  %wide.load112 = load <2 x double>, ptr %179, align 8, !tbaa !5
  %wide.load113 = load <2 x double>, ptr %180, align 8, !tbaa !5
  %181 = fadd <2 x double> %wide.load112, zeroinitializer
  %182 = fadd <2 x double> %wide.load113, zeroinitializer
  %183 = getelementptr inbounds i8, ptr %0, i64 536
  %184 = getelementptr inbounds i8, ptr %0, i64 552
  %wide.load114 = load <2 x double>, ptr %183, align 8, !tbaa !5
  %wide.load115 = load <2 x double>, ptr %184, align 8, !tbaa !5
  %185 = fadd <2 x double> %wide.load114, %181
  %186 = fadd <2 x double> %wide.load115, %182
  store <2 x double> %185, ptr %183, align 8, !tbaa !5
  store <2 x double> %186, ptr %184, align 8, !tbaa !5
  %187 = getelementptr inbounds i8, ptr %1, i64 568
  %188 = getelementptr inbounds i8, ptr %1, i64 584
  %wide.load112.1 = load <2 x double>, ptr %187, align 8, !tbaa !5
  %wide.load113.1 = load <2 x double>, ptr %188, align 8, !tbaa !5
  %189 = fadd <2 x double> %wide.load112.1, zeroinitializer
  %190 = fadd <2 x double> %wide.load113.1, zeroinitializer
  %191 = getelementptr inbounds i8, ptr %0, i64 568
  %192 = getelementptr inbounds i8, ptr %0, i64 584
  %wide.load114.1 = load <2 x double>, ptr %191, align 8, !tbaa !5
  %wide.load115.1 = load <2 x double>, ptr %192, align 8, !tbaa !5
  %193 = fadd <2 x double> %wide.load114.1, %189
  %194 = fadd <2 x double> %wide.load115.1, %190
  store <2 x double> %193, ptr %191, align 8, !tbaa !5
  store <2 x double> %194, ptr %192, align 8, !tbaa !5
  %195 = getelementptr inbounds i8, ptr %1, i64 600
  %196 = getelementptr inbounds i8, ptr %1, i64 616
  %wide.load112.2 = load <2 x double>, ptr %195, align 8, !tbaa !5
  %wide.load113.2 = load <2 x double>, ptr %196, align 8, !tbaa !5
  %197 = fadd <2 x double> %wide.load112.2, zeroinitializer
  %198 = fadd <2 x double> %wide.load113.2, zeroinitializer
  %199 = getelementptr inbounds i8, ptr %0, i64 600
  %200 = getelementptr inbounds i8, ptr %0, i64 616
  %wide.load114.2 = load <2 x double>, ptr %199, align 8, !tbaa !5
  %wide.load115.2 = load <2 x double>, ptr %200, align 8, !tbaa !5
  %201 = fadd <2 x double> %wide.load114.2, %197
  %202 = fadd <2 x double> %wide.load115.2, %198
  store <2 x double> %201, ptr %199, align 8, !tbaa !5
  store <2 x double> %202, ptr %200, align 8, !tbaa !5
  %203 = getelementptr inbounds i8, ptr %1, i64 632
  %204 = getelementptr inbounds i8, ptr %1, i64 648
  %wide.load112.3 = load <2 x double>, ptr %203, align 8, !tbaa !5
  %wide.load113.3 = load <2 x double>, ptr %204, align 8, !tbaa !5
  %205 = fadd <2 x double> %wide.load112.3, zeroinitializer
  %206 = fadd <2 x double> %wide.load113.3, zeroinitializer
  %207 = getelementptr inbounds i8, ptr %0, i64 632
  %208 = getelementptr inbounds i8, ptr %0, i64 648
  %wide.load114.3 = load <2 x double>, ptr %207, align 8, !tbaa !5
  %wide.load115.3 = load <2 x double>, ptr %208, align 8, !tbaa !5
  %209 = fadd <2 x double> %wide.load114.3, %205
  %210 = fadd <2 x double> %wide.load115.3, %206
  store <2 x double> %209, ptr %207, align 8, !tbaa !5
  store <2 x double> %210, ptr %208, align 8, !tbaa !5
  %211 = getelementptr inbounds i8, ptr %1, i64 664
  %212 = getelementptr inbounds i8, ptr %1, i64 680
  %wide.load112.4 = load <2 x double>, ptr %211, align 8, !tbaa !5
  %wide.load113.4 = load <2 x double>, ptr %212, align 8, !tbaa !5
  %213 = fadd <2 x double> %wide.load112.4, zeroinitializer
  %214 = fadd <2 x double> %wide.load113.4, zeroinitializer
  %215 = getelementptr inbounds i8, ptr %0, i64 664
  %216 = getelementptr inbounds i8, ptr %0, i64 680
  %wide.load114.4 = load <2 x double>, ptr %215, align 8, !tbaa !5
  %wide.load115.4 = load <2 x double>, ptr %216, align 8, !tbaa !5
  %217 = fadd <2 x double> %wide.load114.4, %213
  %218 = fadd <2 x double> %wide.load115.4, %214
  store <2 x double> %217, ptr %215, align 8, !tbaa !5
  store <2 x double> %218, ptr %216, align 8, !tbaa !5
  %219 = getelementptr inbounds i8, ptr %1, i64 696
  %220 = getelementptr inbounds i8, ptr %1, i64 712
  %wide.load112.5 = load <2 x double>, ptr %219, align 8, !tbaa !5
  %wide.load113.5 = load <2 x double>, ptr %220, align 8, !tbaa !5
  %221 = fadd <2 x double> %wide.load112.5, zeroinitializer
  %222 = fadd <2 x double> %wide.load113.5, zeroinitializer
  %223 = getelementptr inbounds i8, ptr %0, i64 696
  %224 = getelementptr inbounds i8, ptr %0, i64 712
  %wide.load114.5 = load <2 x double>, ptr %223, align 8, !tbaa !5
  %wide.load115.5 = load <2 x double>, ptr %224, align 8, !tbaa !5
  %225 = fadd <2 x double> %wide.load114.5, %221
  %226 = fadd <2 x double> %wide.load115.5, %222
  store <2 x double> %225, ptr %223, align 8, !tbaa !5
  store <2 x double> %226, ptr %224, align 8, !tbaa !5
  %227 = getelementptr inbounds i8, ptr %1, i64 728
  %228 = getelementptr inbounds i8, ptr %1, i64 744
  %wide.load112.6 = load <2 x double>, ptr %227, align 8, !tbaa !5
  %wide.load113.6 = load <2 x double>, ptr %228, align 8, !tbaa !5
  %229 = fadd <2 x double> %wide.load112.6, zeroinitializer
  %230 = fadd <2 x double> %wide.load113.6, zeroinitializer
  %231 = getelementptr inbounds i8, ptr %0, i64 728
  %232 = getelementptr inbounds i8, ptr %0, i64 744
  %wide.load114.6 = load <2 x double>, ptr %231, align 8, !tbaa !5
  %wide.load115.6 = load <2 x double>, ptr %232, align 8, !tbaa !5
  %233 = fadd <2 x double> %wide.load114.6, %229
  %234 = fadd <2 x double> %wide.load115.6, %230
  store <2 x double> %233, ptr %231, align 8, !tbaa !5
  store <2 x double> %234, ptr %232, align 8, !tbaa !5
  %235 = getelementptr inbounds i8, ptr %1, i64 760
  %236 = getelementptr inbounds i8, ptr %1, i64 776
  %wide.load112.7 = load <2 x double>, ptr %235, align 8, !tbaa !5
  %wide.load113.7 = load <2 x double>, ptr %236, align 8, !tbaa !5
  %237 = fadd <2 x double> %wide.load112.7, zeroinitializer
  %238 = fadd <2 x double> %wide.load113.7, zeroinitializer
  %239 = getelementptr inbounds i8, ptr %0, i64 760
  %240 = getelementptr inbounds i8, ptr %0, i64 776
  %wide.load114.7 = load <2 x double>, ptr %239, align 8, !tbaa !5
  %wide.load115.7 = load <2 x double>, ptr %240, align 8, !tbaa !5
  %241 = fadd <2 x double> %wide.load114.7, %237
  %242 = fadd <2 x double> %wide.load115.7, %238
  store <2 x double> %241, ptr %239, align 8, !tbaa !5
  store <2 x double> %242, ptr %240, align 8, !tbaa !5
  %243 = getelementptr inbounds i8, ptr %1, i64 792
  %244 = getelementptr inbounds i8, ptr %1, i64 808
  %wide.load112.8 = load <2 x double>, ptr %243, align 8, !tbaa !5
  %wide.load113.8 = load <2 x double>, ptr %244, align 8, !tbaa !5
  %245 = fadd <2 x double> %wide.load112.8, zeroinitializer
  %246 = fadd <2 x double> %wide.load113.8, zeroinitializer
  %247 = getelementptr inbounds i8, ptr %0, i64 792
  %248 = getelementptr inbounds i8, ptr %0, i64 808
  %wide.load114.8 = load <2 x double>, ptr %247, align 8, !tbaa !5
  %wide.load115.8 = load <2 x double>, ptr %248, align 8, !tbaa !5
  %249 = fadd <2 x double> %wide.load114.8, %245
  %250 = fadd <2 x double> %wide.load115.8, %246
  store <2 x double> %249, ptr %247, align 8, !tbaa !5
  store <2 x double> %250, ptr %248, align 8, !tbaa !5
  %251 = getelementptr inbounds i8, ptr %1, i64 824
  %252 = getelementptr inbounds i8, ptr %1, i64 840
  %wide.load112.9 = load <2 x double>, ptr %251, align 8, !tbaa !5
  %wide.load113.9 = load <2 x double>, ptr %252, align 8, !tbaa !5
  %253 = fadd <2 x double> %wide.load112.9, zeroinitializer
  %254 = fadd <2 x double> %wide.load113.9, zeroinitializer
  %255 = getelementptr inbounds i8, ptr %0, i64 824
  %256 = getelementptr inbounds i8, ptr %0, i64 840
  %wide.load114.9 = load <2 x double>, ptr %255, align 8, !tbaa !5
  %wide.load115.9 = load <2 x double>, ptr %256, align 8, !tbaa !5
  %257 = fadd <2 x double> %wide.load114.9, %253
  %258 = fadd <2 x double> %wide.load115.9, %254
  store <2 x double> %257, ptr %255, align 8, !tbaa !5
  store <2 x double> %258, ptr %256, align 8, !tbaa !5
  %259 = getelementptr inbounds i8, ptr %1, i64 856
  %260 = getelementptr inbounds i8, ptr %1, i64 872
  %wide.load112.10 = load <2 x double>, ptr %259, align 8, !tbaa !5
  %wide.load113.10 = load <2 x double>, ptr %260, align 8, !tbaa !5
  %261 = fadd <2 x double> %wide.load112.10, zeroinitializer
  %262 = fadd <2 x double> %wide.load113.10, zeroinitializer
  %263 = getelementptr inbounds i8, ptr %0, i64 856
  %264 = getelementptr inbounds i8, ptr %0, i64 872
  %wide.load114.10 = load <2 x double>, ptr %263, align 8, !tbaa !5
  %wide.load115.10 = load <2 x double>, ptr %264, align 8, !tbaa !5
  %265 = fadd <2 x double> %wide.load114.10, %261
  %266 = fadd <2 x double> %wide.load115.10, %262
  store <2 x double> %265, ptr %263, align 8, !tbaa !5
  store <2 x double> %266, ptr %264, align 8, !tbaa !5
  %267 = getelementptr inbounds i8, ptr %1, i64 888
  %268 = getelementptr inbounds i8, ptr %1, i64 904
  %wide.load112.11 = load <2 x double>, ptr %267, align 8, !tbaa !5
  %wide.load113.11 = load <2 x double>, ptr %268, align 8, !tbaa !5
  %269 = fadd <2 x double> %wide.load112.11, zeroinitializer
  %270 = fadd <2 x double> %wide.load113.11, zeroinitializer
  %271 = getelementptr inbounds i8, ptr %0, i64 888
  %272 = getelementptr inbounds i8, ptr %0, i64 904
  %wide.load114.11 = load <2 x double>, ptr %271, align 8, !tbaa !5
  %wide.load115.11 = load <2 x double>, ptr %272, align 8, !tbaa !5
  %273 = fadd <2 x double> %wide.load114.11, %269
  %274 = fadd <2 x double> %wide.load115.11, %270
  store <2 x double> %273, ptr %271, align 8, !tbaa !5
  store <2 x double> %274, ptr %272, align 8, !tbaa !5
  %275 = getelementptr inbounds i8, ptr %1, i64 920
  %276 = getelementptr inbounds i8, ptr %1, i64 936
  %wide.load112.12 = load <2 x double>, ptr %275, align 8, !tbaa !5
  %wide.load113.12 = load <2 x double>, ptr %276, align 8, !tbaa !5
  %277 = fadd <2 x double> %wide.load112.12, zeroinitializer
  %278 = fadd <2 x double> %wide.load113.12, zeroinitializer
  %279 = getelementptr inbounds i8, ptr %0, i64 920
  %280 = getelementptr inbounds i8, ptr %0, i64 936
  %wide.load114.12 = load <2 x double>, ptr %279, align 8, !tbaa !5
  %wide.load115.12 = load <2 x double>, ptr %280, align 8, !tbaa !5
  %281 = fadd <2 x double> %wide.load114.12, %277
  %282 = fadd <2 x double> %wide.load115.12, %278
  store <2 x double> %281, ptr %279, align 8, !tbaa !5
  store <2 x double> %282, ptr %280, align 8, !tbaa !5
  %283 = getelementptr inbounds i8, ptr %1, i64 952
  %284 = getelementptr inbounds i8, ptr %1, i64 968
  %wide.load112.13 = load <2 x double>, ptr %283, align 8, !tbaa !5
  %wide.load113.13 = load <2 x double>, ptr %284, align 8, !tbaa !5
  %285 = fadd <2 x double> %wide.load112.13, zeroinitializer
  %286 = fadd <2 x double> %wide.load113.13, zeroinitializer
  %287 = getelementptr inbounds i8, ptr %0, i64 952
  %288 = getelementptr inbounds i8, ptr %0, i64 968
  %wide.load114.13 = load <2 x double>, ptr %287, align 8, !tbaa !5
  %wide.load115.13 = load <2 x double>, ptr %288, align 8, !tbaa !5
  %289 = fadd <2 x double> %wide.load114.13, %285
  %290 = fadd <2 x double> %wide.load115.13, %286
  store <2 x double> %289, ptr %287, align 8, !tbaa !5
  store <2 x double> %290, ptr %288, align 8, !tbaa !5
  %291 = getelementptr inbounds i8, ptr %1, i64 984
  %292 = getelementptr inbounds i8, ptr %1, i64 1000
  %wide.load112.14 = load <2 x double>, ptr %291, align 8, !tbaa !5
  %wide.load113.14 = load <2 x double>, ptr %292, align 8, !tbaa !5
  %293 = fadd <2 x double> %wide.load112.14, zeroinitializer
  %294 = fadd <2 x double> %wide.load113.14, zeroinitializer
  %295 = getelementptr inbounds i8, ptr %0, i64 984
  %296 = getelementptr inbounds i8, ptr %0, i64 1000
  %wide.load114.14 = load <2 x double>, ptr %295, align 8, !tbaa !5
  %wide.load115.14 = load <2 x double>, ptr %296, align 8, !tbaa !5
  %297 = fadd <2 x double> %wide.load114.14, %293
  %298 = fadd <2 x double> %wide.load115.14, %294
  store <2 x double> %297, ptr %295, align 8, !tbaa !5
  store <2 x double> %298, ptr %296, align 8, !tbaa !5
  %299 = getelementptr inbounds i8, ptr %1, i64 1016
  %300 = load double, ptr %299, align 8, !tbaa !5
  %301 = fadd double %300, 0.000000e+00
  %302 = getelementptr inbounds i8, ptr %0, i64 1016
  %303 = load double, ptr %302, align 8, !tbaa !5
  %304 = fadd double %303, %301
  store double %304, ptr %302, align 8, !tbaa !5
  %.pre80 = load double, ptr %18, align 8, !tbaa !5
  %305 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, double noundef 0.000000e+00, double noundef %17, double noundef %.pre80)
  %306 = getelementptr inbounds i8, ptr %1, i64 1024
  %307 = load double, ptr %306, align 16, !tbaa !5
  %308 = fadd double %307, 0.000000e+00
  %309 = getelementptr inbounds i8, ptr %0, i64 1024
  %310 = load double, ptr %309, align 16, !tbaa !5
  %311 = fadd double %310, %308
  store double %311, ptr %309, align 16, !tbaa !5
  %312 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %307, double noundef %311)
  %313 = getelementptr inbounds i8, ptr %1, i64 1032
  %314 = load double, ptr %313, align 8, !tbaa !5
  %315 = fadd double %314, 0.000000e+00
  %316 = getelementptr inbounds i8, ptr %0, i64 1032
  %317 = load double, ptr %316, align 8, !tbaa !5
  %318 = fadd double %317, %315
  store double %318, ptr %316, align 8, !tbaa !5
  %319 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %314, double noundef %318)
  %320 = getelementptr inbounds i8, ptr %1, i64 1040
  %321 = load double, ptr %320, align 16, !tbaa !5
  %322 = fadd double %321, 0.000000e+00
  %323 = getelementptr inbounds i8, ptr %0, i64 1040
  %324 = load double, ptr %323, align 16, !tbaa !5
  %325 = fadd double %324, %322
  store double %325, ptr %323, align 16, !tbaa !5
  %326 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %321, double noundef %325)
  %327 = getelementptr inbounds i8, ptr %1, i64 1048
  %328 = getelementptr inbounds i8, ptr %1, i64 1064
  %wide.load126 = load <2 x double>, ptr %327, align 8, !tbaa !5
  %wide.load127 = load <2 x double>, ptr %328, align 8, !tbaa !5
  %329 = fadd <2 x double> %wide.load126, zeroinitializer
  %330 = fadd <2 x double> %wide.load127, zeroinitializer
  %331 = getelementptr inbounds i8, ptr %0, i64 1048
  %332 = getelementptr inbounds i8, ptr %0, i64 1064
  %wide.load128 = load <2 x double>, ptr %331, align 8, !tbaa !5
  %wide.load129 = load <2 x double>, ptr %332, align 8, !tbaa !5
  %333 = fadd <2 x double> %wide.load128, %329
  %334 = fadd <2 x double> %wide.load129, %330
  store <2 x double> %333, ptr %331, align 8, !tbaa !5
  store <2 x double> %334, ptr %332, align 8, !tbaa !5
  %335 = getelementptr inbounds i8, ptr %1, i64 1080
  %336 = getelementptr inbounds i8, ptr %1, i64 1096
  %wide.load126.1 = load <2 x double>, ptr %335, align 8, !tbaa !5
  %wide.load127.1 = load <2 x double>, ptr %336, align 8, !tbaa !5
  %337 = fadd <2 x double> %wide.load126.1, zeroinitializer
  %338 = fadd <2 x double> %wide.load127.1, zeroinitializer
  %339 = getelementptr inbounds i8, ptr %0, i64 1080
  %340 = getelementptr inbounds i8, ptr %0, i64 1096
  %wide.load128.1 = load <2 x double>, ptr %339, align 8, !tbaa !5
  %wide.load129.1 = load <2 x double>, ptr %340, align 8, !tbaa !5
  %341 = fadd <2 x double> %wide.load128.1, %337
  %342 = fadd <2 x double> %wide.load129.1, %338
  store <2 x double> %341, ptr %339, align 8, !tbaa !5
  store <2 x double> %342, ptr %340, align 8, !tbaa !5
  %343 = getelementptr inbounds i8, ptr %1, i64 1112
  %344 = getelementptr inbounds i8, ptr %1, i64 1128
  %wide.load126.2 = load <2 x double>, ptr %343, align 8, !tbaa !5
  %wide.load127.2 = load <2 x double>, ptr %344, align 8, !tbaa !5
  %345 = fadd <2 x double> %wide.load126.2, zeroinitializer
  %346 = fadd <2 x double> %wide.load127.2, zeroinitializer
  %347 = getelementptr inbounds i8, ptr %0, i64 1112
  %348 = getelementptr inbounds i8, ptr %0, i64 1128
  %wide.load128.2 = load <2 x double>, ptr %347, align 8, !tbaa !5
  %wide.load129.2 = load <2 x double>, ptr %348, align 8, !tbaa !5
  %349 = fadd <2 x double> %wide.load128.2, %345
  %350 = fadd <2 x double> %wide.load129.2, %346
  store <2 x double> %349, ptr %347, align 8, !tbaa !5
  store <2 x double> %350, ptr %348, align 8, !tbaa !5
  %351 = getelementptr inbounds i8, ptr %1, i64 1144
  %352 = getelementptr inbounds i8, ptr %1, i64 1160
  %wide.load126.3 = load <2 x double>, ptr %351, align 8, !tbaa !5
  %wide.load127.3 = load <2 x double>, ptr %352, align 8, !tbaa !5
  %353 = fadd <2 x double> %wide.load126.3, zeroinitializer
  %354 = fadd <2 x double> %wide.load127.3, zeroinitializer
  %355 = getelementptr inbounds i8, ptr %0, i64 1144
  %356 = getelementptr inbounds i8, ptr %0, i64 1160
  %wide.load128.3 = load <2 x double>, ptr %355, align 8, !tbaa !5
  %wide.load129.3 = load <2 x double>, ptr %356, align 8, !tbaa !5
  %357 = fadd <2 x double> %wide.load128.3, %353
  %358 = fadd <2 x double> %wide.load129.3, %354
  store <2 x double> %357, ptr %355, align 8, !tbaa !5
  store <2 x double> %358, ptr %356, align 8, !tbaa !5
  %359 = getelementptr inbounds i8, ptr %1, i64 1176
  %360 = getelementptr inbounds i8, ptr %1, i64 1192
  %wide.load126.4 = load <2 x double>, ptr %359, align 8, !tbaa !5
  %wide.load127.4 = load <2 x double>, ptr %360, align 8, !tbaa !5
  %361 = fadd <2 x double> %wide.load126.4, zeroinitializer
  %362 = fadd <2 x double> %wide.load127.4, zeroinitializer
  %363 = getelementptr inbounds i8, ptr %0, i64 1176
  %364 = getelementptr inbounds i8, ptr %0, i64 1192
  %wide.load128.4 = load <2 x double>, ptr %363, align 8, !tbaa !5
  %wide.load129.4 = load <2 x double>, ptr %364, align 8, !tbaa !5
  %365 = fadd <2 x double> %wide.load128.4, %361
  %366 = fadd <2 x double> %wide.load129.4, %362
  store <2 x double> %365, ptr %363, align 8, !tbaa !5
  store <2 x double> %366, ptr %364, align 8, !tbaa !5
  %367 = getelementptr inbounds i8, ptr %1, i64 1208
  %368 = getelementptr inbounds i8, ptr %1, i64 1224
  %wide.load126.5 = load <2 x double>, ptr %367, align 8, !tbaa !5
  %wide.load127.5 = load <2 x double>, ptr %368, align 8, !tbaa !5
  %369 = fadd <2 x double> %wide.load126.5, zeroinitializer
  %370 = fadd <2 x double> %wide.load127.5, zeroinitializer
  %371 = getelementptr inbounds i8, ptr %0, i64 1208
  %372 = getelementptr inbounds i8, ptr %0, i64 1224
  %wide.load128.5 = load <2 x double>, ptr %371, align 8, !tbaa !5
  %wide.load129.5 = load <2 x double>, ptr %372, align 8, !tbaa !5
  %373 = fadd <2 x double> %wide.load128.5, %369
  %374 = fadd <2 x double> %wide.load129.5, %370
  store <2 x double> %373, ptr %371, align 8, !tbaa !5
  store <2 x double> %374, ptr %372, align 8, !tbaa !5
  %375 = getelementptr inbounds i8, ptr %1, i64 1240
  %376 = getelementptr inbounds i8, ptr %1, i64 1256
  %wide.load126.6 = load <2 x double>, ptr %375, align 8, !tbaa !5
  %wide.load127.6 = load <2 x double>, ptr %376, align 8, !tbaa !5
  %377 = fadd <2 x double> %wide.load126.6, zeroinitializer
  %378 = fadd <2 x double> %wide.load127.6, zeroinitializer
  %379 = getelementptr inbounds i8, ptr %0, i64 1240
  %380 = getelementptr inbounds i8, ptr %0, i64 1256
  %wide.load128.6 = load <2 x double>, ptr %379, align 8, !tbaa !5
  %wide.load129.6 = load <2 x double>, ptr %380, align 8, !tbaa !5
  %381 = fadd <2 x double> %wide.load128.6, %377
  %382 = fadd <2 x double> %wide.load129.6, %378
  store <2 x double> %381, ptr %379, align 8, !tbaa !5
  store <2 x double> %382, ptr %380, align 8, !tbaa !5
  %383 = getelementptr inbounds i8, ptr %1, i64 1272
  %384 = getelementptr inbounds i8, ptr %1, i64 1288
  %wide.load126.7 = load <2 x double>, ptr %383, align 8, !tbaa !5
  %wide.load127.7 = load <2 x double>, ptr %384, align 8, !tbaa !5
  %385 = fadd <2 x double> %wide.load126.7, zeroinitializer
  %386 = fadd <2 x double> %wide.load127.7, zeroinitializer
  %387 = getelementptr inbounds i8, ptr %0, i64 1272
  %388 = getelementptr inbounds i8, ptr %0, i64 1288
  %wide.load128.7 = load <2 x double>, ptr %387, align 8, !tbaa !5
  %wide.load129.7 = load <2 x double>, ptr %388, align 8, !tbaa !5
  %389 = fadd <2 x double> %wide.load128.7, %385
  %390 = fadd <2 x double> %wide.load129.7, %386
  store <2 x double> %389, ptr %387, align 8, !tbaa !5
  store <2 x double> %390, ptr %388, align 8, !tbaa !5
  %391 = getelementptr inbounds i8, ptr %1, i64 1304
  %392 = getelementptr inbounds i8, ptr %1, i64 1320
  %wide.load126.8 = load <2 x double>, ptr %391, align 8, !tbaa !5
  %wide.load127.8 = load <2 x double>, ptr %392, align 8, !tbaa !5
  %393 = fadd <2 x double> %wide.load126.8, zeroinitializer
  %394 = fadd <2 x double> %wide.load127.8, zeroinitializer
  %395 = getelementptr inbounds i8, ptr %0, i64 1304
  %396 = getelementptr inbounds i8, ptr %0, i64 1320
  %wide.load128.8 = load <2 x double>, ptr %395, align 8, !tbaa !5
  %wide.load129.8 = load <2 x double>, ptr %396, align 8, !tbaa !5
  %397 = fadd <2 x double> %wide.load128.8, %393
  %398 = fadd <2 x double> %wide.load129.8, %394
  store <2 x double> %397, ptr %395, align 8, !tbaa !5
  store <2 x double> %398, ptr %396, align 8, !tbaa !5
  %399 = getelementptr inbounds i8, ptr %1, i64 1336
  %400 = getelementptr inbounds i8, ptr %1, i64 1352
  %wide.load126.9 = load <2 x double>, ptr %399, align 8, !tbaa !5
  %wide.load127.9 = load <2 x double>, ptr %400, align 8, !tbaa !5
  %401 = fadd <2 x double> %wide.load126.9, zeroinitializer
  %402 = fadd <2 x double> %wide.load127.9, zeroinitializer
  %403 = getelementptr inbounds i8, ptr %0, i64 1336
  %404 = getelementptr inbounds i8, ptr %0, i64 1352
  %wide.load128.9 = load <2 x double>, ptr %403, align 8, !tbaa !5
  %wide.load129.9 = load <2 x double>, ptr %404, align 8, !tbaa !5
  %405 = fadd <2 x double> %wide.load128.9, %401
  %406 = fadd <2 x double> %wide.load129.9, %402
  store <2 x double> %405, ptr %403, align 8, !tbaa !5
  store <2 x double> %406, ptr %404, align 8, !tbaa !5
  %407 = getelementptr inbounds i8, ptr %1, i64 1368
  %408 = getelementptr inbounds i8, ptr %1, i64 1384
  %wide.load126.10 = load <2 x double>, ptr %407, align 8, !tbaa !5
  %wide.load127.10 = load <2 x double>, ptr %408, align 8, !tbaa !5
  %409 = fadd <2 x double> %wide.load126.10, zeroinitializer
  %410 = fadd <2 x double> %wide.load127.10, zeroinitializer
  %411 = getelementptr inbounds i8, ptr %0, i64 1368
  %412 = getelementptr inbounds i8, ptr %0, i64 1384
  %wide.load128.10 = load <2 x double>, ptr %411, align 8, !tbaa !5
  %wide.load129.10 = load <2 x double>, ptr %412, align 8, !tbaa !5
  %413 = fadd <2 x double> %wide.load128.10, %409
  %414 = fadd <2 x double> %wide.load129.10, %410
  store <2 x double> %413, ptr %411, align 8, !tbaa !5
  store <2 x double> %414, ptr %412, align 8, !tbaa !5
  %415 = getelementptr inbounds i8, ptr %1, i64 1400
  %416 = getelementptr inbounds i8, ptr %1, i64 1416
  %wide.load126.11 = load <2 x double>, ptr %415, align 8, !tbaa !5
  %wide.load127.11 = load <2 x double>, ptr %416, align 8, !tbaa !5
  %417 = fadd <2 x double> %wide.load126.11, zeroinitializer
  %418 = fadd <2 x double> %wide.load127.11, zeroinitializer
  %419 = getelementptr inbounds i8, ptr %0, i64 1400
  %420 = getelementptr inbounds i8, ptr %0, i64 1416
  %wide.load128.11 = load <2 x double>, ptr %419, align 8, !tbaa !5
  %wide.load129.11 = load <2 x double>, ptr %420, align 8, !tbaa !5
  %421 = fadd <2 x double> %wide.load128.11, %417
  %422 = fadd <2 x double> %wide.load129.11, %418
  store <2 x double> %421, ptr %419, align 8, !tbaa !5
  store <2 x double> %422, ptr %420, align 8, !tbaa !5
  %423 = getelementptr inbounds i8, ptr %1, i64 1432
  %424 = getelementptr inbounds i8, ptr %1, i64 1448
  %wide.load126.12 = load <2 x double>, ptr %423, align 8, !tbaa !5
  %wide.load127.12 = load <2 x double>, ptr %424, align 8, !tbaa !5
  %425 = fadd <2 x double> %wide.load126.12, zeroinitializer
  %426 = fadd <2 x double> %wide.load127.12, zeroinitializer
  %427 = getelementptr inbounds i8, ptr %0, i64 1432
  %428 = getelementptr inbounds i8, ptr %0, i64 1448
  %wide.load128.12 = load <2 x double>, ptr %427, align 8, !tbaa !5
  %wide.load129.12 = load <2 x double>, ptr %428, align 8, !tbaa !5
  %429 = fadd <2 x double> %wide.load128.12, %425
  %430 = fadd <2 x double> %wide.load129.12, %426
  store <2 x double> %429, ptr %427, align 8, !tbaa !5
  store <2 x double> %430, ptr %428, align 8, !tbaa !5
  %431 = getelementptr inbounds i8, ptr %1, i64 1464
  %432 = getelementptr inbounds i8, ptr %1, i64 1480
  %wide.load126.13 = load <2 x double>, ptr %431, align 8, !tbaa !5
  %wide.load127.13 = load <2 x double>, ptr %432, align 8, !tbaa !5
  %433 = fadd <2 x double> %wide.load126.13, zeroinitializer
  %434 = fadd <2 x double> %wide.load127.13, zeroinitializer
  %435 = getelementptr inbounds i8, ptr %0, i64 1464
  %436 = getelementptr inbounds i8, ptr %0, i64 1480
  %wide.load128.13 = load <2 x double>, ptr %435, align 8, !tbaa !5
  %wide.load129.13 = load <2 x double>, ptr %436, align 8, !tbaa !5
  %437 = fadd <2 x double> %wide.load128.13, %433
  %438 = fadd <2 x double> %wide.load129.13, %434
  store <2 x double> %437, ptr %435, align 8, !tbaa !5
  store <2 x double> %438, ptr %436, align 8, !tbaa !5
  %439 = getelementptr inbounds i8, ptr %1, i64 1496
  %440 = getelementptr inbounds i8, ptr %1, i64 1512
  %wide.load126.14 = load <2 x double>, ptr %439, align 8, !tbaa !5
  %wide.load127.14 = load <2 x double>, ptr %440, align 8, !tbaa !5
  %441 = fadd <2 x double> %wide.load126.14, zeroinitializer
  %442 = fadd <2 x double> %wide.load127.14, zeroinitializer
  %443 = getelementptr inbounds i8, ptr %0, i64 1496
  %444 = getelementptr inbounds i8, ptr %0, i64 1512
  %wide.load128.14 = load <2 x double>, ptr %443, align 8, !tbaa !5
  %wide.load129.14 = load <2 x double>, ptr %444, align 8, !tbaa !5
  %445 = fadd <2 x double> %wide.load128.14, %441
  %446 = fadd <2 x double> %wide.load129.14, %442
  store <2 x double> %445, ptr %443, align 8, !tbaa !5
  store <2 x double> %446, ptr %444, align 8, !tbaa !5
  %447 = getelementptr inbounds i8, ptr %1, i64 1528
  %448 = load double, ptr %447, align 8, !tbaa !5
  %449 = fadd double %448, 0.000000e+00
  %450 = getelementptr inbounds i8, ptr %0, i64 1528
  %451 = load double, ptr %450, align 8, !tbaa !5
  %452 = fadd double %451, %449
  store double %452, ptr %450, align 8, !tbaa !5
  %.pre83 = load double, ptr %18, align 8, !tbaa !5
  %453 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, double noundef 0.000000e+00, double noundef %17, double noundef %.pre83)
  %454 = getelementptr inbounds i8, ptr %1, i64 1536
  %455 = load double, ptr %454, align 16, !tbaa !5
  %456 = fadd double %455, 0.000000e+00
  %457 = getelementptr inbounds i8, ptr %0, i64 1536
  %458 = load double, ptr %457, align 16, !tbaa !5
  %459 = fadd double %458, %456
  store double %459, ptr %457, align 16, !tbaa !5
  %460 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %455, double noundef %459)
  %461 = getelementptr inbounds i8, ptr %1, i64 1544
  %462 = load double, ptr %461, align 8, !tbaa !5
  %463 = fadd double %462, 0.000000e+00
  %464 = getelementptr inbounds i8, ptr %0, i64 1544
  %465 = load double, ptr %464, align 8, !tbaa !5
  %466 = fadd double %465, %463
  store double %466, ptr %464, align 8, !tbaa !5
  %467 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %462, double noundef %466)
  %468 = getelementptr inbounds i8, ptr %1, i64 1552
  %469 = load double, ptr %468, align 16, !tbaa !5
  %470 = fadd double %469, 0.000000e+00
  %471 = getelementptr inbounds i8, ptr %0, i64 1552
  %472 = load double, ptr %471, align 16, !tbaa !5
  %473 = fadd double %472, %470
  store double %473, ptr %471, align 16, !tbaa !5
  %474 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, double noundef 0.000000e+00, double noundef %469, double noundef %473)
  %475 = getelementptr inbounds i8, ptr %1, i64 1560
  %476 = getelementptr inbounds i8, ptr %1, i64 1576
  %wide.load140 = load <2 x double>, ptr %475, align 8, !tbaa !5
  %wide.load141 = load <2 x double>, ptr %476, align 8, !tbaa !5
  %477 = fadd <2 x double> %wide.load140, zeroinitializer
  %478 = fadd <2 x double> %wide.load141, zeroinitializer
  %479 = getelementptr inbounds i8, ptr %0, i64 1560
  %480 = getelementptr inbounds i8, ptr %0, i64 1576
  %wide.load142 = load <2 x double>, ptr %479, align 8, !tbaa !5
  %wide.load143 = load <2 x double>, ptr %480, align 8, !tbaa !5
  %481 = fadd <2 x double> %wide.load142, %477
  %482 = fadd <2 x double> %wide.load143, %478
  store <2 x double> %481, ptr %479, align 8, !tbaa !5
  store <2 x double> %482, ptr %480, align 8, !tbaa !5
  %483 = getelementptr inbounds i8, ptr %1, i64 1592
  %484 = getelementptr inbounds i8, ptr %1, i64 1608
  %wide.load140.1 = load <2 x double>, ptr %483, align 8, !tbaa !5
  %wide.load141.1 = load <2 x double>, ptr %484, align 8, !tbaa !5
  %485 = fadd <2 x double> %wide.load140.1, zeroinitializer
  %486 = fadd <2 x double> %wide.load141.1, zeroinitializer
  %487 = getelementptr inbounds i8, ptr %0, i64 1592
  %488 = getelementptr inbounds i8, ptr %0, i64 1608
  %wide.load142.1 = load <2 x double>, ptr %487, align 8, !tbaa !5
  %wide.load143.1 = load <2 x double>, ptr %488, align 8, !tbaa !5
  %489 = fadd <2 x double> %wide.load142.1, %485
  %490 = fadd <2 x double> %wide.load143.1, %486
  store <2 x double> %489, ptr %487, align 8, !tbaa !5
  store <2 x double> %490, ptr %488, align 8, !tbaa !5
  %491 = getelementptr inbounds i8, ptr %1, i64 1624
  %492 = getelementptr inbounds i8, ptr %1, i64 1640
  %wide.load140.2 = load <2 x double>, ptr %491, align 8, !tbaa !5
  %wide.load141.2 = load <2 x double>, ptr %492, align 8, !tbaa !5
  %493 = fadd <2 x double> %wide.load140.2, zeroinitializer
  %494 = fadd <2 x double> %wide.load141.2, zeroinitializer
  %495 = getelementptr inbounds i8, ptr %0, i64 1624
  %496 = getelementptr inbounds i8, ptr %0, i64 1640
  %wide.load142.2 = load <2 x double>, ptr %495, align 8, !tbaa !5
  %wide.load143.2 = load <2 x double>, ptr %496, align 8, !tbaa !5
  %497 = fadd <2 x double> %wide.load142.2, %493
  %498 = fadd <2 x double> %wide.load143.2, %494
  store <2 x double> %497, ptr %495, align 8, !tbaa !5
  store <2 x double> %498, ptr %496, align 8, !tbaa !5
  %499 = getelementptr inbounds i8, ptr %1, i64 1656
  %500 = getelementptr inbounds i8, ptr %1, i64 1672
  %wide.load140.3 = load <2 x double>, ptr %499, align 8, !tbaa !5
  %wide.load141.3 = load <2 x double>, ptr %500, align 8, !tbaa !5
  %501 = fadd <2 x double> %wide.load140.3, zeroinitializer
  %502 = fadd <2 x double> %wide.load141.3, zeroinitializer
  %503 = getelementptr inbounds i8, ptr %0, i64 1656
  %504 = getelementptr inbounds i8, ptr %0, i64 1672
  %wide.load142.3 = load <2 x double>, ptr %503, align 8, !tbaa !5
  %wide.load143.3 = load <2 x double>, ptr %504, align 8, !tbaa !5
  %505 = fadd <2 x double> %wide.load142.3, %501
  %506 = fadd <2 x double> %wide.load143.3, %502
  store <2 x double> %505, ptr %503, align 8, !tbaa !5
  store <2 x double> %506, ptr %504, align 8, !tbaa !5
  %507 = getelementptr inbounds i8, ptr %1, i64 1688
  %508 = getelementptr inbounds i8, ptr %1, i64 1704
  %wide.load140.4 = load <2 x double>, ptr %507, align 8, !tbaa !5
  %wide.load141.4 = load <2 x double>, ptr %508, align 8, !tbaa !5
  %509 = fadd <2 x double> %wide.load140.4, zeroinitializer
  %510 = fadd <2 x double> %wide.load141.4, zeroinitializer
  %511 = getelementptr inbounds i8, ptr %0, i64 1688
  %512 = getelementptr inbounds i8, ptr %0, i64 1704
  %wide.load142.4 = load <2 x double>, ptr %511, align 8, !tbaa !5
  %wide.load143.4 = load <2 x double>, ptr %512, align 8, !tbaa !5
  %513 = fadd <2 x double> %wide.load142.4, %509
  %514 = fadd <2 x double> %wide.load143.4, %510
  store <2 x double> %513, ptr %511, align 8, !tbaa !5
  store <2 x double> %514, ptr %512, align 8, !tbaa !5
  %515 = getelementptr inbounds i8, ptr %1, i64 1720
  %516 = getelementptr inbounds i8, ptr %1, i64 1736
  %wide.load140.5 = load <2 x double>, ptr %515, align 8, !tbaa !5
  %wide.load141.5 = load <2 x double>, ptr %516, align 8, !tbaa !5
  %517 = fadd <2 x double> %wide.load140.5, zeroinitializer
  %518 = fadd <2 x double> %wide.load141.5, zeroinitializer
  %519 = getelementptr inbounds i8, ptr %0, i64 1720
  %520 = getelementptr inbounds i8, ptr %0, i64 1736
  %wide.load142.5 = load <2 x double>, ptr %519, align 8, !tbaa !5
  %wide.load143.5 = load <2 x double>, ptr %520, align 8, !tbaa !5
  %521 = fadd <2 x double> %wide.load142.5, %517
  %522 = fadd <2 x double> %wide.load143.5, %518
  store <2 x double> %521, ptr %519, align 8, !tbaa !5
  store <2 x double> %522, ptr %520, align 8, !tbaa !5
  %523 = getelementptr inbounds i8, ptr %1, i64 1752
  %524 = getelementptr inbounds i8, ptr %1, i64 1768
  %wide.load140.6 = load <2 x double>, ptr %523, align 8, !tbaa !5
  %wide.load141.6 = load <2 x double>, ptr %524, align 8, !tbaa !5
  %525 = fadd <2 x double> %wide.load140.6, zeroinitializer
  %526 = fadd <2 x double> %wide.load141.6, zeroinitializer
  %527 = getelementptr inbounds i8, ptr %0, i64 1752
  %528 = getelementptr inbounds i8, ptr %0, i64 1768
  %wide.load142.6 = load <2 x double>, ptr %527, align 8, !tbaa !5
  %wide.load143.6 = load <2 x double>, ptr %528, align 8, !tbaa !5
  %529 = fadd <2 x double> %wide.load142.6, %525
  %530 = fadd <2 x double> %wide.load143.6, %526
  store <2 x double> %529, ptr %527, align 8, !tbaa !5
  store <2 x double> %530, ptr %528, align 8, !tbaa !5
  %531 = getelementptr inbounds i8, ptr %1, i64 1784
  %532 = getelementptr inbounds i8, ptr %1, i64 1800
  %wide.load140.7 = load <2 x double>, ptr %531, align 8, !tbaa !5
  %wide.load141.7 = load <2 x double>, ptr %532, align 8, !tbaa !5
  %533 = fadd <2 x double> %wide.load140.7, zeroinitializer
  %534 = fadd <2 x double> %wide.load141.7, zeroinitializer
  %535 = getelementptr inbounds i8, ptr %0, i64 1784
  %536 = getelementptr inbounds i8, ptr %0, i64 1800
  %wide.load142.7 = load <2 x double>, ptr %535, align 8, !tbaa !5
  %wide.load143.7 = load <2 x double>, ptr %536, align 8, !tbaa !5
  %537 = fadd <2 x double> %wide.load142.7, %533
  %538 = fadd <2 x double> %wide.load143.7, %534
  store <2 x double> %537, ptr %535, align 8, !tbaa !5
  store <2 x double> %538, ptr %536, align 8, !tbaa !5
  %539 = getelementptr inbounds i8, ptr %1, i64 1816
  %540 = getelementptr inbounds i8, ptr %1, i64 1832
  %wide.load140.8 = load <2 x double>, ptr %539, align 8, !tbaa !5
  %wide.load141.8 = load <2 x double>, ptr %540, align 8, !tbaa !5
  %541 = fadd <2 x double> %wide.load140.8, zeroinitializer
  %542 = fadd <2 x double> %wide.load141.8, zeroinitializer
  %543 = getelementptr inbounds i8, ptr %0, i64 1816
  %544 = getelementptr inbounds i8, ptr %0, i64 1832
  %wide.load142.8 = load <2 x double>, ptr %543, align 8, !tbaa !5
  %wide.load143.8 = load <2 x double>, ptr %544, align 8, !tbaa !5
  %545 = fadd <2 x double> %wide.load142.8, %541
  %546 = fadd <2 x double> %wide.load143.8, %542
  store <2 x double> %545, ptr %543, align 8, !tbaa !5
  store <2 x double> %546, ptr %544, align 8, !tbaa !5
  %547 = getelementptr inbounds i8, ptr %1, i64 1848
  %548 = getelementptr inbounds i8, ptr %1, i64 1864
  %wide.load140.9 = load <2 x double>, ptr %547, align 8, !tbaa !5
  %wide.load141.9 = load <2 x double>, ptr %548, align 8, !tbaa !5
  %549 = fadd <2 x double> %wide.load140.9, zeroinitializer
  %550 = fadd <2 x double> %wide.load141.9, zeroinitializer
  %551 = getelementptr inbounds i8, ptr %0, i64 1848
  %552 = getelementptr inbounds i8, ptr %0, i64 1864
  %wide.load142.9 = load <2 x double>, ptr %551, align 8, !tbaa !5
  %wide.load143.9 = load <2 x double>, ptr %552, align 8, !tbaa !5
  %553 = fadd <2 x double> %wide.load142.9, %549
  %554 = fadd <2 x double> %wide.load143.9, %550
  store <2 x double> %553, ptr %551, align 8, !tbaa !5
  store <2 x double> %554, ptr %552, align 8, !tbaa !5
  %555 = getelementptr inbounds i8, ptr %1, i64 1880
  %556 = getelementptr inbounds i8, ptr %1, i64 1896
  %wide.load140.10 = load <2 x double>, ptr %555, align 8, !tbaa !5
  %wide.load141.10 = load <2 x double>, ptr %556, align 8, !tbaa !5
  %557 = fadd <2 x double> %wide.load140.10, zeroinitializer
  %558 = fadd <2 x double> %wide.load141.10, zeroinitializer
  %559 = getelementptr inbounds i8, ptr %0, i64 1880
  %560 = getelementptr inbounds i8, ptr %0, i64 1896
  %wide.load142.10 = load <2 x double>, ptr %559, align 8, !tbaa !5
  %wide.load143.10 = load <2 x double>, ptr %560, align 8, !tbaa !5
  %561 = fadd <2 x double> %wide.load142.10, %557
  %562 = fadd <2 x double> %wide.load143.10, %558
  store <2 x double> %561, ptr %559, align 8, !tbaa !5
  store <2 x double> %562, ptr %560, align 8, !tbaa !5
  %563 = getelementptr inbounds i8, ptr %1, i64 1912
  %564 = getelementptr inbounds i8, ptr %1, i64 1928
  %wide.load140.11 = load <2 x double>, ptr %563, align 8, !tbaa !5
  %wide.load141.11 = load <2 x double>, ptr %564, align 8, !tbaa !5
  %565 = fadd <2 x double> %wide.load140.11, zeroinitializer
  %566 = fadd <2 x double> %wide.load141.11, zeroinitializer
  %567 = getelementptr inbounds i8, ptr %0, i64 1912
  %568 = getelementptr inbounds i8, ptr %0, i64 1928
  %wide.load142.11 = load <2 x double>, ptr %567, align 8, !tbaa !5
  %wide.load143.11 = load <2 x double>, ptr %568, align 8, !tbaa !5
  %569 = fadd <2 x double> %wide.load142.11, %565
  %570 = fadd <2 x double> %wide.load143.11, %566
  store <2 x double> %569, ptr %567, align 8, !tbaa !5
  store <2 x double> %570, ptr %568, align 8, !tbaa !5
  %571 = getelementptr inbounds i8, ptr %1, i64 1944
  %572 = getelementptr inbounds i8, ptr %1, i64 1960
  %wide.load140.12 = load <2 x double>, ptr %571, align 8, !tbaa !5
  %wide.load141.12 = load <2 x double>, ptr %572, align 8, !tbaa !5
  %573 = fadd <2 x double> %wide.load140.12, zeroinitializer
  %574 = fadd <2 x double> %wide.load141.12, zeroinitializer
  %575 = getelementptr inbounds i8, ptr %0, i64 1944
  %576 = getelementptr inbounds i8, ptr %0, i64 1960
  %wide.load142.12 = load <2 x double>, ptr %575, align 8, !tbaa !5
  %wide.load143.12 = load <2 x double>, ptr %576, align 8, !tbaa !5
  %577 = fadd <2 x double> %wide.load142.12, %573
  %578 = fadd <2 x double> %wide.load143.12, %574
  store <2 x double> %577, ptr %575, align 8, !tbaa !5
  store <2 x double> %578, ptr %576, align 8, !tbaa !5
  %579 = getelementptr inbounds i8, ptr %1, i64 1976
  %580 = getelementptr inbounds i8, ptr %1, i64 1992
  %wide.load140.13 = load <2 x double>, ptr %579, align 8, !tbaa !5
  %wide.load141.13 = load <2 x double>, ptr %580, align 8, !tbaa !5
  %581 = fadd <2 x double> %wide.load140.13, zeroinitializer
  %582 = fadd <2 x double> %wide.load141.13, zeroinitializer
  %583 = getelementptr inbounds i8, ptr %0, i64 1976
  %584 = getelementptr inbounds i8, ptr %0, i64 1992
  %wide.load142.13 = load <2 x double>, ptr %583, align 8, !tbaa !5
  %wide.load143.13 = load <2 x double>, ptr %584, align 8, !tbaa !5
  %585 = fadd <2 x double> %wide.load142.13, %581
  %586 = fadd <2 x double> %wide.load143.13, %582
  store <2 x double> %585, ptr %583, align 8, !tbaa !5
  store <2 x double> %586, ptr %584, align 8, !tbaa !5
  %587 = getelementptr inbounds i8, ptr %1, i64 2008
  %588 = getelementptr inbounds i8, ptr %1, i64 2024
  %wide.load140.14 = load <2 x double>, ptr %587, align 8, !tbaa !5
  %wide.load141.14 = load <2 x double>, ptr %588, align 8, !tbaa !5
  %589 = fadd <2 x double> %wide.load140.14, zeroinitializer
  %590 = fadd <2 x double> %wide.load141.14, zeroinitializer
  %591 = getelementptr inbounds i8, ptr %0, i64 2008
  %592 = getelementptr inbounds i8, ptr %0, i64 2024
  %wide.load142.14 = load <2 x double>, ptr %591, align 8, !tbaa !5
  %wide.load143.14 = load <2 x double>, ptr %592, align 8, !tbaa !5
  %593 = fadd <2 x double> %wide.load142.14, %589
  %594 = fadd <2 x double> %wide.load143.14, %590
  store <2 x double> %593, ptr %591, align 8, !tbaa !5
  store <2 x double> %594, ptr %592, align 8, !tbaa !5
  %595 = getelementptr inbounds i8, ptr %1, i64 2040
  %596 = load double, ptr %595, align 8, !tbaa !5
  %597 = fadd double %596, 0.000000e+00
  %598 = getelementptr inbounds i8, ptr %0, i64 2040
  %599 = load double, ptr %598, align 8, !tbaa !5
  %600 = fadd double %599, %597
  store double %600, ptr %598, align 8, !tbaa !5
  %.pre86 = load double, ptr %18, align 8, !tbaa !5
  %601 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1, double noundef 0.000000e+00, double noundef %17, double noundef %.pre86)
  br label %.critedge.preheader

.critedge.preheader:                              ; preds = %.critedge.3, %.peel.next62
  %indvars.iv71 = phi i64 [ 0, %.peel.next62 ], [ %indvars.iv.next72.3, %.critedge.3 ]
  %602 = getelementptr inbounds [960 x double], ptr %0, i64 0, i64 %indvars.iv71
  %603 = load double, ptr %602, align 16, !tbaa !5
  %604 = fcmp une double %603, 1.000000e+00
  br i1 %604, label %614, label %.critedge

.critedge:                                        ; preds = %.critedge.preheader
  %indvars.iv.next72 = or disjoint i64 %indvars.iv71, 1
  %605 = getelementptr inbounds [960 x double], ptr %0, i64 0, i64 %indvars.iv.next72
  %606 = load double, ptr %605, align 8, !tbaa !5
  %607 = fcmp une double %606, 1.000000e+00
  br i1 %607, label %614, label %.critedge.1

.critedge.1:                                      ; preds = %.critedge
  %indvars.iv.next72.1 = or disjoint i64 %indvars.iv71, 2
  %608 = getelementptr inbounds [960 x double], ptr %0, i64 0, i64 %indvars.iv.next72.1
  %609 = load double, ptr %608, align 16, !tbaa !5
  %610 = fcmp une double %609, 1.000000e+00
  br i1 %610, label %614, label %.critedge.2

.critedge.2:                                      ; preds = %.critedge.1
  %indvars.iv.next72.2 = or disjoint i64 %indvars.iv71, 3
  %611 = getelementptr inbounds [960 x double], ptr %0, i64 0, i64 %indvars.iv.next72.2
  %612 = load double, ptr %611, align 8, !tbaa !5
  %613 = fcmp une double %612, 1.000000e+00
  br i1 %613, label %614, label %.critedge.3

.critedge.3:                                      ; preds = %.critedge.2
  %indvars.iv.next72.3 = add nuw nsw i64 %indvars.iv71, 4
  %exitcond74.3 = icmp eq i64 %indvars.iv.next72.3, 256
  br i1 %exitcond74.3, label %.critedge40, label %.critedge.preheader, !llvm.loop !13

614:                                              ; preds = %.critedge.2, %.critedge.1, %.critedge, %.critedge.preheader
  %indvars.iv71.lcssa = phi i64 [ %indvars.iv71, %.critedge.preheader ], [ %indvars.iv.next72, %.critedge ], [ %indvars.iv.next72.1, %.critedge.1 ], [ %indvars.iv.next72.2, %.critedge.2 ]
  %.lcssa = phi double [ %603, %.critedge.preheader ], [ %606, %.critedge ], [ %609, %.critedge.1 ], [ %612, %.critedge.2 ]
  %615 = trunc nuw nsw i64 %indvars.iv71.lcssa to i32
  %616 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef %615, double noundef 1.000000e+00, double noundef %.lcssa)
  br label %.critedge40

.critedge40:                                      ; preds = %.critedge.3, %614
  %.str.4.sink = phi ptr [ @.str.3, %614 ], [ @.str.4, %.critedge.3 ]
  %.034 = phi i32 [ 1, %614 ], [ 0, %.critedge.3 ]
  %617 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) %.str.4.sink)
  call void @llvm.lifetime.end.p0(i64 7680, ptr nonnull %1) #4
  call void @llvm.lifetime.end.p0(i64 7680, ptr nonnull %0) #4
  ret i32 %.034
}

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


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