; LLVM IR from ROCm/aomp :: test/smoke/clang-host-targ2 (clang-host-targ2)

; 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 [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 = %76, %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 %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, 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 %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 [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
  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, 256
  br i1 %82, label %84, label %83

83:                                               ; preds = %80
  store i32 14, ptr %11, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  br label %101

84:                                               ; preds = %80
  %85 = load i32, ptr %14, align 4, !tbaa !5
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds [960 x double], ptr %3, i64 0, i64 %86
  %88 = load double, ptr %87, align 8, !tbaa !9
  %89 = fcmp une double %88, 1.000000e+00
  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 [960 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 1.000000e+00, double noundef %95)
  store i32 1, ptr %2, align 4, !tbaa !5
  br label %97

97:                                               ; preds = %90, %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 = %83
  %102 = load i32, ptr %2, align 4, !tbaa !5
  %103 = icmp ne i32 %102, 0
  br i1 %103, label %104, label %106

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

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

108:                                              ; preds = %106, %104
  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
  %109 = load i32, ptr %1, align 4
  ret i32 %109
}

; 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 [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
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(7680) %0, i8 0, i64 7680, 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 ]
  %2 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index
  %3 = getelementptr inbounds i8, ptr %2, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %2, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %3, align 16, !tbaa !5
  %index.next = or disjoint i64 %index, 4
  %4 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next
  %5 = getelementptr inbounds i8, ptr %4, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %4, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %5, align 16, !tbaa !5
  %index.next.1 = add nuw nsw i64 %index, 8
  %6 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next.1
  %7 = getelementptr inbounds i8, ptr %6, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %6, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %7, align 16, !tbaa !5
  %index.next.2 = add nuw nsw i64 %index, 12
  %8 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next.2
  %9 = getelementptr inbounds i8, ptr %8, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %8, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %9, align 16, !tbaa !5
  %index.next.3 = add nuw nsw i64 %index, 16
  %10 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next.3
  %11 = getelementptr inbounds i8, ptr %10, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %10, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %11, align 16, !tbaa !5
  %index.next.4 = add nuw nsw i64 %index, 20
  %12 = getelementptr inbounds [960 x double], ptr %1, i64 0, i64 %index.next.4
  %13 = getelementptr inbounds i8, ptr %12, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %12, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %13, align 16, !tbaa !5
  %index.next.5 = add nuw nsw i64 %index, 24
  %14 = icmp eq i64 %index.next.5, 960
  br i1 %14, label %vector.body75, label %vector.body, !llvm.loop !9

vector.body75:                                    ; preds = %vector.body
  %15 = getelementptr inbounds i8, ptr %1, i64 16
  %wide.load78 = load <2 x double>, ptr %1, align 16, !tbaa !5
  %wide.load79 = load <2 x double>, ptr %15, align 16, !tbaa !5
  %16 = fadd <2 x double> %wide.load78, zeroinitializer
  %17 = fadd <2 x double> %wide.load79, zeroinitializer
  %18 = getelementptr inbounds i8, ptr %0, i64 16
  %wide.load80 = load <2 x double>, ptr %0, align 16, !tbaa !5
  %wide.load81 = load <2 x double>, ptr %18, align 16, !tbaa !5
  %19 = fadd <2 x double> %wide.load80, %16
  %20 = fadd <2 x double> %wide.load81, %17
  store <2 x double> %19, ptr %0, align 16, !tbaa !5
  store <2 x double> %20, ptr %18, align 16, !tbaa !5
  %21 = getelementptr inbounds i8, ptr %1, i64 32
  %22 = getelementptr inbounds i8, ptr %1, i64 48
  %wide.load78.1 = load <2 x double>, ptr %21, align 16, !tbaa !5
  %wide.load79.1 = load <2 x double>, ptr %22, align 16, !tbaa !5
  %23 = fadd <2 x double> %wide.load78.1, zeroinitializer
  %24 = fadd <2 x double> %wide.load79.1, zeroinitializer
  %25 = getelementptr inbounds i8, ptr %0, i64 32
  %26 = getelementptr inbounds i8, ptr %0, i64 48
  %wide.load80.1 = load <2 x double>, ptr %25, align 16, !tbaa !5
  %wide.load81.1 = load <2 x double>, ptr %26, align 16, !tbaa !5
  %27 = fadd <2 x double> %wide.load80.1, %23
  %28 = fadd <2 x double> %wide.load81.1, %24
  store <2 x double> %27, ptr %25, align 16, !tbaa !5
  store <2 x double> %28, ptr %26, align 16, !tbaa !5
  %29 = getelementptr inbounds i8, ptr %1, i64 64
  %30 = getelementptr inbounds i8, ptr %1, i64 80
  %wide.load78.2 = load <2 x double>, ptr %29, align 16, !tbaa !5
  %wide.load79.2 = load <2 x double>, ptr %30, align 16, !tbaa !5
  %31 = fadd <2 x double> %wide.load78.2, zeroinitializer
  %32 = fadd <2 x double> %wide.load79.2, zeroinitializer
  %33 = getelementptr inbounds i8, ptr %0, i64 64
  %34 = getelementptr inbounds i8, ptr %0, i64 80
  %wide.load80.2 = load <2 x double>, ptr %33, align 16, !tbaa !5
  %wide.load81.2 = load <2 x double>, ptr %34, align 16, !tbaa !5
  %35 = fadd <2 x double> %wide.load80.2, %31
  %36 = fadd <2 x double> %wide.load81.2, %32
  store <2 x double> %35, ptr %33, align 16, !tbaa !5
  store <2 x double> %36, ptr %34, align 16, !tbaa !5
  %37 = getelementptr inbounds i8, ptr %1, i64 96
  %38 = getelementptr inbounds i8, ptr %1, i64 112
  %wide.load78.3 = load <2 x double>, ptr %37, align 16, !tbaa !5
  %wide.load79.3 = load <2 x double>, ptr %38, align 16, !tbaa !5
  %39 = fadd <2 x double> %wide.load78.3, zeroinitializer
  %40 = fadd <2 x double> %wide.load79.3, zeroinitializer
  %41 = getelementptr inbounds i8, ptr %0, i64 96
  %42 = getelementptr inbounds i8, ptr %0, i64 112
  %wide.load80.3 = load <2 x double>, ptr %41, align 16, !tbaa !5
  %wide.load81.3 = load <2 x double>, ptr %42, align 16, !tbaa !5
  %43 = fadd <2 x double> %wide.load80.3, %39
  %44 = fadd <2 x double> %wide.load81.3, %40
  store <2 x double> %43, ptr %41, align 16, !tbaa !5
  store <2 x double> %44, ptr %42, align 16, !tbaa !5
  %45 = getelementptr inbounds i8, ptr %1, i64 128
  %46 = getelementptr inbounds i8, ptr %1, i64 144
  %wide.load78.4 = load <2 x double>, ptr %45, align 16, !tbaa !5
  %wide.load79.4 = load <2 x double>, ptr %46, align 16, !tbaa !5
  %47 = fadd <2 x double> %wide.load78.4, zeroinitializer
  %48 = fadd <2 x double> %wide.load79.4, zeroinitializer
  %49 = getelementptr inbounds i8, ptr %0, i64 128
  %50 = getelementptr inbounds i8, ptr %0, i64 144
  %wide.load80.4 = load <2 x double>, ptr %49, align 16, !tbaa !5
  %wide.load81.4 = load <2 x double>, ptr %50, align 16, !tbaa !5
  %51 = fadd <2 x double> %wide.load80.4, %47
  %52 = fadd <2 x double> %wide.load81.4, %48
  store <2 x double> %51, ptr %49, align 16, !tbaa !5
  store <2 x double> %52, ptr %50, align 16, !tbaa !5
  %53 = getelementptr inbounds i8, ptr %1, i64 160
  %54 = getelementptr inbounds i8, ptr %1, i64 176
  %wide.load78.5 = load <2 x double>, ptr %53, align 16, !tbaa !5
  %wide.load79.5 = load <2 x double>, ptr %54, align 16, !tbaa !5
  %55 = fadd <2 x double> %wide.load78.5, zeroinitializer
  %56 = fadd <2 x double> %wide.load79.5, zeroinitializer
  %57 = getelementptr inbounds i8, ptr %0, i64 160
  %58 = getelementptr inbounds i8, ptr %0, i64 176
  %wide.load80.5 = load <2 x double>, ptr %57, align 16, !tbaa !5
  %wide.load81.5 = load <2 x double>, ptr %58, align 16, !tbaa !5
  %59 = fadd <2 x double> %wide.load80.5, %55
  %60 = fadd <2 x double> %wide.load81.5, %56
  store <2 x double> %59, ptr %57, align 16, !tbaa !5
  store <2 x double> %60, ptr %58, align 16, !tbaa !5
  %61 = getelementptr inbounds i8, ptr %1, i64 192
  %62 = getelementptr inbounds i8, ptr %1, i64 208
  %wide.load78.6 = load <2 x double>, ptr %61, align 16, !tbaa !5
  %wide.load79.6 = load <2 x double>, ptr %62, align 16, !tbaa !5
  %63 = fadd <2 x double> %wide.load78.6, zeroinitializer
  %64 = fadd <2 x double> %wide.load79.6, zeroinitializer
  %65 = getelementptr inbounds i8, ptr %0, i64 192
  %66 = getelementptr inbounds i8, ptr %0, i64 208
  %wide.load80.6 = load <2 x double>, ptr %65, align 16, !tbaa !5
  %wide.load81.6 = load <2 x double>, ptr %66, align 16, !tbaa !5
  %67 = fadd <2 x double> %wide.load80.6, %63
  %68 = fadd <2 x double> %wide.load81.6, %64
  store <2 x double> %67, ptr %65, align 16, !tbaa !5
  store <2 x double> %68, ptr %66, align 16, !tbaa !5
  %69 = getelementptr inbounds i8, ptr %1, i64 224
  %70 = getelementptr inbounds i8, ptr %1, i64 240
  %wide.load78.7 = load <2 x double>, ptr %69, align 16, !tbaa !5
  %wide.load79.7 = load <2 x double>, ptr %70, align 16, !tbaa !5
  %71 = fadd <2 x double> %wide.load78.7, zeroinitializer
  %72 = fadd <2 x double> %wide.load79.7, zeroinitializer
  %73 = getelementptr inbounds i8, ptr %0, i64 224
  %74 = getelementptr inbounds i8, ptr %0, i64 240
  %wide.load80.7 = load <2 x double>, ptr %73, align 16, !tbaa !5
  %wide.load81.7 = load <2 x double>, ptr %74, align 16, !tbaa !5
  %75 = fadd <2 x double> %wide.load80.7, %71
  %76 = fadd <2 x double> %wide.load81.7, %72
  store <2 x double> %75, ptr %73, align 16, !tbaa !5
  store <2 x double> %76, ptr %74, align 16, !tbaa !5
  %77 = getelementptr inbounds i8, ptr %1, i64 256
  %78 = getelementptr inbounds i8, ptr %1, i64 272
  %wide.load78.8 = load <2 x double>, ptr %77, align 16, !tbaa !5
  %wide.load79.8 = load <2 x double>, ptr %78, align 16, !tbaa !5
  %79 = fadd <2 x double> %wide.load78.8, zeroinitializer
  %80 = fadd <2 x double> %wide.load79.8, zeroinitializer
  %81 = getelementptr inbounds i8, ptr %0, i64 256
  %82 = getelementptr inbounds i8, ptr %0, i64 272
  %wide.load80.8 = load <2 x double>, ptr %81, align 16, !tbaa !5
  %wide.load81.8 = load <2 x double>, ptr %82, align 16, !tbaa !5
  %83 = fadd <2 x double> %wide.load80.8, %79
  %84 = fadd <2 x double> %wide.load81.8, %80
  store <2 x double> %83, ptr %81, align 16, !tbaa !5
  store <2 x double> %84, ptr %82, align 16, !tbaa !5
  %85 = getelementptr inbounds i8, ptr %1, i64 288
  %86 = getelementptr inbounds i8, ptr %1, i64 304
  %wide.load78.9 = load <2 x double>, ptr %85, align 16, !tbaa !5
  %wide.load79.9 = load <2 x double>, ptr %86, align 16, !tbaa !5
  %87 = fadd <2 x double> %wide.load78.9, zeroinitializer
  %88 = fadd <2 x double> %wide.load79.9, zeroinitializer
  %89 = getelementptr inbounds i8, ptr %0, i64 288
  %90 = getelementptr inbounds i8, ptr %0, i64 304
  %wide.load80.9 = load <2 x double>, ptr %89, align 16, !tbaa !5
  %wide.load81.9 = load <2 x double>, ptr %90, align 16, !tbaa !5
  %91 = fadd <2 x double> %wide.load80.9, %87
  %92 = fadd <2 x double> %wide.load81.9, %88
  store <2 x double> %91, ptr %89, align 16, !tbaa !5
  store <2 x double> %92, ptr %90, align 16, !tbaa !5
  %93 = getelementptr inbounds i8, ptr %1, i64 320
  %94 = getelementptr inbounds i8, ptr %1, i64 336
  %wide.load78.10 = load <2 x double>, ptr %93, align 16, !tbaa !5
  %wide.load79.10 = load <2 x double>, ptr %94, align 16, !tbaa !5
  %95 = fadd <2 x double> %wide.load78.10, zeroinitializer
  %96 = fadd <2 x double> %wide.load79.10, zeroinitializer
  %97 = getelementptr inbounds i8, ptr %0, i64 320
  %98 = getelementptr inbounds i8, ptr %0, i64 336
  %wide.load80.10 = load <2 x double>, ptr %97, align 16, !tbaa !5
  %wide.load81.10 = load <2 x double>, ptr %98, align 16, !tbaa !5
  %99 = fadd <2 x double> %wide.load80.10, %95
  %100 = fadd <2 x double> %wide.load81.10, %96
  store <2 x double> %99, ptr %97, align 16, !tbaa !5
  store <2 x double> %100, ptr %98, align 16, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %1, i64 352
  %102 = getelementptr inbounds i8, ptr %1, i64 368
  %wide.load78.11 = load <2 x double>, ptr %101, align 16, !tbaa !5
  %wide.load79.11 = load <2 x double>, ptr %102, align 16, !tbaa !5
  %103 = fadd <2 x double> %wide.load78.11, zeroinitializer
  %104 = fadd <2 x double> %wide.load79.11, zeroinitializer
  %105 = getelementptr inbounds i8, ptr %0, i64 352
  %106 = getelementptr inbounds i8, ptr %0, i64 368
  %wide.load80.11 = load <2 x double>, ptr %105, align 16, !tbaa !5
  %wide.load81.11 = load <2 x double>, ptr %106, align 16, !tbaa !5
  %107 = fadd <2 x double> %wide.load80.11, %103
  %108 = fadd <2 x double> %wide.load81.11, %104
  store <2 x double> %107, ptr %105, align 16, !tbaa !5
  store <2 x double> %108, ptr %106, align 16, !tbaa !5
  %109 = getelementptr inbounds i8, ptr %1, i64 384
  %110 = getelementptr inbounds i8, ptr %1, i64 400
  %wide.load78.12 = load <2 x double>, ptr %109, align 16, !tbaa !5
  %wide.load79.12 = load <2 x double>, ptr %110, align 16, !tbaa !5
  %111 = fadd <2 x double> %wide.load78.12, zeroinitializer
  %112 = fadd <2 x double> %wide.load79.12, zeroinitializer
  %113 = getelementptr inbounds i8, ptr %0, i64 384
  %114 = getelementptr inbounds i8, ptr %0, i64 400
  %wide.load80.12 = load <2 x double>, ptr %113, align 16, !tbaa !5
  %wide.load81.12 = load <2 x double>, ptr %114, align 16, !tbaa !5
  %115 = fadd <2 x double> %wide.load80.12, %111
  %116 = fadd <2 x double> %wide.load81.12, %112
  store <2 x double> %115, ptr %113, align 16, !tbaa !5
  store <2 x double> %116, ptr %114, align 16, !tbaa !5
  %117 = getelementptr inbounds i8, ptr %1, i64 416
  %118 = getelementptr inbounds i8, ptr %1, i64 432
  %wide.load78.13 = load <2 x double>, ptr %117, align 16, !tbaa !5
  %wide.load79.13 = load <2 x double>, ptr %118, align 16, !tbaa !5
  %119 = fadd <2 x double> %wide.load78.13, zeroinitializer
  %120 = fadd <2 x double> %wide.load79.13, zeroinitializer
  %121 = getelementptr inbounds i8, ptr %0, i64 416
  %122 = getelementptr inbounds i8, ptr %0, i64 432
  %wide.load80.13 = load <2 x double>, ptr %121, align 16, !tbaa !5
  %wide.load81.13 = load <2 x double>, ptr %122, align 16, !tbaa !5
  %123 = fadd <2 x double> %wide.load80.13, %119
  %124 = fadd <2 x double> %wide.load81.13, %120
  store <2 x double> %123, ptr %121, align 16, !tbaa !5
  store <2 x double> %124, ptr %122, align 16, !tbaa !5
  %125 = getelementptr inbounds i8, ptr %1, i64 448
  %126 = getelementptr inbounds i8, ptr %1, i64 464
  %wide.load78.14 = load <2 x double>, ptr %125, align 16, !tbaa !5
  %wide.load79.14 = load <2 x double>, ptr %126, align 16, !tbaa !5
  %127 = fadd <2 x double> %wide.load78.14, zeroinitializer
  %128 = fadd <2 x double> %wide.load79.14, zeroinitializer
  %129 = getelementptr inbounds i8, ptr %0, i64 448
  %130 = getelementptr inbounds i8, ptr %0, i64 464
  %wide.load80.14 = load <2 x double>, ptr %129, align 16, !tbaa !5
  %wide.load81.14 = load <2 x double>, ptr %130, align 16, !tbaa !5
  %131 = fadd <2 x double> %wide.load80.14, %127
  %132 = fadd <2 x double> %wide.load81.14, %128
  store <2 x double> %131, ptr %129, align 16, !tbaa !5
  store <2 x double> %132, ptr %130, align 16, !tbaa !5
  %133 = getelementptr inbounds i8, ptr %1, i64 480
  %134 = getelementptr inbounds i8, ptr %1, i64 496
  %wide.load78.15 = load <2 x double>, ptr %133, align 16, !tbaa !5
  %wide.load79.15 = load <2 x double>, ptr %134, align 16, !tbaa !5
  %135 = fadd <2 x double> %wide.load78.15, zeroinitializer
  %136 = fadd <2 x double> %wide.load79.15, zeroinitializer
  %137 = getelementptr inbounds i8, ptr %0, i64 480
  %138 = getelementptr inbounds i8, ptr %0, i64 496
  %wide.load80.15 = load <2 x double>, ptr %137, align 16, !tbaa !5
  %wide.load81.15 = load <2 x double>, ptr %138, align 16, !tbaa !5
  %139 = fadd <2 x double> %wide.load80.15, %135
  %140 = fadd <2 x double> %wide.load81.15, %136
  store <2 x double> %139, ptr %137, align 16, !tbaa !5
  store <2 x double> %140, ptr %138, align 16, !tbaa !5
  %141 = getelementptr inbounds i8, ptr %1, i64 512
  %142 = getelementptr inbounds i8, ptr %1, i64 528
  %wide.load91 = load <2 x double>, ptr %141, align 16, !tbaa !5
  %wide.load92 = load <2 x double>, ptr %142, align 16, !tbaa !5
  %143 = fadd <2 x double> %wide.load91, zeroinitializer
  %144 = fadd <2 x double> %wide.load92, zeroinitializer
  %145 = getelementptr inbounds i8, ptr %0, i64 512
  %146 = getelementptr inbounds i8, ptr %0, i64 528
  %wide.load93 = load <2 x double>, ptr %145, align 16, !tbaa !5
  %wide.load94 = load <2 x double>, ptr %146, align 16, !tbaa !5
  %147 = fadd <2 x double> %wide.load93, %143
  %148 = fadd <2 x double> %wide.load94, %144
  store <2 x double> %147, ptr %145, align 16, !tbaa !5
  store <2 x double> %148, ptr %146, align 16, !tbaa !5
  %149 = getelementptr inbounds i8, ptr %1, i64 544
  %150 = getelementptr inbounds i8, ptr %1, i64 560
  %wide.load91.1 = load <2 x double>, ptr %149, align 16, !tbaa !5
  %wide.load92.1 = load <2 x double>, ptr %150, align 16, !tbaa !5
  %151 = fadd <2 x double> %wide.load91.1, zeroinitializer
  %152 = fadd <2 x double> %wide.load92.1, zeroinitializer
  %153 = getelementptr inbounds i8, ptr %0, i64 544
  %154 = getelementptr inbounds i8, ptr %0, i64 560
  %wide.load93.1 = load <2 x double>, ptr %153, align 16, !tbaa !5
  %wide.load94.1 = load <2 x double>, ptr %154, align 16, !tbaa !5
  %155 = fadd <2 x double> %wide.load93.1, %151
  %156 = fadd <2 x double> %wide.load94.1, %152
  store <2 x double> %155, ptr %153, align 16, !tbaa !5
  store <2 x double> %156, ptr %154, align 16, !tbaa !5
  %157 = getelementptr inbounds i8, ptr %1, i64 576
  %158 = getelementptr inbounds i8, ptr %1, i64 592
  %wide.load91.2 = load <2 x double>, ptr %157, align 16, !tbaa !5
  %wide.load92.2 = load <2 x double>, ptr %158, align 16, !tbaa !5
  %159 = fadd <2 x double> %wide.load91.2, zeroinitializer
  %160 = fadd <2 x double> %wide.load92.2, zeroinitializer
  %161 = getelementptr inbounds i8, ptr %0, i64 576
  %162 = getelementptr inbounds i8, ptr %0, i64 592
  %wide.load93.2 = load <2 x double>, ptr %161, align 16, !tbaa !5
  %wide.load94.2 = load <2 x double>, ptr %162, align 16, !tbaa !5
  %163 = fadd <2 x double> %wide.load93.2, %159
  %164 = fadd <2 x double> %wide.load94.2, %160
  store <2 x double> %163, ptr %161, align 16, !tbaa !5
  store <2 x double> %164, ptr %162, align 16, !tbaa !5
  %165 = getelementptr inbounds i8, ptr %1, i64 608
  %166 = getelementptr inbounds i8, ptr %1, i64 624
  %wide.load91.3 = load <2 x double>, ptr %165, align 16, !tbaa !5
  %wide.load92.3 = load <2 x double>, ptr %166, align 16, !tbaa !5
  %167 = fadd <2 x double> %wide.load91.3, zeroinitializer
  %168 = fadd <2 x double> %wide.load92.3, zeroinitializer
  %169 = getelementptr inbounds i8, ptr %0, i64 608
  %170 = getelementptr inbounds i8, ptr %0, i64 624
  %wide.load93.3 = load <2 x double>, ptr %169, align 16, !tbaa !5
  %wide.load94.3 = load <2 x double>, ptr %170, align 16, !tbaa !5
  %171 = fadd <2 x double> %wide.load93.3, %167
  %172 = fadd <2 x double> %wide.load94.3, %168
  store <2 x double> %171, ptr %169, align 16, !tbaa !5
  store <2 x double> %172, ptr %170, align 16, !tbaa !5
  %173 = getelementptr inbounds i8, ptr %1, i64 640
  %174 = getelementptr inbounds i8, ptr %1, i64 656
  %wide.load91.4 = load <2 x double>, ptr %173, align 16, !tbaa !5
  %wide.load92.4 = load <2 x double>, ptr %174, align 16, !tbaa !5
  %175 = fadd <2 x double> %wide.load91.4, zeroinitializer
  %176 = fadd <2 x double> %wide.load92.4, zeroinitializer
  %177 = getelementptr inbounds i8, ptr %0, i64 640
  %178 = getelementptr inbounds i8, ptr %0, i64 656
  %wide.load93.4 = load <2 x double>, ptr %177, align 16, !tbaa !5
  %wide.load94.4 = load <2 x double>, ptr %178, align 16, !tbaa !5
  %179 = fadd <2 x double> %wide.load93.4, %175
  %180 = fadd <2 x double> %wide.load94.4, %176
  store <2 x double> %179, ptr %177, align 16, !tbaa !5
  store <2 x double> %180, ptr %178, align 16, !tbaa !5
  %181 = getelementptr inbounds i8, ptr %1, i64 672
  %182 = getelementptr inbounds i8, ptr %1, i64 688
  %wide.load91.5 = load <2 x double>, ptr %181, align 16, !tbaa !5
  %wide.load92.5 = load <2 x double>, ptr %182, align 16, !tbaa !5
  %183 = fadd <2 x double> %wide.load91.5, zeroinitializer
  %184 = fadd <2 x double> %wide.load92.5, zeroinitializer
  %185 = getelementptr inbounds i8, ptr %0, i64 672
  %186 = getelementptr inbounds i8, ptr %0, i64 688
  %wide.load93.5 = load <2 x double>, ptr %185, align 16, !tbaa !5
  %wide.load94.5 = load <2 x double>, ptr %186, align 16, !tbaa !5
  %187 = fadd <2 x double> %wide.load93.5, %183
  %188 = fadd <2 x double> %wide.load94.5, %184
  store <2 x double> %187, ptr %185, align 16, !tbaa !5
  store <2 x double> %188, ptr %186, align 16, !tbaa !5
  %189 = getelementptr inbounds i8, ptr %1, i64 704
  %190 = getelementptr inbounds i8, ptr %1, i64 720
  %wide.load91.6 = load <2 x double>, ptr %189, align 16, !tbaa !5
  %wide.load92.6 = load <2 x double>, ptr %190, align 16, !tbaa !5
  %191 = fadd <2 x double> %wide.load91.6, zeroinitializer
  %192 = fadd <2 x double> %wide.load92.6, zeroinitializer
  %193 = getelementptr inbounds i8, ptr %0, i64 704
  %194 = getelementptr inbounds i8, ptr %0, i64 720
  %wide.load93.6 = load <2 x double>, ptr %193, align 16, !tbaa !5
  %wide.load94.6 = load <2 x double>, ptr %194, align 16, !tbaa !5
  %195 = fadd <2 x double> %wide.load93.6, %191
  %196 = fadd <2 x double> %wide.load94.6, %192
  store <2 x double> %195, ptr %193, align 16, !tbaa !5
  store <2 x double> %196, ptr %194, align 16, !tbaa !5
  %197 = getelementptr inbounds i8, ptr %1, i64 736
  %198 = getelementptr inbounds i8, ptr %1, i64 752
  %wide.load91.7 = load <2 x double>, ptr %197, align 16, !tbaa !5
  %wide.load92.7 = load <2 x double>, ptr %198, align 16, !tbaa !5
  %199 = fadd <2 x double> %wide.load91.7, zeroinitializer
  %200 = fadd <2 x double> %wide.load92.7, zeroinitializer
  %201 = getelementptr inbounds i8, ptr %0, i64 736
  %202 = getelementptr inbounds i8, ptr %0, i64 752
  %wide.load93.7 = load <2 x double>, ptr %201, align 16, !tbaa !5
  %wide.load94.7 = load <2 x double>, ptr %202, align 16, !tbaa !5
  %203 = fadd <2 x double> %wide.load93.7, %199
  %204 = fadd <2 x double> %wide.load94.7, %200
  store <2 x double> %203, ptr %201, align 16, !tbaa !5
  store <2 x double> %204, ptr %202, align 16, !tbaa !5
  %205 = getelementptr inbounds i8, ptr %1, i64 768
  %206 = getelementptr inbounds i8, ptr %1, i64 784
  %wide.load91.8 = load <2 x double>, ptr %205, align 16, !tbaa !5
  %wide.load92.8 = load <2 x double>, ptr %206, align 16, !tbaa !5
  %207 = fadd <2 x double> %wide.load91.8, zeroinitializer
  %208 = fadd <2 x double> %wide.load92.8, zeroinitializer
  %209 = getelementptr inbounds i8, ptr %0, i64 768
  %210 = getelementptr inbounds i8, ptr %0, i64 784
  %wide.load93.8 = load <2 x double>, ptr %209, align 16, !tbaa !5
  %wide.load94.8 = load <2 x double>, ptr %210, align 16, !tbaa !5
  %211 = fadd <2 x double> %wide.load93.8, %207
  %212 = fadd <2 x double> %wide.load94.8, %208
  store <2 x double> %211, ptr %209, align 16, !tbaa !5
  store <2 x double> %212, ptr %210, align 16, !tbaa !5
  %213 = getelementptr inbounds i8, ptr %1, i64 800
  %214 = getelementptr inbounds i8, ptr %1, i64 816
  %wide.load91.9 = load <2 x double>, ptr %213, align 16, !tbaa !5
  %wide.load92.9 = load <2 x double>, ptr %214, align 16, !tbaa !5
  %215 = fadd <2 x double> %wide.load91.9, zeroinitializer
  %216 = fadd <2 x double> %wide.load92.9, zeroinitializer
  %217 = getelementptr inbounds i8, ptr %0, i64 800
  %218 = getelementptr inbounds i8, ptr %0, i64 816
  %wide.load93.9 = load <2 x double>, ptr %217, align 16, !tbaa !5
  %wide.load94.9 = load <2 x double>, ptr %218, align 16, !tbaa !5
  %219 = fadd <2 x double> %wide.load93.9, %215
  %220 = fadd <2 x double> %wide.load94.9, %216
  store <2 x double> %219, ptr %217, align 16, !tbaa !5
  store <2 x double> %220, ptr %218, align 16, !tbaa !5
  %221 = getelementptr inbounds i8, ptr %1, i64 832
  %222 = getelementptr inbounds i8, ptr %1, i64 848
  %wide.load91.10 = load <2 x double>, ptr %221, align 16, !tbaa !5
  %wide.load92.10 = load <2 x double>, ptr %222, align 16, !tbaa !5
  %223 = fadd <2 x double> %wide.load91.10, zeroinitializer
  %224 = fadd <2 x double> %wide.load92.10, zeroinitializer
  %225 = getelementptr inbounds i8, ptr %0, i64 832
  %226 = getelementptr inbounds i8, ptr %0, i64 848
  %wide.load93.10 = load <2 x double>, ptr %225, align 16, !tbaa !5
  %wide.load94.10 = load <2 x double>, ptr %226, align 16, !tbaa !5
  %227 = fadd <2 x double> %wide.load93.10, %223
  %228 = fadd <2 x double> %wide.load94.10, %224
  store <2 x double> %227, ptr %225, align 16, !tbaa !5
  store <2 x double> %228, ptr %226, align 16, !tbaa !5
  %229 = getelementptr inbounds i8, ptr %1, i64 864
  %230 = getelementptr inbounds i8, ptr %1, i64 880
  %wide.load91.11 = load <2 x double>, ptr %229, align 16, !tbaa !5
  %wide.load92.11 = load <2 x double>, ptr %230, align 16, !tbaa !5
  %231 = fadd <2 x double> %wide.load91.11, zeroinitializer
  %232 = fadd <2 x double> %wide.load92.11, zeroinitializer
  %233 = getelementptr inbounds i8, ptr %0, i64 864
  %234 = getelementptr inbounds i8, ptr %0, i64 880
  %wide.load93.11 = load <2 x double>, ptr %233, align 16, !tbaa !5
  %wide.load94.11 = load <2 x double>, ptr %234, align 16, !tbaa !5
  %235 = fadd <2 x double> %wide.load93.11, %231
  %236 = fadd <2 x double> %wide.load94.11, %232
  store <2 x double> %235, ptr %233, align 16, !tbaa !5
  store <2 x double> %236, ptr %234, align 16, !tbaa !5
  %237 = getelementptr inbounds i8, ptr %1, i64 896
  %238 = getelementptr inbounds i8, ptr %1, i64 912
  %wide.load91.12 = load <2 x double>, ptr %237, align 16, !tbaa !5
  %wide.load92.12 = load <2 x double>, ptr %238, align 16, !tbaa !5
  %239 = fadd <2 x double> %wide.load91.12, zeroinitializer
  %240 = fadd <2 x double> %wide.load92.12, zeroinitializer
  %241 = getelementptr inbounds i8, ptr %0, i64 896
  %242 = getelementptr inbounds i8, ptr %0, i64 912
  %wide.load93.12 = load <2 x double>, ptr %241, align 16, !tbaa !5
  %wide.load94.12 = load <2 x double>, ptr %242, align 16, !tbaa !5
  %243 = fadd <2 x double> %wide.load93.12, %239
  %244 = fadd <2 x double> %wide.load94.12, %240
  store <2 x double> %243, ptr %241, align 16, !tbaa !5
  store <2 x double> %244, ptr %242, align 16, !tbaa !5
  %245 = getelementptr inbounds i8, ptr %1, i64 928
  %246 = getelementptr inbounds i8, ptr %1, i64 944
  %wide.load91.13 = load <2 x double>, ptr %245, align 16, !tbaa !5
  %wide.load92.13 = load <2 x double>, ptr %246, align 16, !tbaa !5
  %247 = fadd <2 x double> %wide.load91.13, zeroinitializer
  %248 = fadd <2 x double> %wide.load92.13, zeroinitializer
  %249 = getelementptr inbounds i8, ptr %0, i64 928
  %250 = getelementptr inbounds i8, ptr %0, i64 944
  %wide.load93.13 = load <2 x double>, ptr %249, align 16, !tbaa !5
  %wide.load94.13 = load <2 x double>, ptr %250, align 16, !tbaa !5
  %251 = fadd <2 x double> %wide.load93.13, %247
  %252 = fadd <2 x double> %wide.load94.13, %248
  store <2 x double> %251, ptr %249, align 16, !tbaa !5
  store <2 x double> %252, ptr %250, align 16, !tbaa !5
  %253 = getelementptr inbounds i8, ptr %1, i64 960
  %254 = getelementptr inbounds i8, ptr %1, i64 976
  %wide.load91.14 = load <2 x double>, ptr %253, align 16, !tbaa !5
  %wide.load92.14 = load <2 x double>, ptr %254, align 16, !tbaa !5
  %255 = fadd <2 x double> %wide.load91.14, zeroinitializer
  %256 = fadd <2 x double> %wide.load92.14, zeroinitializer
  %257 = getelementptr inbounds i8, ptr %0, i64 960
  %258 = getelementptr inbounds i8, ptr %0, i64 976
  %wide.load93.14 = load <2 x double>, ptr %257, align 16, !tbaa !5
  %wide.load94.14 = load <2 x double>, ptr %258, align 16, !tbaa !5
  %259 = fadd <2 x double> %wide.load93.14, %255
  %260 = fadd <2 x double> %wide.load94.14, %256
  store <2 x double> %259, ptr %257, align 16, !tbaa !5
  store <2 x double> %260, ptr %258, align 16, !tbaa !5
  %261 = getelementptr inbounds i8, ptr %1, i64 992
  %262 = getelementptr inbounds i8, ptr %1, i64 1008
  %wide.load91.15 = load <2 x double>, ptr %261, align 16, !tbaa !5
  %wide.load92.15 = load <2 x double>, ptr %262, align 16, !tbaa !5
  %263 = fadd <2 x double> %wide.load91.15, zeroinitializer
  %264 = fadd <2 x double> %wide.load92.15, zeroinitializer
  %265 = getelementptr inbounds i8, ptr %0, i64 992
  %266 = getelementptr inbounds i8, ptr %0, i64 1008
  %wide.load93.15 = load <2 x double>, ptr %265, align 16, !tbaa !5
  %wide.load94.15 = load <2 x double>, ptr %266, align 16, !tbaa !5
  %267 = fadd <2 x double> %wide.load93.15, %263
  %268 = fadd <2 x double> %wide.load94.15, %264
  store <2 x double> %267, ptr %265, align 16, !tbaa !5
  store <2 x double> %268, ptr %266, align 16, !tbaa !5
  %269 = getelementptr inbounds i8, ptr %1, i64 1024
  %270 = getelementptr inbounds i8, ptr %1, i64 1040
  %wide.load105 = load <2 x double>, ptr %269, align 16, !tbaa !5
  %wide.load106 = load <2 x double>, ptr %270, align 16, !tbaa !5
  %271 = fadd <2 x double> %wide.load105, zeroinitializer
  %272 = fadd <2 x double> %wide.load106, zeroinitializer
  %273 = getelementptr inbounds i8, ptr %0, i64 1024
  %274 = getelementptr inbounds i8, ptr %0, i64 1040
  %wide.load107 = load <2 x double>, ptr %273, align 16, !tbaa !5
  %wide.load108 = load <2 x double>, ptr %274, align 16, !tbaa !5
  %275 = fadd <2 x double> %wide.load107, %271
  %276 = fadd <2 x double> %wide.load108, %272
  store <2 x double> %275, ptr %273, align 16, !tbaa !5
  store <2 x double> %276, ptr %274, align 16, !tbaa !5
  %277 = getelementptr inbounds i8, ptr %1, i64 1056
  %278 = getelementptr inbounds i8, ptr %1, i64 1072
  %wide.load105.1 = load <2 x double>, ptr %277, align 16, !tbaa !5
  %wide.load106.1 = load <2 x double>, ptr %278, align 16, !tbaa !5
  %279 = fadd <2 x double> %wide.load105.1, zeroinitializer
  %280 = fadd <2 x double> %wide.load106.1, zeroinitializer
  %281 = getelementptr inbounds i8, ptr %0, i64 1056
  %282 = getelementptr inbounds i8, ptr %0, i64 1072
  %wide.load107.1 = load <2 x double>, ptr %281, align 16, !tbaa !5
  %wide.load108.1 = load <2 x double>, ptr %282, align 16, !tbaa !5
  %283 = fadd <2 x double> %wide.load107.1, %279
  %284 = fadd <2 x double> %wide.load108.1, %280
  store <2 x double> %283, ptr %281, align 16, !tbaa !5
  store <2 x double> %284, ptr %282, align 16, !tbaa !5
  %285 = getelementptr inbounds i8, ptr %1, i64 1088
  %286 = getelementptr inbounds i8, ptr %1, i64 1104
  %wide.load105.2 = load <2 x double>, ptr %285, align 16, !tbaa !5
  %wide.load106.2 = load <2 x double>, ptr %286, align 16, !tbaa !5
  %287 = fadd <2 x double> %wide.load105.2, zeroinitializer
  %288 = fadd <2 x double> %wide.load106.2, zeroinitializer
  %289 = getelementptr inbounds i8, ptr %0, i64 1088
  %290 = getelementptr inbounds i8, ptr %0, i64 1104
  %wide.load107.2 = load <2 x double>, ptr %289, align 16, !tbaa !5
  %wide.load108.2 = load <2 x double>, ptr %290, align 16, !tbaa !5
  %291 = fadd <2 x double> %wide.load107.2, %287
  %292 = fadd <2 x double> %wide.load108.2, %288
  store <2 x double> %291, ptr %289, align 16, !tbaa !5
  store <2 x double> %292, ptr %290, align 16, !tbaa !5
  %293 = getelementptr inbounds i8, ptr %1, i64 1120
  %294 = getelementptr inbounds i8, ptr %1, i64 1136
  %wide.load105.3 = load <2 x double>, ptr %293, align 16, !tbaa !5
  %wide.load106.3 = load <2 x double>, ptr %294, align 16, !tbaa !5
  %295 = fadd <2 x double> %wide.load105.3, zeroinitializer
  %296 = fadd <2 x double> %wide.load106.3, zeroinitializer
  %297 = getelementptr inbounds i8, ptr %0, i64 1120
  %298 = getelementptr inbounds i8, ptr %0, i64 1136
  %wide.load107.3 = load <2 x double>, ptr %297, align 16, !tbaa !5
  %wide.load108.3 = load <2 x double>, ptr %298, align 16, !tbaa !5
  %299 = fadd <2 x double> %wide.load107.3, %295
  %300 = fadd <2 x double> %wide.load108.3, %296
  store <2 x double> %299, ptr %297, align 16, !tbaa !5
  store <2 x double> %300, ptr %298, align 16, !tbaa !5
  %301 = getelementptr inbounds i8, ptr %1, i64 1152
  %302 = getelementptr inbounds i8, ptr %1, i64 1168
  %wide.load105.4 = load <2 x double>, ptr %301, align 16, !tbaa !5
  %wide.load106.4 = load <2 x double>, ptr %302, align 16, !tbaa !5
  %303 = fadd <2 x double> %wide.load105.4, zeroinitializer
  %304 = fadd <2 x double> %wide.load106.4, zeroinitializer
  %305 = getelementptr inbounds i8, ptr %0, i64 1152
  %306 = getelementptr inbounds i8, ptr %0, i64 1168
  %wide.load107.4 = load <2 x double>, ptr %305, align 16, !tbaa !5
  %wide.load108.4 = load <2 x double>, ptr %306, align 16, !tbaa !5
  %307 = fadd <2 x double> %wide.load107.4, %303
  %308 = fadd <2 x double> %wide.load108.4, %304
  store <2 x double> %307, ptr %305, align 16, !tbaa !5
  store <2 x double> %308, ptr %306, align 16, !tbaa !5
  %309 = getelementptr inbounds i8, ptr %1, i64 1184
  %310 = getelementptr inbounds i8, ptr %1, i64 1200
  %wide.load105.5 = load <2 x double>, ptr %309, align 16, !tbaa !5
  %wide.load106.5 = load <2 x double>, ptr %310, align 16, !tbaa !5
  %311 = fadd <2 x double> %wide.load105.5, zeroinitializer
  %312 = fadd <2 x double> %wide.load106.5, zeroinitializer
  %313 = getelementptr inbounds i8, ptr %0, i64 1184
  %314 = getelementptr inbounds i8, ptr %0, i64 1200
  %wide.load107.5 = load <2 x double>, ptr %313, align 16, !tbaa !5
  %wide.load108.5 = load <2 x double>, ptr %314, align 16, !tbaa !5
  %315 = fadd <2 x double> %wide.load107.5, %311
  %316 = fadd <2 x double> %wide.load108.5, %312
  store <2 x double> %315, ptr %313, align 16, !tbaa !5
  store <2 x double> %316, ptr %314, align 16, !tbaa !5
  %317 = getelementptr inbounds i8, ptr %1, i64 1216
  %318 = getelementptr inbounds i8, ptr %1, i64 1232
  %wide.load105.6 = load <2 x double>, ptr %317, align 16, !tbaa !5
  %wide.load106.6 = load <2 x double>, ptr %318, align 16, !tbaa !5
  %319 = fadd <2 x double> %wide.load105.6, zeroinitializer
  %320 = fadd <2 x double> %wide.load106.6, zeroinitializer
  %321 = getelementptr inbounds i8, ptr %0, i64 1216
  %322 = getelementptr inbounds i8, ptr %0, i64 1232
  %wide.load107.6 = load <2 x double>, ptr %321, align 16, !tbaa !5
  %wide.load108.6 = load <2 x double>, ptr %322, align 16, !tbaa !5
  %323 = fadd <2 x double> %wide.load107.6, %319
  %324 = fadd <2 x double> %wide.load108.6, %320
  store <2 x double> %323, ptr %321, align 16, !tbaa !5
  store <2 x double> %324, ptr %322, align 16, !tbaa !5
  %325 = getelementptr inbounds i8, ptr %1, i64 1248
  %326 = getelementptr inbounds i8, ptr %1, i64 1264
  %wide.load105.7 = load <2 x double>, ptr %325, align 16, !tbaa !5
  %wide.load106.7 = load <2 x double>, ptr %326, align 16, !tbaa !5
  %327 = fadd <2 x double> %wide.load105.7, zeroinitializer
  %328 = fadd <2 x double> %wide.load106.7, zeroinitializer
  %329 = getelementptr inbounds i8, ptr %0, i64 1248
  %330 = getelementptr inbounds i8, ptr %0, i64 1264
  %wide.load107.7 = load <2 x double>, ptr %329, align 16, !tbaa !5
  %wide.load108.7 = load <2 x double>, ptr %330, align 16, !tbaa !5
  %331 = fadd <2 x double> %wide.load107.7, %327
  %332 = fadd <2 x double> %wide.load108.7, %328
  store <2 x double> %331, ptr %329, align 16, !tbaa !5
  store <2 x double> %332, ptr %330, align 16, !tbaa !5
  %333 = getelementptr inbounds i8, ptr %1, i64 1280
  %334 = getelementptr inbounds i8, ptr %1, i64 1296
  %wide.load105.8 = load <2 x double>, ptr %333, align 16, !tbaa !5
  %wide.load106.8 = load <2 x double>, ptr %334, align 16, !tbaa !5
  %335 = fadd <2 x double> %wide.load105.8, zeroinitializer
  %336 = fadd <2 x double> %wide.load106.8, zeroinitializer
  %337 = getelementptr inbounds i8, ptr %0, i64 1280
  %338 = getelementptr inbounds i8, ptr %0, i64 1296
  %wide.load107.8 = load <2 x double>, ptr %337, align 16, !tbaa !5
  %wide.load108.8 = load <2 x double>, ptr %338, align 16, !tbaa !5
  %339 = fadd <2 x double> %wide.load107.8, %335
  %340 = fadd <2 x double> %wide.load108.8, %336
  store <2 x double> %339, ptr %337, align 16, !tbaa !5
  store <2 x double> %340, ptr %338, align 16, !tbaa !5
  %341 = getelementptr inbounds i8, ptr %1, i64 1312
  %342 = getelementptr inbounds i8, ptr %1, i64 1328
  %wide.load105.9 = load <2 x double>, ptr %341, align 16, !tbaa !5
  %wide.load106.9 = load <2 x double>, ptr %342, align 16, !tbaa !5
  %343 = fadd <2 x double> %wide.load105.9, zeroinitializer
  %344 = fadd <2 x double> %wide.load106.9, zeroinitializer
  %345 = getelementptr inbounds i8, ptr %0, i64 1312
  %346 = getelementptr inbounds i8, ptr %0, i64 1328
  %wide.load107.9 = load <2 x double>, ptr %345, align 16, !tbaa !5
  %wide.load108.9 = load <2 x double>, ptr %346, align 16, !tbaa !5
  %347 = fadd <2 x double> %wide.load107.9, %343
  %348 = fadd <2 x double> %wide.load108.9, %344
  store <2 x double> %347, ptr %345, align 16, !tbaa !5
  store <2 x double> %348, ptr %346, align 16, !tbaa !5
  %349 = getelementptr inbounds i8, ptr %1, i64 1344
  %350 = getelementptr inbounds i8, ptr %1, i64 1360
  %wide.load105.10 = load <2 x double>, ptr %349, align 16, !tbaa !5
  %wide.load106.10 = load <2 x double>, ptr %350, align 16, !tbaa !5
  %351 = fadd <2 x double> %wide.load105.10, zeroinitializer
  %352 = fadd <2 x double> %wide.load106.10, zeroinitializer
  %353 = getelementptr inbounds i8, ptr %0, i64 1344
  %354 = getelementptr inbounds i8, ptr %0, i64 1360
  %wide.load107.10 = load <2 x double>, ptr %353, align 16, !tbaa !5
  %wide.load108.10 = load <2 x double>, ptr %354, align 16, !tbaa !5
  %355 = fadd <2 x double> %wide.load107.10, %351
  %356 = fadd <2 x double> %wide.load108.10, %352
  store <2 x double> %355, ptr %353, align 16, !tbaa !5
  store <2 x double> %356, ptr %354, align 16, !tbaa !5
  %357 = getelementptr inbounds i8, ptr %1, i64 1376
  %358 = getelementptr inbounds i8, ptr %1, i64 1392
  %wide.load105.11 = load <2 x double>, ptr %357, align 16, !tbaa !5
  %wide.load106.11 = load <2 x double>, ptr %358, align 16, !tbaa !5
  %359 = fadd <2 x double> %wide.load105.11, zeroinitializer
  %360 = fadd <2 x double> %wide.load106.11, zeroinitializer
  %361 = getelementptr inbounds i8, ptr %0, i64 1376
  %362 = getelementptr inbounds i8, ptr %0, i64 1392
  %wide.load107.11 = load <2 x double>, ptr %361, align 16, !tbaa !5
  %wide.load108.11 = load <2 x double>, ptr %362, align 16, !tbaa !5
  %363 = fadd <2 x double> %wide.load107.11, %359
  %364 = fadd <2 x double> %wide.load108.11, %360
  store <2 x double> %363, ptr %361, align 16, !tbaa !5
  store <2 x double> %364, ptr %362, align 16, !tbaa !5
  %365 = getelementptr inbounds i8, ptr %1, i64 1408
  %366 = getelementptr inbounds i8, ptr %1, i64 1424
  %wide.load105.12 = load <2 x double>, ptr %365, align 16, !tbaa !5
  %wide.load106.12 = load <2 x double>, ptr %366, align 16, !tbaa !5
  %367 = fadd <2 x double> %wide.load105.12, zeroinitializer
  %368 = fadd <2 x double> %wide.load106.12, zeroinitializer
  %369 = getelementptr inbounds i8, ptr %0, i64 1408
  %370 = getelementptr inbounds i8, ptr %0, i64 1424
  %wide.load107.12 = load <2 x double>, ptr %369, align 16, !tbaa !5
  %wide.load108.12 = load <2 x double>, ptr %370, align 16, !tbaa !5
  %371 = fadd <2 x double> %wide.load107.12, %367
  %372 = fadd <2 x double> %wide.load108.12, %368
  store <2 x double> %371, ptr %369, align 16, !tbaa !5
  store <2 x double> %372, ptr %370, align 16, !tbaa !5
  %373 = getelementptr inbounds i8, ptr %1, i64 1440
  %374 = getelementptr inbounds i8, ptr %1, i64 1456
  %wide.load105.13 = load <2 x double>, ptr %373, align 16, !tbaa !5
  %wide.load106.13 = load <2 x double>, ptr %374, align 16, !tbaa !5
  %375 = fadd <2 x double> %wide.load105.13, zeroinitializer
  %376 = fadd <2 x double> %wide.load106.13, zeroinitializer
  %377 = getelementptr inbounds i8, ptr %0, i64 1440
  %378 = getelementptr inbounds i8, ptr %0, i64 1456
  %wide.load107.13 = load <2 x double>, ptr %377, align 16, !tbaa !5
  %wide.load108.13 = load <2 x double>, ptr %378, align 16, !tbaa !5
  %379 = fadd <2 x double> %wide.load107.13, %375
  %380 = fadd <2 x double> %wide.load108.13, %376
  store <2 x double> %379, ptr %377, align 16, !tbaa !5
  store <2 x double> %380, ptr %378, align 16, !tbaa !5
  %381 = getelementptr inbounds i8, ptr %1, i64 1472
  %382 = getelementptr inbounds i8, ptr %1, i64 1488
  %wide.load105.14 = load <2 x double>, ptr %381, align 16, !tbaa !5
  %wide.load106.14 = load <2 x double>, ptr %382, align 16, !tbaa !5
  %383 = fadd <2 x double> %wide.load105.14, zeroinitializer
  %384 = fadd <2 x double> %wide.load106.14, zeroinitializer
  %385 = getelementptr inbounds i8, ptr %0, i64 1472
  %386 = getelementptr inbounds i8, ptr %0, i64 1488
  %wide.load107.14 = load <2 x double>, ptr %385, align 16, !tbaa !5
  %wide.load108.14 = load <2 x double>, ptr %386, align 16, !tbaa !5
  %387 = fadd <2 x double> %wide.load107.14, %383
  %388 = fadd <2 x double> %wide.load108.14, %384
  store <2 x double> %387, ptr %385, align 16, !tbaa !5
  store <2 x double> %388, ptr %386, align 16, !tbaa !5
  %389 = getelementptr inbounds i8, ptr %1, i64 1504
  %390 = getelementptr inbounds i8, ptr %1, i64 1520
  %wide.load105.15 = load <2 x double>, ptr %389, align 16, !tbaa !5
  %wide.load106.15 = load <2 x double>, ptr %390, align 16, !tbaa !5
  %391 = fadd <2 x double> %wide.load105.15, zeroinitializer
  %392 = fadd <2 x double> %wide.load106.15, zeroinitializer
  %393 = getelementptr inbounds i8, ptr %0, i64 1504
  %394 = getelementptr inbounds i8, ptr %0, i64 1520
  %wide.load107.15 = load <2 x double>, ptr %393, align 16, !tbaa !5
  %wide.load108.15 = load <2 x double>, ptr %394, align 16, !tbaa !5
  %395 = fadd <2 x double> %wide.load107.15, %391
  %396 = fadd <2 x double> %wide.load108.15, %392
  store <2 x double> %395, ptr %393, align 16, !tbaa !5
  store <2 x double> %396, ptr %394, align 16, !tbaa !5
  %397 = getelementptr inbounds i8, ptr %1, i64 1536
  %398 = getelementptr inbounds i8, ptr %1, i64 1552
  %wide.load119 = load <2 x double>, ptr %397, align 16, !tbaa !5
  %wide.load120 = load <2 x double>, ptr %398, align 16, !tbaa !5
  %399 = fadd <2 x double> %wide.load119, zeroinitializer
  %400 = fadd <2 x double> %wide.load120, zeroinitializer
  %401 = getelementptr inbounds i8, ptr %0, i64 1536
  %402 = getelementptr inbounds i8, ptr %0, i64 1552
  %wide.load121 = load <2 x double>, ptr %401, align 16, !tbaa !5
  %wide.load122 = load <2 x double>, ptr %402, align 16, !tbaa !5
  %403 = fadd <2 x double> %wide.load121, %399
  %404 = fadd <2 x double> %wide.load122, %400
  store <2 x double> %403, ptr %401, align 16, !tbaa !5
  store <2 x double> %404, ptr %402, align 16, !tbaa !5
  %405 = getelementptr inbounds i8, ptr %1, i64 1568
  %406 = getelementptr inbounds i8, ptr %1, i64 1584
  %wide.load119.1 = load <2 x double>, ptr %405, align 16, !tbaa !5
  %wide.load120.1 = load <2 x double>, ptr %406, align 16, !tbaa !5
  %407 = fadd <2 x double> %wide.load119.1, zeroinitializer
  %408 = fadd <2 x double> %wide.load120.1, zeroinitializer
  %409 = getelementptr inbounds i8, ptr %0, i64 1568
  %410 = getelementptr inbounds i8, ptr %0, i64 1584
  %wide.load121.1 = load <2 x double>, ptr %409, align 16, !tbaa !5
  %wide.load122.1 = load <2 x double>, ptr %410, align 16, !tbaa !5
  %411 = fadd <2 x double> %wide.load121.1, %407
  %412 = fadd <2 x double> %wide.load122.1, %408
  store <2 x double> %411, ptr %409, align 16, !tbaa !5
  store <2 x double> %412, ptr %410, align 16, !tbaa !5
  %413 = getelementptr inbounds i8, ptr %1, i64 1600
  %414 = getelementptr inbounds i8, ptr %1, i64 1616
  %wide.load119.2 = load <2 x double>, ptr %413, align 16, !tbaa !5
  %wide.load120.2 = load <2 x double>, ptr %414, align 16, !tbaa !5
  %415 = fadd <2 x double> %wide.load119.2, zeroinitializer
  %416 = fadd <2 x double> %wide.load120.2, zeroinitializer
  %417 = getelementptr inbounds i8, ptr %0, i64 1600
  %418 = getelementptr inbounds i8, ptr %0, i64 1616
  %wide.load121.2 = load <2 x double>, ptr %417, align 16, !tbaa !5
  %wide.load122.2 = load <2 x double>, ptr %418, align 16, !tbaa !5
  %419 = fadd <2 x double> %wide.load121.2, %415
  %420 = fadd <2 x double> %wide.load122.2, %416
  store <2 x double> %419, ptr %417, align 16, !tbaa !5
  store <2 x double> %420, ptr %418, align 16, !tbaa !5
  %421 = getelementptr inbounds i8, ptr %1, i64 1632
  %422 = getelementptr inbounds i8, ptr %1, i64 1648
  %wide.load119.3 = load <2 x double>, ptr %421, align 16, !tbaa !5
  %wide.load120.3 = load <2 x double>, ptr %422, align 16, !tbaa !5
  %423 = fadd <2 x double> %wide.load119.3, zeroinitializer
  %424 = fadd <2 x double> %wide.load120.3, zeroinitializer
  %425 = getelementptr inbounds i8, ptr %0, i64 1632
  %426 = getelementptr inbounds i8, ptr %0, i64 1648
  %wide.load121.3 = load <2 x double>, ptr %425, align 16, !tbaa !5
  %wide.load122.3 = load <2 x double>, ptr %426, align 16, !tbaa !5
  %427 = fadd <2 x double> %wide.load121.3, %423
  %428 = fadd <2 x double> %wide.load122.3, %424
  store <2 x double> %427, ptr %425, align 16, !tbaa !5
  store <2 x double> %428, ptr %426, align 16, !tbaa !5
  %429 = getelementptr inbounds i8, ptr %1, i64 1664
  %430 = getelementptr inbounds i8, ptr %1, i64 1680
  %wide.load119.4 = load <2 x double>, ptr %429, align 16, !tbaa !5
  %wide.load120.4 = load <2 x double>, ptr %430, align 16, !tbaa !5
  %431 = fadd <2 x double> %wide.load119.4, zeroinitializer
  %432 = fadd <2 x double> %wide.load120.4, zeroinitializer
  %433 = getelementptr inbounds i8, ptr %0, i64 1664
  %434 = getelementptr inbounds i8, ptr %0, i64 1680
  %wide.load121.4 = load <2 x double>, ptr %433, align 16, !tbaa !5
  %wide.load122.4 = load <2 x double>, ptr %434, align 16, !tbaa !5
  %435 = fadd <2 x double> %wide.load121.4, %431
  %436 = fadd <2 x double> %wide.load122.4, %432
  store <2 x double> %435, ptr %433, align 16, !tbaa !5
  store <2 x double> %436, ptr %434, align 16, !tbaa !5
  %437 = getelementptr inbounds i8, ptr %1, i64 1696
  %438 = getelementptr inbounds i8, ptr %1, i64 1712
  %wide.load119.5 = load <2 x double>, ptr %437, align 16, !tbaa !5
  %wide.load120.5 = load <2 x double>, ptr %438, align 16, !tbaa !5
  %439 = fadd <2 x double> %wide.load119.5, zeroinitializer
  %440 = fadd <2 x double> %wide.load120.5, zeroinitializer
  %441 = getelementptr inbounds i8, ptr %0, i64 1696
  %442 = getelementptr inbounds i8, ptr %0, i64 1712
  %wide.load121.5 = load <2 x double>, ptr %441, align 16, !tbaa !5
  %wide.load122.5 = load <2 x double>, ptr %442, align 16, !tbaa !5
  %443 = fadd <2 x double> %wide.load121.5, %439
  %444 = fadd <2 x double> %wide.load122.5, %440
  store <2 x double> %443, ptr %441, align 16, !tbaa !5
  store <2 x double> %444, ptr %442, align 16, !tbaa !5
  %445 = getelementptr inbounds i8, ptr %1, i64 1728
  %446 = getelementptr inbounds i8, ptr %1, i64 1744
  %wide.load119.6 = load <2 x double>, ptr %445, align 16, !tbaa !5
  %wide.load120.6 = load <2 x double>, ptr %446, align 16, !tbaa !5
  %447 = fadd <2 x double> %wide.load119.6, zeroinitializer
  %448 = fadd <2 x double> %wide.load120.6, zeroinitializer
  %449 = getelementptr inbounds i8, ptr %0, i64 1728
  %450 = getelementptr inbounds i8, ptr %0, i64 1744
  %wide.load121.6 = load <2 x double>, ptr %449, align 16, !tbaa !5
  %wide.load122.6 = load <2 x double>, ptr %450, align 16, !tbaa !5
  %451 = fadd <2 x double> %wide.load121.6, %447
  %452 = fadd <2 x double> %wide.load122.6, %448
  store <2 x double> %451, ptr %449, align 16, !tbaa !5
  store <2 x double> %452, ptr %450, align 16, !tbaa !5
  %453 = getelementptr inbounds i8, ptr %1, i64 1760
  %454 = getelementptr inbounds i8, ptr %1, i64 1776
  %wide.load119.7 = load <2 x double>, ptr %453, align 16, !tbaa !5
  %wide.load120.7 = load <2 x double>, ptr %454, align 16, !tbaa !5
  %455 = fadd <2 x double> %wide.load119.7, zeroinitializer
  %456 = fadd <2 x double> %wide.load120.7, zeroinitializer
  %457 = getelementptr inbounds i8, ptr %0, i64 1760
  %458 = getelementptr inbounds i8, ptr %0, i64 1776
  %wide.load121.7 = load <2 x double>, ptr %457, align 16, !tbaa !5
  %wide.load122.7 = load <2 x double>, ptr %458, align 16, !tbaa !5
  %459 = fadd <2 x double> %wide.load121.7, %455
  %460 = fadd <2 x double> %wide.load122.7, %456
  store <2 x double> %459, ptr %457, align 16, !tbaa !5
  store <2 x double> %460, ptr %458, align 16, !tbaa !5
  %461 = getelementptr inbounds i8, ptr %1, i64 1792
  %462 = getelementptr inbounds i8, ptr %1, i64 1808
  %wide.load119.8 = load <2 x double>, ptr %461, align 16, !tbaa !5
  %wide.load120.8 = load <2 x double>, ptr %462, align 16, !tbaa !5
  %463 = fadd <2 x double> %wide.load119.8, zeroinitializer
  %464 = fadd <2 x double> %wide.load120.8, zeroinitializer
  %465 = getelementptr inbounds i8, ptr %0, i64 1792
  %466 = getelementptr inbounds i8, ptr %0, i64 1808
  %wide.load121.8 = load <2 x double>, ptr %465, align 16, !tbaa !5
  %wide.load122.8 = load <2 x double>, ptr %466, align 16, !tbaa !5
  %467 = fadd <2 x double> %wide.load121.8, %463
  %468 = fadd <2 x double> %wide.load122.8, %464
  store <2 x double> %467, ptr %465, align 16, !tbaa !5
  store <2 x double> %468, ptr %466, align 16, !tbaa !5
  %469 = getelementptr inbounds i8, ptr %1, i64 1824
  %470 = getelementptr inbounds i8, ptr %1, i64 1840
  %wide.load119.9 = load <2 x double>, ptr %469, align 16, !tbaa !5
  %wide.load120.9 = load <2 x double>, ptr %470, align 16, !tbaa !5
  %471 = fadd <2 x double> %wide.load119.9, zeroinitializer
  %472 = fadd <2 x double> %wide.load120.9, zeroinitializer
  %473 = getelementptr inbounds i8, ptr %0, i64 1824
  %474 = getelementptr inbounds i8, ptr %0, i64 1840
  %wide.load121.9 = load <2 x double>, ptr %473, align 16, !tbaa !5
  %wide.load122.9 = load <2 x double>, ptr %474, align 16, !tbaa !5
  %475 = fadd <2 x double> %wide.load121.9, %471
  %476 = fadd <2 x double> %wide.load122.9, %472
  store <2 x double> %475, ptr %473, align 16, !tbaa !5
  store <2 x double> %476, ptr %474, align 16, !tbaa !5
  %477 = getelementptr inbounds i8, ptr %1, i64 1856
  %478 = getelementptr inbounds i8, ptr %1, i64 1872
  %wide.load119.10 = load <2 x double>, ptr %477, align 16, !tbaa !5
  %wide.load120.10 = load <2 x double>, ptr %478, align 16, !tbaa !5
  %479 = fadd <2 x double> %wide.load119.10, zeroinitializer
  %480 = fadd <2 x double> %wide.load120.10, zeroinitializer
  %481 = getelementptr inbounds i8, ptr %0, i64 1856
  %482 = getelementptr inbounds i8, ptr %0, i64 1872
  %wide.load121.10 = load <2 x double>, ptr %481, align 16, !tbaa !5
  %wide.load122.10 = load <2 x double>, ptr %482, align 16, !tbaa !5
  %483 = fadd <2 x double> %wide.load121.10, %479
  %484 = fadd <2 x double> %wide.load122.10, %480
  store <2 x double> %483, ptr %481, align 16, !tbaa !5
  store <2 x double> %484, ptr %482, align 16, !tbaa !5
  %485 = getelementptr inbounds i8, ptr %1, i64 1888
  %486 = getelementptr inbounds i8, ptr %1, i64 1904
  %wide.load119.11 = load <2 x double>, ptr %485, align 16, !tbaa !5
  %wide.load120.11 = load <2 x double>, ptr %486, align 16, !tbaa !5
  %487 = fadd <2 x double> %wide.load119.11, zeroinitializer
  %488 = fadd <2 x double> %wide.load120.11, zeroinitializer
  %489 = getelementptr inbounds i8, ptr %0, i64 1888
  %490 = getelementptr inbounds i8, ptr %0, i64 1904
  %wide.load121.11 = load <2 x double>, ptr %489, align 16, !tbaa !5
  %wide.load122.11 = load <2 x double>, ptr %490, align 16, !tbaa !5
  %491 = fadd <2 x double> %wide.load121.11, %487
  %492 = fadd <2 x double> %wide.load122.11, %488
  store <2 x double> %491, ptr %489, align 16, !tbaa !5
  store <2 x double> %492, ptr %490, align 16, !tbaa !5
  %493 = getelementptr inbounds i8, ptr %1, i64 1920
  %494 = getelementptr inbounds i8, ptr %1, i64 1936
  %wide.load119.12 = load <2 x double>, ptr %493, align 16, !tbaa !5
  %wide.load120.12 = load <2 x double>, ptr %494, align 16, !tbaa !5
  %495 = fadd <2 x double> %wide.load119.12, zeroinitializer
  %496 = fadd <2 x double> %wide.load120.12, zeroinitializer
  %497 = getelementptr inbounds i8, ptr %0, i64 1920
  %498 = getelementptr inbounds i8, ptr %0, i64 1936
  %wide.load121.12 = load <2 x double>, ptr %497, align 16, !tbaa !5
  %wide.load122.12 = load <2 x double>, ptr %498, align 16, !tbaa !5
  %499 = fadd <2 x double> %wide.load121.12, %495
  %500 = fadd <2 x double> %wide.load122.12, %496
  store <2 x double> %499, ptr %497, align 16, !tbaa !5
  store <2 x double> %500, ptr %498, align 16, !tbaa !5
  %501 = getelementptr inbounds i8, ptr %1, i64 1952
  %502 = getelementptr inbounds i8, ptr %1, i64 1968
  %wide.load119.13 = load <2 x double>, ptr %501, align 16, !tbaa !5
  %wide.load120.13 = load <2 x double>, ptr %502, align 16, !tbaa !5
  %503 = fadd <2 x double> %wide.load119.13, zeroinitializer
  %504 = fadd <2 x double> %wide.load120.13, zeroinitializer
  %505 = getelementptr inbounds i8, ptr %0, i64 1952
  %506 = getelementptr inbounds i8, ptr %0, i64 1968
  %wide.load121.13 = load <2 x double>, ptr %505, align 16, !tbaa !5
  %wide.load122.13 = load <2 x double>, ptr %506, align 16, !tbaa !5
  %507 = fadd <2 x double> %wide.load121.13, %503
  %508 = fadd <2 x double> %wide.load122.13, %504
  store <2 x double> %507, ptr %505, align 16, !tbaa !5
  store <2 x double> %508, ptr %506, align 16, !tbaa !5
  %509 = getelementptr inbounds i8, ptr %1, i64 1984
  %510 = getelementptr inbounds i8, ptr %1, i64 2000
  %wide.load119.14 = load <2 x double>, ptr %509, align 16, !tbaa !5
  %wide.load120.14 = load <2 x double>, ptr %510, align 16, !tbaa !5
  %511 = fadd <2 x double> %wide.load119.14, zeroinitializer
  %512 = fadd <2 x double> %wide.load120.14, zeroinitializer
  %513 = getelementptr inbounds i8, ptr %0, i64 1984
  %514 = getelementptr inbounds i8, ptr %0, i64 2000
  %wide.load121.14 = load <2 x double>, ptr %513, align 16, !tbaa !5
  %wide.load122.14 = load <2 x double>, ptr %514, align 16, !tbaa !5
  %515 = fadd <2 x double> %wide.load121.14, %511
  %516 = fadd <2 x double> %wide.load122.14, %512
  store <2 x double> %515, ptr %513, align 16, !tbaa !5
  store <2 x double> %516, ptr %514, align 16, !tbaa !5
  %517 = getelementptr inbounds i8, ptr %1, i64 2016
  %518 = getelementptr inbounds i8, ptr %1, i64 2032
  %wide.load119.15 = load <2 x double>, ptr %517, align 16, !tbaa !5
  %wide.load120.15 = load <2 x double>, ptr %518, align 16, !tbaa !5
  %519 = fadd <2 x double> %wide.load119.15, zeroinitializer
  %520 = fadd <2 x double> %wide.load120.15, zeroinitializer
  %521 = getelementptr inbounds i8, ptr %0, i64 2016
  %522 = getelementptr inbounds i8, ptr %0, i64 2032
  %wide.load121.15 = load <2 x double>, ptr %521, align 16, !tbaa !5
  %wide.load122.15 = load <2 x double>, ptr %522, align 16, !tbaa !5
  %523 = fadd <2 x double> %wide.load121.15, %519
  %524 = fadd <2 x double> %wide.load122.15, %520
  store <2 x double> %523, ptr %521, align 16, !tbaa !5
  store <2 x double> %524, ptr %522, align 16, !tbaa !5
  br label %.critedge.preheader.outer

.critedge.preheader.outer:                        ; preds = %vector.body75, %.critedge.thread
  %indvars.iv54.ph = phi i64 [ %indvars.iv.next5559, %.critedge.thread ], [ 0, %vector.body75 ]
  %.not = phi i1 [ false, %.critedge.thread ], [ true, %vector.body75 ]
  br label %.critedge.preheader

525:                                              ; preds = %.critedge
  %spec.select = select i1 %.not, ptr @.str.2, ptr @.str.1
  %not..not = xor i1 %.not, true
  %spec.select67 = zext i1 %not..not to i32
  br label %.thread

.critedge.preheader:                              ; preds = %.critedge.preheader.outer, %.critedge
  %indvars.iv54 = phi i64 [ %indvars.iv.next55, %.critedge ], [ %indvars.iv54.ph, %.critedge.preheader.outer ]
  %526 = getelementptr inbounds [960 x double], ptr %0, i64 0, i64 %indvars.iv54
  %527 = load double, ptr %526, align 8, !tbaa !5
  %528 = fcmp une double %527, 1.000000e+00
  br i1 %528, label %.critedge.thread, label %.critedge

.critedge:                                        ; preds = %.critedge.preheader
  %indvars.iv.next55 = add nuw nsw i64 %indvars.iv54, 1
  %exitcond57.not = icmp eq i64 %indvars.iv.next55, 256
  br i1 %exitcond57.not, label %525, label %.critedge.preheader, !llvm.loop !13

.critedge.thread:                                 ; preds = %.critedge.preheader
  %529 = trunc nuw nsw i64 %indvars.iv54 to i32
  %530 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, i32 noundef %529, double noundef 1.000000e+00, double noundef %527)
  %indvars.iv.next5559 = add nuw nsw i64 %indvars.iv54, 1
  %exitcond57.not60 = icmp eq i64 %indvars.iv.next5559, 256
  br i1 %exitcond57.not60, label %.thread, label %.critedge.preheader.outer, !llvm.loop !13

.thread:                                          ; preds = %.critedge.thread, %525
  %.str.2.sink = phi ptr [ %spec.select, %525 ], [ @.str.1, %.critedge.thread ]
  %.029 = phi i32 [ %spec.select67, %525 ], [ 1, %.critedge.thread ]
  %531 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) %.str.2.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 %.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}


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