; LLVM IR from ROCm/aomp :: test/a+atest (stream)

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

@.str = external hidden unnamed_addr constant [63 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [46 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [50 x i8], align 1
@a = external hidden global [10000000 x double], align 16
@b = external hidden global [10000000 x double], align 16
@c = external hidden global [10000000 x double], align 16
@.str.9 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [60 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [49 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [33 x i8], align 1
@avgtime = external hidden global [4 x double], align 16
@mintime = external hidden global [4 x double], align 16
@maxtime = external hidden global [4 x double], align 16
@.str.18 = external hidden unnamed_addr constant [64 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [34 x i8], align 1
@label = external hidden global [4 x ptr], align 16
@bytes = external hidden global [4 x double], align 16

; Function Attrs: nounwind uwtable
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i64, align 8
  %6 = alloca double, align 8
  %7 = alloca double, align 8
  %8 = alloca [4 x [10 x double]], align 16
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #4
  call void @llvm.lifetime.start.p0(i64 320, ptr %8) #4
  %9 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %10 = call i32 (ptr, ...) @printf(ptr noundef @.str.1)
  %11 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  store i32 8, ptr %3, align 4, !tbaa !5
  %12 = load i32, ptr %3, align 4, !tbaa !5
  %13 = call i32 (ptr, ...) @printf(ptr noundef @.str.2, i32 noundef %12)
  %14 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %15 = call i32 (ptr, ...) @printf(ptr noundef @.str.3, i64 noundef 10000000, i32 noundef 0)
  %16 = load i32, ptr %3, align 4, !tbaa !5
  %17 = sitofp i32 %16 to double
  %18 = fmul double %17, 0x402312D000000000
  %19 = load i32, ptr %3, align 4, !tbaa !5
  %20 = sitofp i32 %19 to double
  %21 = fmul double %20, 0x3F8312D000000000
  %22 = call i32 (ptr, ...) @printf(ptr noundef @.str.4, double noundef %18, double noundef %21)
  %23 = load i32, ptr %3, align 4, !tbaa !5
  %24 = sitofp i32 %23 to double
  %25 = fmul double 3.000000e+00, %24
  %26 = fmul double %25, 0x402312D000000000
  %27 = load i32, ptr %3, align 4, !tbaa !5
  %28 = sitofp i32 %27 to double
  %29 = fmul double 3.000000e+00, %28
  %30 = fmul double %29, 0x3F8312D000000000
  %31 = call i32 (ptr, ...) @printf(ptr noundef @.str.5, double noundef %26, double noundef %30)
  %32 = call i32 (ptr, ...) @printf(ptr noundef @.str.6, i32 noundef 10)
  %33 = call i32 (ptr, ...) @printf(ptr noundef @.str.7)
  %34 = call i32 (ptr, ...) @printf(ptr noundef @.str.8)
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %35

35:                                               ; preds = %45, %0
  %36 = load i64, ptr %5, align 8, !tbaa !9
  %37 = icmp slt i64 %36, 10000000
  br i1 %37, label %38, label %48

38:                                               ; preds = %35
  %39 = load i64, ptr %5, align 8, !tbaa !9
  %40 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %39
  store double 1.000000e+00, ptr %40, align 8, !tbaa !11
  %41 = load i64, ptr %5, align 8, !tbaa !9
  %42 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %41
  store double 2.000000e+00, ptr %42, align 8, !tbaa !11
  %43 = load i64, ptr %5, align 8, !tbaa !9
  %44 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %43
  store double 0.000000e+00, ptr %44, align 8, !tbaa !11
  br label %45

45:                                               ; preds = %38
  %46 = load i64, ptr %5, align 8, !tbaa !9
  %47 = add nsw i64 %46, 1
  store i64 %47, ptr %5, align 8, !tbaa !9
  br label %35, !llvm.loop !13

48:                                               ; preds = %35
  %49 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %50 = call i32 @checktick()
  store i32 %50, ptr %2, align 4, !tbaa !5
  %51 = icmp sge i32 %50, 1
  br i1 %51, label %52, label %55

52:                                               ; preds = %48
  %53 = load i32, ptr %2, align 4, !tbaa !5
  %54 = call i32 (ptr, ...) @printf(ptr noundef @.str.9, i32 noundef %53)
  br label %57

55:                                               ; preds = %48
  %56 = call i32 (ptr, ...) @printf(ptr noundef @.str.10)
  store i32 1, ptr %2, align 4, !tbaa !5
  br label %57

57:                                               ; preds = %55, %52
  %58 = call double @mysecond()
  store double %58, ptr %7, align 8, !tbaa !11
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %59

59:                                               ; preds = %69, %57
  %60 = load i64, ptr %5, align 8, !tbaa !9
  %61 = icmp slt i64 %60, 10000000
  br i1 %61, label %62, label %72

62:                                               ; preds = %59
  %63 = load i64, ptr %5, align 8, !tbaa !9
  %64 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %63
  %65 = load double, ptr %64, align 8, !tbaa !11
  %66 = fmul double 2.000000e+00, %65
  %67 = load i64, ptr %5, align 8, !tbaa !9
  %68 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %67
  store double %66, ptr %68, align 8, !tbaa !11
  br label %69

69:                                               ; preds = %62
  %70 = load i64, ptr %5, align 8, !tbaa !9
  %71 = add nsw i64 %70, 1
  store i64 %71, ptr %5, align 8, !tbaa !9
  br label %59, !llvm.loop !15

72:                                               ; preds = %59
  %73 = call double @mysecond()
  %74 = load double, ptr %7, align 8, !tbaa !11
  %75 = fsub double %73, %74
  %76 = fmul double 1.000000e+06, %75
  store double %76, ptr %7, align 8, !tbaa !11
  %77 = load double, ptr %7, align 8, !tbaa !11
  %78 = fptosi double %77 to i32
  %79 = call i32 (ptr, ...) @printf(ptr noundef @.str.11, i32 noundef %78)
  %80 = load double, ptr %7, align 8, !tbaa !11
  %81 = load i32, ptr %2, align 4, !tbaa !5
  %82 = sitofp i32 %81 to double
  %83 = fdiv double %80, %82
  %84 = fptosi double %83 to i32
  %85 = call i32 (ptr, ...) @printf(ptr noundef @.str.12, i32 noundef %84)
  %86 = call i32 (ptr, ...) @printf(ptr noundef @.str.13)
  %87 = call i32 (ptr, ...) @printf(ptr noundef @.str.14)
  %88 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %89 = call i32 (ptr, ...) @printf(ptr noundef @.str.15)
  %90 = call i32 (ptr, ...) @printf(ptr noundef @.str.16)
  %91 = call i32 (ptr, ...) @printf(ptr noundef @.str.17)
  %92 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  store double 3.000000e+00, ptr %6, align 8, !tbaa !11
  store i32 0, ptr %4, align 4, !tbaa !5
  br label %93

93:                                               ; preds = %224, %72
  %94 = load i32, ptr %4, align 4, !tbaa !5
  %95 = icmp slt i32 %94, 10
  br i1 %95, label %96, label %227

96:                                               ; preds = %93
  %97 = call double @mysecond()
  %98 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 0
  %99 = load i32, ptr %4, align 4, !tbaa !5
  %100 = sext i32 %99 to i64
  %101 = getelementptr inbounds [10 x double], ptr %98, i64 0, i64 %100
  store double %97, ptr %101, align 8, !tbaa !11
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %102

102:                                              ; preds = %111, %96
  %103 = load i64, ptr %5, align 8, !tbaa !9
  %104 = icmp slt i64 %103, 10000000
  br i1 %104, label %105, label %114

105:                                              ; preds = %102
  %106 = load i64, ptr %5, align 8, !tbaa !9
  %107 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %106
  %108 = load double, ptr %107, align 8, !tbaa !11
  %109 = load i64, ptr %5, align 8, !tbaa !9
  %110 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %109
  store double %108, ptr %110, align 8, !tbaa !11
  br label %111

111:                                              ; preds = %105
  %112 = load i64, ptr %5, align 8, !tbaa !9
  %113 = add nsw i64 %112, 1
  store i64 %113, ptr %5, align 8, !tbaa !9
  br label %102, !llvm.loop !16

114:                                              ; preds = %102
  %115 = call double @mysecond()
  %116 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 0
  %117 = load i32, ptr %4, align 4, !tbaa !5
  %118 = sext i32 %117 to i64
  %119 = getelementptr inbounds [10 x double], ptr %116, i64 0, i64 %118
  %120 = load double, ptr %119, align 8, !tbaa !11
  %121 = fsub double %115, %120
  %122 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 0
  %123 = load i32, ptr %4, align 4, !tbaa !5
  %124 = sext i32 %123 to i64
  %125 = getelementptr inbounds [10 x double], ptr %122, i64 0, i64 %124
  store double %121, ptr %125, align 8, !tbaa !11
  %126 = call double @mysecond()
  %127 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 1
  %128 = load i32, ptr %4, align 4, !tbaa !5
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds [10 x double], ptr %127, i64 0, i64 %129
  store double %126, ptr %130, align 8, !tbaa !11
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %131

131:                                              ; preds = %142, %114
  %132 = load i64, ptr %5, align 8, !tbaa !9
  %133 = icmp slt i64 %132, 10000000
  br i1 %133, label %134, label %145

134:                                              ; preds = %131
  %135 = load double, ptr %6, align 8, !tbaa !11
  %136 = load i64, ptr %5, align 8, !tbaa !9
  %137 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %136
  %138 = load double, ptr %137, align 8, !tbaa !11
  %139 = fmul double %135, %138
  %140 = load i64, ptr %5, align 8, !tbaa !9
  %141 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %140
  store double %139, ptr %141, align 8, !tbaa !11
  br label %142

142:                                              ; preds = %134
  %143 = load i64, ptr %5, align 8, !tbaa !9
  %144 = add nsw i64 %143, 1
  store i64 %144, ptr %5, align 8, !tbaa !9
  br label %131, !llvm.loop !17

145:                                              ; preds = %131
  %146 = call double @mysecond()
  %147 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 1
  %148 = load i32, ptr %4, align 4, !tbaa !5
  %149 = sext i32 %148 to i64
  %150 = getelementptr inbounds [10 x double], ptr %147, i64 0, i64 %149
  %151 = load double, ptr %150, align 8, !tbaa !11
  %152 = fsub double %146, %151
  %153 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 1
  %154 = load i32, ptr %4, align 4, !tbaa !5
  %155 = sext i32 %154 to i64
  %156 = getelementptr inbounds [10 x double], ptr %153, i64 0, i64 %155
  store double %152, ptr %156, align 8, !tbaa !11
  %157 = call double @mysecond()
  %158 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 2
  %159 = load i32, ptr %4, align 4, !tbaa !5
  %160 = sext i32 %159 to i64
  %161 = getelementptr inbounds [10 x double], ptr %158, i64 0, i64 %160
  store double %157, ptr %161, align 8, !tbaa !11
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %162

162:                                              ; preds = %175, %145
  %163 = load i64, ptr %5, align 8, !tbaa !9
  %164 = icmp slt i64 %163, 10000000
  br i1 %164, label %165, label %178

165:                                              ; preds = %162
  %166 = load i64, ptr %5, align 8, !tbaa !9
  %167 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %166
  %168 = load double, ptr %167, align 8, !tbaa !11
  %169 = load i64, ptr %5, align 8, !tbaa !9
  %170 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %169
  %171 = load double, ptr %170, align 8, !tbaa !11
  %172 = fadd double %168, %171
  %173 = load i64, ptr %5, align 8, !tbaa !9
  %174 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %173
  store double %172, ptr %174, align 8, !tbaa !11
  br label %175

175:                                              ; preds = %165
  %176 = load i64, ptr %5, align 8, !tbaa !9
  %177 = add nsw i64 %176, 1
  store i64 %177, ptr %5, align 8, !tbaa !9
  br label %162, !llvm.loop !18

178:                                              ; preds = %162
  %179 = call double @mysecond()
  %180 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 2
  %181 = load i32, ptr %4, align 4, !tbaa !5
  %182 = sext i32 %181 to i64
  %183 = getelementptr inbounds [10 x double], ptr %180, i64 0, i64 %182
  %184 = load double, ptr %183, align 8, !tbaa !11
  %185 = fsub double %179, %184
  %186 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 2
  %187 = load i32, ptr %4, align 4, !tbaa !5
  %188 = sext i32 %187 to i64
  %189 = getelementptr inbounds [10 x double], ptr %186, i64 0, i64 %188
  store double %185, ptr %189, align 8, !tbaa !11
  %190 = call double @mysecond()
  %191 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 3
  %192 = load i32, ptr %4, align 4, !tbaa !5
  %193 = sext i32 %192 to i64
  %194 = getelementptr inbounds [10 x double], ptr %191, i64 0, i64 %193
  store double %190, ptr %194, align 8, !tbaa !11
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %195

195:                                              ; preds = %209, %178
  %196 = load i64, ptr %5, align 8, !tbaa !9
  %197 = icmp slt i64 %196, 10000000
  br i1 %197, label %198, label %212

198:                                              ; preds = %195
  %199 = load i64, ptr %5, align 8, !tbaa !9
  %200 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %199
  %201 = load double, ptr %200, align 8, !tbaa !11
  %202 = load double, ptr %6, align 8, !tbaa !11
  %203 = load i64, ptr %5, align 8, !tbaa !9
  %204 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %203
  %205 = load double, ptr %204, align 8, !tbaa !11
  %206 = call double @llvm.fmuladd.f64(double %202, double %205, double %201)
  %207 = load i64, ptr %5, align 8, !tbaa !9
  %208 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %207
  store double %206, ptr %208, align 8, !tbaa !11
  br label %209

209:                                              ; preds = %198
  %210 = load i64, ptr %5, align 8, !tbaa !9
  %211 = add nsw i64 %210, 1
  store i64 %211, ptr %5, align 8, !tbaa !9
  br label %195, !llvm.loop !19

212:                                              ; preds = %195
  %213 = call double @mysecond()
  %214 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 3
  %215 = load i32, ptr %4, align 4, !tbaa !5
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds [10 x double], ptr %214, i64 0, i64 %216
  %218 = load double, ptr %217, align 8, !tbaa !11
  %219 = fsub double %213, %218
  %220 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 3
  %221 = load i32, ptr %4, align 4, !tbaa !5
  %222 = sext i32 %221 to i64
  %223 = getelementptr inbounds [10 x double], ptr %220, i64 0, i64 %222
  store double %219, ptr %223, align 8, !tbaa !11
  br label %224

224:                                              ; preds = %212
  %225 = load i32, ptr %4, align 4, !tbaa !5
  %226 = add nsw i32 %225, 1
  store i32 %226, ptr %4, align 4, !tbaa !5
  br label %93, !llvm.loop !20

227:                                              ; preds = %93
  store i32 1, ptr %4, align 4, !tbaa !5
  br label %228

228:                                              ; preds = %302, %227
  %229 = load i32, ptr %4, align 4, !tbaa !5
  %230 = icmp slt i32 %229, 10
  br i1 %230, label %231, label %305

231:                                              ; preds = %228
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %232

232:                                              ; preds = %298, %231
  %233 = load i64, ptr %5, align 8, !tbaa !9
  %234 = icmp slt i64 %233, 4
  br i1 %234, label %235, label %301

235:                                              ; preds = %232
  %236 = load i64, ptr %5, align 8, !tbaa !9
  %237 = getelementptr inbounds [4 x double], ptr @avgtime, i64 0, i64 %236
  %238 = load double, ptr %237, align 8, !tbaa !11
  %239 = load i64, ptr %5, align 8, !tbaa !9
  %240 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 %239
  %241 = load i32, ptr %4, align 4, !tbaa !5
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds [10 x double], ptr %240, i64 0, i64 %242
  %244 = load double, ptr %243, align 8, !tbaa !11
  %245 = fadd double %238, %244
  %246 = load i64, ptr %5, align 8, !tbaa !9
  %247 = getelementptr inbounds [4 x double], ptr @avgtime, i64 0, i64 %246
  store double %245, ptr %247, align 8, !tbaa !11
  %248 = load i64, ptr %5, align 8, !tbaa !9
  %249 = getelementptr inbounds [4 x double], ptr @mintime, i64 0, i64 %248
  %250 = load double, ptr %249, align 8, !tbaa !11
  %251 = load i64, ptr %5, align 8, !tbaa !9
  %252 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 %251
  %253 = load i32, ptr %4, align 4, !tbaa !5
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds [10 x double], ptr %252, i64 0, i64 %254
  %256 = load double, ptr %255, align 8, !tbaa !11
  %257 = fcmp olt double %250, %256
  br i1 %257, label %258, label %262

258:                                              ; preds = %235
  %259 = load i64, ptr %5, align 8, !tbaa !9
  %260 = getelementptr inbounds [4 x double], ptr @mintime, i64 0, i64 %259
  %261 = load double, ptr %260, align 8, !tbaa !11
  br label %269

262:                                              ; preds = %235
  %263 = load i64, ptr %5, align 8, !tbaa !9
  %264 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 %263
  %265 = load i32, ptr %4, align 4, !tbaa !5
  %266 = sext i32 %265 to i64
  %267 = getelementptr inbounds [10 x double], ptr %264, i64 0, i64 %266
  %268 = load double, ptr %267, align 8, !tbaa !11
  br label %269

269:                                              ; preds = %262, %258
  %270 = phi double [ %261, %258 ], [ %268, %262 ]
  %271 = load i64, ptr %5, align 8, !tbaa !9
  %272 = getelementptr inbounds [4 x double], ptr @mintime, i64 0, i64 %271
  store double %270, ptr %272, align 8, !tbaa !11
  %273 = load i64, ptr %5, align 8, !tbaa !9
  %274 = getelementptr inbounds [4 x double], ptr @maxtime, i64 0, i64 %273
  %275 = load double, ptr %274, align 8, !tbaa !11
  %276 = load i64, ptr %5, align 8, !tbaa !9
  %277 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 %276
  %278 = load i32, ptr %4, align 4, !tbaa !5
  %279 = sext i32 %278 to i64
  %280 = getelementptr inbounds [10 x double], ptr %277, i64 0, i64 %279
  %281 = load double, ptr %280, align 8, !tbaa !11
  %282 = fcmp ogt double %275, %281
  br i1 %282, label %283, label %287

283:                                              ; preds = %269
  %284 = load i64, ptr %5, align 8, !tbaa !9
  %285 = getelementptr inbounds [4 x double], ptr @maxtime, i64 0, i64 %284
  %286 = load double, ptr %285, align 8, !tbaa !11
  br label %294

287:                                              ; preds = %269
  %288 = load i64, ptr %5, align 8, !tbaa !9
  %289 = getelementptr inbounds [4 x [10 x double]], ptr %8, i64 0, i64 %288
  %290 = load i32, ptr %4, align 4, !tbaa !5
  %291 = sext i32 %290 to i64
  %292 = getelementptr inbounds [10 x double], ptr %289, i64 0, i64 %291
  %293 = load double, ptr %292, align 8, !tbaa !11
  br label %294

294:                                              ; preds = %287, %283
  %295 = phi double [ %286, %283 ], [ %293, %287 ]
  %296 = load i64, ptr %5, align 8, !tbaa !9
  %297 = getelementptr inbounds [4 x double], ptr @maxtime, i64 0, i64 %296
  store double %295, ptr %297, align 8, !tbaa !11
  br label %298

298:                                              ; preds = %294
  %299 = load i64, ptr %5, align 8, !tbaa !9
  %300 = add nsw i64 %299, 1
  store i64 %300, ptr %5, align 8, !tbaa !9
  br label %232, !llvm.loop !21

301:                                              ; preds = %232
  br label %302

302:                                              ; preds = %301
  %303 = load i32, ptr %4, align 4, !tbaa !5
  %304 = add nsw i32 %303, 1
  store i32 %304, ptr %4, align 4, !tbaa !5
  br label %228, !llvm.loop !22

305:                                              ; preds = %228
  %306 = call i32 (ptr, ...) @printf(ptr noundef @.str.18)
  store i64 0, ptr %5, align 8, !tbaa !9
  br label %307

307:                                              ; preds = %338, %305
  %308 = load i64, ptr %5, align 8, !tbaa !9
  %309 = icmp slt i64 %308, 4
  br i1 %309, label %310, label %341

310:                                              ; preds = %307
  %311 = load i64, ptr %5, align 8, !tbaa !9
  %312 = getelementptr inbounds [4 x double], ptr @avgtime, i64 0, i64 %311
  %313 = load double, ptr %312, align 8, !tbaa !11
  %314 = fdiv double %313, 9.000000e+00
  %315 = load i64, ptr %5, align 8, !tbaa !9
  %316 = getelementptr inbounds [4 x double], ptr @avgtime, i64 0, i64 %315
  store double %314, ptr %316, align 8, !tbaa !11
  %317 = load i64, ptr %5, align 8, !tbaa !9
  %318 = getelementptr inbounds [4 x ptr], ptr @label, i64 0, i64 %317
  %319 = load ptr, ptr %318, align 8, !tbaa !23
  %320 = load i64, ptr %5, align 8, !tbaa !9
  %321 = getelementptr inbounds [4 x double], ptr @bytes, i64 0, i64 %320
  %322 = load double, ptr %321, align 8, !tbaa !11
  %323 = fmul double 0x3EB0C6F7A0B5ED8D, %322
  %324 = load i64, ptr %5, align 8, !tbaa !9
  %325 = getelementptr inbounds [4 x double], ptr @mintime, i64 0, i64 %324
  %326 = load double, ptr %325, align 8, !tbaa !11
  %327 = fdiv double %323, %326
  %328 = load i64, ptr %5, align 8, !tbaa !9
  %329 = getelementptr inbounds [4 x double], ptr @avgtime, i64 0, i64 %328
  %330 = load double, ptr %329, align 8, !tbaa !11
  %331 = load i64, ptr %5, align 8, !tbaa !9
  %332 = getelementptr inbounds [4 x double], ptr @mintime, i64 0, i64 %331
  %333 = load double, ptr %332, align 8, !tbaa !11
  %334 = load i64, ptr %5, align 8, !tbaa !9
  %335 = getelementptr inbounds [4 x double], ptr @maxtime, i64 0, i64 %334
  %336 = load double, ptr %335, align 8, !tbaa !11
  %337 = call i32 (ptr, ...) @printf(ptr noundef @.str.19, ptr noundef %319, double noundef %327, double noundef %330, double noundef %333, double noundef %336)
  br label %338

338:                                              ; preds = %310
  %339 = load i64, ptr %5, align 8, !tbaa !9
  %340 = add nsw i64 %339, 1
  store i64 %340, ptr %5, align 8, !tbaa !9
  br label %307, !llvm.loop !25

341:                                              ; preds = %307
  %342 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  call void @checkSTREAMresults()
  %343 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  call void @llvm.lifetime.end.p0(i64 320, ptr %8) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #4
  ret i32 0
}

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

declare i32 @printf(ptr noundef, ...) #2

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

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @checktick() #0

; Function Attrs: nounwind uwtable
declare dso_local double @mysecond() #0

; Function Attrs: nounwind uwtable
declare dso_local void @checkSTREAMresults() #0

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"long", !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}
!23 = !{!24, !24, i64 0}
!24 = !{!"any pointer", !7, i64 0}
!25 = distinct !{!25, !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"

@.str = external hidden unnamed_addr constant [63 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [46 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [50 x i8], align 1
@a = external hidden local_unnamed_addr global [10000000 x double], align 16
@b = external hidden local_unnamed_addr global [10000000 x double], align 16
@c = external hidden local_unnamed_addr global [10000000 x double], align 16
@.str.9 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [65 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [60 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [49 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [33 x i8], align 1
@avgtime = external hidden local_unnamed_addr global [4 x double], align 16
@mintime = external hidden local_unnamed_addr global [4 x double], align 16
@maxtime = external hidden local_unnamed_addr global [4 x double], align 16
@.str.18 = external hidden unnamed_addr constant [64 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [34 x i8], align 1
@label = external hidden local_unnamed_addr global [4 x ptr], align 16
@bytes = external hidden local_unnamed_addr global [4 x double], align 16

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @main() local_unnamed_addr #0 {
vector.ph:
  %0 = alloca [4 x [10 x double]], align 16
  call void @llvm.lifetime.start.p0(i64 320, ptr nonnull %0) #6
  %1 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %2 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1)
  %3 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %4 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 8)
  %5 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %6 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.3, i64 noundef 10000000, i32 noundef 0)
  %7 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.4, double noundef 0x405312D000000000, double noundef 0x3FB312D000000000)
  %8 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.5, double noundef 0x406C9C3800000000, double noundef 0x3FCC9C3800000000)
  %9 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.6, i32 noundef 10)
  %10 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.7)
  %11 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.8)
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(80000000) @c, i8 0, i64 80000000, i1 false), !tbaa !5
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next.1, %vector.body ]
  %12 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index
  %13 = getelementptr inbounds i8, ptr %12, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %12, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %13, align 16, !tbaa !5
  %14 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index
  %15 = getelementptr inbounds i8, ptr %14, i64 16
  store <2 x double> <double 2.000000e+00, double 2.000000e+00>, ptr %14, align 16, !tbaa !5
  store <2 x double> <double 2.000000e+00, double 2.000000e+00>, ptr %15, align 16, !tbaa !5
  %index.next = or disjoint i64 %index, 4
  %16 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index.next
  %17 = getelementptr inbounds i8, ptr %16, i64 16
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %16, align 16, !tbaa !5
  store <2 x double> <double 1.000000e+00, double 1.000000e+00>, ptr %17, align 16, !tbaa !5
  %18 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index.next
  %19 = getelementptr inbounds i8, ptr %18, i64 16
  store <2 x double> <double 2.000000e+00, double 2.000000e+00>, ptr %18, align 16, !tbaa !5
  store <2 x double> <double 2.000000e+00, double 2.000000e+00>, ptr %19, align 16, !tbaa !5
  %index.next.1 = add nuw nsw i64 %index, 8
  %20 = icmp eq i64 %index.next.1, 10000000
  br i1 %20, label %middle.block, label %vector.body, !llvm.loop !9

middle.block:                                     ; preds = %vector.body
  %21 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %22 = tail call i32 @checktick()
  %23 = icmp sgt i32 %22, 0
  br i1 %23, label %24, label %27

24:                                               ; preds = %middle.block
  %25 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, i32 noundef %22)
  %26 = uitofp nneg i32 %22 to double
  br label %vector.ph142

27:                                               ; preds = %middle.block
  %28 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.10)
  br label %vector.ph142

vector.ph142:                                     ; preds = %27, %24
  %.0 = phi double [ %26, %24 ], [ 1.000000e+00, %27 ]
  %29 = tail call double @mysecond()
  br label %vector.body144

vector.body144:                                   ; preds = %vector.body144, %vector.ph142
  %index145 = phi i64 [ 0, %vector.ph142 ], [ %index.next147.1, %vector.body144 ]
  %30 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index145
  %31 = getelementptr inbounds i8, ptr %30, i64 16
  %wide.load = load <2 x double>, ptr %30, align 16, !tbaa !5
  %wide.load146 = load <2 x double>, ptr %31, align 16, !tbaa !5
  %32 = fmul <2 x double> %wide.load, <double 2.000000e+00, double 2.000000e+00>
  %33 = fmul <2 x double> %wide.load146, <double 2.000000e+00, double 2.000000e+00>
  store <2 x double> %32, ptr %30, align 16, !tbaa !5
  store <2 x double> %33, ptr %31, align 16, !tbaa !5
  %index.next147 = or disjoint i64 %index145, 4
  %34 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index.next147
  %35 = getelementptr inbounds i8, ptr %34, i64 16
  %wide.load.1 = load <2 x double>, ptr %34, align 16, !tbaa !5
  %wide.load146.1 = load <2 x double>, ptr %35, align 16, !tbaa !5
  %36 = fmul <2 x double> %wide.load.1, <double 2.000000e+00, double 2.000000e+00>
  %37 = fmul <2 x double> %wide.load146.1, <double 2.000000e+00, double 2.000000e+00>
  store <2 x double> %36, ptr %34, align 16, !tbaa !5
  store <2 x double> %37, ptr %35, align 16, !tbaa !5
  %index.next147.1 = add nuw nsw i64 %index145, 8
  %38 = icmp eq i64 %index.next147.1, 10000000
  br i1 %38, label %middle.block140, label %vector.body144, !llvm.loop !13

middle.block140:                                  ; preds = %vector.body144
  %39 = tail call double @mysecond()
  %40 = fsub double %39, %29
  %41 = fmul double %40, 1.000000e+06
  %42 = fptosi double %41 to i32
  %43 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.11, i32 noundef %42)
  %44 = fdiv double %41, %.0
  %45 = fptosi double %44 to i32
  %46 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.12, i32 noundef %45)
  %47 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.13)
  %48 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.14)
  %49 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %50 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15)
  %51 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16)
  %52 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.17)
  %53 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %54 = getelementptr inbounds i8, ptr %0, i64 80
  %55 = getelementptr inbounds i8, ptr %0, i64 160
  %56 = getelementptr inbounds i8, ptr %0, i64 240
  br label %vector.ph172

vector.ph172:                                     ; preds = %middle.block140, %middle.block148
  %indvars.iv = phi i64 [ 0, %middle.block140 ], [ %indvars.iv.next, %middle.block148 ]
  %57 = tail call double @mysecond()
  %58 = getelementptr inbounds [10 x double], ptr %0, i64 0, i64 %indvars.iv
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(80000000) @c, ptr noundef nonnull align 16 dereferenceable(80000000) @a, i64 80000000, i1 false), !tbaa !5
  %59 = tail call double @mysecond()
  %60 = fsub double %59, %57
  store double %60, ptr %58, align 8, !tbaa !5
  %61 = tail call double @mysecond()
  %62 = getelementptr inbounds [10 x double], ptr %54, i64 0, i64 %indvars.iv
  br label %vector.body174

vector.body174:                                   ; preds = %vector.body174, %vector.ph172
  %index175 = phi i64 [ 0, %vector.ph172 ], [ %index.next178.1, %vector.body174 ]
  %63 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index175
  %64 = getelementptr inbounds i8, ptr %63, i64 16
  %wide.load176 = load <2 x double>, ptr %63, align 16, !tbaa !5
  %wide.load177 = load <2 x double>, ptr %64, align 16, !tbaa !5
  %65 = fmul <2 x double> %wide.load176, <double 3.000000e+00, double 3.000000e+00>
  %66 = fmul <2 x double> %wide.load177, <double 3.000000e+00, double 3.000000e+00>
  %67 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index175
  %68 = getelementptr inbounds i8, ptr %67, i64 16
  store <2 x double> %65, ptr %67, align 16, !tbaa !5
  store <2 x double> %66, ptr %68, align 16, !tbaa !5
  %index.next178 = or disjoint i64 %index175, 4
  %69 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index.next178
  %70 = getelementptr inbounds i8, ptr %69, i64 16
  %wide.load176.1 = load <2 x double>, ptr %69, align 16, !tbaa !5
  %wide.load177.1 = load <2 x double>, ptr %70, align 16, !tbaa !5
  %71 = fmul <2 x double> %wide.load176.1, <double 3.000000e+00, double 3.000000e+00>
  %72 = fmul <2 x double> %wide.load177.1, <double 3.000000e+00, double 3.000000e+00>
  %73 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index.next178
  %74 = getelementptr inbounds i8, ptr %73, i64 16
  store <2 x double> %71, ptr %73, align 16, !tbaa !5
  store <2 x double> %72, ptr %74, align 16, !tbaa !5
  %index.next178.1 = add nuw nsw i64 %index175, 8
  %75 = icmp eq i64 %index.next178.1, 10000000
  br i1 %75, label %middle.block170, label %vector.body174, !llvm.loop !14

middle.block170:                                  ; preds = %vector.body174
  %76 = tail call double @mysecond()
  %77 = fsub double %76, %61
  store double %77, ptr %62, align 8, !tbaa !5
  %78 = tail call double @mysecond()
  %79 = getelementptr inbounds [10 x double], ptr %55, i64 0, i64 %indvars.iv
  br label %vector.body163

vector.body163:                                   ; preds = %vector.body163, %middle.block170
  %index164 = phi i64 [ 0, %middle.block170 ], [ %index.next169.1, %vector.body163 ]
  %80 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index164
  %81 = getelementptr inbounds i8, ptr %80, i64 16
  %wide.load165 = load <2 x double>, ptr %80, align 16, !tbaa !5
  %wide.load166 = load <2 x double>, ptr %81, align 16, !tbaa !5
  %82 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index164
  %83 = getelementptr inbounds i8, ptr %82, i64 16
  %wide.load167 = load <2 x double>, ptr %82, align 16, !tbaa !5
  %wide.load168 = load <2 x double>, ptr %83, align 16, !tbaa !5
  %84 = fadd <2 x double> %wide.load165, %wide.load167
  %85 = fadd <2 x double> %wide.load166, %wide.load168
  %86 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index164
  %87 = getelementptr inbounds i8, ptr %86, i64 16
  store <2 x double> %84, ptr %86, align 16, !tbaa !5
  store <2 x double> %85, ptr %87, align 16, !tbaa !5
  %index.next169 = or disjoint i64 %index164, 4
  %88 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index.next169
  %89 = getelementptr inbounds i8, ptr %88, i64 16
  %wide.load165.1 = load <2 x double>, ptr %88, align 16, !tbaa !5
  %wide.load166.1 = load <2 x double>, ptr %89, align 16, !tbaa !5
  %90 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index.next169
  %91 = getelementptr inbounds i8, ptr %90, i64 16
  %wide.load167.1 = load <2 x double>, ptr %90, align 16, !tbaa !5
  %wide.load168.1 = load <2 x double>, ptr %91, align 16, !tbaa !5
  %92 = fadd <2 x double> %wide.load165.1, %wide.load167.1
  %93 = fadd <2 x double> %wide.load166.1, %wide.load168.1
  %94 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index.next169
  %95 = getelementptr inbounds i8, ptr %94, i64 16
  store <2 x double> %92, ptr %94, align 16, !tbaa !5
  store <2 x double> %93, ptr %95, align 16, !tbaa !5
  %index.next169.1 = add nuw nsw i64 %index164, 8
  %96 = icmp eq i64 %index.next169.1, 10000000
  br i1 %96, label %middle.block159, label %vector.body163, !llvm.loop !15

middle.block159:                                  ; preds = %vector.body163
  %97 = tail call double @mysecond()
  %98 = fsub double %97, %78
  store double %98, ptr %79, align 8, !tbaa !5
  %99 = tail call double @mysecond()
  %100 = getelementptr inbounds [10 x double], ptr %56, i64 0, i64 %indvars.iv
  br label %vector.body152

vector.body152:                                   ; preds = %vector.body152, %middle.block159
  %index153 = phi i64 [ 0, %middle.block159 ], [ %index.next158.1, %vector.body152 ]
  %101 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index153
  %102 = getelementptr inbounds i8, ptr %101, i64 16
  %wide.load154 = load <2 x double>, ptr %101, align 16, !tbaa !5
  %wide.load155 = load <2 x double>, ptr %102, align 16, !tbaa !5
  %103 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index153
  %104 = getelementptr inbounds i8, ptr %103, i64 16
  %wide.load156 = load <2 x double>, ptr %103, align 16, !tbaa !5
  %wide.load157 = load <2 x double>, ptr %104, align 16, !tbaa !5
  %105 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load156, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %wide.load154)
  %106 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load157, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %wide.load155)
  %107 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index153
  %108 = getelementptr inbounds i8, ptr %107, i64 16
  store <2 x double> %105, ptr %107, align 16, !tbaa !5
  store <2 x double> %106, ptr %108, align 16, !tbaa !5
  %index.next158 = or disjoint i64 %index153, 4
  %109 = getelementptr inbounds [10000000 x double], ptr @b, i64 0, i64 %index.next158
  %110 = getelementptr inbounds i8, ptr %109, i64 16
  %wide.load154.1 = load <2 x double>, ptr %109, align 16, !tbaa !5
  %wide.load155.1 = load <2 x double>, ptr %110, align 16, !tbaa !5
  %111 = getelementptr inbounds [10000000 x double], ptr @c, i64 0, i64 %index.next158
  %112 = getelementptr inbounds i8, ptr %111, i64 16
  %wide.load156.1 = load <2 x double>, ptr %111, align 16, !tbaa !5
  %wide.load157.1 = load <2 x double>, ptr %112, align 16, !tbaa !5
  %113 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load156.1, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %wide.load154.1)
  %114 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load157.1, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %wide.load155.1)
  %115 = getelementptr inbounds [10000000 x double], ptr @a, i64 0, i64 %index.next158
  %116 = getelementptr inbounds i8, ptr %115, i64 16
  store <2 x double> %113, ptr %115, align 16, !tbaa !5
  store <2 x double> %114, ptr %116, align 16, !tbaa !5
  %index.next158.1 = add nuw nsw i64 %index153, 8
  %117 = icmp eq i64 %index.next158.1, 10000000
  br i1 %117, label %middle.block148, label %vector.body152, !llvm.loop !16

middle.block148:                                  ; preds = %vector.body152
  %118 = tail call double @mysecond()
  %119 = fsub double %118, %99
  store double %119, ptr %100, align 8, !tbaa !5
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond108.not = icmp eq i64 %indvars.iv.next, 10
  br i1 %exitcond108.not, label %.preheader, label %vector.ph172, !llvm.loop !17

.preheader:                                       ; preds = %middle.block148
  %120 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @maxtime, i64 16), align 16, !tbaa !5
  %121 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @mintime, i64 16), align 16, !tbaa !5
  %122 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @avgtime, i64 16), align 16, !tbaa !5
  %123 = load <2 x double>, ptr @maxtime, align 16, !tbaa !5
  %124 = load <2 x double>, ptr @mintime, align 16, !tbaa !5
  %125 = load <2 x double>, ptr @avgtime, align 16, !tbaa !5
  %126 = getelementptr inbounds i8, ptr %0, i64 8
  %127 = load double, ptr %126, align 8, !tbaa !5
  %128 = getelementptr inbounds i8, ptr %0, i64 88
  %129 = load double, ptr %128, align 8, !tbaa !5
  %130 = insertelement <2 x double> poison, double %127, i64 0
  %131 = insertelement <2 x double> %130, double %129, i64 1
  %132 = fadd <2 x double> %125, %131
  %133 = fcmp olt <2 x double> %124, %131
  %134 = select <2 x i1> %133, <2 x double> %124, <2 x double> %131
  %135 = fcmp ogt <2 x double> %123, %131
  %136 = select <2 x i1> %135, <2 x double> %123, <2 x double> %131
  %137 = getelementptr inbounds i8, ptr %0, i64 168
  %138 = load double, ptr %137, align 8, !tbaa !5
  %139 = getelementptr inbounds i8, ptr %0, i64 248
  %140 = load double, ptr %139, align 8, !tbaa !5
  %141 = insertelement <2 x double> poison, double %138, i64 0
  %142 = insertelement <2 x double> %141, double %140, i64 1
  %143 = fadd <2 x double> %122, %142
  %144 = fcmp olt <2 x double> %121, %142
  %145 = select <2 x i1> %144, <2 x double> %121, <2 x double> %142
  %146 = fcmp ogt <2 x double> %120, %142
  %147 = select <2 x i1> %146, <2 x double> %120, <2 x double> %142
  %148 = getelementptr inbounds i8, ptr %0, i64 16
  %149 = load double, ptr %148, align 16, !tbaa !5
  %150 = getelementptr inbounds i8, ptr %0, i64 96
  %151 = load double, ptr %150, align 16, !tbaa !5
  %152 = insertelement <2 x double> poison, double %149, i64 0
  %153 = insertelement <2 x double> %152, double %151, i64 1
  %154 = fadd <2 x double> %132, %153
  %155 = fcmp olt <2 x double> %134, %153
  %156 = select <2 x i1> %155, <2 x double> %134, <2 x double> %153
  %157 = fcmp ogt <2 x double> %136, %153
  %158 = select <2 x i1> %157, <2 x double> %136, <2 x double> %153
  %159 = getelementptr inbounds i8, ptr %0, i64 176
  %160 = load double, ptr %159, align 16, !tbaa !5
  %161 = getelementptr inbounds i8, ptr %0, i64 256
  %162 = load double, ptr %161, align 16, !tbaa !5
  %163 = insertelement <2 x double> poison, double %160, i64 0
  %164 = insertelement <2 x double> %163, double %162, i64 1
  %165 = fadd <2 x double> %143, %164
  %166 = fcmp olt <2 x double> %145, %164
  %167 = select <2 x i1> %166, <2 x double> %145, <2 x double> %164
  %168 = fcmp ogt <2 x double> %147, %164
  %169 = select <2 x i1> %168, <2 x double> %147, <2 x double> %164
  %170 = getelementptr inbounds i8, ptr %0, i64 24
  %171 = load double, ptr %170, align 8, !tbaa !5
  %172 = getelementptr inbounds i8, ptr %0, i64 104
  %173 = load double, ptr %172, align 8, !tbaa !5
  %174 = insertelement <2 x double> poison, double %171, i64 0
  %175 = insertelement <2 x double> %174, double %173, i64 1
  %176 = fadd <2 x double> %154, %175
  %177 = fcmp olt <2 x double> %156, %175
  %178 = select <2 x i1> %177, <2 x double> %156, <2 x double> %175
  %179 = fcmp ogt <2 x double> %158, %175
  %180 = select <2 x i1> %179, <2 x double> %158, <2 x double> %175
  %181 = getelementptr inbounds i8, ptr %0, i64 184
  %182 = load double, ptr %181, align 8, !tbaa !5
  %183 = getelementptr inbounds i8, ptr %0, i64 264
  %184 = load double, ptr %183, align 8, !tbaa !5
  %185 = insertelement <2 x double> poison, double %182, i64 0
  %186 = insertelement <2 x double> %185, double %184, i64 1
  %187 = fadd <2 x double> %165, %186
  %188 = fcmp olt <2 x double> %167, %186
  %189 = select <2 x i1> %188, <2 x double> %167, <2 x double> %186
  %190 = fcmp ogt <2 x double> %169, %186
  %191 = select <2 x i1> %190, <2 x double> %169, <2 x double> %186
  %192 = getelementptr inbounds i8, ptr %0, i64 32
  %193 = load double, ptr %192, align 16, !tbaa !5
  %194 = getelementptr inbounds i8, ptr %0, i64 112
  %195 = load double, ptr %194, align 16, !tbaa !5
  %196 = insertelement <2 x double> poison, double %193, i64 0
  %197 = insertelement <2 x double> %196, double %195, i64 1
  %198 = fadd <2 x double> %176, %197
  %199 = fcmp olt <2 x double> %178, %197
  %200 = select <2 x i1> %199, <2 x double> %178, <2 x double> %197
  %201 = fcmp ogt <2 x double> %180, %197
  %202 = select <2 x i1> %201, <2 x double> %180, <2 x double> %197
  %203 = getelementptr inbounds i8, ptr %0, i64 192
  %204 = load double, ptr %203, align 16, !tbaa !5
  %205 = getelementptr inbounds i8, ptr %0, i64 272
  %206 = load double, ptr %205, align 16, !tbaa !5
  %207 = insertelement <2 x double> poison, double %204, i64 0
  %208 = insertelement <2 x double> %207, double %206, i64 1
  %209 = fadd <2 x double> %187, %208
  %210 = fcmp olt <2 x double> %189, %208
  %211 = select <2 x i1> %210, <2 x double> %189, <2 x double> %208
  %212 = fcmp ogt <2 x double> %191, %208
  %213 = select <2 x i1> %212, <2 x double> %191, <2 x double> %208
  %214 = getelementptr inbounds i8, ptr %0, i64 40
  %215 = load double, ptr %214, align 8, !tbaa !5
  %216 = getelementptr inbounds i8, ptr %0, i64 120
  %217 = load double, ptr %216, align 8, !tbaa !5
  %218 = insertelement <2 x double> poison, double %215, i64 0
  %219 = insertelement <2 x double> %218, double %217, i64 1
  %220 = fadd <2 x double> %198, %219
  %221 = fcmp olt <2 x double> %200, %219
  %222 = select <2 x i1> %221, <2 x double> %200, <2 x double> %219
  %223 = fcmp ogt <2 x double> %202, %219
  %224 = select <2 x i1> %223, <2 x double> %202, <2 x double> %219
  %225 = getelementptr inbounds i8, ptr %0, i64 200
  %226 = load double, ptr %225, align 8, !tbaa !5
  %227 = getelementptr inbounds i8, ptr %0, i64 280
  %228 = load double, ptr %227, align 8, !tbaa !5
  %229 = insertelement <2 x double> poison, double %226, i64 0
  %230 = insertelement <2 x double> %229, double %228, i64 1
  %231 = fadd <2 x double> %209, %230
  %232 = fcmp olt <2 x double> %211, %230
  %233 = select <2 x i1> %232, <2 x double> %211, <2 x double> %230
  %234 = fcmp ogt <2 x double> %213, %230
  %235 = select <2 x i1> %234, <2 x double> %213, <2 x double> %230
  %236 = getelementptr inbounds i8, ptr %0, i64 48
  %237 = load double, ptr %236, align 16, !tbaa !5
  %238 = getelementptr inbounds i8, ptr %0, i64 128
  %239 = load double, ptr %238, align 16, !tbaa !5
  %240 = insertelement <2 x double> poison, double %237, i64 0
  %241 = insertelement <2 x double> %240, double %239, i64 1
  %242 = fadd <2 x double> %220, %241
  %243 = fcmp olt <2 x double> %222, %241
  %244 = select <2 x i1> %243, <2 x double> %222, <2 x double> %241
  %245 = fcmp ogt <2 x double> %224, %241
  %246 = select <2 x i1> %245, <2 x double> %224, <2 x double> %241
  %247 = getelementptr inbounds i8, ptr %0, i64 208
  %248 = load double, ptr %247, align 16, !tbaa !5
  %249 = getelementptr inbounds i8, ptr %0, i64 288
  %250 = load double, ptr %249, align 16, !tbaa !5
  %251 = insertelement <2 x double> poison, double %248, i64 0
  %252 = insertelement <2 x double> %251, double %250, i64 1
  %253 = fadd <2 x double> %231, %252
  %254 = fcmp olt <2 x double> %233, %252
  %255 = select <2 x i1> %254, <2 x double> %233, <2 x double> %252
  %256 = fcmp ogt <2 x double> %235, %252
  %257 = select <2 x i1> %256, <2 x double> %235, <2 x double> %252
  %258 = getelementptr inbounds i8, ptr %0, i64 56
  %259 = load double, ptr %258, align 8, !tbaa !5
  %260 = getelementptr inbounds i8, ptr %0, i64 136
  %261 = load double, ptr %260, align 8, !tbaa !5
  %262 = insertelement <2 x double> poison, double %259, i64 0
  %263 = insertelement <2 x double> %262, double %261, i64 1
  %264 = fadd <2 x double> %242, %263
  %265 = fcmp olt <2 x double> %244, %263
  %266 = select <2 x i1> %265, <2 x double> %244, <2 x double> %263
  %267 = fcmp ogt <2 x double> %246, %263
  %268 = select <2 x i1> %267, <2 x double> %246, <2 x double> %263
  %269 = getelementptr inbounds i8, ptr %0, i64 216
  %270 = load double, ptr %269, align 8, !tbaa !5
  %271 = getelementptr inbounds i8, ptr %0, i64 296
  %272 = load double, ptr %271, align 8, !tbaa !5
  %273 = insertelement <2 x double> poison, double %270, i64 0
  %274 = insertelement <2 x double> %273, double %272, i64 1
  %275 = fadd <2 x double> %253, %274
  %276 = fcmp olt <2 x double> %255, %274
  %277 = select <2 x i1> %276, <2 x double> %255, <2 x double> %274
  %278 = fcmp ogt <2 x double> %257, %274
  %279 = select <2 x i1> %278, <2 x double> %257, <2 x double> %274
  %280 = getelementptr inbounds i8, ptr %0, i64 64
  %281 = load double, ptr %280, align 16, !tbaa !5
  %282 = getelementptr inbounds i8, ptr %0, i64 144
  %283 = load double, ptr %282, align 16, !tbaa !5
  %284 = insertelement <2 x double> poison, double %281, i64 0
  %285 = insertelement <2 x double> %284, double %283, i64 1
  %286 = fadd <2 x double> %264, %285
  %287 = fcmp olt <2 x double> %266, %285
  %288 = select <2 x i1> %287, <2 x double> %266, <2 x double> %285
  %289 = fcmp ogt <2 x double> %268, %285
  %290 = select <2 x i1> %289, <2 x double> %268, <2 x double> %285
  %291 = getelementptr inbounds i8, ptr %0, i64 224
  %292 = load double, ptr %291, align 16, !tbaa !5
  %293 = getelementptr inbounds i8, ptr %0, i64 304
  %294 = load double, ptr %293, align 16, !tbaa !5
  %295 = insertelement <2 x double> poison, double %292, i64 0
  %296 = insertelement <2 x double> %295, double %294, i64 1
  %297 = fadd <2 x double> %275, %296
  %298 = fcmp olt <2 x double> %277, %296
  %299 = select <2 x i1> %298, <2 x double> %277, <2 x double> %296
  %300 = fcmp ogt <2 x double> %279, %296
  %301 = select <2 x i1> %300, <2 x double> %279, <2 x double> %296
  %302 = getelementptr inbounds i8, ptr %0, i64 72
  %303 = load double, ptr %302, align 8, !tbaa !5
  %304 = getelementptr inbounds i8, ptr %0, i64 152
  %305 = load double, ptr %304, align 8, !tbaa !5
  %306 = insertelement <2 x double> poison, double %303, i64 0
  %307 = insertelement <2 x double> %306, double %305, i64 1
  %308 = fadd <2 x double> %286, %307
  %309 = fcmp olt <2 x double> %288, %307
  %310 = select <2 x i1> %309, <2 x double> %288, <2 x double> %307
  %311 = fcmp ogt <2 x double> %290, %307
  %312 = select <2 x i1> %311, <2 x double> %290, <2 x double> %307
  %313 = getelementptr inbounds i8, ptr %0, i64 232
  %314 = load double, ptr %313, align 8, !tbaa !5
  %315 = getelementptr inbounds i8, ptr %0, i64 312
  %316 = load double, ptr %315, align 8, !tbaa !5
  %317 = insertelement <2 x double> poison, double %314, i64 0
  %318 = insertelement <2 x double> %317, double %316, i64 1
  %319 = fadd <2 x double> %297, %318
  %320 = fcmp olt <2 x double> %299, %318
  %321 = select <2 x i1> %320, <2 x double> %299, <2 x double> %318
  %322 = fcmp ogt <2 x double> %301, %318
  %323 = select <2 x i1> %322, <2 x double> %301, <2 x double> %318
  store <2 x double> %308, ptr @avgtime, align 16, !tbaa !5
  store <2 x double> %310, ptr @mintime, align 16, !tbaa !5
  store <2 x double> %312, ptr @maxtime, align 16, !tbaa !5
  store <2 x double> %319, ptr getelementptr inbounds (i8, ptr @avgtime, i64 16), align 16, !tbaa !5
  store <2 x double> %321, ptr getelementptr inbounds (i8, ptr @mintime, i64 16), align 16, !tbaa !5
  store <2 x double> %323, ptr getelementptr inbounds (i8, ptr @maxtime, i64 16), align 16, !tbaa !5
  %324 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18)
  %325 = load double, ptr @avgtime, align 16, !tbaa !5
  %326 = fdiv double %325, 9.000000e+00
  store double %326, ptr @avgtime, align 16, !tbaa !5
  %327 = load ptr, ptr @label, align 16, !tbaa !18
  %328 = load double, ptr @bytes, align 16, !tbaa !5
  %329 = fmul double %328, 0x3EB0C6F7A0B5ED8D
  %330 = load double, ptr @mintime, align 16, !tbaa !5
  %331 = fdiv double %329, %330
  %332 = load double, ptr @maxtime, align 16, !tbaa !5
  %333 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.19, ptr noundef %327, double noundef %331, double noundef %326, double noundef %330, double noundef %332)
  %334 = load double, ptr getelementptr inbounds (i8, ptr @avgtime, i64 8), align 8, !tbaa !5
  %335 = fdiv double %334, 9.000000e+00
  store double %335, ptr getelementptr inbounds (i8, ptr @avgtime, i64 8), align 8, !tbaa !5
  %336 = load ptr, ptr getelementptr inbounds (i8, ptr @label, i64 8), align 8, !tbaa !18
  %337 = load double, ptr getelementptr inbounds (i8, ptr @bytes, i64 8), align 8, !tbaa !5
  %338 = fmul double %337, 0x3EB0C6F7A0B5ED8D
  %339 = load double, ptr getelementptr inbounds (i8, ptr @mintime, i64 8), align 8, !tbaa !5
  %340 = fdiv double %338, %339
  %341 = load double, ptr getelementptr inbounds (i8, ptr @maxtime, i64 8), align 8, !tbaa !5
  %342 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.19, ptr noundef %336, double noundef %340, double noundef %335, double noundef %339, double noundef %341)
  %343 = load double, ptr getelementptr inbounds (i8, ptr @avgtime, i64 16), align 16, !tbaa !5
  %344 = fdiv double %343, 9.000000e+00
  store double %344, ptr getelementptr inbounds (i8, ptr @avgtime, i64 16), align 16, !tbaa !5
  %345 = load ptr, ptr getelementptr inbounds (i8, ptr @label, i64 16), align 16, !tbaa !18
  %346 = load double, ptr getelementptr inbounds (i8, ptr @bytes, i64 16), align 16, !tbaa !5
  %347 = fmul double %346, 0x3EB0C6F7A0B5ED8D
  %348 = load double, ptr getelementptr inbounds (i8, ptr @mintime, i64 16), align 16, !tbaa !5
  %349 = fdiv double %347, %348
  %350 = load double, ptr getelementptr inbounds (i8, ptr @maxtime, i64 16), align 16, !tbaa !5
  %351 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.19, ptr noundef %345, double noundef %349, double noundef %344, double noundef %348, double noundef %350)
  %352 = load double, ptr getelementptr inbounds (i8, ptr @avgtime, i64 24), align 8, !tbaa !5
  %353 = fdiv double %352, 9.000000e+00
  store double %353, ptr getelementptr inbounds (i8, ptr @avgtime, i64 24), align 8, !tbaa !5
  %354 = load ptr, ptr getelementptr inbounds (i8, ptr @label, i64 24), align 8, !tbaa !18
  %355 = load double, ptr getelementptr inbounds (i8, ptr @bytes, i64 24), align 8, !tbaa !5
  %356 = fmul double %355, 0x3EB0C6F7A0B5ED8D
  %357 = load double, ptr getelementptr inbounds (i8, ptr @mintime, i64 24), align 8, !tbaa !5
  %358 = fdiv double %356, %357
  %359 = load double, ptr getelementptr inbounds (i8, ptr @maxtime, i64 24), align 8, !tbaa !5
  %360 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.19, ptr noundef %354, double noundef %358, double noundef %353, double noundef %357, double noundef %359)
  %361 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  tail call void @checkSTREAMresults()
  %362 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  call void @llvm.lifetime.end.p0(i64 320, ptr nonnull %0) #6
  ret i32 0
}

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

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

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @checktick() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local double @mysecond() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local void @checkSTREAMresults() local_unnamed_addr #0

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #4

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nounwind }

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

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


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