; LLVM IR from jingweizhanghuai/Morn :: src/math (morn_matrix)

; 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.MMatrix = type { i32, i32, ptr }

@.str = external hidden unnamed_addr constant [78 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [19 x i8], align 1
@__FUNCTION__.m_MatrixScale = external hidden unnamed_addr constant [14 x i8], align 1

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

declare void @m_Exception(i32 noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, ptr noundef, ...) #1

; 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
declare dso_local void @MatrixRedefine(ptr noundef, i32 noundef, i32 noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
define dso_local void @m_MatrixScale(ptr noundef %0, ptr noundef %1, float noundef %2, float noundef %3) #2 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca float, align 4
  %8 = alloca float, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store float %2, ptr %7, align 4, !tbaa !9
  store float %3, ptr %8, align 4, !tbaa !9
  br label %18

18:                                               ; preds = %4
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #4
  %19 = load ptr, ptr %5, align 8, !tbaa !5
  %20 = icmp eq ptr %19, null
  br i1 %20, label %25, label %21

21:                                               ; preds = %18
  %22 = load ptr, ptr %5, align 8, !tbaa !5
  %23 = ptrtoint ptr %22 to i64
  %24 = icmp eq i64 %23, -1
  br i1 %24, label %25, label %26

25:                                               ; preds = %21, %18
  br label %50

26:                                               ; preds = %21
  %27 = load ptr, ptr %5, align 8, !tbaa !5
  %28 = getelementptr inbounds %struct.MMatrix, ptr %27, i32 0, i32 2
  %29 = load ptr, ptr %28, align 8, !tbaa !11
  %30 = icmp eq ptr %29, null
  br i1 %30, label %47, label %31

31:                                               ; preds = %26
  %32 = load ptr, ptr %5, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.MMatrix, ptr %32, i32 0, i32 2
  %34 = load ptr, ptr %33, align 8, !tbaa !11
  %35 = ptrtoint ptr %34 to i64
  %36 = icmp sle i64 %35, 0
  br i1 %36, label %47, label %37

37:                                               ; preds = %31
  %38 = load ptr, ptr %5, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.MMatrix, ptr %38, i32 0, i32 1
  %40 = load i32, ptr %39, align 4, !tbaa !14
  %41 = icmp sle i32 %40, 0
  br i1 %41, label %47, label %42

42:                                               ; preds = %37
  %43 = load ptr, ptr %5, align 8, !tbaa !5
  %44 = getelementptr inbounds %struct.MMatrix, ptr %43, i32 0, i32 0
  %45 = load i32, ptr %44, align 8, !tbaa !15
  %46 = icmp sle i32 %45, 0
  br label %47

47:                                               ; preds = %42, %37, %31, %26
  %48 = phi i1 [ true, %37 ], [ true, %31 ], [ true, %26 ], [ %46, %42 ]
  %49 = zext i1 %48 to i32
  br label %50

50:                                               ; preds = %47, %25
  %51 = phi i32 [ 1, %25 ], [ %49, %47 ]
  store i32 %51, ptr %9, align 4, !tbaa !16
  %52 = load i32, ptr %9, align 4, !tbaa !16
  %53 = icmp ne i32 %52, 0
  br i1 %53, label %54, label %56

54:                                               ; preds = %50
  %55 = load i32, ptr %9, align 4, !tbaa !16
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %55, i32 noundef -1, ptr noundef @.str, i32 noundef 318, ptr noundef @__FUNCTION__.m_MatrixScale, ptr noundef @.str.2)
  br label %56

56:                                               ; preds = %54, %50
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #4
  br label %57

57:                                               ; preds = %56
  %58 = load ptr, ptr %6, align 8, !tbaa !5
  %59 = load ptr, ptr %5, align 8, !tbaa !5
  %60 = icmp ne ptr %58, %59
  br i1 %60, label %61, label %101

61:                                               ; preds = %57
  br label %62

62:                                               ; preds = %61
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #4
  store i32 3, ptr %10, align 4, !tbaa !16
  %63 = load i32, ptr %10, align 4, !tbaa !16
  %64 = icmp eq i32 %63, 2
  br i1 %64, label %65, label %77

65:                                               ; preds = %62
  %66 = load ptr, ptr %6, align 8, !tbaa !5
  %67 = load ptr, ptr %5, align 8, !tbaa !5
  %68 = getelementptr inbounds %struct.MMatrix, ptr %67, i32 0, i32 0
  %69 = load i32, ptr %68, align 8, !tbaa !15
  %70 = add nsw i32 %69, 0
  %71 = load ptr, ptr %5, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.MMatrix, ptr %71, i32 0, i32 1
  %73 = load i32, ptr %72, align 4, !tbaa !14
  %74 = load ptr, ptr %6, align 8, !tbaa !5
  %75 = getelementptr inbounds %struct.MMatrix, ptr %74, i32 0, i32 2
  %76 = load ptr, ptr %75, align 8, !tbaa !11
  call void @MatrixRedefine(ptr noundef %66, i32 noundef %70, i32 noundef %73, ptr noundef %76)
  br label %99

77:                                               ; preds = %62
  %78 = load i32, ptr %10, align 4, !tbaa !16
  %79 = icmp eq i32 %78, 3
  br i1 %79, label %80, label %89

80:                                               ; preds = %77
  %81 = load ptr, ptr %6, align 8, !tbaa !5
  %82 = load ptr, ptr %5, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.MMatrix, ptr %82, i32 0, i32 0
  %84 = load i32, ptr %83, align 8, !tbaa !15
  %85 = add nsw i32 %84, 0
  %86 = load ptr, ptr %5, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.MMatrix, ptr %86, i32 0, i32 1
  %88 = load i32, ptr %87, align 4, !tbaa !14
  call void @MatrixRedefine(ptr noundef %81, i32 noundef %85, i32 noundef %88, ptr noundef null)
  br label %98

89:                                               ; preds = %77
  br label %90

90:                                               ; preds = %89
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #4
  store i32 1, ptr %11, align 4, !tbaa !16
  %91 = load i32, ptr %11, align 4, !tbaa !16
  %92 = icmp ne i32 %91, 0
  br i1 %92, label %93, label %95

93:                                               ; preds = %90
  %94 = load i32, ptr %11, align 4, !tbaa !16
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %94, i32 noundef -1, ptr noundef @.str, i32 noundef 319, ptr noundef @__FUNCTION__.m_MatrixScale, ptr noundef @.str.11)
  br label %95

95:                                               ; preds = %93, %90
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #4
  br label %96

96:                                               ; preds = %95
  br label %97

97:                                               ; preds = %96
  br label %98

98:                                               ; preds = %97, %80
  br label %99

99:                                               ; preds = %98, %65
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  br label %100

100:                                              ; preds = %99
  br label %101

101:                                              ; preds = %100, %57
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #4
  %102 = load ptr, ptr %5, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.MMatrix, ptr %102, i32 0, i32 2
  %104 = load ptr, ptr %103, align 8, !tbaa !11
  store ptr %104, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #4
  %105 = load ptr, ptr %6, align 8, !tbaa !5
  %106 = getelementptr inbounds %struct.MMatrix, ptr %105, i32 0, i32 2
  %107 = load ptr, ptr %106, align 8, !tbaa !11
  store ptr %107, ptr %13, align 8, !tbaa !5
  %108 = load float, ptr %8, align 4, !tbaa !9
  %109 = fcmp une float %108, 0.000000e+00
  br i1 %109, label %110, label %252

110:                                              ; preds = %101
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #4
  store i32 0, ptr %14, align 4, !tbaa !16
  br label %111

111:                                              ; preds = %248, %110
  %112 = load i32, ptr %14, align 4, !tbaa !16
  %113 = load ptr, ptr %5, align 8, !tbaa !5
  %114 = getelementptr inbounds %struct.MMatrix, ptr %113, i32 0, i32 0
  %115 = load i32, ptr %114, align 8, !tbaa !15
  %116 = icmp slt i32 %112, %115
  br i1 %116, label %118, label %117

117:                                              ; preds = %111
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  br label %251

118:                                              ; preds = %111
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  store i32 0, ptr %15, align 4, !tbaa !16
  br label %119

119:                                              ; preds = %213, %118
  %120 = load i32, ptr %15, align 4, !tbaa !16
  %121 = load ptr, ptr %5, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.MMatrix, ptr %121, i32 0, i32 1
  %123 = load i32, ptr %122, align 4, !tbaa !14
  %124 = sub nsw i32 %123, 3
  %125 = icmp slt i32 %120, %124
  br i1 %125, label %126, label %216

126:                                              ; preds = %119
  %127 = load ptr, ptr %12, align 8, !tbaa !5
  %128 = load i32, ptr %14, align 4, !tbaa !16
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds ptr, ptr %127, i64 %129
  %131 = load ptr, ptr %130, align 8, !tbaa !5
  %132 = load i32, ptr %15, align 4, !tbaa !16
  %133 = sext i32 %132 to i64
  %134 = getelementptr inbounds float, ptr %131, i64 %133
  %135 = load float, ptr %134, align 4, !tbaa !9
  %136 = load float, ptr %7, align 4, !tbaa !9
  %137 = load float, ptr %8, align 4, !tbaa !9
  %138 = call float @llvm.fmuladd.f32(float %135, float %136, float %137)
  %139 = load ptr, ptr %13, align 8, !tbaa !5
  %140 = load i32, ptr %14, align 4, !tbaa !16
  %141 = sext i32 %140 to i64
  %142 = getelementptr inbounds ptr, ptr %139, i64 %141
  %143 = load ptr, ptr %142, align 8, !tbaa !5
  %144 = load i32, ptr %15, align 4, !tbaa !16
  %145 = sext i32 %144 to i64
  %146 = getelementptr inbounds float, ptr %143, i64 %145
  store float %138, ptr %146, align 4, !tbaa !9
  %147 = load ptr, ptr %12, align 8, !tbaa !5
  %148 = load i32, ptr %14, align 4, !tbaa !16
  %149 = sext i32 %148 to i64
  %150 = getelementptr inbounds ptr, ptr %147, i64 %149
  %151 = load ptr, ptr %150, align 8, !tbaa !5
  %152 = load i32, ptr %15, align 4, !tbaa !16
  %153 = add nsw i32 %152, 1
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds float, ptr %151, i64 %154
  %156 = load float, ptr %155, align 4, !tbaa !9
  %157 = load float, ptr %7, align 4, !tbaa !9
  %158 = load float, ptr %8, align 4, !tbaa !9
  %159 = call float @llvm.fmuladd.f32(float %156, float %157, float %158)
  %160 = load ptr, ptr %13, align 8, !tbaa !5
  %161 = load i32, ptr %14, align 4, !tbaa !16
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds ptr, ptr %160, i64 %162
  %164 = load ptr, ptr %163, align 8, !tbaa !5
  %165 = load i32, ptr %15, align 4, !tbaa !16
  %166 = add nsw i32 %165, 1
  %167 = sext i32 %166 to i64
  %168 = getelementptr inbounds float, ptr %164, i64 %167
  store float %159, ptr %168, align 4, !tbaa !9
  %169 = load ptr, ptr %12, align 8, !tbaa !5
  %170 = load i32, ptr %14, align 4, !tbaa !16
  %171 = sext i32 %170 to i64
  %172 = getelementptr inbounds ptr, ptr %169, i64 %171
  %173 = load ptr, ptr %172, align 8, !tbaa !5
  %174 = load i32, ptr %15, align 4, !tbaa !16
  %175 = add nsw i32 %174, 2
  %176 = sext i32 %175 to i64
  %177 = getelementptr inbounds float, ptr %173, i64 %176
  %178 = load float, ptr %177, align 4, !tbaa !9
  %179 = load float, ptr %7, align 4, !tbaa !9
  %180 = load float, ptr %8, align 4, !tbaa !9
  %181 = call float @llvm.fmuladd.f32(float %178, float %179, float %180)
  %182 = load ptr, ptr %13, align 8, !tbaa !5
  %183 = load i32, ptr %14, align 4, !tbaa !16
  %184 = sext i32 %183 to i64
  %185 = getelementptr inbounds ptr, ptr %182, i64 %184
  %186 = load ptr, ptr %185, align 8, !tbaa !5
  %187 = load i32, ptr %15, align 4, !tbaa !16
  %188 = add nsw i32 %187, 2
  %189 = sext i32 %188 to i64
  %190 = getelementptr inbounds float, ptr %186, i64 %189
  store float %181, ptr %190, align 4, !tbaa !9
  %191 = load ptr, ptr %12, align 8, !tbaa !5
  %192 = load i32, ptr %14, align 4, !tbaa !16
  %193 = sext i32 %192 to i64
  %194 = getelementptr inbounds ptr, ptr %191, i64 %193
  %195 = load ptr, ptr %194, align 8, !tbaa !5
  %196 = load i32, ptr %15, align 4, !tbaa !16
  %197 = add nsw i32 %196, 3
  %198 = sext i32 %197 to i64
  %199 = getelementptr inbounds float, ptr %195, i64 %198
  %200 = load float, ptr %199, align 4, !tbaa !9
  %201 = load float, ptr %7, align 4, !tbaa !9
  %202 = load float, ptr %8, align 4, !tbaa !9
  %203 = call float @llvm.fmuladd.f32(float %200, float %201, float %202)
  %204 = load ptr, ptr %13, align 8, !tbaa !5
  %205 = load i32, ptr %14, align 4, !tbaa !16
  %206 = sext i32 %205 to i64
  %207 = getelementptr inbounds ptr, ptr %204, i64 %206
  %208 = load ptr, ptr %207, align 8, !tbaa !5
  %209 = load i32, ptr %15, align 4, !tbaa !16
  %210 = add nsw i32 %209, 3
  %211 = sext i32 %210 to i64
  %212 = getelementptr inbounds float, ptr %208, i64 %211
  store float %203, ptr %212, align 4, !tbaa !9
  br label %213

213:                                              ; preds = %126
  %214 = load i32, ptr %15, align 4, !tbaa !16
  %215 = add nsw i32 %214, 4
  store i32 %215, ptr %15, align 4, !tbaa !16
  br label %119, !llvm.loop !17

216:                                              ; preds = %119
  br label %217

217:                                              ; preds = %244, %216
  %218 = load i32, ptr %15, align 4, !tbaa !16
  %219 = load ptr, ptr %5, align 8, !tbaa !5
  %220 = getelementptr inbounds %struct.MMatrix, ptr %219, i32 0, i32 1
  %221 = load i32, ptr %220, align 4, !tbaa !14
  %222 = icmp slt i32 %218, %221
  br i1 %222, label %223, label %247

223:                                              ; preds = %217
  %224 = load ptr, ptr %12, align 8, !tbaa !5
  %225 = load i32, ptr %14, align 4, !tbaa !16
  %226 = sext i32 %225 to i64
  %227 = getelementptr inbounds ptr, ptr %224, i64 %226
  %228 = load ptr, ptr %227, align 8, !tbaa !5
  %229 = load i32, ptr %15, align 4, !tbaa !16
  %230 = sext i32 %229 to i64
  %231 = getelementptr inbounds float, ptr %228, i64 %230
  %232 = load float, ptr %231, align 4, !tbaa !9
  %233 = load float, ptr %7, align 4, !tbaa !9
  %234 = load float, ptr %8, align 4, !tbaa !9
  %235 = call float @llvm.fmuladd.f32(float %232, float %233, float %234)
  %236 = load ptr, ptr %13, align 8, !tbaa !5
  %237 = load i32, ptr %14, align 4, !tbaa !16
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds ptr, ptr %236, i64 %238
  %240 = load ptr, ptr %239, align 8, !tbaa !5
  %241 = load i32, ptr %15, align 4, !tbaa !16
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds float, ptr %240, i64 %242
  store float %235, ptr %243, align 4, !tbaa !9
  br label %244

244:                                              ; preds = %223
  %245 = load i32, ptr %15, align 4, !tbaa !16
  %246 = add nsw i32 %245, 1
  store i32 %246, ptr %15, align 4, !tbaa !16
  br label %217, !llvm.loop !19

247:                                              ; preds = %217
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  br label %248

248:                                              ; preds = %247
  %249 = load i32, ptr %14, align 4, !tbaa !16
  %250 = add nsw i32 %249, 1
  store i32 %250, ptr %14, align 4, !tbaa !16
  br label %111, !llvm.loop !20

251:                                              ; preds = %117
  br label %389

252:                                              ; preds = %101
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #4
  store i32 0, ptr %16, align 4, !tbaa !16
  br label %253

253:                                              ; preds = %385, %252
  %254 = load i32, ptr %16, align 4, !tbaa !16
  %255 = load ptr, ptr %5, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.MMatrix, ptr %255, i32 0, i32 0
  %257 = load i32, ptr %256, align 8, !tbaa !15
  %258 = icmp slt i32 %254, %257
  br i1 %258, label %260, label %259

259:                                              ; preds = %253
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  br label %388

260:                                              ; preds = %253
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  store i32 0, ptr %17, align 4, !tbaa !16
  br label %261

261:                                              ; preds = %351, %260
  %262 = load i32, ptr %17, align 4, !tbaa !16
  %263 = load ptr, ptr %5, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.MMatrix, ptr %263, i32 0, i32 1
  %265 = load i32, ptr %264, align 4, !tbaa !14
  %266 = sub nsw i32 %265, 3
  %267 = icmp slt i32 %262, %266
  br i1 %267, label %268, label %354

268:                                              ; preds = %261
  %269 = load ptr, ptr %12, align 8, !tbaa !5
  %270 = load i32, ptr %16, align 4, !tbaa !16
  %271 = sext i32 %270 to i64
  %272 = getelementptr inbounds ptr, ptr %269, i64 %271
  %273 = load ptr, ptr %272, align 8, !tbaa !5
  %274 = load i32, ptr %17, align 4, !tbaa !16
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds float, ptr %273, i64 %275
  %277 = load float, ptr %276, align 4, !tbaa !9
  %278 = load float, ptr %7, align 4, !tbaa !9
  %279 = fmul float %277, %278
  %280 = load ptr, ptr %13, align 8, !tbaa !5
  %281 = load i32, ptr %16, align 4, !tbaa !16
  %282 = sext i32 %281 to i64
  %283 = getelementptr inbounds ptr, ptr %280, i64 %282
  %284 = load ptr, ptr %283, align 8, !tbaa !5
  %285 = load i32, ptr %17, align 4, !tbaa !16
  %286 = sext i32 %285 to i64
  %287 = getelementptr inbounds float, ptr %284, i64 %286
  store float %279, ptr %287, align 4, !tbaa !9
  %288 = load ptr, ptr %12, align 8, !tbaa !5
  %289 = load i32, ptr %16, align 4, !tbaa !16
  %290 = sext i32 %289 to i64
  %291 = getelementptr inbounds ptr, ptr %288, i64 %290
  %292 = load ptr, ptr %291, align 8, !tbaa !5
  %293 = load i32, ptr %17, align 4, !tbaa !16
  %294 = add nsw i32 %293, 1
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds float, ptr %292, i64 %295
  %297 = load float, ptr %296, align 4, !tbaa !9
  %298 = load float, ptr %7, align 4, !tbaa !9
  %299 = fmul float %297, %298
  %300 = load ptr, ptr %13, align 8, !tbaa !5
  %301 = load i32, ptr %16, align 4, !tbaa !16
  %302 = sext i32 %301 to i64
  %303 = getelementptr inbounds ptr, ptr %300, i64 %302
  %304 = load ptr, ptr %303, align 8, !tbaa !5
  %305 = load i32, ptr %17, align 4, !tbaa !16
  %306 = add nsw i32 %305, 1
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds float, ptr %304, i64 %307
  store float %299, ptr %308, align 4, !tbaa !9
  %309 = load ptr, ptr %12, align 8, !tbaa !5
  %310 = load i32, ptr %16, align 4, !tbaa !16
  %311 = sext i32 %310 to i64
  %312 = getelementptr inbounds ptr, ptr %309, i64 %311
  %313 = load ptr, ptr %312, align 8, !tbaa !5
  %314 = load i32, ptr %17, align 4, !tbaa !16
  %315 = add nsw i32 %314, 2
  %316 = sext i32 %315 to i64
  %317 = getelementptr inbounds float, ptr %313, i64 %316
  %318 = load float, ptr %317, align 4, !tbaa !9
  %319 = load float, ptr %7, align 4, !tbaa !9
  %320 = fmul float %318, %319
  %321 = load ptr, ptr %13, align 8, !tbaa !5
  %322 = load i32, ptr %16, align 4, !tbaa !16
  %323 = sext i32 %322 to i64
  %324 = getelementptr inbounds ptr, ptr %321, i64 %323
  %325 = load ptr, ptr %324, align 8, !tbaa !5
  %326 = load i32, ptr %17, align 4, !tbaa !16
  %327 = add nsw i32 %326, 2
  %328 = sext i32 %327 to i64
  %329 = getelementptr inbounds float, ptr %325, i64 %328
  store float %320, ptr %329, align 4, !tbaa !9
  %330 = load ptr, ptr %12, align 8, !tbaa !5
  %331 = load i32, ptr %16, align 4, !tbaa !16
  %332 = sext i32 %331 to i64
  %333 = getelementptr inbounds ptr, ptr %330, i64 %332
  %334 = load ptr, ptr %333, align 8, !tbaa !5
  %335 = load i32, ptr %17, align 4, !tbaa !16
  %336 = add nsw i32 %335, 3
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds float, ptr %334, i64 %337
  %339 = load float, ptr %338, align 4, !tbaa !9
  %340 = load float, ptr %7, align 4, !tbaa !9
  %341 = fmul float %339, %340
  %342 = load ptr, ptr %13, align 8, !tbaa !5
  %343 = load i32, ptr %16, align 4, !tbaa !16
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds ptr, ptr %342, i64 %344
  %346 = load ptr, ptr %345, align 8, !tbaa !5
  %347 = load i32, ptr %17, align 4, !tbaa !16
  %348 = add nsw i32 %347, 3
  %349 = sext i32 %348 to i64
  %350 = getelementptr inbounds float, ptr %346, i64 %349
  store float %341, ptr %350, align 4, !tbaa !9
  br label %351

351:                                              ; preds = %268
  %352 = load i32, ptr %17, align 4, !tbaa !16
  %353 = add nsw i32 %352, 4
  store i32 %353, ptr %17, align 4, !tbaa !16
  br label %261, !llvm.loop !21

354:                                              ; preds = %261
  br label %355

355:                                              ; preds = %381, %354
  %356 = load i32, ptr %17, align 4, !tbaa !16
  %357 = load ptr, ptr %5, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.MMatrix, ptr %357, i32 0, i32 1
  %359 = load i32, ptr %358, align 4, !tbaa !14
  %360 = icmp slt i32 %356, %359
  br i1 %360, label %361, label %384

361:                                              ; preds = %355
  %362 = load ptr, ptr %12, align 8, !tbaa !5
  %363 = load i32, ptr %16, align 4, !tbaa !16
  %364 = sext i32 %363 to i64
  %365 = getelementptr inbounds ptr, ptr %362, i64 %364
  %366 = load ptr, ptr %365, align 8, !tbaa !5
  %367 = load i32, ptr %17, align 4, !tbaa !16
  %368 = sext i32 %367 to i64
  %369 = getelementptr inbounds float, ptr %366, i64 %368
  %370 = load float, ptr %369, align 4, !tbaa !9
  %371 = load float, ptr %7, align 4, !tbaa !9
  %372 = fmul float %370, %371
  %373 = load ptr, ptr %13, align 8, !tbaa !5
  %374 = load i32, ptr %16, align 4, !tbaa !16
  %375 = sext i32 %374 to i64
  %376 = getelementptr inbounds ptr, ptr %373, i64 %375
  %377 = load ptr, ptr %376, align 8, !tbaa !5
  %378 = load i32, ptr %17, align 4, !tbaa !16
  %379 = sext i32 %378 to i64
  %380 = getelementptr inbounds float, ptr %377, i64 %379
  store float %372, ptr %380, align 4, !tbaa !9
  br label %381

381:                                              ; preds = %361
  %382 = load i32, ptr %17, align 4, !tbaa !16
  %383 = add nsw i32 %382, 1
  store i32 %383, ptr %17, align 4, !tbaa !16
  br label %355, !llvm.loop !22

384:                                              ; preds = %355
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  br label %385

385:                                              ; preds = %384
  %386 = load i32, ptr %16, align 4, !tbaa !16
  %387 = add nsw i32 %386, 1
  store i32 %387, ptr %16, align 4, !tbaa !16
  br label %253, !llvm.loop !23

388:                                              ; preds = %259
  br label %389

389:                                              ; preds = %388, %251
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #4
  ret void
}

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

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 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 #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 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !6, i64 8}
!12 = !{!"MMatrix", !13, i64 0, !13, i64 4, !6, i64 8}
!13 = !{!"int", !7, i64 0}
!14 = !{!12, !13, i64 4}
!15 = !{!12, !13, i64 0}
!16 = !{!13, !13, i64 0}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = distinct !{!19, !18}
!20 = distinct !{!20, !18}
!21 = distinct !{!21, !18}
!22 = distinct !{!22, !18}
!23 = distinct !{!23, !18}


; 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 [78 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [14 x i8], align 1
@__FUNCTION__.m_MatrixScale = external hidden unnamed_addr constant [14 x i8], align 1

declare void @m_Exception(i32 noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, ptr noundef, ...) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local void @MatrixRedefine(ptr noundef, i32 noundef, i32 noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local void @m_MatrixScale(ptr noundef %0, ptr noundef %1, float noundef %2, float noundef %3) local_unnamed_addr #1 {
  %magicptr = ptrtoint ptr %0 to i64
  switch i64 %magicptr, label %5 [
    i64 -1, label %.critedge
    i64 0, label %.critedge
  ]

5:                                                ; preds = %4
  %6 = getelementptr inbounds i8, ptr %0, i64 8
  %7 = load ptr, ptr %6, align 8, !tbaa !5
  %8 = icmp slt ptr %7, inttoptr (i64 1 to ptr)
  br i1 %8, label %.critedge, label %9

9:                                                ; preds = %5
  %10 = getelementptr inbounds i8, ptr %0, i64 4
  %11 = load i32, ptr %10, align 4, !tbaa !11
  %12 = icmp slt i32 %11, 1
  br i1 %12, label %.critedge, label %13

13:                                               ; preds = %9
  %14 = load i32, ptr %0, align 8, !tbaa !12
  %15 = icmp sgt i32 %14, 0
  br i1 %15, label %16, label %.critedge

.critedge:                                        ; preds = %4, %4, %9, %5, %13
  tail call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef 1, i32 noundef -1, ptr noundef nonnull @.str, i32 noundef 318, ptr noundef nonnull @__FUNCTION__.m_MatrixScale, ptr noundef nonnull @.str.2) #4
  br label %16

16:                                               ; preds = %.critedge, %13
  %.not128 = icmp eq ptr %1, %0
  br i1 %.not128, label %21, label %17

17:                                               ; preds = %16
  %18 = load i32, ptr %0, align 8, !tbaa !12
  %19 = getelementptr inbounds i8, ptr %0, i64 4
  %20 = load i32, ptr %19, align 4, !tbaa !11
  tail call void @MatrixRedefine(ptr noundef %1, i32 noundef %18, i32 noundef %20, ptr noundef null)
  br label %21

21:                                               ; preds = %17, %16
  %22 = getelementptr inbounds i8, ptr %0, i64 8
  %23 = load ptr, ptr %22, align 8, !tbaa !5
  %24 = getelementptr inbounds i8, ptr %1, i64 8
  %25 = load ptr, ptr %24, align 8, !tbaa !5
  %26 = fcmp une float %3, 0.000000e+00
  %27 = load i32, ptr %0, align 8, !tbaa !12
  %28 = icmp sgt i32 %27, 0
  br i1 %26, label %.preheader130, label %.preheader133

.preheader133:                                    ; preds = %21
  br i1 %28, label %.preheader132.lr.ph, label %.loopexit

.preheader132.lr.ph:                              ; preds = %.preheader133
  %29 = getelementptr inbounds i8, ptr %0, i64 4
  %30 = load i32, ptr %29, align 4, !tbaa !11
  %31 = icmp sgt i32 %30, 3
  br i1 %31, label %.preheader132.us.preheader, label %.preheader132.lr.ph.split

.preheader132.us.preheader:                       ; preds = %.preheader132.lr.ph
  %32 = add nsw i32 %30, -3
  %33 = zext i32 %32 to i64
  %34 = zext nneg i32 %30 to i64
  %wide.trip.count181 = zext nneg i32 %27 to i64
  %umax = tail call i64 @llvm.umax.i64(i64 %33, i64 4)
  %35 = add nsw i64 %umax, -1
  %36 = and i64 %35, -4
  %37 = add nuw nsw i64 %36, 5
  %umax212 = tail call i64 @llvm.umax.i64(i64 %37, i64 %34)
  %38 = add i64 %umax212, -4
  %39 = sub i64 %38, %36
  %umax215 = tail call i64 @llvm.umax.i64(i64 %33, i64 4)
  %40 = shl nuw nsw i64 %umax215, 2
  %41 = add nsw i64 %40, -4
  %42 = and i64 %41, -16
  %43 = add nuw nsw i64 %42, 16
  %umax217 = tail call i64 @llvm.umax.i64(i64 %33, i64 4)
  %44 = add nsw i64 %umax217, -1
  %45 = lshr i64 %44, 2
  %46 = add nuw nsw i64 %45, 1
  %min.iters.check220 = icmp ult i32 %32, 13
  %n.vec223 = and i64 %46, 9223372036854775804
  %47 = shl i64 %n.vec223, 2
  %ind.end224 = or disjoint i64 %47, 4
  %ind.end226 = shl i64 %n.vec223, 2
  %broadcast.splatinsert231 = insertelement <4 x float> poison, float %2, i64 0
  %broadcast.splat232 = shufflevector <4 x float> %broadcast.splatinsert231, <4 x float> poison, <4 x i32> zeroinitializer
  %cmp.n234 = icmp eq i64 %46, %n.vec223
  %cmo = shl i64 %n.vec223, 2
  %min.iters.check = icmp ult i64 %39, 8
  %n.vec = and i64 %39, -8
  %broadcast.splatinsert = insertelement <4 x float> poison, float %2, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  %cmp.n = icmp eq i64 %39, %n.vec
  br label %.preheader132.us

.preheader132.us:                                 ; preds = %.preheader132.us.preheader, %._crit_edge.us
  %indvars.iv178 = phi i64 [ 0, %.preheader132.us.preheader ], [ %indvars.iv.next179, %._crit_edge.us ]
  %48 = getelementptr inbounds ptr, ptr %23, i64 %indvars.iv178
  %49 = load ptr, ptr %48, align 8, !tbaa !13
  %50 = ptrtoint ptr %49 to i64
  %51 = getelementptr inbounds ptr, ptr %25, i64 %indvars.iv178
  %52 = load ptr, ptr %51, align 8, !tbaa !13
  %53 = ptrtoint ptr %52 to i64
  br i1 %min.iters.check220, label %scalar.ph219.preheader, label %vector.memcheck214

scalar.ph219.preheader:                           ; preds = %middle.block218, %vector.memcheck214, %.preheader132.us
  %indvars.iv173.ph = phi i64 [ 4, %vector.memcheck214 ], [ 4, %.preheader132.us ], [ %ind.end224, %middle.block218 ]
  %indvars.iv170.ph = phi i64 [ 0, %vector.memcheck214 ], [ 0, %.preheader132.us ], [ %ind.end226, %middle.block218 ]
  br label %scalar.ph219

vector.memcheck214:                               ; preds = %.preheader132.us
  %scevgep = getelementptr i8, ptr %52, i64 %43
  %scevgep216 = getelementptr i8, ptr %49, i64 %43
  %bound0 = icmp ult ptr %52, %scevgep216
  %bound1 = icmp ult ptr %49, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %scalar.ph219.preheader, label %vector.ph221

vector.ph221:                                     ; preds = %vector.memcheck214
  %invariant.gep = getelementptr i8, ptr %52, i64 -12
  br label %vector.body228

vector.body228:                                   ; preds = %vector.body228, %vector.ph221
  %index229 = phi i64 [ 0, %vector.ph221 ], [ %index.next233, %vector.body228 ]
  %offset.idx230 = shl i64 %index229, 2
  %54 = or disjoint i64 %offset.idx230, 4
  %55 = or disjoint i64 %offset.idx230, 8
  %56 = or disjoint i64 %offset.idx230, 12
  %57 = getelementptr inbounds float, ptr %49, i64 %offset.idx230
  %58 = getelementptr inbounds float, ptr %49, i64 %54
  %59 = getelementptr inbounds float, ptr %49, i64 %55
  %60 = getelementptr inbounds float, ptr %49, i64 %56
  %61 = load float, ptr %57, align 4, !tbaa !14, !alias.scope !16
  %62 = load float, ptr %58, align 4, !tbaa !14, !alias.scope !16
  %63 = load float, ptr %59, align 4, !tbaa !14, !alias.scope !16
  %64 = load float, ptr %60, align 4, !tbaa !14, !alias.scope !16
  %65 = insertelement <4 x float> poison, float %61, i64 0
  %66 = insertelement <4 x float> %65, float %62, i64 1
  %67 = insertelement <4 x float> %66, float %63, i64 2
  %68 = insertelement <4 x float> %67, float %64, i64 3
  %69 = fmul <4 x float> %68, %broadcast.splat232
  %70 = or disjoint i64 %offset.idx230, 1
  %71 = or disjoint i64 %offset.idx230, 5
  %72 = or disjoint i64 %offset.idx230, 9
  %73 = or disjoint i64 %offset.idx230, 13
  %74 = getelementptr inbounds float, ptr %49, i64 %70
  %75 = getelementptr inbounds float, ptr %49, i64 %71
  %76 = getelementptr inbounds float, ptr %49, i64 %72
  %77 = getelementptr inbounds float, ptr %49, i64 %73
  %78 = load float, ptr %74, align 4, !tbaa !14, !alias.scope !16
  %79 = load float, ptr %75, align 4, !tbaa !14, !alias.scope !16
  %80 = load float, ptr %76, align 4, !tbaa !14, !alias.scope !16
  %81 = load float, ptr %77, align 4, !tbaa !14, !alias.scope !16
  %82 = insertelement <4 x float> poison, float %78, i64 0
  %83 = insertelement <4 x float> %82, float %79, i64 1
  %84 = insertelement <4 x float> %83, float %80, i64 2
  %85 = insertelement <4 x float> %84, float %81, i64 3
  %86 = fmul <4 x float> %85, %broadcast.splat232
  %87 = or disjoint i64 %offset.idx230, 2
  %88 = or disjoint i64 %offset.idx230, 6
  %89 = or disjoint i64 %offset.idx230, 10
  %90 = or disjoint i64 %offset.idx230, 14
  %91 = getelementptr inbounds float, ptr %49, i64 %87
  %92 = getelementptr inbounds float, ptr %49, i64 %88
  %93 = getelementptr inbounds float, ptr %49, i64 %89
  %94 = getelementptr inbounds float, ptr %49, i64 %90
  %95 = load float, ptr %91, align 4, !tbaa !14, !alias.scope !16
  %96 = load float, ptr %92, align 4, !tbaa !14, !alias.scope !16
  %97 = load float, ptr %93, align 4, !tbaa !14, !alias.scope !16
  %98 = load float, ptr %94, align 4, !tbaa !14, !alias.scope !16
  %99 = insertelement <4 x float> poison, float %95, i64 0
  %100 = insertelement <4 x float> %99, float %96, i64 1
  %101 = insertelement <4 x float> %100, float %97, i64 2
  %102 = insertelement <4 x float> %101, float %98, i64 3
  %103 = fmul <4 x float> %102, %broadcast.splat232
  %104 = or disjoint i64 %offset.idx230, 3
  %105 = or disjoint i64 %offset.idx230, 7
  %106 = or disjoint i64 %offset.idx230, 11
  %107 = or disjoint i64 %offset.idx230, 15
  %108 = getelementptr inbounds float, ptr %49, i64 %104
  %109 = getelementptr inbounds float, ptr %49, i64 %105
  %110 = getelementptr inbounds float, ptr %49, i64 %106
  %111 = getelementptr inbounds float, ptr %49, i64 %107
  %112 = load float, ptr %108, align 4, !tbaa !14, !alias.scope !16
  %113 = load float, ptr %109, align 4, !tbaa !14, !alias.scope !16
  %114 = load float, ptr %110, align 4, !tbaa !14, !alias.scope !16
  %115 = load float, ptr %111, align 4, !tbaa !14, !alias.scope !16
  %116 = insertelement <4 x float> poison, float %112, i64 0
  %117 = insertelement <4 x float> %116, float %113, i64 1
  %118 = insertelement <4 x float> %117, float %114, i64 2
  %119 = insertelement <4 x float> %118, float %115, i64 3
  %120 = fmul <4 x float> %119, %broadcast.splat232
  %gep = getelementptr float, ptr %invariant.gep, i64 %104
  %121 = shufflevector <4 x float> %69, <4 x float> %86, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %122 = shufflevector <4 x float> %103, <4 x float> %120, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec = shufflevector <8 x float> %121, <8 x float> %122, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
  store <16 x float> %interleaved.vec, ptr %gep, align 4, !tbaa !14
  %index.next233 = add nuw i64 %index229, 4
  %123 = icmp eq i64 %index.next233, %n.vec223
  br i1 %123, label %middle.block218, label %vector.body228, !llvm.loop !19

middle.block218:                                  ; preds = %vector.body228
  br i1 %cmp.n234, label %..preheader131_crit_edge.us, label %scalar.ph219.preheader

._crit_edge.us:                                   ; preds = %.lr.ph139.us, %middle.block, %..preheader131_crit_edge.us
  %indvars.iv.next179 = add nuw nsw i64 %indvars.iv178, 1
  %exitcond182.not = icmp eq i64 %indvars.iv.next179, %wide.trip.count181
  br i1 %exitcond182.not, label %.loopexit, label %.preheader132.us, !llvm.loop !23

.lr.ph139.us:                                     ; preds = %.lr.ph139.us.preheader293, %.lr.ph139.us
  %indvars.iv175 = phi i64 [ %indvars.iv.next176, %.lr.ph139.us ], [ %indvars.iv175.ph, %.lr.ph139.us.preheader293 ]
  %124 = getelementptr inbounds float, ptr %49, i64 %indvars.iv175
  %125 = load float, ptr %124, align 4, !tbaa !14
  %126 = fmul float %125, %2
  %127 = getelementptr inbounds float, ptr %52, i64 %indvars.iv175
  store float %126, ptr %127, align 4, !tbaa !14
  %indvars.iv.next176 = add nuw nsw i64 %indvars.iv175, 1
  %128 = icmp ult i64 %indvars.iv.next176, %34
  br i1 %128, label %.lr.ph139.us, label %._crit_edge.us, !llvm.loop !24

scalar.ph219:                                     ; preds = %scalar.ph219.preheader, %scalar.ph219
  %indvars.iv173 = phi i64 [ %indvars.iv.next174, %scalar.ph219 ], [ %indvars.iv173.ph, %scalar.ph219.preheader ]
  %indvars.iv170 = phi i64 [ %indvars.iv.next171, %scalar.ph219 ], [ %indvars.iv170.ph, %scalar.ph219.preheader ]
  %129 = getelementptr inbounds float, ptr %49, i64 %indvars.iv170
  %130 = load float, ptr %129, align 4, !tbaa !14
  %131 = fmul float %130, %2
  %132 = getelementptr inbounds float, ptr %52, i64 %indvars.iv170
  store float %131, ptr %132, align 4, !tbaa !14
  %133 = or disjoint i64 %indvars.iv170, 1
  %134 = getelementptr inbounds float, ptr %49, i64 %133
  %135 = load float, ptr %134, align 4, !tbaa !14
  %136 = fmul float %135, %2
  %137 = getelementptr inbounds float, ptr %52, i64 %133
  store float %136, ptr %137, align 4, !tbaa !14
  %138 = or disjoint i64 %indvars.iv170, 2
  %139 = getelementptr inbounds float, ptr %49, i64 %138
  %140 = load float, ptr %139, align 4, !tbaa !14
  %141 = fmul float %140, %2
  %142 = getelementptr inbounds float, ptr %52, i64 %138
  store float %141, ptr %142, align 4, !tbaa !14
  %143 = or disjoint i64 %indvars.iv170, 3
  %144 = getelementptr inbounds float, ptr %49, i64 %143
  %145 = load float, ptr %144, align 4, !tbaa !14
  %146 = fmul float %145, %2
  %147 = getelementptr inbounds float, ptr %52, i64 %143
  store float %146, ptr %147, align 4, !tbaa !14
  %indvars.iv.next171 = add nuw nsw i64 %indvars.iv170, 4
  %148 = icmp ult i64 %indvars.iv.next171, %33
  %indvars.iv.next174 = add nuw nsw i64 %indvars.iv173, 4
  br i1 %148, label %scalar.ph219, label %..preheader131_crit_edge.us, !llvm.loop !25

..preheader131_crit_edge.us:                      ; preds = %scalar.ph219, %middle.block218
  %indvars.iv173.lcssa = phi i64 [ %cmo, %middle.block218 ], [ %indvars.iv173, %scalar.ph219 ]
  %indvars.iv.next171.lcssa = phi i64 [ %ind.end226, %middle.block218 ], [ %indvars.iv.next171, %scalar.ph219 ]
  %149 = trunc nuw nsw i64 %indvars.iv.next171.lcssa to i32
  %150 = icmp sgt i32 %30, %149
  br i1 %150, label %.lr.ph139.us.preheader, label %._crit_edge.us

.lr.ph139.us.preheader:                           ; preds = %..preheader131_crit_edge.us
  %151 = sub i64 %53, %50
  %diff.check = icmp ult i64 %151, 32
  %or.cond = select i1 %min.iters.check, i1 true, i1 %diff.check
  br i1 %or.cond, label %.lr.ph139.us.preheader293, label %vector.ph

.lr.ph139.us.preheader293:                        ; preds = %middle.block, %.lr.ph139.us.preheader
  %indvars.iv175.ph = phi i64 [ %indvars.iv173.lcssa, %.lr.ph139.us.preheader ], [ %ind.end, %middle.block ]
  br label %.lr.ph139.us

vector.ph:                                        ; preds = %.lr.ph139.us.preheader
  %ind.end = add i64 %indvars.iv173.lcssa, %n.vec
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %offset.idx = add i64 %indvars.iv173.lcssa, %index
  %152 = getelementptr inbounds float, ptr %49, i64 %offset.idx
  %153 = getelementptr inbounds i8, ptr %152, i64 16
  %wide.load = load <4 x float>, ptr %152, align 4, !tbaa !14
  %wide.load213 = load <4 x float>, ptr %153, align 4, !tbaa !14
  %154 = fmul <4 x float> %wide.load, %broadcast.splat
  %155 = fmul <4 x float> %wide.load213, %broadcast.splat
  %156 = getelementptr inbounds float, ptr %52, i64 %offset.idx
  %157 = getelementptr inbounds i8, ptr %156, i64 16
  store <4 x float> %154, ptr %156, align 4, !tbaa !14
  store <4 x float> %155, ptr %157, align 4, !tbaa !14
  %index.next = add nuw i64 %index, 8
  %158 = icmp eq i64 %index.next, %n.vec
  br i1 %158, label %middle.block, label %vector.body, !llvm.loop !26

middle.block:                                     ; preds = %vector.body
  br i1 %cmp.n, label %._crit_edge.us, label %.lr.ph139.us.preheader293

.preheader132.lr.ph.split:                        ; preds = %.preheader132.lr.ph
  %159 = icmp sgt i32 %30, 0
  br i1 %159, label %.preheader132.us141.preheader, label %.loopexit

.preheader132.us141.preheader:                    ; preds = %.preheader132.lr.ph.split
  %wide.trip.count168 = zext nneg i32 %27 to i64
  %exitcond.not = icmp eq i32 %30, 1
  %exitcond.not.1 = icmp eq i32 %30, 2
  br label %.preheader132.us141

.preheader132.us141:                              ; preds = %.preheader132.us141.preheader, %._crit_edge.us145
  %indvars.iv165 = phi i64 [ 0, %.preheader132.us141.preheader ], [ %indvars.iv.next166, %._crit_edge.us145 ]
  %160 = getelementptr inbounds ptr, ptr %23, i64 %indvars.iv165
  %161 = load ptr, ptr %160, align 8, !tbaa !13
  %162 = getelementptr inbounds ptr, ptr %25, i64 %indvars.iv165
  %163 = load ptr, ptr %162, align 8, !tbaa !13
  %164 = load float, ptr %161, align 4, !tbaa !14
  %165 = fmul float %164, %2
  store float %165, ptr %163, align 4, !tbaa !14
  br i1 %exitcond.not, label %._crit_edge.us145, label %166, !llvm.loop !27

166:                                              ; preds = %.preheader132.us141
  %167 = getelementptr inbounds i8, ptr %161, i64 4
  %168 = load float, ptr %167, align 4, !tbaa !14
  %169 = fmul float %168, %2
  %170 = getelementptr inbounds i8, ptr %163, i64 4
  store float %169, ptr %170, align 4, !tbaa !14
  br i1 %exitcond.not.1, label %._crit_edge.us145, label %171, !llvm.loop !27

171:                                              ; preds = %166
  %172 = getelementptr inbounds i8, ptr %161, i64 8
  %173 = load float, ptr %172, align 4, !tbaa !14
  %174 = fmul float %173, %2
  %175 = getelementptr inbounds i8, ptr %163, i64 8
  store float %174, ptr %175, align 4, !tbaa !14
  br label %._crit_edge.us145

._crit_edge.us145:                                ; preds = %171, %166, %.preheader132.us141
  %indvars.iv.next166 = add nuw nsw i64 %indvars.iv165, 1
  %exitcond169.not = icmp eq i64 %indvars.iv.next166, %wide.trip.count168
  br i1 %exitcond169.not, label %.loopexit, label %.preheader132.us141, !llvm.loop !23

.preheader130:                                    ; preds = %21
  br i1 %28, label %.preheader129.lr.ph, label %.loopexit

.preheader129.lr.ph:                              ; preds = %.preheader130
  %176 = getelementptr inbounds i8, ptr %0, i64 4
  %177 = load i32, ptr %176, align 4, !tbaa !11
  %178 = icmp sgt i32 %177, 3
  br i1 %178, label %.preheader129.us.preheader, label %.preheader129.lr.ph.split

.preheader129.us.preheader:                       ; preds = %.preheader129.lr.ph
  %179 = add nsw i32 %177, -3
  %180 = zext i32 %179 to i64
  %181 = zext nneg i32 %177 to i64
  %wide.trip.count204 = zext nneg i32 %27 to i64
  %umax237 = tail call i64 @llvm.umax.i64(i64 %180, i64 4)
  %182 = add nsw i64 %umax237, -1
  %183 = and i64 %182, -4
  %184 = add nuw nsw i64 %183, 5
  %umax238 = tail call i64 @llvm.umax.i64(i64 %184, i64 %181)
  %185 = add i64 %umax238, -4
  %186 = sub i64 %185, %183
  %umax259 = tail call i64 @llvm.umax.i64(i64 %180, i64 4)
  %187 = shl nuw nsw i64 %umax259, 2
  %188 = add nsw i64 %187, -4
  %189 = and i64 %188, -16
  %190 = add nuw nsw i64 %189, 16
  %umax265 = tail call i64 @llvm.umax.i64(i64 %180, i64 4)
  %191 = add nsw i64 %umax265, -1
  %192 = lshr i64 %191, 2
  %193 = add nuw nsw i64 %192, 1
  %min.iters.check268 = icmp ult i32 %179, 13
  %n.vec271 = and i64 %193, 9223372036854775804
  %194 = shl i64 %n.vec271, 2
  %ind.end272 = or disjoint i64 %194, 4
  %ind.end274 = shl i64 %n.vec271, 2
  %broadcast.splatinsert279 = insertelement <4 x float> poison, float %2, i64 0
  %broadcast.splat280 = shufflevector <4 x float> %broadcast.splatinsert279, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert281 = insertelement <4 x float> poison, float %3, i64 0
  %broadcast.splat282 = shufflevector <4 x float> %broadcast.splatinsert281, <4 x float> poison, <4 x i32> zeroinitializer
  %cmp.n285 = icmp eq i64 %193, %n.vec271
  %cmo286 = shl i64 %n.vec271, 2
  %min.iters.check241 = icmp ult i64 %186, 8
  %n.vec244 = and i64 %186, -8
  %broadcast.splatinsert252 = insertelement <4 x float> poison, float %2, i64 0
  %broadcast.splat253 = shufflevector <4 x float> %broadcast.splatinsert252, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert254 = insertelement <4 x float> poison, float %3, i64 0
  %broadcast.splat255 = shufflevector <4 x float> %broadcast.splatinsert254, <4 x float> poison, <4 x i32> zeroinitializer
  %cmp.n257 = icmp eq i64 %186, %n.vec244
  br label %.preheader129.us

.preheader129.us:                                 ; preds = %.preheader129.us.preheader, %._crit_edge.us152
  %indvars.iv201 = phi i64 [ 0, %.preheader129.us.preheader ], [ %indvars.iv.next202, %._crit_edge.us152 ]
  %195 = getelementptr inbounds ptr, ptr %23, i64 %indvars.iv201
  %196 = load ptr, ptr %195, align 8, !tbaa !13
  %197 = ptrtoint ptr %196 to i64
  %198 = getelementptr inbounds ptr, ptr %25, i64 %indvars.iv201
  %199 = load ptr, ptr %198, align 8, !tbaa !13
  %200 = ptrtoint ptr %199 to i64
  br i1 %min.iters.check268, label %scalar.ph267.preheader, label %vector.memcheck258

scalar.ph267.preheader:                           ; preds = %middle.block266, %vector.memcheck258, %.preheader129.us
  %indvars.iv196.ph = phi i64 [ 4, %vector.memcheck258 ], [ 4, %.preheader129.us ], [ %ind.end272, %middle.block266 ]
  %indvars.iv193.ph = phi i64 [ 0, %vector.memcheck258 ], [ 0, %.preheader129.us ], [ %ind.end274, %middle.block266 ]
  br label %scalar.ph267

vector.memcheck258:                               ; preds = %.preheader129.us
  %scevgep260 = getelementptr i8, ptr %199, i64 %190
  %scevgep261 = getelementptr i8, ptr %196, i64 %190
  %bound0262 = icmp ult ptr %199, %scevgep261
  %bound1263 = icmp ult ptr %196, %scevgep260
  %found.conflict264 = and i1 %bound0262, %bound1263
  br i1 %found.conflict264, label %scalar.ph267.preheader, label %vector.ph269

vector.ph269:                                     ; preds = %vector.memcheck258
  %invariant.gep302 = getelementptr i8, ptr %199, i64 -12
  br label %vector.body276

vector.body276:                                   ; preds = %vector.body276, %vector.ph269
  %index277 = phi i64 [ 0, %vector.ph269 ], [ %index.next284, %vector.body276 ]
  %offset.idx278 = shl i64 %index277, 2
  %201 = or disjoint i64 %offset.idx278, 4
  %202 = or disjoint i64 %offset.idx278, 8
  %203 = or disjoint i64 %offset.idx278, 12
  %204 = getelementptr inbounds float, ptr %196, i64 %offset.idx278
  %205 = getelementptr inbounds float, ptr %196, i64 %201
  %206 = getelementptr inbounds float, ptr %196, i64 %202
  %207 = getelementptr inbounds float, ptr %196, i64 %203
  %208 = load float, ptr %204, align 4, !tbaa !14, !alias.scope !28
  %209 = load float, ptr %205, align 4, !tbaa !14, !alias.scope !28
  %210 = load float, ptr %206, align 4, !tbaa !14, !alias.scope !28
  %211 = load float, ptr %207, align 4, !tbaa !14, !alias.scope !28
  %212 = insertelement <4 x float> poison, float %208, i64 0
  %213 = insertelement <4 x float> %212, float %209, i64 1
  %214 = insertelement <4 x float> %213, float %210, i64 2
  %215 = insertelement <4 x float> %214, float %211, i64 3
  %216 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %215, <4 x float> %broadcast.splat280, <4 x float> %broadcast.splat282)
  %217 = or disjoint i64 %offset.idx278, 1
  %218 = or disjoint i64 %offset.idx278, 5
  %219 = or disjoint i64 %offset.idx278, 9
  %220 = or disjoint i64 %offset.idx278, 13
  %221 = getelementptr inbounds float, ptr %196, i64 %217
  %222 = getelementptr inbounds float, ptr %196, i64 %218
  %223 = getelementptr inbounds float, ptr %196, i64 %219
  %224 = getelementptr inbounds float, ptr %196, i64 %220
  %225 = load float, ptr %221, align 4, !tbaa !14, !alias.scope !28
  %226 = load float, ptr %222, align 4, !tbaa !14, !alias.scope !28
  %227 = load float, ptr %223, align 4, !tbaa !14, !alias.scope !28
  %228 = load float, ptr %224, align 4, !tbaa !14, !alias.scope !28
  %229 = insertelement <4 x float> poison, float %225, i64 0
  %230 = insertelement <4 x float> %229, float %226, i64 1
  %231 = insertelement <4 x float> %230, float %227, i64 2
  %232 = insertelement <4 x float> %231, float %228, i64 3
  %233 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %232, <4 x float> %broadcast.splat280, <4 x float> %broadcast.splat282)
  %234 = or disjoint i64 %offset.idx278, 2
  %235 = or disjoint i64 %offset.idx278, 6
  %236 = or disjoint i64 %offset.idx278, 10
  %237 = or disjoint i64 %offset.idx278, 14
  %238 = getelementptr inbounds float, ptr %196, i64 %234
  %239 = getelementptr inbounds float, ptr %196, i64 %235
  %240 = getelementptr inbounds float, ptr %196, i64 %236
  %241 = getelementptr inbounds float, ptr %196, i64 %237
  %242 = load float, ptr %238, align 4, !tbaa !14, !alias.scope !28
  %243 = load float, ptr %239, align 4, !tbaa !14, !alias.scope !28
  %244 = load float, ptr %240, align 4, !tbaa !14, !alias.scope !28
  %245 = load float, ptr %241, align 4, !tbaa !14, !alias.scope !28
  %246 = insertelement <4 x float> poison, float %242, i64 0
  %247 = insertelement <4 x float> %246, float %243, i64 1
  %248 = insertelement <4 x float> %247, float %244, i64 2
  %249 = insertelement <4 x float> %248, float %245, i64 3
  %250 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %249, <4 x float> %broadcast.splat280, <4 x float> %broadcast.splat282)
  %251 = or disjoint i64 %offset.idx278, 3
  %252 = or disjoint i64 %offset.idx278, 7
  %253 = or disjoint i64 %offset.idx278, 11
  %254 = or disjoint i64 %offset.idx278, 15
  %255 = getelementptr inbounds float, ptr %196, i64 %251
  %256 = getelementptr inbounds float, ptr %196, i64 %252
  %257 = getelementptr inbounds float, ptr %196, i64 %253
  %258 = getelementptr inbounds float, ptr %196, i64 %254
  %259 = load float, ptr %255, align 4, !tbaa !14, !alias.scope !28
  %260 = load float, ptr %256, align 4, !tbaa !14, !alias.scope !28
  %261 = load float, ptr %257, align 4, !tbaa !14, !alias.scope !28
  %262 = load float, ptr %258, align 4, !tbaa !14, !alias.scope !28
  %263 = insertelement <4 x float> poison, float %259, i64 0
  %264 = insertelement <4 x float> %263, float %260, i64 1
  %265 = insertelement <4 x float> %264, float %261, i64 2
  %266 = insertelement <4 x float> %265, float %262, i64 3
  %267 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %266, <4 x float> %broadcast.splat280, <4 x float> %broadcast.splat282)
  %gep303 = getelementptr float, ptr %invariant.gep302, i64 %251
  %268 = shufflevector <4 x float> %216, <4 x float> %233, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %269 = shufflevector <4 x float> %250, <4 x float> %267, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec283 = shufflevector <8 x float> %268, <8 x float> %269, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
  store <16 x float> %interleaved.vec283, ptr %gep303, align 4, !tbaa !14
  %index.next284 = add nuw i64 %index277, 4
  %270 = icmp eq i64 %index.next284, %n.vec271
  br i1 %270, label %middle.block266, label %vector.body276, !llvm.loop !31

middle.block266:                                  ; preds = %vector.body276
  br i1 %cmp.n285, label %..preheader_crit_edge.us, label %scalar.ph267.preheader

._crit_edge.us152:                                ; preds = %.lr.ph149.us, %middle.block239, %..preheader_crit_edge.us
  %indvars.iv.next202 = add nuw nsw i64 %indvars.iv201, 1
  %exitcond205.not = icmp eq i64 %indvars.iv.next202, %wide.trip.count204
  br i1 %exitcond205.not, label %.loopexit, label %.preheader129.us, !llvm.loop !32

.lr.ph149.us:                                     ; preds = %.lr.ph149.us.preheader289, %.lr.ph149.us
  %indvars.iv198 = phi i64 [ %indvars.iv.next199, %.lr.ph149.us ], [ %indvars.iv198.ph, %.lr.ph149.us.preheader289 ]
  %271 = getelementptr inbounds float, ptr %196, i64 %indvars.iv198
  %272 = load float, ptr %271, align 4, !tbaa !14
  %273 = tail call float @llvm.fmuladd.f32(float %272, float %2, float %3)
  %274 = getelementptr inbounds float, ptr %199, i64 %indvars.iv198
  store float %273, ptr %274, align 4, !tbaa !14
  %indvars.iv.next199 = add nuw nsw i64 %indvars.iv198, 1
  %275 = icmp ult i64 %indvars.iv.next199, %181
  br i1 %275, label %.lr.ph149.us, label %._crit_edge.us152, !llvm.loop !33

scalar.ph267:                                     ; preds = %scalar.ph267.preheader, %scalar.ph267
  %indvars.iv196 = phi i64 [ %indvars.iv.next197, %scalar.ph267 ], [ %indvars.iv196.ph, %scalar.ph267.preheader ]
  %indvars.iv193 = phi i64 [ %indvars.iv.next194, %scalar.ph267 ], [ %indvars.iv193.ph, %scalar.ph267.preheader ]
  %276 = getelementptr inbounds float, ptr %196, i64 %indvars.iv193
  %277 = load float, ptr %276, align 4, !tbaa !14
  %278 = tail call float @llvm.fmuladd.f32(float %277, float %2, float %3)
  %279 = getelementptr inbounds float, ptr %199, i64 %indvars.iv193
  store float %278, ptr %279, align 4, !tbaa !14
  %280 = or disjoint i64 %indvars.iv193, 1
  %281 = getelementptr inbounds float, ptr %196, i64 %280
  %282 = load float, ptr %281, align 4, !tbaa !14
  %283 = tail call float @llvm.fmuladd.f32(float %282, float %2, float %3)
  %284 = getelementptr inbounds float, ptr %199, i64 %280
  store float %283, ptr %284, align 4, !tbaa !14
  %285 = or disjoint i64 %indvars.iv193, 2
  %286 = getelementptr inbounds float, ptr %196, i64 %285
  %287 = load float, ptr %286, align 4, !tbaa !14
  %288 = tail call float @llvm.fmuladd.f32(float %287, float %2, float %3)
  %289 = getelementptr inbounds float, ptr %199, i64 %285
  store float %288, ptr %289, align 4, !tbaa !14
  %290 = or disjoint i64 %indvars.iv193, 3
  %291 = getelementptr inbounds float, ptr %196, i64 %290
  %292 = load float, ptr %291, align 4, !tbaa !14
  %293 = tail call float @llvm.fmuladd.f32(float %292, float %2, float %3)
  %294 = getelementptr inbounds float, ptr %199, i64 %290
  store float %293, ptr %294, align 4, !tbaa !14
  %indvars.iv.next194 = add nuw nsw i64 %indvars.iv193, 4
  %295 = icmp ult i64 %indvars.iv.next194, %180
  %indvars.iv.next197 = add nuw nsw i64 %indvars.iv196, 4
  br i1 %295, label %scalar.ph267, label %..preheader_crit_edge.us, !llvm.loop !34

..preheader_crit_edge.us:                         ; preds = %scalar.ph267, %middle.block266
  %indvars.iv196.lcssa = phi i64 [ %cmo286, %middle.block266 ], [ %indvars.iv196, %scalar.ph267 ]
  %indvars.iv.next194.lcssa = phi i64 [ %ind.end274, %middle.block266 ], [ %indvars.iv.next194, %scalar.ph267 ]
  %296 = trunc nuw nsw i64 %indvars.iv.next194.lcssa to i32
  %297 = icmp sgt i32 %177, %296
  br i1 %297, label %.lr.ph149.us.preheader, label %._crit_edge.us152

.lr.ph149.us.preheader:                           ; preds = %..preheader_crit_edge.us
  %298 = sub i64 %200, %197
  %diff.check236 = icmp ult i64 %298, 32
  %or.cond288 = select i1 %min.iters.check241, i1 true, i1 %diff.check236
  br i1 %or.cond288, label %.lr.ph149.us.preheader289, label %vector.ph242

.lr.ph149.us.preheader289:                        ; preds = %middle.block239, %.lr.ph149.us.preheader
  %indvars.iv198.ph = phi i64 [ %indvars.iv196.lcssa, %.lr.ph149.us.preheader ], [ %ind.end245, %middle.block239 ]
  br label %.lr.ph149.us

vector.ph242:                                     ; preds = %.lr.ph149.us.preheader
  %ind.end245 = add i64 %indvars.iv196.lcssa, %n.vec244
  br label %vector.body247

vector.body247:                                   ; preds = %vector.body247, %vector.ph242
  %index248 = phi i64 [ 0, %vector.ph242 ], [ %index.next256, %vector.body247 ]
  %offset.idx249 = add i64 %indvars.iv196.lcssa, %index248
  %299 = getelementptr inbounds float, ptr %196, i64 %offset.idx249
  %300 = getelementptr inbounds i8, ptr %299, i64 16
  %wide.load250 = load <4 x float>, ptr %299, align 4, !tbaa !14
  %wide.load251 = load <4 x float>, ptr %300, align 4, !tbaa !14
  %301 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load250, <4 x float> %broadcast.splat253, <4 x float> %broadcast.splat255)
  %302 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %wide.load251, <4 x float> %broadcast.splat253, <4 x float> %broadcast.splat255)
  %303 = getelementptr inbounds float, ptr %199, i64 %offset.idx249
  %304 = getelementptr inbounds i8, ptr %303, i64 16
  store <4 x float> %301, ptr %303, align 4, !tbaa !14
  store <4 x float> %302, ptr %304, align 4, !tbaa !14
  %index.next256 = add nuw i64 %index248, 8
  %305 = icmp eq i64 %index.next256, %n.vec244
  br i1 %305, label %middle.block239, label %vector.body247, !llvm.loop !35

middle.block239:                                  ; preds = %vector.body247
  br i1 %cmp.n257, label %._crit_edge.us152, label %.lr.ph149.us.preheader289

.preheader129.lr.ph.split:                        ; preds = %.preheader129.lr.ph
  %306 = icmp sgt i32 %177, 0
  br i1 %306, label %.preheader129.us153.preheader, label %.loopexit

.preheader129.us153.preheader:                    ; preds = %.preheader129.lr.ph.split
  %wide.trip.count191 = zext nneg i32 %27 to i64
  %exitcond187.not = icmp eq i32 %177, 1
  %exitcond187.not.1 = icmp eq i32 %177, 2
  br label %.preheader129.us153

.preheader129.us153:                              ; preds = %.preheader129.us153.preheader, %._crit_edge.us157
  %indvars.iv188 = phi i64 [ 0, %.preheader129.us153.preheader ], [ %indvars.iv.next189, %._crit_edge.us157 ]
  %307 = getelementptr inbounds ptr, ptr %23, i64 %indvars.iv188
  %308 = load ptr, ptr %307, align 8, !tbaa !13
  %309 = getelementptr inbounds ptr, ptr %25, i64 %indvars.iv188
  %310 = load ptr, ptr %309, align 8, !tbaa !13
  %311 = load float, ptr %308, align 4, !tbaa !14
  %312 = tail call float @llvm.fmuladd.f32(float %311, float %2, float %3)
  store float %312, ptr %310, align 4, !tbaa !14
  br i1 %exitcond187.not, label %._crit_edge.us157, label %313, !llvm.loop !36

313:                                              ; preds = %.preheader129.us153
  %314 = getelementptr inbounds i8, ptr %308, i64 4
  %315 = load float, ptr %314, align 4, !tbaa !14
  %316 = tail call float @llvm.fmuladd.f32(float %315, float %2, float %3)
  %317 = getelementptr inbounds i8, ptr %310, i64 4
  store float %316, ptr %317, align 4, !tbaa !14
  br i1 %exitcond187.not.1, label %._crit_edge.us157, label %318, !llvm.loop !36

318:                                              ; preds = %313
  %319 = getelementptr inbounds i8, ptr %308, i64 8
  %320 = load float, ptr %319, align 4, !tbaa !14
  %321 = tail call float @llvm.fmuladd.f32(float %320, float %2, float %3)
  %322 = getelementptr inbounds i8, ptr %310, i64 8
  store float %321, ptr %322, align 4, !tbaa !14
  br label %._crit_edge.us157

._crit_edge.us157:                                ; preds = %318, %313, %.preheader129.us153
  %indvars.iv.next189 = add nuw nsw i64 %indvars.iv188, 1
  %exitcond192.not = icmp eq i64 %indvars.iv.next189, %wide.trip.count191
  br i1 %exitcond192.not, label %.loopexit, label %.preheader129.us153, !llvm.loop !32

.loopexit:                                        ; preds = %._crit_edge.us145, %._crit_edge.us, %._crit_edge.us157, %._crit_edge.us152, %.preheader129.lr.ph.split, %.preheader132.lr.ph.split, %.preheader133, %.preheader130
  ret void
}

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #2

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #3

attributes #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 = { 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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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, !10, i64 8}
!6 = !{!"MMatrix", !7, i64 0, !7, i64 4, !10, i64 8}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!6, !7, i64 4}
!12 = !{!6, !7, i64 0}
!13 = !{!10, !10, i64 0}
!14 = !{!15, !15, i64 0}
!15 = !{!"float", !8, i64 0}
!16 = !{!17}
!17 = distinct !{!17, !18}
!18 = distinct !{!18, !"LVerDomain"}
!19 = distinct !{!19, !20, !21, !22}
!20 = !{!"llvm.loop.mustprogress"}
!21 = !{!"llvm.loop.isvectorized", i32 1}
!22 = !{!"llvm.loop.unroll.runtime.disable"}
!23 = distinct !{!23, !20}
!24 = distinct !{!24, !20, !21}
!25 = distinct !{!25, !20, !21}
!26 = distinct !{!26, !20, !21, !22}
!27 = distinct !{!27, !20}
!28 = !{!29}
!29 = distinct !{!29, !30}
!30 = distinct !{!30, !"LVerDomain"}
!31 = distinct !{!31, !20, !21, !22}
!32 = distinct !{!32, !20}
!33 = distinct !{!33, !20, !21}
!34 = distinct !{!34, !20, !21}
!35 = distinct !{!35, !20, !21, !22}
!36 = distinct !{!36, !20}


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