; LLVM IR from aferikoglou/GenHLSOptimizer :: dataset/machsuite-backprop (local_support)

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

%struct.bench_args_t = type { [832 x double], [4096 x double], [192 x double], [64 x double], [64 x double], [3 x double], [2119 x double], [489 x double] }

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

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

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

13:                                               ; preds = %54, %2
  %14 = load i32, ptr %8, align 4, !tbaa !9
  %15 = icmp slt i32 %14, 13
  br i1 %15, label %16, label %57

16:                                               ; preds = %13
  store i32 0, ptr %9, align 4, !tbaa !9
  br label %17

17:                                               ; preds = %50, %16
  %18 = load i32, ptr %9, align 4, !tbaa !9
  %19 = icmp slt i32 %18, 64
  br i1 %19, label %20, label %53

20:                                               ; preds = %17
  %21 = load ptr, ptr %5, align 8, !tbaa !5
  %22 = getelementptr inbounds %struct.bench_args_t, ptr %21, i32 0, i32 0
  %23 = load i32, ptr %8, align 4, !tbaa !9
  %24 = mul nsw i32 %23, 64
  %25 = load i32, ptr %9, align 4, !tbaa !9
  %26 = add nsw i32 %24, %25
  %27 = sext i32 %26 to i64
  %28 = getelementptr inbounds [832 x double], ptr %22, i64 0, i64 %27
  %29 = load double, ptr %28, align 8, !tbaa !11
  %30 = load ptr, ptr %6, align 8, !tbaa !5
  %31 = getelementptr inbounds %struct.bench_args_t, ptr %30, i32 0, i32 0
  %32 = load i32, ptr %8, align 4, !tbaa !9
  %33 = mul nsw i32 %32, 64
  %34 = load i32, ptr %9, align 4, !tbaa !9
  %35 = add nsw i32 %33, %34
  %36 = sext i32 %35 to i64
  %37 = getelementptr inbounds [832 x double], ptr %31, i64 0, i64 %36
  %38 = load double, ptr %37, align 8, !tbaa !11
  %39 = fsub double %29, %38
  store double %39, ptr %10, align 8, !tbaa !11
  %40 = load double, ptr %10, align 8, !tbaa !11
  %41 = fcmp olt double %40, 0xBEB0C6F7A0B5ED8D
  br i1 %41, label %45, label %42

42:                                               ; preds = %20
  %43 = load double, ptr %10, align 8, !tbaa !11
  %44 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %43
  br label %45

45:                                               ; preds = %42, %20
  %46 = phi i1 [ true, %20 ], [ %44, %42 ]
  %47 = zext i1 %46 to i32
  %48 = load i32, ptr %7, align 4, !tbaa !9
  %49 = or i32 %48, %47
  store i32 %49, ptr %7, align 4, !tbaa !9
  br label %50

50:                                               ; preds = %45
  %51 = load i32, ptr %9, align 4, !tbaa !9
  %52 = add nsw i32 %51, 1
  store i32 %52, ptr %9, align 4, !tbaa !9
  br label %17, !llvm.loop !13

53:                                               ; preds = %17
  br label %54

54:                                               ; preds = %53
  %55 = load i32, ptr %8, align 4, !tbaa !9
  %56 = add nsw i32 %55, 1
  store i32 %56, ptr %8, align 4, !tbaa !9
  br label %13, !llvm.loop !15

57:                                               ; preds = %13
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %58

58:                                               ; preds = %99, %57
  %59 = load i32, ptr %8, align 4, !tbaa !9
  %60 = icmp slt i32 %59, 64
  br i1 %60, label %61, label %102

61:                                               ; preds = %58
  store i32 0, ptr %9, align 4, !tbaa !9
  br label %62

62:                                               ; preds = %95, %61
  %63 = load i32, ptr %9, align 4, !tbaa !9
  %64 = icmp slt i32 %63, 64
  br i1 %64, label %65, label %98

65:                                               ; preds = %62
  %66 = load ptr, ptr %5, align 8, !tbaa !5
  %67 = getelementptr inbounds %struct.bench_args_t, ptr %66, i32 0, i32 1
  %68 = load i32, ptr %8, align 4, !tbaa !9
  %69 = mul nsw i32 %68, 64
  %70 = load i32, ptr %9, align 4, !tbaa !9
  %71 = add nsw i32 %69, %70
  %72 = sext i32 %71 to i64
  %73 = getelementptr inbounds [4096 x double], ptr %67, i64 0, i64 %72
  %74 = load double, ptr %73, align 8, !tbaa !11
  %75 = load ptr, ptr %6, align 8, !tbaa !5
  %76 = getelementptr inbounds %struct.bench_args_t, ptr %75, i32 0, i32 1
  %77 = load i32, ptr %8, align 4, !tbaa !9
  %78 = mul nsw i32 %77, 64
  %79 = load i32, ptr %9, align 4, !tbaa !9
  %80 = add nsw i32 %78, %79
  %81 = sext i32 %80 to i64
  %82 = getelementptr inbounds [4096 x double], ptr %76, i64 0, i64 %81
  %83 = load double, ptr %82, align 8, !tbaa !11
  %84 = fsub double %74, %83
  store double %84, ptr %10, align 8, !tbaa !11
  %85 = load double, ptr %10, align 8, !tbaa !11
  %86 = fcmp olt double %85, 0xBEB0C6F7A0B5ED8D
  br i1 %86, label %90, label %87

87:                                               ; preds = %65
  %88 = load double, ptr %10, align 8, !tbaa !11
  %89 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %88
  br label %90

90:                                               ; preds = %87, %65
  %91 = phi i1 [ true, %65 ], [ %89, %87 ]
  %92 = zext i1 %91 to i32
  %93 = load i32, ptr %7, align 4, !tbaa !9
  %94 = or i32 %93, %92
  store i32 %94, ptr %7, align 4, !tbaa !9
  br label %95

95:                                               ; preds = %90
  %96 = load i32, ptr %9, align 4, !tbaa !9
  %97 = add nsw i32 %96, 1
  store i32 %97, ptr %9, align 4, !tbaa !9
  br label %62, !llvm.loop !16

98:                                               ; preds = %62
  br label %99

99:                                               ; preds = %98
  %100 = load i32, ptr %8, align 4, !tbaa !9
  %101 = add nsw i32 %100, 1
  store i32 %101, ptr %8, align 4, !tbaa !9
  br label %58, !llvm.loop !17

102:                                              ; preds = %58
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %103

103:                                              ; preds = %144, %102
  %104 = load i32, ptr %8, align 4, !tbaa !9
  %105 = icmp slt i32 %104, 64
  br i1 %105, label %106, label %147

106:                                              ; preds = %103
  store i32 0, ptr %9, align 4, !tbaa !9
  br label %107

107:                                              ; preds = %140, %106
  %108 = load i32, ptr %9, align 4, !tbaa !9
  %109 = icmp slt i32 %108, 3
  br i1 %109, label %110, label %143

110:                                              ; preds = %107
  %111 = load ptr, ptr %5, align 8, !tbaa !5
  %112 = getelementptr inbounds %struct.bench_args_t, ptr %111, i32 0, i32 2
  %113 = load i32, ptr %8, align 4, !tbaa !9
  %114 = mul nsw i32 %113, 3
  %115 = load i32, ptr %9, align 4, !tbaa !9
  %116 = add nsw i32 %114, %115
  %117 = sext i32 %116 to i64
  %118 = getelementptr inbounds [192 x double], ptr %112, i64 0, i64 %117
  %119 = load double, ptr %118, align 8, !tbaa !11
  %120 = load ptr, ptr %6, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct.bench_args_t, ptr %120, i32 0, i32 2
  %122 = load i32, ptr %8, align 4, !tbaa !9
  %123 = mul nsw i32 %122, 3
  %124 = load i32, ptr %9, align 4, !tbaa !9
  %125 = add nsw i32 %123, %124
  %126 = sext i32 %125 to i64
  %127 = getelementptr inbounds [192 x double], ptr %121, i64 0, i64 %126
  %128 = load double, ptr %127, align 8, !tbaa !11
  %129 = fsub double %119, %128
  store double %129, ptr %10, align 8, !tbaa !11
  %130 = load double, ptr %10, align 8, !tbaa !11
  %131 = fcmp olt double %130, 0xBEB0C6F7A0B5ED8D
  br i1 %131, label %135, label %132

132:                                              ; preds = %110
  %133 = load double, ptr %10, align 8, !tbaa !11
  %134 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %133
  br label %135

135:                                              ; preds = %132, %110
  %136 = phi i1 [ true, %110 ], [ %134, %132 ]
  %137 = zext i1 %136 to i32
  %138 = load i32, ptr %7, align 4, !tbaa !9
  %139 = or i32 %138, %137
  store i32 %139, ptr %7, align 4, !tbaa !9
  br label %140

140:                                              ; preds = %135
  %141 = load i32, ptr %9, align 4, !tbaa !9
  %142 = add nsw i32 %141, 1
  store i32 %142, ptr %9, align 4, !tbaa !9
  br label %107, !llvm.loop !18

143:                                              ; preds = %107
  br label %144

144:                                              ; preds = %143
  %145 = load i32, ptr %8, align 4, !tbaa !9
  %146 = add nsw i32 %145, 1
  store i32 %146, ptr %8, align 4, !tbaa !9
  br label %103, !llvm.loop !19

147:                                              ; preds = %103
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %148

148:                                              ; preds = %175, %147
  %149 = load i32, ptr %8, align 4, !tbaa !9
  %150 = icmp slt i32 %149, 64
  br i1 %150, label %151, label %178

151:                                              ; preds = %148
  %152 = load ptr, ptr %5, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.bench_args_t, ptr %152, i32 0, i32 3
  %154 = load i32, ptr %8, align 4, !tbaa !9
  %155 = sext i32 %154 to i64
  %156 = getelementptr inbounds [64 x double], ptr %153, i64 0, i64 %155
  %157 = load double, ptr %156, align 8, !tbaa !11
  %158 = load ptr, ptr %6, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.bench_args_t, ptr %158, i32 0, i32 3
  %160 = load i32, ptr %8, align 4, !tbaa !9
  %161 = sext i32 %160 to i64
  %162 = getelementptr inbounds [64 x double], ptr %159, i64 0, i64 %161
  %163 = load double, ptr %162, align 8, !tbaa !11
  %164 = fsub double %157, %163
  store double %164, ptr %10, align 8, !tbaa !11
  %165 = load double, ptr %10, align 8, !tbaa !11
  %166 = fcmp olt double %165, 0xBEB0C6F7A0B5ED8D
  br i1 %166, label %170, label %167

167:                                              ; preds = %151
  %168 = load double, ptr %10, align 8, !tbaa !11
  %169 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %168
  br label %170

170:                                              ; preds = %167, %151
  %171 = phi i1 [ true, %151 ], [ %169, %167 ]
  %172 = zext i1 %171 to i32
  %173 = load i32, ptr %7, align 4, !tbaa !9
  %174 = or i32 %173, %172
  store i32 %174, ptr %7, align 4, !tbaa !9
  br label %175

175:                                              ; preds = %170
  %176 = load i32, ptr %8, align 4, !tbaa !9
  %177 = add nsw i32 %176, 1
  store i32 %177, ptr %8, align 4, !tbaa !9
  br label %148, !llvm.loop !20

178:                                              ; preds = %148
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %179

179:                                              ; preds = %206, %178
  %180 = load i32, ptr %8, align 4, !tbaa !9
  %181 = icmp slt i32 %180, 64
  br i1 %181, label %182, label %209

182:                                              ; preds = %179
  %183 = load ptr, ptr %5, align 8, !tbaa !5
  %184 = getelementptr inbounds %struct.bench_args_t, ptr %183, i32 0, i32 4
  %185 = load i32, ptr %8, align 4, !tbaa !9
  %186 = sext i32 %185 to i64
  %187 = getelementptr inbounds [64 x double], ptr %184, i64 0, i64 %186
  %188 = load double, ptr %187, align 8, !tbaa !11
  %189 = load ptr, ptr %6, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.bench_args_t, ptr %189, i32 0, i32 4
  %191 = load i32, ptr %8, align 4, !tbaa !9
  %192 = sext i32 %191 to i64
  %193 = getelementptr inbounds [64 x double], ptr %190, i64 0, i64 %192
  %194 = load double, ptr %193, align 8, !tbaa !11
  %195 = fsub double %188, %194
  store double %195, ptr %10, align 8, !tbaa !11
  %196 = load double, ptr %10, align 8, !tbaa !11
  %197 = fcmp olt double %196, 0xBEB0C6F7A0B5ED8D
  br i1 %197, label %201, label %198

198:                                              ; preds = %182
  %199 = load double, ptr %10, align 8, !tbaa !11
  %200 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %199
  br label %201

201:                                              ; preds = %198, %182
  %202 = phi i1 [ true, %182 ], [ %200, %198 ]
  %203 = zext i1 %202 to i32
  %204 = load i32, ptr %7, align 4, !tbaa !9
  %205 = or i32 %204, %203
  store i32 %205, ptr %7, align 4, !tbaa !9
  br label %206

206:                                              ; preds = %201
  %207 = load i32, ptr %8, align 4, !tbaa !9
  %208 = add nsw i32 %207, 1
  store i32 %208, ptr %8, align 4, !tbaa !9
  br label %179, !llvm.loop !21

209:                                              ; preds = %179
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %210

210:                                              ; preds = %237, %209
  %211 = load i32, ptr %8, align 4, !tbaa !9
  %212 = icmp slt i32 %211, 3
  br i1 %212, label %213, label %240

213:                                              ; preds = %210
  %214 = load ptr, ptr %5, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.bench_args_t, ptr %214, i32 0, i32 5
  %216 = load i32, ptr %8, align 4, !tbaa !9
  %217 = sext i32 %216 to i64
  %218 = getelementptr inbounds [3 x double], ptr %215, i64 0, i64 %217
  %219 = load double, ptr %218, align 8, !tbaa !11
  %220 = load ptr, ptr %6, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.bench_args_t, ptr %220, i32 0, i32 5
  %222 = load i32, ptr %8, align 4, !tbaa !9
  %223 = sext i32 %222 to i64
  %224 = getelementptr inbounds [3 x double], ptr %221, i64 0, i64 %223
  %225 = load double, ptr %224, align 8, !tbaa !11
  %226 = fsub double %219, %225
  store double %226, ptr %10, align 8, !tbaa !11
  %227 = load double, ptr %10, align 8, !tbaa !11
  %228 = fcmp olt double %227, 0xBEB0C6F7A0B5ED8D
  br i1 %228, label %232, label %229

229:                                              ; preds = %213
  %230 = load double, ptr %10, align 8, !tbaa !11
  %231 = fcmp olt double 0x3EB0C6F7A0B5ED8D, %230
  br label %232

232:                                              ; preds = %229, %213
  %233 = phi i1 [ true, %213 ], [ %231, %229 ]
  %234 = zext i1 %233 to i32
  %235 = load i32, ptr %7, align 4, !tbaa !9
  %236 = or i32 %235, %234
  store i32 %236, ptr %7, align 4, !tbaa !9
  br label %237

237:                                              ; preds = %232
  %238 = load i32, ptr %8, align 4, !tbaa !9
  %239 = add nsw i32 %238, 1
  store i32 %239, ptr %8, align 4, !tbaa !9
  br label %210, !llvm.loop !22

240:                                              ; preds = %210
  %241 = load i32, ptr %7, align 4, !tbaa !9
  %242 = icmp ne i32 %241, 0
  %243 = xor i1 %242, true
  %244 = zext i1 %243 to i32
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #2
  ret i32 %244
}

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

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

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


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

; Function Attrs: nofree norecurse nosync nounwind memory(argmem: read) uwtable
define dso_local range(i32 0, 2) i32 @check_data(ptr nocapture noundef readonly %0, ptr nocapture noundef readonly %1) local_unnamed_addr #0 {
.preheader83:
  %2 = getelementptr inbounds i8, ptr %0, i64 16
  %wide.load173 = load <2 x double>, ptr %2, align 8, !tbaa !5
  %3 = getelementptr inbounds i8, ptr %1, i64 16
  %wide.load175 = load <2 x double>, ptr %3, align 8, !tbaa !5
  %4 = fsub <2 x double> %wide.load173, %wide.load175
  %5 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %4)
  %6 = fcmp ogt <2 x double> %5, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %7 = getelementptr inbounds i8, ptr %0, i64 48
  %wide.load173.1 = load <2 x double>, ptr %7, align 8, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %1, i64 48
  %wide.load175.1 = load <2 x double>, ptr %8, align 8, !tbaa !5
  %9 = fsub <2 x double> %wide.load173.1, %wide.load175.1
  %10 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %9)
  %11 = fcmp ogt <2 x double> %10, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %12 = or <2 x i1> %6, %11
  %13 = getelementptr inbounds i8, ptr %0, i64 80
  %wide.load173.2 = load <2 x double>, ptr %13, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %1, i64 80
  %wide.load175.2 = load <2 x double>, ptr %14, align 8, !tbaa !5
  %15 = fsub <2 x double> %wide.load173.2, %wide.load175.2
  %16 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %15)
  %17 = fcmp ogt <2 x double> %16, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %18 = or <2 x i1> %12, %17
  %19 = getelementptr inbounds i8, ptr %0, i64 112
  %wide.load173.3 = load <2 x double>, ptr %19, align 8, !tbaa !5
  %20 = getelementptr inbounds i8, ptr %1, i64 112
  %wide.load175.3 = load <2 x double>, ptr %20, align 8, !tbaa !5
  %21 = fsub <2 x double> %wide.load173.3, %wide.load175.3
  %22 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %21)
  %23 = fcmp ogt <2 x double> %22, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %24 = or <2 x i1> %18, %23
  %25 = getelementptr inbounds i8, ptr %0, i64 144
  %wide.load173.4 = load <2 x double>, ptr %25, align 8, !tbaa !5
  %26 = getelementptr inbounds i8, ptr %1, i64 144
  %wide.load175.4 = load <2 x double>, ptr %26, align 8, !tbaa !5
  %27 = fsub <2 x double> %wide.load173.4, %wide.load175.4
  %28 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %27)
  %29 = fcmp ogt <2 x double> %28, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %30 = or <2 x i1> %24, %29
  %31 = getelementptr inbounds i8, ptr %0, i64 176
  %wide.load173.5 = load <2 x double>, ptr %31, align 8, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %1, i64 176
  %wide.load175.5 = load <2 x double>, ptr %32, align 8, !tbaa !5
  %33 = fsub <2 x double> %wide.load173.5, %wide.load175.5
  %34 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %33)
  %35 = fcmp ogt <2 x double> %34, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %36 = or <2 x i1> %30, %35
  %37 = getelementptr inbounds i8, ptr %0, i64 208
  %wide.load173.6 = load <2 x double>, ptr %37, align 8, !tbaa !5
  %38 = getelementptr inbounds i8, ptr %1, i64 208
  %wide.load175.6 = load <2 x double>, ptr %38, align 8, !tbaa !5
  %39 = fsub <2 x double> %wide.load173.6, %wide.load175.6
  %40 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %39)
  %41 = fcmp ogt <2 x double> %40, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %42 = or <2 x i1> %36, %41
  %43 = getelementptr inbounds i8, ptr %0, i64 240
  %wide.load173.7 = load <2 x double>, ptr %43, align 8, !tbaa !5
  %44 = getelementptr inbounds i8, ptr %1, i64 240
  %wide.load175.7 = load <2 x double>, ptr %44, align 8, !tbaa !5
  %45 = fsub <2 x double> %wide.load173.7, %wide.load175.7
  %46 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %45)
  %47 = fcmp ogt <2 x double> %46, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %48 = or <2 x i1> %42, %47
  %49 = getelementptr inbounds i8, ptr %0, i64 272
  %wide.load173.8 = load <2 x double>, ptr %49, align 8, !tbaa !5
  %50 = getelementptr inbounds i8, ptr %1, i64 272
  %wide.load175.8 = load <2 x double>, ptr %50, align 8, !tbaa !5
  %51 = fsub <2 x double> %wide.load173.8, %wide.load175.8
  %52 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %51)
  %53 = fcmp ogt <2 x double> %52, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %54 = or <2 x i1> %48, %53
  %55 = getelementptr inbounds i8, ptr %0, i64 304
  %wide.load173.9 = load <2 x double>, ptr %55, align 8, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %1, i64 304
  %wide.load175.9 = load <2 x double>, ptr %56, align 8, !tbaa !5
  %57 = fsub <2 x double> %wide.load173.9, %wide.load175.9
  %58 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %57)
  %59 = fcmp ogt <2 x double> %58, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %60 = or <2 x i1> %54, %59
  %61 = getelementptr inbounds i8, ptr %0, i64 336
  %wide.load173.10 = load <2 x double>, ptr %61, align 8, !tbaa !5
  %62 = getelementptr inbounds i8, ptr %1, i64 336
  %wide.load175.10 = load <2 x double>, ptr %62, align 8, !tbaa !5
  %63 = fsub <2 x double> %wide.load173.10, %wide.load175.10
  %64 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %63)
  %65 = fcmp ogt <2 x double> %64, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %66 = or <2 x i1> %60, %65
  %67 = getelementptr inbounds i8, ptr %0, i64 368
  %wide.load173.11 = load <2 x double>, ptr %67, align 8, !tbaa !5
  %68 = getelementptr inbounds i8, ptr %1, i64 368
  %wide.load175.11 = load <2 x double>, ptr %68, align 8, !tbaa !5
  %69 = fsub <2 x double> %wide.load173.11, %wide.load175.11
  %70 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %69)
  %71 = fcmp ogt <2 x double> %70, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %72 = or <2 x i1> %66, %71
  %73 = getelementptr inbounds i8, ptr %0, i64 400
  %wide.load173.12 = load <2 x double>, ptr %73, align 8, !tbaa !5
  %74 = getelementptr inbounds i8, ptr %1, i64 400
  %wide.load175.12 = load <2 x double>, ptr %74, align 8, !tbaa !5
  %75 = fsub <2 x double> %wide.load173.12, %wide.load175.12
  %76 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %75)
  %77 = fcmp ogt <2 x double> %76, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %78 = or <2 x i1> %72, %77
  %79 = getelementptr inbounds i8, ptr %0, i64 432
  %wide.load173.13 = load <2 x double>, ptr %79, align 8, !tbaa !5
  %80 = getelementptr inbounds i8, ptr %1, i64 432
  %wide.load175.13 = load <2 x double>, ptr %80, align 8, !tbaa !5
  %81 = fsub <2 x double> %wide.load173.13, %wide.load175.13
  %82 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %81)
  %83 = fcmp ogt <2 x double> %82, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %84 = or <2 x i1> %78, %83
  %85 = getelementptr inbounds i8, ptr %0, i64 464
  %wide.load173.14 = load <2 x double>, ptr %85, align 8, !tbaa !5
  %86 = getelementptr inbounds i8, ptr %1, i64 464
  %wide.load175.14 = load <2 x double>, ptr %86, align 8, !tbaa !5
  %87 = fsub <2 x double> %wide.load173.14, %wide.load175.14
  %88 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %87)
  %89 = fcmp ogt <2 x double> %88, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %90 = or <2 x i1> %84, %89
  %91 = getelementptr inbounds i8, ptr %0, i64 496
  %wide.load173.15 = load <2 x double>, ptr %91, align 8, !tbaa !5
  %92 = getelementptr inbounds i8, ptr %1, i64 496
  %wide.load175.15 = load <2 x double>, ptr %92, align 8, !tbaa !5
  %93 = fsub <2 x double> %wide.load173.15, %wide.load175.15
  %94 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %93)
  %95 = fcmp ogt <2 x double> %94, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %96 = or <2 x i1> %90, %95
  %wide.load = load <2 x double>, ptr %0, align 8, !tbaa !5
  %wide.load174 = load <2 x double>, ptr %1, align 8, !tbaa !5
  %97 = fsub <2 x double> %wide.load, %wide.load174
  %98 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %97)
  %99 = fcmp ogt <2 x double> %98, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %100 = getelementptr inbounds i8, ptr %0, i64 32
  %wide.load.1 = load <2 x double>, ptr %100, align 8, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %1, i64 32
  %wide.load174.1 = load <2 x double>, ptr %101, align 8, !tbaa !5
  %102 = fsub <2 x double> %wide.load.1, %wide.load174.1
  %103 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %102)
  %104 = fcmp ogt <2 x double> %103, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %105 = or <2 x i1> %99, %104
  %106 = getelementptr inbounds i8, ptr %0, i64 64
  %wide.load.2 = load <2 x double>, ptr %106, align 8, !tbaa !5
  %107 = getelementptr inbounds i8, ptr %1, i64 64
  %wide.load174.2 = load <2 x double>, ptr %107, align 8, !tbaa !5
  %108 = fsub <2 x double> %wide.load.2, %wide.load174.2
  %109 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %108)
  %110 = fcmp ogt <2 x double> %109, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %111 = or <2 x i1> %105, %110
  %112 = getelementptr inbounds i8, ptr %0, i64 96
  %wide.load.3 = load <2 x double>, ptr %112, align 8, !tbaa !5
  %113 = getelementptr inbounds i8, ptr %1, i64 96
  %wide.load174.3 = load <2 x double>, ptr %113, align 8, !tbaa !5
  %114 = fsub <2 x double> %wide.load.3, %wide.load174.3
  %115 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %114)
  %116 = fcmp ogt <2 x double> %115, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %117 = or <2 x i1> %111, %116
  %118 = getelementptr inbounds i8, ptr %0, i64 128
  %wide.load.4 = load <2 x double>, ptr %118, align 8, !tbaa !5
  %119 = getelementptr inbounds i8, ptr %1, i64 128
  %wide.load174.4 = load <2 x double>, ptr %119, align 8, !tbaa !5
  %120 = fsub <2 x double> %wide.load.4, %wide.load174.4
  %121 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %120)
  %122 = fcmp ogt <2 x double> %121, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %123 = or <2 x i1> %117, %122
  %124 = getelementptr inbounds i8, ptr %0, i64 160
  %wide.load.5 = load <2 x double>, ptr %124, align 8, !tbaa !5
  %125 = getelementptr inbounds i8, ptr %1, i64 160
  %wide.load174.5 = load <2 x double>, ptr %125, align 8, !tbaa !5
  %126 = fsub <2 x double> %wide.load.5, %wide.load174.5
  %127 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %126)
  %128 = fcmp ogt <2 x double> %127, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %129 = or <2 x i1> %123, %128
  %130 = getelementptr inbounds i8, ptr %0, i64 192
  %wide.load.6 = load <2 x double>, ptr %130, align 8, !tbaa !5
  %131 = getelementptr inbounds i8, ptr %1, i64 192
  %wide.load174.6 = load <2 x double>, ptr %131, align 8, !tbaa !5
  %132 = fsub <2 x double> %wide.load.6, %wide.load174.6
  %133 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %132)
  %134 = fcmp ogt <2 x double> %133, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %135 = or <2 x i1> %129, %134
  %136 = getelementptr inbounds i8, ptr %0, i64 224
  %wide.load.7 = load <2 x double>, ptr %136, align 8, !tbaa !5
  %137 = getelementptr inbounds i8, ptr %1, i64 224
  %wide.load174.7 = load <2 x double>, ptr %137, align 8, !tbaa !5
  %138 = fsub <2 x double> %wide.load.7, %wide.load174.7
  %139 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %138)
  %140 = fcmp ogt <2 x double> %139, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %141 = or <2 x i1> %135, %140
  %142 = getelementptr inbounds i8, ptr %0, i64 256
  %wide.load.8 = load <2 x double>, ptr %142, align 8, !tbaa !5
  %143 = getelementptr inbounds i8, ptr %1, i64 256
  %wide.load174.8 = load <2 x double>, ptr %143, align 8, !tbaa !5
  %144 = fsub <2 x double> %wide.load.8, %wide.load174.8
  %145 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %144)
  %146 = fcmp ogt <2 x double> %145, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %147 = or <2 x i1> %141, %146
  %148 = getelementptr inbounds i8, ptr %0, i64 288
  %wide.load.9 = load <2 x double>, ptr %148, align 8, !tbaa !5
  %149 = getelementptr inbounds i8, ptr %1, i64 288
  %wide.load174.9 = load <2 x double>, ptr %149, align 8, !tbaa !5
  %150 = fsub <2 x double> %wide.load.9, %wide.load174.9
  %151 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %150)
  %152 = fcmp ogt <2 x double> %151, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %153 = or <2 x i1> %147, %152
  %154 = getelementptr inbounds i8, ptr %0, i64 320
  %wide.load.10 = load <2 x double>, ptr %154, align 8, !tbaa !5
  %155 = getelementptr inbounds i8, ptr %1, i64 320
  %wide.load174.10 = load <2 x double>, ptr %155, align 8, !tbaa !5
  %156 = fsub <2 x double> %wide.load.10, %wide.load174.10
  %157 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %156)
  %158 = fcmp ogt <2 x double> %157, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %159 = or <2 x i1> %153, %158
  %160 = getelementptr inbounds i8, ptr %0, i64 352
  %wide.load.11 = load <2 x double>, ptr %160, align 8, !tbaa !5
  %161 = getelementptr inbounds i8, ptr %1, i64 352
  %wide.load174.11 = load <2 x double>, ptr %161, align 8, !tbaa !5
  %162 = fsub <2 x double> %wide.load.11, %wide.load174.11
  %163 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %162)
  %164 = fcmp ogt <2 x double> %163, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %165 = or <2 x i1> %159, %164
  %166 = getelementptr inbounds i8, ptr %0, i64 384
  %wide.load.12 = load <2 x double>, ptr %166, align 8, !tbaa !5
  %167 = getelementptr inbounds i8, ptr %1, i64 384
  %wide.load174.12 = load <2 x double>, ptr %167, align 8, !tbaa !5
  %168 = fsub <2 x double> %wide.load.12, %wide.load174.12
  %169 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %168)
  %170 = fcmp ogt <2 x double> %169, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %171 = or <2 x i1> %165, %170
  %172 = getelementptr inbounds i8, ptr %0, i64 416
  %wide.load.13 = load <2 x double>, ptr %172, align 8, !tbaa !5
  %173 = getelementptr inbounds i8, ptr %1, i64 416
  %wide.load174.13 = load <2 x double>, ptr %173, align 8, !tbaa !5
  %174 = fsub <2 x double> %wide.load.13, %wide.load174.13
  %175 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %174)
  %176 = fcmp ogt <2 x double> %175, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %177 = or <2 x i1> %171, %176
  %178 = getelementptr inbounds i8, ptr %0, i64 448
  %wide.load.14 = load <2 x double>, ptr %178, align 8, !tbaa !5
  %179 = getelementptr inbounds i8, ptr %1, i64 448
  %wide.load174.14 = load <2 x double>, ptr %179, align 8, !tbaa !5
  %180 = fsub <2 x double> %wide.load.14, %wide.load174.14
  %181 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %180)
  %182 = fcmp ogt <2 x double> %181, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %183 = or <2 x i1> %177, %182
  %184 = getelementptr inbounds i8, ptr %0, i64 480
  %wide.load.15 = load <2 x double>, ptr %184, align 8, !tbaa !5
  %185 = getelementptr inbounds i8, ptr %1, i64 480
  %wide.load174.15 = load <2 x double>, ptr %185, align 8, !tbaa !5
  %186 = fsub <2 x double> %wide.load.15, %wide.load174.15
  %187 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %186)
  %188 = fcmp ogt <2 x double> %187, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %189 = or <2 x i1> %183, %188
  %bin.rdx460 = or <2 x i1> %96, %189
  %190 = bitcast <2 x i1> %bin.rdx460 to i2
  %191 = icmp ne i2 %190, 0
  %192 = zext i1 %191 to i32
  %193 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %192, i64 0
  %194 = getelementptr inbounds i8, ptr %0, i64 512
  %wide.load184 = load <2 x double>, ptr %194, align 8, !tbaa !5
  %195 = getelementptr inbounds i8, ptr %1, i64 512
  %wide.load186 = load <2 x double>, ptr %195, align 8, !tbaa !5
  %196 = fsub <2 x double> %wide.load184, %wide.load186
  %197 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %196)
  %198 = fcmp ogt <2 x double> %197, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %199 = zext <2 x i1> %198 to <2 x i32>
  %200 = or <2 x i32> %193, %199
  %201 = getelementptr inbounds i8, ptr %0, i64 544
  %wide.load184.1 = load <2 x double>, ptr %201, align 8, !tbaa !5
  %202 = getelementptr inbounds i8, ptr %1, i64 544
  %wide.load186.1 = load <2 x double>, ptr %202, align 8, !tbaa !5
  %203 = fsub <2 x double> %wide.load184.1, %wide.load186.1
  %204 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %203)
  %205 = fcmp ogt <2 x double> %204, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %206 = zext <2 x i1> %205 to <2 x i32>
  %207 = or <2 x i32> %200, %206
  %208 = getelementptr inbounds i8, ptr %0, i64 576
  %wide.load184.2 = load <2 x double>, ptr %208, align 8, !tbaa !5
  %209 = getelementptr inbounds i8, ptr %1, i64 576
  %wide.load186.2 = load <2 x double>, ptr %209, align 8, !tbaa !5
  %210 = fsub <2 x double> %wide.load184.2, %wide.load186.2
  %211 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %210)
  %212 = fcmp ogt <2 x double> %211, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %213 = zext <2 x i1> %212 to <2 x i32>
  %214 = or <2 x i32> %207, %213
  %215 = getelementptr inbounds i8, ptr %0, i64 608
  %wide.load184.3 = load <2 x double>, ptr %215, align 8, !tbaa !5
  %216 = getelementptr inbounds i8, ptr %1, i64 608
  %wide.load186.3 = load <2 x double>, ptr %216, align 8, !tbaa !5
  %217 = fsub <2 x double> %wide.load184.3, %wide.load186.3
  %218 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %217)
  %219 = fcmp ogt <2 x double> %218, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %220 = zext <2 x i1> %219 to <2 x i32>
  %221 = or <2 x i32> %214, %220
  %222 = getelementptr inbounds i8, ptr %0, i64 640
  %wide.load184.4 = load <2 x double>, ptr %222, align 8, !tbaa !5
  %223 = getelementptr inbounds i8, ptr %1, i64 640
  %wide.load186.4 = load <2 x double>, ptr %223, align 8, !tbaa !5
  %224 = fsub <2 x double> %wide.load184.4, %wide.load186.4
  %225 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %224)
  %226 = fcmp ogt <2 x double> %225, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %227 = zext <2 x i1> %226 to <2 x i32>
  %228 = or <2 x i32> %221, %227
  %229 = getelementptr inbounds i8, ptr %0, i64 672
  %wide.load184.5 = load <2 x double>, ptr %229, align 8, !tbaa !5
  %230 = getelementptr inbounds i8, ptr %1, i64 672
  %wide.load186.5 = load <2 x double>, ptr %230, align 8, !tbaa !5
  %231 = fsub <2 x double> %wide.load184.5, %wide.load186.5
  %232 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %231)
  %233 = fcmp ogt <2 x double> %232, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %234 = zext <2 x i1> %233 to <2 x i32>
  %235 = or <2 x i32> %228, %234
  %236 = getelementptr inbounds i8, ptr %0, i64 704
  %wide.load184.6 = load <2 x double>, ptr %236, align 8, !tbaa !5
  %237 = getelementptr inbounds i8, ptr %1, i64 704
  %wide.load186.6 = load <2 x double>, ptr %237, align 8, !tbaa !5
  %238 = fsub <2 x double> %wide.load184.6, %wide.load186.6
  %239 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %238)
  %240 = fcmp ogt <2 x double> %239, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %241 = zext <2 x i1> %240 to <2 x i32>
  %242 = or <2 x i32> %235, %241
  %243 = getelementptr inbounds i8, ptr %0, i64 736
  %wide.load184.7 = load <2 x double>, ptr %243, align 8, !tbaa !5
  %244 = getelementptr inbounds i8, ptr %1, i64 736
  %wide.load186.7 = load <2 x double>, ptr %244, align 8, !tbaa !5
  %245 = fsub <2 x double> %wide.load184.7, %wide.load186.7
  %246 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %245)
  %247 = fcmp ogt <2 x double> %246, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %248 = zext <2 x i1> %247 to <2 x i32>
  %249 = or <2 x i32> %242, %248
  %250 = getelementptr inbounds i8, ptr %0, i64 768
  %wide.load184.8 = load <2 x double>, ptr %250, align 8, !tbaa !5
  %251 = getelementptr inbounds i8, ptr %1, i64 768
  %wide.load186.8 = load <2 x double>, ptr %251, align 8, !tbaa !5
  %252 = fsub <2 x double> %wide.load184.8, %wide.load186.8
  %253 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %252)
  %254 = fcmp ogt <2 x double> %253, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %255 = zext <2 x i1> %254 to <2 x i32>
  %256 = or <2 x i32> %249, %255
  %257 = getelementptr inbounds i8, ptr %0, i64 800
  %wide.load184.9 = load <2 x double>, ptr %257, align 8, !tbaa !5
  %258 = getelementptr inbounds i8, ptr %1, i64 800
  %wide.load186.9 = load <2 x double>, ptr %258, align 8, !tbaa !5
  %259 = fsub <2 x double> %wide.load184.9, %wide.load186.9
  %260 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %259)
  %261 = fcmp ogt <2 x double> %260, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %262 = zext <2 x i1> %261 to <2 x i32>
  %263 = or <2 x i32> %256, %262
  %264 = getelementptr inbounds i8, ptr %0, i64 832
  %wide.load184.10 = load <2 x double>, ptr %264, align 8, !tbaa !5
  %265 = getelementptr inbounds i8, ptr %1, i64 832
  %wide.load186.10 = load <2 x double>, ptr %265, align 8, !tbaa !5
  %266 = fsub <2 x double> %wide.load184.10, %wide.load186.10
  %267 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %266)
  %268 = fcmp ogt <2 x double> %267, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %269 = zext <2 x i1> %268 to <2 x i32>
  %270 = or <2 x i32> %263, %269
  %271 = getelementptr inbounds i8, ptr %0, i64 864
  %wide.load184.11 = load <2 x double>, ptr %271, align 8, !tbaa !5
  %272 = getelementptr inbounds i8, ptr %1, i64 864
  %wide.load186.11 = load <2 x double>, ptr %272, align 8, !tbaa !5
  %273 = fsub <2 x double> %wide.load184.11, %wide.load186.11
  %274 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %273)
  %275 = fcmp ogt <2 x double> %274, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %276 = zext <2 x i1> %275 to <2 x i32>
  %277 = or <2 x i32> %270, %276
  %278 = getelementptr inbounds i8, ptr %0, i64 896
  %wide.load184.12 = load <2 x double>, ptr %278, align 8, !tbaa !5
  %279 = getelementptr inbounds i8, ptr %1, i64 896
  %wide.load186.12 = load <2 x double>, ptr %279, align 8, !tbaa !5
  %280 = fsub <2 x double> %wide.load184.12, %wide.load186.12
  %281 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %280)
  %282 = fcmp ogt <2 x double> %281, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %283 = zext <2 x i1> %282 to <2 x i32>
  %284 = or <2 x i32> %277, %283
  %285 = getelementptr inbounds i8, ptr %0, i64 928
  %wide.load184.13 = load <2 x double>, ptr %285, align 8, !tbaa !5
  %286 = getelementptr inbounds i8, ptr %1, i64 928
  %wide.load186.13 = load <2 x double>, ptr %286, align 8, !tbaa !5
  %287 = fsub <2 x double> %wide.load184.13, %wide.load186.13
  %288 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %287)
  %289 = fcmp ogt <2 x double> %288, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %290 = zext <2 x i1> %289 to <2 x i32>
  %291 = or <2 x i32> %284, %290
  %292 = getelementptr inbounds i8, ptr %0, i64 960
  %wide.load184.14 = load <2 x double>, ptr %292, align 8, !tbaa !5
  %293 = getelementptr inbounds i8, ptr %1, i64 960
  %wide.load186.14 = load <2 x double>, ptr %293, align 8, !tbaa !5
  %294 = fsub <2 x double> %wide.load184.14, %wide.load186.14
  %295 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %294)
  %296 = fcmp ogt <2 x double> %295, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %297 = zext <2 x i1> %296 to <2 x i32>
  %298 = or <2 x i32> %291, %297
  %299 = getelementptr inbounds i8, ptr %0, i64 992
  %wide.load184.15 = load <2 x double>, ptr %299, align 8, !tbaa !5
  %300 = getelementptr inbounds i8, ptr %1, i64 992
  %wide.load186.15 = load <2 x double>, ptr %300, align 8, !tbaa !5
  %301 = fsub <2 x double> %wide.load184.15, %wide.load186.15
  %302 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %301)
  %303 = fcmp ogt <2 x double> %302, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %304 = zext <2 x i1> %303 to <2 x i32>
  %305 = or <2 x i32> %298, %304
  %306 = getelementptr inbounds i8, ptr %0, i64 528
  %wide.load185 = load <2 x double>, ptr %306, align 8, !tbaa !5
  %307 = getelementptr inbounds i8, ptr %1, i64 528
  %wide.load187 = load <2 x double>, ptr %307, align 8, !tbaa !5
  %308 = fsub <2 x double> %wide.load185, %wide.load187
  %309 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %308)
  %310 = fcmp ogt <2 x double> %309, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %311 = getelementptr inbounds i8, ptr %0, i64 560
  %wide.load185.1 = load <2 x double>, ptr %311, align 8, !tbaa !5
  %312 = getelementptr inbounds i8, ptr %1, i64 560
  %wide.load187.1 = load <2 x double>, ptr %312, align 8, !tbaa !5
  %313 = fsub <2 x double> %wide.load185.1, %wide.load187.1
  %314 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %313)
  %315 = fcmp ogt <2 x double> %314, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %316 = or <2 x i1> %310, %315
  %317 = getelementptr inbounds i8, ptr %0, i64 592
  %wide.load185.2 = load <2 x double>, ptr %317, align 8, !tbaa !5
  %318 = getelementptr inbounds i8, ptr %1, i64 592
  %wide.load187.2 = load <2 x double>, ptr %318, align 8, !tbaa !5
  %319 = fsub <2 x double> %wide.load185.2, %wide.load187.2
  %320 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %319)
  %321 = fcmp ogt <2 x double> %320, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %322 = or <2 x i1> %316, %321
  %323 = getelementptr inbounds i8, ptr %0, i64 624
  %wide.load185.3 = load <2 x double>, ptr %323, align 8, !tbaa !5
  %324 = getelementptr inbounds i8, ptr %1, i64 624
  %wide.load187.3 = load <2 x double>, ptr %324, align 8, !tbaa !5
  %325 = fsub <2 x double> %wide.load185.3, %wide.load187.3
  %326 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %325)
  %327 = fcmp ogt <2 x double> %326, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %328 = or <2 x i1> %322, %327
  %329 = getelementptr inbounds i8, ptr %0, i64 656
  %wide.load185.4 = load <2 x double>, ptr %329, align 8, !tbaa !5
  %330 = getelementptr inbounds i8, ptr %1, i64 656
  %wide.load187.4 = load <2 x double>, ptr %330, align 8, !tbaa !5
  %331 = fsub <2 x double> %wide.load185.4, %wide.load187.4
  %332 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %331)
  %333 = fcmp ogt <2 x double> %332, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %334 = or <2 x i1> %328, %333
  %335 = getelementptr inbounds i8, ptr %0, i64 688
  %wide.load185.5 = load <2 x double>, ptr %335, align 8, !tbaa !5
  %336 = getelementptr inbounds i8, ptr %1, i64 688
  %wide.load187.5 = load <2 x double>, ptr %336, align 8, !tbaa !5
  %337 = fsub <2 x double> %wide.load185.5, %wide.load187.5
  %338 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %337)
  %339 = fcmp ogt <2 x double> %338, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %340 = or <2 x i1> %334, %339
  %341 = getelementptr inbounds i8, ptr %0, i64 720
  %wide.load185.6 = load <2 x double>, ptr %341, align 8, !tbaa !5
  %342 = getelementptr inbounds i8, ptr %1, i64 720
  %wide.load187.6 = load <2 x double>, ptr %342, align 8, !tbaa !5
  %343 = fsub <2 x double> %wide.load185.6, %wide.load187.6
  %344 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %343)
  %345 = fcmp ogt <2 x double> %344, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %346 = or <2 x i1> %340, %345
  %347 = getelementptr inbounds i8, ptr %0, i64 752
  %wide.load185.7 = load <2 x double>, ptr %347, align 8, !tbaa !5
  %348 = getelementptr inbounds i8, ptr %1, i64 752
  %wide.load187.7 = load <2 x double>, ptr %348, align 8, !tbaa !5
  %349 = fsub <2 x double> %wide.load185.7, %wide.load187.7
  %350 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %349)
  %351 = fcmp ogt <2 x double> %350, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %352 = or <2 x i1> %346, %351
  %353 = getelementptr inbounds i8, ptr %0, i64 784
  %wide.load185.8 = load <2 x double>, ptr %353, align 8, !tbaa !5
  %354 = getelementptr inbounds i8, ptr %1, i64 784
  %wide.load187.8 = load <2 x double>, ptr %354, align 8, !tbaa !5
  %355 = fsub <2 x double> %wide.load185.8, %wide.load187.8
  %356 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %355)
  %357 = fcmp ogt <2 x double> %356, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %358 = or <2 x i1> %352, %357
  %359 = getelementptr inbounds i8, ptr %0, i64 816
  %wide.load185.9 = load <2 x double>, ptr %359, align 8, !tbaa !5
  %360 = getelementptr inbounds i8, ptr %1, i64 816
  %wide.load187.9 = load <2 x double>, ptr %360, align 8, !tbaa !5
  %361 = fsub <2 x double> %wide.load185.9, %wide.load187.9
  %362 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %361)
  %363 = fcmp ogt <2 x double> %362, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %364 = or <2 x i1> %358, %363
  %365 = getelementptr inbounds i8, ptr %0, i64 848
  %wide.load185.10 = load <2 x double>, ptr %365, align 8, !tbaa !5
  %366 = getelementptr inbounds i8, ptr %1, i64 848
  %wide.load187.10 = load <2 x double>, ptr %366, align 8, !tbaa !5
  %367 = fsub <2 x double> %wide.load185.10, %wide.load187.10
  %368 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %367)
  %369 = fcmp ogt <2 x double> %368, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %370 = or <2 x i1> %364, %369
  %371 = getelementptr inbounds i8, ptr %0, i64 880
  %wide.load185.11 = load <2 x double>, ptr %371, align 8, !tbaa !5
  %372 = getelementptr inbounds i8, ptr %1, i64 880
  %wide.load187.11 = load <2 x double>, ptr %372, align 8, !tbaa !5
  %373 = fsub <2 x double> %wide.load185.11, %wide.load187.11
  %374 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %373)
  %375 = fcmp ogt <2 x double> %374, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %376 = or <2 x i1> %370, %375
  %377 = getelementptr inbounds i8, ptr %0, i64 912
  %wide.load185.12 = load <2 x double>, ptr %377, align 8, !tbaa !5
  %378 = getelementptr inbounds i8, ptr %1, i64 912
  %wide.load187.12 = load <2 x double>, ptr %378, align 8, !tbaa !5
  %379 = fsub <2 x double> %wide.load185.12, %wide.load187.12
  %380 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %379)
  %381 = fcmp ogt <2 x double> %380, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %382 = or <2 x i1> %376, %381
  %383 = getelementptr inbounds i8, ptr %0, i64 944
  %wide.load185.13 = load <2 x double>, ptr %383, align 8, !tbaa !5
  %384 = getelementptr inbounds i8, ptr %1, i64 944
  %wide.load187.13 = load <2 x double>, ptr %384, align 8, !tbaa !5
  %385 = fsub <2 x double> %wide.load185.13, %wide.load187.13
  %386 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %385)
  %387 = fcmp ogt <2 x double> %386, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %388 = or <2 x i1> %382, %387
  %389 = getelementptr inbounds i8, ptr %0, i64 976
  %wide.load185.14 = load <2 x double>, ptr %389, align 8, !tbaa !5
  %390 = getelementptr inbounds i8, ptr %1, i64 976
  %wide.load187.14 = load <2 x double>, ptr %390, align 8, !tbaa !5
  %391 = fsub <2 x double> %wide.load185.14, %wide.load187.14
  %392 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %391)
  %393 = fcmp ogt <2 x double> %392, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %394 = or <2 x i1> %388, %393
  %395 = getelementptr inbounds i8, ptr %0, i64 1008
  %wide.load185.15 = load <2 x double>, ptr %395, align 8, !tbaa !5
  %396 = getelementptr inbounds i8, ptr %1, i64 1008
  %wide.load187.15 = load <2 x double>, ptr %396, align 8, !tbaa !5
  %397 = fsub <2 x double> %wide.load185.15, %wide.load187.15
  %398 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %397)
  %399 = fcmp ogt <2 x double> %398, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %400 = or <2 x i1> %394, %399
  %401 = zext <2 x i1> %400 to <2 x i32>
  %bin.rdx189 = or <2 x i32> %305, %401
  %402 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx189)
  %403 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %402, i64 0
  %404 = getelementptr inbounds i8, ptr %0, i64 1024
  %wide.load199 = load <2 x double>, ptr %404, align 8, !tbaa !5
  %405 = getelementptr inbounds i8, ptr %1, i64 1024
  %wide.load201 = load <2 x double>, ptr %405, align 8, !tbaa !5
  %406 = fsub <2 x double> %wide.load199, %wide.load201
  %407 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %406)
  %408 = fcmp ogt <2 x double> %407, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %409 = zext <2 x i1> %408 to <2 x i32>
  %410 = or <2 x i32> %403, %409
  %411 = getelementptr inbounds i8, ptr %0, i64 1056
  %wide.load199.1 = load <2 x double>, ptr %411, align 8, !tbaa !5
  %412 = getelementptr inbounds i8, ptr %1, i64 1056
  %wide.load201.1 = load <2 x double>, ptr %412, align 8, !tbaa !5
  %413 = fsub <2 x double> %wide.load199.1, %wide.load201.1
  %414 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %413)
  %415 = fcmp ogt <2 x double> %414, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %416 = zext <2 x i1> %415 to <2 x i32>
  %417 = or <2 x i32> %410, %416
  %418 = getelementptr inbounds i8, ptr %0, i64 1088
  %wide.load199.2 = load <2 x double>, ptr %418, align 8, !tbaa !5
  %419 = getelementptr inbounds i8, ptr %1, i64 1088
  %wide.load201.2 = load <2 x double>, ptr %419, align 8, !tbaa !5
  %420 = fsub <2 x double> %wide.load199.2, %wide.load201.2
  %421 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %420)
  %422 = fcmp ogt <2 x double> %421, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %423 = zext <2 x i1> %422 to <2 x i32>
  %424 = or <2 x i32> %417, %423
  %425 = getelementptr inbounds i8, ptr %0, i64 1120
  %wide.load199.3 = load <2 x double>, ptr %425, align 8, !tbaa !5
  %426 = getelementptr inbounds i8, ptr %1, i64 1120
  %wide.load201.3 = load <2 x double>, ptr %426, align 8, !tbaa !5
  %427 = fsub <2 x double> %wide.load199.3, %wide.load201.3
  %428 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %427)
  %429 = fcmp ogt <2 x double> %428, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %430 = zext <2 x i1> %429 to <2 x i32>
  %431 = or <2 x i32> %424, %430
  %432 = getelementptr inbounds i8, ptr %0, i64 1152
  %wide.load199.4 = load <2 x double>, ptr %432, align 8, !tbaa !5
  %433 = getelementptr inbounds i8, ptr %1, i64 1152
  %wide.load201.4 = load <2 x double>, ptr %433, align 8, !tbaa !5
  %434 = fsub <2 x double> %wide.load199.4, %wide.load201.4
  %435 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %434)
  %436 = fcmp ogt <2 x double> %435, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %437 = zext <2 x i1> %436 to <2 x i32>
  %438 = or <2 x i32> %431, %437
  %439 = getelementptr inbounds i8, ptr %0, i64 1184
  %wide.load199.5 = load <2 x double>, ptr %439, align 8, !tbaa !5
  %440 = getelementptr inbounds i8, ptr %1, i64 1184
  %wide.load201.5 = load <2 x double>, ptr %440, align 8, !tbaa !5
  %441 = fsub <2 x double> %wide.load199.5, %wide.load201.5
  %442 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %441)
  %443 = fcmp ogt <2 x double> %442, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %444 = zext <2 x i1> %443 to <2 x i32>
  %445 = or <2 x i32> %438, %444
  %446 = getelementptr inbounds i8, ptr %0, i64 1216
  %wide.load199.6 = load <2 x double>, ptr %446, align 8, !tbaa !5
  %447 = getelementptr inbounds i8, ptr %1, i64 1216
  %wide.load201.6 = load <2 x double>, ptr %447, align 8, !tbaa !5
  %448 = fsub <2 x double> %wide.load199.6, %wide.load201.6
  %449 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %448)
  %450 = fcmp ogt <2 x double> %449, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %451 = zext <2 x i1> %450 to <2 x i32>
  %452 = or <2 x i32> %445, %451
  %453 = getelementptr inbounds i8, ptr %0, i64 1248
  %wide.load199.7 = load <2 x double>, ptr %453, align 8, !tbaa !5
  %454 = getelementptr inbounds i8, ptr %1, i64 1248
  %wide.load201.7 = load <2 x double>, ptr %454, align 8, !tbaa !5
  %455 = fsub <2 x double> %wide.load199.7, %wide.load201.7
  %456 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %455)
  %457 = fcmp ogt <2 x double> %456, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %458 = zext <2 x i1> %457 to <2 x i32>
  %459 = or <2 x i32> %452, %458
  %460 = getelementptr inbounds i8, ptr %0, i64 1280
  %wide.load199.8 = load <2 x double>, ptr %460, align 8, !tbaa !5
  %461 = getelementptr inbounds i8, ptr %1, i64 1280
  %wide.load201.8 = load <2 x double>, ptr %461, align 8, !tbaa !5
  %462 = fsub <2 x double> %wide.load199.8, %wide.load201.8
  %463 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %462)
  %464 = fcmp ogt <2 x double> %463, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %465 = zext <2 x i1> %464 to <2 x i32>
  %466 = or <2 x i32> %459, %465
  %467 = getelementptr inbounds i8, ptr %0, i64 1312
  %wide.load199.9 = load <2 x double>, ptr %467, align 8, !tbaa !5
  %468 = getelementptr inbounds i8, ptr %1, i64 1312
  %wide.load201.9 = load <2 x double>, ptr %468, align 8, !tbaa !5
  %469 = fsub <2 x double> %wide.load199.9, %wide.load201.9
  %470 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %469)
  %471 = fcmp ogt <2 x double> %470, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %472 = zext <2 x i1> %471 to <2 x i32>
  %473 = or <2 x i32> %466, %472
  %474 = getelementptr inbounds i8, ptr %0, i64 1344
  %wide.load199.10 = load <2 x double>, ptr %474, align 8, !tbaa !5
  %475 = getelementptr inbounds i8, ptr %1, i64 1344
  %wide.load201.10 = load <2 x double>, ptr %475, align 8, !tbaa !5
  %476 = fsub <2 x double> %wide.load199.10, %wide.load201.10
  %477 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %476)
  %478 = fcmp ogt <2 x double> %477, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %479 = zext <2 x i1> %478 to <2 x i32>
  %480 = or <2 x i32> %473, %479
  %481 = getelementptr inbounds i8, ptr %0, i64 1376
  %wide.load199.11 = load <2 x double>, ptr %481, align 8, !tbaa !5
  %482 = getelementptr inbounds i8, ptr %1, i64 1376
  %wide.load201.11 = load <2 x double>, ptr %482, align 8, !tbaa !5
  %483 = fsub <2 x double> %wide.load199.11, %wide.load201.11
  %484 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %483)
  %485 = fcmp ogt <2 x double> %484, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %486 = zext <2 x i1> %485 to <2 x i32>
  %487 = or <2 x i32> %480, %486
  %488 = getelementptr inbounds i8, ptr %0, i64 1408
  %wide.load199.12 = load <2 x double>, ptr %488, align 8, !tbaa !5
  %489 = getelementptr inbounds i8, ptr %1, i64 1408
  %wide.load201.12 = load <2 x double>, ptr %489, align 8, !tbaa !5
  %490 = fsub <2 x double> %wide.load199.12, %wide.load201.12
  %491 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %490)
  %492 = fcmp ogt <2 x double> %491, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %493 = zext <2 x i1> %492 to <2 x i32>
  %494 = or <2 x i32> %487, %493
  %495 = getelementptr inbounds i8, ptr %0, i64 1440
  %wide.load199.13 = load <2 x double>, ptr %495, align 8, !tbaa !5
  %496 = getelementptr inbounds i8, ptr %1, i64 1440
  %wide.load201.13 = load <2 x double>, ptr %496, align 8, !tbaa !5
  %497 = fsub <2 x double> %wide.load199.13, %wide.load201.13
  %498 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %497)
  %499 = fcmp ogt <2 x double> %498, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %500 = zext <2 x i1> %499 to <2 x i32>
  %501 = or <2 x i32> %494, %500
  %502 = getelementptr inbounds i8, ptr %0, i64 1472
  %wide.load199.14 = load <2 x double>, ptr %502, align 8, !tbaa !5
  %503 = getelementptr inbounds i8, ptr %1, i64 1472
  %wide.load201.14 = load <2 x double>, ptr %503, align 8, !tbaa !5
  %504 = fsub <2 x double> %wide.load199.14, %wide.load201.14
  %505 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %504)
  %506 = fcmp ogt <2 x double> %505, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %507 = zext <2 x i1> %506 to <2 x i32>
  %508 = or <2 x i32> %501, %507
  %509 = getelementptr inbounds i8, ptr %0, i64 1504
  %wide.load199.15 = load <2 x double>, ptr %509, align 8, !tbaa !5
  %510 = getelementptr inbounds i8, ptr %1, i64 1504
  %wide.load201.15 = load <2 x double>, ptr %510, align 8, !tbaa !5
  %511 = fsub <2 x double> %wide.load199.15, %wide.load201.15
  %512 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %511)
  %513 = fcmp ogt <2 x double> %512, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %514 = zext <2 x i1> %513 to <2 x i32>
  %515 = or <2 x i32> %508, %514
  %516 = getelementptr inbounds i8, ptr %0, i64 1040
  %wide.load200 = load <2 x double>, ptr %516, align 8, !tbaa !5
  %517 = getelementptr inbounds i8, ptr %1, i64 1040
  %wide.load202 = load <2 x double>, ptr %517, align 8, !tbaa !5
  %518 = fsub <2 x double> %wide.load200, %wide.load202
  %519 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %518)
  %520 = fcmp ogt <2 x double> %519, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %521 = getelementptr inbounds i8, ptr %0, i64 1072
  %wide.load200.1 = load <2 x double>, ptr %521, align 8, !tbaa !5
  %522 = getelementptr inbounds i8, ptr %1, i64 1072
  %wide.load202.1 = load <2 x double>, ptr %522, align 8, !tbaa !5
  %523 = fsub <2 x double> %wide.load200.1, %wide.load202.1
  %524 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %523)
  %525 = fcmp ogt <2 x double> %524, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %526 = or <2 x i1> %520, %525
  %527 = getelementptr inbounds i8, ptr %0, i64 1104
  %wide.load200.2 = load <2 x double>, ptr %527, align 8, !tbaa !5
  %528 = getelementptr inbounds i8, ptr %1, i64 1104
  %wide.load202.2 = load <2 x double>, ptr %528, align 8, !tbaa !5
  %529 = fsub <2 x double> %wide.load200.2, %wide.load202.2
  %530 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %529)
  %531 = fcmp ogt <2 x double> %530, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %532 = or <2 x i1> %526, %531
  %533 = getelementptr inbounds i8, ptr %0, i64 1136
  %wide.load200.3 = load <2 x double>, ptr %533, align 8, !tbaa !5
  %534 = getelementptr inbounds i8, ptr %1, i64 1136
  %wide.load202.3 = load <2 x double>, ptr %534, align 8, !tbaa !5
  %535 = fsub <2 x double> %wide.load200.3, %wide.load202.3
  %536 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %535)
  %537 = fcmp ogt <2 x double> %536, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %538 = or <2 x i1> %532, %537
  %539 = getelementptr inbounds i8, ptr %0, i64 1168
  %wide.load200.4 = load <2 x double>, ptr %539, align 8, !tbaa !5
  %540 = getelementptr inbounds i8, ptr %1, i64 1168
  %wide.load202.4 = load <2 x double>, ptr %540, align 8, !tbaa !5
  %541 = fsub <2 x double> %wide.load200.4, %wide.load202.4
  %542 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %541)
  %543 = fcmp ogt <2 x double> %542, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %544 = or <2 x i1> %538, %543
  %545 = getelementptr inbounds i8, ptr %0, i64 1200
  %wide.load200.5 = load <2 x double>, ptr %545, align 8, !tbaa !5
  %546 = getelementptr inbounds i8, ptr %1, i64 1200
  %wide.load202.5 = load <2 x double>, ptr %546, align 8, !tbaa !5
  %547 = fsub <2 x double> %wide.load200.5, %wide.load202.5
  %548 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %547)
  %549 = fcmp ogt <2 x double> %548, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %550 = or <2 x i1> %544, %549
  %551 = getelementptr inbounds i8, ptr %0, i64 1232
  %wide.load200.6 = load <2 x double>, ptr %551, align 8, !tbaa !5
  %552 = getelementptr inbounds i8, ptr %1, i64 1232
  %wide.load202.6 = load <2 x double>, ptr %552, align 8, !tbaa !5
  %553 = fsub <2 x double> %wide.load200.6, %wide.load202.6
  %554 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %553)
  %555 = fcmp ogt <2 x double> %554, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %556 = or <2 x i1> %550, %555
  %557 = getelementptr inbounds i8, ptr %0, i64 1264
  %wide.load200.7 = load <2 x double>, ptr %557, align 8, !tbaa !5
  %558 = getelementptr inbounds i8, ptr %1, i64 1264
  %wide.load202.7 = load <2 x double>, ptr %558, align 8, !tbaa !5
  %559 = fsub <2 x double> %wide.load200.7, %wide.load202.7
  %560 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %559)
  %561 = fcmp ogt <2 x double> %560, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %562 = or <2 x i1> %556, %561
  %563 = getelementptr inbounds i8, ptr %0, i64 1296
  %wide.load200.8 = load <2 x double>, ptr %563, align 8, !tbaa !5
  %564 = getelementptr inbounds i8, ptr %1, i64 1296
  %wide.load202.8 = load <2 x double>, ptr %564, align 8, !tbaa !5
  %565 = fsub <2 x double> %wide.load200.8, %wide.load202.8
  %566 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %565)
  %567 = fcmp ogt <2 x double> %566, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %568 = or <2 x i1> %562, %567
  %569 = getelementptr inbounds i8, ptr %0, i64 1328
  %wide.load200.9 = load <2 x double>, ptr %569, align 8, !tbaa !5
  %570 = getelementptr inbounds i8, ptr %1, i64 1328
  %wide.load202.9 = load <2 x double>, ptr %570, align 8, !tbaa !5
  %571 = fsub <2 x double> %wide.load200.9, %wide.load202.9
  %572 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %571)
  %573 = fcmp ogt <2 x double> %572, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %574 = or <2 x i1> %568, %573
  %575 = getelementptr inbounds i8, ptr %0, i64 1360
  %wide.load200.10 = load <2 x double>, ptr %575, align 8, !tbaa !5
  %576 = getelementptr inbounds i8, ptr %1, i64 1360
  %wide.load202.10 = load <2 x double>, ptr %576, align 8, !tbaa !5
  %577 = fsub <2 x double> %wide.load200.10, %wide.load202.10
  %578 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %577)
  %579 = fcmp ogt <2 x double> %578, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %580 = or <2 x i1> %574, %579
  %581 = getelementptr inbounds i8, ptr %0, i64 1392
  %wide.load200.11 = load <2 x double>, ptr %581, align 8, !tbaa !5
  %582 = getelementptr inbounds i8, ptr %1, i64 1392
  %wide.load202.11 = load <2 x double>, ptr %582, align 8, !tbaa !5
  %583 = fsub <2 x double> %wide.load200.11, %wide.load202.11
  %584 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %583)
  %585 = fcmp ogt <2 x double> %584, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %586 = or <2 x i1> %580, %585
  %587 = getelementptr inbounds i8, ptr %0, i64 1424
  %wide.load200.12 = load <2 x double>, ptr %587, align 8, !tbaa !5
  %588 = getelementptr inbounds i8, ptr %1, i64 1424
  %wide.load202.12 = load <2 x double>, ptr %588, align 8, !tbaa !5
  %589 = fsub <2 x double> %wide.load200.12, %wide.load202.12
  %590 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %589)
  %591 = fcmp ogt <2 x double> %590, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %592 = or <2 x i1> %586, %591
  %593 = getelementptr inbounds i8, ptr %0, i64 1456
  %wide.load200.13 = load <2 x double>, ptr %593, align 8, !tbaa !5
  %594 = getelementptr inbounds i8, ptr %1, i64 1456
  %wide.load202.13 = load <2 x double>, ptr %594, align 8, !tbaa !5
  %595 = fsub <2 x double> %wide.load200.13, %wide.load202.13
  %596 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %595)
  %597 = fcmp ogt <2 x double> %596, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %598 = or <2 x i1> %592, %597
  %599 = getelementptr inbounds i8, ptr %0, i64 1488
  %wide.load200.14 = load <2 x double>, ptr %599, align 8, !tbaa !5
  %600 = getelementptr inbounds i8, ptr %1, i64 1488
  %wide.load202.14 = load <2 x double>, ptr %600, align 8, !tbaa !5
  %601 = fsub <2 x double> %wide.load200.14, %wide.load202.14
  %602 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %601)
  %603 = fcmp ogt <2 x double> %602, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %604 = or <2 x i1> %598, %603
  %605 = getelementptr inbounds i8, ptr %0, i64 1520
  %wide.load200.15 = load <2 x double>, ptr %605, align 8, !tbaa !5
  %606 = getelementptr inbounds i8, ptr %1, i64 1520
  %wide.load202.15 = load <2 x double>, ptr %606, align 8, !tbaa !5
  %607 = fsub <2 x double> %wide.load200.15, %wide.load202.15
  %608 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %607)
  %609 = fcmp ogt <2 x double> %608, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %610 = or <2 x i1> %604, %609
  %611 = zext <2 x i1> %610 to <2 x i32>
  %bin.rdx204 = or <2 x i32> %515, %611
  %612 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx204)
  %613 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %612, i64 0
  %614 = getelementptr inbounds i8, ptr %0, i64 1536
  %wide.load214 = load <2 x double>, ptr %614, align 8, !tbaa !5
  %615 = getelementptr inbounds i8, ptr %1, i64 1536
  %wide.load216 = load <2 x double>, ptr %615, align 8, !tbaa !5
  %616 = fsub <2 x double> %wide.load214, %wide.load216
  %617 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %616)
  %618 = fcmp ogt <2 x double> %617, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %619 = zext <2 x i1> %618 to <2 x i32>
  %620 = or <2 x i32> %613, %619
  %621 = getelementptr inbounds i8, ptr %0, i64 1568
  %wide.load214.1 = load <2 x double>, ptr %621, align 8, !tbaa !5
  %622 = getelementptr inbounds i8, ptr %1, i64 1568
  %wide.load216.1 = load <2 x double>, ptr %622, align 8, !tbaa !5
  %623 = fsub <2 x double> %wide.load214.1, %wide.load216.1
  %624 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %623)
  %625 = fcmp ogt <2 x double> %624, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %626 = zext <2 x i1> %625 to <2 x i32>
  %627 = or <2 x i32> %620, %626
  %628 = getelementptr inbounds i8, ptr %0, i64 1600
  %wide.load214.2 = load <2 x double>, ptr %628, align 8, !tbaa !5
  %629 = getelementptr inbounds i8, ptr %1, i64 1600
  %wide.load216.2 = load <2 x double>, ptr %629, align 8, !tbaa !5
  %630 = fsub <2 x double> %wide.load214.2, %wide.load216.2
  %631 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %630)
  %632 = fcmp ogt <2 x double> %631, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %633 = zext <2 x i1> %632 to <2 x i32>
  %634 = or <2 x i32> %627, %633
  %635 = getelementptr inbounds i8, ptr %0, i64 1632
  %wide.load214.3 = load <2 x double>, ptr %635, align 8, !tbaa !5
  %636 = getelementptr inbounds i8, ptr %1, i64 1632
  %wide.load216.3 = load <2 x double>, ptr %636, align 8, !tbaa !5
  %637 = fsub <2 x double> %wide.load214.3, %wide.load216.3
  %638 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %637)
  %639 = fcmp ogt <2 x double> %638, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %640 = zext <2 x i1> %639 to <2 x i32>
  %641 = or <2 x i32> %634, %640
  %642 = getelementptr inbounds i8, ptr %0, i64 1664
  %wide.load214.4 = load <2 x double>, ptr %642, align 8, !tbaa !5
  %643 = getelementptr inbounds i8, ptr %1, i64 1664
  %wide.load216.4 = load <2 x double>, ptr %643, align 8, !tbaa !5
  %644 = fsub <2 x double> %wide.load214.4, %wide.load216.4
  %645 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %644)
  %646 = fcmp ogt <2 x double> %645, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %647 = zext <2 x i1> %646 to <2 x i32>
  %648 = or <2 x i32> %641, %647
  %649 = getelementptr inbounds i8, ptr %0, i64 1696
  %wide.load214.5 = load <2 x double>, ptr %649, align 8, !tbaa !5
  %650 = getelementptr inbounds i8, ptr %1, i64 1696
  %wide.load216.5 = load <2 x double>, ptr %650, align 8, !tbaa !5
  %651 = fsub <2 x double> %wide.load214.5, %wide.load216.5
  %652 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %651)
  %653 = fcmp ogt <2 x double> %652, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %654 = zext <2 x i1> %653 to <2 x i32>
  %655 = or <2 x i32> %648, %654
  %656 = getelementptr inbounds i8, ptr %0, i64 1728
  %wide.load214.6 = load <2 x double>, ptr %656, align 8, !tbaa !5
  %657 = getelementptr inbounds i8, ptr %1, i64 1728
  %wide.load216.6 = load <2 x double>, ptr %657, align 8, !tbaa !5
  %658 = fsub <2 x double> %wide.load214.6, %wide.load216.6
  %659 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %658)
  %660 = fcmp ogt <2 x double> %659, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %661 = zext <2 x i1> %660 to <2 x i32>
  %662 = or <2 x i32> %655, %661
  %663 = getelementptr inbounds i8, ptr %0, i64 1760
  %wide.load214.7 = load <2 x double>, ptr %663, align 8, !tbaa !5
  %664 = getelementptr inbounds i8, ptr %1, i64 1760
  %wide.load216.7 = load <2 x double>, ptr %664, align 8, !tbaa !5
  %665 = fsub <2 x double> %wide.load214.7, %wide.load216.7
  %666 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %665)
  %667 = fcmp ogt <2 x double> %666, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %668 = zext <2 x i1> %667 to <2 x i32>
  %669 = or <2 x i32> %662, %668
  %670 = getelementptr inbounds i8, ptr %0, i64 1792
  %wide.load214.8 = load <2 x double>, ptr %670, align 8, !tbaa !5
  %671 = getelementptr inbounds i8, ptr %1, i64 1792
  %wide.load216.8 = load <2 x double>, ptr %671, align 8, !tbaa !5
  %672 = fsub <2 x double> %wide.load214.8, %wide.load216.8
  %673 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %672)
  %674 = fcmp ogt <2 x double> %673, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %675 = zext <2 x i1> %674 to <2 x i32>
  %676 = or <2 x i32> %669, %675
  %677 = getelementptr inbounds i8, ptr %0, i64 1824
  %wide.load214.9 = load <2 x double>, ptr %677, align 8, !tbaa !5
  %678 = getelementptr inbounds i8, ptr %1, i64 1824
  %wide.load216.9 = load <2 x double>, ptr %678, align 8, !tbaa !5
  %679 = fsub <2 x double> %wide.load214.9, %wide.load216.9
  %680 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %679)
  %681 = fcmp ogt <2 x double> %680, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %682 = zext <2 x i1> %681 to <2 x i32>
  %683 = or <2 x i32> %676, %682
  %684 = getelementptr inbounds i8, ptr %0, i64 1856
  %wide.load214.10 = load <2 x double>, ptr %684, align 8, !tbaa !5
  %685 = getelementptr inbounds i8, ptr %1, i64 1856
  %wide.load216.10 = load <2 x double>, ptr %685, align 8, !tbaa !5
  %686 = fsub <2 x double> %wide.load214.10, %wide.load216.10
  %687 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %686)
  %688 = fcmp ogt <2 x double> %687, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %689 = zext <2 x i1> %688 to <2 x i32>
  %690 = or <2 x i32> %683, %689
  %691 = getelementptr inbounds i8, ptr %0, i64 1888
  %wide.load214.11 = load <2 x double>, ptr %691, align 8, !tbaa !5
  %692 = getelementptr inbounds i8, ptr %1, i64 1888
  %wide.load216.11 = load <2 x double>, ptr %692, align 8, !tbaa !5
  %693 = fsub <2 x double> %wide.load214.11, %wide.load216.11
  %694 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %693)
  %695 = fcmp ogt <2 x double> %694, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %696 = zext <2 x i1> %695 to <2 x i32>
  %697 = or <2 x i32> %690, %696
  %698 = getelementptr inbounds i8, ptr %0, i64 1920
  %wide.load214.12 = load <2 x double>, ptr %698, align 8, !tbaa !5
  %699 = getelementptr inbounds i8, ptr %1, i64 1920
  %wide.load216.12 = load <2 x double>, ptr %699, align 8, !tbaa !5
  %700 = fsub <2 x double> %wide.load214.12, %wide.load216.12
  %701 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %700)
  %702 = fcmp ogt <2 x double> %701, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %703 = zext <2 x i1> %702 to <2 x i32>
  %704 = or <2 x i32> %697, %703
  %705 = getelementptr inbounds i8, ptr %0, i64 1952
  %wide.load214.13 = load <2 x double>, ptr %705, align 8, !tbaa !5
  %706 = getelementptr inbounds i8, ptr %1, i64 1952
  %wide.load216.13 = load <2 x double>, ptr %706, align 8, !tbaa !5
  %707 = fsub <2 x double> %wide.load214.13, %wide.load216.13
  %708 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %707)
  %709 = fcmp ogt <2 x double> %708, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %710 = zext <2 x i1> %709 to <2 x i32>
  %711 = or <2 x i32> %704, %710
  %712 = getelementptr inbounds i8, ptr %0, i64 1984
  %wide.load214.14 = load <2 x double>, ptr %712, align 8, !tbaa !5
  %713 = getelementptr inbounds i8, ptr %1, i64 1984
  %wide.load216.14 = load <2 x double>, ptr %713, align 8, !tbaa !5
  %714 = fsub <2 x double> %wide.load214.14, %wide.load216.14
  %715 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %714)
  %716 = fcmp ogt <2 x double> %715, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %717 = zext <2 x i1> %716 to <2 x i32>
  %718 = or <2 x i32> %711, %717
  %719 = getelementptr inbounds i8, ptr %0, i64 2016
  %wide.load214.15 = load <2 x double>, ptr %719, align 8, !tbaa !5
  %720 = getelementptr inbounds i8, ptr %1, i64 2016
  %wide.load216.15 = load <2 x double>, ptr %720, align 8, !tbaa !5
  %721 = fsub <2 x double> %wide.load214.15, %wide.load216.15
  %722 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %721)
  %723 = fcmp ogt <2 x double> %722, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %724 = zext <2 x i1> %723 to <2 x i32>
  %725 = or <2 x i32> %718, %724
  %726 = getelementptr inbounds i8, ptr %0, i64 1552
  %wide.load215 = load <2 x double>, ptr %726, align 8, !tbaa !5
  %727 = getelementptr inbounds i8, ptr %1, i64 1552
  %wide.load217 = load <2 x double>, ptr %727, align 8, !tbaa !5
  %728 = fsub <2 x double> %wide.load215, %wide.load217
  %729 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %728)
  %730 = fcmp ogt <2 x double> %729, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %731 = getelementptr inbounds i8, ptr %0, i64 1584
  %wide.load215.1 = load <2 x double>, ptr %731, align 8, !tbaa !5
  %732 = getelementptr inbounds i8, ptr %1, i64 1584
  %wide.load217.1 = load <2 x double>, ptr %732, align 8, !tbaa !5
  %733 = fsub <2 x double> %wide.load215.1, %wide.load217.1
  %734 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %733)
  %735 = fcmp ogt <2 x double> %734, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %736 = or <2 x i1> %730, %735
  %737 = getelementptr inbounds i8, ptr %0, i64 1616
  %wide.load215.2 = load <2 x double>, ptr %737, align 8, !tbaa !5
  %738 = getelementptr inbounds i8, ptr %1, i64 1616
  %wide.load217.2 = load <2 x double>, ptr %738, align 8, !tbaa !5
  %739 = fsub <2 x double> %wide.load215.2, %wide.load217.2
  %740 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %739)
  %741 = fcmp ogt <2 x double> %740, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %742 = or <2 x i1> %736, %741
  %743 = getelementptr inbounds i8, ptr %0, i64 1648
  %wide.load215.3 = load <2 x double>, ptr %743, align 8, !tbaa !5
  %744 = getelementptr inbounds i8, ptr %1, i64 1648
  %wide.load217.3 = load <2 x double>, ptr %744, align 8, !tbaa !5
  %745 = fsub <2 x double> %wide.load215.3, %wide.load217.3
  %746 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %745)
  %747 = fcmp ogt <2 x double> %746, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %748 = or <2 x i1> %742, %747
  %749 = getelementptr inbounds i8, ptr %0, i64 1680
  %wide.load215.4 = load <2 x double>, ptr %749, align 8, !tbaa !5
  %750 = getelementptr inbounds i8, ptr %1, i64 1680
  %wide.load217.4 = load <2 x double>, ptr %750, align 8, !tbaa !5
  %751 = fsub <2 x double> %wide.load215.4, %wide.load217.4
  %752 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %751)
  %753 = fcmp ogt <2 x double> %752, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %754 = or <2 x i1> %748, %753
  %755 = getelementptr inbounds i8, ptr %0, i64 1712
  %wide.load215.5 = load <2 x double>, ptr %755, align 8, !tbaa !5
  %756 = getelementptr inbounds i8, ptr %1, i64 1712
  %wide.load217.5 = load <2 x double>, ptr %756, align 8, !tbaa !5
  %757 = fsub <2 x double> %wide.load215.5, %wide.load217.5
  %758 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %757)
  %759 = fcmp ogt <2 x double> %758, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %760 = or <2 x i1> %754, %759
  %761 = getelementptr inbounds i8, ptr %0, i64 1744
  %wide.load215.6 = load <2 x double>, ptr %761, align 8, !tbaa !5
  %762 = getelementptr inbounds i8, ptr %1, i64 1744
  %wide.load217.6 = load <2 x double>, ptr %762, align 8, !tbaa !5
  %763 = fsub <2 x double> %wide.load215.6, %wide.load217.6
  %764 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %763)
  %765 = fcmp ogt <2 x double> %764, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %766 = or <2 x i1> %760, %765
  %767 = getelementptr inbounds i8, ptr %0, i64 1776
  %wide.load215.7 = load <2 x double>, ptr %767, align 8, !tbaa !5
  %768 = getelementptr inbounds i8, ptr %1, i64 1776
  %wide.load217.7 = load <2 x double>, ptr %768, align 8, !tbaa !5
  %769 = fsub <2 x double> %wide.load215.7, %wide.load217.7
  %770 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %769)
  %771 = fcmp ogt <2 x double> %770, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %772 = or <2 x i1> %766, %771
  %773 = getelementptr inbounds i8, ptr %0, i64 1808
  %wide.load215.8 = load <2 x double>, ptr %773, align 8, !tbaa !5
  %774 = getelementptr inbounds i8, ptr %1, i64 1808
  %wide.load217.8 = load <2 x double>, ptr %774, align 8, !tbaa !5
  %775 = fsub <2 x double> %wide.load215.8, %wide.load217.8
  %776 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %775)
  %777 = fcmp ogt <2 x double> %776, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %778 = or <2 x i1> %772, %777
  %779 = getelementptr inbounds i8, ptr %0, i64 1840
  %wide.load215.9 = load <2 x double>, ptr %779, align 8, !tbaa !5
  %780 = getelementptr inbounds i8, ptr %1, i64 1840
  %wide.load217.9 = load <2 x double>, ptr %780, align 8, !tbaa !5
  %781 = fsub <2 x double> %wide.load215.9, %wide.load217.9
  %782 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %781)
  %783 = fcmp ogt <2 x double> %782, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %784 = or <2 x i1> %778, %783
  %785 = getelementptr inbounds i8, ptr %0, i64 1872
  %wide.load215.10 = load <2 x double>, ptr %785, align 8, !tbaa !5
  %786 = getelementptr inbounds i8, ptr %1, i64 1872
  %wide.load217.10 = load <2 x double>, ptr %786, align 8, !tbaa !5
  %787 = fsub <2 x double> %wide.load215.10, %wide.load217.10
  %788 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %787)
  %789 = fcmp ogt <2 x double> %788, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %790 = or <2 x i1> %784, %789
  %791 = getelementptr inbounds i8, ptr %0, i64 1904
  %wide.load215.11 = load <2 x double>, ptr %791, align 8, !tbaa !5
  %792 = getelementptr inbounds i8, ptr %1, i64 1904
  %wide.load217.11 = load <2 x double>, ptr %792, align 8, !tbaa !5
  %793 = fsub <2 x double> %wide.load215.11, %wide.load217.11
  %794 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %793)
  %795 = fcmp ogt <2 x double> %794, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %796 = or <2 x i1> %790, %795
  %797 = getelementptr inbounds i8, ptr %0, i64 1936
  %wide.load215.12 = load <2 x double>, ptr %797, align 8, !tbaa !5
  %798 = getelementptr inbounds i8, ptr %1, i64 1936
  %wide.load217.12 = load <2 x double>, ptr %798, align 8, !tbaa !5
  %799 = fsub <2 x double> %wide.load215.12, %wide.load217.12
  %800 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %799)
  %801 = fcmp ogt <2 x double> %800, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %802 = or <2 x i1> %796, %801
  %803 = getelementptr inbounds i8, ptr %0, i64 1968
  %wide.load215.13 = load <2 x double>, ptr %803, align 8, !tbaa !5
  %804 = getelementptr inbounds i8, ptr %1, i64 1968
  %wide.load217.13 = load <2 x double>, ptr %804, align 8, !tbaa !5
  %805 = fsub <2 x double> %wide.load215.13, %wide.load217.13
  %806 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %805)
  %807 = fcmp ogt <2 x double> %806, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %808 = or <2 x i1> %802, %807
  %809 = getelementptr inbounds i8, ptr %0, i64 2000
  %wide.load215.14 = load <2 x double>, ptr %809, align 8, !tbaa !5
  %810 = getelementptr inbounds i8, ptr %1, i64 2000
  %wide.load217.14 = load <2 x double>, ptr %810, align 8, !tbaa !5
  %811 = fsub <2 x double> %wide.load215.14, %wide.load217.14
  %812 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %811)
  %813 = fcmp ogt <2 x double> %812, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %814 = or <2 x i1> %808, %813
  %815 = getelementptr inbounds i8, ptr %0, i64 2032
  %wide.load215.15 = load <2 x double>, ptr %815, align 8, !tbaa !5
  %816 = getelementptr inbounds i8, ptr %1, i64 2032
  %wide.load217.15 = load <2 x double>, ptr %816, align 8, !tbaa !5
  %817 = fsub <2 x double> %wide.load215.15, %wide.load217.15
  %818 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %817)
  %819 = fcmp ogt <2 x double> %818, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %820 = or <2 x i1> %814, %819
  %821 = zext <2 x i1> %820 to <2 x i32>
  %bin.rdx219 = or <2 x i32> %725, %821
  %822 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx219)
  %823 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %822, i64 0
  %824 = getelementptr inbounds i8, ptr %0, i64 2048
  %wide.load229 = load <2 x double>, ptr %824, align 8, !tbaa !5
  %825 = getelementptr inbounds i8, ptr %1, i64 2048
  %wide.load231 = load <2 x double>, ptr %825, align 8, !tbaa !5
  %826 = fsub <2 x double> %wide.load229, %wide.load231
  %827 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %826)
  %828 = fcmp ogt <2 x double> %827, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %829 = zext <2 x i1> %828 to <2 x i32>
  %830 = or <2 x i32> %823, %829
  %831 = getelementptr inbounds i8, ptr %0, i64 2080
  %wide.load229.1 = load <2 x double>, ptr %831, align 8, !tbaa !5
  %832 = getelementptr inbounds i8, ptr %1, i64 2080
  %wide.load231.1 = load <2 x double>, ptr %832, align 8, !tbaa !5
  %833 = fsub <2 x double> %wide.load229.1, %wide.load231.1
  %834 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %833)
  %835 = fcmp ogt <2 x double> %834, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %836 = zext <2 x i1> %835 to <2 x i32>
  %837 = or <2 x i32> %830, %836
  %838 = getelementptr inbounds i8, ptr %0, i64 2112
  %wide.load229.2 = load <2 x double>, ptr %838, align 8, !tbaa !5
  %839 = getelementptr inbounds i8, ptr %1, i64 2112
  %wide.load231.2 = load <2 x double>, ptr %839, align 8, !tbaa !5
  %840 = fsub <2 x double> %wide.load229.2, %wide.load231.2
  %841 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %840)
  %842 = fcmp ogt <2 x double> %841, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %843 = zext <2 x i1> %842 to <2 x i32>
  %844 = or <2 x i32> %837, %843
  %845 = getelementptr inbounds i8, ptr %0, i64 2144
  %wide.load229.3 = load <2 x double>, ptr %845, align 8, !tbaa !5
  %846 = getelementptr inbounds i8, ptr %1, i64 2144
  %wide.load231.3 = load <2 x double>, ptr %846, align 8, !tbaa !5
  %847 = fsub <2 x double> %wide.load229.3, %wide.load231.3
  %848 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %847)
  %849 = fcmp ogt <2 x double> %848, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %850 = zext <2 x i1> %849 to <2 x i32>
  %851 = or <2 x i32> %844, %850
  %852 = getelementptr inbounds i8, ptr %0, i64 2176
  %wide.load229.4 = load <2 x double>, ptr %852, align 8, !tbaa !5
  %853 = getelementptr inbounds i8, ptr %1, i64 2176
  %wide.load231.4 = load <2 x double>, ptr %853, align 8, !tbaa !5
  %854 = fsub <2 x double> %wide.load229.4, %wide.load231.4
  %855 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %854)
  %856 = fcmp ogt <2 x double> %855, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %857 = zext <2 x i1> %856 to <2 x i32>
  %858 = or <2 x i32> %851, %857
  %859 = getelementptr inbounds i8, ptr %0, i64 2208
  %wide.load229.5 = load <2 x double>, ptr %859, align 8, !tbaa !5
  %860 = getelementptr inbounds i8, ptr %1, i64 2208
  %wide.load231.5 = load <2 x double>, ptr %860, align 8, !tbaa !5
  %861 = fsub <2 x double> %wide.load229.5, %wide.load231.5
  %862 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %861)
  %863 = fcmp ogt <2 x double> %862, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %864 = zext <2 x i1> %863 to <2 x i32>
  %865 = or <2 x i32> %858, %864
  %866 = getelementptr inbounds i8, ptr %0, i64 2240
  %wide.load229.6 = load <2 x double>, ptr %866, align 8, !tbaa !5
  %867 = getelementptr inbounds i8, ptr %1, i64 2240
  %wide.load231.6 = load <2 x double>, ptr %867, align 8, !tbaa !5
  %868 = fsub <2 x double> %wide.load229.6, %wide.load231.6
  %869 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %868)
  %870 = fcmp ogt <2 x double> %869, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %871 = zext <2 x i1> %870 to <2 x i32>
  %872 = or <2 x i32> %865, %871
  %873 = getelementptr inbounds i8, ptr %0, i64 2272
  %wide.load229.7 = load <2 x double>, ptr %873, align 8, !tbaa !5
  %874 = getelementptr inbounds i8, ptr %1, i64 2272
  %wide.load231.7 = load <2 x double>, ptr %874, align 8, !tbaa !5
  %875 = fsub <2 x double> %wide.load229.7, %wide.load231.7
  %876 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %875)
  %877 = fcmp ogt <2 x double> %876, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %878 = zext <2 x i1> %877 to <2 x i32>
  %879 = or <2 x i32> %872, %878
  %880 = getelementptr inbounds i8, ptr %0, i64 2304
  %wide.load229.8 = load <2 x double>, ptr %880, align 8, !tbaa !5
  %881 = getelementptr inbounds i8, ptr %1, i64 2304
  %wide.load231.8 = load <2 x double>, ptr %881, align 8, !tbaa !5
  %882 = fsub <2 x double> %wide.load229.8, %wide.load231.8
  %883 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %882)
  %884 = fcmp ogt <2 x double> %883, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %885 = zext <2 x i1> %884 to <2 x i32>
  %886 = or <2 x i32> %879, %885
  %887 = getelementptr inbounds i8, ptr %0, i64 2336
  %wide.load229.9 = load <2 x double>, ptr %887, align 8, !tbaa !5
  %888 = getelementptr inbounds i8, ptr %1, i64 2336
  %wide.load231.9 = load <2 x double>, ptr %888, align 8, !tbaa !5
  %889 = fsub <2 x double> %wide.load229.9, %wide.load231.9
  %890 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %889)
  %891 = fcmp ogt <2 x double> %890, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %892 = zext <2 x i1> %891 to <2 x i32>
  %893 = or <2 x i32> %886, %892
  %894 = getelementptr inbounds i8, ptr %0, i64 2368
  %wide.load229.10 = load <2 x double>, ptr %894, align 8, !tbaa !5
  %895 = getelementptr inbounds i8, ptr %1, i64 2368
  %wide.load231.10 = load <2 x double>, ptr %895, align 8, !tbaa !5
  %896 = fsub <2 x double> %wide.load229.10, %wide.load231.10
  %897 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %896)
  %898 = fcmp ogt <2 x double> %897, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %899 = zext <2 x i1> %898 to <2 x i32>
  %900 = or <2 x i32> %893, %899
  %901 = getelementptr inbounds i8, ptr %0, i64 2400
  %wide.load229.11 = load <2 x double>, ptr %901, align 8, !tbaa !5
  %902 = getelementptr inbounds i8, ptr %1, i64 2400
  %wide.load231.11 = load <2 x double>, ptr %902, align 8, !tbaa !5
  %903 = fsub <2 x double> %wide.load229.11, %wide.load231.11
  %904 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %903)
  %905 = fcmp ogt <2 x double> %904, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %906 = zext <2 x i1> %905 to <2 x i32>
  %907 = or <2 x i32> %900, %906
  %908 = getelementptr inbounds i8, ptr %0, i64 2432
  %wide.load229.12 = load <2 x double>, ptr %908, align 8, !tbaa !5
  %909 = getelementptr inbounds i8, ptr %1, i64 2432
  %wide.load231.12 = load <2 x double>, ptr %909, align 8, !tbaa !5
  %910 = fsub <2 x double> %wide.load229.12, %wide.load231.12
  %911 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %910)
  %912 = fcmp ogt <2 x double> %911, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %913 = zext <2 x i1> %912 to <2 x i32>
  %914 = or <2 x i32> %907, %913
  %915 = getelementptr inbounds i8, ptr %0, i64 2464
  %wide.load229.13 = load <2 x double>, ptr %915, align 8, !tbaa !5
  %916 = getelementptr inbounds i8, ptr %1, i64 2464
  %wide.load231.13 = load <2 x double>, ptr %916, align 8, !tbaa !5
  %917 = fsub <2 x double> %wide.load229.13, %wide.load231.13
  %918 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %917)
  %919 = fcmp ogt <2 x double> %918, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %920 = zext <2 x i1> %919 to <2 x i32>
  %921 = or <2 x i32> %914, %920
  %922 = getelementptr inbounds i8, ptr %0, i64 2496
  %wide.load229.14 = load <2 x double>, ptr %922, align 8, !tbaa !5
  %923 = getelementptr inbounds i8, ptr %1, i64 2496
  %wide.load231.14 = load <2 x double>, ptr %923, align 8, !tbaa !5
  %924 = fsub <2 x double> %wide.load229.14, %wide.load231.14
  %925 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %924)
  %926 = fcmp ogt <2 x double> %925, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %927 = zext <2 x i1> %926 to <2 x i32>
  %928 = or <2 x i32> %921, %927
  %929 = getelementptr inbounds i8, ptr %0, i64 2528
  %wide.load229.15 = load <2 x double>, ptr %929, align 8, !tbaa !5
  %930 = getelementptr inbounds i8, ptr %1, i64 2528
  %wide.load231.15 = load <2 x double>, ptr %930, align 8, !tbaa !5
  %931 = fsub <2 x double> %wide.load229.15, %wide.load231.15
  %932 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %931)
  %933 = fcmp ogt <2 x double> %932, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %934 = zext <2 x i1> %933 to <2 x i32>
  %935 = or <2 x i32> %928, %934
  %936 = getelementptr inbounds i8, ptr %0, i64 2064
  %wide.load230 = load <2 x double>, ptr %936, align 8, !tbaa !5
  %937 = getelementptr inbounds i8, ptr %1, i64 2064
  %wide.load232 = load <2 x double>, ptr %937, align 8, !tbaa !5
  %938 = fsub <2 x double> %wide.load230, %wide.load232
  %939 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %938)
  %940 = fcmp ogt <2 x double> %939, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %941 = getelementptr inbounds i8, ptr %0, i64 2096
  %wide.load230.1 = load <2 x double>, ptr %941, align 8, !tbaa !5
  %942 = getelementptr inbounds i8, ptr %1, i64 2096
  %wide.load232.1 = load <2 x double>, ptr %942, align 8, !tbaa !5
  %943 = fsub <2 x double> %wide.load230.1, %wide.load232.1
  %944 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %943)
  %945 = fcmp ogt <2 x double> %944, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %946 = or <2 x i1> %940, %945
  %947 = getelementptr inbounds i8, ptr %0, i64 2128
  %wide.load230.2 = load <2 x double>, ptr %947, align 8, !tbaa !5
  %948 = getelementptr inbounds i8, ptr %1, i64 2128
  %wide.load232.2 = load <2 x double>, ptr %948, align 8, !tbaa !5
  %949 = fsub <2 x double> %wide.load230.2, %wide.load232.2
  %950 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %949)
  %951 = fcmp ogt <2 x double> %950, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %952 = or <2 x i1> %946, %951
  %953 = getelementptr inbounds i8, ptr %0, i64 2160
  %wide.load230.3 = load <2 x double>, ptr %953, align 8, !tbaa !5
  %954 = getelementptr inbounds i8, ptr %1, i64 2160
  %wide.load232.3 = load <2 x double>, ptr %954, align 8, !tbaa !5
  %955 = fsub <2 x double> %wide.load230.3, %wide.load232.3
  %956 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %955)
  %957 = fcmp ogt <2 x double> %956, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %958 = or <2 x i1> %952, %957
  %959 = getelementptr inbounds i8, ptr %0, i64 2192
  %wide.load230.4 = load <2 x double>, ptr %959, align 8, !tbaa !5
  %960 = getelementptr inbounds i8, ptr %1, i64 2192
  %wide.load232.4 = load <2 x double>, ptr %960, align 8, !tbaa !5
  %961 = fsub <2 x double> %wide.load230.4, %wide.load232.4
  %962 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %961)
  %963 = fcmp ogt <2 x double> %962, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %964 = or <2 x i1> %958, %963
  %965 = getelementptr inbounds i8, ptr %0, i64 2224
  %wide.load230.5 = load <2 x double>, ptr %965, align 8, !tbaa !5
  %966 = getelementptr inbounds i8, ptr %1, i64 2224
  %wide.load232.5 = load <2 x double>, ptr %966, align 8, !tbaa !5
  %967 = fsub <2 x double> %wide.load230.5, %wide.load232.5
  %968 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %967)
  %969 = fcmp ogt <2 x double> %968, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %970 = or <2 x i1> %964, %969
  %971 = getelementptr inbounds i8, ptr %0, i64 2256
  %wide.load230.6 = load <2 x double>, ptr %971, align 8, !tbaa !5
  %972 = getelementptr inbounds i8, ptr %1, i64 2256
  %wide.load232.6 = load <2 x double>, ptr %972, align 8, !tbaa !5
  %973 = fsub <2 x double> %wide.load230.6, %wide.load232.6
  %974 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %973)
  %975 = fcmp ogt <2 x double> %974, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %976 = or <2 x i1> %970, %975
  %977 = getelementptr inbounds i8, ptr %0, i64 2288
  %wide.load230.7 = load <2 x double>, ptr %977, align 8, !tbaa !5
  %978 = getelementptr inbounds i8, ptr %1, i64 2288
  %wide.load232.7 = load <2 x double>, ptr %978, align 8, !tbaa !5
  %979 = fsub <2 x double> %wide.load230.7, %wide.load232.7
  %980 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %979)
  %981 = fcmp ogt <2 x double> %980, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %982 = or <2 x i1> %976, %981
  %983 = getelementptr inbounds i8, ptr %0, i64 2320
  %wide.load230.8 = load <2 x double>, ptr %983, align 8, !tbaa !5
  %984 = getelementptr inbounds i8, ptr %1, i64 2320
  %wide.load232.8 = load <2 x double>, ptr %984, align 8, !tbaa !5
  %985 = fsub <2 x double> %wide.load230.8, %wide.load232.8
  %986 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %985)
  %987 = fcmp ogt <2 x double> %986, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %988 = or <2 x i1> %982, %987
  %989 = getelementptr inbounds i8, ptr %0, i64 2352
  %wide.load230.9 = load <2 x double>, ptr %989, align 8, !tbaa !5
  %990 = getelementptr inbounds i8, ptr %1, i64 2352
  %wide.load232.9 = load <2 x double>, ptr %990, align 8, !tbaa !5
  %991 = fsub <2 x double> %wide.load230.9, %wide.load232.9
  %992 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %991)
  %993 = fcmp ogt <2 x double> %992, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %994 = or <2 x i1> %988, %993
  %995 = getelementptr inbounds i8, ptr %0, i64 2384
  %wide.load230.10 = load <2 x double>, ptr %995, align 8, !tbaa !5
  %996 = getelementptr inbounds i8, ptr %1, i64 2384
  %wide.load232.10 = load <2 x double>, ptr %996, align 8, !tbaa !5
  %997 = fsub <2 x double> %wide.load230.10, %wide.load232.10
  %998 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %997)
  %999 = fcmp ogt <2 x double> %998, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1000 = or <2 x i1> %994, %999
  %1001 = getelementptr inbounds i8, ptr %0, i64 2416
  %wide.load230.11 = load <2 x double>, ptr %1001, align 8, !tbaa !5
  %1002 = getelementptr inbounds i8, ptr %1, i64 2416
  %wide.load232.11 = load <2 x double>, ptr %1002, align 8, !tbaa !5
  %1003 = fsub <2 x double> %wide.load230.11, %wide.load232.11
  %1004 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1003)
  %1005 = fcmp ogt <2 x double> %1004, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1006 = or <2 x i1> %1000, %1005
  %1007 = getelementptr inbounds i8, ptr %0, i64 2448
  %wide.load230.12 = load <2 x double>, ptr %1007, align 8, !tbaa !5
  %1008 = getelementptr inbounds i8, ptr %1, i64 2448
  %wide.load232.12 = load <2 x double>, ptr %1008, align 8, !tbaa !5
  %1009 = fsub <2 x double> %wide.load230.12, %wide.load232.12
  %1010 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1009)
  %1011 = fcmp ogt <2 x double> %1010, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1012 = or <2 x i1> %1006, %1011
  %1013 = getelementptr inbounds i8, ptr %0, i64 2480
  %wide.load230.13 = load <2 x double>, ptr %1013, align 8, !tbaa !5
  %1014 = getelementptr inbounds i8, ptr %1, i64 2480
  %wide.load232.13 = load <2 x double>, ptr %1014, align 8, !tbaa !5
  %1015 = fsub <2 x double> %wide.load230.13, %wide.load232.13
  %1016 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1015)
  %1017 = fcmp ogt <2 x double> %1016, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1018 = or <2 x i1> %1012, %1017
  %1019 = getelementptr inbounds i8, ptr %0, i64 2512
  %wide.load230.14 = load <2 x double>, ptr %1019, align 8, !tbaa !5
  %1020 = getelementptr inbounds i8, ptr %1, i64 2512
  %wide.load232.14 = load <2 x double>, ptr %1020, align 8, !tbaa !5
  %1021 = fsub <2 x double> %wide.load230.14, %wide.load232.14
  %1022 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1021)
  %1023 = fcmp ogt <2 x double> %1022, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1024 = or <2 x i1> %1018, %1023
  %1025 = getelementptr inbounds i8, ptr %0, i64 2544
  %wide.load230.15 = load <2 x double>, ptr %1025, align 8, !tbaa !5
  %1026 = getelementptr inbounds i8, ptr %1, i64 2544
  %wide.load232.15 = load <2 x double>, ptr %1026, align 8, !tbaa !5
  %1027 = fsub <2 x double> %wide.load230.15, %wide.load232.15
  %1028 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1027)
  %1029 = fcmp ogt <2 x double> %1028, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1030 = or <2 x i1> %1024, %1029
  %1031 = zext <2 x i1> %1030 to <2 x i32>
  %bin.rdx234 = or <2 x i32> %935, %1031
  %1032 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx234)
  %1033 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1032, i64 0
  %1034 = getelementptr inbounds i8, ptr %0, i64 2560
  %wide.load244 = load <2 x double>, ptr %1034, align 8, !tbaa !5
  %1035 = getelementptr inbounds i8, ptr %1, i64 2560
  %wide.load246 = load <2 x double>, ptr %1035, align 8, !tbaa !5
  %1036 = fsub <2 x double> %wide.load244, %wide.load246
  %1037 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1036)
  %1038 = fcmp ogt <2 x double> %1037, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1039 = zext <2 x i1> %1038 to <2 x i32>
  %1040 = or <2 x i32> %1033, %1039
  %1041 = getelementptr inbounds i8, ptr %0, i64 2592
  %wide.load244.1 = load <2 x double>, ptr %1041, align 8, !tbaa !5
  %1042 = getelementptr inbounds i8, ptr %1, i64 2592
  %wide.load246.1 = load <2 x double>, ptr %1042, align 8, !tbaa !5
  %1043 = fsub <2 x double> %wide.load244.1, %wide.load246.1
  %1044 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1043)
  %1045 = fcmp ogt <2 x double> %1044, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1046 = zext <2 x i1> %1045 to <2 x i32>
  %1047 = or <2 x i32> %1040, %1046
  %1048 = getelementptr inbounds i8, ptr %0, i64 2624
  %wide.load244.2 = load <2 x double>, ptr %1048, align 8, !tbaa !5
  %1049 = getelementptr inbounds i8, ptr %1, i64 2624
  %wide.load246.2 = load <2 x double>, ptr %1049, align 8, !tbaa !5
  %1050 = fsub <2 x double> %wide.load244.2, %wide.load246.2
  %1051 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1050)
  %1052 = fcmp ogt <2 x double> %1051, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1053 = zext <2 x i1> %1052 to <2 x i32>
  %1054 = or <2 x i32> %1047, %1053
  %1055 = getelementptr inbounds i8, ptr %0, i64 2656
  %wide.load244.3 = load <2 x double>, ptr %1055, align 8, !tbaa !5
  %1056 = getelementptr inbounds i8, ptr %1, i64 2656
  %wide.load246.3 = load <2 x double>, ptr %1056, align 8, !tbaa !5
  %1057 = fsub <2 x double> %wide.load244.3, %wide.load246.3
  %1058 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1057)
  %1059 = fcmp ogt <2 x double> %1058, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1060 = zext <2 x i1> %1059 to <2 x i32>
  %1061 = or <2 x i32> %1054, %1060
  %1062 = getelementptr inbounds i8, ptr %0, i64 2688
  %wide.load244.4 = load <2 x double>, ptr %1062, align 8, !tbaa !5
  %1063 = getelementptr inbounds i8, ptr %1, i64 2688
  %wide.load246.4 = load <2 x double>, ptr %1063, align 8, !tbaa !5
  %1064 = fsub <2 x double> %wide.load244.4, %wide.load246.4
  %1065 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1064)
  %1066 = fcmp ogt <2 x double> %1065, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1067 = zext <2 x i1> %1066 to <2 x i32>
  %1068 = or <2 x i32> %1061, %1067
  %1069 = getelementptr inbounds i8, ptr %0, i64 2720
  %wide.load244.5 = load <2 x double>, ptr %1069, align 8, !tbaa !5
  %1070 = getelementptr inbounds i8, ptr %1, i64 2720
  %wide.load246.5 = load <2 x double>, ptr %1070, align 8, !tbaa !5
  %1071 = fsub <2 x double> %wide.load244.5, %wide.load246.5
  %1072 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1071)
  %1073 = fcmp ogt <2 x double> %1072, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1074 = zext <2 x i1> %1073 to <2 x i32>
  %1075 = or <2 x i32> %1068, %1074
  %1076 = getelementptr inbounds i8, ptr %0, i64 2752
  %wide.load244.6 = load <2 x double>, ptr %1076, align 8, !tbaa !5
  %1077 = getelementptr inbounds i8, ptr %1, i64 2752
  %wide.load246.6 = load <2 x double>, ptr %1077, align 8, !tbaa !5
  %1078 = fsub <2 x double> %wide.load244.6, %wide.load246.6
  %1079 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1078)
  %1080 = fcmp ogt <2 x double> %1079, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1081 = zext <2 x i1> %1080 to <2 x i32>
  %1082 = or <2 x i32> %1075, %1081
  %1083 = getelementptr inbounds i8, ptr %0, i64 2784
  %wide.load244.7 = load <2 x double>, ptr %1083, align 8, !tbaa !5
  %1084 = getelementptr inbounds i8, ptr %1, i64 2784
  %wide.load246.7 = load <2 x double>, ptr %1084, align 8, !tbaa !5
  %1085 = fsub <2 x double> %wide.load244.7, %wide.load246.7
  %1086 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1085)
  %1087 = fcmp ogt <2 x double> %1086, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1088 = zext <2 x i1> %1087 to <2 x i32>
  %1089 = or <2 x i32> %1082, %1088
  %1090 = getelementptr inbounds i8, ptr %0, i64 2816
  %wide.load244.8 = load <2 x double>, ptr %1090, align 8, !tbaa !5
  %1091 = getelementptr inbounds i8, ptr %1, i64 2816
  %wide.load246.8 = load <2 x double>, ptr %1091, align 8, !tbaa !5
  %1092 = fsub <2 x double> %wide.load244.8, %wide.load246.8
  %1093 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1092)
  %1094 = fcmp ogt <2 x double> %1093, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1095 = zext <2 x i1> %1094 to <2 x i32>
  %1096 = or <2 x i32> %1089, %1095
  %1097 = getelementptr inbounds i8, ptr %0, i64 2848
  %wide.load244.9 = load <2 x double>, ptr %1097, align 8, !tbaa !5
  %1098 = getelementptr inbounds i8, ptr %1, i64 2848
  %wide.load246.9 = load <2 x double>, ptr %1098, align 8, !tbaa !5
  %1099 = fsub <2 x double> %wide.load244.9, %wide.load246.9
  %1100 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1099)
  %1101 = fcmp ogt <2 x double> %1100, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1102 = zext <2 x i1> %1101 to <2 x i32>
  %1103 = or <2 x i32> %1096, %1102
  %1104 = getelementptr inbounds i8, ptr %0, i64 2880
  %wide.load244.10 = load <2 x double>, ptr %1104, align 8, !tbaa !5
  %1105 = getelementptr inbounds i8, ptr %1, i64 2880
  %wide.load246.10 = load <2 x double>, ptr %1105, align 8, !tbaa !5
  %1106 = fsub <2 x double> %wide.load244.10, %wide.load246.10
  %1107 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1106)
  %1108 = fcmp ogt <2 x double> %1107, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1109 = zext <2 x i1> %1108 to <2 x i32>
  %1110 = or <2 x i32> %1103, %1109
  %1111 = getelementptr inbounds i8, ptr %0, i64 2912
  %wide.load244.11 = load <2 x double>, ptr %1111, align 8, !tbaa !5
  %1112 = getelementptr inbounds i8, ptr %1, i64 2912
  %wide.load246.11 = load <2 x double>, ptr %1112, align 8, !tbaa !5
  %1113 = fsub <2 x double> %wide.load244.11, %wide.load246.11
  %1114 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1113)
  %1115 = fcmp ogt <2 x double> %1114, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1116 = zext <2 x i1> %1115 to <2 x i32>
  %1117 = or <2 x i32> %1110, %1116
  %1118 = getelementptr inbounds i8, ptr %0, i64 2944
  %wide.load244.12 = load <2 x double>, ptr %1118, align 8, !tbaa !5
  %1119 = getelementptr inbounds i8, ptr %1, i64 2944
  %wide.load246.12 = load <2 x double>, ptr %1119, align 8, !tbaa !5
  %1120 = fsub <2 x double> %wide.load244.12, %wide.load246.12
  %1121 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1120)
  %1122 = fcmp ogt <2 x double> %1121, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1123 = zext <2 x i1> %1122 to <2 x i32>
  %1124 = or <2 x i32> %1117, %1123
  %1125 = getelementptr inbounds i8, ptr %0, i64 2976
  %wide.load244.13 = load <2 x double>, ptr %1125, align 8, !tbaa !5
  %1126 = getelementptr inbounds i8, ptr %1, i64 2976
  %wide.load246.13 = load <2 x double>, ptr %1126, align 8, !tbaa !5
  %1127 = fsub <2 x double> %wide.load244.13, %wide.load246.13
  %1128 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1127)
  %1129 = fcmp ogt <2 x double> %1128, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1130 = zext <2 x i1> %1129 to <2 x i32>
  %1131 = or <2 x i32> %1124, %1130
  %1132 = getelementptr inbounds i8, ptr %0, i64 3008
  %wide.load244.14 = load <2 x double>, ptr %1132, align 8, !tbaa !5
  %1133 = getelementptr inbounds i8, ptr %1, i64 3008
  %wide.load246.14 = load <2 x double>, ptr %1133, align 8, !tbaa !5
  %1134 = fsub <2 x double> %wide.load244.14, %wide.load246.14
  %1135 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1134)
  %1136 = fcmp ogt <2 x double> %1135, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1137 = zext <2 x i1> %1136 to <2 x i32>
  %1138 = or <2 x i32> %1131, %1137
  %1139 = getelementptr inbounds i8, ptr %0, i64 3040
  %wide.load244.15 = load <2 x double>, ptr %1139, align 8, !tbaa !5
  %1140 = getelementptr inbounds i8, ptr %1, i64 3040
  %wide.load246.15 = load <2 x double>, ptr %1140, align 8, !tbaa !5
  %1141 = fsub <2 x double> %wide.load244.15, %wide.load246.15
  %1142 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1141)
  %1143 = fcmp ogt <2 x double> %1142, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1144 = zext <2 x i1> %1143 to <2 x i32>
  %1145 = or <2 x i32> %1138, %1144
  %1146 = getelementptr inbounds i8, ptr %0, i64 2576
  %wide.load245 = load <2 x double>, ptr %1146, align 8, !tbaa !5
  %1147 = getelementptr inbounds i8, ptr %1, i64 2576
  %wide.load247 = load <2 x double>, ptr %1147, align 8, !tbaa !5
  %1148 = fsub <2 x double> %wide.load245, %wide.load247
  %1149 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1148)
  %1150 = fcmp ogt <2 x double> %1149, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1151 = getelementptr inbounds i8, ptr %0, i64 2608
  %wide.load245.1 = load <2 x double>, ptr %1151, align 8, !tbaa !5
  %1152 = getelementptr inbounds i8, ptr %1, i64 2608
  %wide.load247.1 = load <2 x double>, ptr %1152, align 8, !tbaa !5
  %1153 = fsub <2 x double> %wide.load245.1, %wide.load247.1
  %1154 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1153)
  %1155 = fcmp ogt <2 x double> %1154, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1156 = or <2 x i1> %1150, %1155
  %1157 = getelementptr inbounds i8, ptr %0, i64 2640
  %wide.load245.2 = load <2 x double>, ptr %1157, align 8, !tbaa !5
  %1158 = getelementptr inbounds i8, ptr %1, i64 2640
  %wide.load247.2 = load <2 x double>, ptr %1158, align 8, !tbaa !5
  %1159 = fsub <2 x double> %wide.load245.2, %wide.load247.2
  %1160 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1159)
  %1161 = fcmp ogt <2 x double> %1160, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1162 = or <2 x i1> %1156, %1161
  %1163 = getelementptr inbounds i8, ptr %0, i64 2672
  %wide.load245.3 = load <2 x double>, ptr %1163, align 8, !tbaa !5
  %1164 = getelementptr inbounds i8, ptr %1, i64 2672
  %wide.load247.3 = load <2 x double>, ptr %1164, align 8, !tbaa !5
  %1165 = fsub <2 x double> %wide.load245.3, %wide.load247.3
  %1166 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1165)
  %1167 = fcmp ogt <2 x double> %1166, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1168 = or <2 x i1> %1162, %1167
  %1169 = getelementptr inbounds i8, ptr %0, i64 2704
  %wide.load245.4 = load <2 x double>, ptr %1169, align 8, !tbaa !5
  %1170 = getelementptr inbounds i8, ptr %1, i64 2704
  %wide.load247.4 = load <2 x double>, ptr %1170, align 8, !tbaa !5
  %1171 = fsub <2 x double> %wide.load245.4, %wide.load247.4
  %1172 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1171)
  %1173 = fcmp ogt <2 x double> %1172, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1174 = or <2 x i1> %1168, %1173
  %1175 = getelementptr inbounds i8, ptr %0, i64 2736
  %wide.load245.5 = load <2 x double>, ptr %1175, align 8, !tbaa !5
  %1176 = getelementptr inbounds i8, ptr %1, i64 2736
  %wide.load247.5 = load <2 x double>, ptr %1176, align 8, !tbaa !5
  %1177 = fsub <2 x double> %wide.load245.5, %wide.load247.5
  %1178 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1177)
  %1179 = fcmp ogt <2 x double> %1178, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1180 = or <2 x i1> %1174, %1179
  %1181 = getelementptr inbounds i8, ptr %0, i64 2768
  %wide.load245.6 = load <2 x double>, ptr %1181, align 8, !tbaa !5
  %1182 = getelementptr inbounds i8, ptr %1, i64 2768
  %wide.load247.6 = load <2 x double>, ptr %1182, align 8, !tbaa !5
  %1183 = fsub <2 x double> %wide.load245.6, %wide.load247.6
  %1184 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1183)
  %1185 = fcmp ogt <2 x double> %1184, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1186 = or <2 x i1> %1180, %1185
  %1187 = getelementptr inbounds i8, ptr %0, i64 2800
  %wide.load245.7 = load <2 x double>, ptr %1187, align 8, !tbaa !5
  %1188 = getelementptr inbounds i8, ptr %1, i64 2800
  %wide.load247.7 = load <2 x double>, ptr %1188, align 8, !tbaa !5
  %1189 = fsub <2 x double> %wide.load245.7, %wide.load247.7
  %1190 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1189)
  %1191 = fcmp ogt <2 x double> %1190, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1192 = or <2 x i1> %1186, %1191
  %1193 = getelementptr inbounds i8, ptr %0, i64 2832
  %wide.load245.8 = load <2 x double>, ptr %1193, align 8, !tbaa !5
  %1194 = getelementptr inbounds i8, ptr %1, i64 2832
  %wide.load247.8 = load <2 x double>, ptr %1194, align 8, !tbaa !5
  %1195 = fsub <2 x double> %wide.load245.8, %wide.load247.8
  %1196 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1195)
  %1197 = fcmp ogt <2 x double> %1196, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1198 = or <2 x i1> %1192, %1197
  %1199 = getelementptr inbounds i8, ptr %0, i64 2864
  %wide.load245.9 = load <2 x double>, ptr %1199, align 8, !tbaa !5
  %1200 = getelementptr inbounds i8, ptr %1, i64 2864
  %wide.load247.9 = load <2 x double>, ptr %1200, align 8, !tbaa !5
  %1201 = fsub <2 x double> %wide.load245.9, %wide.load247.9
  %1202 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1201)
  %1203 = fcmp ogt <2 x double> %1202, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1204 = or <2 x i1> %1198, %1203
  %1205 = getelementptr inbounds i8, ptr %0, i64 2896
  %wide.load245.10 = load <2 x double>, ptr %1205, align 8, !tbaa !5
  %1206 = getelementptr inbounds i8, ptr %1, i64 2896
  %wide.load247.10 = load <2 x double>, ptr %1206, align 8, !tbaa !5
  %1207 = fsub <2 x double> %wide.load245.10, %wide.load247.10
  %1208 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1207)
  %1209 = fcmp ogt <2 x double> %1208, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1210 = or <2 x i1> %1204, %1209
  %1211 = getelementptr inbounds i8, ptr %0, i64 2928
  %wide.load245.11 = load <2 x double>, ptr %1211, align 8, !tbaa !5
  %1212 = getelementptr inbounds i8, ptr %1, i64 2928
  %wide.load247.11 = load <2 x double>, ptr %1212, align 8, !tbaa !5
  %1213 = fsub <2 x double> %wide.load245.11, %wide.load247.11
  %1214 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1213)
  %1215 = fcmp ogt <2 x double> %1214, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1216 = or <2 x i1> %1210, %1215
  %1217 = getelementptr inbounds i8, ptr %0, i64 2960
  %wide.load245.12 = load <2 x double>, ptr %1217, align 8, !tbaa !5
  %1218 = getelementptr inbounds i8, ptr %1, i64 2960
  %wide.load247.12 = load <2 x double>, ptr %1218, align 8, !tbaa !5
  %1219 = fsub <2 x double> %wide.load245.12, %wide.load247.12
  %1220 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1219)
  %1221 = fcmp ogt <2 x double> %1220, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1222 = or <2 x i1> %1216, %1221
  %1223 = getelementptr inbounds i8, ptr %0, i64 2992
  %wide.load245.13 = load <2 x double>, ptr %1223, align 8, !tbaa !5
  %1224 = getelementptr inbounds i8, ptr %1, i64 2992
  %wide.load247.13 = load <2 x double>, ptr %1224, align 8, !tbaa !5
  %1225 = fsub <2 x double> %wide.load245.13, %wide.load247.13
  %1226 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1225)
  %1227 = fcmp ogt <2 x double> %1226, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1228 = or <2 x i1> %1222, %1227
  %1229 = getelementptr inbounds i8, ptr %0, i64 3024
  %wide.load245.14 = load <2 x double>, ptr %1229, align 8, !tbaa !5
  %1230 = getelementptr inbounds i8, ptr %1, i64 3024
  %wide.load247.14 = load <2 x double>, ptr %1230, align 8, !tbaa !5
  %1231 = fsub <2 x double> %wide.load245.14, %wide.load247.14
  %1232 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1231)
  %1233 = fcmp ogt <2 x double> %1232, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1234 = or <2 x i1> %1228, %1233
  %1235 = getelementptr inbounds i8, ptr %0, i64 3056
  %wide.load245.15 = load <2 x double>, ptr %1235, align 8, !tbaa !5
  %1236 = getelementptr inbounds i8, ptr %1, i64 3056
  %wide.load247.15 = load <2 x double>, ptr %1236, align 8, !tbaa !5
  %1237 = fsub <2 x double> %wide.load245.15, %wide.load247.15
  %1238 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1237)
  %1239 = fcmp ogt <2 x double> %1238, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1240 = or <2 x i1> %1234, %1239
  %1241 = zext <2 x i1> %1240 to <2 x i32>
  %bin.rdx249 = or <2 x i32> %1145, %1241
  %1242 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx249)
  %1243 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1242, i64 0
  %1244 = getelementptr inbounds i8, ptr %0, i64 3072
  %wide.load259 = load <2 x double>, ptr %1244, align 8, !tbaa !5
  %1245 = getelementptr inbounds i8, ptr %1, i64 3072
  %wide.load261 = load <2 x double>, ptr %1245, align 8, !tbaa !5
  %1246 = fsub <2 x double> %wide.load259, %wide.load261
  %1247 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1246)
  %1248 = fcmp ogt <2 x double> %1247, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1249 = zext <2 x i1> %1248 to <2 x i32>
  %1250 = or <2 x i32> %1243, %1249
  %1251 = getelementptr inbounds i8, ptr %0, i64 3104
  %wide.load259.1 = load <2 x double>, ptr %1251, align 8, !tbaa !5
  %1252 = getelementptr inbounds i8, ptr %1, i64 3104
  %wide.load261.1 = load <2 x double>, ptr %1252, align 8, !tbaa !5
  %1253 = fsub <2 x double> %wide.load259.1, %wide.load261.1
  %1254 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1253)
  %1255 = fcmp ogt <2 x double> %1254, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1256 = zext <2 x i1> %1255 to <2 x i32>
  %1257 = or <2 x i32> %1250, %1256
  %1258 = getelementptr inbounds i8, ptr %0, i64 3136
  %wide.load259.2 = load <2 x double>, ptr %1258, align 8, !tbaa !5
  %1259 = getelementptr inbounds i8, ptr %1, i64 3136
  %wide.load261.2 = load <2 x double>, ptr %1259, align 8, !tbaa !5
  %1260 = fsub <2 x double> %wide.load259.2, %wide.load261.2
  %1261 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1260)
  %1262 = fcmp ogt <2 x double> %1261, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1263 = zext <2 x i1> %1262 to <2 x i32>
  %1264 = or <2 x i32> %1257, %1263
  %1265 = getelementptr inbounds i8, ptr %0, i64 3168
  %wide.load259.3 = load <2 x double>, ptr %1265, align 8, !tbaa !5
  %1266 = getelementptr inbounds i8, ptr %1, i64 3168
  %wide.load261.3 = load <2 x double>, ptr %1266, align 8, !tbaa !5
  %1267 = fsub <2 x double> %wide.load259.3, %wide.load261.3
  %1268 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1267)
  %1269 = fcmp ogt <2 x double> %1268, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1270 = zext <2 x i1> %1269 to <2 x i32>
  %1271 = or <2 x i32> %1264, %1270
  %1272 = getelementptr inbounds i8, ptr %0, i64 3200
  %wide.load259.4 = load <2 x double>, ptr %1272, align 8, !tbaa !5
  %1273 = getelementptr inbounds i8, ptr %1, i64 3200
  %wide.load261.4 = load <2 x double>, ptr %1273, align 8, !tbaa !5
  %1274 = fsub <2 x double> %wide.load259.4, %wide.load261.4
  %1275 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1274)
  %1276 = fcmp ogt <2 x double> %1275, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1277 = zext <2 x i1> %1276 to <2 x i32>
  %1278 = or <2 x i32> %1271, %1277
  %1279 = getelementptr inbounds i8, ptr %0, i64 3232
  %wide.load259.5 = load <2 x double>, ptr %1279, align 8, !tbaa !5
  %1280 = getelementptr inbounds i8, ptr %1, i64 3232
  %wide.load261.5 = load <2 x double>, ptr %1280, align 8, !tbaa !5
  %1281 = fsub <2 x double> %wide.load259.5, %wide.load261.5
  %1282 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1281)
  %1283 = fcmp ogt <2 x double> %1282, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1284 = zext <2 x i1> %1283 to <2 x i32>
  %1285 = or <2 x i32> %1278, %1284
  %1286 = getelementptr inbounds i8, ptr %0, i64 3264
  %wide.load259.6 = load <2 x double>, ptr %1286, align 8, !tbaa !5
  %1287 = getelementptr inbounds i8, ptr %1, i64 3264
  %wide.load261.6 = load <2 x double>, ptr %1287, align 8, !tbaa !5
  %1288 = fsub <2 x double> %wide.load259.6, %wide.load261.6
  %1289 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1288)
  %1290 = fcmp ogt <2 x double> %1289, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1291 = zext <2 x i1> %1290 to <2 x i32>
  %1292 = or <2 x i32> %1285, %1291
  %1293 = getelementptr inbounds i8, ptr %0, i64 3296
  %wide.load259.7 = load <2 x double>, ptr %1293, align 8, !tbaa !5
  %1294 = getelementptr inbounds i8, ptr %1, i64 3296
  %wide.load261.7 = load <2 x double>, ptr %1294, align 8, !tbaa !5
  %1295 = fsub <2 x double> %wide.load259.7, %wide.load261.7
  %1296 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1295)
  %1297 = fcmp ogt <2 x double> %1296, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1298 = zext <2 x i1> %1297 to <2 x i32>
  %1299 = or <2 x i32> %1292, %1298
  %1300 = getelementptr inbounds i8, ptr %0, i64 3328
  %wide.load259.8 = load <2 x double>, ptr %1300, align 8, !tbaa !5
  %1301 = getelementptr inbounds i8, ptr %1, i64 3328
  %wide.load261.8 = load <2 x double>, ptr %1301, align 8, !tbaa !5
  %1302 = fsub <2 x double> %wide.load259.8, %wide.load261.8
  %1303 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1302)
  %1304 = fcmp ogt <2 x double> %1303, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1305 = zext <2 x i1> %1304 to <2 x i32>
  %1306 = or <2 x i32> %1299, %1305
  %1307 = getelementptr inbounds i8, ptr %0, i64 3360
  %wide.load259.9 = load <2 x double>, ptr %1307, align 8, !tbaa !5
  %1308 = getelementptr inbounds i8, ptr %1, i64 3360
  %wide.load261.9 = load <2 x double>, ptr %1308, align 8, !tbaa !5
  %1309 = fsub <2 x double> %wide.load259.9, %wide.load261.9
  %1310 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1309)
  %1311 = fcmp ogt <2 x double> %1310, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1312 = zext <2 x i1> %1311 to <2 x i32>
  %1313 = or <2 x i32> %1306, %1312
  %1314 = getelementptr inbounds i8, ptr %0, i64 3392
  %wide.load259.10 = load <2 x double>, ptr %1314, align 8, !tbaa !5
  %1315 = getelementptr inbounds i8, ptr %1, i64 3392
  %wide.load261.10 = load <2 x double>, ptr %1315, align 8, !tbaa !5
  %1316 = fsub <2 x double> %wide.load259.10, %wide.load261.10
  %1317 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1316)
  %1318 = fcmp ogt <2 x double> %1317, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1319 = zext <2 x i1> %1318 to <2 x i32>
  %1320 = or <2 x i32> %1313, %1319
  %1321 = getelementptr inbounds i8, ptr %0, i64 3424
  %wide.load259.11 = load <2 x double>, ptr %1321, align 8, !tbaa !5
  %1322 = getelementptr inbounds i8, ptr %1, i64 3424
  %wide.load261.11 = load <2 x double>, ptr %1322, align 8, !tbaa !5
  %1323 = fsub <2 x double> %wide.load259.11, %wide.load261.11
  %1324 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1323)
  %1325 = fcmp ogt <2 x double> %1324, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1326 = zext <2 x i1> %1325 to <2 x i32>
  %1327 = or <2 x i32> %1320, %1326
  %1328 = getelementptr inbounds i8, ptr %0, i64 3456
  %wide.load259.12 = load <2 x double>, ptr %1328, align 8, !tbaa !5
  %1329 = getelementptr inbounds i8, ptr %1, i64 3456
  %wide.load261.12 = load <2 x double>, ptr %1329, align 8, !tbaa !5
  %1330 = fsub <2 x double> %wide.load259.12, %wide.load261.12
  %1331 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1330)
  %1332 = fcmp ogt <2 x double> %1331, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1333 = zext <2 x i1> %1332 to <2 x i32>
  %1334 = or <2 x i32> %1327, %1333
  %1335 = getelementptr inbounds i8, ptr %0, i64 3488
  %wide.load259.13 = load <2 x double>, ptr %1335, align 8, !tbaa !5
  %1336 = getelementptr inbounds i8, ptr %1, i64 3488
  %wide.load261.13 = load <2 x double>, ptr %1336, align 8, !tbaa !5
  %1337 = fsub <2 x double> %wide.load259.13, %wide.load261.13
  %1338 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1337)
  %1339 = fcmp ogt <2 x double> %1338, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1340 = zext <2 x i1> %1339 to <2 x i32>
  %1341 = or <2 x i32> %1334, %1340
  %1342 = getelementptr inbounds i8, ptr %0, i64 3520
  %wide.load259.14 = load <2 x double>, ptr %1342, align 8, !tbaa !5
  %1343 = getelementptr inbounds i8, ptr %1, i64 3520
  %wide.load261.14 = load <2 x double>, ptr %1343, align 8, !tbaa !5
  %1344 = fsub <2 x double> %wide.load259.14, %wide.load261.14
  %1345 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1344)
  %1346 = fcmp ogt <2 x double> %1345, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1347 = zext <2 x i1> %1346 to <2 x i32>
  %1348 = or <2 x i32> %1341, %1347
  %1349 = getelementptr inbounds i8, ptr %0, i64 3552
  %wide.load259.15 = load <2 x double>, ptr %1349, align 8, !tbaa !5
  %1350 = getelementptr inbounds i8, ptr %1, i64 3552
  %wide.load261.15 = load <2 x double>, ptr %1350, align 8, !tbaa !5
  %1351 = fsub <2 x double> %wide.load259.15, %wide.load261.15
  %1352 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1351)
  %1353 = fcmp ogt <2 x double> %1352, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1354 = zext <2 x i1> %1353 to <2 x i32>
  %1355 = or <2 x i32> %1348, %1354
  %1356 = getelementptr inbounds i8, ptr %0, i64 3088
  %wide.load260 = load <2 x double>, ptr %1356, align 8, !tbaa !5
  %1357 = getelementptr inbounds i8, ptr %1, i64 3088
  %wide.load262 = load <2 x double>, ptr %1357, align 8, !tbaa !5
  %1358 = fsub <2 x double> %wide.load260, %wide.load262
  %1359 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1358)
  %1360 = fcmp ogt <2 x double> %1359, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1361 = getelementptr inbounds i8, ptr %0, i64 3120
  %wide.load260.1 = load <2 x double>, ptr %1361, align 8, !tbaa !5
  %1362 = getelementptr inbounds i8, ptr %1, i64 3120
  %wide.load262.1 = load <2 x double>, ptr %1362, align 8, !tbaa !5
  %1363 = fsub <2 x double> %wide.load260.1, %wide.load262.1
  %1364 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1363)
  %1365 = fcmp ogt <2 x double> %1364, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1366 = or <2 x i1> %1360, %1365
  %1367 = getelementptr inbounds i8, ptr %0, i64 3152
  %wide.load260.2 = load <2 x double>, ptr %1367, align 8, !tbaa !5
  %1368 = getelementptr inbounds i8, ptr %1, i64 3152
  %wide.load262.2 = load <2 x double>, ptr %1368, align 8, !tbaa !5
  %1369 = fsub <2 x double> %wide.load260.2, %wide.load262.2
  %1370 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1369)
  %1371 = fcmp ogt <2 x double> %1370, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1372 = or <2 x i1> %1366, %1371
  %1373 = getelementptr inbounds i8, ptr %0, i64 3184
  %wide.load260.3 = load <2 x double>, ptr %1373, align 8, !tbaa !5
  %1374 = getelementptr inbounds i8, ptr %1, i64 3184
  %wide.load262.3 = load <2 x double>, ptr %1374, align 8, !tbaa !5
  %1375 = fsub <2 x double> %wide.load260.3, %wide.load262.3
  %1376 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1375)
  %1377 = fcmp ogt <2 x double> %1376, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1378 = or <2 x i1> %1372, %1377
  %1379 = getelementptr inbounds i8, ptr %0, i64 3216
  %wide.load260.4 = load <2 x double>, ptr %1379, align 8, !tbaa !5
  %1380 = getelementptr inbounds i8, ptr %1, i64 3216
  %wide.load262.4 = load <2 x double>, ptr %1380, align 8, !tbaa !5
  %1381 = fsub <2 x double> %wide.load260.4, %wide.load262.4
  %1382 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1381)
  %1383 = fcmp ogt <2 x double> %1382, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1384 = or <2 x i1> %1378, %1383
  %1385 = getelementptr inbounds i8, ptr %0, i64 3248
  %wide.load260.5 = load <2 x double>, ptr %1385, align 8, !tbaa !5
  %1386 = getelementptr inbounds i8, ptr %1, i64 3248
  %wide.load262.5 = load <2 x double>, ptr %1386, align 8, !tbaa !5
  %1387 = fsub <2 x double> %wide.load260.5, %wide.load262.5
  %1388 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1387)
  %1389 = fcmp ogt <2 x double> %1388, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1390 = or <2 x i1> %1384, %1389
  %1391 = getelementptr inbounds i8, ptr %0, i64 3280
  %wide.load260.6 = load <2 x double>, ptr %1391, align 8, !tbaa !5
  %1392 = getelementptr inbounds i8, ptr %1, i64 3280
  %wide.load262.6 = load <2 x double>, ptr %1392, align 8, !tbaa !5
  %1393 = fsub <2 x double> %wide.load260.6, %wide.load262.6
  %1394 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1393)
  %1395 = fcmp ogt <2 x double> %1394, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1396 = or <2 x i1> %1390, %1395
  %1397 = getelementptr inbounds i8, ptr %0, i64 3312
  %wide.load260.7 = load <2 x double>, ptr %1397, align 8, !tbaa !5
  %1398 = getelementptr inbounds i8, ptr %1, i64 3312
  %wide.load262.7 = load <2 x double>, ptr %1398, align 8, !tbaa !5
  %1399 = fsub <2 x double> %wide.load260.7, %wide.load262.7
  %1400 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1399)
  %1401 = fcmp ogt <2 x double> %1400, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1402 = or <2 x i1> %1396, %1401
  %1403 = getelementptr inbounds i8, ptr %0, i64 3344
  %wide.load260.8 = load <2 x double>, ptr %1403, align 8, !tbaa !5
  %1404 = getelementptr inbounds i8, ptr %1, i64 3344
  %wide.load262.8 = load <2 x double>, ptr %1404, align 8, !tbaa !5
  %1405 = fsub <2 x double> %wide.load260.8, %wide.load262.8
  %1406 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1405)
  %1407 = fcmp ogt <2 x double> %1406, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1408 = or <2 x i1> %1402, %1407
  %1409 = getelementptr inbounds i8, ptr %0, i64 3376
  %wide.load260.9 = load <2 x double>, ptr %1409, align 8, !tbaa !5
  %1410 = getelementptr inbounds i8, ptr %1, i64 3376
  %wide.load262.9 = load <2 x double>, ptr %1410, align 8, !tbaa !5
  %1411 = fsub <2 x double> %wide.load260.9, %wide.load262.9
  %1412 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1411)
  %1413 = fcmp ogt <2 x double> %1412, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1414 = or <2 x i1> %1408, %1413
  %1415 = getelementptr inbounds i8, ptr %0, i64 3408
  %wide.load260.10 = load <2 x double>, ptr %1415, align 8, !tbaa !5
  %1416 = getelementptr inbounds i8, ptr %1, i64 3408
  %wide.load262.10 = load <2 x double>, ptr %1416, align 8, !tbaa !5
  %1417 = fsub <2 x double> %wide.load260.10, %wide.load262.10
  %1418 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1417)
  %1419 = fcmp ogt <2 x double> %1418, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1420 = or <2 x i1> %1414, %1419
  %1421 = getelementptr inbounds i8, ptr %0, i64 3440
  %wide.load260.11 = load <2 x double>, ptr %1421, align 8, !tbaa !5
  %1422 = getelementptr inbounds i8, ptr %1, i64 3440
  %wide.load262.11 = load <2 x double>, ptr %1422, align 8, !tbaa !5
  %1423 = fsub <2 x double> %wide.load260.11, %wide.load262.11
  %1424 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1423)
  %1425 = fcmp ogt <2 x double> %1424, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1426 = or <2 x i1> %1420, %1425
  %1427 = getelementptr inbounds i8, ptr %0, i64 3472
  %wide.load260.12 = load <2 x double>, ptr %1427, align 8, !tbaa !5
  %1428 = getelementptr inbounds i8, ptr %1, i64 3472
  %wide.load262.12 = load <2 x double>, ptr %1428, align 8, !tbaa !5
  %1429 = fsub <2 x double> %wide.load260.12, %wide.load262.12
  %1430 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1429)
  %1431 = fcmp ogt <2 x double> %1430, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1432 = or <2 x i1> %1426, %1431
  %1433 = getelementptr inbounds i8, ptr %0, i64 3504
  %wide.load260.13 = load <2 x double>, ptr %1433, align 8, !tbaa !5
  %1434 = getelementptr inbounds i8, ptr %1, i64 3504
  %wide.load262.13 = load <2 x double>, ptr %1434, align 8, !tbaa !5
  %1435 = fsub <2 x double> %wide.load260.13, %wide.load262.13
  %1436 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1435)
  %1437 = fcmp ogt <2 x double> %1436, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1438 = or <2 x i1> %1432, %1437
  %1439 = getelementptr inbounds i8, ptr %0, i64 3536
  %wide.load260.14 = load <2 x double>, ptr %1439, align 8, !tbaa !5
  %1440 = getelementptr inbounds i8, ptr %1, i64 3536
  %wide.load262.14 = load <2 x double>, ptr %1440, align 8, !tbaa !5
  %1441 = fsub <2 x double> %wide.load260.14, %wide.load262.14
  %1442 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1441)
  %1443 = fcmp ogt <2 x double> %1442, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1444 = or <2 x i1> %1438, %1443
  %1445 = getelementptr inbounds i8, ptr %0, i64 3568
  %wide.load260.15 = load <2 x double>, ptr %1445, align 8, !tbaa !5
  %1446 = getelementptr inbounds i8, ptr %1, i64 3568
  %wide.load262.15 = load <2 x double>, ptr %1446, align 8, !tbaa !5
  %1447 = fsub <2 x double> %wide.load260.15, %wide.load262.15
  %1448 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1447)
  %1449 = fcmp ogt <2 x double> %1448, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1450 = or <2 x i1> %1444, %1449
  %1451 = zext <2 x i1> %1450 to <2 x i32>
  %bin.rdx264 = or <2 x i32> %1355, %1451
  %1452 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx264)
  %1453 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1452, i64 0
  %1454 = getelementptr inbounds i8, ptr %0, i64 3584
  %wide.load274 = load <2 x double>, ptr %1454, align 8, !tbaa !5
  %1455 = getelementptr inbounds i8, ptr %1, i64 3584
  %wide.load276 = load <2 x double>, ptr %1455, align 8, !tbaa !5
  %1456 = fsub <2 x double> %wide.load274, %wide.load276
  %1457 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1456)
  %1458 = fcmp ogt <2 x double> %1457, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1459 = zext <2 x i1> %1458 to <2 x i32>
  %1460 = or <2 x i32> %1453, %1459
  %1461 = getelementptr inbounds i8, ptr %0, i64 3616
  %wide.load274.1 = load <2 x double>, ptr %1461, align 8, !tbaa !5
  %1462 = getelementptr inbounds i8, ptr %1, i64 3616
  %wide.load276.1 = load <2 x double>, ptr %1462, align 8, !tbaa !5
  %1463 = fsub <2 x double> %wide.load274.1, %wide.load276.1
  %1464 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1463)
  %1465 = fcmp ogt <2 x double> %1464, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1466 = zext <2 x i1> %1465 to <2 x i32>
  %1467 = or <2 x i32> %1460, %1466
  %1468 = getelementptr inbounds i8, ptr %0, i64 3648
  %wide.load274.2 = load <2 x double>, ptr %1468, align 8, !tbaa !5
  %1469 = getelementptr inbounds i8, ptr %1, i64 3648
  %wide.load276.2 = load <2 x double>, ptr %1469, align 8, !tbaa !5
  %1470 = fsub <2 x double> %wide.load274.2, %wide.load276.2
  %1471 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1470)
  %1472 = fcmp ogt <2 x double> %1471, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1473 = zext <2 x i1> %1472 to <2 x i32>
  %1474 = or <2 x i32> %1467, %1473
  %1475 = getelementptr inbounds i8, ptr %0, i64 3680
  %wide.load274.3 = load <2 x double>, ptr %1475, align 8, !tbaa !5
  %1476 = getelementptr inbounds i8, ptr %1, i64 3680
  %wide.load276.3 = load <2 x double>, ptr %1476, align 8, !tbaa !5
  %1477 = fsub <2 x double> %wide.load274.3, %wide.load276.3
  %1478 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1477)
  %1479 = fcmp ogt <2 x double> %1478, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1480 = zext <2 x i1> %1479 to <2 x i32>
  %1481 = or <2 x i32> %1474, %1480
  %1482 = getelementptr inbounds i8, ptr %0, i64 3712
  %wide.load274.4 = load <2 x double>, ptr %1482, align 8, !tbaa !5
  %1483 = getelementptr inbounds i8, ptr %1, i64 3712
  %wide.load276.4 = load <2 x double>, ptr %1483, align 8, !tbaa !5
  %1484 = fsub <2 x double> %wide.load274.4, %wide.load276.4
  %1485 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1484)
  %1486 = fcmp ogt <2 x double> %1485, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1487 = zext <2 x i1> %1486 to <2 x i32>
  %1488 = or <2 x i32> %1481, %1487
  %1489 = getelementptr inbounds i8, ptr %0, i64 3744
  %wide.load274.5 = load <2 x double>, ptr %1489, align 8, !tbaa !5
  %1490 = getelementptr inbounds i8, ptr %1, i64 3744
  %wide.load276.5 = load <2 x double>, ptr %1490, align 8, !tbaa !5
  %1491 = fsub <2 x double> %wide.load274.5, %wide.load276.5
  %1492 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1491)
  %1493 = fcmp ogt <2 x double> %1492, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1494 = zext <2 x i1> %1493 to <2 x i32>
  %1495 = or <2 x i32> %1488, %1494
  %1496 = getelementptr inbounds i8, ptr %0, i64 3776
  %wide.load274.6 = load <2 x double>, ptr %1496, align 8, !tbaa !5
  %1497 = getelementptr inbounds i8, ptr %1, i64 3776
  %wide.load276.6 = load <2 x double>, ptr %1497, align 8, !tbaa !5
  %1498 = fsub <2 x double> %wide.load274.6, %wide.load276.6
  %1499 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1498)
  %1500 = fcmp ogt <2 x double> %1499, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1501 = zext <2 x i1> %1500 to <2 x i32>
  %1502 = or <2 x i32> %1495, %1501
  %1503 = getelementptr inbounds i8, ptr %0, i64 3808
  %wide.load274.7 = load <2 x double>, ptr %1503, align 8, !tbaa !5
  %1504 = getelementptr inbounds i8, ptr %1, i64 3808
  %wide.load276.7 = load <2 x double>, ptr %1504, align 8, !tbaa !5
  %1505 = fsub <2 x double> %wide.load274.7, %wide.load276.7
  %1506 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1505)
  %1507 = fcmp ogt <2 x double> %1506, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1508 = zext <2 x i1> %1507 to <2 x i32>
  %1509 = or <2 x i32> %1502, %1508
  %1510 = getelementptr inbounds i8, ptr %0, i64 3840
  %wide.load274.8 = load <2 x double>, ptr %1510, align 8, !tbaa !5
  %1511 = getelementptr inbounds i8, ptr %1, i64 3840
  %wide.load276.8 = load <2 x double>, ptr %1511, align 8, !tbaa !5
  %1512 = fsub <2 x double> %wide.load274.8, %wide.load276.8
  %1513 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1512)
  %1514 = fcmp ogt <2 x double> %1513, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1515 = zext <2 x i1> %1514 to <2 x i32>
  %1516 = or <2 x i32> %1509, %1515
  %1517 = getelementptr inbounds i8, ptr %0, i64 3872
  %wide.load274.9 = load <2 x double>, ptr %1517, align 8, !tbaa !5
  %1518 = getelementptr inbounds i8, ptr %1, i64 3872
  %wide.load276.9 = load <2 x double>, ptr %1518, align 8, !tbaa !5
  %1519 = fsub <2 x double> %wide.load274.9, %wide.load276.9
  %1520 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1519)
  %1521 = fcmp ogt <2 x double> %1520, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1522 = zext <2 x i1> %1521 to <2 x i32>
  %1523 = or <2 x i32> %1516, %1522
  %1524 = getelementptr inbounds i8, ptr %0, i64 3904
  %wide.load274.10 = load <2 x double>, ptr %1524, align 8, !tbaa !5
  %1525 = getelementptr inbounds i8, ptr %1, i64 3904
  %wide.load276.10 = load <2 x double>, ptr %1525, align 8, !tbaa !5
  %1526 = fsub <2 x double> %wide.load274.10, %wide.load276.10
  %1527 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1526)
  %1528 = fcmp ogt <2 x double> %1527, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1529 = zext <2 x i1> %1528 to <2 x i32>
  %1530 = or <2 x i32> %1523, %1529
  %1531 = getelementptr inbounds i8, ptr %0, i64 3936
  %wide.load274.11 = load <2 x double>, ptr %1531, align 8, !tbaa !5
  %1532 = getelementptr inbounds i8, ptr %1, i64 3936
  %wide.load276.11 = load <2 x double>, ptr %1532, align 8, !tbaa !5
  %1533 = fsub <2 x double> %wide.load274.11, %wide.load276.11
  %1534 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1533)
  %1535 = fcmp ogt <2 x double> %1534, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1536 = zext <2 x i1> %1535 to <2 x i32>
  %1537 = or <2 x i32> %1530, %1536
  %1538 = getelementptr inbounds i8, ptr %0, i64 3968
  %wide.load274.12 = load <2 x double>, ptr %1538, align 8, !tbaa !5
  %1539 = getelementptr inbounds i8, ptr %1, i64 3968
  %wide.load276.12 = load <2 x double>, ptr %1539, align 8, !tbaa !5
  %1540 = fsub <2 x double> %wide.load274.12, %wide.load276.12
  %1541 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1540)
  %1542 = fcmp ogt <2 x double> %1541, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1543 = zext <2 x i1> %1542 to <2 x i32>
  %1544 = or <2 x i32> %1537, %1543
  %1545 = getelementptr inbounds i8, ptr %0, i64 4000
  %wide.load274.13 = load <2 x double>, ptr %1545, align 8, !tbaa !5
  %1546 = getelementptr inbounds i8, ptr %1, i64 4000
  %wide.load276.13 = load <2 x double>, ptr %1546, align 8, !tbaa !5
  %1547 = fsub <2 x double> %wide.load274.13, %wide.load276.13
  %1548 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1547)
  %1549 = fcmp ogt <2 x double> %1548, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1550 = zext <2 x i1> %1549 to <2 x i32>
  %1551 = or <2 x i32> %1544, %1550
  %1552 = getelementptr inbounds i8, ptr %0, i64 4032
  %wide.load274.14 = load <2 x double>, ptr %1552, align 8, !tbaa !5
  %1553 = getelementptr inbounds i8, ptr %1, i64 4032
  %wide.load276.14 = load <2 x double>, ptr %1553, align 8, !tbaa !5
  %1554 = fsub <2 x double> %wide.load274.14, %wide.load276.14
  %1555 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1554)
  %1556 = fcmp ogt <2 x double> %1555, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1557 = zext <2 x i1> %1556 to <2 x i32>
  %1558 = or <2 x i32> %1551, %1557
  %1559 = getelementptr inbounds i8, ptr %0, i64 4064
  %wide.load274.15 = load <2 x double>, ptr %1559, align 8, !tbaa !5
  %1560 = getelementptr inbounds i8, ptr %1, i64 4064
  %wide.load276.15 = load <2 x double>, ptr %1560, align 8, !tbaa !5
  %1561 = fsub <2 x double> %wide.load274.15, %wide.load276.15
  %1562 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1561)
  %1563 = fcmp ogt <2 x double> %1562, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1564 = zext <2 x i1> %1563 to <2 x i32>
  %1565 = or <2 x i32> %1558, %1564
  %1566 = getelementptr inbounds i8, ptr %0, i64 3600
  %wide.load275 = load <2 x double>, ptr %1566, align 8, !tbaa !5
  %1567 = getelementptr inbounds i8, ptr %1, i64 3600
  %wide.load277 = load <2 x double>, ptr %1567, align 8, !tbaa !5
  %1568 = fsub <2 x double> %wide.load275, %wide.load277
  %1569 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1568)
  %1570 = fcmp ogt <2 x double> %1569, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1571 = getelementptr inbounds i8, ptr %0, i64 3632
  %wide.load275.1 = load <2 x double>, ptr %1571, align 8, !tbaa !5
  %1572 = getelementptr inbounds i8, ptr %1, i64 3632
  %wide.load277.1 = load <2 x double>, ptr %1572, align 8, !tbaa !5
  %1573 = fsub <2 x double> %wide.load275.1, %wide.load277.1
  %1574 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1573)
  %1575 = fcmp ogt <2 x double> %1574, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1576 = or <2 x i1> %1570, %1575
  %1577 = getelementptr inbounds i8, ptr %0, i64 3664
  %wide.load275.2 = load <2 x double>, ptr %1577, align 8, !tbaa !5
  %1578 = getelementptr inbounds i8, ptr %1, i64 3664
  %wide.load277.2 = load <2 x double>, ptr %1578, align 8, !tbaa !5
  %1579 = fsub <2 x double> %wide.load275.2, %wide.load277.2
  %1580 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1579)
  %1581 = fcmp ogt <2 x double> %1580, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1582 = or <2 x i1> %1576, %1581
  %1583 = getelementptr inbounds i8, ptr %0, i64 3696
  %wide.load275.3 = load <2 x double>, ptr %1583, align 8, !tbaa !5
  %1584 = getelementptr inbounds i8, ptr %1, i64 3696
  %wide.load277.3 = load <2 x double>, ptr %1584, align 8, !tbaa !5
  %1585 = fsub <2 x double> %wide.load275.3, %wide.load277.3
  %1586 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1585)
  %1587 = fcmp ogt <2 x double> %1586, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1588 = or <2 x i1> %1582, %1587
  %1589 = getelementptr inbounds i8, ptr %0, i64 3728
  %wide.load275.4 = load <2 x double>, ptr %1589, align 8, !tbaa !5
  %1590 = getelementptr inbounds i8, ptr %1, i64 3728
  %wide.load277.4 = load <2 x double>, ptr %1590, align 8, !tbaa !5
  %1591 = fsub <2 x double> %wide.load275.4, %wide.load277.4
  %1592 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1591)
  %1593 = fcmp ogt <2 x double> %1592, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1594 = or <2 x i1> %1588, %1593
  %1595 = getelementptr inbounds i8, ptr %0, i64 3760
  %wide.load275.5 = load <2 x double>, ptr %1595, align 8, !tbaa !5
  %1596 = getelementptr inbounds i8, ptr %1, i64 3760
  %wide.load277.5 = load <2 x double>, ptr %1596, align 8, !tbaa !5
  %1597 = fsub <2 x double> %wide.load275.5, %wide.load277.5
  %1598 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1597)
  %1599 = fcmp ogt <2 x double> %1598, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1600 = or <2 x i1> %1594, %1599
  %1601 = getelementptr inbounds i8, ptr %0, i64 3792
  %wide.load275.6 = load <2 x double>, ptr %1601, align 8, !tbaa !5
  %1602 = getelementptr inbounds i8, ptr %1, i64 3792
  %wide.load277.6 = load <2 x double>, ptr %1602, align 8, !tbaa !5
  %1603 = fsub <2 x double> %wide.load275.6, %wide.load277.6
  %1604 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1603)
  %1605 = fcmp ogt <2 x double> %1604, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1606 = or <2 x i1> %1600, %1605
  %1607 = getelementptr inbounds i8, ptr %0, i64 3824
  %wide.load275.7 = load <2 x double>, ptr %1607, align 8, !tbaa !5
  %1608 = getelementptr inbounds i8, ptr %1, i64 3824
  %wide.load277.7 = load <2 x double>, ptr %1608, align 8, !tbaa !5
  %1609 = fsub <2 x double> %wide.load275.7, %wide.load277.7
  %1610 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1609)
  %1611 = fcmp ogt <2 x double> %1610, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1612 = or <2 x i1> %1606, %1611
  %1613 = getelementptr inbounds i8, ptr %0, i64 3856
  %wide.load275.8 = load <2 x double>, ptr %1613, align 8, !tbaa !5
  %1614 = getelementptr inbounds i8, ptr %1, i64 3856
  %wide.load277.8 = load <2 x double>, ptr %1614, align 8, !tbaa !5
  %1615 = fsub <2 x double> %wide.load275.8, %wide.load277.8
  %1616 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1615)
  %1617 = fcmp ogt <2 x double> %1616, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1618 = or <2 x i1> %1612, %1617
  %1619 = getelementptr inbounds i8, ptr %0, i64 3888
  %wide.load275.9 = load <2 x double>, ptr %1619, align 8, !tbaa !5
  %1620 = getelementptr inbounds i8, ptr %1, i64 3888
  %wide.load277.9 = load <2 x double>, ptr %1620, align 8, !tbaa !5
  %1621 = fsub <2 x double> %wide.load275.9, %wide.load277.9
  %1622 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1621)
  %1623 = fcmp ogt <2 x double> %1622, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1624 = or <2 x i1> %1618, %1623
  %1625 = getelementptr inbounds i8, ptr %0, i64 3920
  %wide.load275.10 = load <2 x double>, ptr %1625, align 8, !tbaa !5
  %1626 = getelementptr inbounds i8, ptr %1, i64 3920
  %wide.load277.10 = load <2 x double>, ptr %1626, align 8, !tbaa !5
  %1627 = fsub <2 x double> %wide.load275.10, %wide.load277.10
  %1628 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1627)
  %1629 = fcmp ogt <2 x double> %1628, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1630 = or <2 x i1> %1624, %1629
  %1631 = getelementptr inbounds i8, ptr %0, i64 3952
  %wide.load275.11 = load <2 x double>, ptr %1631, align 8, !tbaa !5
  %1632 = getelementptr inbounds i8, ptr %1, i64 3952
  %wide.load277.11 = load <2 x double>, ptr %1632, align 8, !tbaa !5
  %1633 = fsub <2 x double> %wide.load275.11, %wide.load277.11
  %1634 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1633)
  %1635 = fcmp ogt <2 x double> %1634, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1636 = or <2 x i1> %1630, %1635
  %1637 = getelementptr inbounds i8, ptr %0, i64 3984
  %wide.load275.12 = load <2 x double>, ptr %1637, align 8, !tbaa !5
  %1638 = getelementptr inbounds i8, ptr %1, i64 3984
  %wide.load277.12 = load <2 x double>, ptr %1638, align 8, !tbaa !5
  %1639 = fsub <2 x double> %wide.load275.12, %wide.load277.12
  %1640 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1639)
  %1641 = fcmp ogt <2 x double> %1640, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1642 = or <2 x i1> %1636, %1641
  %1643 = getelementptr inbounds i8, ptr %0, i64 4016
  %wide.load275.13 = load <2 x double>, ptr %1643, align 8, !tbaa !5
  %1644 = getelementptr inbounds i8, ptr %1, i64 4016
  %wide.load277.13 = load <2 x double>, ptr %1644, align 8, !tbaa !5
  %1645 = fsub <2 x double> %wide.load275.13, %wide.load277.13
  %1646 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1645)
  %1647 = fcmp ogt <2 x double> %1646, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1648 = or <2 x i1> %1642, %1647
  %1649 = getelementptr inbounds i8, ptr %0, i64 4048
  %wide.load275.14 = load <2 x double>, ptr %1649, align 8, !tbaa !5
  %1650 = getelementptr inbounds i8, ptr %1, i64 4048
  %wide.load277.14 = load <2 x double>, ptr %1650, align 8, !tbaa !5
  %1651 = fsub <2 x double> %wide.load275.14, %wide.load277.14
  %1652 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1651)
  %1653 = fcmp ogt <2 x double> %1652, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1654 = or <2 x i1> %1648, %1653
  %1655 = getelementptr inbounds i8, ptr %0, i64 4080
  %wide.load275.15 = load <2 x double>, ptr %1655, align 8, !tbaa !5
  %1656 = getelementptr inbounds i8, ptr %1, i64 4080
  %wide.load277.15 = load <2 x double>, ptr %1656, align 8, !tbaa !5
  %1657 = fsub <2 x double> %wide.load275.15, %wide.load277.15
  %1658 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1657)
  %1659 = fcmp ogt <2 x double> %1658, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1660 = or <2 x i1> %1654, %1659
  %1661 = zext <2 x i1> %1660 to <2 x i32>
  %bin.rdx279 = or <2 x i32> %1565, %1661
  %1662 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx279)
  %1663 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1662, i64 0
  %1664 = getelementptr inbounds i8, ptr %0, i64 4096
  %wide.load289 = load <2 x double>, ptr %1664, align 8, !tbaa !5
  %1665 = getelementptr inbounds i8, ptr %1, i64 4096
  %wide.load291 = load <2 x double>, ptr %1665, align 8, !tbaa !5
  %1666 = fsub <2 x double> %wide.load289, %wide.load291
  %1667 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1666)
  %1668 = fcmp ogt <2 x double> %1667, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1669 = zext <2 x i1> %1668 to <2 x i32>
  %1670 = or <2 x i32> %1663, %1669
  %1671 = getelementptr inbounds i8, ptr %0, i64 4128
  %wide.load289.1 = load <2 x double>, ptr %1671, align 8, !tbaa !5
  %1672 = getelementptr inbounds i8, ptr %1, i64 4128
  %wide.load291.1 = load <2 x double>, ptr %1672, align 8, !tbaa !5
  %1673 = fsub <2 x double> %wide.load289.1, %wide.load291.1
  %1674 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1673)
  %1675 = fcmp ogt <2 x double> %1674, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1676 = zext <2 x i1> %1675 to <2 x i32>
  %1677 = or <2 x i32> %1670, %1676
  %1678 = getelementptr inbounds i8, ptr %0, i64 4160
  %wide.load289.2 = load <2 x double>, ptr %1678, align 8, !tbaa !5
  %1679 = getelementptr inbounds i8, ptr %1, i64 4160
  %wide.load291.2 = load <2 x double>, ptr %1679, align 8, !tbaa !5
  %1680 = fsub <2 x double> %wide.load289.2, %wide.load291.2
  %1681 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1680)
  %1682 = fcmp ogt <2 x double> %1681, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1683 = zext <2 x i1> %1682 to <2 x i32>
  %1684 = or <2 x i32> %1677, %1683
  %1685 = getelementptr inbounds i8, ptr %0, i64 4192
  %wide.load289.3 = load <2 x double>, ptr %1685, align 8, !tbaa !5
  %1686 = getelementptr inbounds i8, ptr %1, i64 4192
  %wide.load291.3 = load <2 x double>, ptr %1686, align 8, !tbaa !5
  %1687 = fsub <2 x double> %wide.load289.3, %wide.load291.3
  %1688 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1687)
  %1689 = fcmp ogt <2 x double> %1688, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1690 = zext <2 x i1> %1689 to <2 x i32>
  %1691 = or <2 x i32> %1684, %1690
  %1692 = getelementptr inbounds i8, ptr %0, i64 4224
  %wide.load289.4 = load <2 x double>, ptr %1692, align 8, !tbaa !5
  %1693 = getelementptr inbounds i8, ptr %1, i64 4224
  %wide.load291.4 = load <2 x double>, ptr %1693, align 8, !tbaa !5
  %1694 = fsub <2 x double> %wide.load289.4, %wide.load291.4
  %1695 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1694)
  %1696 = fcmp ogt <2 x double> %1695, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1697 = zext <2 x i1> %1696 to <2 x i32>
  %1698 = or <2 x i32> %1691, %1697
  %1699 = getelementptr inbounds i8, ptr %0, i64 4256
  %wide.load289.5 = load <2 x double>, ptr %1699, align 8, !tbaa !5
  %1700 = getelementptr inbounds i8, ptr %1, i64 4256
  %wide.load291.5 = load <2 x double>, ptr %1700, align 8, !tbaa !5
  %1701 = fsub <2 x double> %wide.load289.5, %wide.load291.5
  %1702 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1701)
  %1703 = fcmp ogt <2 x double> %1702, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1704 = zext <2 x i1> %1703 to <2 x i32>
  %1705 = or <2 x i32> %1698, %1704
  %1706 = getelementptr inbounds i8, ptr %0, i64 4288
  %wide.load289.6 = load <2 x double>, ptr %1706, align 8, !tbaa !5
  %1707 = getelementptr inbounds i8, ptr %1, i64 4288
  %wide.load291.6 = load <2 x double>, ptr %1707, align 8, !tbaa !5
  %1708 = fsub <2 x double> %wide.load289.6, %wide.load291.6
  %1709 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1708)
  %1710 = fcmp ogt <2 x double> %1709, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1711 = zext <2 x i1> %1710 to <2 x i32>
  %1712 = or <2 x i32> %1705, %1711
  %1713 = getelementptr inbounds i8, ptr %0, i64 4320
  %wide.load289.7 = load <2 x double>, ptr %1713, align 8, !tbaa !5
  %1714 = getelementptr inbounds i8, ptr %1, i64 4320
  %wide.load291.7 = load <2 x double>, ptr %1714, align 8, !tbaa !5
  %1715 = fsub <2 x double> %wide.load289.7, %wide.load291.7
  %1716 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1715)
  %1717 = fcmp ogt <2 x double> %1716, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1718 = zext <2 x i1> %1717 to <2 x i32>
  %1719 = or <2 x i32> %1712, %1718
  %1720 = getelementptr inbounds i8, ptr %0, i64 4352
  %wide.load289.8 = load <2 x double>, ptr %1720, align 8, !tbaa !5
  %1721 = getelementptr inbounds i8, ptr %1, i64 4352
  %wide.load291.8 = load <2 x double>, ptr %1721, align 8, !tbaa !5
  %1722 = fsub <2 x double> %wide.load289.8, %wide.load291.8
  %1723 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1722)
  %1724 = fcmp ogt <2 x double> %1723, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1725 = zext <2 x i1> %1724 to <2 x i32>
  %1726 = or <2 x i32> %1719, %1725
  %1727 = getelementptr inbounds i8, ptr %0, i64 4384
  %wide.load289.9 = load <2 x double>, ptr %1727, align 8, !tbaa !5
  %1728 = getelementptr inbounds i8, ptr %1, i64 4384
  %wide.load291.9 = load <2 x double>, ptr %1728, align 8, !tbaa !5
  %1729 = fsub <2 x double> %wide.load289.9, %wide.load291.9
  %1730 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1729)
  %1731 = fcmp ogt <2 x double> %1730, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1732 = zext <2 x i1> %1731 to <2 x i32>
  %1733 = or <2 x i32> %1726, %1732
  %1734 = getelementptr inbounds i8, ptr %0, i64 4416
  %wide.load289.10 = load <2 x double>, ptr %1734, align 8, !tbaa !5
  %1735 = getelementptr inbounds i8, ptr %1, i64 4416
  %wide.load291.10 = load <2 x double>, ptr %1735, align 8, !tbaa !5
  %1736 = fsub <2 x double> %wide.load289.10, %wide.load291.10
  %1737 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1736)
  %1738 = fcmp ogt <2 x double> %1737, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1739 = zext <2 x i1> %1738 to <2 x i32>
  %1740 = or <2 x i32> %1733, %1739
  %1741 = getelementptr inbounds i8, ptr %0, i64 4448
  %wide.load289.11 = load <2 x double>, ptr %1741, align 8, !tbaa !5
  %1742 = getelementptr inbounds i8, ptr %1, i64 4448
  %wide.load291.11 = load <2 x double>, ptr %1742, align 8, !tbaa !5
  %1743 = fsub <2 x double> %wide.load289.11, %wide.load291.11
  %1744 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1743)
  %1745 = fcmp ogt <2 x double> %1744, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1746 = zext <2 x i1> %1745 to <2 x i32>
  %1747 = or <2 x i32> %1740, %1746
  %1748 = getelementptr inbounds i8, ptr %0, i64 4480
  %wide.load289.12 = load <2 x double>, ptr %1748, align 8, !tbaa !5
  %1749 = getelementptr inbounds i8, ptr %1, i64 4480
  %wide.load291.12 = load <2 x double>, ptr %1749, align 8, !tbaa !5
  %1750 = fsub <2 x double> %wide.load289.12, %wide.load291.12
  %1751 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1750)
  %1752 = fcmp ogt <2 x double> %1751, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1753 = zext <2 x i1> %1752 to <2 x i32>
  %1754 = or <2 x i32> %1747, %1753
  %1755 = getelementptr inbounds i8, ptr %0, i64 4512
  %wide.load289.13 = load <2 x double>, ptr %1755, align 8, !tbaa !5
  %1756 = getelementptr inbounds i8, ptr %1, i64 4512
  %wide.load291.13 = load <2 x double>, ptr %1756, align 8, !tbaa !5
  %1757 = fsub <2 x double> %wide.load289.13, %wide.load291.13
  %1758 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1757)
  %1759 = fcmp ogt <2 x double> %1758, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1760 = zext <2 x i1> %1759 to <2 x i32>
  %1761 = or <2 x i32> %1754, %1760
  %1762 = getelementptr inbounds i8, ptr %0, i64 4544
  %wide.load289.14 = load <2 x double>, ptr %1762, align 8, !tbaa !5
  %1763 = getelementptr inbounds i8, ptr %1, i64 4544
  %wide.load291.14 = load <2 x double>, ptr %1763, align 8, !tbaa !5
  %1764 = fsub <2 x double> %wide.load289.14, %wide.load291.14
  %1765 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1764)
  %1766 = fcmp ogt <2 x double> %1765, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1767 = zext <2 x i1> %1766 to <2 x i32>
  %1768 = or <2 x i32> %1761, %1767
  %1769 = getelementptr inbounds i8, ptr %0, i64 4576
  %wide.load289.15 = load <2 x double>, ptr %1769, align 8, !tbaa !5
  %1770 = getelementptr inbounds i8, ptr %1, i64 4576
  %wide.load291.15 = load <2 x double>, ptr %1770, align 8, !tbaa !5
  %1771 = fsub <2 x double> %wide.load289.15, %wide.load291.15
  %1772 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1771)
  %1773 = fcmp ogt <2 x double> %1772, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1774 = zext <2 x i1> %1773 to <2 x i32>
  %1775 = or <2 x i32> %1768, %1774
  %1776 = getelementptr inbounds i8, ptr %0, i64 4112
  %wide.load290 = load <2 x double>, ptr %1776, align 8, !tbaa !5
  %1777 = getelementptr inbounds i8, ptr %1, i64 4112
  %wide.load292 = load <2 x double>, ptr %1777, align 8, !tbaa !5
  %1778 = fsub <2 x double> %wide.load290, %wide.load292
  %1779 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1778)
  %1780 = fcmp ogt <2 x double> %1779, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1781 = getelementptr inbounds i8, ptr %0, i64 4144
  %wide.load290.1 = load <2 x double>, ptr %1781, align 8, !tbaa !5
  %1782 = getelementptr inbounds i8, ptr %1, i64 4144
  %wide.load292.1 = load <2 x double>, ptr %1782, align 8, !tbaa !5
  %1783 = fsub <2 x double> %wide.load290.1, %wide.load292.1
  %1784 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1783)
  %1785 = fcmp ogt <2 x double> %1784, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1786 = or <2 x i1> %1780, %1785
  %1787 = getelementptr inbounds i8, ptr %0, i64 4176
  %wide.load290.2 = load <2 x double>, ptr %1787, align 8, !tbaa !5
  %1788 = getelementptr inbounds i8, ptr %1, i64 4176
  %wide.load292.2 = load <2 x double>, ptr %1788, align 8, !tbaa !5
  %1789 = fsub <2 x double> %wide.load290.2, %wide.load292.2
  %1790 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1789)
  %1791 = fcmp ogt <2 x double> %1790, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1792 = or <2 x i1> %1786, %1791
  %1793 = getelementptr inbounds i8, ptr %0, i64 4208
  %wide.load290.3 = load <2 x double>, ptr %1793, align 8, !tbaa !5
  %1794 = getelementptr inbounds i8, ptr %1, i64 4208
  %wide.load292.3 = load <2 x double>, ptr %1794, align 8, !tbaa !5
  %1795 = fsub <2 x double> %wide.load290.3, %wide.load292.3
  %1796 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1795)
  %1797 = fcmp ogt <2 x double> %1796, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1798 = or <2 x i1> %1792, %1797
  %1799 = getelementptr inbounds i8, ptr %0, i64 4240
  %wide.load290.4 = load <2 x double>, ptr %1799, align 8, !tbaa !5
  %1800 = getelementptr inbounds i8, ptr %1, i64 4240
  %wide.load292.4 = load <2 x double>, ptr %1800, align 8, !tbaa !5
  %1801 = fsub <2 x double> %wide.load290.4, %wide.load292.4
  %1802 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1801)
  %1803 = fcmp ogt <2 x double> %1802, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1804 = or <2 x i1> %1798, %1803
  %1805 = getelementptr inbounds i8, ptr %0, i64 4272
  %wide.load290.5 = load <2 x double>, ptr %1805, align 8, !tbaa !5
  %1806 = getelementptr inbounds i8, ptr %1, i64 4272
  %wide.load292.5 = load <2 x double>, ptr %1806, align 8, !tbaa !5
  %1807 = fsub <2 x double> %wide.load290.5, %wide.load292.5
  %1808 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1807)
  %1809 = fcmp ogt <2 x double> %1808, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1810 = or <2 x i1> %1804, %1809
  %1811 = getelementptr inbounds i8, ptr %0, i64 4304
  %wide.load290.6 = load <2 x double>, ptr %1811, align 8, !tbaa !5
  %1812 = getelementptr inbounds i8, ptr %1, i64 4304
  %wide.load292.6 = load <2 x double>, ptr %1812, align 8, !tbaa !5
  %1813 = fsub <2 x double> %wide.load290.6, %wide.load292.6
  %1814 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1813)
  %1815 = fcmp ogt <2 x double> %1814, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1816 = or <2 x i1> %1810, %1815
  %1817 = getelementptr inbounds i8, ptr %0, i64 4336
  %wide.load290.7 = load <2 x double>, ptr %1817, align 8, !tbaa !5
  %1818 = getelementptr inbounds i8, ptr %1, i64 4336
  %wide.load292.7 = load <2 x double>, ptr %1818, align 8, !tbaa !5
  %1819 = fsub <2 x double> %wide.load290.7, %wide.load292.7
  %1820 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1819)
  %1821 = fcmp ogt <2 x double> %1820, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1822 = or <2 x i1> %1816, %1821
  %1823 = getelementptr inbounds i8, ptr %0, i64 4368
  %wide.load290.8 = load <2 x double>, ptr %1823, align 8, !tbaa !5
  %1824 = getelementptr inbounds i8, ptr %1, i64 4368
  %wide.load292.8 = load <2 x double>, ptr %1824, align 8, !tbaa !5
  %1825 = fsub <2 x double> %wide.load290.8, %wide.load292.8
  %1826 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1825)
  %1827 = fcmp ogt <2 x double> %1826, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1828 = or <2 x i1> %1822, %1827
  %1829 = getelementptr inbounds i8, ptr %0, i64 4400
  %wide.load290.9 = load <2 x double>, ptr %1829, align 8, !tbaa !5
  %1830 = getelementptr inbounds i8, ptr %1, i64 4400
  %wide.load292.9 = load <2 x double>, ptr %1830, align 8, !tbaa !5
  %1831 = fsub <2 x double> %wide.load290.9, %wide.load292.9
  %1832 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1831)
  %1833 = fcmp ogt <2 x double> %1832, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1834 = or <2 x i1> %1828, %1833
  %1835 = getelementptr inbounds i8, ptr %0, i64 4432
  %wide.load290.10 = load <2 x double>, ptr %1835, align 8, !tbaa !5
  %1836 = getelementptr inbounds i8, ptr %1, i64 4432
  %wide.load292.10 = load <2 x double>, ptr %1836, align 8, !tbaa !5
  %1837 = fsub <2 x double> %wide.load290.10, %wide.load292.10
  %1838 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1837)
  %1839 = fcmp ogt <2 x double> %1838, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1840 = or <2 x i1> %1834, %1839
  %1841 = getelementptr inbounds i8, ptr %0, i64 4464
  %wide.load290.11 = load <2 x double>, ptr %1841, align 8, !tbaa !5
  %1842 = getelementptr inbounds i8, ptr %1, i64 4464
  %wide.load292.11 = load <2 x double>, ptr %1842, align 8, !tbaa !5
  %1843 = fsub <2 x double> %wide.load290.11, %wide.load292.11
  %1844 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1843)
  %1845 = fcmp ogt <2 x double> %1844, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1846 = or <2 x i1> %1840, %1845
  %1847 = getelementptr inbounds i8, ptr %0, i64 4496
  %wide.load290.12 = load <2 x double>, ptr %1847, align 8, !tbaa !5
  %1848 = getelementptr inbounds i8, ptr %1, i64 4496
  %wide.load292.12 = load <2 x double>, ptr %1848, align 8, !tbaa !5
  %1849 = fsub <2 x double> %wide.load290.12, %wide.load292.12
  %1850 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1849)
  %1851 = fcmp ogt <2 x double> %1850, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1852 = or <2 x i1> %1846, %1851
  %1853 = getelementptr inbounds i8, ptr %0, i64 4528
  %wide.load290.13 = load <2 x double>, ptr %1853, align 8, !tbaa !5
  %1854 = getelementptr inbounds i8, ptr %1, i64 4528
  %wide.load292.13 = load <2 x double>, ptr %1854, align 8, !tbaa !5
  %1855 = fsub <2 x double> %wide.load290.13, %wide.load292.13
  %1856 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1855)
  %1857 = fcmp ogt <2 x double> %1856, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1858 = or <2 x i1> %1852, %1857
  %1859 = getelementptr inbounds i8, ptr %0, i64 4560
  %wide.load290.14 = load <2 x double>, ptr %1859, align 8, !tbaa !5
  %1860 = getelementptr inbounds i8, ptr %1, i64 4560
  %wide.load292.14 = load <2 x double>, ptr %1860, align 8, !tbaa !5
  %1861 = fsub <2 x double> %wide.load290.14, %wide.load292.14
  %1862 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1861)
  %1863 = fcmp ogt <2 x double> %1862, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1864 = or <2 x i1> %1858, %1863
  %1865 = getelementptr inbounds i8, ptr %0, i64 4592
  %wide.load290.15 = load <2 x double>, ptr %1865, align 8, !tbaa !5
  %1866 = getelementptr inbounds i8, ptr %1, i64 4592
  %wide.load292.15 = load <2 x double>, ptr %1866, align 8, !tbaa !5
  %1867 = fsub <2 x double> %wide.load290.15, %wide.load292.15
  %1868 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1867)
  %1869 = fcmp ogt <2 x double> %1868, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1870 = or <2 x i1> %1864, %1869
  %1871 = zext <2 x i1> %1870 to <2 x i32>
  %bin.rdx294 = or <2 x i32> %1775, %1871
  %1872 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx294)
  %1873 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %1872, i64 0
  %1874 = getelementptr inbounds i8, ptr %0, i64 4608
  %wide.load304 = load <2 x double>, ptr %1874, align 8, !tbaa !5
  %1875 = getelementptr inbounds i8, ptr %1, i64 4608
  %wide.load306 = load <2 x double>, ptr %1875, align 8, !tbaa !5
  %1876 = fsub <2 x double> %wide.load304, %wide.load306
  %1877 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1876)
  %1878 = fcmp ogt <2 x double> %1877, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1879 = zext <2 x i1> %1878 to <2 x i32>
  %1880 = or <2 x i32> %1873, %1879
  %1881 = getelementptr inbounds i8, ptr %0, i64 4640
  %wide.load304.1 = load <2 x double>, ptr %1881, align 8, !tbaa !5
  %1882 = getelementptr inbounds i8, ptr %1, i64 4640
  %wide.load306.1 = load <2 x double>, ptr %1882, align 8, !tbaa !5
  %1883 = fsub <2 x double> %wide.load304.1, %wide.load306.1
  %1884 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1883)
  %1885 = fcmp ogt <2 x double> %1884, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1886 = zext <2 x i1> %1885 to <2 x i32>
  %1887 = or <2 x i32> %1880, %1886
  %1888 = getelementptr inbounds i8, ptr %0, i64 4672
  %wide.load304.2 = load <2 x double>, ptr %1888, align 8, !tbaa !5
  %1889 = getelementptr inbounds i8, ptr %1, i64 4672
  %wide.load306.2 = load <2 x double>, ptr %1889, align 8, !tbaa !5
  %1890 = fsub <2 x double> %wide.load304.2, %wide.load306.2
  %1891 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1890)
  %1892 = fcmp ogt <2 x double> %1891, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1893 = zext <2 x i1> %1892 to <2 x i32>
  %1894 = or <2 x i32> %1887, %1893
  %1895 = getelementptr inbounds i8, ptr %0, i64 4704
  %wide.load304.3 = load <2 x double>, ptr %1895, align 8, !tbaa !5
  %1896 = getelementptr inbounds i8, ptr %1, i64 4704
  %wide.load306.3 = load <2 x double>, ptr %1896, align 8, !tbaa !5
  %1897 = fsub <2 x double> %wide.load304.3, %wide.load306.3
  %1898 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1897)
  %1899 = fcmp ogt <2 x double> %1898, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1900 = zext <2 x i1> %1899 to <2 x i32>
  %1901 = or <2 x i32> %1894, %1900
  %1902 = getelementptr inbounds i8, ptr %0, i64 4736
  %wide.load304.4 = load <2 x double>, ptr %1902, align 8, !tbaa !5
  %1903 = getelementptr inbounds i8, ptr %1, i64 4736
  %wide.load306.4 = load <2 x double>, ptr %1903, align 8, !tbaa !5
  %1904 = fsub <2 x double> %wide.load304.4, %wide.load306.4
  %1905 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1904)
  %1906 = fcmp ogt <2 x double> %1905, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1907 = zext <2 x i1> %1906 to <2 x i32>
  %1908 = or <2 x i32> %1901, %1907
  %1909 = getelementptr inbounds i8, ptr %0, i64 4768
  %wide.load304.5 = load <2 x double>, ptr %1909, align 8, !tbaa !5
  %1910 = getelementptr inbounds i8, ptr %1, i64 4768
  %wide.load306.5 = load <2 x double>, ptr %1910, align 8, !tbaa !5
  %1911 = fsub <2 x double> %wide.load304.5, %wide.load306.5
  %1912 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1911)
  %1913 = fcmp ogt <2 x double> %1912, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1914 = zext <2 x i1> %1913 to <2 x i32>
  %1915 = or <2 x i32> %1908, %1914
  %1916 = getelementptr inbounds i8, ptr %0, i64 4800
  %wide.load304.6 = load <2 x double>, ptr %1916, align 8, !tbaa !5
  %1917 = getelementptr inbounds i8, ptr %1, i64 4800
  %wide.load306.6 = load <2 x double>, ptr %1917, align 8, !tbaa !5
  %1918 = fsub <2 x double> %wide.load304.6, %wide.load306.6
  %1919 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1918)
  %1920 = fcmp ogt <2 x double> %1919, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1921 = zext <2 x i1> %1920 to <2 x i32>
  %1922 = or <2 x i32> %1915, %1921
  %1923 = getelementptr inbounds i8, ptr %0, i64 4832
  %wide.load304.7 = load <2 x double>, ptr %1923, align 8, !tbaa !5
  %1924 = getelementptr inbounds i8, ptr %1, i64 4832
  %wide.load306.7 = load <2 x double>, ptr %1924, align 8, !tbaa !5
  %1925 = fsub <2 x double> %wide.load304.7, %wide.load306.7
  %1926 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1925)
  %1927 = fcmp ogt <2 x double> %1926, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1928 = zext <2 x i1> %1927 to <2 x i32>
  %1929 = or <2 x i32> %1922, %1928
  %1930 = getelementptr inbounds i8, ptr %0, i64 4864
  %wide.load304.8 = load <2 x double>, ptr %1930, align 8, !tbaa !5
  %1931 = getelementptr inbounds i8, ptr %1, i64 4864
  %wide.load306.8 = load <2 x double>, ptr %1931, align 8, !tbaa !5
  %1932 = fsub <2 x double> %wide.load304.8, %wide.load306.8
  %1933 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1932)
  %1934 = fcmp ogt <2 x double> %1933, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1935 = zext <2 x i1> %1934 to <2 x i32>
  %1936 = or <2 x i32> %1929, %1935
  %1937 = getelementptr inbounds i8, ptr %0, i64 4896
  %wide.load304.9 = load <2 x double>, ptr %1937, align 8, !tbaa !5
  %1938 = getelementptr inbounds i8, ptr %1, i64 4896
  %wide.load306.9 = load <2 x double>, ptr %1938, align 8, !tbaa !5
  %1939 = fsub <2 x double> %wide.load304.9, %wide.load306.9
  %1940 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1939)
  %1941 = fcmp ogt <2 x double> %1940, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1942 = zext <2 x i1> %1941 to <2 x i32>
  %1943 = or <2 x i32> %1936, %1942
  %1944 = getelementptr inbounds i8, ptr %0, i64 4928
  %wide.load304.10 = load <2 x double>, ptr %1944, align 8, !tbaa !5
  %1945 = getelementptr inbounds i8, ptr %1, i64 4928
  %wide.load306.10 = load <2 x double>, ptr %1945, align 8, !tbaa !5
  %1946 = fsub <2 x double> %wide.load304.10, %wide.load306.10
  %1947 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1946)
  %1948 = fcmp ogt <2 x double> %1947, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1949 = zext <2 x i1> %1948 to <2 x i32>
  %1950 = or <2 x i32> %1943, %1949
  %1951 = getelementptr inbounds i8, ptr %0, i64 4960
  %wide.load304.11 = load <2 x double>, ptr %1951, align 8, !tbaa !5
  %1952 = getelementptr inbounds i8, ptr %1, i64 4960
  %wide.load306.11 = load <2 x double>, ptr %1952, align 8, !tbaa !5
  %1953 = fsub <2 x double> %wide.load304.11, %wide.load306.11
  %1954 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1953)
  %1955 = fcmp ogt <2 x double> %1954, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1956 = zext <2 x i1> %1955 to <2 x i32>
  %1957 = or <2 x i32> %1950, %1956
  %1958 = getelementptr inbounds i8, ptr %0, i64 4992
  %wide.load304.12 = load <2 x double>, ptr %1958, align 8, !tbaa !5
  %1959 = getelementptr inbounds i8, ptr %1, i64 4992
  %wide.load306.12 = load <2 x double>, ptr %1959, align 8, !tbaa !5
  %1960 = fsub <2 x double> %wide.load304.12, %wide.load306.12
  %1961 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1960)
  %1962 = fcmp ogt <2 x double> %1961, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1963 = zext <2 x i1> %1962 to <2 x i32>
  %1964 = or <2 x i32> %1957, %1963
  %1965 = getelementptr inbounds i8, ptr %0, i64 5024
  %wide.load304.13 = load <2 x double>, ptr %1965, align 8, !tbaa !5
  %1966 = getelementptr inbounds i8, ptr %1, i64 5024
  %wide.load306.13 = load <2 x double>, ptr %1966, align 8, !tbaa !5
  %1967 = fsub <2 x double> %wide.load304.13, %wide.load306.13
  %1968 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1967)
  %1969 = fcmp ogt <2 x double> %1968, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1970 = zext <2 x i1> %1969 to <2 x i32>
  %1971 = or <2 x i32> %1964, %1970
  %1972 = getelementptr inbounds i8, ptr %0, i64 5056
  %wide.load304.14 = load <2 x double>, ptr %1972, align 8, !tbaa !5
  %1973 = getelementptr inbounds i8, ptr %1, i64 5056
  %wide.load306.14 = load <2 x double>, ptr %1973, align 8, !tbaa !5
  %1974 = fsub <2 x double> %wide.load304.14, %wide.load306.14
  %1975 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1974)
  %1976 = fcmp ogt <2 x double> %1975, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1977 = zext <2 x i1> %1976 to <2 x i32>
  %1978 = or <2 x i32> %1971, %1977
  %1979 = getelementptr inbounds i8, ptr %0, i64 5088
  %wide.load304.15 = load <2 x double>, ptr %1979, align 8, !tbaa !5
  %1980 = getelementptr inbounds i8, ptr %1, i64 5088
  %wide.load306.15 = load <2 x double>, ptr %1980, align 8, !tbaa !5
  %1981 = fsub <2 x double> %wide.load304.15, %wide.load306.15
  %1982 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1981)
  %1983 = fcmp ogt <2 x double> %1982, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1984 = zext <2 x i1> %1983 to <2 x i32>
  %1985 = or <2 x i32> %1978, %1984
  %1986 = getelementptr inbounds i8, ptr %0, i64 4624
  %wide.load305 = load <2 x double>, ptr %1986, align 8, !tbaa !5
  %1987 = getelementptr inbounds i8, ptr %1, i64 4624
  %wide.load307 = load <2 x double>, ptr %1987, align 8, !tbaa !5
  %1988 = fsub <2 x double> %wide.load305, %wide.load307
  %1989 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1988)
  %1990 = fcmp ogt <2 x double> %1989, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1991 = getelementptr inbounds i8, ptr %0, i64 4656
  %wide.load305.1 = load <2 x double>, ptr %1991, align 8, !tbaa !5
  %1992 = getelementptr inbounds i8, ptr %1, i64 4656
  %wide.load307.1 = load <2 x double>, ptr %1992, align 8, !tbaa !5
  %1993 = fsub <2 x double> %wide.load305.1, %wide.load307.1
  %1994 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1993)
  %1995 = fcmp ogt <2 x double> %1994, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %1996 = or <2 x i1> %1990, %1995
  %1997 = getelementptr inbounds i8, ptr %0, i64 4688
  %wide.load305.2 = load <2 x double>, ptr %1997, align 8, !tbaa !5
  %1998 = getelementptr inbounds i8, ptr %1, i64 4688
  %wide.load307.2 = load <2 x double>, ptr %1998, align 8, !tbaa !5
  %1999 = fsub <2 x double> %wide.load305.2, %wide.load307.2
  %2000 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %1999)
  %2001 = fcmp ogt <2 x double> %2000, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2002 = or <2 x i1> %1996, %2001
  %2003 = getelementptr inbounds i8, ptr %0, i64 4720
  %wide.load305.3 = load <2 x double>, ptr %2003, align 8, !tbaa !5
  %2004 = getelementptr inbounds i8, ptr %1, i64 4720
  %wide.load307.3 = load <2 x double>, ptr %2004, align 8, !tbaa !5
  %2005 = fsub <2 x double> %wide.load305.3, %wide.load307.3
  %2006 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2005)
  %2007 = fcmp ogt <2 x double> %2006, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2008 = or <2 x i1> %2002, %2007
  %2009 = getelementptr inbounds i8, ptr %0, i64 4752
  %wide.load305.4 = load <2 x double>, ptr %2009, align 8, !tbaa !5
  %2010 = getelementptr inbounds i8, ptr %1, i64 4752
  %wide.load307.4 = load <2 x double>, ptr %2010, align 8, !tbaa !5
  %2011 = fsub <2 x double> %wide.load305.4, %wide.load307.4
  %2012 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2011)
  %2013 = fcmp ogt <2 x double> %2012, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2014 = or <2 x i1> %2008, %2013
  %2015 = getelementptr inbounds i8, ptr %0, i64 4784
  %wide.load305.5 = load <2 x double>, ptr %2015, align 8, !tbaa !5
  %2016 = getelementptr inbounds i8, ptr %1, i64 4784
  %wide.load307.5 = load <2 x double>, ptr %2016, align 8, !tbaa !5
  %2017 = fsub <2 x double> %wide.load305.5, %wide.load307.5
  %2018 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2017)
  %2019 = fcmp ogt <2 x double> %2018, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2020 = or <2 x i1> %2014, %2019
  %2021 = getelementptr inbounds i8, ptr %0, i64 4816
  %wide.load305.6 = load <2 x double>, ptr %2021, align 8, !tbaa !5
  %2022 = getelementptr inbounds i8, ptr %1, i64 4816
  %wide.load307.6 = load <2 x double>, ptr %2022, align 8, !tbaa !5
  %2023 = fsub <2 x double> %wide.load305.6, %wide.load307.6
  %2024 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2023)
  %2025 = fcmp ogt <2 x double> %2024, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2026 = or <2 x i1> %2020, %2025
  %2027 = getelementptr inbounds i8, ptr %0, i64 4848
  %wide.load305.7 = load <2 x double>, ptr %2027, align 8, !tbaa !5
  %2028 = getelementptr inbounds i8, ptr %1, i64 4848
  %wide.load307.7 = load <2 x double>, ptr %2028, align 8, !tbaa !5
  %2029 = fsub <2 x double> %wide.load305.7, %wide.load307.7
  %2030 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2029)
  %2031 = fcmp ogt <2 x double> %2030, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2032 = or <2 x i1> %2026, %2031
  %2033 = getelementptr inbounds i8, ptr %0, i64 4880
  %wide.load305.8 = load <2 x double>, ptr %2033, align 8, !tbaa !5
  %2034 = getelementptr inbounds i8, ptr %1, i64 4880
  %wide.load307.8 = load <2 x double>, ptr %2034, align 8, !tbaa !5
  %2035 = fsub <2 x double> %wide.load305.8, %wide.load307.8
  %2036 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2035)
  %2037 = fcmp ogt <2 x double> %2036, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2038 = or <2 x i1> %2032, %2037
  %2039 = getelementptr inbounds i8, ptr %0, i64 4912
  %wide.load305.9 = load <2 x double>, ptr %2039, align 8, !tbaa !5
  %2040 = getelementptr inbounds i8, ptr %1, i64 4912
  %wide.load307.9 = load <2 x double>, ptr %2040, align 8, !tbaa !5
  %2041 = fsub <2 x double> %wide.load305.9, %wide.load307.9
  %2042 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2041)
  %2043 = fcmp ogt <2 x double> %2042, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2044 = or <2 x i1> %2038, %2043
  %2045 = getelementptr inbounds i8, ptr %0, i64 4944
  %wide.load305.10 = load <2 x double>, ptr %2045, align 8, !tbaa !5
  %2046 = getelementptr inbounds i8, ptr %1, i64 4944
  %wide.load307.10 = load <2 x double>, ptr %2046, align 8, !tbaa !5
  %2047 = fsub <2 x double> %wide.load305.10, %wide.load307.10
  %2048 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2047)
  %2049 = fcmp ogt <2 x double> %2048, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2050 = or <2 x i1> %2044, %2049
  %2051 = getelementptr inbounds i8, ptr %0, i64 4976
  %wide.load305.11 = load <2 x double>, ptr %2051, align 8, !tbaa !5
  %2052 = getelementptr inbounds i8, ptr %1, i64 4976
  %wide.load307.11 = load <2 x double>, ptr %2052, align 8, !tbaa !5
  %2053 = fsub <2 x double> %wide.load305.11, %wide.load307.11
  %2054 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2053)
  %2055 = fcmp ogt <2 x double> %2054, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2056 = or <2 x i1> %2050, %2055
  %2057 = getelementptr inbounds i8, ptr %0, i64 5008
  %wide.load305.12 = load <2 x double>, ptr %2057, align 8, !tbaa !5
  %2058 = getelementptr inbounds i8, ptr %1, i64 5008
  %wide.load307.12 = load <2 x double>, ptr %2058, align 8, !tbaa !5
  %2059 = fsub <2 x double> %wide.load305.12, %wide.load307.12
  %2060 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2059)
  %2061 = fcmp ogt <2 x double> %2060, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2062 = or <2 x i1> %2056, %2061
  %2063 = getelementptr inbounds i8, ptr %0, i64 5040
  %wide.load305.13 = load <2 x double>, ptr %2063, align 8, !tbaa !5
  %2064 = getelementptr inbounds i8, ptr %1, i64 5040
  %wide.load307.13 = load <2 x double>, ptr %2064, align 8, !tbaa !5
  %2065 = fsub <2 x double> %wide.load305.13, %wide.load307.13
  %2066 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2065)
  %2067 = fcmp ogt <2 x double> %2066, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2068 = or <2 x i1> %2062, %2067
  %2069 = getelementptr inbounds i8, ptr %0, i64 5072
  %wide.load305.14 = load <2 x double>, ptr %2069, align 8, !tbaa !5
  %2070 = getelementptr inbounds i8, ptr %1, i64 5072
  %wide.load307.14 = load <2 x double>, ptr %2070, align 8, !tbaa !5
  %2071 = fsub <2 x double> %wide.load305.14, %wide.load307.14
  %2072 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2071)
  %2073 = fcmp ogt <2 x double> %2072, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2074 = or <2 x i1> %2068, %2073
  %2075 = getelementptr inbounds i8, ptr %0, i64 5104
  %wide.load305.15 = load <2 x double>, ptr %2075, align 8, !tbaa !5
  %2076 = getelementptr inbounds i8, ptr %1, i64 5104
  %wide.load307.15 = load <2 x double>, ptr %2076, align 8, !tbaa !5
  %2077 = fsub <2 x double> %wide.load305.15, %wide.load307.15
  %2078 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2077)
  %2079 = fcmp ogt <2 x double> %2078, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2080 = or <2 x i1> %2074, %2079
  %2081 = zext <2 x i1> %2080 to <2 x i32>
  %bin.rdx309 = or <2 x i32> %1985, %2081
  %2082 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx309)
  %2083 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %2082, i64 0
  %2084 = getelementptr inbounds i8, ptr %0, i64 5120
  %wide.load319 = load <2 x double>, ptr %2084, align 8, !tbaa !5
  %2085 = getelementptr inbounds i8, ptr %1, i64 5120
  %wide.load321 = load <2 x double>, ptr %2085, align 8, !tbaa !5
  %2086 = fsub <2 x double> %wide.load319, %wide.load321
  %2087 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2086)
  %2088 = fcmp ogt <2 x double> %2087, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2089 = zext <2 x i1> %2088 to <2 x i32>
  %2090 = or <2 x i32> %2083, %2089
  %2091 = getelementptr inbounds i8, ptr %0, i64 5152
  %wide.load319.1 = load <2 x double>, ptr %2091, align 8, !tbaa !5
  %2092 = getelementptr inbounds i8, ptr %1, i64 5152
  %wide.load321.1 = load <2 x double>, ptr %2092, align 8, !tbaa !5
  %2093 = fsub <2 x double> %wide.load319.1, %wide.load321.1
  %2094 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2093)
  %2095 = fcmp ogt <2 x double> %2094, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2096 = zext <2 x i1> %2095 to <2 x i32>
  %2097 = or <2 x i32> %2090, %2096
  %2098 = getelementptr inbounds i8, ptr %0, i64 5184
  %wide.load319.2 = load <2 x double>, ptr %2098, align 8, !tbaa !5
  %2099 = getelementptr inbounds i8, ptr %1, i64 5184
  %wide.load321.2 = load <2 x double>, ptr %2099, align 8, !tbaa !5
  %2100 = fsub <2 x double> %wide.load319.2, %wide.load321.2
  %2101 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2100)
  %2102 = fcmp ogt <2 x double> %2101, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2103 = zext <2 x i1> %2102 to <2 x i32>
  %2104 = or <2 x i32> %2097, %2103
  %2105 = getelementptr inbounds i8, ptr %0, i64 5216
  %wide.load319.3 = load <2 x double>, ptr %2105, align 8, !tbaa !5
  %2106 = getelementptr inbounds i8, ptr %1, i64 5216
  %wide.load321.3 = load <2 x double>, ptr %2106, align 8, !tbaa !5
  %2107 = fsub <2 x double> %wide.load319.3, %wide.load321.3
  %2108 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2107)
  %2109 = fcmp ogt <2 x double> %2108, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2110 = zext <2 x i1> %2109 to <2 x i32>
  %2111 = or <2 x i32> %2104, %2110
  %2112 = getelementptr inbounds i8, ptr %0, i64 5248
  %wide.load319.4 = load <2 x double>, ptr %2112, align 8, !tbaa !5
  %2113 = getelementptr inbounds i8, ptr %1, i64 5248
  %wide.load321.4 = load <2 x double>, ptr %2113, align 8, !tbaa !5
  %2114 = fsub <2 x double> %wide.load319.4, %wide.load321.4
  %2115 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2114)
  %2116 = fcmp ogt <2 x double> %2115, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2117 = zext <2 x i1> %2116 to <2 x i32>
  %2118 = or <2 x i32> %2111, %2117
  %2119 = getelementptr inbounds i8, ptr %0, i64 5280
  %wide.load319.5 = load <2 x double>, ptr %2119, align 8, !tbaa !5
  %2120 = getelementptr inbounds i8, ptr %1, i64 5280
  %wide.load321.5 = load <2 x double>, ptr %2120, align 8, !tbaa !5
  %2121 = fsub <2 x double> %wide.load319.5, %wide.load321.5
  %2122 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2121)
  %2123 = fcmp ogt <2 x double> %2122, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2124 = zext <2 x i1> %2123 to <2 x i32>
  %2125 = or <2 x i32> %2118, %2124
  %2126 = getelementptr inbounds i8, ptr %0, i64 5312
  %wide.load319.6 = load <2 x double>, ptr %2126, align 8, !tbaa !5
  %2127 = getelementptr inbounds i8, ptr %1, i64 5312
  %wide.load321.6 = load <2 x double>, ptr %2127, align 8, !tbaa !5
  %2128 = fsub <2 x double> %wide.load319.6, %wide.load321.6
  %2129 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2128)
  %2130 = fcmp ogt <2 x double> %2129, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2131 = zext <2 x i1> %2130 to <2 x i32>
  %2132 = or <2 x i32> %2125, %2131
  %2133 = getelementptr inbounds i8, ptr %0, i64 5344
  %wide.load319.7 = load <2 x double>, ptr %2133, align 8, !tbaa !5
  %2134 = getelementptr inbounds i8, ptr %1, i64 5344
  %wide.load321.7 = load <2 x double>, ptr %2134, align 8, !tbaa !5
  %2135 = fsub <2 x double> %wide.load319.7, %wide.load321.7
  %2136 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2135)
  %2137 = fcmp ogt <2 x double> %2136, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2138 = zext <2 x i1> %2137 to <2 x i32>
  %2139 = or <2 x i32> %2132, %2138
  %2140 = getelementptr inbounds i8, ptr %0, i64 5376
  %wide.load319.8 = load <2 x double>, ptr %2140, align 8, !tbaa !5
  %2141 = getelementptr inbounds i8, ptr %1, i64 5376
  %wide.load321.8 = load <2 x double>, ptr %2141, align 8, !tbaa !5
  %2142 = fsub <2 x double> %wide.load319.8, %wide.load321.8
  %2143 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2142)
  %2144 = fcmp ogt <2 x double> %2143, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2145 = zext <2 x i1> %2144 to <2 x i32>
  %2146 = or <2 x i32> %2139, %2145
  %2147 = getelementptr inbounds i8, ptr %0, i64 5408
  %wide.load319.9 = load <2 x double>, ptr %2147, align 8, !tbaa !5
  %2148 = getelementptr inbounds i8, ptr %1, i64 5408
  %wide.load321.9 = load <2 x double>, ptr %2148, align 8, !tbaa !5
  %2149 = fsub <2 x double> %wide.load319.9, %wide.load321.9
  %2150 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2149)
  %2151 = fcmp ogt <2 x double> %2150, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2152 = zext <2 x i1> %2151 to <2 x i32>
  %2153 = or <2 x i32> %2146, %2152
  %2154 = getelementptr inbounds i8, ptr %0, i64 5440
  %wide.load319.10 = load <2 x double>, ptr %2154, align 8, !tbaa !5
  %2155 = getelementptr inbounds i8, ptr %1, i64 5440
  %wide.load321.10 = load <2 x double>, ptr %2155, align 8, !tbaa !5
  %2156 = fsub <2 x double> %wide.load319.10, %wide.load321.10
  %2157 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2156)
  %2158 = fcmp ogt <2 x double> %2157, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2159 = zext <2 x i1> %2158 to <2 x i32>
  %2160 = or <2 x i32> %2153, %2159
  %2161 = getelementptr inbounds i8, ptr %0, i64 5472
  %wide.load319.11 = load <2 x double>, ptr %2161, align 8, !tbaa !5
  %2162 = getelementptr inbounds i8, ptr %1, i64 5472
  %wide.load321.11 = load <2 x double>, ptr %2162, align 8, !tbaa !5
  %2163 = fsub <2 x double> %wide.load319.11, %wide.load321.11
  %2164 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2163)
  %2165 = fcmp ogt <2 x double> %2164, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2166 = zext <2 x i1> %2165 to <2 x i32>
  %2167 = or <2 x i32> %2160, %2166
  %2168 = getelementptr inbounds i8, ptr %0, i64 5504
  %wide.load319.12 = load <2 x double>, ptr %2168, align 8, !tbaa !5
  %2169 = getelementptr inbounds i8, ptr %1, i64 5504
  %wide.load321.12 = load <2 x double>, ptr %2169, align 8, !tbaa !5
  %2170 = fsub <2 x double> %wide.load319.12, %wide.load321.12
  %2171 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2170)
  %2172 = fcmp ogt <2 x double> %2171, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2173 = zext <2 x i1> %2172 to <2 x i32>
  %2174 = or <2 x i32> %2167, %2173
  %2175 = getelementptr inbounds i8, ptr %0, i64 5536
  %wide.load319.13 = load <2 x double>, ptr %2175, align 8, !tbaa !5
  %2176 = getelementptr inbounds i8, ptr %1, i64 5536
  %wide.load321.13 = load <2 x double>, ptr %2176, align 8, !tbaa !5
  %2177 = fsub <2 x double> %wide.load319.13, %wide.load321.13
  %2178 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2177)
  %2179 = fcmp ogt <2 x double> %2178, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2180 = zext <2 x i1> %2179 to <2 x i32>
  %2181 = or <2 x i32> %2174, %2180
  %2182 = getelementptr inbounds i8, ptr %0, i64 5568
  %wide.load319.14 = load <2 x double>, ptr %2182, align 8, !tbaa !5
  %2183 = getelementptr inbounds i8, ptr %1, i64 5568
  %wide.load321.14 = load <2 x double>, ptr %2183, align 8, !tbaa !5
  %2184 = fsub <2 x double> %wide.load319.14, %wide.load321.14
  %2185 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2184)
  %2186 = fcmp ogt <2 x double> %2185, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2187 = zext <2 x i1> %2186 to <2 x i32>
  %2188 = or <2 x i32> %2181, %2187
  %2189 = getelementptr inbounds i8, ptr %0, i64 5600
  %wide.load319.15 = load <2 x double>, ptr %2189, align 8, !tbaa !5
  %2190 = getelementptr inbounds i8, ptr %1, i64 5600
  %wide.load321.15 = load <2 x double>, ptr %2190, align 8, !tbaa !5
  %2191 = fsub <2 x double> %wide.load319.15, %wide.load321.15
  %2192 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2191)
  %2193 = fcmp ogt <2 x double> %2192, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2194 = zext <2 x i1> %2193 to <2 x i32>
  %2195 = or <2 x i32> %2188, %2194
  %2196 = getelementptr inbounds i8, ptr %0, i64 5136
  %wide.load320 = load <2 x double>, ptr %2196, align 8, !tbaa !5
  %2197 = getelementptr inbounds i8, ptr %1, i64 5136
  %wide.load322 = load <2 x double>, ptr %2197, align 8, !tbaa !5
  %2198 = fsub <2 x double> %wide.load320, %wide.load322
  %2199 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2198)
  %2200 = fcmp ogt <2 x double> %2199, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2201 = getelementptr inbounds i8, ptr %0, i64 5168
  %wide.load320.1 = load <2 x double>, ptr %2201, align 8, !tbaa !5
  %2202 = getelementptr inbounds i8, ptr %1, i64 5168
  %wide.load322.1 = load <2 x double>, ptr %2202, align 8, !tbaa !5
  %2203 = fsub <2 x double> %wide.load320.1, %wide.load322.1
  %2204 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2203)
  %2205 = fcmp ogt <2 x double> %2204, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2206 = or <2 x i1> %2200, %2205
  %2207 = getelementptr inbounds i8, ptr %0, i64 5200
  %wide.load320.2 = load <2 x double>, ptr %2207, align 8, !tbaa !5
  %2208 = getelementptr inbounds i8, ptr %1, i64 5200
  %wide.load322.2 = load <2 x double>, ptr %2208, align 8, !tbaa !5
  %2209 = fsub <2 x double> %wide.load320.2, %wide.load322.2
  %2210 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2209)
  %2211 = fcmp ogt <2 x double> %2210, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2212 = or <2 x i1> %2206, %2211
  %2213 = getelementptr inbounds i8, ptr %0, i64 5232
  %wide.load320.3 = load <2 x double>, ptr %2213, align 8, !tbaa !5
  %2214 = getelementptr inbounds i8, ptr %1, i64 5232
  %wide.load322.3 = load <2 x double>, ptr %2214, align 8, !tbaa !5
  %2215 = fsub <2 x double> %wide.load320.3, %wide.load322.3
  %2216 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2215)
  %2217 = fcmp ogt <2 x double> %2216, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2218 = or <2 x i1> %2212, %2217
  %2219 = getelementptr inbounds i8, ptr %0, i64 5264
  %wide.load320.4 = load <2 x double>, ptr %2219, align 8, !tbaa !5
  %2220 = getelementptr inbounds i8, ptr %1, i64 5264
  %wide.load322.4 = load <2 x double>, ptr %2220, align 8, !tbaa !5
  %2221 = fsub <2 x double> %wide.load320.4, %wide.load322.4
  %2222 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2221)
  %2223 = fcmp ogt <2 x double> %2222, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2224 = or <2 x i1> %2218, %2223
  %2225 = getelementptr inbounds i8, ptr %0, i64 5296
  %wide.load320.5 = load <2 x double>, ptr %2225, align 8, !tbaa !5
  %2226 = getelementptr inbounds i8, ptr %1, i64 5296
  %wide.load322.5 = load <2 x double>, ptr %2226, align 8, !tbaa !5
  %2227 = fsub <2 x double> %wide.load320.5, %wide.load322.5
  %2228 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2227)
  %2229 = fcmp ogt <2 x double> %2228, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2230 = or <2 x i1> %2224, %2229
  %2231 = getelementptr inbounds i8, ptr %0, i64 5328
  %wide.load320.6 = load <2 x double>, ptr %2231, align 8, !tbaa !5
  %2232 = getelementptr inbounds i8, ptr %1, i64 5328
  %wide.load322.6 = load <2 x double>, ptr %2232, align 8, !tbaa !5
  %2233 = fsub <2 x double> %wide.load320.6, %wide.load322.6
  %2234 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2233)
  %2235 = fcmp ogt <2 x double> %2234, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2236 = or <2 x i1> %2230, %2235
  %2237 = getelementptr inbounds i8, ptr %0, i64 5360
  %wide.load320.7 = load <2 x double>, ptr %2237, align 8, !tbaa !5
  %2238 = getelementptr inbounds i8, ptr %1, i64 5360
  %wide.load322.7 = load <2 x double>, ptr %2238, align 8, !tbaa !5
  %2239 = fsub <2 x double> %wide.load320.7, %wide.load322.7
  %2240 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2239)
  %2241 = fcmp ogt <2 x double> %2240, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2242 = or <2 x i1> %2236, %2241
  %2243 = getelementptr inbounds i8, ptr %0, i64 5392
  %wide.load320.8 = load <2 x double>, ptr %2243, align 8, !tbaa !5
  %2244 = getelementptr inbounds i8, ptr %1, i64 5392
  %wide.load322.8 = load <2 x double>, ptr %2244, align 8, !tbaa !5
  %2245 = fsub <2 x double> %wide.load320.8, %wide.load322.8
  %2246 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2245)
  %2247 = fcmp ogt <2 x double> %2246, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2248 = or <2 x i1> %2242, %2247
  %2249 = getelementptr inbounds i8, ptr %0, i64 5424
  %wide.load320.9 = load <2 x double>, ptr %2249, align 8, !tbaa !5
  %2250 = getelementptr inbounds i8, ptr %1, i64 5424
  %wide.load322.9 = load <2 x double>, ptr %2250, align 8, !tbaa !5
  %2251 = fsub <2 x double> %wide.load320.9, %wide.load322.9
  %2252 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2251)
  %2253 = fcmp ogt <2 x double> %2252, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2254 = or <2 x i1> %2248, %2253
  %2255 = getelementptr inbounds i8, ptr %0, i64 5456
  %wide.load320.10 = load <2 x double>, ptr %2255, align 8, !tbaa !5
  %2256 = getelementptr inbounds i8, ptr %1, i64 5456
  %wide.load322.10 = load <2 x double>, ptr %2256, align 8, !tbaa !5
  %2257 = fsub <2 x double> %wide.load320.10, %wide.load322.10
  %2258 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2257)
  %2259 = fcmp ogt <2 x double> %2258, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2260 = or <2 x i1> %2254, %2259
  %2261 = getelementptr inbounds i8, ptr %0, i64 5488
  %wide.load320.11 = load <2 x double>, ptr %2261, align 8, !tbaa !5
  %2262 = getelementptr inbounds i8, ptr %1, i64 5488
  %wide.load322.11 = load <2 x double>, ptr %2262, align 8, !tbaa !5
  %2263 = fsub <2 x double> %wide.load320.11, %wide.load322.11
  %2264 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2263)
  %2265 = fcmp ogt <2 x double> %2264, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2266 = or <2 x i1> %2260, %2265
  %2267 = getelementptr inbounds i8, ptr %0, i64 5520
  %wide.load320.12 = load <2 x double>, ptr %2267, align 8, !tbaa !5
  %2268 = getelementptr inbounds i8, ptr %1, i64 5520
  %wide.load322.12 = load <2 x double>, ptr %2268, align 8, !tbaa !5
  %2269 = fsub <2 x double> %wide.load320.12, %wide.load322.12
  %2270 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2269)
  %2271 = fcmp ogt <2 x double> %2270, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2272 = or <2 x i1> %2266, %2271
  %2273 = getelementptr inbounds i8, ptr %0, i64 5552
  %wide.load320.13 = load <2 x double>, ptr %2273, align 8, !tbaa !5
  %2274 = getelementptr inbounds i8, ptr %1, i64 5552
  %wide.load322.13 = load <2 x double>, ptr %2274, align 8, !tbaa !5
  %2275 = fsub <2 x double> %wide.load320.13, %wide.load322.13
  %2276 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2275)
  %2277 = fcmp ogt <2 x double> %2276, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2278 = or <2 x i1> %2272, %2277
  %2279 = getelementptr inbounds i8, ptr %0, i64 5584
  %wide.load320.14 = load <2 x double>, ptr %2279, align 8, !tbaa !5
  %2280 = getelementptr inbounds i8, ptr %1, i64 5584
  %wide.load322.14 = load <2 x double>, ptr %2280, align 8, !tbaa !5
  %2281 = fsub <2 x double> %wide.load320.14, %wide.load322.14
  %2282 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2281)
  %2283 = fcmp ogt <2 x double> %2282, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2284 = or <2 x i1> %2278, %2283
  %2285 = getelementptr inbounds i8, ptr %0, i64 5616
  %wide.load320.15 = load <2 x double>, ptr %2285, align 8, !tbaa !5
  %2286 = getelementptr inbounds i8, ptr %1, i64 5616
  %wide.load322.15 = load <2 x double>, ptr %2286, align 8, !tbaa !5
  %2287 = fsub <2 x double> %wide.load320.15, %wide.load322.15
  %2288 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2287)
  %2289 = fcmp ogt <2 x double> %2288, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2290 = or <2 x i1> %2284, %2289
  %2291 = zext <2 x i1> %2290 to <2 x i32>
  %bin.rdx324 = or <2 x i32> %2195, %2291
  %2292 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx324)
  %2293 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %2292, i64 0
  %2294 = getelementptr inbounds i8, ptr %0, i64 5632
  %wide.load334 = load <2 x double>, ptr %2294, align 8, !tbaa !5
  %2295 = getelementptr inbounds i8, ptr %1, i64 5632
  %wide.load336 = load <2 x double>, ptr %2295, align 8, !tbaa !5
  %2296 = fsub <2 x double> %wide.load334, %wide.load336
  %2297 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2296)
  %2298 = fcmp ogt <2 x double> %2297, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2299 = zext <2 x i1> %2298 to <2 x i32>
  %2300 = or <2 x i32> %2293, %2299
  %2301 = getelementptr inbounds i8, ptr %0, i64 5664
  %wide.load334.1 = load <2 x double>, ptr %2301, align 8, !tbaa !5
  %2302 = getelementptr inbounds i8, ptr %1, i64 5664
  %wide.load336.1 = load <2 x double>, ptr %2302, align 8, !tbaa !5
  %2303 = fsub <2 x double> %wide.load334.1, %wide.load336.1
  %2304 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2303)
  %2305 = fcmp ogt <2 x double> %2304, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2306 = zext <2 x i1> %2305 to <2 x i32>
  %2307 = or <2 x i32> %2300, %2306
  %2308 = getelementptr inbounds i8, ptr %0, i64 5696
  %wide.load334.2 = load <2 x double>, ptr %2308, align 8, !tbaa !5
  %2309 = getelementptr inbounds i8, ptr %1, i64 5696
  %wide.load336.2 = load <2 x double>, ptr %2309, align 8, !tbaa !5
  %2310 = fsub <2 x double> %wide.load334.2, %wide.load336.2
  %2311 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2310)
  %2312 = fcmp ogt <2 x double> %2311, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2313 = zext <2 x i1> %2312 to <2 x i32>
  %2314 = or <2 x i32> %2307, %2313
  %2315 = getelementptr inbounds i8, ptr %0, i64 5728
  %wide.load334.3 = load <2 x double>, ptr %2315, align 8, !tbaa !5
  %2316 = getelementptr inbounds i8, ptr %1, i64 5728
  %wide.load336.3 = load <2 x double>, ptr %2316, align 8, !tbaa !5
  %2317 = fsub <2 x double> %wide.load334.3, %wide.load336.3
  %2318 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2317)
  %2319 = fcmp ogt <2 x double> %2318, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2320 = zext <2 x i1> %2319 to <2 x i32>
  %2321 = or <2 x i32> %2314, %2320
  %2322 = getelementptr inbounds i8, ptr %0, i64 5760
  %wide.load334.4 = load <2 x double>, ptr %2322, align 8, !tbaa !5
  %2323 = getelementptr inbounds i8, ptr %1, i64 5760
  %wide.load336.4 = load <2 x double>, ptr %2323, align 8, !tbaa !5
  %2324 = fsub <2 x double> %wide.load334.4, %wide.load336.4
  %2325 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2324)
  %2326 = fcmp ogt <2 x double> %2325, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2327 = zext <2 x i1> %2326 to <2 x i32>
  %2328 = or <2 x i32> %2321, %2327
  %2329 = getelementptr inbounds i8, ptr %0, i64 5792
  %wide.load334.5 = load <2 x double>, ptr %2329, align 8, !tbaa !5
  %2330 = getelementptr inbounds i8, ptr %1, i64 5792
  %wide.load336.5 = load <2 x double>, ptr %2330, align 8, !tbaa !5
  %2331 = fsub <2 x double> %wide.load334.5, %wide.load336.5
  %2332 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2331)
  %2333 = fcmp ogt <2 x double> %2332, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2334 = zext <2 x i1> %2333 to <2 x i32>
  %2335 = or <2 x i32> %2328, %2334
  %2336 = getelementptr inbounds i8, ptr %0, i64 5824
  %wide.load334.6 = load <2 x double>, ptr %2336, align 8, !tbaa !5
  %2337 = getelementptr inbounds i8, ptr %1, i64 5824
  %wide.load336.6 = load <2 x double>, ptr %2337, align 8, !tbaa !5
  %2338 = fsub <2 x double> %wide.load334.6, %wide.load336.6
  %2339 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2338)
  %2340 = fcmp ogt <2 x double> %2339, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2341 = zext <2 x i1> %2340 to <2 x i32>
  %2342 = or <2 x i32> %2335, %2341
  %2343 = getelementptr inbounds i8, ptr %0, i64 5856
  %wide.load334.7 = load <2 x double>, ptr %2343, align 8, !tbaa !5
  %2344 = getelementptr inbounds i8, ptr %1, i64 5856
  %wide.load336.7 = load <2 x double>, ptr %2344, align 8, !tbaa !5
  %2345 = fsub <2 x double> %wide.load334.7, %wide.load336.7
  %2346 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2345)
  %2347 = fcmp ogt <2 x double> %2346, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2348 = zext <2 x i1> %2347 to <2 x i32>
  %2349 = or <2 x i32> %2342, %2348
  %2350 = getelementptr inbounds i8, ptr %0, i64 5888
  %wide.load334.8 = load <2 x double>, ptr %2350, align 8, !tbaa !5
  %2351 = getelementptr inbounds i8, ptr %1, i64 5888
  %wide.load336.8 = load <2 x double>, ptr %2351, align 8, !tbaa !5
  %2352 = fsub <2 x double> %wide.load334.8, %wide.load336.8
  %2353 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2352)
  %2354 = fcmp ogt <2 x double> %2353, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2355 = zext <2 x i1> %2354 to <2 x i32>
  %2356 = or <2 x i32> %2349, %2355
  %2357 = getelementptr inbounds i8, ptr %0, i64 5920
  %wide.load334.9 = load <2 x double>, ptr %2357, align 8, !tbaa !5
  %2358 = getelementptr inbounds i8, ptr %1, i64 5920
  %wide.load336.9 = load <2 x double>, ptr %2358, align 8, !tbaa !5
  %2359 = fsub <2 x double> %wide.load334.9, %wide.load336.9
  %2360 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2359)
  %2361 = fcmp ogt <2 x double> %2360, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2362 = zext <2 x i1> %2361 to <2 x i32>
  %2363 = or <2 x i32> %2356, %2362
  %2364 = getelementptr inbounds i8, ptr %0, i64 5952
  %wide.load334.10 = load <2 x double>, ptr %2364, align 8, !tbaa !5
  %2365 = getelementptr inbounds i8, ptr %1, i64 5952
  %wide.load336.10 = load <2 x double>, ptr %2365, align 8, !tbaa !5
  %2366 = fsub <2 x double> %wide.load334.10, %wide.load336.10
  %2367 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2366)
  %2368 = fcmp ogt <2 x double> %2367, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2369 = zext <2 x i1> %2368 to <2 x i32>
  %2370 = or <2 x i32> %2363, %2369
  %2371 = getelementptr inbounds i8, ptr %0, i64 5984
  %wide.load334.11 = load <2 x double>, ptr %2371, align 8, !tbaa !5
  %2372 = getelementptr inbounds i8, ptr %1, i64 5984
  %wide.load336.11 = load <2 x double>, ptr %2372, align 8, !tbaa !5
  %2373 = fsub <2 x double> %wide.load334.11, %wide.load336.11
  %2374 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2373)
  %2375 = fcmp ogt <2 x double> %2374, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2376 = zext <2 x i1> %2375 to <2 x i32>
  %2377 = or <2 x i32> %2370, %2376
  %2378 = getelementptr inbounds i8, ptr %0, i64 6016
  %wide.load334.12 = load <2 x double>, ptr %2378, align 8, !tbaa !5
  %2379 = getelementptr inbounds i8, ptr %1, i64 6016
  %wide.load336.12 = load <2 x double>, ptr %2379, align 8, !tbaa !5
  %2380 = fsub <2 x double> %wide.load334.12, %wide.load336.12
  %2381 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2380)
  %2382 = fcmp ogt <2 x double> %2381, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2383 = zext <2 x i1> %2382 to <2 x i32>
  %2384 = or <2 x i32> %2377, %2383
  %2385 = getelementptr inbounds i8, ptr %0, i64 6048
  %wide.load334.13 = load <2 x double>, ptr %2385, align 8, !tbaa !5
  %2386 = getelementptr inbounds i8, ptr %1, i64 6048
  %wide.load336.13 = load <2 x double>, ptr %2386, align 8, !tbaa !5
  %2387 = fsub <2 x double> %wide.load334.13, %wide.load336.13
  %2388 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2387)
  %2389 = fcmp ogt <2 x double> %2388, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2390 = zext <2 x i1> %2389 to <2 x i32>
  %2391 = or <2 x i32> %2384, %2390
  %2392 = getelementptr inbounds i8, ptr %0, i64 6080
  %wide.load334.14 = load <2 x double>, ptr %2392, align 8, !tbaa !5
  %2393 = getelementptr inbounds i8, ptr %1, i64 6080
  %wide.load336.14 = load <2 x double>, ptr %2393, align 8, !tbaa !5
  %2394 = fsub <2 x double> %wide.load334.14, %wide.load336.14
  %2395 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2394)
  %2396 = fcmp ogt <2 x double> %2395, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2397 = zext <2 x i1> %2396 to <2 x i32>
  %2398 = or <2 x i32> %2391, %2397
  %2399 = getelementptr inbounds i8, ptr %0, i64 6112
  %wide.load334.15 = load <2 x double>, ptr %2399, align 8, !tbaa !5
  %2400 = getelementptr inbounds i8, ptr %1, i64 6112
  %wide.load336.15 = load <2 x double>, ptr %2400, align 8, !tbaa !5
  %2401 = fsub <2 x double> %wide.load334.15, %wide.load336.15
  %2402 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2401)
  %2403 = fcmp ogt <2 x double> %2402, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2404 = zext <2 x i1> %2403 to <2 x i32>
  %2405 = or <2 x i32> %2398, %2404
  %2406 = getelementptr inbounds i8, ptr %0, i64 5648
  %wide.load335 = load <2 x double>, ptr %2406, align 8, !tbaa !5
  %2407 = getelementptr inbounds i8, ptr %1, i64 5648
  %wide.load337 = load <2 x double>, ptr %2407, align 8, !tbaa !5
  %2408 = fsub <2 x double> %wide.load335, %wide.load337
  %2409 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2408)
  %2410 = fcmp ogt <2 x double> %2409, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2411 = getelementptr inbounds i8, ptr %0, i64 5680
  %wide.load335.1 = load <2 x double>, ptr %2411, align 8, !tbaa !5
  %2412 = getelementptr inbounds i8, ptr %1, i64 5680
  %wide.load337.1 = load <2 x double>, ptr %2412, align 8, !tbaa !5
  %2413 = fsub <2 x double> %wide.load335.1, %wide.load337.1
  %2414 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2413)
  %2415 = fcmp ogt <2 x double> %2414, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2416 = or <2 x i1> %2410, %2415
  %2417 = getelementptr inbounds i8, ptr %0, i64 5712
  %wide.load335.2 = load <2 x double>, ptr %2417, align 8, !tbaa !5
  %2418 = getelementptr inbounds i8, ptr %1, i64 5712
  %wide.load337.2 = load <2 x double>, ptr %2418, align 8, !tbaa !5
  %2419 = fsub <2 x double> %wide.load335.2, %wide.load337.2
  %2420 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2419)
  %2421 = fcmp ogt <2 x double> %2420, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2422 = or <2 x i1> %2416, %2421
  %2423 = getelementptr inbounds i8, ptr %0, i64 5744
  %wide.load335.3 = load <2 x double>, ptr %2423, align 8, !tbaa !5
  %2424 = getelementptr inbounds i8, ptr %1, i64 5744
  %wide.load337.3 = load <2 x double>, ptr %2424, align 8, !tbaa !5
  %2425 = fsub <2 x double> %wide.load335.3, %wide.load337.3
  %2426 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2425)
  %2427 = fcmp ogt <2 x double> %2426, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2428 = or <2 x i1> %2422, %2427
  %2429 = getelementptr inbounds i8, ptr %0, i64 5776
  %wide.load335.4 = load <2 x double>, ptr %2429, align 8, !tbaa !5
  %2430 = getelementptr inbounds i8, ptr %1, i64 5776
  %wide.load337.4 = load <2 x double>, ptr %2430, align 8, !tbaa !5
  %2431 = fsub <2 x double> %wide.load335.4, %wide.load337.4
  %2432 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2431)
  %2433 = fcmp ogt <2 x double> %2432, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2434 = or <2 x i1> %2428, %2433
  %2435 = getelementptr inbounds i8, ptr %0, i64 5808
  %wide.load335.5 = load <2 x double>, ptr %2435, align 8, !tbaa !5
  %2436 = getelementptr inbounds i8, ptr %1, i64 5808
  %wide.load337.5 = load <2 x double>, ptr %2436, align 8, !tbaa !5
  %2437 = fsub <2 x double> %wide.load335.5, %wide.load337.5
  %2438 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2437)
  %2439 = fcmp ogt <2 x double> %2438, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2440 = or <2 x i1> %2434, %2439
  %2441 = getelementptr inbounds i8, ptr %0, i64 5840
  %wide.load335.6 = load <2 x double>, ptr %2441, align 8, !tbaa !5
  %2442 = getelementptr inbounds i8, ptr %1, i64 5840
  %wide.load337.6 = load <2 x double>, ptr %2442, align 8, !tbaa !5
  %2443 = fsub <2 x double> %wide.load335.6, %wide.load337.6
  %2444 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2443)
  %2445 = fcmp ogt <2 x double> %2444, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2446 = or <2 x i1> %2440, %2445
  %2447 = getelementptr inbounds i8, ptr %0, i64 5872
  %wide.load335.7 = load <2 x double>, ptr %2447, align 8, !tbaa !5
  %2448 = getelementptr inbounds i8, ptr %1, i64 5872
  %wide.load337.7 = load <2 x double>, ptr %2448, align 8, !tbaa !5
  %2449 = fsub <2 x double> %wide.load335.7, %wide.load337.7
  %2450 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2449)
  %2451 = fcmp ogt <2 x double> %2450, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2452 = or <2 x i1> %2446, %2451
  %2453 = getelementptr inbounds i8, ptr %0, i64 5904
  %wide.load335.8 = load <2 x double>, ptr %2453, align 8, !tbaa !5
  %2454 = getelementptr inbounds i8, ptr %1, i64 5904
  %wide.load337.8 = load <2 x double>, ptr %2454, align 8, !tbaa !5
  %2455 = fsub <2 x double> %wide.load335.8, %wide.load337.8
  %2456 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2455)
  %2457 = fcmp ogt <2 x double> %2456, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2458 = or <2 x i1> %2452, %2457
  %2459 = getelementptr inbounds i8, ptr %0, i64 5936
  %wide.load335.9 = load <2 x double>, ptr %2459, align 8, !tbaa !5
  %2460 = getelementptr inbounds i8, ptr %1, i64 5936
  %wide.load337.9 = load <2 x double>, ptr %2460, align 8, !tbaa !5
  %2461 = fsub <2 x double> %wide.load335.9, %wide.load337.9
  %2462 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2461)
  %2463 = fcmp ogt <2 x double> %2462, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2464 = or <2 x i1> %2458, %2463
  %2465 = getelementptr inbounds i8, ptr %0, i64 5968
  %wide.load335.10 = load <2 x double>, ptr %2465, align 8, !tbaa !5
  %2466 = getelementptr inbounds i8, ptr %1, i64 5968
  %wide.load337.10 = load <2 x double>, ptr %2466, align 8, !tbaa !5
  %2467 = fsub <2 x double> %wide.load335.10, %wide.load337.10
  %2468 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2467)
  %2469 = fcmp ogt <2 x double> %2468, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2470 = or <2 x i1> %2464, %2469
  %2471 = getelementptr inbounds i8, ptr %0, i64 6000
  %wide.load335.11 = load <2 x double>, ptr %2471, align 8, !tbaa !5
  %2472 = getelementptr inbounds i8, ptr %1, i64 6000
  %wide.load337.11 = load <2 x double>, ptr %2472, align 8, !tbaa !5
  %2473 = fsub <2 x double> %wide.load335.11, %wide.load337.11
  %2474 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2473)
  %2475 = fcmp ogt <2 x double> %2474, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2476 = or <2 x i1> %2470, %2475
  %2477 = getelementptr inbounds i8, ptr %0, i64 6032
  %wide.load335.12 = load <2 x double>, ptr %2477, align 8, !tbaa !5
  %2478 = getelementptr inbounds i8, ptr %1, i64 6032
  %wide.load337.12 = load <2 x double>, ptr %2478, align 8, !tbaa !5
  %2479 = fsub <2 x double> %wide.load335.12, %wide.load337.12
  %2480 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2479)
  %2481 = fcmp ogt <2 x double> %2480, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2482 = or <2 x i1> %2476, %2481
  %2483 = getelementptr inbounds i8, ptr %0, i64 6064
  %wide.load335.13 = load <2 x double>, ptr %2483, align 8, !tbaa !5
  %2484 = getelementptr inbounds i8, ptr %1, i64 6064
  %wide.load337.13 = load <2 x double>, ptr %2484, align 8, !tbaa !5
  %2485 = fsub <2 x double> %wide.load335.13, %wide.load337.13
  %2486 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2485)
  %2487 = fcmp ogt <2 x double> %2486, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2488 = or <2 x i1> %2482, %2487
  %2489 = getelementptr inbounds i8, ptr %0, i64 6096
  %wide.load335.14 = load <2 x double>, ptr %2489, align 8, !tbaa !5
  %2490 = getelementptr inbounds i8, ptr %1, i64 6096
  %wide.load337.14 = load <2 x double>, ptr %2490, align 8, !tbaa !5
  %2491 = fsub <2 x double> %wide.load335.14, %wide.load337.14
  %2492 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2491)
  %2493 = fcmp ogt <2 x double> %2492, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2494 = or <2 x i1> %2488, %2493
  %2495 = getelementptr inbounds i8, ptr %0, i64 6128
  %wide.load335.15 = load <2 x double>, ptr %2495, align 8, !tbaa !5
  %2496 = getelementptr inbounds i8, ptr %1, i64 6128
  %wide.load337.15 = load <2 x double>, ptr %2496, align 8, !tbaa !5
  %2497 = fsub <2 x double> %wide.load335.15, %wide.load337.15
  %2498 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2497)
  %2499 = fcmp ogt <2 x double> %2498, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2500 = or <2 x i1> %2494, %2499
  %2501 = zext <2 x i1> %2500 to <2 x i32>
  %bin.rdx339 = or <2 x i32> %2405, %2501
  %2502 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx339)
  %2503 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %2502, i64 0
  %2504 = getelementptr inbounds i8, ptr %0, i64 6144
  %2505 = getelementptr inbounds i8, ptr %0, i64 6160
  %wide.load349 = load <2 x double>, ptr %2504, align 8, !tbaa !5
  %wide.load350 = load <2 x double>, ptr %2505, align 8, !tbaa !5
  %2506 = getelementptr inbounds i8, ptr %1, i64 6144
  %2507 = getelementptr inbounds i8, ptr %1, i64 6160
  %wide.load351 = load <2 x double>, ptr %2506, align 8, !tbaa !5
  %wide.load352 = load <2 x double>, ptr %2507, align 8, !tbaa !5
  %2508 = fsub <2 x double> %wide.load349, %wide.load351
  %2509 = fsub <2 x double> %wide.load350, %wide.load352
  %2510 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2508)
  %2511 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2509)
  %2512 = fcmp ogt <2 x double> %2510, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2513 = fcmp ogt <2 x double> %2511, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2514 = zext <2 x i1> %2512 to <2 x i32>
  %2515 = or <2 x i32> %2503, %2514
  %2516 = getelementptr inbounds i8, ptr %0, i64 6176
  %2517 = getelementptr inbounds i8, ptr %0, i64 6192
  %wide.load349.1 = load <2 x double>, ptr %2516, align 8, !tbaa !5
  %wide.load350.1 = load <2 x double>, ptr %2517, align 8, !tbaa !5
  %2518 = getelementptr inbounds i8, ptr %1, i64 6176
  %2519 = getelementptr inbounds i8, ptr %1, i64 6192
  %wide.load351.1 = load <2 x double>, ptr %2518, align 8, !tbaa !5
  %wide.load352.1 = load <2 x double>, ptr %2519, align 8, !tbaa !5
  %2520 = fsub <2 x double> %wide.load349.1, %wide.load351.1
  %2521 = fsub <2 x double> %wide.load350.1, %wide.load352.1
  %2522 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2520)
  %2523 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2521)
  %2524 = fcmp ogt <2 x double> %2522, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2525 = fcmp ogt <2 x double> %2523, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2526 = zext <2 x i1> %2524 to <2 x i32>
  %2527 = or <2 x i32> %2515, %2526
  %2528 = or <2 x i1> %2513, %2525
  %2529 = getelementptr inbounds i8, ptr %0, i64 6208
  %2530 = getelementptr inbounds i8, ptr %0, i64 6224
  %wide.load349.2 = load <2 x double>, ptr %2529, align 8, !tbaa !5
  %wide.load350.2 = load <2 x double>, ptr %2530, align 8, !tbaa !5
  %2531 = getelementptr inbounds i8, ptr %1, i64 6208
  %2532 = getelementptr inbounds i8, ptr %1, i64 6224
  %wide.load351.2 = load <2 x double>, ptr %2531, align 8, !tbaa !5
  %wide.load352.2 = load <2 x double>, ptr %2532, align 8, !tbaa !5
  %2533 = fsub <2 x double> %wide.load349.2, %wide.load351.2
  %2534 = fsub <2 x double> %wide.load350.2, %wide.load352.2
  %2535 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2533)
  %2536 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2534)
  %2537 = fcmp ogt <2 x double> %2535, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2538 = fcmp ogt <2 x double> %2536, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2539 = zext <2 x i1> %2537 to <2 x i32>
  %2540 = or <2 x i32> %2527, %2539
  %2541 = or <2 x i1> %2528, %2538
  %2542 = getelementptr inbounds i8, ptr %0, i64 6240
  %2543 = getelementptr inbounds i8, ptr %0, i64 6256
  %wide.load349.3 = load <2 x double>, ptr %2542, align 8, !tbaa !5
  %wide.load350.3 = load <2 x double>, ptr %2543, align 8, !tbaa !5
  %2544 = getelementptr inbounds i8, ptr %1, i64 6240
  %2545 = getelementptr inbounds i8, ptr %1, i64 6256
  %wide.load351.3 = load <2 x double>, ptr %2544, align 8, !tbaa !5
  %wide.load352.3 = load <2 x double>, ptr %2545, align 8, !tbaa !5
  %2546 = fsub <2 x double> %wide.load349.3, %wide.load351.3
  %2547 = fsub <2 x double> %wide.load350.3, %wide.load352.3
  %2548 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2546)
  %2549 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2547)
  %2550 = fcmp ogt <2 x double> %2548, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2551 = fcmp ogt <2 x double> %2549, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2552 = zext <2 x i1> %2550 to <2 x i32>
  %2553 = or <2 x i32> %2540, %2552
  %2554 = or <2 x i1> %2541, %2551
  %2555 = getelementptr inbounds i8, ptr %0, i64 6272
  %2556 = getelementptr inbounds i8, ptr %0, i64 6288
  %wide.load349.4 = load <2 x double>, ptr %2555, align 8, !tbaa !5
  %wide.load350.4 = load <2 x double>, ptr %2556, align 8, !tbaa !5
  %2557 = getelementptr inbounds i8, ptr %1, i64 6272
  %2558 = getelementptr inbounds i8, ptr %1, i64 6288
  %wide.load351.4 = load <2 x double>, ptr %2557, align 8, !tbaa !5
  %wide.load352.4 = load <2 x double>, ptr %2558, align 8, !tbaa !5
  %2559 = fsub <2 x double> %wide.load349.4, %wide.load351.4
  %2560 = fsub <2 x double> %wide.load350.4, %wide.load352.4
  %2561 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2559)
  %2562 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2560)
  %2563 = fcmp ogt <2 x double> %2561, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2564 = fcmp ogt <2 x double> %2562, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2565 = zext <2 x i1> %2563 to <2 x i32>
  %2566 = or <2 x i32> %2553, %2565
  %2567 = or <2 x i1> %2554, %2564
  %2568 = getelementptr inbounds i8, ptr %0, i64 6304
  %2569 = getelementptr inbounds i8, ptr %0, i64 6320
  %wide.load349.5 = load <2 x double>, ptr %2568, align 8, !tbaa !5
  %wide.load350.5 = load <2 x double>, ptr %2569, align 8, !tbaa !5
  %2570 = getelementptr inbounds i8, ptr %1, i64 6304
  %2571 = getelementptr inbounds i8, ptr %1, i64 6320
  %wide.load351.5 = load <2 x double>, ptr %2570, align 8, !tbaa !5
  %wide.load352.5 = load <2 x double>, ptr %2571, align 8, !tbaa !5
  %2572 = fsub <2 x double> %wide.load349.5, %wide.load351.5
  %2573 = fsub <2 x double> %wide.load350.5, %wide.load352.5
  %2574 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2572)
  %2575 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2573)
  %2576 = fcmp ogt <2 x double> %2574, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2577 = fcmp ogt <2 x double> %2575, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2578 = zext <2 x i1> %2576 to <2 x i32>
  %2579 = or <2 x i32> %2566, %2578
  %2580 = or <2 x i1> %2567, %2577
  %2581 = getelementptr inbounds i8, ptr %0, i64 6336
  %2582 = getelementptr inbounds i8, ptr %0, i64 6352
  %wide.load349.6 = load <2 x double>, ptr %2581, align 8, !tbaa !5
  %wide.load350.6 = load <2 x double>, ptr %2582, align 8, !tbaa !5
  %2583 = getelementptr inbounds i8, ptr %1, i64 6336
  %2584 = getelementptr inbounds i8, ptr %1, i64 6352
  %wide.load351.6 = load <2 x double>, ptr %2583, align 8, !tbaa !5
  %wide.load352.6 = load <2 x double>, ptr %2584, align 8, !tbaa !5
  %2585 = fsub <2 x double> %wide.load349.6, %wide.load351.6
  %2586 = fsub <2 x double> %wide.load350.6, %wide.load352.6
  %2587 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2585)
  %2588 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2586)
  %2589 = fcmp ogt <2 x double> %2587, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2590 = fcmp ogt <2 x double> %2588, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2591 = zext <2 x i1> %2589 to <2 x i32>
  %2592 = or <2 x i32> %2579, %2591
  %2593 = or <2 x i1> %2580, %2590
  %2594 = getelementptr inbounds i8, ptr %0, i64 6368
  %2595 = getelementptr inbounds i8, ptr %0, i64 6384
  %wide.load349.7 = load <2 x double>, ptr %2594, align 8, !tbaa !5
  %wide.load350.7 = load <2 x double>, ptr %2595, align 8, !tbaa !5
  %2596 = getelementptr inbounds i8, ptr %1, i64 6368
  %2597 = getelementptr inbounds i8, ptr %1, i64 6384
  %wide.load351.7 = load <2 x double>, ptr %2596, align 8, !tbaa !5
  %wide.load352.7 = load <2 x double>, ptr %2597, align 8, !tbaa !5
  %2598 = fsub <2 x double> %wide.load349.7, %wide.load351.7
  %2599 = fsub <2 x double> %wide.load350.7, %wide.load352.7
  %2600 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2598)
  %2601 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2599)
  %2602 = fcmp ogt <2 x double> %2600, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2603 = fcmp ogt <2 x double> %2601, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2604 = zext <2 x i1> %2602 to <2 x i32>
  %2605 = or <2 x i32> %2592, %2604
  %2606 = or <2 x i1> %2593, %2603
  %2607 = getelementptr inbounds i8, ptr %0, i64 6400
  %2608 = getelementptr inbounds i8, ptr %0, i64 6416
  %wide.load349.8 = load <2 x double>, ptr %2607, align 8, !tbaa !5
  %wide.load350.8 = load <2 x double>, ptr %2608, align 8, !tbaa !5
  %2609 = getelementptr inbounds i8, ptr %1, i64 6400
  %2610 = getelementptr inbounds i8, ptr %1, i64 6416
  %wide.load351.8 = load <2 x double>, ptr %2609, align 8, !tbaa !5
  %wide.load352.8 = load <2 x double>, ptr %2610, align 8, !tbaa !5
  %2611 = fsub <2 x double> %wide.load349.8, %wide.load351.8
  %2612 = fsub <2 x double> %wide.load350.8, %wide.load352.8
  %2613 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2611)
  %2614 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2612)
  %2615 = fcmp ogt <2 x double> %2613, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2616 = fcmp ogt <2 x double> %2614, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2617 = zext <2 x i1> %2615 to <2 x i32>
  %2618 = or <2 x i32> %2605, %2617
  %2619 = or <2 x i1> %2606, %2616
  %2620 = getelementptr inbounds i8, ptr %0, i64 6432
  %2621 = getelementptr inbounds i8, ptr %0, i64 6448
  %wide.load349.9 = load <2 x double>, ptr %2620, align 8, !tbaa !5
  %wide.load350.9 = load <2 x double>, ptr %2621, align 8, !tbaa !5
  %2622 = getelementptr inbounds i8, ptr %1, i64 6432
  %2623 = getelementptr inbounds i8, ptr %1, i64 6448
  %wide.load351.9 = load <2 x double>, ptr %2622, align 8, !tbaa !5
  %wide.load352.9 = load <2 x double>, ptr %2623, align 8, !tbaa !5
  %2624 = fsub <2 x double> %wide.load349.9, %wide.load351.9
  %2625 = fsub <2 x double> %wide.load350.9, %wide.load352.9
  %2626 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2624)
  %2627 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2625)
  %2628 = fcmp ogt <2 x double> %2626, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2629 = fcmp ogt <2 x double> %2627, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2630 = zext <2 x i1> %2628 to <2 x i32>
  %2631 = or <2 x i32> %2618, %2630
  %2632 = or <2 x i1> %2619, %2629
  %2633 = getelementptr inbounds i8, ptr %0, i64 6464
  %2634 = getelementptr inbounds i8, ptr %0, i64 6480
  %wide.load349.10 = load <2 x double>, ptr %2633, align 8, !tbaa !5
  %wide.load350.10 = load <2 x double>, ptr %2634, align 8, !tbaa !5
  %2635 = getelementptr inbounds i8, ptr %1, i64 6464
  %2636 = getelementptr inbounds i8, ptr %1, i64 6480
  %wide.load351.10 = load <2 x double>, ptr %2635, align 8, !tbaa !5
  %wide.load352.10 = load <2 x double>, ptr %2636, align 8, !tbaa !5
  %2637 = fsub <2 x double> %wide.load349.10, %wide.load351.10
  %2638 = fsub <2 x double> %wide.load350.10, %wide.load352.10
  %2639 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2637)
  %2640 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2638)
  %2641 = fcmp ogt <2 x double> %2639, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2642 = fcmp ogt <2 x double> %2640, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2643 = zext <2 x i1> %2641 to <2 x i32>
  %2644 = or <2 x i32> %2631, %2643
  %2645 = or <2 x i1> %2632, %2642
  %2646 = getelementptr inbounds i8, ptr %0, i64 6496
  %2647 = getelementptr inbounds i8, ptr %0, i64 6512
  %wide.load349.11 = load <2 x double>, ptr %2646, align 8, !tbaa !5
  %wide.load350.11 = load <2 x double>, ptr %2647, align 8, !tbaa !5
  %2648 = getelementptr inbounds i8, ptr %1, i64 6496
  %2649 = getelementptr inbounds i8, ptr %1, i64 6512
  %wide.load351.11 = load <2 x double>, ptr %2648, align 8, !tbaa !5
  %wide.load352.11 = load <2 x double>, ptr %2649, align 8, !tbaa !5
  %2650 = fsub <2 x double> %wide.load349.11, %wide.load351.11
  %2651 = fsub <2 x double> %wide.load350.11, %wide.load352.11
  %2652 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2650)
  %2653 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2651)
  %2654 = fcmp ogt <2 x double> %2652, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2655 = fcmp ogt <2 x double> %2653, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2656 = zext <2 x i1> %2654 to <2 x i32>
  %2657 = or <2 x i32> %2644, %2656
  %2658 = or <2 x i1> %2645, %2655
  %2659 = getelementptr inbounds i8, ptr %0, i64 6528
  %2660 = getelementptr inbounds i8, ptr %0, i64 6544
  %wide.load349.12 = load <2 x double>, ptr %2659, align 8, !tbaa !5
  %wide.load350.12 = load <2 x double>, ptr %2660, align 8, !tbaa !5
  %2661 = getelementptr inbounds i8, ptr %1, i64 6528
  %2662 = getelementptr inbounds i8, ptr %1, i64 6544
  %wide.load351.12 = load <2 x double>, ptr %2661, align 8, !tbaa !5
  %wide.load352.12 = load <2 x double>, ptr %2662, align 8, !tbaa !5
  %2663 = fsub <2 x double> %wide.load349.12, %wide.load351.12
  %2664 = fsub <2 x double> %wide.load350.12, %wide.load352.12
  %2665 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2663)
  %2666 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2664)
  %2667 = fcmp ogt <2 x double> %2665, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2668 = fcmp ogt <2 x double> %2666, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2669 = zext <2 x i1> %2667 to <2 x i32>
  %2670 = or <2 x i32> %2657, %2669
  %2671 = or <2 x i1> %2658, %2668
  %2672 = getelementptr inbounds i8, ptr %0, i64 6560
  %2673 = getelementptr inbounds i8, ptr %0, i64 6576
  %wide.load349.13 = load <2 x double>, ptr %2672, align 8, !tbaa !5
  %wide.load350.13 = load <2 x double>, ptr %2673, align 8, !tbaa !5
  %2674 = getelementptr inbounds i8, ptr %1, i64 6560
  %2675 = getelementptr inbounds i8, ptr %1, i64 6576
  %wide.load351.13 = load <2 x double>, ptr %2674, align 8, !tbaa !5
  %wide.load352.13 = load <2 x double>, ptr %2675, align 8, !tbaa !5
  %2676 = fsub <2 x double> %wide.load349.13, %wide.load351.13
  %2677 = fsub <2 x double> %wide.load350.13, %wide.load352.13
  %2678 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2676)
  %2679 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2677)
  %2680 = fcmp ogt <2 x double> %2678, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2681 = fcmp ogt <2 x double> %2679, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2682 = zext <2 x i1> %2680 to <2 x i32>
  %2683 = or <2 x i32> %2670, %2682
  %2684 = or <2 x i1> %2671, %2681
  %2685 = getelementptr inbounds i8, ptr %0, i64 6592
  %2686 = getelementptr inbounds i8, ptr %0, i64 6608
  %wide.load349.14 = load <2 x double>, ptr %2685, align 8, !tbaa !5
  %wide.load350.14 = load <2 x double>, ptr %2686, align 8, !tbaa !5
  %2687 = getelementptr inbounds i8, ptr %1, i64 6592
  %2688 = getelementptr inbounds i8, ptr %1, i64 6608
  %wide.load351.14 = load <2 x double>, ptr %2687, align 8, !tbaa !5
  %wide.load352.14 = load <2 x double>, ptr %2688, align 8, !tbaa !5
  %2689 = fsub <2 x double> %wide.load349.14, %wide.load351.14
  %2690 = fsub <2 x double> %wide.load350.14, %wide.load352.14
  %2691 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2689)
  %2692 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2690)
  %2693 = fcmp ogt <2 x double> %2691, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2694 = fcmp ogt <2 x double> %2692, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2695 = zext <2 x i1> %2693 to <2 x i32>
  %2696 = or <2 x i32> %2683, %2695
  %2697 = or <2 x i1> %2684, %2694
  %2698 = getelementptr inbounds i8, ptr %0, i64 6624
  %2699 = getelementptr inbounds i8, ptr %0, i64 6640
  %wide.load349.15 = load <2 x double>, ptr %2698, align 8, !tbaa !5
  %wide.load350.15 = load <2 x double>, ptr %2699, align 8, !tbaa !5
  %2700 = getelementptr inbounds i8, ptr %1, i64 6624
  %2701 = getelementptr inbounds i8, ptr %1, i64 6640
  %wide.load351.15 = load <2 x double>, ptr %2700, align 8, !tbaa !5
  %wide.load352.15 = load <2 x double>, ptr %2701, align 8, !tbaa !5
  %2702 = fsub <2 x double> %wide.load349.15, %wide.load351.15
  %2703 = fsub <2 x double> %wide.load350.15, %wide.load352.15
  %2704 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2702)
  %2705 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2703)
  %2706 = fcmp ogt <2 x double> %2704, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2707 = fcmp ogt <2 x double> %2705, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2708 = zext <2 x i1> %2706 to <2 x i32>
  %2709 = or <2 x i32> %2696, %2708
  %2710 = or <2 x i1> %2697, %2707
  %2711 = zext <2 x i1> %2710 to <2 x i32>
  %bin.rdx354 = or <2 x i32> %2709, %2711
  %2712 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx354)
  %2713 = getelementptr inbounds i8, ptr %0, i64 6656
  %2714 = getelementptr inbounds i8, ptr %1, i64 6656
  br label %.preheader81

.preheader81:                                     ; preds = %.preheader83, %.preheader81
  %indvars.iv116 = phi i64 [ 0, %.preheader83 ], [ %indvars.iv.next117, %.preheader81 ]
  %.27390 = phi i32 [ %2712, %.preheader83 ], [ %2940, %.preheader81 ]
  %2715 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %.27390, i64 0
  %2716 = shl nuw nsw i64 %indvars.iv116, 6
  %2717 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2716
  %2718 = getelementptr inbounds i8, ptr %2717, i64 16
  %wide.load364 = load <2 x double>, ptr %2717, align 8, !tbaa !5
  %wide.load365 = load <2 x double>, ptr %2718, align 8, !tbaa !5
  %2719 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2716
  %2720 = getelementptr inbounds i8, ptr %2719, i64 16
  %wide.load366 = load <2 x double>, ptr %2719, align 8, !tbaa !5
  %wide.load367 = load <2 x double>, ptr %2720, align 8, !tbaa !5
  %2721 = fsub <2 x double> %wide.load364, %wide.load366
  %2722 = fsub <2 x double> %wide.load365, %wide.load367
  %2723 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2721)
  %2724 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2722)
  %2725 = fcmp ogt <2 x double> %2723, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2726 = fcmp ogt <2 x double> %2724, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2727 = zext <2 x i1> %2725 to <2 x i32>
  %2728 = or <2 x i32> %2715, %2727
  %2729 = or disjoint i64 %2716, 4
  %2730 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2729
  %2731 = getelementptr inbounds i8, ptr %2730, i64 16
  %wide.load364.1 = load <2 x double>, ptr %2730, align 8, !tbaa !5
  %wide.load365.1 = load <2 x double>, ptr %2731, align 8, !tbaa !5
  %2732 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2729
  %2733 = getelementptr inbounds i8, ptr %2732, i64 16
  %wide.load366.1 = load <2 x double>, ptr %2732, align 8, !tbaa !5
  %wide.load367.1 = load <2 x double>, ptr %2733, align 8, !tbaa !5
  %2734 = fsub <2 x double> %wide.load364.1, %wide.load366.1
  %2735 = fsub <2 x double> %wide.load365.1, %wide.load367.1
  %2736 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2734)
  %2737 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2735)
  %2738 = fcmp ogt <2 x double> %2736, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2739 = fcmp ogt <2 x double> %2737, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2740 = zext <2 x i1> %2738 to <2 x i32>
  %2741 = or <2 x i32> %2728, %2740
  %2742 = or <2 x i1> %2726, %2739
  %2743 = or disjoint i64 %2716, 8
  %2744 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2743
  %2745 = getelementptr inbounds i8, ptr %2744, i64 16
  %wide.load364.2 = load <2 x double>, ptr %2744, align 8, !tbaa !5
  %wide.load365.2 = load <2 x double>, ptr %2745, align 8, !tbaa !5
  %2746 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2743
  %2747 = getelementptr inbounds i8, ptr %2746, i64 16
  %wide.load366.2 = load <2 x double>, ptr %2746, align 8, !tbaa !5
  %wide.load367.2 = load <2 x double>, ptr %2747, align 8, !tbaa !5
  %2748 = fsub <2 x double> %wide.load364.2, %wide.load366.2
  %2749 = fsub <2 x double> %wide.load365.2, %wide.load367.2
  %2750 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2748)
  %2751 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2749)
  %2752 = fcmp ogt <2 x double> %2750, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2753 = fcmp ogt <2 x double> %2751, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2754 = zext <2 x i1> %2752 to <2 x i32>
  %2755 = or <2 x i32> %2741, %2754
  %2756 = or <2 x i1> %2742, %2753
  %2757 = or disjoint i64 %2716, 12
  %2758 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2757
  %2759 = getelementptr inbounds i8, ptr %2758, i64 16
  %wide.load364.3 = load <2 x double>, ptr %2758, align 8, !tbaa !5
  %wide.load365.3 = load <2 x double>, ptr %2759, align 8, !tbaa !5
  %2760 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2757
  %2761 = getelementptr inbounds i8, ptr %2760, i64 16
  %wide.load366.3 = load <2 x double>, ptr %2760, align 8, !tbaa !5
  %wide.load367.3 = load <2 x double>, ptr %2761, align 8, !tbaa !5
  %2762 = fsub <2 x double> %wide.load364.3, %wide.load366.3
  %2763 = fsub <2 x double> %wide.load365.3, %wide.load367.3
  %2764 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2762)
  %2765 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2763)
  %2766 = fcmp ogt <2 x double> %2764, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2767 = fcmp ogt <2 x double> %2765, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2768 = zext <2 x i1> %2766 to <2 x i32>
  %2769 = or <2 x i32> %2755, %2768
  %2770 = or <2 x i1> %2756, %2767
  %2771 = or disjoint i64 %2716, 16
  %2772 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2771
  %2773 = getelementptr inbounds i8, ptr %2772, i64 16
  %wide.load364.4 = load <2 x double>, ptr %2772, align 8, !tbaa !5
  %wide.load365.4 = load <2 x double>, ptr %2773, align 8, !tbaa !5
  %2774 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2771
  %2775 = getelementptr inbounds i8, ptr %2774, i64 16
  %wide.load366.4 = load <2 x double>, ptr %2774, align 8, !tbaa !5
  %wide.load367.4 = load <2 x double>, ptr %2775, align 8, !tbaa !5
  %2776 = fsub <2 x double> %wide.load364.4, %wide.load366.4
  %2777 = fsub <2 x double> %wide.load365.4, %wide.load367.4
  %2778 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2776)
  %2779 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2777)
  %2780 = fcmp ogt <2 x double> %2778, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2781 = fcmp ogt <2 x double> %2779, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2782 = zext <2 x i1> %2780 to <2 x i32>
  %2783 = or <2 x i32> %2769, %2782
  %2784 = or <2 x i1> %2770, %2781
  %2785 = or disjoint i64 %2716, 20
  %2786 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2785
  %2787 = getelementptr inbounds i8, ptr %2786, i64 16
  %wide.load364.5 = load <2 x double>, ptr %2786, align 8, !tbaa !5
  %wide.load365.5 = load <2 x double>, ptr %2787, align 8, !tbaa !5
  %2788 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2785
  %2789 = getelementptr inbounds i8, ptr %2788, i64 16
  %wide.load366.5 = load <2 x double>, ptr %2788, align 8, !tbaa !5
  %wide.load367.5 = load <2 x double>, ptr %2789, align 8, !tbaa !5
  %2790 = fsub <2 x double> %wide.load364.5, %wide.load366.5
  %2791 = fsub <2 x double> %wide.load365.5, %wide.load367.5
  %2792 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2790)
  %2793 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2791)
  %2794 = fcmp ogt <2 x double> %2792, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2795 = fcmp ogt <2 x double> %2793, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2796 = zext <2 x i1> %2794 to <2 x i32>
  %2797 = or <2 x i32> %2783, %2796
  %2798 = or <2 x i1> %2784, %2795
  %2799 = or disjoint i64 %2716, 24
  %2800 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2799
  %2801 = getelementptr inbounds i8, ptr %2800, i64 16
  %wide.load364.6 = load <2 x double>, ptr %2800, align 8, !tbaa !5
  %wide.load365.6 = load <2 x double>, ptr %2801, align 8, !tbaa !5
  %2802 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2799
  %2803 = getelementptr inbounds i8, ptr %2802, i64 16
  %wide.load366.6 = load <2 x double>, ptr %2802, align 8, !tbaa !5
  %wide.load367.6 = load <2 x double>, ptr %2803, align 8, !tbaa !5
  %2804 = fsub <2 x double> %wide.load364.6, %wide.load366.6
  %2805 = fsub <2 x double> %wide.load365.6, %wide.load367.6
  %2806 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2804)
  %2807 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2805)
  %2808 = fcmp ogt <2 x double> %2806, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2809 = fcmp ogt <2 x double> %2807, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2810 = zext <2 x i1> %2808 to <2 x i32>
  %2811 = or <2 x i32> %2797, %2810
  %2812 = or <2 x i1> %2798, %2809
  %2813 = or disjoint i64 %2716, 28
  %2814 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2813
  %2815 = getelementptr inbounds i8, ptr %2814, i64 16
  %wide.load364.7 = load <2 x double>, ptr %2814, align 8, !tbaa !5
  %wide.load365.7 = load <2 x double>, ptr %2815, align 8, !tbaa !5
  %2816 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2813
  %2817 = getelementptr inbounds i8, ptr %2816, i64 16
  %wide.load366.7 = load <2 x double>, ptr %2816, align 8, !tbaa !5
  %wide.load367.7 = load <2 x double>, ptr %2817, align 8, !tbaa !5
  %2818 = fsub <2 x double> %wide.load364.7, %wide.load366.7
  %2819 = fsub <2 x double> %wide.load365.7, %wide.load367.7
  %2820 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2818)
  %2821 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2819)
  %2822 = fcmp ogt <2 x double> %2820, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2823 = fcmp ogt <2 x double> %2821, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2824 = zext <2 x i1> %2822 to <2 x i32>
  %2825 = or <2 x i32> %2811, %2824
  %2826 = or <2 x i1> %2812, %2823
  %2827 = or disjoint i64 %2716, 32
  %2828 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2827
  %2829 = getelementptr inbounds i8, ptr %2828, i64 16
  %wide.load364.8 = load <2 x double>, ptr %2828, align 8, !tbaa !5
  %wide.load365.8 = load <2 x double>, ptr %2829, align 8, !tbaa !5
  %2830 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2827
  %2831 = getelementptr inbounds i8, ptr %2830, i64 16
  %wide.load366.8 = load <2 x double>, ptr %2830, align 8, !tbaa !5
  %wide.load367.8 = load <2 x double>, ptr %2831, align 8, !tbaa !5
  %2832 = fsub <2 x double> %wide.load364.8, %wide.load366.8
  %2833 = fsub <2 x double> %wide.load365.8, %wide.load367.8
  %2834 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2832)
  %2835 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2833)
  %2836 = fcmp ogt <2 x double> %2834, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2837 = fcmp ogt <2 x double> %2835, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2838 = zext <2 x i1> %2836 to <2 x i32>
  %2839 = or <2 x i32> %2825, %2838
  %2840 = or <2 x i1> %2826, %2837
  %2841 = or disjoint i64 %2716, 36
  %2842 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2841
  %2843 = getelementptr inbounds i8, ptr %2842, i64 16
  %wide.load364.9 = load <2 x double>, ptr %2842, align 8, !tbaa !5
  %wide.load365.9 = load <2 x double>, ptr %2843, align 8, !tbaa !5
  %2844 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2841
  %2845 = getelementptr inbounds i8, ptr %2844, i64 16
  %wide.load366.9 = load <2 x double>, ptr %2844, align 8, !tbaa !5
  %wide.load367.9 = load <2 x double>, ptr %2845, align 8, !tbaa !5
  %2846 = fsub <2 x double> %wide.load364.9, %wide.load366.9
  %2847 = fsub <2 x double> %wide.load365.9, %wide.load367.9
  %2848 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2846)
  %2849 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2847)
  %2850 = fcmp ogt <2 x double> %2848, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2851 = fcmp ogt <2 x double> %2849, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2852 = zext <2 x i1> %2850 to <2 x i32>
  %2853 = or <2 x i32> %2839, %2852
  %2854 = or <2 x i1> %2840, %2851
  %2855 = or disjoint i64 %2716, 40
  %2856 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2855
  %2857 = getelementptr inbounds i8, ptr %2856, i64 16
  %wide.load364.10 = load <2 x double>, ptr %2856, align 8, !tbaa !5
  %wide.load365.10 = load <2 x double>, ptr %2857, align 8, !tbaa !5
  %2858 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2855
  %2859 = getelementptr inbounds i8, ptr %2858, i64 16
  %wide.load366.10 = load <2 x double>, ptr %2858, align 8, !tbaa !5
  %wide.load367.10 = load <2 x double>, ptr %2859, align 8, !tbaa !5
  %2860 = fsub <2 x double> %wide.load364.10, %wide.load366.10
  %2861 = fsub <2 x double> %wide.load365.10, %wide.load367.10
  %2862 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2860)
  %2863 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2861)
  %2864 = fcmp ogt <2 x double> %2862, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2865 = fcmp ogt <2 x double> %2863, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2866 = zext <2 x i1> %2864 to <2 x i32>
  %2867 = or <2 x i32> %2853, %2866
  %2868 = or <2 x i1> %2854, %2865
  %2869 = or disjoint i64 %2716, 44
  %2870 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2869
  %2871 = getelementptr inbounds i8, ptr %2870, i64 16
  %wide.load364.11 = load <2 x double>, ptr %2870, align 8, !tbaa !5
  %wide.load365.11 = load <2 x double>, ptr %2871, align 8, !tbaa !5
  %2872 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2869
  %2873 = getelementptr inbounds i8, ptr %2872, i64 16
  %wide.load366.11 = load <2 x double>, ptr %2872, align 8, !tbaa !5
  %wide.load367.11 = load <2 x double>, ptr %2873, align 8, !tbaa !5
  %2874 = fsub <2 x double> %wide.load364.11, %wide.load366.11
  %2875 = fsub <2 x double> %wide.load365.11, %wide.load367.11
  %2876 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2874)
  %2877 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2875)
  %2878 = fcmp ogt <2 x double> %2876, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2879 = fcmp ogt <2 x double> %2877, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2880 = zext <2 x i1> %2878 to <2 x i32>
  %2881 = or <2 x i32> %2867, %2880
  %2882 = or <2 x i1> %2868, %2879
  %2883 = or disjoint i64 %2716, 48
  %2884 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2883
  %2885 = getelementptr inbounds i8, ptr %2884, i64 16
  %wide.load364.12 = load <2 x double>, ptr %2884, align 8, !tbaa !5
  %wide.load365.12 = load <2 x double>, ptr %2885, align 8, !tbaa !5
  %2886 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2883
  %2887 = getelementptr inbounds i8, ptr %2886, i64 16
  %wide.load366.12 = load <2 x double>, ptr %2886, align 8, !tbaa !5
  %wide.load367.12 = load <2 x double>, ptr %2887, align 8, !tbaa !5
  %2888 = fsub <2 x double> %wide.load364.12, %wide.load366.12
  %2889 = fsub <2 x double> %wide.load365.12, %wide.load367.12
  %2890 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2888)
  %2891 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2889)
  %2892 = fcmp ogt <2 x double> %2890, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2893 = fcmp ogt <2 x double> %2891, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2894 = zext <2 x i1> %2892 to <2 x i32>
  %2895 = or <2 x i32> %2881, %2894
  %2896 = or <2 x i1> %2882, %2893
  %2897 = or disjoint i64 %2716, 52
  %2898 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2897
  %2899 = getelementptr inbounds i8, ptr %2898, i64 16
  %wide.load364.13 = load <2 x double>, ptr %2898, align 8, !tbaa !5
  %wide.load365.13 = load <2 x double>, ptr %2899, align 8, !tbaa !5
  %2900 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2897
  %2901 = getelementptr inbounds i8, ptr %2900, i64 16
  %wide.load366.13 = load <2 x double>, ptr %2900, align 8, !tbaa !5
  %wide.load367.13 = load <2 x double>, ptr %2901, align 8, !tbaa !5
  %2902 = fsub <2 x double> %wide.load364.13, %wide.load366.13
  %2903 = fsub <2 x double> %wide.load365.13, %wide.load367.13
  %2904 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2902)
  %2905 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2903)
  %2906 = fcmp ogt <2 x double> %2904, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2907 = fcmp ogt <2 x double> %2905, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2908 = zext <2 x i1> %2906 to <2 x i32>
  %2909 = or <2 x i32> %2895, %2908
  %2910 = or <2 x i1> %2896, %2907
  %2911 = or disjoint i64 %2716, 56
  %2912 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2911
  %2913 = getelementptr inbounds i8, ptr %2912, i64 16
  %wide.load364.14 = load <2 x double>, ptr %2912, align 8, !tbaa !5
  %wide.load365.14 = load <2 x double>, ptr %2913, align 8, !tbaa !5
  %2914 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2911
  %2915 = getelementptr inbounds i8, ptr %2914, i64 16
  %wide.load366.14 = load <2 x double>, ptr %2914, align 8, !tbaa !5
  %wide.load367.14 = load <2 x double>, ptr %2915, align 8, !tbaa !5
  %2916 = fsub <2 x double> %wide.load364.14, %wide.load366.14
  %2917 = fsub <2 x double> %wide.load365.14, %wide.load367.14
  %2918 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2916)
  %2919 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2917)
  %2920 = fcmp ogt <2 x double> %2918, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2921 = fcmp ogt <2 x double> %2919, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2922 = zext <2 x i1> %2920 to <2 x i32>
  %2923 = or <2 x i32> %2909, %2922
  %2924 = or <2 x i1> %2910, %2921
  %2925 = or disjoint i64 %2716, 60
  %2926 = getelementptr inbounds [4096 x double], ptr %2713, i64 0, i64 %2925
  %2927 = getelementptr inbounds i8, ptr %2926, i64 16
  %wide.load364.15 = load <2 x double>, ptr %2926, align 8, !tbaa !5
  %wide.load365.15 = load <2 x double>, ptr %2927, align 8, !tbaa !5
  %2928 = getelementptr inbounds [4096 x double], ptr %2714, i64 0, i64 %2925
  %2929 = getelementptr inbounds i8, ptr %2928, i64 16
  %wide.load366.15 = load <2 x double>, ptr %2928, align 8, !tbaa !5
  %wide.load367.15 = load <2 x double>, ptr %2929, align 8, !tbaa !5
  %2930 = fsub <2 x double> %wide.load364.15, %wide.load366.15
  %2931 = fsub <2 x double> %wide.load365.15, %wide.load367.15
  %2932 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2930)
  %2933 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2931)
  %2934 = fcmp ogt <2 x double> %2932, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2935 = fcmp ogt <2 x double> %2933, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2936 = zext <2 x i1> %2934 to <2 x i32>
  %2937 = or <2 x i32> %2923, %2936
  %2938 = or <2 x i1> %2924, %2935
  %2939 = zext <2 x i1> %2938 to <2 x i32>
  %bin.rdx369 = or <2 x i32> %2937, %2939
  %2940 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx369)
  %indvars.iv.next117 = add nuw nsw i64 %indvars.iv116, 1
  %exitcond119.not = icmp eq i64 %indvars.iv.next117, 64
  br i1 %exitcond119.not, label %.preheader80, label %.preheader81, !llvm.loop !9

.preheader80:                                     ; preds = %.preheader81
  %2941 = getelementptr inbounds i8, ptr %0, i64 39424
  %2942 = getelementptr inbounds i8, ptr %1, i64 39424
  %2943 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %2940, i64 0
  br label %vector.body375

vector.body375:                                   ; preds = %vector.body375, %.preheader80
  %index376 = phi i64 [ 0, %.preheader80 ], [ %index.next393, %vector.body375 ]
  %vec.phi377 = phi <2 x i32> [ %2943, %.preheader80 ], [ %2985, %vector.body375 ]
  %vec.phi378 = phi <2 x i32> [ zeroinitializer, %.preheader80 ], [ %2986, %vector.body375 ]
  %2944 = mul nuw nsw i64 %index376, 3
  %2945 = mul nuw i64 %index376, 3
  %2946 = add nuw i64 %2945, 6
  %2947 = getelementptr inbounds [192 x double], ptr %2941, i64 0, i64 %2944
  %2948 = getelementptr inbounds [192 x double], ptr %2941, i64 0, i64 %2946
  %wide.vec = load <6 x double>, ptr %2947, align 8, !tbaa !5
  %wide.vec379 = load <6 x double>, ptr %2948, align 8, !tbaa !5
  %2949 = getelementptr inbounds [192 x double], ptr %2942, i64 0, i64 %2944
  %2950 = getelementptr inbounds [192 x double], ptr %2942, i64 0, i64 %2946
  %wide.vec385 = load <6 x double>, ptr %2949, align 8, !tbaa !5
  %wide.vec386 = load <6 x double>, ptr %2950, align 8, !tbaa !5
  %2951 = fsub <6 x double> %wide.vec, %wide.vec385
  %2952 = shufflevector <6 x double> %2951, <6 x double> poison, <2 x i32> <i32 0, i32 3>
  %2953 = fsub <6 x double> %wide.vec379, %wide.vec386
  %2954 = shufflevector <6 x double> %2953, <6 x double> poison, <2 x i32> <i32 0, i32 3>
  %2955 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2952)
  %2956 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2954)
  %2957 = fcmp ogt <2 x double> %2955, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2958 = fcmp ogt <2 x double> %2956, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2959 = zext <2 x i1> %2957 to <2 x i32>
  %2960 = zext <2 x i1> %2958 to <2 x i32>
  %2961 = or <2 x i32> %vec.phi377, %2959
  %2962 = or <2 x i32> %vec.phi378, %2960
  %2963 = fsub <6 x double> %wide.vec, %wide.vec385
  %2964 = shufflevector <6 x double> %2963, <6 x double> poison, <2 x i32> <i32 1, i32 4>
  %2965 = fsub <6 x double> %wide.vec379, %wide.vec386
  %2966 = shufflevector <6 x double> %2965, <6 x double> poison, <2 x i32> <i32 1, i32 4>
  %2967 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2964)
  %2968 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2966)
  %2969 = fcmp ogt <2 x double> %2967, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2970 = fcmp ogt <2 x double> %2968, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2971 = zext <2 x i1> %2969 to <2 x i32>
  %2972 = zext <2 x i1> %2970 to <2 x i32>
  %2973 = or <2 x i32> %2961, %2971
  %2974 = or <2 x i32> %2962, %2972
  %2975 = fsub <6 x double> %wide.vec, %wide.vec385
  %2976 = shufflevector <6 x double> %2975, <6 x double> poison, <2 x i32> <i32 2, i32 5>
  %2977 = fsub <6 x double> %wide.vec379, %wide.vec386
  %2978 = shufflevector <6 x double> %2977, <6 x double> poison, <2 x i32> <i32 2, i32 5>
  %2979 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2976)
  %2980 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2978)
  %2981 = fcmp ogt <2 x double> %2979, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2982 = fcmp ogt <2 x double> %2980, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2983 = zext <2 x i1> %2981 to <2 x i32>
  %2984 = zext <2 x i1> %2982 to <2 x i32>
  %2985 = or <2 x i32> %2973, %2983
  %2986 = or <2 x i32> %2974, %2984
  %index.next393 = add nuw i64 %index376, 4
  %2987 = icmp eq i64 %index.next393, 64
  br i1 %2987, label %vector.body415, label %vector.body375, !llvm.loop !11

vector.body415:                                   ; preds = %vector.body375
  %bin.rdx394 = or <2 x i32> %2986, %2985
  %2988 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx394)
  %2989 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %2988, i64 0
  %2990 = getelementptr inbounds i8, ptr %0, i64 40960
  %wide.load404 = load <2 x double>, ptr %2990, align 8, !tbaa !5
  %2991 = getelementptr inbounds i8, ptr %1, i64 40960
  %wide.load406 = load <2 x double>, ptr %2991, align 8, !tbaa !5
  %2992 = fsub <2 x double> %wide.load404, %wide.load406
  %2993 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2992)
  %2994 = fcmp ogt <2 x double> %2993, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %2995 = zext <2 x i1> %2994 to <2 x i32>
  %2996 = or <2 x i32> %2989, %2995
  %2997 = getelementptr inbounds i8, ptr %0, i64 40992
  %wide.load404.1 = load <2 x double>, ptr %2997, align 8, !tbaa !5
  %2998 = getelementptr inbounds i8, ptr %1, i64 40992
  %wide.load406.1 = load <2 x double>, ptr %2998, align 8, !tbaa !5
  %2999 = fsub <2 x double> %wide.load404.1, %wide.load406.1
  %3000 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %2999)
  %3001 = fcmp ogt <2 x double> %3000, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3002 = zext <2 x i1> %3001 to <2 x i32>
  %3003 = or <2 x i32> %2996, %3002
  %3004 = getelementptr inbounds i8, ptr %0, i64 41024
  %wide.load404.2 = load <2 x double>, ptr %3004, align 8, !tbaa !5
  %3005 = getelementptr inbounds i8, ptr %1, i64 41024
  %wide.load406.2 = load <2 x double>, ptr %3005, align 8, !tbaa !5
  %3006 = fsub <2 x double> %wide.load404.2, %wide.load406.2
  %3007 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3006)
  %3008 = fcmp ogt <2 x double> %3007, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3009 = zext <2 x i1> %3008 to <2 x i32>
  %3010 = or <2 x i32> %3003, %3009
  %3011 = getelementptr inbounds i8, ptr %0, i64 41056
  %wide.load404.3 = load <2 x double>, ptr %3011, align 8, !tbaa !5
  %3012 = getelementptr inbounds i8, ptr %1, i64 41056
  %wide.load406.3 = load <2 x double>, ptr %3012, align 8, !tbaa !5
  %3013 = fsub <2 x double> %wide.load404.3, %wide.load406.3
  %3014 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3013)
  %3015 = fcmp ogt <2 x double> %3014, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3016 = zext <2 x i1> %3015 to <2 x i32>
  %3017 = or <2 x i32> %3010, %3016
  %3018 = getelementptr inbounds i8, ptr %0, i64 41088
  %wide.load404.4 = load <2 x double>, ptr %3018, align 8, !tbaa !5
  %3019 = getelementptr inbounds i8, ptr %1, i64 41088
  %wide.load406.4 = load <2 x double>, ptr %3019, align 8, !tbaa !5
  %3020 = fsub <2 x double> %wide.load404.4, %wide.load406.4
  %3021 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3020)
  %3022 = fcmp ogt <2 x double> %3021, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3023 = zext <2 x i1> %3022 to <2 x i32>
  %3024 = or <2 x i32> %3017, %3023
  %3025 = getelementptr inbounds i8, ptr %0, i64 41120
  %wide.load404.5 = load <2 x double>, ptr %3025, align 8, !tbaa !5
  %3026 = getelementptr inbounds i8, ptr %1, i64 41120
  %wide.load406.5 = load <2 x double>, ptr %3026, align 8, !tbaa !5
  %3027 = fsub <2 x double> %wide.load404.5, %wide.load406.5
  %3028 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3027)
  %3029 = fcmp ogt <2 x double> %3028, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3030 = zext <2 x i1> %3029 to <2 x i32>
  %3031 = or <2 x i32> %3024, %3030
  %3032 = getelementptr inbounds i8, ptr %0, i64 41152
  %wide.load404.6 = load <2 x double>, ptr %3032, align 8, !tbaa !5
  %3033 = getelementptr inbounds i8, ptr %1, i64 41152
  %wide.load406.6 = load <2 x double>, ptr %3033, align 8, !tbaa !5
  %3034 = fsub <2 x double> %wide.load404.6, %wide.load406.6
  %3035 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3034)
  %3036 = fcmp ogt <2 x double> %3035, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3037 = zext <2 x i1> %3036 to <2 x i32>
  %3038 = or <2 x i32> %3031, %3037
  %3039 = getelementptr inbounds i8, ptr %0, i64 41184
  %wide.load404.7 = load <2 x double>, ptr %3039, align 8, !tbaa !5
  %3040 = getelementptr inbounds i8, ptr %1, i64 41184
  %wide.load406.7 = load <2 x double>, ptr %3040, align 8, !tbaa !5
  %3041 = fsub <2 x double> %wide.load404.7, %wide.load406.7
  %3042 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3041)
  %3043 = fcmp ogt <2 x double> %3042, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3044 = zext <2 x i1> %3043 to <2 x i32>
  %3045 = or <2 x i32> %3038, %3044
  %3046 = getelementptr inbounds i8, ptr %0, i64 41216
  %wide.load404.8 = load <2 x double>, ptr %3046, align 8, !tbaa !5
  %3047 = getelementptr inbounds i8, ptr %1, i64 41216
  %wide.load406.8 = load <2 x double>, ptr %3047, align 8, !tbaa !5
  %3048 = fsub <2 x double> %wide.load404.8, %wide.load406.8
  %3049 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3048)
  %3050 = fcmp ogt <2 x double> %3049, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3051 = zext <2 x i1> %3050 to <2 x i32>
  %3052 = or <2 x i32> %3045, %3051
  %3053 = getelementptr inbounds i8, ptr %0, i64 41248
  %wide.load404.9 = load <2 x double>, ptr %3053, align 8, !tbaa !5
  %3054 = getelementptr inbounds i8, ptr %1, i64 41248
  %wide.load406.9 = load <2 x double>, ptr %3054, align 8, !tbaa !5
  %3055 = fsub <2 x double> %wide.load404.9, %wide.load406.9
  %3056 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3055)
  %3057 = fcmp ogt <2 x double> %3056, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3058 = zext <2 x i1> %3057 to <2 x i32>
  %3059 = or <2 x i32> %3052, %3058
  %3060 = getelementptr inbounds i8, ptr %0, i64 41280
  %wide.load404.10 = load <2 x double>, ptr %3060, align 8, !tbaa !5
  %3061 = getelementptr inbounds i8, ptr %1, i64 41280
  %wide.load406.10 = load <2 x double>, ptr %3061, align 8, !tbaa !5
  %3062 = fsub <2 x double> %wide.load404.10, %wide.load406.10
  %3063 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3062)
  %3064 = fcmp ogt <2 x double> %3063, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3065 = zext <2 x i1> %3064 to <2 x i32>
  %3066 = or <2 x i32> %3059, %3065
  %3067 = getelementptr inbounds i8, ptr %0, i64 41312
  %wide.load404.11 = load <2 x double>, ptr %3067, align 8, !tbaa !5
  %3068 = getelementptr inbounds i8, ptr %1, i64 41312
  %wide.load406.11 = load <2 x double>, ptr %3068, align 8, !tbaa !5
  %3069 = fsub <2 x double> %wide.load404.11, %wide.load406.11
  %3070 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3069)
  %3071 = fcmp ogt <2 x double> %3070, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3072 = zext <2 x i1> %3071 to <2 x i32>
  %3073 = or <2 x i32> %3066, %3072
  %3074 = getelementptr inbounds i8, ptr %0, i64 41344
  %wide.load404.12 = load <2 x double>, ptr %3074, align 8, !tbaa !5
  %3075 = getelementptr inbounds i8, ptr %1, i64 41344
  %wide.load406.12 = load <2 x double>, ptr %3075, align 8, !tbaa !5
  %3076 = fsub <2 x double> %wide.load404.12, %wide.load406.12
  %3077 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3076)
  %3078 = fcmp ogt <2 x double> %3077, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3079 = zext <2 x i1> %3078 to <2 x i32>
  %3080 = or <2 x i32> %3073, %3079
  %3081 = getelementptr inbounds i8, ptr %0, i64 41376
  %wide.load404.13 = load <2 x double>, ptr %3081, align 8, !tbaa !5
  %3082 = getelementptr inbounds i8, ptr %1, i64 41376
  %wide.load406.13 = load <2 x double>, ptr %3082, align 8, !tbaa !5
  %3083 = fsub <2 x double> %wide.load404.13, %wide.load406.13
  %3084 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3083)
  %3085 = fcmp ogt <2 x double> %3084, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3086 = zext <2 x i1> %3085 to <2 x i32>
  %3087 = or <2 x i32> %3080, %3086
  %3088 = getelementptr inbounds i8, ptr %0, i64 41408
  %wide.load404.14 = load <2 x double>, ptr %3088, align 8, !tbaa !5
  %3089 = getelementptr inbounds i8, ptr %1, i64 41408
  %wide.load406.14 = load <2 x double>, ptr %3089, align 8, !tbaa !5
  %3090 = fsub <2 x double> %wide.load404.14, %wide.load406.14
  %3091 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3090)
  %3092 = fcmp ogt <2 x double> %3091, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3093 = zext <2 x i1> %3092 to <2 x i32>
  %3094 = or <2 x i32> %3087, %3093
  %3095 = getelementptr inbounds i8, ptr %0, i64 41440
  %wide.load404.15 = load <2 x double>, ptr %3095, align 8, !tbaa !5
  %3096 = getelementptr inbounds i8, ptr %1, i64 41440
  %wide.load406.15 = load <2 x double>, ptr %3096, align 8, !tbaa !5
  %3097 = fsub <2 x double> %wide.load404.15, %wide.load406.15
  %3098 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3097)
  %3099 = fcmp ogt <2 x double> %3098, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3100 = zext <2 x i1> %3099 to <2 x i32>
  %3101 = or <2 x i32> %3094, %3100
  %3102 = getelementptr inbounds i8, ptr %0, i64 40976
  %wide.load405 = load <2 x double>, ptr %3102, align 8, !tbaa !5
  %3103 = getelementptr inbounds i8, ptr %1, i64 40976
  %wide.load407 = load <2 x double>, ptr %3103, align 8, !tbaa !5
  %3104 = fsub <2 x double> %wide.load405, %wide.load407
  %3105 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3104)
  %3106 = fcmp ogt <2 x double> %3105, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3107 = getelementptr inbounds i8, ptr %0, i64 41008
  %wide.load405.1 = load <2 x double>, ptr %3107, align 8, !tbaa !5
  %3108 = getelementptr inbounds i8, ptr %1, i64 41008
  %wide.load407.1 = load <2 x double>, ptr %3108, align 8, !tbaa !5
  %3109 = fsub <2 x double> %wide.load405.1, %wide.load407.1
  %3110 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3109)
  %3111 = fcmp ogt <2 x double> %3110, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3112 = or <2 x i1> %3106, %3111
  %3113 = getelementptr inbounds i8, ptr %0, i64 41040
  %wide.load405.2 = load <2 x double>, ptr %3113, align 8, !tbaa !5
  %3114 = getelementptr inbounds i8, ptr %1, i64 41040
  %wide.load407.2 = load <2 x double>, ptr %3114, align 8, !tbaa !5
  %3115 = fsub <2 x double> %wide.load405.2, %wide.load407.2
  %3116 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3115)
  %3117 = fcmp ogt <2 x double> %3116, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3118 = or <2 x i1> %3112, %3117
  %3119 = getelementptr inbounds i8, ptr %0, i64 41072
  %wide.load405.3 = load <2 x double>, ptr %3119, align 8, !tbaa !5
  %3120 = getelementptr inbounds i8, ptr %1, i64 41072
  %wide.load407.3 = load <2 x double>, ptr %3120, align 8, !tbaa !5
  %3121 = fsub <2 x double> %wide.load405.3, %wide.load407.3
  %3122 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3121)
  %3123 = fcmp ogt <2 x double> %3122, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3124 = or <2 x i1> %3118, %3123
  %3125 = getelementptr inbounds i8, ptr %0, i64 41104
  %wide.load405.4 = load <2 x double>, ptr %3125, align 8, !tbaa !5
  %3126 = getelementptr inbounds i8, ptr %1, i64 41104
  %wide.load407.4 = load <2 x double>, ptr %3126, align 8, !tbaa !5
  %3127 = fsub <2 x double> %wide.load405.4, %wide.load407.4
  %3128 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3127)
  %3129 = fcmp ogt <2 x double> %3128, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3130 = or <2 x i1> %3124, %3129
  %3131 = getelementptr inbounds i8, ptr %0, i64 41136
  %wide.load405.5 = load <2 x double>, ptr %3131, align 8, !tbaa !5
  %3132 = getelementptr inbounds i8, ptr %1, i64 41136
  %wide.load407.5 = load <2 x double>, ptr %3132, align 8, !tbaa !5
  %3133 = fsub <2 x double> %wide.load405.5, %wide.load407.5
  %3134 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3133)
  %3135 = fcmp ogt <2 x double> %3134, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3136 = or <2 x i1> %3130, %3135
  %3137 = getelementptr inbounds i8, ptr %0, i64 41168
  %wide.load405.6 = load <2 x double>, ptr %3137, align 8, !tbaa !5
  %3138 = getelementptr inbounds i8, ptr %1, i64 41168
  %wide.load407.6 = load <2 x double>, ptr %3138, align 8, !tbaa !5
  %3139 = fsub <2 x double> %wide.load405.6, %wide.load407.6
  %3140 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3139)
  %3141 = fcmp ogt <2 x double> %3140, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3142 = or <2 x i1> %3136, %3141
  %3143 = getelementptr inbounds i8, ptr %0, i64 41200
  %wide.load405.7 = load <2 x double>, ptr %3143, align 8, !tbaa !5
  %3144 = getelementptr inbounds i8, ptr %1, i64 41200
  %wide.load407.7 = load <2 x double>, ptr %3144, align 8, !tbaa !5
  %3145 = fsub <2 x double> %wide.load405.7, %wide.load407.7
  %3146 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3145)
  %3147 = fcmp ogt <2 x double> %3146, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3148 = or <2 x i1> %3142, %3147
  %3149 = getelementptr inbounds i8, ptr %0, i64 41232
  %wide.load405.8 = load <2 x double>, ptr %3149, align 8, !tbaa !5
  %3150 = getelementptr inbounds i8, ptr %1, i64 41232
  %wide.load407.8 = load <2 x double>, ptr %3150, align 8, !tbaa !5
  %3151 = fsub <2 x double> %wide.load405.8, %wide.load407.8
  %3152 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3151)
  %3153 = fcmp ogt <2 x double> %3152, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3154 = or <2 x i1> %3148, %3153
  %3155 = getelementptr inbounds i8, ptr %0, i64 41264
  %wide.load405.9 = load <2 x double>, ptr %3155, align 8, !tbaa !5
  %3156 = getelementptr inbounds i8, ptr %1, i64 41264
  %wide.load407.9 = load <2 x double>, ptr %3156, align 8, !tbaa !5
  %3157 = fsub <2 x double> %wide.load405.9, %wide.load407.9
  %3158 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3157)
  %3159 = fcmp ogt <2 x double> %3158, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3160 = or <2 x i1> %3154, %3159
  %3161 = getelementptr inbounds i8, ptr %0, i64 41296
  %wide.load405.10 = load <2 x double>, ptr %3161, align 8, !tbaa !5
  %3162 = getelementptr inbounds i8, ptr %1, i64 41296
  %wide.load407.10 = load <2 x double>, ptr %3162, align 8, !tbaa !5
  %3163 = fsub <2 x double> %wide.load405.10, %wide.load407.10
  %3164 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3163)
  %3165 = fcmp ogt <2 x double> %3164, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3166 = or <2 x i1> %3160, %3165
  %3167 = getelementptr inbounds i8, ptr %0, i64 41328
  %wide.load405.11 = load <2 x double>, ptr %3167, align 8, !tbaa !5
  %3168 = getelementptr inbounds i8, ptr %1, i64 41328
  %wide.load407.11 = load <2 x double>, ptr %3168, align 8, !tbaa !5
  %3169 = fsub <2 x double> %wide.load405.11, %wide.load407.11
  %3170 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3169)
  %3171 = fcmp ogt <2 x double> %3170, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3172 = or <2 x i1> %3166, %3171
  %3173 = getelementptr inbounds i8, ptr %0, i64 41360
  %wide.load405.12 = load <2 x double>, ptr %3173, align 8, !tbaa !5
  %3174 = getelementptr inbounds i8, ptr %1, i64 41360
  %wide.load407.12 = load <2 x double>, ptr %3174, align 8, !tbaa !5
  %3175 = fsub <2 x double> %wide.load405.12, %wide.load407.12
  %3176 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3175)
  %3177 = fcmp ogt <2 x double> %3176, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3178 = or <2 x i1> %3172, %3177
  %3179 = getelementptr inbounds i8, ptr %0, i64 41392
  %wide.load405.13 = load <2 x double>, ptr %3179, align 8, !tbaa !5
  %3180 = getelementptr inbounds i8, ptr %1, i64 41392
  %wide.load407.13 = load <2 x double>, ptr %3180, align 8, !tbaa !5
  %3181 = fsub <2 x double> %wide.load405.13, %wide.load407.13
  %3182 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3181)
  %3183 = fcmp ogt <2 x double> %3182, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3184 = or <2 x i1> %3178, %3183
  %3185 = getelementptr inbounds i8, ptr %0, i64 41424
  %wide.load405.14 = load <2 x double>, ptr %3185, align 8, !tbaa !5
  %3186 = getelementptr inbounds i8, ptr %1, i64 41424
  %wide.load407.14 = load <2 x double>, ptr %3186, align 8, !tbaa !5
  %3187 = fsub <2 x double> %wide.load405.14, %wide.load407.14
  %3188 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3187)
  %3189 = fcmp ogt <2 x double> %3188, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3190 = or <2 x i1> %3184, %3189
  %3191 = getelementptr inbounds i8, ptr %0, i64 41456
  %wide.load405.15 = load <2 x double>, ptr %3191, align 8, !tbaa !5
  %3192 = getelementptr inbounds i8, ptr %1, i64 41456
  %wide.load407.15 = load <2 x double>, ptr %3192, align 8, !tbaa !5
  %3193 = fsub <2 x double> %wide.load405.15, %wide.load407.15
  %3194 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3193)
  %3195 = fcmp ogt <2 x double> %3194, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3196 = or <2 x i1> %3190, %3195
  %3197 = zext <2 x i1> %3196 to <2 x i32>
  %bin.rdx409 = or <2 x i32> %3101, %3197
  %3198 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx409)
  %3199 = insertelement <2 x i32> <i32 poison, i32 0>, i32 %3198, i64 0
  %3200 = getelementptr inbounds i8, ptr %1, i64 41472
  %3201 = getelementptr inbounds i8, ptr %0, i64 41472
  %3202 = getelementptr inbounds i8, ptr %0, i64 41488
  %wide.load419 = load <2 x double>, ptr %3201, align 8, !tbaa !5
  %wide.load420 = load <2 x double>, ptr %3202, align 8, !tbaa !5
  %3203 = getelementptr inbounds i8, ptr %1, i64 41488
  %wide.load421 = load <2 x double>, ptr %3200, align 8, !tbaa !5
  %wide.load422 = load <2 x double>, ptr %3203, align 8, !tbaa !5
  %3204 = fsub <2 x double> %wide.load419, %wide.load421
  %3205 = fsub <2 x double> %wide.load420, %wide.load422
  %3206 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3204)
  %3207 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3205)
  %3208 = fcmp ogt <2 x double> %3206, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3209 = fcmp ogt <2 x double> %3207, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3210 = zext <2 x i1> %3208 to <2 x i32>
  %3211 = or <2 x i32> %3199, %3210
  %3212 = getelementptr inbounds i8, ptr %0, i64 41504
  %3213 = getelementptr inbounds i8, ptr %0, i64 41520
  %wide.load419.1 = load <2 x double>, ptr %3212, align 8, !tbaa !5
  %wide.load420.1 = load <2 x double>, ptr %3213, align 8, !tbaa !5
  %3214 = getelementptr inbounds i8, ptr %1, i64 41504
  %3215 = getelementptr inbounds i8, ptr %1, i64 41520
  %wide.load421.1 = load <2 x double>, ptr %3214, align 8, !tbaa !5
  %wide.load422.1 = load <2 x double>, ptr %3215, align 8, !tbaa !5
  %3216 = fsub <2 x double> %wide.load419.1, %wide.load421.1
  %3217 = fsub <2 x double> %wide.load420.1, %wide.load422.1
  %3218 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3216)
  %3219 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3217)
  %3220 = fcmp ogt <2 x double> %3218, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3221 = fcmp ogt <2 x double> %3219, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3222 = zext <2 x i1> %3220 to <2 x i32>
  %3223 = or <2 x i32> %3211, %3222
  %3224 = or <2 x i1> %3209, %3221
  %3225 = getelementptr inbounds i8, ptr %0, i64 41536
  %3226 = getelementptr inbounds i8, ptr %0, i64 41552
  %wide.load419.2 = load <2 x double>, ptr %3225, align 8, !tbaa !5
  %wide.load420.2 = load <2 x double>, ptr %3226, align 8, !tbaa !5
  %3227 = getelementptr inbounds i8, ptr %1, i64 41536
  %3228 = getelementptr inbounds i8, ptr %1, i64 41552
  %wide.load421.2 = load <2 x double>, ptr %3227, align 8, !tbaa !5
  %wide.load422.2 = load <2 x double>, ptr %3228, align 8, !tbaa !5
  %3229 = fsub <2 x double> %wide.load419.2, %wide.load421.2
  %3230 = fsub <2 x double> %wide.load420.2, %wide.load422.2
  %3231 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3229)
  %3232 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3230)
  %3233 = fcmp ogt <2 x double> %3231, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3234 = fcmp ogt <2 x double> %3232, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3235 = zext <2 x i1> %3233 to <2 x i32>
  %3236 = or <2 x i32> %3223, %3235
  %3237 = or <2 x i1> %3224, %3234
  %3238 = getelementptr inbounds i8, ptr %0, i64 41568
  %3239 = getelementptr inbounds i8, ptr %0, i64 41584
  %wide.load419.3 = load <2 x double>, ptr %3238, align 8, !tbaa !5
  %wide.load420.3 = load <2 x double>, ptr %3239, align 8, !tbaa !5
  %3240 = getelementptr inbounds i8, ptr %1, i64 41568
  %3241 = getelementptr inbounds i8, ptr %1, i64 41584
  %wide.load421.3 = load <2 x double>, ptr %3240, align 8, !tbaa !5
  %wide.load422.3 = load <2 x double>, ptr %3241, align 8, !tbaa !5
  %3242 = fsub <2 x double> %wide.load419.3, %wide.load421.3
  %3243 = fsub <2 x double> %wide.load420.3, %wide.load422.3
  %3244 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3242)
  %3245 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3243)
  %3246 = fcmp ogt <2 x double> %3244, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3247 = fcmp ogt <2 x double> %3245, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3248 = zext <2 x i1> %3246 to <2 x i32>
  %3249 = or <2 x i32> %3236, %3248
  %3250 = or <2 x i1> %3237, %3247
  %3251 = getelementptr inbounds i8, ptr %0, i64 41600
  %3252 = getelementptr inbounds i8, ptr %0, i64 41616
  %wide.load419.4 = load <2 x double>, ptr %3251, align 8, !tbaa !5
  %wide.load420.4 = load <2 x double>, ptr %3252, align 8, !tbaa !5
  %3253 = getelementptr inbounds i8, ptr %1, i64 41600
  %3254 = getelementptr inbounds i8, ptr %1, i64 41616
  %wide.load421.4 = load <2 x double>, ptr %3253, align 8, !tbaa !5
  %wide.load422.4 = load <2 x double>, ptr %3254, align 8, !tbaa !5
  %3255 = fsub <2 x double> %wide.load419.4, %wide.load421.4
  %3256 = fsub <2 x double> %wide.load420.4, %wide.load422.4
  %3257 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3255)
  %3258 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3256)
  %3259 = fcmp ogt <2 x double> %3257, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3260 = fcmp ogt <2 x double> %3258, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3261 = zext <2 x i1> %3259 to <2 x i32>
  %3262 = or <2 x i32> %3249, %3261
  %3263 = or <2 x i1> %3250, %3260
  %3264 = getelementptr inbounds i8, ptr %0, i64 41632
  %3265 = getelementptr inbounds i8, ptr %0, i64 41648
  %wide.load419.5 = load <2 x double>, ptr %3264, align 8, !tbaa !5
  %wide.load420.5 = load <2 x double>, ptr %3265, align 8, !tbaa !5
  %3266 = getelementptr inbounds i8, ptr %1, i64 41632
  %3267 = getelementptr inbounds i8, ptr %1, i64 41648
  %wide.load421.5 = load <2 x double>, ptr %3266, align 8, !tbaa !5
  %wide.load422.5 = load <2 x double>, ptr %3267, align 8, !tbaa !5
  %3268 = fsub <2 x double> %wide.load419.5, %wide.load421.5
  %3269 = fsub <2 x double> %wide.load420.5, %wide.load422.5
  %3270 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3268)
  %3271 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3269)
  %3272 = fcmp ogt <2 x double> %3270, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3273 = fcmp ogt <2 x double> %3271, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3274 = zext <2 x i1> %3272 to <2 x i32>
  %3275 = or <2 x i32> %3262, %3274
  %3276 = or <2 x i1> %3263, %3273
  %3277 = getelementptr inbounds i8, ptr %0, i64 41664
  %3278 = getelementptr inbounds i8, ptr %0, i64 41680
  %wide.load419.6 = load <2 x double>, ptr %3277, align 8, !tbaa !5
  %wide.load420.6 = load <2 x double>, ptr %3278, align 8, !tbaa !5
  %3279 = getelementptr inbounds i8, ptr %1, i64 41664
  %3280 = getelementptr inbounds i8, ptr %1, i64 41680
  %wide.load421.6 = load <2 x double>, ptr %3279, align 8, !tbaa !5
  %wide.load422.6 = load <2 x double>, ptr %3280, align 8, !tbaa !5
  %3281 = fsub <2 x double> %wide.load419.6, %wide.load421.6
  %3282 = fsub <2 x double> %wide.load420.6, %wide.load422.6
  %3283 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3281)
  %3284 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3282)
  %3285 = fcmp ogt <2 x double> %3283, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3286 = fcmp ogt <2 x double> %3284, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3287 = zext <2 x i1> %3285 to <2 x i32>
  %3288 = or <2 x i32> %3275, %3287
  %3289 = or <2 x i1> %3276, %3286
  %3290 = getelementptr inbounds i8, ptr %0, i64 41696
  %3291 = getelementptr inbounds i8, ptr %0, i64 41712
  %wide.load419.7 = load <2 x double>, ptr %3290, align 8, !tbaa !5
  %wide.load420.7 = load <2 x double>, ptr %3291, align 8, !tbaa !5
  %3292 = getelementptr inbounds i8, ptr %1, i64 41696
  %3293 = getelementptr inbounds i8, ptr %1, i64 41712
  %wide.load421.7 = load <2 x double>, ptr %3292, align 8, !tbaa !5
  %wide.load422.7 = load <2 x double>, ptr %3293, align 8, !tbaa !5
  %3294 = fsub <2 x double> %wide.load419.7, %wide.load421.7
  %3295 = fsub <2 x double> %wide.load420.7, %wide.load422.7
  %3296 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3294)
  %3297 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3295)
  %3298 = fcmp ogt <2 x double> %3296, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3299 = fcmp ogt <2 x double> %3297, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3300 = zext <2 x i1> %3298 to <2 x i32>
  %3301 = or <2 x i32> %3288, %3300
  %3302 = or <2 x i1> %3289, %3299
  %3303 = getelementptr inbounds i8, ptr %0, i64 41728
  %3304 = getelementptr inbounds i8, ptr %0, i64 41744
  %wide.load419.8 = load <2 x double>, ptr %3303, align 8, !tbaa !5
  %wide.load420.8 = load <2 x double>, ptr %3304, align 8, !tbaa !5
  %3305 = getelementptr inbounds i8, ptr %1, i64 41728
  %3306 = getelementptr inbounds i8, ptr %1, i64 41744
  %wide.load421.8 = load <2 x double>, ptr %3305, align 8, !tbaa !5
  %wide.load422.8 = load <2 x double>, ptr %3306, align 8, !tbaa !5
  %3307 = fsub <2 x double> %wide.load419.8, %wide.load421.8
  %3308 = fsub <2 x double> %wide.load420.8, %wide.load422.8
  %3309 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3307)
  %3310 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3308)
  %3311 = fcmp ogt <2 x double> %3309, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3312 = fcmp ogt <2 x double> %3310, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3313 = zext <2 x i1> %3311 to <2 x i32>
  %3314 = or <2 x i32> %3301, %3313
  %3315 = or <2 x i1> %3302, %3312
  %3316 = getelementptr inbounds i8, ptr %0, i64 41760
  %3317 = getelementptr inbounds i8, ptr %0, i64 41776
  %wide.load419.9 = load <2 x double>, ptr %3316, align 8, !tbaa !5
  %wide.load420.9 = load <2 x double>, ptr %3317, align 8, !tbaa !5
  %3318 = getelementptr inbounds i8, ptr %1, i64 41760
  %3319 = getelementptr inbounds i8, ptr %1, i64 41776
  %wide.load421.9 = load <2 x double>, ptr %3318, align 8, !tbaa !5
  %wide.load422.9 = load <2 x double>, ptr %3319, align 8, !tbaa !5
  %3320 = fsub <2 x double> %wide.load419.9, %wide.load421.9
  %3321 = fsub <2 x double> %wide.load420.9, %wide.load422.9
  %3322 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3320)
  %3323 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3321)
  %3324 = fcmp ogt <2 x double> %3322, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3325 = fcmp ogt <2 x double> %3323, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3326 = zext <2 x i1> %3324 to <2 x i32>
  %3327 = or <2 x i32> %3314, %3326
  %3328 = or <2 x i1> %3315, %3325
  %3329 = getelementptr inbounds i8, ptr %0, i64 41792
  %3330 = getelementptr inbounds i8, ptr %0, i64 41808
  %wide.load419.10 = load <2 x double>, ptr %3329, align 8, !tbaa !5
  %wide.load420.10 = load <2 x double>, ptr %3330, align 8, !tbaa !5
  %3331 = getelementptr inbounds i8, ptr %1, i64 41792
  %3332 = getelementptr inbounds i8, ptr %1, i64 41808
  %wide.load421.10 = load <2 x double>, ptr %3331, align 8, !tbaa !5
  %wide.load422.10 = load <2 x double>, ptr %3332, align 8, !tbaa !5
  %3333 = fsub <2 x double> %wide.load419.10, %wide.load421.10
  %3334 = fsub <2 x double> %wide.load420.10, %wide.load422.10
  %3335 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3333)
  %3336 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3334)
  %3337 = fcmp ogt <2 x double> %3335, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3338 = fcmp ogt <2 x double> %3336, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3339 = zext <2 x i1> %3337 to <2 x i32>
  %3340 = or <2 x i32> %3327, %3339
  %3341 = or <2 x i1> %3328, %3338
  %3342 = getelementptr inbounds i8, ptr %0, i64 41824
  %3343 = getelementptr inbounds i8, ptr %0, i64 41840
  %wide.load419.11 = load <2 x double>, ptr %3342, align 8, !tbaa !5
  %wide.load420.11 = load <2 x double>, ptr %3343, align 8, !tbaa !5
  %3344 = getelementptr inbounds i8, ptr %1, i64 41824
  %3345 = getelementptr inbounds i8, ptr %1, i64 41840
  %wide.load421.11 = load <2 x double>, ptr %3344, align 8, !tbaa !5
  %wide.load422.11 = load <2 x double>, ptr %3345, align 8, !tbaa !5
  %3346 = fsub <2 x double> %wide.load419.11, %wide.load421.11
  %3347 = fsub <2 x double> %wide.load420.11, %wide.load422.11
  %3348 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3346)
  %3349 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3347)
  %3350 = fcmp ogt <2 x double> %3348, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3351 = fcmp ogt <2 x double> %3349, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3352 = zext <2 x i1> %3350 to <2 x i32>
  %3353 = or <2 x i32> %3340, %3352
  %3354 = or <2 x i1> %3341, %3351
  %3355 = getelementptr inbounds i8, ptr %0, i64 41856
  %3356 = getelementptr inbounds i8, ptr %0, i64 41872
  %wide.load419.12 = load <2 x double>, ptr %3355, align 8, !tbaa !5
  %wide.load420.12 = load <2 x double>, ptr %3356, align 8, !tbaa !5
  %3357 = getelementptr inbounds i8, ptr %1, i64 41856
  %3358 = getelementptr inbounds i8, ptr %1, i64 41872
  %wide.load421.12 = load <2 x double>, ptr %3357, align 8, !tbaa !5
  %wide.load422.12 = load <2 x double>, ptr %3358, align 8, !tbaa !5
  %3359 = fsub <2 x double> %wide.load419.12, %wide.load421.12
  %3360 = fsub <2 x double> %wide.load420.12, %wide.load422.12
  %3361 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3359)
  %3362 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3360)
  %3363 = fcmp ogt <2 x double> %3361, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3364 = fcmp ogt <2 x double> %3362, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3365 = zext <2 x i1> %3363 to <2 x i32>
  %3366 = or <2 x i32> %3353, %3365
  %3367 = or <2 x i1> %3354, %3364
  %3368 = getelementptr inbounds i8, ptr %0, i64 41888
  %3369 = getelementptr inbounds i8, ptr %0, i64 41904
  %wide.load419.13 = load <2 x double>, ptr %3368, align 8, !tbaa !5
  %wide.load420.13 = load <2 x double>, ptr %3369, align 8, !tbaa !5
  %3370 = getelementptr inbounds i8, ptr %1, i64 41888
  %3371 = getelementptr inbounds i8, ptr %1, i64 41904
  %wide.load421.13 = load <2 x double>, ptr %3370, align 8, !tbaa !5
  %wide.load422.13 = load <2 x double>, ptr %3371, align 8, !tbaa !5
  %3372 = fsub <2 x double> %wide.load419.13, %wide.load421.13
  %3373 = fsub <2 x double> %wide.load420.13, %wide.load422.13
  %3374 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3372)
  %3375 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3373)
  %3376 = fcmp ogt <2 x double> %3374, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3377 = fcmp ogt <2 x double> %3375, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3378 = zext <2 x i1> %3376 to <2 x i32>
  %3379 = or <2 x i32> %3366, %3378
  %3380 = or <2 x i1> %3367, %3377
  %3381 = getelementptr inbounds i8, ptr %0, i64 41920
  %3382 = getelementptr inbounds i8, ptr %0, i64 41936
  %wide.load419.14 = load <2 x double>, ptr %3381, align 8, !tbaa !5
  %wide.load420.14 = load <2 x double>, ptr %3382, align 8, !tbaa !5
  %3383 = getelementptr inbounds i8, ptr %1, i64 41920
  %3384 = getelementptr inbounds i8, ptr %1, i64 41936
  %wide.load421.14 = load <2 x double>, ptr %3383, align 8, !tbaa !5
  %wide.load422.14 = load <2 x double>, ptr %3384, align 8, !tbaa !5
  %3385 = fsub <2 x double> %wide.load419.14, %wide.load421.14
  %3386 = fsub <2 x double> %wide.load420.14, %wide.load422.14
  %3387 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3385)
  %3388 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3386)
  %3389 = fcmp ogt <2 x double> %3387, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3390 = fcmp ogt <2 x double> %3388, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3391 = zext <2 x i1> %3389 to <2 x i32>
  %3392 = or <2 x i32> %3379, %3391
  %3393 = or <2 x i1> %3380, %3390
  %3394 = getelementptr inbounds i8, ptr %0, i64 41952
  %3395 = getelementptr inbounds i8, ptr %0, i64 41968
  %wide.load419.15 = load <2 x double>, ptr %3394, align 8, !tbaa !5
  %wide.load420.15 = load <2 x double>, ptr %3395, align 8, !tbaa !5
  %3396 = getelementptr inbounds i8, ptr %1, i64 41952
  %3397 = getelementptr inbounds i8, ptr %1, i64 41968
  %wide.load421.15 = load <2 x double>, ptr %3396, align 8, !tbaa !5
  %wide.load422.15 = load <2 x double>, ptr %3397, align 8, !tbaa !5
  %3398 = fsub <2 x double> %wide.load419.15, %wide.load421.15
  %3399 = fsub <2 x double> %wide.load420.15, %wide.load422.15
  %3400 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3398)
  %3401 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3399)
  %3402 = fcmp ogt <2 x double> %3400, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3403 = fcmp ogt <2 x double> %3401, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %3404 = zext <2 x i1> %3402 to <2 x i32>
  %3405 = or <2 x i32> %3392, %3404
  %3406 = or <2 x i1> %3393, %3403
  %3407 = zext <2 x i1> %3406 to <2 x i32>
  %bin.rdx424 = or <2 x i32> %3405, %3407
  %3408 = tail call i32 @llvm.vector.reduce.or.v2i32(<2 x i32> %bin.rdx424)
  %3409 = getelementptr inbounds i8, ptr %0, i64 41984
  %3410 = getelementptr inbounds i8, ptr %1, i64 41984
  %3411 = load <2 x double>, ptr %3409, align 8, !tbaa !5
  %3412 = load <2 x double>, ptr %3410, align 8, !tbaa !5
  %3413 = fsub <2 x double> %3411, %3412
  %3414 = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %3413)
  %3415 = fcmp ogt <2 x double> %3414, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
  %shift = shufflevector <2 x i1> %3415, <2 x i1> poison, <2 x i32> <i32 1, i32 poison>
  %3416 = or <2 x i1> %3415, %shift
  %3417 = extractelement <2 x i1> %3416, i64 0
  %3418 = getelementptr inbounds i8, ptr %0, i64 42000
  %3419 = load double, ptr %3418, align 8, !tbaa !5
  %3420 = getelementptr inbounds i8, ptr %1, i64 42000
  %3421 = load double, ptr %3420, align 8, !tbaa !5
  %3422 = fsub double %3419, %3421
  %3423 = tail call double @llvm.fabs.f64(double %3422)
  %3424 = fcmp ogt double %3423, 0x3EB0C6F7A0B5ED8D
  %3425 = or i1 %3417, %3424
  %3426 = zext i1 %3425 to i32
  %3427 = or i32 %3408, %3426
  %.not = icmp eq i32 %3427, 0
  %3428 = zext i1 %.not to i32
  ret i32 %3428
}

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.vector.reduce.or.v2i32(<2 x i32>) #1

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

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

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


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