; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z29_hmt_test_Division_Mat4ScalarP21hmt_testresult_struct)

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

%union.HMM_Mat4 = type { [4 x %union.HMM_Vec4] }
%union.HMM_Vec4 = type { <4 x float> }
%struct.hmt_testresult_struct = type { i32, i32 }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 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

; 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) #1

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL6HMM_M4v(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16) #3

; Function Attrs: mustprogress uwtable
define dso_local void @_Z29_hmt_test_Division_Mat4ScalarP21hmt_testresult_struct(ptr noundef %0) #4 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca float, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca %union.HMM_Mat4, align 16
  %10 = alloca %union.HMM_Mat4, align 16
  %11 = alloca float, align 4
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca float, align 4
  %20 = alloca float, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca float, align 4
  %34 = alloca float, align 4
  %35 = alloca float, align 4
  %36 = alloca float, align 4
  %37 = alloca float, align 4
  %38 = alloca float, align 4
  %39 = alloca float, align 4
  %40 = alloca float, align 4
  %41 = alloca float, align 4
  %42 = alloca float, align 4
  %43 = alloca %union.HMM_Mat4, align 16
  %44 = alloca %union.HMM_Mat4, align 16
  %45 = alloca float, align 4
  %46 = alloca float, align 4
  %47 = alloca float, align 4
  %48 = alloca float, align 4
  %49 = alloca float, align 4
  %50 = alloca float, align 4
  %51 = alloca float, align 4
  %52 = alloca float, align 4
  %53 = alloca float, align 4
  %54 = alloca float, align 4
  %55 = alloca float, align 4
  %56 = alloca float, align 4
  %57 = alloca float, align 4
  %58 = alloca float, align 4
  %59 = alloca float, align 4
  %60 = alloca float, align 4
  %61 = alloca float, align 4
  %62 = alloca float, align 4
  %63 = alloca float, align 4
  %64 = alloca float, align 4
  %65 = alloca float, align 4
  %66 = alloca float, align 4
  %67 = alloca float, align 4
  %68 = alloca float, align 4
  %69 = alloca float, align 4
  %70 = alloca float, align 4
  %71 = alloca float, align 4
  %72 = alloca float, align 4
  %73 = alloca float, align 4
  %74 = alloca float, align 4
  %75 = alloca float, align 4
  %76 = alloca float, align 4
  %77 = alloca %union.HMM_Mat4, align 16
  %78 = alloca %union.HMM_Mat4, align 16
  %79 = alloca float, align 4
  %80 = alloca float, align 4
  %81 = alloca float, align 4
  %82 = alloca float, align 4
  %83 = alloca float, align 4
  %84 = alloca float, align 4
  %85 = alloca float, align 4
  %86 = alloca float, align 4
  %87 = alloca float, align 4
  %88 = alloca float, align 4
  %89 = alloca float, align 4
  %90 = alloca float, align 4
  %91 = alloca float, align 4
  %92 = alloca float, align 4
  %93 = alloca float, align 4
  %94 = alloca float, align 4
  %95 = alloca float, align 4
  %96 = alloca float, align 4
  %97 = alloca float, align 4
  %98 = alloca float, align 4
  %99 = alloca float, align 4
  %100 = alloca float, align 4
  %101 = alloca float, align 4
  %102 = alloca float, align 4
  %103 = alloca float, align 4
  %104 = alloca float, align 4
  %105 = alloca float, align 4
  %106 = alloca float, align 4
  %107 = alloca float, align 4
  %108 = alloca float, align 4
  %109 = alloca float, align 4
  %110 = alloca float, align 4
  %111 = alloca float, align 4
  %112 = alloca float, align 4
  %113 = alloca float, align 4
  %114 = alloca float, align 4
  %115 = alloca float, align 4
  %116 = alloca float, align 4
  %117 = alloca float, align 4
  %118 = alloca float, align 4
  %119 = alloca float, align 4
  %120 = alloca float, align 4
  %121 = alloca float, align 4
  %122 = alloca float, align 4
  %123 = alloca float, align 4
  %124 = alloca float, align 4
  %125 = alloca float, align 4
  %126 = alloca float, align 4
  %127 = alloca float, align 4
  %128 = alloca float, align 4
  %129 = alloca float, align 4
  %130 = alloca float, align 4
  %131 = alloca float, align 4
  %132 = alloca float, align 4
  %133 = alloca float, align 4
  %134 = alloca float, align 4
  %135 = alloca float, align 4
  %136 = alloca float, align 4
  %137 = alloca float, align 4
  %138 = alloca float, align 4
  %139 = alloca float, align 4
  %140 = alloca float, align 4
  %141 = alloca float, align 4
  %142 = alloca float, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %3) #6
  call void @_ZL6HMM_M4v(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %3)
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #6
  store float 2.000000e+00, ptr %4, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #6
  store i32 1, ptr %5, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  store i32 0, ptr %6, align 4, !tbaa !11
  br label %143

143:                                              ; preds = %167, %1
  %144 = load i32, ptr %6, align 4, !tbaa !11
  %145 = icmp slt i32 %144, 4
  br i1 %145, label %147, label %146

146:                                              ; preds = %143
  store i32 2, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  br label %170

147:                                              ; preds = %143
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  store i32 0, ptr %8, align 4, !tbaa !11
  br label %148

148:                                              ; preds = %163, %147
  %149 = load i32, ptr %8, align 4, !tbaa !11
  %150 = icmp slt i32 %149, 4
  br i1 %150, label %152, label %151

151:                                              ; preds = %148
  store i32 5, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  br label %166

152:                                              ; preds = %148
  %153 = load i32, ptr %5, align 4, !tbaa !11
  %154 = sitofp i32 %153 to float
  %155 = load i32, ptr %6, align 4, !tbaa !11
  %156 = sext i32 %155 to i64
  %157 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 %156
  %158 = load i32, ptr %8, align 4, !tbaa !11
  %159 = sext i32 %158 to i64
  %160 = getelementptr inbounds [4 x float], ptr %157, i64 0, i64 %159
  store float %154, ptr %160, align 4, !tbaa !13
  %161 = load i32, ptr %5, align 4, !tbaa !11
  %162 = add nsw i32 %161, 1
  store i32 %162, ptr %5, align 4, !tbaa !11
  br label %163

163:                                              ; preds = %152
  %164 = load i32, ptr %8, align 4, !tbaa !11
  %165 = add nsw i32 %164, 1
  store i32 %165, ptr %8, align 4, !tbaa !11
  br label %148, !llvm.loop !14

166:                                              ; preds = %151
  br label %167

167:                                              ; preds = %166
  %168 = load i32, ptr %6, align 4, !tbaa !11
  %169 = add nsw i32 %168, 1
  store i32 %169, ptr %6, align 4, !tbaa !11
  br label %143, !llvm.loop !16

170:                                              ; preds = %146
  call void @llvm.lifetime.start.p0(i64 64, ptr %9) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %10, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  %171 = load float, ptr %4, align 4, !tbaa !9
  call void @_ZL10HMM_DivM4F8HMM_Mat4f(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %9, ptr noundef byval(%union.HMM_Mat4) align 16 %10, float noundef %171)
  %172 = load ptr, ptr %2, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %172, i32 0, i32 0
  %174 = load i32, ptr %173, align 4, !tbaa !18
  %175 = add nsw i32 %174, 1
  store i32 %175, ptr %173, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  %176 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 0
  %177 = getelementptr inbounds [4 x float], ptr %176, i64 0, i64 0
  %178 = load float, ptr %177, align 16, !tbaa !13
  store float %178, ptr %11, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  %179 = load float, ptr %11, align 4, !tbaa !9
  %180 = fsub float %179, 5.000000e-01
  store float %180, ptr %12, align 4, !tbaa !9
  %181 = load float, ptr %12, align 4, !tbaa !9
  %182 = fcmp olt float %181, 0xBE80000000000000
  br i1 %182, label %186, label %183

183:                                              ; preds = %170
  %184 = load float, ptr %12, align 4, !tbaa !9
  %185 = fcmp olt float 0x3E80000000000000, %184
  br i1 %185, label %186, label %197

186:                                              ; preds = %183, %170
  %187 = load ptr, ptr %2, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %187, i32 0, i32 1
  %189 = load i32, ptr %188, align 4, !tbaa !20
  %190 = add nsw i32 %189, 1
  store i32 %190, ptr %188, align 4, !tbaa !20
  %191 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 324)
  %192 = load float, ptr %11, align 4, !tbaa !9
  %193 = fpext float %192 to double
  %194 = load float, ptr %12, align 4, !tbaa !9
  %195 = fpext float %194 to double
  %196 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e-01, double noundef %193, double noundef %195)
  br label %197

197:                                              ; preds = %186, %183
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  %198 = load ptr, ptr %2, align 8, !tbaa !5
  %199 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %198, i32 0, i32 0
  %200 = load i32, ptr %199, align 4, !tbaa !18
  %201 = add nsw i32 %200, 1
  store i32 %201, ptr %199, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %202 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 0
  %203 = getelementptr inbounds [4 x float], ptr %202, i64 0, i64 1
  %204 = load float, ptr %203, align 4, !tbaa !13
  store float %204, ptr %13, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  %205 = load float, ptr %13, align 4, !tbaa !9
  %206 = fsub float %205, 1.000000e+00
  store float %206, ptr %14, align 4, !tbaa !9
  %207 = load float, ptr %14, align 4, !tbaa !9
  %208 = fcmp olt float %207, 0xBE80000000000000
  br i1 %208, label %212, label %209

209:                                              ; preds = %197
  %210 = load float, ptr %14, align 4, !tbaa !9
  %211 = fcmp olt float 0x3E80000000000000, %210
  br i1 %211, label %212, label %223

212:                                              ; preds = %209, %197
  %213 = load ptr, ptr %2, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %213, i32 0, i32 1
  %215 = load i32, ptr %214, align 4, !tbaa !20
  %216 = add nsw i32 %215, 1
  store i32 %216, ptr %214, align 4, !tbaa !20
  %217 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 325)
  %218 = load float, ptr %13, align 4, !tbaa !9
  %219 = fpext float %218 to double
  %220 = load float, ptr %14, align 4, !tbaa !9
  %221 = fpext float %220 to double
  %222 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+00, double noundef %219, double noundef %221)
  br label %223

223:                                              ; preds = %212, %209
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  %224 = load ptr, ptr %2, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %224, i32 0, i32 0
  %226 = load i32, ptr %225, align 4, !tbaa !18
  %227 = add nsw i32 %226, 1
  store i32 %227, ptr %225, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #6
  %228 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 0
  %229 = getelementptr inbounds [4 x float], ptr %228, i64 0, i64 2
  %230 = load float, ptr %229, align 8, !tbaa !13
  store float %230, ptr %15, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %231 = load float, ptr %15, align 4, !tbaa !9
  %232 = fsub float %231, 1.500000e+00
  store float %232, ptr %16, align 4, !tbaa !9
  %233 = load float, ptr %16, align 4, !tbaa !9
  %234 = fcmp olt float %233, 0xBE80000000000000
  br i1 %234, label %238, label %235

235:                                              ; preds = %223
  %236 = load float, ptr %16, align 4, !tbaa !9
  %237 = fcmp olt float 0x3E80000000000000, %236
  br i1 %237, label %238, label %249

238:                                              ; preds = %235, %223
  %239 = load ptr, ptr %2, align 8, !tbaa !5
  %240 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %239, i32 0, i32 1
  %241 = load i32, ptr %240, align 4, !tbaa !20
  %242 = add nsw i32 %241, 1
  store i32 %242, ptr %240, align 4, !tbaa !20
  %243 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 326)
  %244 = load float, ptr %15, align 4, !tbaa !9
  %245 = fpext float %244 to double
  %246 = load float, ptr %16, align 4, !tbaa !9
  %247 = fpext float %246 to double
  %248 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.500000e+00, double noundef %245, double noundef %247)
  br label %249

249:                                              ; preds = %238, %235
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #6
  %250 = load ptr, ptr %2, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %250, i32 0, i32 0
  %252 = load i32, ptr %251, align 4, !tbaa !18
  %253 = add nsw i32 %252, 1
  store i32 %253, ptr %251, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %254 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 0
  %255 = getelementptr inbounds [4 x float], ptr %254, i64 0, i64 3
  %256 = load float, ptr %255, align 4, !tbaa !13
  store float %256, ptr %17, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  %257 = load float, ptr %17, align 4, !tbaa !9
  %258 = fsub float %257, 2.000000e+00
  store float %258, ptr %18, align 4, !tbaa !9
  %259 = load float, ptr %18, align 4, !tbaa !9
  %260 = fcmp olt float %259, 0xBE80000000000000
  br i1 %260, label %264, label %261

261:                                              ; preds = %249
  %262 = load float, ptr %18, align 4, !tbaa !9
  %263 = fcmp olt float 0x3E80000000000000, %262
  br i1 %263, label %264, label %275

264:                                              ; preds = %261, %249
  %265 = load ptr, ptr %2, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %265, i32 0, i32 1
  %267 = load i32, ptr %266, align 4, !tbaa !20
  %268 = add nsw i32 %267, 1
  store i32 %268, ptr %266, align 4, !tbaa !20
  %269 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 327)
  %270 = load float, ptr %17, align 4, !tbaa !9
  %271 = fpext float %270 to double
  %272 = load float, ptr %18, align 4, !tbaa !9
  %273 = fpext float %272 to double
  %274 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+00, double noundef %271, double noundef %273)
  br label %275

275:                                              ; preds = %264, %261
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  %276 = load ptr, ptr %2, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %276, i32 0, i32 0
  %278 = load i32, ptr %277, align 4, !tbaa !18
  %279 = add nsw i32 %278, 1
  store i32 %279, ptr %277, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  %280 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 1
  %281 = getelementptr inbounds [4 x float], ptr %280, i64 0, i64 0
  %282 = load float, ptr %281, align 16, !tbaa !13
  store float %282, ptr %19, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  %283 = load float, ptr %19, align 4, !tbaa !9
  %284 = fsub float %283, 2.500000e+00
  store float %284, ptr %20, align 4, !tbaa !9
  %285 = load float, ptr %20, align 4, !tbaa !9
  %286 = fcmp olt float %285, 0xBE80000000000000
  br i1 %286, label %290, label %287

287:                                              ; preds = %275
  %288 = load float, ptr %20, align 4, !tbaa !9
  %289 = fcmp olt float 0x3E80000000000000, %288
  br i1 %289, label %290, label %301

290:                                              ; preds = %287, %275
  %291 = load ptr, ptr %2, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %291, i32 0, i32 1
  %293 = load i32, ptr %292, align 4, !tbaa !20
  %294 = add nsw i32 %293, 1
  store i32 %294, ptr %292, align 4, !tbaa !20
  %295 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 328)
  %296 = load float, ptr %19, align 4, !tbaa !9
  %297 = fpext float %296 to double
  %298 = load float, ptr %20, align 4, !tbaa !9
  %299 = fpext float %298 to double
  %300 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.500000e+00, double noundef %297, double noundef %299)
  br label %301

301:                                              ; preds = %290, %287
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  %302 = load ptr, ptr %2, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %302, i32 0, i32 0
  %304 = load i32, ptr %303, align 4, !tbaa !18
  %305 = add nsw i32 %304, 1
  store i32 %305, ptr %303, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  %306 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 1
  %307 = getelementptr inbounds [4 x float], ptr %306, i64 0, i64 1
  %308 = load float, ptr %307, align 4, !tbaa !13
  store float %308, ptr %21, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %309 = load float, ptr %21, align 4, !tbaa !9
  %310 = fsub float %309, 3.000000e+00
  store float %310, ptr %22, align 4, !tbaa !9
  %311 = load float, ptr %22, align 4, !tbaa !9
  %312 = fcmp olt float %311, 0xBE80000000000000
  br i1 %312, label %316, label %313

313:                                              ; preds = %301
  %314 = load float, ptr %22, align 4, !tbaa !9
  %315 = fcmp olt float 0x3E80000000000000, %314
  br i1 %315, label %316, label %327

316:                                              ; preds = %313, %301
  %317 = load ptr, ptr %2, align 8, !tbaa !5
  %318 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %317, i32 0, i32 1
  %319 = load i32, ptr %318, align 4, !tbaa !20
  %320 = add nsw i32 %319, 1
  store i32 %320, ptr %318, align 4, !tbaa !20
  %321 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %322 = load float, ptr %21, align 4, !tbaa !9
  %323 = fpext float %322 to double
  %324 = load float, ptr %22, align 4, !tbaa !9
  %325 = fpext float %324 to double
  %326 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+00, double noundef %323, double noundef %325)
  br label %327

327:                                              ; preds = %316, %313
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  %328 = load ptr, ptr %2, align 8, !tbaa !5
  %329 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %328, i32 0, i32 0
  %330 = load i32, ptr %329, align 4, !tbaa !18
  %331 = add nsw i32 %330, 1
  store i32 %331, ptr %329, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %332 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 1
  %333 = getelementptr inbounds [4 x float], ptr %332, i64 0, i64 2
  %334 = load float, ptr %333, align 8, !tbaa !13
  store float %334, ptr %23, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %335 = load float, ptr %23, align 4, !tbaa !9
  %336 = fsub float %335, 3.500000e+00
  store float %336, ptr %24, align 4, !tbaa !9
  %337 = load float, ptr %24, align 4, !tbaa !9
  %338 = fcmp olt float %337, 0xBE80000000000000
  br i1 %338, label %342, label %339

339:                                              ; preds = %327
  %340 = load float, ptr %24, align 4, !tbaa !9
  %341 = fcmp olt float 0x3E80000000000000, %340
  br i1 %341, label %342, label %353

342:                                              ; preds = %339, %327
  %343 = load ptr, ptr %2, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %343, i32 0, i32 1
  %345 = load i32, ptr %344, align 4, !tbaa !20
  %346 = add nsw i32 %345, 1
  store i32 %346, ptr %344, align 4, !tbaa !20
  %347 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 330)
  %348 = load float, ptr %23, align 4, !tbaa !9
  %349 = fpext float %348 to double
  %350 = load float, ptr %24, align 4, !tbaa !9
  %351 = fpext float %350 to double
  %352 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.500000e+00, double noundef %349, double noundef %351)
  br label %353

353:                                              ; preds = %342, %339
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  %354 = load ptr, ptr %2, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %354, i32 0, i32 0
  %356 = load i32, ptr %355, align 4, !tbaa !18
  %357 = add nsw i32 %356, 1
  store i32 %357, ptr %355, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  %358 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 1
  %359 = getelementptr inbounds [4 x float], ptr %358, i64 0, i64 3
  %360 = load float, ptr %359, align 4, !tbaa !13
  store float %360, ptr %25, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %361 = load float, ptr %25, align 4, !tbaa !9
  %362 = fsub float %361, 4.000000e+00
  store float %362, ptr %26, align 4, !tbaa !9
  %363 = load float, ptr %26, align 4, !tbaa !9
  %364 = fcmp olt float %363, 0xBE80000000000000
  br i1 %364, label %368, label %365

365:                                              ; preds = %353
  %366 = load float, ptr %26, align 4, !tbaa !9
  %367 = fcmp olt float 0x3E80000000000000, %366
  br i1 %367, label %368, label %379

368:                                              ; preds = %365, %353
  %369 = load ptr, ptr %2, align 8, !tbaa !5
  %370 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %369, i32 0, i32 1
  %371 = load i32, ptr %370, align 4, !tbaa !20
  %372 = add nsw i32 %371, 1
  store i32 %372, ptr %370, align 4, !tbaa !20
  %373 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 331)
  %374 = load float, ptr %25, align 4, !tbaa !9
  %375 = fpext float %374 to double
  %376 = load float, ptr %26, align 4, !tbaa !9
  %377 = fpext float %376 to double
  %378 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+00, double noundef %375, double noundef %377)
  br label %379

379:                                              ; preds = %368, %365
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  %380 = load ptr, ptr %2, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %380, i32 0, i32 0
  %382 = load i32, ptr %381, align 4, !tbaa !18
  %383 = add nsw i32 %382, 1
  store i32 %383, ptr %381, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  %384 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 2
  %385 = getelementptr inbounds [4 x float], ptr %384, i64 0, i64 0
  %386 = load float, ptr %385, align 16, !tbaa !13
  store float %386, ptr %27, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %387 = load float, ptr %27, align 4, !tbaa !9
  %388 = fsub float %387, 4.500000e+00
  store float %388, ptr %28, align 4, !tbaa !9
  %389 = load float, ptr %28, align 4, !tbaa !9
  %390 = fcmp olt float %389, 0xBE80000000000000
  br i1 %390, label %394, label %391

391:                                              ; preds = %379
  %392 = load float, ptr %28, align 4, !tbaa !9
  %393 = fcmp olt float 0x3E80000000000000, %392
  br i1 %393, label %394, label %405

394:                                              ; preds = %391, %379
  %395 = load ptr, ptr %2, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %395, i32 0, i32 1
  %397 = load i32, ptr %396, align 4, !tbaa !20
  %398 = add nsw i32 %397, 1
  store i32 %398, ptr %396, align 4, !tbaa !20
  %399 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 332)
  %400 = load float, ptr %27, align 4, !tbaa !9
  %401 = fpext float %400 to double
  %402 = load float, ptr %28, align 4, !tbaa !9
  %403 = fpext float %402 to double
  %404 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.500000e+00, double noundef %401, double noundef %403)
  br label %405

405:                                              ; preds = %394, %391
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  %406 = load ptr, ptr %2, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %406, i32 0, i32 0
  %408 = load i32, ptr %407, align 4, !tbaa !18
  %409 = add nsw i32 %408, 1
  store i32 %409, ptr %407, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  %410 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 2
  %411 = getelementptr inbounds [4 x float], ptr %410, i64 0, i64 1
  %412 = load float, ptr %411, align 4, !tbaa !13
  store float %412, ptr %29, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %413 = load float, ptr %29, align 4, !tbaa !9
  %414 = fsub float %413, 5.000000e+00
  store float %414, ptr %30, align 4, !tbaa !9
  %415 = load float, ptr %30, align 4, !tbaa !9
  %416 = fcmp olt float %415, 0xBE80000000000000
  br i1 %416, label %420, label %417

417:                                              ; preds = %405
  %418 = load float, ptr %30, align 4, !tbaa !9
  %419 = fcmp olt float 0x3E80000000000000, %418
  br i1 %419, label %420, label %431

420:                                              ; preds = %417, %405
  %421 = load ptr, ptr %2, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %421, i32 0, i32 1
  %423 = load i32, ptr %422, align 4, !tbaa !20
  %424 = add nsw i32 %423, 1
  store i32 %424, ptr %422, align 4, !tbaa !20
  %425 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 333)
  %426 = load float, ptr %29, align 4, !tbaa !9
  %427 = fpext float %426 to double
  %428 = load float, ptr %30, align 4, !tbaa !9
  %429 = fpext float %428 to double
  %430 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e+00, double noundef %427, double noundef %429)
  br label %431

431:                                              ; preds = %420, %417
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  %432 = load ptr, ptr %2, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %432, i32 0, i32 0
  %434 = load i32, ptr %433, align 4, !tbaa !18
  %435 = add nsw i32 %434, 1
  store i32 %435, ptr %433, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %436 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 2
  %437 = getelementptr inbounds [4 x float], ptr %436, i64 0, i64 2
  %438 = load float, ptr %437, align 8, !tbaa !13
  store float %438, ptr %31, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  %439 = load float, ptr %31, align 4, !tbaa !9
  %440 = fsub float %439, 5.500000e+00
  store float %440, ptr %32, align 4, !tbaa !9
  %441 = load float, ptr %32, align 4, !tbaa !9
  %442 = fcmp olt float %441, 0xBE80000000000000
  br i1 %442, label %446, label %443

443:                                              ; preds = %431
  %444 = load float, ptr %32, align 4, !tbaa !9
  %445 = fcmp olt float 0x3E80000000000000, %444
  br i1 %445, label %446, label %457

446:                                              ; preds = %443, %431
  %447 = load ptr, ptr %2, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %447, i32 0, i32 1
  %449 = load i32, ptr %448, align 4, !tbaa !20
  %450 = add nsw i32 %449, 1
  store i32 %450, ptr %448, align 4, !tbaa !20
  %451 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 334)
  %452 = load float, ptr %31, align 4, !tbaa !9
  %453 = fpext float %452 to double
  %454 = load float, ptr %32, align 4, !tbaa !9
  %455 = fpext float %454 to double
  %456 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.500000e+00, double noundef %453, double noundef %455)
  br label %457

457:                                              ; preds = %446, %443
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  %458 = load ptr, ptr %2, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %458, i32 0, i32 0
  %460 = load i32, ptr %459, align 4, !tbaa !18
  %461 = add nsw i32 %460, 1
  store i32 %461, ptr %459, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  %462 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 2
  %463 = getelementptr inbounds [4 x float], ptr %462, i64 0, i64 3
  %464 = load float, ptr %463, align 4, !tbaa !13
  store float %464, ptr %33, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  %465 = load float, ptr %33, align 4, !tbaa !9
  %466 = fsub float %465, 6.000000e+00
  store float %466, ptr %34, align 4, !tbaa !9
  %467 = load float, ptr %34, align 4, !tbaa !9
  %468 = fcmp olt float %467, 0xBE80000000000000
  br i1 %468, label %472, label %469

469:                                              ; preds = %457
  %470 = load float, ptr %34, align 4, !tbaa !9
  %471 = fcmp olt float 0x3E80000000000000, %470
  br i1 %471, label %472, label %483

472:                                              ; preds = %469, %457
  %473 = load ptr, ptr %2, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %473, i32 0, i32 1
  %475 = load i32, ptr %474, align 4, !tbaa !20
  %476 = add nsw i32 %475, 1
  store i32 %476, ptr %474, align 4, !tbaa !20
  %477 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 335)
  %478 = load float, ptr %33, align 4, !tbaa !9
  %479 = fpext float %478 to double
  %480 = load float, ptr %34, align 4, !tbaa !9
  %481 = fpext float %480 to double
  %482 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.000000e+00, double noundef %479, double noundef %481)
  br label %483

483:                                              ; preds = %472, %469
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  %484 = load ptr, ptr %2, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %484, i32 0, i32 0
  %486 = load i32, ptr %485, align 4, !tbaa !18
  %487 = add nsw i32 %486, 1
  store i32 %487, ptr %485, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  %488 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 3
  %489 = getelementptr inbounds [4 x float], ptr %488, i64 0, i64 0
  %490 = load float, ptr %489, align 16, !tbaa !13
  store float %490, ptr %35, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %491 = load float, ptr %35, align 4, !tbaa !9
  %492 = fsub float %491, 6.500000e+00
  store float %492, ptr %36, align 4, !tbaa !9
  %493 = load float, ptr %36, align 4, !tbaa !9
  %494 = fcmp olt float %493, 0xBE80000000000000
  br i1 %494, label %498, label %495

495:                                              ; preds = %483
  %496 = load float, ptr %36, align 4, !tbaa !9
  %497 = fcmp olt float 0x3E80000000000000, %496
  br i1 %497, label %498, label %509

498:                                              ; preds = %495, %483
  %499 = load ptr, ptr %2, align 8, !tbaa !5
  %500 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %499, i32 0, i32 1
  %501 = load i32, ptr %500, align 4, !tbaa !20
  %502 = add nsw i32 %501, 1
  store i32 %502, ptr %500, align 4, !tbaa !20
  %503 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 336)
  %504 = load float, ptr %35, align 4, !tbaa !9
  %505 = fpext float %504 to double
  %506 = load float, ptr %36, align 4, !tbaa !9
  %507 = fpext float %506 to double
  %508 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+00, double noundef %505, double noundef %507)
  br label %509

509:                                              ; preds = %498, %495
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  %510 = load ptr, ptr %2, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %510, i32 0, i32 0
  %512 = load i32, ptr %511, align 4, !tbaa !18
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %511, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  %514 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 3
  %515 = getelementptr inbounds [4 x float], ptr %514, i64 0, i64 1
  %516 = load float, ptr %515, align 4, !tbaa !13
  store float %516, ptr %37, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  %517 = load float, ptr %37, align 4, !tbaa !9
  %518 = fsub float %517, 7.000000e+00
  store float %518, ptr %38, align 4, !tbaa !9
  %519 = load float, ptr %38, align 4, !tbaa !9
  %520 = fcmp olt float %519, 0xBE80000000000000
  br i1 %520, label %524, label %521

521:                                              ; preds = %509
  %522 = load float, ptr %38, align 4, !tbaa !9
  %523 = fcmp olt float 0x3E80000000000000, %522
  br i1 %523, label %524, label %535

524:                                              ; preds = %521, %509
  %525 = load ptr, ptr %2, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %525, i32 0, i32 1
  %527 = load i32, ptr %526, align 4, !tbaa !20
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %526, align 4, !tbaa !20
  %529 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %530 = load float, ptr %37, align 4, !tbaa !9
  %531 = fpext float %530 to double
  %532 = load float, ptr %38, align 4, !tbaa !9
  %533 = fpext float %532 to double
  %534 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.000000e+00, double noundef %531, double noundef %533)
  br label %535

535:                                              ; preds = %524, %521
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  %536 = load ptr, ptr %2, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %536, i32 0, i32 0
  %538 = load i32, ptr %537, align 4, !tbaa !18
  %539 = add nsw i32 %538, 1
  store i32 %539, ptr %537, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  %540 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 3
  %541 = getelementptr inbounds [4 x float], ptr %540, i64 0, i64 2
  %542 = load float, ptr %541, align 8, !tbaa !13
  store float %542, ptr %39, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #6
  %543 = load float, ptr %39, align 4, !tbaa !9
  %544 = fsub float %543, 7.500000e+00
  store float %544, ptr %40, align 4, !tbaa !9
  %545 = load float, ptr %40, align 4, !tbaa !9
  %546 = fcmp olt float %545, 0xBE80000000000000
  br i1 %546, label %550, label %547

547:                                              ; preds = %535
  %548 = load float, ptr %40, align 4, !tbaa !9
  %549 = fcmp olt float 0x3E80000000000000, %548
  br i1 %549, label %550, label %561

550:                                              ; preds = %547, %535
  %551 = load ptr, ptr %2, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %551, i32 0, i32 1
  %553 = load i32, ptr %552, align 4, !tbaa !20
  %554 = add nsw i32 %553, 1
  store i32 %554, ptr %552, align 4, !tbaa !20
  %555 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 338)
  %556 = load float, ptr %39, align 4, !tbaa !9
  %557 = fpext float %556 to double
  %558 = load float, ptr %40, align 4, !tbaa !9
  %559 = fpext float %558 to double
  %560 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.500000e+00, double noundef %557, double noundef %559)
  br label %561

561:                                              ; preds = %550, %547
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  %562 = load ptr, ptr %2, align 8, !tbaa !5
  %563 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %562, i32 0, i32 0
  %564 = load i32, ptr %563, align 4, !tbaa !18
  %565 = add nsw i32 %564, 1
  store i32 %565, ptr %563, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  %566 = getelementptr inbounds [4 x [4 x float]], ptr %9, i64 0, i64 3
  %567 = getelementptr inbounds [4 x float], ptr %566, i64 0, i64 3
  %568 = load float, ptr %567, align 4, !tbaa !13
  store float %568, ptr %41, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  %569 = load float, ptr %41, align 4, !tbaa !9
  %570 = fsub float %569, 8.000000e+00
  store float %570, ptr %42, align 4, !tbaa !9
  %571 = load float, ptr %42, align 4, !tbaa !9
  %572 = fcmp olt float %571, 0xBE80000000000000
  br i1 %572, label %576, label %573

573:                                              ; preds = %561
  %574 = load float, ptr %42, align 4, !tbaa !9
  %575 = fcmp olt float 0x3E80000000000000, %574
  br i1 %575, label %576, label %587

576:                                              ; preds = %573, %561
  %577 = load ptr, ptr %2, align 8, !tbaa !5
  %578 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %577, i32 0, i32 1
  %579 = load i32, ptr %578, align 4, !tbaa !20
  %580 = add nsw i32 %579, 1
  store i32 %580, ptr %578, align 4, !tbaa !20
  %581 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 339)
  %582 = load float, ptr %41, align 4, !tbaa !9
  %583 = fpext float %582 to double
  %584 = load float, ptr %42, align 4, !tbaa !9
  %585 = fpext float %584 to double
  %586 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.000000e+00, double noundef %583, double noundef %585)
  br label %587

587:                                              ; preds = %576, %573
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %43) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %44, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  %588 = load float, ptr %4, align 4, !tbaa !9
  call void @_ZL7HMM_Div8HMM_Mat4f(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %43, ptr noundef byval(%union.HMM_Mat4) align 16 %44, float noundef %588)
  %589 = load ptr, ptr %2, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %589, i32 0, i32 0
  %591 = load i32, ptr %590, align 4, !tbaa !18
  %592 = add nsw i32 %591, 1
  store i32 %592, ptr %590, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %593 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 0
  %594 = getelementptr inbounds [4 x float], ptr %593, i64 0, i64 0
  %595 = load float, ptr %594, align 16, !tbaa !13
  store float %595, ptr %45, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %596 = load float, ptr %45, align 4, !tbaa !9
  %597 = fsub float %596, 5.000000e-01
  store float %597, ptr %46, align 4, !tbaa !9
  %598 = load float, ptr %46, align 4, !tbaa !9
  %599 = fcmp olt float %598, 0xBE80000000000000
  br i1 %599, label %603, label %600

600:                                              ; preds = %587
  %601 = load float, ptr %46, align 4, !tbaa !9
  %602 = fcmp olt float 0x3E80000000000000, %601
  br i1 %602, label %603, label %614

603:                                              ; preds = %600, %587
  %604 = load ptr, ptr %2, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %604, i32 0, i32 1
  %606 = load i32, ptr %605, align 4, !tbaa !20
  %607 = add nsw i32 %606, 1
  store i32 %607, ptr %605, align 4, !tbaa !20
  %608 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 344)
  %609 = load float, ptr %45, align 4, !tbaa !9
  %610 = fpext float %609 to double
  %611 = load float, ptr %46, align 4, !tbaa !9
  %612 = fpext float %611 to double
  %613 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e-01, double noundef %610, double noundef %612)
  br label %614

614:                                              ; preds = %603, %600
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  %615 = load ptr, ptr %2, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %615, i32 0, i32 0
  %617 = load i32, ptr %616, align 4, !tbaa !18
  %618 = add nsw i32 %617, 1
  store i32 %618, ptr %616, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #6
  %619 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 0
  %620 = getelementptr inbounds [4 x float], ptr %619, i64 0, i64 1
  %621 = load float, ptr %620, align 4, !tbaa !13
  store float %621, ptr %47, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  %622 = load float, ptr %47, align 4, !tbaa !9
  %623 = fsub float %622, 1.000000e+00
  store float %623, ptr %48, align 4, !tbaa !9
  %624 = load float, ptr %48, align 4, !tbaa !9
  %625 = fcmp olt float %624, 0xBE80000000000000
  br i1 %625, label %629, label %626

626:                                              ; preds = %614
  %627 = load float, ptr %48, align 4, !tbaa !9
  %628 = fcmp olt float 0x3E80000000000000, %627
  br i1 %628, label %629, label %640

629:                                              ; preds = %626, %614
  %630 = load ptr, ptr %2, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %630, i32 0, i32 1
  %632 = load i32, ptr %631, align 4, !tbaa !20
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %631, align 4, !tbaa !20
  %634 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 345)
  %635 = load float, ptr %47, align 4, !tbaa !9
  %636 = fpext float %635 to double
  %637 = load float, ptr %48, align 4, !tbaa !9
  %638 = fpext float %637 to double
  %639 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+00, double noundef %636, double noundef %638)
  br label %640

640:                                              ; preds = %629, %626
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #6
  %641 = load ptr, ptr %2, align 8, !tbaa !5
  %642 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %641, i32 0, i32 0
  %643 = load i32, ptr %642, align 4, !tbaa !18
  %644 = add nsw i32 %643, 1
  store i32 %644, ptr %642, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  %645 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 0
  %646 = getelementptr inbounds [4 x float], ptr %645, i64 0, i64 2
  %647 = load float, ptr %646, align 8, !tbaa !13
  store float %647, ptr %49, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  %648 = load float, ptr %49, align 4, !tbaa !9
  %649 = fsub float %648, 1.500000e+00
  store float %649, ptr %50, align 4, !tbaa !9
  %650 = load float, ptr %50, align 4, !tbaa !9
  %651 = fcmp olt float %650, 0xBE80000000000000
  br i1 %651, label %655, label %652

652:                                              ; preds = %640
  %653 = load float, ptr %50, align 4, !tbaa !9
  %654 = fcmp olt float 0x3E80000000000000, %653
  br i1 %654, label %655, label %666

655:                                              ; preds = %652, %640
  %656 = load ptr, ptr %2, align 8, !tbaa !5
  %657 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %656, i32 0, i32 1
  %658 = load i32, ptr %657, align 4, !tbaa !20
  %659 = add nsw i32 %658, 1
  store i32 %659, ptr %657, align 4, !tbaa !20
  %660 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 346)
  %661 = load float, ptr %49, align 4, !tbaa !9
  %662 = fpext float %661 to double
  %663 = load float, ptr %50, align 4, !tbaa !9
  %664 = fpext float %663 to double
  %665 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.500000e+00, double noundef %662, double noundef %664)
  br label %666

666:                                              ; preds = %655, %652
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  %667 = load ptr, ptr %2, align 8, !tbaa !5
  %668 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %667, i32 0, i32 0
  %669 = load i32, ptr %668, align 4, !tbaa !18
  %670 = add nsw i32 %669, 1
  store i32 %670, ptr %668, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #6
  %671 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 0
  %672 = getelementptr inbounds [4 x float], ptr %671, i64 0, i64 3
  %673 = load float, ptr %672, align 4, !tbaa !13
  store float %673, ptr %51, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #6
  %674 = load float, ptr %51, align 4, !tbaa !9
  %675 = fsub float %674, 2.000000e+00
  store float %675, ptr %52, align 4, !tbaa !9
  %676 = load float, ptr %52, align 4, !tbaa !9
  %677 = fcmp olt float %676, 0xBE80000000000000
  br i1 %677, label %681, label %678

678:                                              ; preds = %666
  %679 = load float, ptr %52, align 4, !tbaa !9
  %680 = fcmp olt float 0x3E80000000000000, %679
  br i1 %680, label %681, label %692

681:                                              ; preds = %678, %666
  %682 = load ptr, ptr %2, align 8, !tbaa !5
  %683 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %682, i32 0, i32 1
  %684 = load i32, ptr %683, align 4, !tbaa !20
  %685 = add nsw i32 %684, 1
  store i32 %685, ptr %683, align 4, !tbaa !20
  %686 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 347)
  %687 = load float, ptr %51, align 4, !tbaa !9
  %688 = fpext float %687 to double
  %689 = load float, ptr %52, align 4, !tbaa !9
  %690 = fpext float %689 to double
  %691 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+00, double noundef %688, double noundef %690)
  br label %692

692:                                              ; preds = %681, %678
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #6
  %693 = load ptr, ptr %2, align 8, !tbaa !5
  %694 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %693, i32 0, i32 0
  %695 = load i32, ptr %694, align 4, !tbaa !18
  %696 = add nsw i32 %695, 1
  store i32 %696, ptr %694, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #6
  %697 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 1
  %698 = getelementptr inbounds [4 x float], ptr %697, i64 0, i64 0
  %699 = load float, ptr %698, align 16, !tbaa !13
  store float %699, ptr %53, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  %700 = load float, ptr %53, align 4, !tbaa !9
  %701 = fsub float %700, 2.500000e+00
  store float %701, ptr %54, align 4, !tbaa !9
  %702 = load float, ptr %54, align 4, !tbaa !9
  %703 = fcmp olt float %702, 0xBE80000000000000
  br i1 %703, label %707, label %704

704:                                              ; preds = %692
  %705 = load float, ptr %54, align 4, !tbaa !9
  %706 = fcmp olt float 0x3E80000000000000, %705
  br i1 %706, label %707, label %718

707:                                              ; preds = %704, %692
  %708 = load ptr, ptr %2, align 8, !tbaa !5
  %709 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %708, i32 0, i32 1
  %710 = load i32, ptr %709, align 4, !tbaa !20
  %711 = add nsw i32 %710, 1
  store i32 %711, ptr %709, align 4, !tbaa !20
  %712 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 348)
  %713 = load float, ptr %53, align 4, !tbaa !9
  %714 = fpext float %713 to double
  %715 = load float, ptr %54, align 4, !tbaa !9
  %716 = fpext float %715 to double
  %717 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.500000e+00, double noundef %714, double noundef %716)
  br label %718

718:                                              ; preds = %707, %704
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  %719 = load ptr, ptr %2, align 8, !tbaa !5
  %720 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %719, i32 0, i32 0
  %721 = load i32, ptr %720, align 4, !tbaa !18
  %722 = add nsw i32 %721, 1
  store i32 %722, ptr %720, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #6
  %723 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 1
  %724 = getelementptr inbounds [4 x float], ptr %723, i64 0, i64 1
  %725 = load float, ptr %724, align 4, !tbaa !13
  store float %725, ptr %55, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #6
  %726 = load float, ptr %55, align 4, !tbaa !9
  %727 = fsub float %726, 3.000000e+00
  store float %727, ptr %56, align 4, !tbaa !9
  %728 = load float, ptr %56, align 4, !tbaa !9
  %729 = fcmp olt float %728, 0xBE80000000000000
  br i1 %729, label %733, label %730

730:                                              ; preds = %718
  %731 = load float, ptr %56, align 4, !tbaa !9
  %732 = fcmp olt float 0x3E80000000000000, %731
  br i1 %732, label %733, label %744

733:                                              ; preds = %730, %718
  %734 = load ptr, ptr %2, align 8, !tbaa !5
  %735 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %734, i32 0, i32 1
  %736 = load i32, ptr %735, align 4, !tbaa !20
  %737 = add nsw i32 %736, 1
  store i32 %737, ptr %735, align 4, !tbaa !20
  %738 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 349)
  %739 = load float, ptr %55, align 4, !tbaa !9
  %740 = fpext float %739 to double
  %741 = load float, ptr %56, align 4, !tbaa !9
  %742 = fpext float %741 to double
  %743 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+00, double noundef %740, double noundef %742)
  br label %744

744:                                              ; preds = %733, %730
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #6
  %745 = load ptr, ptr %2, align 8, !tbaa !5
  %746 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %745, i32 0, i32 0
  %747 = load i32, ptr %746, align 4, !tbaa !18
  %748 = add nsw i32 %747, 1
  store i32 %748, ptr %746, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #6
  %749 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 1
  %750 = getelementptr inbounds [4 x float], ptr %749, i64 0, i64 2
  %751 = load float, ptr %750, align 8, !tbaa !13
  store float %751, ptr %57, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #6
  %752 = load float, ptr %57, align 4, !tbaa !9
  %753 = fsub float %752, 3.500000e+00
  store float %753, ptr %58, align 4, !tbaa !9
  %754 = load float, ptr %58, align 4, !tbaa !9
  %755 = fcmp olt float %754, 0xBE80000000000000
  br i1 %755, label %759, label %756

756:                                              ; preds = %744
  %757 = load float, ptr %58, align 4, !tbaa !9
  %758 = fcmp olt float 0x3E80000000000000, %757
  br i1 %758, label %759, label %770

759:                                              ; preds = %756, %744
  %760 = load ptr, ptr %2, align 8, !tbaa !5
  %761 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %760, i32 0, i32 1
  %762 = load i32, ptr %761, align 4, !tbaa !20
  %763 = add nsw i32 %762, 1
  store i32 %763, ptr %761, align 4, !tbaa !20
  %764 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 350)
  %765 = load float, ptr %57, align 4, !tbaa !9
  %766 = fpext float %765 to double
  %767 = load float, ptr %58, align 4, !tbaa !9
  %768 = fpext float %767 to double
  %769 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.500000e+00, double noundef %766, double noundef %768)
  br label %770

770:                                              ; preds = %759, %756
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #6
  %771 = load ptr, ptr %2, align 8, !tbaa !5
  %772 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %771, i32 0, i32 0
  %773 = load i32, ptr %772, align 4, !tbaa !18
  %774 = add nsw i32 %773, 1
  store i32 %774, ptr %772, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #6
  %775 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 1
  %776 = getelementptr inbounds [4 x float], ptr %775, i64 0, i64 3
  %777 = load float, ptr %776, align 4, !tbaa !13
  store float %777, ptr %59, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #6
  %778 = load float, ptr %59, align 4, !tbaa !9
  %779 = fsub float %778, 4.000000e+00
  store float %779, ptr %60, align 4, !tbaa !9
  %780 = load float, ptr %60, align 4, !tbaa !9
  %781 = fcmp olt float %780, 0xBE80000000000000
  br i1 %781, label %785, label %782

782:                                              ; preds = %770
  %783 = load float, ptr %60, align 4, !tbaa !9
  %784 = fcmp olt float 0x3E80000000000000, %783
  br i1 %784, label %785, label %796

785:                                              ; preds = %782, %770
  %786 = load ptr, ptr %2, align 8, !tbaa !5
  %787 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %786, i32 0, i32 1
  %788 = load i32, ptr %787, align 4, !tbaa !20
  %789 = add nsw i32 %788, 1
  store i32 %789, ptr %787, align 4, !tbaa !20
  %790 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 351)
  %791 = load float, ptr %59, align 4, !tbaa !9
  %792 = fpext float %791 to double
  %793 = load float, ptr %60, align 4, !tbaa !9
  %794 = fpext float %793 to double
  %795 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+00, double noundef %792, double noundef %794)
  br label %796

796:                                              ; preds = %785, %782
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #6
  %797 = load ptr, ptr %2, align 8, !tbaa !5
  %798 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %797, i32 0, i32 0
  %799 = load i32, ptr %798, align 4, !tbaa !18
  %800 = add nsw i32 %799, 1
  store i32 %800, ptr %798, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #6
  %801 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 2
  %802 = getelementptr inbounds [4 x float], ptr %801, i64 0, i64 0
  %803 = load float, ptr %802, align 16, !tbaa !13
  store float %803, ptr %61, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #6
  %804 = load float, ptr %61, align 4, !tbaa !9
  %805 = fsub float %804, 4.500000e+00
  store float %805, ptr %62, align 4, !tbaa !9
  %806 = load float, ptr %62, align 4, !tbaa !9
  %807 = fcmp olt float %806, 0xBE80000000000000
  br i1 %807, label %811, label %808

808:                                              ; preds = %796
  %809 = load float, ptr %62, align 4, !tbaa !9
  %810 = fcmp olt float 0x3E80000000000000, %809
  br i1 %810, label %811, label %822

811:                                              ; preds = %808, %796
  %812 = load ptr, ptr %2, align 8, !tbaa !5
  %813 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %812, i32 0, i32 1
  %814 = load i32, ptr %813, align 4, !tbaa !20
  %815 = add nsw i32 %814, 1
  store i32 %815, ptr %813, align 4, !tbaa !20
  %816 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 352)
  %817 = load float, ptr %61, align 4, !tbaa !9
  %818 = fpext float %817 to double
  %819 = load float, ptr %62, align 4, !tbaa !9
  %820 = fpext float %819 to double
  %821 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.500000e+00, double noundef %818, double noundef %820)
  br label %822

822:                                              ; preds = %811, %808
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #6
  %823 = load ptr, ptr %2, align 8, !tbaa !5
  %824 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %823, i32 0, i32 0
  %825 = load i32, ptr %824, align 4, !tbaa !18
  %826 = add nsw i32 %825, 1
  store i32 %826, ptr %824, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #6
  %827 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 2
  %828 = getelementptr inbounds [4 x float], ptr %827, i64 0, i64 1
  %829 = load float, ptr %828, align 4, !tbaa !13
  store float %829, ptr %63, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #6
  %830 = load float, ptr %63, align 4, !tbaa !9
  %831 = fsub float %830, 5.000000e+00
  store float %831, ptr %64, align 4, !tbaa !9
  %832 = load float, ptr %64, align 4, !tbaa !9
  %833 = fcmp olt float %832, 0xBE80000000000000
  br i1 %833, label %837, label %834

834:                                              ; preds = %822
  %835 = load float, ptr %64, align 4, !tbaa !9
  %836 = fcmp olt float 0x3E80000000000000, %835
  br i1 %836, label %837, label %848

837:                                              ; preds = %834, %822
  %838 = load ptr, ptr %2, align 8, !tbaa !5
  %839 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %838, i32 0, i32 1
  %840 = load i32, ptr %839, align 4, !tbaa !20
  %841 = add nsw i32 %840, 1
  store i32 %841, ptr %839, align 4, !tbaa !20
  %842 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 353)
  %843 = load float, ptr %63, align 4, !tbaa !9
  %844 = fpext float %843 to double
  %845 = load float, ptr %64, align 4, !tbaa !9
  %846 = fpext float %845 to double
  %847 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e+00, double noundef %844, double noundef %846)
  br label %848

848:                                              ; preds = %837, %834
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  %849 = load ptr, ptr %2, align 8, !tbaa !5
  %850 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %849, i32 0, i32 0
  %851 = load i32, ptr %850, align 4, !tbaa !18
  %852 = add nsw i32 %851, 1
  store i32 %852, ptr %850, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #6
  %853 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 2
  %854 = getelementptr inbounds [4 x float], ptr %853, i64 0, i64 2
  %855 = load float, ptr %854, align 8, !tbaa !13
  store float %855, ptr %65, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #6
  %856 = load float, ptr %65, align 4, !tbaa !9
  %857 = fsub float %856, 5.500000e+00
  store float %857, ptr %66, align 4, !tbaa !9
  %858 = load float, ptr %66, align 4, !tbaa !9
  %859 = fcmp olt float %858, 0xBE80000000000000
  br i1 %859, label %863, label %860

860:                                              ; preds = %848
  %861 = load float, ptr %66, align 4, !tbaa !9
  %862 = fcmp olt float 0x3E80000000000000, %861
  br i1 %862, label %863, label %874

863:                                              ; preds = %860, %848
  %864 = load ptr, ptr %2, align 8, !tbaa !5
  %865 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %864, i32 0, i32 1
  %866 = load i32, ptr %865, align 4, !tbaa !20
  %867 = add nsw i32 %866, 1
  store i32 %867, ptr %865, align 4, !tbaa !20
  %868 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 354)
  %869 = load float, ptr %65, align 4, !tbaa !9
  %870 = fpext float %869 to double
  %871 = load float, ptr %66, align 4, !tbaa !9
  %872 = fpext float %871 to double
  %873 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.500000e+00, double noundef %870, double noundef %872)
  br label %874

874:                                              ; preds = %863, %860
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #6
  %875 = load ptr, ptr %2, align 8, !tbaa !5
  %876 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %875, i32 0, i32 0
  %877 = load i32, ptr %876, align 4, !tbaa !18
  %878 = add nsw i32 %877, 1
  store i32 %878, ptr %876, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #6
  %879 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 2
  %880 = getelementptr inbounds [4 x float], ptr %879, i64 0, i64 3
  %881 = load float, ptr %880, align 4, !tbaa !13
  store float %881, ptr %67, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #6
  %882 = load float, ptr %67, align 4, !tbaa !9
  %883 = fsub float %882, 6.000000e+00
  store float %883, ptr %68, align 4, !tbaa !9
  %884 = load float, ptr %68, align 4, !tbaa !9
  %885 = fcmp olt float %884, 0xBE80000000000000
  br i1 %885, label %889, label %886

886:                                              ; preds = %874
  %887 = load float, ptr %68, align 4, !tbaa !9
  %888 = fcmp olt float 0x3E80000000000000, %887
  br i1 %888, label %889, label %900

889:                                              ; preds = %886, %874
  %890 = load ptr, ptr %2, align 8, !tbaa !5
  %891 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %890, i32 0, i32 1
  %892 = load i32, ptr %891, align 4, !tbaa !20
  %893 = add nsw i32 %892, 1
  store i32 %893, ptr %891, align 4, !tbaa !20
  %894 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 355)
  %895 = load float, ptr %67, align 4, !tbaa !9
  %896 = fpext float %895 to double
  %897 = load float, ptr %68, align 4, !tbaa !9
  %898 = fpext float %897 to double
  %899 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.000000e+00, double noundef %896, double noundef %898)
  br label %900

900:                                              ; preds = %889, %886
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #6
  %901 = load ptr, ptr %2, align 8, !tbaa !5
  %902 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %901, i32 0, i32 0
  %903 = load i32, ptr %902, align 4, !tbaa !18
  %904 = add nsw i32 %903, 1
  store i32 %904, ptr %902, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #6
  %905 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 3
  %906 = getelementptr inbounds [4 x float], ptr %905, i64 0, i64 0
  %907 = load float, ptr %906, align 16, !tbaa !13
  store float %907, ptr %69, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #6
  %908 = load float, ptr %69, align 4, !tbaa !9
  %909 = fsub float %908, 6.500000e+00
  store float %909, ptr %70, align 4, !tbaa !9
  %910 = load float, ptr %70, align 4, !tbaa !9
  %911 = fcmp olt float %910, 0xBE80000000000000
  br i1 %911, label %915, label %912

912:                                              ; preds = %900
  %913 = load float, ptr %70, align 4, !tbaa !9
  %914 = fcmp olt float 0x3E80000000000000, %913
  br i1 %914, label %915, label %926

915:                                              ; preds = %912, %900
  %916 = load ptr, ptr %2, align 8, !tbaa !5
  %917 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %916, i32 0, i32 1
  %918 = load i32, ptr %917, align 4, !tbaa !20
  %919 = add nsw i32 %918, 1
  store i32 %919, ptr %917, align 4, !tbaa !20
  %920 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 356)
  %921 = load float, ptr %69, align 4, !tbaa !9
  %922 = fpext float %921 to double
  %923 = load float, ptr %70, align 4, !tbaa !9
  %924 = fpext float %923 to double
  %925 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+00, double noundef %922, double noundef %924)
  br label %926

926:                                              ; preds = %915, %912
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #6
  %927 = load ptr, ptr %2, align 8, !tbaa !5
  %928 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %927, i32 0, i32 0
  %929 = load i32, ptr %928, align 4, !tbaa !18
  %930 = add nsw i32 %929, 1
  store i32 %930, ptr %928, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #6
  %931 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 3
  %932 = getelementptr inbounds [4 x float], ptr %931, i64 0, i64 1
  %933 = load float, ptr %932, align 4, !tbaa !13
  store float %933, ptr %71, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #6
  %934 = load float, ptr %71, align 4, !tbaa !9
  %935 = fsub float %934, 7.000000e+00
  store float %935, ptr %72, align 4, !tbaa !9
  %936 = load float, ptr %72, align 4, !tbaa !9
  %937 = fcmp olt float %936, 0xBE80000000000000
  br i1 %937, label %941, label %938

938:                                              ; preds = %926
  %939 = load float, ptr %72, align 4, !tbaa !9
  %940 = fcmp olt float 0x3E80000000000000, %939
  br i1 %940, label %941, label %952

941:                                              ; preds = %938, %926
  %942 = load ptr, ptr %2, align 8, !tbaa !5
  %943 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %942, i32 0, i32 1
  %944 = load i32, ptr %943, align 4, !tbaa !20
  %945 = add nsw i32 %944, 1
  store i32 %945, ptr %943, align 4, !tbaa !20
  %946 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 357)
  %947 = load float, ptr %71, align 4, !tbaa !9
  %948 = fpext float %947 to double
  %949 = load float, ptr %72, align 4, !tbaa !9
  %950 = fpext float %949 to double
  %951 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.000000e+00, double noundef %948, double noundef %950)
  br label %952

952:                                              ; preds = %941, %938
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #6
  %953 = load ptr, ptr %2, align 8, !tbaa !5
  %954 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %953, i32 0, i32 0
  %955 = load i32, ptr %954, align 4, !tbaa !18
  %956 = add nsw i32 %955, 1
  store i32 %956, ptr %954, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #6
  %957 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 3
  %958 = getelementptr inbounds [4 x float], ptr %957, i64 0, i64 2
  %959 = load float, ptr %958, align 8, !tbaa !13
  store float %959, ptr %73, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #6
  %960 = load float, ptr %73, align 4, !tbaa !9
  %961 = fsub float %960, 7.500000e+00
  store float %961, ptr %74, align 4, !tbaa !9
  %962 = load float, ptr %74, align 4, !tbaa !9
  %963 = fcmp olt float %962, 0xBE80000000000000
  br i1 %963, label %967, label %964

964:                                              ; preds = %952
  %965 = load float, ptr %74, align 4, !tbaa !9
  %966 = fcmp olt float 0x3E80000000000000, %965
  br i1 %966, label %967, label %978

967:                                              ; preds = %964, %952
  %968 = load ptr, ptr %2, align 8, !tbaa !5
  %969 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %968, i32 0, i32 1
  %970 = load i32, ptr %969, align 4, !tbaa !20
  %971 = add nsw i32 %970, 1
  store i32 %971, ptr %969, align 4, !tbaa !20
  %972 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 358)
  %973 = load float, ptr %73, align 4, !tbaa !9
  %974 = fpext float %973 to double
  %975 = load float, ptr %74, align 4, !tbaa !9
  %976 = fpext float %975 to double
  %977 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.500000e+00, double noundef %974, double noundef %976)
  br label %978

978:                                              ; preds = %967, %964
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #6
  %979 = load ptr, ptr %2, align 8, !tbaa !5
  %980 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %979, i32 0, i32 0
  %981 = load i32, ptr %980, align 4, !tbaa !18
  %982 = add nsw i32 %981, 1
  store i32 %982, ptr %980, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #6
  %983 = getelementptr inbounds [4 x [4 x float]], ptr %43, i64 0, i64 3
  %984 = getelementptr inbounds [4 x float], ptr %983, i64 0, i64 3
  %985 = load float, ptr %984, align 4, !tbaa !13
  store float %985, ptr %75, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #6
  %986 = load float, ptr %75, align 4, !tbaa !9
  %987 = fsub float %986, 8.000000e+00
  store float %987, ptr %76, align 4, !tbaa !9
  %988 = load float, ptr %76, align 4, !tbaa !9
  %989 = fcmp olt float %988, 0xBE80000000000000
  br i1 %989, label %993, label %990

990:                                              ; preds = %978
  %991 = load float, ptr %76, align 4, !tbaa !9
  %992 = fcmp olt float 0x3E80000000000000, %991
  br i1 %992, label %993, label %1004

993:                                              ; preds = %990, %978
  %994 = load ptr, ptr %2, align 8, !tbaa !5
  %995 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %994, i32 0, i32 1
  %996 = load i32, ptr %995, align 4, !tbaa !20
  %997 = add nsw i32 %996, 1
  store i32 %997, ptr %995, align 4, !tbaa !20
  %998 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 359)
  %999 = load float, ptr %75, align 4, !tbaa !9
  %1000 = fpext float %999 to double
  %1001 = load float, ptr %76, align 4, !tbaa !9
  %1002 = fpext float %1001 to double
  %1003 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.000000e+00, double noundef %1000, double noundef %1002)
  br label %1004

1004:                                             ; preds = %993, %990
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %77) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %78, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  %1005 = load float, ptr %4, align 4, !tbaa !9
  call void @_Zdv8HMM_Mat4f(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %77, ptr noundef byval(%union.HMM_Mat4) align 16 %78, float noundef %1005)
  %1006 = load ptr, ptr %2, align 8, !tbaa !5
  %1007 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1006, i32 0, i32 0
  %1008 = load i32, ptr %1007, align 4, !tbaa !18
  %1009 = add nsw i32 %1008, 1
  store i32 %1009, ptr %1007, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #6
  %1010 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 0
  %1011 = getelementptr inbounds [4 x float], ptr %1010, i64 0, i64 0
  %1012 = load float, ptr %1011, align 16, !tbaa !13
  store float %1012, ptr %79, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #6
  %1013 = load float, ptr %79, align 4, !tbaa !9
  %1014 = fsub float %1013, 5.000000e-01
  store float %1014, ptr %80, align 4, !tbaa !9
  %1015 = load float, ptr %80, align 4, !tbaa !9
  %1016 = fcmp olt float %1015, 0xBE80000000000000
  br i1 %1016, label %1020, label %1017

1017:                                             ; preds = %1004
  %1018 = load float, ptr %80, align 4, !tbaa !9
  %1019 = fcmp olt float 0x3E80000000000000, %1018
  br i1 %1019, label %1020, label %1031

1020:                                             ; preds = %1017, %1004
  %1021 = load ptr, ptr %2, align 8, !tbaa !5
  %1022 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1021, i32 0, i32 1
  %1023 = load i32, ptr %1022, align 4, !tbaa !20
  %1024 = add nsw i32 %1023, 1
  store i32 %1024, ptr %1022, align 4, !tbaa !20
  %1025 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 365)
  %1026 = load float, ptr %79, align 4, !tbaa !9
  %1027 = fpext float %1026 to double
  %1028 = load float, ptr %80, align 4, !tbaa !9
  %1029 = fpext float %1028 to double
  %1030 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e-01, double noundef %1027, double noundef %1029)
  br label %1031

1031:                                             ; preds = %1020, %1017
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #6
  %1032 = load ptr, ptr %2, align 8, !tbaa !5
  %1033 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1032, i32 0, i32 0
  %1034 = load i32, ptr %1033, align 4, !tbaa !18
  %1035 = add nsw i32 %1034, 1
  store i32 %1035, ptr %1033, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #6
  %1036 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 0
  %1037 = getelementptr inbounds [4 x float], ptr %1036, i64 0, i64 1
  %1038 = load float, ptr %1037, align 4, !tbaa !13
  store float %1038, ptr %81, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #6
  %1039 = load float, ptr %81, align 4, !tbaa !9
  %1040 = fsub float %1039, 1.000000e+00
  store float %1040, ptr %82, align 4, !tbaa !9
  %1041 = load float, ptr %82, align 4, !tbaa !9
  %1042 = fcmp olt float %1041, 0xBE80000000000000
  br i1 %1042, label %1046, label %1043

1043:                                             ; preds = %1031
  %1044 = load float, ptr %82, align 4, !tbaa !9
  %1045 = fcmp olt float 0x3E80000000000000, %1044
  br i1 %1045, label %1046, label %1057

1046:                                             ; preds = %1043, %1031
  %1047 = load ptr, ptr %2, align 8, !tbaa !5
  %1048 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1047, i32 0, i32 1
  %1049 = load i32, ptr %1048, align 4, !tbaa !20
  %1050 = add nsw i32 %1049, 1
  store i32 %1050, ptr %1048, align 4, !tbaa !20
  %1051 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 366)
  %1052 = load float, ptr %81, align 4, !tbaa !9
  %1053 = fpext float %1052 to double
  %1054 = load float, ptr %82, align 4, !tbaa !9
  %1055 = fpext float %1054 to double
  %1056 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+00, double noundef %1053, double noundef %1055)
  br label %1057

1057:                                             ; preds = %1046, %1043
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #6
  %1058 = load ptr, ptr %2, align 8, !tbaa !5
  %1059 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1058, i32 0, i32 0
  %1060 = load i32, ptr %1059, align 4, !tbaa !18
  %1061 = add nsw i32 %1060, 1
  store i32 %1061, ptr %1059, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #6
  %1062 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 0
  %1063 = getelementptr inbounds [4 x float], ptr %1062, i64 0, i64 2
  %1064 = load float, ptr %1063, align 8, !tbaa !13
  store float %1064, ptr %83, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #6
  %1065 = load float, ptr %83, align 4, !tbaa !9
  %1066 = fsub float %1065, 1.500000e+00
  store float %1066, ptr %84, align 4, !tbaa !9
  %1067 = load float, ptr %84, align 4, !tbaa !9
  %1068 = fcmp olt float %1067, 0xBE80000000000000
  br i1 %1068, label %1072, label %1069

1069:                                             ; preds = %1057
  %1070 = load float, ptr %84, align 4, !tbaa !9
  %1071 = fcmp olt float 0x3E80000000000000, %1070
  br i1 %1071, label %1072, label %1083

1072:                                             ; preds = %1069, %1057
  %1073 = load ptr, ptr %2, align 8, !tbaa !5
  %1074 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1073, i32 0, i32 1
  %1075 = load i32, ptr %1074, align 4, !tbaa !20
  %1076 = add nsw i32 %1075, 1
  store i32 %1076, ptr %1074, align 4, !tbaa !20
  %1077 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 367)
  %1078 = load float, ptr %83, align 4, !tbaa !9
  %1079 = fpext float %1078 to double
  %1080 = load float, ptr %84, align 4, !tbaa !9
  %1081 = fpext float %1080 to double
  %1082 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.500000e+00, double noundef %1079, double noundef %1081)
  br label %1083

1083:                                             ; preds = %1072, %1069
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  %1084 = load ptr, ptr %2, align 8, !tbaa !5
  %1085 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1084, i32 0, i32 0
  %1086 = load i32, ptr %1085, align 4, !tbaa !18
  %1087 = add nsw i32 %1086, 1
  store i32 %1087, ptr %1085, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #6
  %1088 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 0
  %1089 = getelementptr inbounds [4 x float], ptr %1088, i64 0, i64 3
  %1090 = load float, ptr %1089, align 4, !tbaa !13
  store float %1090, ptr %85, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #6
  %1091 = load float, ptr %85, align 4, !tbaa !9
  %1092 = fsub float %1091, 2.000000e+00
  store float %1092, ptr %86, align 4, !tbaa !9
  %1093 = load float, ptr %86, align 4, !tbaa !9
  %1094 = fcmp olt float %1093, 0xBE80000000000000
  br i1 %1094, label %1098, label %1095

1095:                                             ; preds = %1083
  %1096 = load float, ptr %86, align 4, !tbaa !9
  %1097 = fcmp olt float 0x3E80000000000000, %1096
  br i1 %1097, label %1098, label %1109

1098:                                             ; preds = %1095, %1083
  %1099 = load ptr, ptr %2, align 8, !tbaa !5
  %1100 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1099, i32 0, i32 1
  %1101 = load i32, ptr %1100, align 4, !tbaa !20
  %1102 = add nsw i32 %1101, 1
  store i32 %1102, ptr %1100, align 4, !tbaa !20
  %1103 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 368)
  %1104 = load float, ptr %85, align 4, !tbaa !9
  %1105 = fpext float %1104 to double
  %1106 = load float, ptr %86, align 4, !tbaa !9
  %1107 = fpext float %1106 to double
  %1108 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+00, double noundef %1105, double noundef %1107)
  br label %1109

1109:                                             ; preds = %1098, %1095
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #6
  %1110 = load ptr, ptr %2, align 8, !tbaa !5
  %1111 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1110, i32 0, i32 0
  %1112 = load i32, ptr %1111, align 4, !tbaa !18
  %1113 = add nsw i32 %1112, 1
  store i32 %1113, ptr %1111, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #6
  %1114 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 1
  %1115 = getelementptr inbounds [4 x float], ptr %1114, i64 0, i64 0
  %1116 = load float, ptr %1115, align 16, !tbaa !13
  store float %1116, ptr %87, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #6
  %1117 = load float, ptr %87, align 4, !tbaa !9
  %1118 = fsub float %1117, 2.500000e+00
  store float %1118, ptr %88, align 4, !tbaa !9
  %1119 = load float, ptr %88, align 4, !tbaa !9
  %1120 = fcmp olt float %1119, 0xBE80000000000000
  br i1 %1120, label %1124, label %1121

1121:                                             ; preds = %1109
  %1122 = load float, ptr %88, align 4, !tbaa !9
  %1123 = fcmp olt float 0x3E80000000000000, %1122
  br i1 %1123, label %1124, label %1135

1124:                                             ; preds = %1121, %1109
  %1125 = load ptr, ptr %2, align 8, !tbaa !5
  %1126 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1125, i32 0, i32 1
  %1127 = load i32, ptr %1126, align 4, !tbaa !20
  %1128 = add nsw i32 %1127, 1
  store i32 %1128, ptr %1126, align 4, !tbaa !20
  %1129 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 369)
  %1130 = load float, ptr %87, align 4, !tbaa !9
  %1131 = fpext float %1130 to double
  %1132 = load float, ptr %88, align 4, !tbaa !9
  %1133 = fpext float %1132 to double
  %1134 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.500000e+00, double noundef %1131, double noundef %1133)
  br label %1135

1135:                                             ; preds = %1124, %1121
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #6
  %1136 = load ptr, ptr %2, align 8, !tbaa !5
  %1137 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1136, i32 0, i32 0
  %1138 = load i32, ptr %1137, align 4, !tbaa !18
  %1139 = add nsw i32 %1138, 1
  store i32 %1139, ptr %1137, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %89) #6
  %1140 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 1
  %1141 = getelementptr inbounds [4 x float], ptr %1140, i64 0, i64 1
  %1142 = load float, ptr %1141, align 4, !tbaa !13
  store float %1142, ptr %89, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #6
  %1143 = load float, ptr %89, align 4, !tbaa !9
  %1144 = fsub float %1143, 3.000000e+00
  store float %1144, ptr %90, align 4, !tbaa !9
  %1145 = load float, ptr %90, align 4, !tbaa !9
  %1146 = fcmp olt float %1145, 0xBE80000000000000
  br i1 %1146, label %1150, label %1147

1147:                                             ; preds = %1135
  %1148 = load float, ptr %90, align 4, !tbaa !9
  %1149 = fcmp olt float 0x3E80000000000000, %1148
  br i1 %1149, label %1150, label %1161

1150:                                             ; preds = %1147, %1135
  %1151 = load ptr, ptr %2, align 8, !tbaa !5
  %1152 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1151, i32 0, i32 1
  %1153 = load i32, ptr %1152, align 4, !tbaa !20
  %1154 = add nsw i32 %1153, 1
  store i32 %1154, ptr %1152, align 4, !tbaa !20
  %1155 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 370)
  %1156 = load float, ptr %89, align 4, !tbaa !9
  %1157 = fpext float %1156 to double
  %1158 = load float, ptr %90, align 4, !tbaa !9
  %1159 = fpext float %1158 to double
  %1160 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+00, double noundef %1157, double noundef %1159)
  br label %1161

1161:                                             ; preds = %1150, %1147
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %89) #6
  %1162 = load ptr, ptr %2, align 8, !tbaa !5
  %1163 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1162, i32 0, i32 0
  %1164 = load i32, ptr %1163, align 4, !tbaa !18
  %1165 = add nsw i32 %1164, 1
  store i32 %1165, ptr %1163, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #6
  %1166 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 1
  %1167 = getelementptr inbounds [4 x float], ptr %1166, i64 0, i64 2
  %1168 = load float, ptr %1167, align 8, !tbaa !13
  store float %1168, ptr %91, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #6
  %1169 = load float, ptr %91, align 4, !tbaa !9
  %1170 = fsub float %1169, 3.500000e+00
  store float %1170, ptr %92, align 4, !tbaa !9
  %1171 = load float, ptr %92, align 4, !tbaa !9
  %1172 = fcmp olt float %1171, 0xBE80000000000000
  br i1 %1172, label %1176, label %1173

1173:                                             ; preds = %1161
  %1174 = load float, ptr %92, align 4, !tbaa !9
  %1175 = fcmp olt float 0x3E80000000000000, %1174
  br i1 %1175, label %1176, label %1187

1176:                                             ; preds = %1173, %1161
  %1177 = load ptr, ptr %2, align 8, !tbaa !5
  %1178 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1177, i32 0, i32 1
  %1179 = load i32, ptr %1178, align 4, !tbaa !20
  %1180 = add nsw i32 %1179, 1
  store i32 %1180, ptr %1178, align 4, !tbaa !20
  %1181 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 371)
  %1182 = load float, ptr %91, align 4, !tbaa !9
  %1183 = fpext float %1182 to double
  %1184 = load float, ptr %92, align 4, !tbaa !9
  %1185 = fpext float %1184 to double
  %1186 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.500000e+00, double noundef %1183, double noundef %1185)
  br label %1187

1187:                                             ; preds = %1176, %1173
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #6
  %1188 = load ptr, ptr %2, align 8, !tbaa !5
  %1189 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1188, i32 0, i32 0
  %1190 = load i32, ptr %1189, align 4, !tbaa !18
  %1191 = add nsw i32 %1190, 1
  store i32 %1191, ptr %1189, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #6
  %1192 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 1
  %1193 = getelementptr inbounds [4 x float], ptr %1192, i64 0, i64 3
  %1194 = load float, ptr %1193, align 4, !tbaa !13
  store float %1194, ptr %93, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #6
  %1195 = load float, ptr %93, align 4, !tbaa !9
  %1196 = fsub float %1195, 4.000000e+00
  store float %1196, ptr %94, align 4, !tbaa !9
  %1197 = load float, ptr %94, align 4, !tbaa !9
  %1198 = fcmp olt float %1197, 0xBE80000000000000
  br i1 %1198, label %1202, label %1199

1199:                                             ; preds = %1187
  %1200 = load float, ptr %94, align 4, !tbaa !9
  %1201 = fcmp olt float 0x3E80000000000000, %1200
  br i1 %1201, label %1202, label %1213

1202:                                             ; preds = %1199, %1187
  %1203 = load ptr, ptr %2, align 8, !tbaa !5
  %1204 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1203, i32 0, i32 1
  %1205 = load i32, ptr %1204, align 4, !tbaa !20
  %1206 = add nsw i32 %1205, 1
  store i32 %1206, ptr %1204, align 4, !tbaa !20
  %1207 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 372)
  %1208 = load float, ptr %93, align 4, !tbaa !9
  %1209 = fpext float %1208 to double
  %1210 = load float, ptr %94, align 4, !tbaa !9
  %1211 = fpext float %1210 to double
  %1212 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+00, double noundef %1209, double noundef %1211)
  br label %1213

1213:                                             ; preds = %1202, %1199
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #6
  %1214 = load ptr, ptr %2, align 8, !tbaa !5
  %1215 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1214, i32 0, i32 0
  %1216 = load i32, ptr %1215, align 4, !tbaa !18
  %1217 = add nsw i32 %1216, 1
  store i32 %1217, ptr %1215, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #6
  %1218 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 2
  %1219 = getelementptr inbounds [4 x float], ptr %1218, i64 0, i64 0
  %1220 = load float, ptr %1219, align 16, !tbaa !13
  store float %1220, ptr %95, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #6
  %1221 = load float, ptr %95, align 4, !tbaa !9
  %1222 = fsub float %1221, 4.500000e+00
  store float %1222, ptr %96, align 4, !tbaa !9
  %1223 = load float, ptr %96, align 4, !tbaa !9
  %1224 = fcmp olt float %1223, 0xBE80000000000000
  br i1 %1224, label %1228, label %1225

1225:                                             ; preds = %1213
  %1226 = load float, ptr %96, align 4, !tbaa !9
  %1227 = fcmp olt float 0x3E80000000000000, %1226
  br i1 %1227, label %1228, label %1239

1228:                                             ; preds = %1225, %1213
  %1229 = load ptr, ptr %2, align 8, !tbaa !5
  %1230 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1229, i32 0, i32 1
  %1231 = load i32, ptr %1230, align 4, !tbaa !20
  %1232 = add nsw i32 %1231, 1
  store i32 %1232, ptr %1230, align 4, !tbaa !20
  %1233 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 373)
  %1234 = load float, ptr %95, align 4, !tbaa !9
  %1235 = fpext float %1234 to double
  %1236 = load float, ptr %96, align 4, !tbaa !9
  %1237 = fpext float %1236 to double
  %1238 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.500000e+00, double noundef %1235, double noundef %1237)
  br label %1239

1239:                                             ; preds = %1228, %1225
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #6
  %1240 = load ptr, ptr %2, align 8, !tbaa !5
  %1241 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1240, i32 0, i32 0
  %1242 = load i32, ptr %1241, align 4, !tbaa !18
  %1243 = add nsw i32 %1242, 1
  store i32 %1243, ptr %1241, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #6
  %1244 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 2
  %1245 = getelementptr inbounds [4 x float], ptr %1244, i64 0, i64 1
  %1246 = load float, ptr %1245, align 4, !tbaa !13
  store float %1246, ptr %97, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #6
  %1247 = load float, ptr %97, align 4, !tbaa !9
  %1248 = fsub float %1247, 5.000000e+00
  store float %1248, ptr %98, align 4, !tbaa !9
  %1249 = load float, ptr %98, align 4, !tbaa !9
  %1250 = fcmp olt float %1249, 0xBE80000000000000
  br i1 %1250, label %1254, label %1251

1251:                                             ; preds = %1239
  %1252 = load float, ptr %98, align 4, !tbaa !9
  %1253 = fcmp olt float 0x3E80000000000000, %1252
  br i1 %1253, label %1254, label %1265

1254:                                             ; preds = %1251, %1239
  %1255 = load ptr, ptr %2, align 8, !tbaa !5
  %1256 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1255, i32 0, i32 1
  %1257 = load i32, ptr %1256, align 4, !tbaa !20
  %1258 = add nsw i32 %1257, 1
  store i32 %1258, ptr %1256, align 4, !tbaa !20
  %1259 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 374)
  %1260 = load float, ptr %97, align 4, !tbaa !9
  %1261 = fpext float %1260 to double
  %1262 = load float, ptr %98, align 4, !tbaa !9
  %1263 = fpext float %1262 to double
  %1264 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e+00, double noundef %1261, double noundef %1263)
  br label %1265

1265:                                             ; preds = %1254, %1251
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #6
  %1266 = load ptr, ptr %2, align 8, !tbaa !5
  %1267 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1266, i32 0, i32 0
  %1268 = load i32, ptr %1267, align 4, !tbaa !18
  %1269 = add nsw i32 %1268, 1
  store i32 %1269, ptr %1267, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #6
  %1270 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 2
  %1271 = getelementptr inbounds [4 x float], ptr %1270, i64 0, i64 2
  %1272 = load float, ptr %1271, align 8, !tbaa !13
  store float %1272, ptr %99, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #6
  %1273 = load float, ptr %99, align 4, !tbaa !9
  %1274 = fsub float %1273, 5.500000e+00
  store float %1274, ptr %100, align 4, !tbaa !9
  %1275 = load float, ptr %100, align 4, !tbaa !9
  %1276 = fcmp olt float %1275, 0xBE80000000000000
  br i1 %1276, label %1280, label %1277

1277:                                             ; preds = %1265
  %1278 = load float, ptr %100, align 4, !tbaa !9
  %1279 = fcmp olt float 0x3E80000000000000, %1278
  br i1 %1279, label %1280, label %1291

1280:                                             ; preds = %1277, %1265
  %1281 = load ptr, ptr %2, align 8, !tbaa !5
  %1282 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1281, i32 0, i32 1
  %1283 = load i32, ptr %1282, align 4, !tbaa !20
  %1284 = add nsw i32 %1283, 1
  store i32 %1284, ptr %1282, align 4, !tbaa !20
  %1285 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 375)
  %1286 = load float, ptr %99, align 4, !tbaa !9
  %1287 = fpext float %1286 to double
  %1288 = load float, ptr %100, align 4, !tbaa !9
  %1289 = fpext float %1288 to double
  %1290 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.500000e+00, double noundef %1287, double noundef %1289)
  br label %1291

1291:                                             ; preds = %1280, %1277
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #6
  %1292 = load ptr, ptr %2, align 8, !tbaa !5
  %1293 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1292, i32 0, i32 0
  %1294 = load i32, ptr %1293, align 4, !tbaa !18
  %1295 = add nsw i32 %1294, 1
  store i32 %1295, ptr %1293, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %101) #6
  %1296 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 2
  %1297 = getelementptr inbounds [4 x float], ptr %1296, i64 0, i64 3
  %1298 = load float, ptr %1297, align 4, !tbaa !13
  store float %1298, ptr %101, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #6
  %1299 = load float, ptr %101, align 4, !tbaa !9
  %1300 = fsub float %1299, 6.000000e+00
  store float %1300, ptr %102, align 4, !tbaa !9
  %1301 = load float, ptr %102, align 4, !tbaa !9
  %1302 = fcmp olt float %1301, 0xBE80000000000000
  br i1 %1302, label %1306, label %1303

1303:                                             ; preds = %1291
  %1304 = load float, ptr %102, align 4, !tbaa !9
  %1305 = fcmp olt float 0x3E80000000000000, %1304
  br i1 %1305, label %1306, label %1317

1306:                                             ; preds = %1303, %1291
  %1307 = load ptr, ptr %2, align 8, !tbaa !5
  %1308 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1307, i32 0, i32 1
  %1309 = load i32, ptr %1308, align 4, !tbaa !20
  %1310 = add nsw i32 %1309, 1
  store i32 %1310, ptr %1308, align 4, !tbaa !20
  %1311 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 376)
  %1312 = load float, ptr %101, align 4, !tbaa !9
  %1313 = fpext float %1312 to double
  %1314 = load float, ptr %102, align 4, !tbaa !9
  %1315 = fpext float %1314 to double
  %1316 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.000000e+00, double noundef %1313, double noundef %1315)
  br label %1317

1317:                                             ; preds = %1306, %1303
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %101) #6
  %1318 = load ptr, ptr %2, align 8, !tbaa !5
  %1319 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1318, i32 0, i32 0
  %1320 = load i32, ptr %1319, align 4, !tbaa !18
  %1321 = add nsw i32 %1320, 1
  store i32 %1321, ptr %1319, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #6
  %1322 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 3
  %1323 = getelementptr inbounds [4 x float], ptr %1322, i64 0, i64 0
  %1324 = load float, ptr %1323, align 16, !tbaa !13
  store float %1324, ptr %103, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #6
  %1325 = load float, ptr %103, align 4, !tbaa !9
  %1326 = fsub float %1325, 6.500000e+00
  store float %1326, ptr %104, align 4, !tbaa !9
  %1327 = load float, ptr %104, align 4, !tbaa !9
  %1328 = fcmp olt float %1327, 0xBE80000000000000
  br i1 %1328, label %1332, label %1329

1329:                                             ; preds = %1317
  %1330 = load float, ptr %104, align 4, !tbaa !9
  %1331 = fcmp olt float 0x3E80000000000000, %1330
  br i1 %1331, label %1332, label %1343

1332:                                             ; preds = %1329, %1317
  %1333 = load ptr, ptr %2, align 8, !tbaa !5
  %1334 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1333, i32 0, i32 1
  %1335 = load i32, ptr %1334, align 4, !tbaa !20
  %1336 = add nsw i32 %1335, 1
  store i32 %1336, ptr %1334, align 4, !tbaa !20
  %1337 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 377)
  %1338 = load float, ptr %103, align 4, !tbaa !9
  %1339 = fpext float %1338 to double
  %1340 = load float, ptr %104, align 4, !tbaa !9
  %1341 = fpext float %1340 to double
  %1342 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+00, double noundef %1339, double noundef %1341)
  br label %1343

1343:                                             ; preds = %1332, %1329
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #6
  %1344 = load ptr, ptr %2, align 8, !tbaa !5
  %1345 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1344, i32 0, i32 0
  %1346 = load i32, ptr %1345, align 4, !tbaa !18
  %1347 = add nsw i32 %1346, 1
  store i32 %1347, ptr %1345, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #6
  %1348 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 3
  %1349 = getelementptr inbounds [4 x float], ptr %1348, i64 0, i64 1
  %1350 = load float, ptr %1349, align 4, !tbaa !13
  store float %1350, ptr %105, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #6
  %1351 = load float, ptr %105, align 4, !tbaa !9
  %1352 = fsub float %1351, 7.000000e+00
  store float %1352, ptr %106, align 4, !tbaa !9
  %1353 = load float, ptr %106, align 4, !tbaa !9
  %1354 = fcmp olt float %1353, 0xBE80000000000000
  br i1 %1354, label %1358, label %1355

1355:                                             ; preds = %1343
  %1356 = load float, ptr %106, align 4, !tbaa !9
  %1357 = fcmp olt float 0x3E80000000000000, %1356
  br i1 %1357, label %1358, label %1369

1358:                                             ; preds = %1355, %1343
  %1359 = load ptr, ptr %2, align 8, !tbaa !5
  %1360 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1359, i32 0, i32 1
  %1361 = load i32, ptr %1360, align 4, !tbaa !20
  %1362 = add nsw i32 %1361, 1
  store i32 %1362, ptr %1360, align 4, !tbaa !20
  %1363 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 378)
  %1364 = load float, ptr %105, align 4, !tbaa !9
  %1365 = fpext float %1364 to double
  %1366 = load float, ptr %106, align 4, !tbaa !9
  %1367 = fpext float %1366 to double
  %1368 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.000000e+00, double noundef %1365, double noundef %1367)
  br label %1369

1369:                                             ; preds = %1358, %1355
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #6
  %1370 = load ptr, ptr %2, align 8, !tbaa !5
  %1371 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1370, i32 0, i32 0
  %1372 = load i32, ptr %1371, align 4, !tbaa !18
  %1373 = add nsw i32 %1372, 1
  store i32 %1373, ptr %1371, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #6
  %1374 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 3
  %1375 = getelementptr inbounds [4 x float], ptr %1374, i64 0, i64 2
  %1376 = load float, ptr %1375, align 8, !tbaa !13
  store float %1376, ptr %107, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %108) #6
  %1377 = load float, ptr %107, align 4, !tbaa !9
  %1378 = fsub float %1377, 7.500000e+00
  store float %1378, ptr %108, align 4, !tbaa !9
  %1379 = load float, ptr %108, align 4, !tbaa !9
  %1380 = fcmp olt float %1379, 0xBE80000000000000
  br i1 %1380, label %1384, label %1381

1381:                                             ; preds = %1369
  %1382 = load float, ptr %108, align 4, !tbaa !9
  %1383 = fcmp olt float 0x3E80000000000000, %1382
  br i1 %1383, label %1384, label %1395

1384:                                             ; preds = %1381, %1369
  %1385 = load ptr, ptr %2, align 8, !tbaa !5
  %1386 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1385, i32 0, i32 1
  %1387 = load i32, ptr %1386, align 4, !tbaa !20
  %1388 = add nsw i32 %1387, 1
  store i32 %1388, ptr %1386, align 4, !tbaa !20
  %1389 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 379)
  %1390 = load float, ptr %107, align 4, !tbaa !9
  %1391 = fpext float %1390 to double
  %1392 = load float, ptr %108, align 4, !tbaa !9
  %1393 = fpext float %1392 to double
  %1394 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.500000e+00, double noundef %1391, double noundef %1393)
  br label %1395

1395:                                             ; preds = %1384, %1381
  call void @llvm.lifetime.end.p0(i64 4, ptr %108) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #6
  %1396 = load ptr, ptr %2, align 8, !tbaa !5
  %1397 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1396, i32 0, i32 0
  %1398 = load i32, ptr %1397, align 4, !tbaa !18
  %1399 = add nsw i32 %1398, 1
  store i32 %1399, ptr %1397, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #6
  %1400 = getelementptr inbounds [4 x [4 x float]], ptr %77, i64 0, i64 3
  %1401 = getelementptr inbounds [4 x float], ptr %1400, i64 0, i64 3
  %1402 = load float, ptr %1401, align 4, !tbaa !13
  store float %1402, ptr %109, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %110) #6
  %1403 = load float, ptr %109, align 4, !tbaa !9
  %1404 = fsub float %1403, 8.000000e+00
  store float %1404, ptr %110, align 4, !tbaa !9
  %1405 = load float, ptr %110, align 4, !tbaa !9
  %1406 = fcmp olt float %1405, 0xBE80000000000000
  br i1 %1406, label %1410, label %1407

1407:                                             ; preds = %1395
  %1408 = load float, ptr %110, align 4, !tbaa !9
  %1409 = fcmp olt float 0x3E80000000000000, %1408
  br i1 %1409, label %1410, label %1421

1410:                                             ; preds = %1407, %1395
  %1411 = load ptr, ptr %2, align 8, !tbaa !5
  %1412 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1411, i32 0, i32 1
  %1413 = load i32, ptr %1412, align 4, !tbaa !20
  %1414 = add nsw i32 %1413, 1
  store i32 %1414, ptr %1412, align 4, !tbaa !20
  %1415 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 380)
  %1416 = load float, ptr %109, align 4, !tbaa !9
  %1417 = fpext float %1416 to double
  %1418 = load float, ptr %110, align 4, !tbaa !9
  %1419 = fpext float %1418 to double
  %1420 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.000000e+00, double noundef %1417, double noundef %1419)
  br label %1421

1421:                                             ; preds = %1410, %1407
  call void @llvm.lifetime.end.p0(i64 4, ptr %110) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %77) #6
  %1422 = load float, ptr %4, align 4, !tbaa !9
  %1423 = call noundef nonnull align 16 dereferenceable(64) ptr @_ZdVR8HMM_Mat4f(ptr noundef nonnull align 16 dereferenceable(64) %3, float noundef %1422)
  %1424 = load ptr, ptr %2, align 8, !tbaa !5
  %1425 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1424, i32 0, i32 0
  %1426 = load i32, ptr %1425, align 4, !tbaa !18
  %1427 = add nsw i32 %1426, 1
  store i32 %1427, ptr %1425, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %111) #6
  %1428 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 0
  %1429 = getelementptr inbounds [4 x float], ptr %1428, i64 0, i64 0
  %1430 = load float, ptr %1429, align 16, !tbaa !13
  store float %1430, ptr %111, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #6
  %1431 = load float, ptr %111, align 4, !tbaa !9
  %1432 = fsub float %1431, 5.000000e-01
  store float %1432, ptr %112, align 4, !tbaa !9
  %1433 = load float, ptr %112, align 4, !tbaa !9
  %1434 = fcmp olt float %1433, 0xBE80000000000000
  br i1 %1434, label %1438, label %1435

1435:                                             ; preds = %1421
  %1436 = load float, ptr %112, align 4, !tbaa !9
  %1437 = fcmp olt float 0x3E80000000000000, %1436
  br i1 %1437, label %1438, label %1449

1438:                                             ; preds = %1435, %1421
  %1439 = load ptr, ptr %2, align 8, !tbaa !5
  %1440 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1439, i32 0, i32 1
  %1441 = load i32, ptr %1440, align 4, !tbaa !20
  %1442 = add nsw i32 %1441, 1
  store i32 %1442, ptr %1440, align 4, !tbaa !20
  %1443 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 384)
  %1444 = load float, ptr %111, align 4, !tbaa !9
  %1445 = fpext float %1444 to double
  %1446 = load float, ptr %112, align 4, !tbaa !9
  %1447 = fpext float %1446 to double
  %1448 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e-01, double noundef %1445, double noundef %1447)
  br label %1449

1449:                                             ; preds = %1438, %1435
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %111) #6
  %1450 = load ptr, ptr %2, align 8, !tbaa !5
  %1451 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1450, i32 0, i32 0
  %1452 = load i32, ptr %1451, align 4, !tbaa !18
  %1453 = add nsw i32 %1452, 1
  store i32 %1453, ptr %1451, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %113) #6
  %1454 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 0
  %1455 = getelementptr inbounds [4 x float], ptr %1454, i64 0, i64 1
  %1456 = load float, ptr %1455, align 4, !tbaa !13
  store float %1456, ptr %113, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %114) #6
  %1457 = load float, ptr %113, align 4, !tbaa !9
  %1458 = fsub float %1457, 1.000000e+00
  store float %1458, ptr %114, align 4, !tbaa !9
  %1459 = load float, ptr %114, align 4, !tbaa !9
  %1460 = fcmp olt float %1459, 0xBE80000000000000
  br i1 %1460, label %1464, label %1461

1461:                                             ; preds = %1449
  %1462 = load float, ptr %114, align 4, !tbaa !9
  %1463 = fcmp olt float 0x3E80000000000000, %1462
  br i1 %1463, label %1464, label %1475

1464:                                             ; preds = %1461, %1449
  %1465 = load ptr, ptr %2, align 8, !tbaa !5
  %1466 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1465, i32 0, i32 1
  %1467 = load i32, ptr %1466, align 4, !tbaa !20
  %1468 = add nsw i32 %1467, 1
  store i32 %1468, ptr %1466, align 4, !tbaa !20
  %1469 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 385)
  %1470 = load float, ptr %113, align 4, !tbaa !9
  %1471 = fpext float %1470 to double
  %1472 = load float, ptr %114, align 4, !tbaa !9
  %1473 = fpext float %1472 to double
  %1474 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+00, double noundef %1471, double noundef %1473)
  br label %1475

1475:                                             ; preds = %1464, %1461
  call void @llvm.lifetime.end.p0(i64 4, ptr %114) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %113) #6
  %1476 = load ptr, ptr %2, align 8, !tbaa !5
  %1477 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1476, i32 0, i32 0
  %1478 = load i32, ptr %1477, align 4, !tbaa !18
  %1479 = add nsw i32 %1478, 1
  store i32 %1479, ptr %1477, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %115) #6
  %1480 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 0
  %1481 = getelementptr inbounds [4 x float], ptr %1480, i64 0, i64 2
  %1482 = load float, ptr %1481, align 8, !tbaa !13
  store float %1482, ptr %115, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %116) #6
  %1483 = load float, ptr %115, align 4, !tbaa !9
  %1484 = fsub float %1483, 1.500000e+00
  store float %1484, ptr %116, align 4, !tbaa !9
  %1485 = load float, ptr %116, align 4, !tbaa !9
  %1486 = fcmp olt float %1485, 0xBE80000000000000
  br i1 %1486, label %1490, label %1487

1487:                                             ; preds = %1475
  %1488 = load float, ptr %116, align 4, !tbaa !9
  %1489 = fcmp olt float 0x3E80000000000000, %1488
  br i1 %1489, label %1490, label %1501

1490:                                             ; preds = %1487, %1475
  %1491 = load ptr, ptr %2, align 8, !tbaa !5
  %1492 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1491, i32 0, i32 1
  %1493 = load i32, ptr %1492, align 4, !tbaa !20
  %1494 = add nsw i32 %1493, 1
  store i32 %1494, ptr %1492, align 4, !tbaa !20
  %1495 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 386)
  %1496 = load float, ptr %115, align 4, !tbaa !9
  %1497 = fpext float %1496 to double
  %1498 = load float, ptr %116, align 4, !tbaa !9
  %1499 = fpext float %1498 to double
  %1500 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.500000e+00, double noundef %1497, double noundef %1499)
  br label %1501

1501:                                             ; preds = %1490, %1487
  call void @llvm.lifetime.end.p0(i64 4, ptr %116) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %115) #6
  %1502 = load ptr, ptr %2, align 8, !tbaa !5
  %1503 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1502, i32 0, i32 0
  %1504 = load i32, ptr %1503, align 4, !tbaa !18
  %1505 = add nsw i32 %1504, 1
  store i32 %1505, ptr %1503, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %117) #6
  %1506 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 0
  %1507 = getelementptr inbounds [4 x float], ptr %1506, i64 0, i64 3
  %1508 = load float, ptr %1507, align 4, !tbaa !13
  store float %1508, ptr %117, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %118) #6
  %1509 = load float, ptr %117, align 4, !tbaa !9
  %1510 = fsub float %1509, 2.000000e+00
  store float %1510, ptr %118, align 4, !tbaa !9
  %1511 = load float, ptr %118, align 4, !tbaa !9
  %1512 = fcmp olt float %1511, 0xBE80000000000000
  br i1 %1512, label %1516, label %1513

1513:                                             ; preds = %1501
  %1514 = load float, ptr %118, align 4, !tbaa !9
  %1515 = fcmp olt float 0x3E80000000000000, %1514
  br i1 %1515, label %1516, label %1527

1516:                                             ; preds = %1513, %1501
  %1517 = load ptr, ptr %2, align 8, !tbaa !5
  %1518 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1517, i32 0, i32 1
  %1519 = load i32, ptr %1518, align 4, !tbaa !20
  %1520 = add nsw i32 %1519, 1
  store i32 %1520, ptr %1518, align 4, !tbaa !20
  %1521 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 387)
  %1522 = load float, ptr %117, align 4, !tbaa !9
  %1523 = fpext float %1522 to double
  %1524 = load float, ptr %118, align 4, !tbaa !9
  %1525 = fpext float %1524 to double
  %1526 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+00, double noundef %1523, double noundef %1525)
  br label %1527

1527:                                             ; preds = %1516, %1513
  call void @llvm.lifetime.end.p0(i64 4, ptr %118) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %117) #6
  %1528 = load ptr, ptr %2, align 8, !tbaa !5
  %1529 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1528, i32 0, i32 0
  %1530 = load i32, ptr %1529, align 4, !tbaa !18
  %1531 = add nsw i32 %1530, 1
  store i32 %1531, ptr %1529, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %119) #6
  %1532 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 1
  %1533 = getelementptr inbounds [4 x float], ptr %1532, i64 0, i64 0
  %1534 = load float, ptr %1533, align 16, !tbaa !13
  store float %1534, ptr %119, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %120) #6
  %1535 = load float, ptr %119, align 4, !tbaa !9
  %1536 = fsub float %1535, 2.500000e+00
  store float %1536, ptr %120, align 4, !tbaa !9
  %1537 = load float, ptr %120, align 4, !tbaa !9
  %1538 = fcmp olt float %1537, 0xBE80000000000000
  br i1 %1538, label %1542, label %1539

1539:                                             ; preds = %1527
  %1540 = load float, ptr %120, align 4, !tbaa !9
  %1541 = fcmp olt float 0x3E80000000000000, %1540
  br i1 %1541, label %1542, label %1553

1542:                                             ; preds = %1539, %1527
  %1543 = load ptr, ptr %2, align 8, !tbaa !5
  %1544 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1543, i32 0, i32 1
  %1545 = load i32, ptr %1544, align 4, !tbaa !20
  %1546 = add nsw i32 %1545, 1
  store i32 %1546, ptr %1544, align 4, !tbaa !20
  %1547 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 388)
  %1548 = load float, ptr %119, align 4, !tbaa !9
  %1549 = fpext float %1548 to double
  %1550 = load float, ptr %120, align 4, !tbaa !9
  %1551 = fpext float %1550 to double
  %1552 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.500000e+00, double noundef %1549, double noundef %1551)
  br label %1553

1553:                                             ; preds = %1542, %1539
  call void @llvm.lifetime.end.p0(i64 4, ptr %120) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %119) #6
  %1554 = load ptr, ptr %2, align 8, !tbaa !5
  %1555 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1554, i32 0, i32 0
  %1556 = load i32, ptr %1555, align 4, !tbaa !18
  %1557 = add nsw i32 %1556, 1
  store i32 %1557, ptr %1555, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %121) #6
  %1558 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 1
  %1559 = getelementptr inbounds [4 x float], ptr %1558, i64 0, i64 1
  %1560 = load float, ptr %1559, align 4, !tbaa !13
  store float %1560, ptr %121, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %122) #6
  %1561 = load float, ptr %121, align 4, !tbaa !9
  %1562 = fsub float %1561, 3.000000e+00
  store float %1562, ptr %122, align 4, !tbaa !9
  %1563 = load float, ptr %122, align 4, !tbaa !9
  %1564 = fcmp olt float %1563, 0xBE80000000000000
  br i1 %1564, label %1568, label %1565

1565:                                             ; preds = %1553
  %1566 = load float, ptr %122, align 4, !tbaa !9
  %1567 = fcmp olt float 0x3E80000000000000, %1566
  br i1 %1567, label %1568, label %1579

1568:                                             ; preds = %1565, %1553
  %1569 = load ptr, ptr %2, align 8, !tbaa !5
  %1570 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1569, i32 0, i32 1
  %1571 = load i32, ptr %1570, align 4, !tbaa !20
  %1572 = add nsw i32 %1571, 1
  store i32 %1572, ptr %1570, align 4, !tbaa !20
  %1573 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 389)
  %1574 = load float, ptr %121, align 4, !tbaa !9
  %1575 = fpext float %1574 to double
  %1576 = load float, ptr %122, align 4, !tbaa !9
  %1577 = fpext float %1576 to double
  %1578 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+00, double noundef %1575, double noundef %1577)
  br label %1579

1579:                                             ; preds = %1568, %1565
  call void @llvm.lifetime.end.p0(i64 4, ptr %122) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %121) #6
  %1580 = load ptr, ptr %2, align 8, !tbaa !5
  %1581 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1580, i32 0, i32 0
  %1582 = load i32, ptr %1581, align 4, !tbaa !18
  %1583 = add nsw i32 %1582, 1
  store i32 %1583, ptr %1581, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %123) #6
  %1584 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 1
  %1585 = getelementptr inbounds [4 x float], ptr %1584, i64 0, i64 2
  %1586 = load float, ptr %1585, align 8, !tbaa !13
  store float %1586, ptr %123, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %124) #6
  %1587 = load float, ptr %123, align 4, !tbaa !9
  %1588 = fsub float %1587, 3.500000e+00
  store float %1588, ptr %124, align 4, !tbaa !9
  %1589 = load float, ptr %124, align 4, !tbaa !9
  %1590 = fcmp olt float %1589, 0xBE80000000000000
  br i1 %1590, label %1594, label %1591

1591:                                             ; preds = %1579
  %1592 = load float, ptr %124, align 4, !tbaa !9
  %1593 = fcmp olt float 0x3E80000000000000, %1592
  br i1 %1593, label %1594, label %1605

1594:                                             ; preds = %1591, %1579
  %1595 = load ptr, ptr %2, align 8, !tbaa !5
  %1596 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1595, i32 0, i32 1
  %1597 = load i32, ptr %1596, align 4, !tbaa !20
  %1598 = add nsw i32 %1597, 1
  store i32 %1598, ptr %1596, align 4, !tbaa !20
  %1599 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 390)
  %1600 = load float, ptr %123, align 4, !tbaa !9
  %1601 = fpext float %1600 to double
  %1602 = load float, ptr %124, align 4, !tbaa !9
  %1603 = fpext float %1602 to double
  %1604 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.500000e+00, double noundef %1601, double noundef %1603)
  br label %1605

1605:                                             ; preds = %1594, %1591
  call void @llvm.lifetime.end.p0(i64 4, ptr %124) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %123) #6
  %1606 = load ptr, ptr %2, align 8, !tbaa !5
  %1607 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1606, i32 0, i32 0
  %1608 = load i32, ptr %1607, align 4, !tbaa !18
  %1609 = add nsw i32 %1608, 1
  store i32 %1609, ptr %1607, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %125) #6
  %1610 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 1
  %1611 = getelementptr inbounds [4 x float], ptr %1610, i64 0, i64 3
  %1612 = load float, ptr %1611, align 4, !tbaa !13
  store float %1612, ptr %125, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %126) #6
  %1613 = load float, ptr %125, align 4, !tbaa !9
  %1614 = fsub float %1613, 4.000000e+00
  store float %1614, ptr %126, align 4, !tbaa !9
  %1615 = load float, ptr %126, align 4, !tbaa !9
  %1616 = fcmp olt float %1615, 0xBE80000000000000
  br i1 %1616, label %1620, label %1617

1617:                                             ; preds = %1605
  %1618 = load float, ptr %126, align 4, !tbaa !9
  %1619 = fcmp olt float 0x3E80000000000000, %1618
  br i1 %1619, label %1620, label %1631

1620:                                             ; preds = %1617, %1605
  %1621 = load ptr, ptr %2, align 8, !tbaa !5
  %1622 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1621, i32 0, i32 1
  %1623 = load i32, ptr %1622, align 4, !tbaa !20
  %1624 = add nsw i32 %1623, 1
  store i32 %1624, ptr %1622, align 4, !tbaa !20
  %1625 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 391)
  %1626 = load float, ptr %125, align 4, !tbaa !9
  %1627 = fpext float %1626 to double
  %1628 = load float, ptr %126, align 4, !tbaa !9
  %1629 = fpext float %1628 to double
  %1630 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+00, double noundef %1627, double noundef %1629)
  br label %1631

1631:                                             ; preds = %1620, %1617
  call void @llvm.lifetime.end.p0(i64 4, ptr %126) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %125) #6
  %1632 = load ptr, ptr %2, align 8, !tbaa !5
  %1633 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1632, i32 0, i32 0
  %1634 = load i32, ptr %1633, align 4, !tbaa !18
  %1635 = add nsw i32 %1634, 1
  store i32 %1635, ptr %1633, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %127) #6
  %1636 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 2
  %1637 = getelementptr inbounds [4 x float], ptr %1636, i64 0, i64 0
  %1638 = load float, ptr %1637, align 16, !tbaa !13
  store float %1638, ptr %127, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %128) #6
  %1639 = load float, ptr %127, align 4, !tbaa !9
  %1640 = fsub float %1639, 4.500000e+00
  store float %1640, ptr %128, align 4, !tbaa !9
  %1641 = load float, ptr %128, align 4, !tbaa !9
  %1642 = fcmp olt float %1641, 0xBE80000000000000
  br i1 %1642, label %1646, label %1643

1643:                                             ; preds = %1631
  %1644 = load float, ptr %128, align 4, !tbaa !9
  %1645 = fcmp olt float 0x3E80000000000000, %1644
  br i1 %1645, label %1646, label %1657

1646:                                             ; preds = %1643, %1631
  %1647 = load ptr, ptr %2, align 8, !tbaa !5
  %1648 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1647, i32 0, i32 1
  %1649 = load i32, ptr %1648, align 4, !tbaa !20
  %1650 = add nsw i32 %1649, 1
  store i32 %1650, ptr %1648, align 4, !tbaa !20
  %1651 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 392)
  %1652 = load float, ptr %127, align 4, !tbaa !9
  %1653 = fpext float %1652 to double
  %1654 = load float, ptr %128, align 4, !tbaa !9
  %1655 = fpext float %1654 to double
  %1656 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.500000e+00, double noundef %1653, double noundef %1655)
  br label %1657

1657:                                             ; preds = %1646, %1643
  call void @llvm.lifetime.end.p0(i64 4, ptr %128) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %127) #6
  %1658 = load ptr, ptr %2, align 8, !tbaa !5
  %1659 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1658, i32 0, i32 0
  %1660 = load i32, ptr %1659, align 4, !tbaa !18
  %1661 = add nsw i32 %1660, 1
  store i32 %1661, ptr %1659, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %129) #6
  %1662 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 2
  %1663 = getelementptr inbounds [4 x float], ptr %1662, i64 0, i64 1
  %1664 = load float, ptr %1663, align 4, !tbaa !13
  store float %1664, ptr %129, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %130) #6
  %1665 = load float, ptr %129, align 4, !tbaa !9
  %1666 = fsub float %1665, 5.000000e+00
  store float %1666, ptr %130, align 4, !tbaa !9
  %1667 = load float, ptr %130, align 4, !tbaa !9
  %1668 = fcmp olt float %1667, 0xBE80000000000000
  br i1 %1668, label %1672, label %1669

1669:                                             ; preds = %1657
  %1670 = load float, ptr %130, align 4, !tbaa !9
  %1671 = fcmp olt float 0x3E80000000000000, %1670
  br i1 %1671, label %1672, label %1683

1672:                                             ; preds = %1669, %1657
  %1673 = load ptr, ptr %2, align 8, !tbaa !5
  %1674 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1673, i32 0, i32 1
  %1675 = load i32, ptr %1674, align 4, !tbaa !20
  %1676 = add nsw i32 %1675, 1
  store i32 %1676, ptr %1674, align 4, !tbaa !20
  %1677 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 393)
  %1678 = load float, ptr %129, align 4, !tbaa !9
  %1679 = fpext float %1678 to double
  %1680 = load float, ptr %130, align 4, !tbaa !9
  %1681 = fpext float %1680 to double
  %1682 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.000000e+00, double noundef %1679, double noundef %1681)
  br label %1683

1683:                                             ; preds = %1672, %1669
  call void @llvm.lifetime.end.p0(i64 4, ptr %130) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %129) #6
  %1684 = load ptr, ptr %2, align 8, !tbaa !5
  %1685 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1684, i32 0, i32 0
  %1686 = load i32, ptr %1685, align 4, !tbaa !18
  %1687 = add nsw i32 %1686, 1
  store i32 %1687, ptr %1685, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %131) #6
  %1688 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 2
  %1689 = getelementptr inbounds [4 x float], ptr %1688, i64 0, i64 2
  %1690 = load float, ptr %1689, align 8, !tbaa !13
  store float %1690, ptr %131, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %132) #6
  %1691 = load float, ptr %131, align 4, !tbaa !9
  %1692 = fsub float %1691, 5.500000e+00
  store float %1692, ptr %132, align 4, !tbaa !9
  %1693 = load float, ptr %132, align 4, !tbaa !9
  %1694 = fcmp olt float %1693, 0xBE80000000000000
  br i1 %1694, label %1698, label %1695

1695:                                             ; preds = %1683
  %1696 = load float, ptr %132, align 4, !tbaa !9
  %1697 = fcmp olt float 0x3E80000000000000, %1696
  br i1 %1697, label %1698, label %1709

1698:                                             ; preds = %1695, %1683
  %1699 = load ptr, ptr %2, align 8, !tbaa !5
  %1700 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1699, i32 0, i32 1
  %1701 = load i32, ptr %1700, align 4, !tbaa !20
  %1702 = add nsw i32 %1701, 1
  store i32 %1702, ptr %1700, align 4, !tbaa !20
  %1703 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 394)
  %1704 = load float, ptr %131, align 4, !tbaa !9
  %1705 = fpext float %1704 to double
  %1706 = load float, ptr %132, align 4, !tbaa !9
  %1707 = fpext float %1706 to double
  %1708 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.500000e+00, double noundef %1705, double noundef %1707)
  br label %1709

1709:                                             ; preds = %1698, %1695
  call void @llvm.lifetime.end.p0(i64 4, ptr %132) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %131) #6
  %1710 = load ptr, ptr %2, align 8, !tbaa !5
  %1711 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1710, i32 0, i32 0
  %1712 = load i32, ptr %1711, align 4, !tbaa !18
  %1713 = add nsw i32 %1712, 1
  store i32 %1713, ptr %1711, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %133) #6
  %1714 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 2
  %1715 = getelementptr inbounds [4 x float], ptr %1714, i64 0, i64 3
  %1716 = load float, ptr %1715, align 4, !tbaa !13
  store float %1716, ptr %133, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %134) #6
  %1717 = load float, ptr %133, align 4, !tbaa !9
  %1718 = fsub float %1717, 6.000000e+00
  store float %1718, ptr %134, align 4, !tbaa !9
  %1719 = load float, ptr %134, align 4, !tbaa !9
  %1720 = fcmp olt float %1719, 0xBE80000000000000
  br i1 %1720, label %1724, label %1721

1721:                                             ; preds = %1709
  %1722 = load float, ptr %134, align 4, !tbaa !9
  %1723 = fcmp olt float 0x3E80000000000000, %1722
  br i1 %1723, label %1724, label %1735

1724:                                             ; preds = %1721, %1709
  %1725 = load ptr, ptr %2, align 8, !tbaa !5
  %1726 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1725, i32 0, i32 1
  %1727 = load i32, ptr %1726, align 4, !tbaa !20
  %1728 = add nsw i32 %1727, 1
  store i32 %1728, ptr %1726, align 4, !tbaa !20
  %1729 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 395)
  %1730 = load float, ptr %133, align 4, !tbaa !9
  %1731 = fpext float %1730 to double
  %1732 = load float, ptr %134, align 4, !tbaa !9
  %1733 = fpext float %1732 to double
  %1734 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.000000e+00, double noundef %1731, double noundef %1733)
  br label %1735

1735:                                             ; preds = %1724, %1721
  call void @llvm.lifetime.end.p0(i64 4, ptr %134) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %133) #6
  %1736 = load ptr, ptr %2, align 8, !tbaa !5
  %1737 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1736, i32 0, i32 0
  %1738 = load i32, ptr %1737, align 4, !tbaa !18
  %1739 = add nsw i32 %1738, 1
  store i32 %1739, ptr %1737, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %135) #6
  %1740 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 3
  %1741 = getelementptr inbounds [4 x float], ptr %1740, i64 0, i64 0
  %1742 = load float, ptr %1741, align 16, !tbaa !13
  store float %1742, ptr %135, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %136) #6
  %1743 = load float, ptr %135, align 4, !tbaa !9
  %1744 = fsub float %1743, 6.500000e+00
  store float %1744, ptr %136, align 4, !tbaa !9
  %1745 = load float, ptr %136, align 4, !tbaa !9
  %1746 = fcmp olt float %1745, 0xBE80000000000000
  br i1 %1746, label %1750, label %1747

1747:                                             ; preds = %1735
  %1748 = load float, ptr %136, align 4, !tbaa !9
  %1749 = fcmp olt float 0x3E80000000000000, %1748
  br i1 %1749, label %1750, label %1761

1750:                                             ; preds = %1747, %1735
  %1751 = load ptr, ptr %2, align 8, !tbaa !5
  %1752 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1751, i32 0, i32 1
  %1753 = load i32, ptr %1752, align 4, !tbaa !20
  %1754 = add nsw i32 %1753, 1
  store i32 %1754, ptr %1752, align 4, !tbaa !20
  %1755 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 396)
  %1756 = load float, ptr %135, align 4, !tbaa !9
  %1757 = fpext float %1756 to double
  %1758 = load float, ptr %136, align 4, !tbaa !9
  %1759 = fpext float %1758 to double
  %1760 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+00, double noundef %1757, double noundef %1759)
  br label %1761

1761:                                             ; preds = %1750, %1747
  call void @llvm.lifetime.end.p0(i64 4, ptr %136) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %135) #6
  %1762 = load ptr, ptr %2, align 8, !tbaa !5
  %1763 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1762, i32 0, i32 0
  %1764 = load i32, ptr %1763, align 4, !tbaa !18
  %1765 = add nsw i32 %1764, 1
  store i32 %1765, ptr %1763, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %137) #6
  %1766 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 3
  %1767 = getelementptr inbounds [4 x float], ptr %1766, i64 0, i64 1
  %1768 = load float, ptr %1767, align 4, !tbaa !13
  store float %1768, ptr %137, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %138) #6
  %1769 = load float, ptr %137, align 4, !tbaa !9
  %1770 = fsub float %1769, 7.000000e+00
  store float %1770, ptr %138, align 4, !tbaa !9
  %1771 = load float, ptr %138, align 4, !tbaa !9
  %1772 = fcmp olt float %1771, 0xBE80000000000000
  br i1 %1772, label %1776, label %1773

1773:                                             ; preds = %1761
  %1774 = load float, ptr %138, align 4, !tbaa !9
  %1775 = fcmp olt float 0x3E80000000000000, %1774
  br i1 %1775, label %1776, label %1787

1776:                                             ; preds = %1773, %1761
  %1777 = load ptr, ptr %2, align 8, !tbaa !5
  %1778 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1777, i32 0, i32 1
  %1779 = load i32, ptr %1778, align 4, !tbaa !20
  %1780 = add nsw i32 %1779, 1
  store i32 %1780, ptr %1778, align 4, !tbaa !20
  %1781 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 397)
  %1782 = load float, ptr %137, align 4, !tbaa !9
  %1783 = fpext float %1782 to double
  %1784 = load float, ptr %138, align 4, !tbaa !9
  %1785 = fpext float %1784 to double
  %1786 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.000000e+00, double noundef %1783, double noundef %1785)
  br label %1787

1787:                                             ; preds = %1776, %1773
  call void @llvm.lifetime.end.p0(i64 4, ptr %138) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %137) #6
  %1788 = load ptr, ptr %2, align 8, !tbaa !5
  %1789 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1788, i32 0, i32 0
  %1790 = load i32, ptr %1789, align 4, !tbaa !18
  %1791 = add nsw i32 %1790, 1
  store i32 %1791, ptr %1789, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %139) #6
  %1792 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 3
  %1793 = getelementptr inbounds [4 x float], ptr %1792, i64 0, i64 2
  %1794 = load float, ptr %1793, align 8, !tbaa !13
  store float %1794, ptr %139, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %140) #6
  %1795 = load float, ptr %139, align 4, !tbaa !9
  %1796 = fsub float %1795, 7.500000e+00
  store float %1796, ptr %140, align 4, !tbaa !9
  %1797 = load float, ptr %140, align 4, !tbaa !9
  %1798 = fcmp olt float %1797, 0xBE80000000000000
  br i1 %1798, label %1802, label %1799

1799:                                             ; preds = %1787
  %1800 = load float, ptr %140, align 4, !tbaa !9
  %1801 = fcmp olt float 0x3E80000000000000, %1800
  br i1 %1801, label %1802, label %1813

1802:                                             ; preds = %1799, %1787
  %1803 = load ptr, ptr %2, align 8, !tbaa !5
  %1804 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1803, i32 0, i32 1
  %1805 = load i32, ptr %1804, align 4, !tbaa !20
  %1806 = add nsw i32 %1805, 1
  store i32 %1806, ptr %1804, align 4, !tbaa !20
  %1807 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 398)
  %1808 = load float, ptr %139, align 4, !tbaa !9
  %1809 = fpext float %1808 to double
  %1810 = load float, ptr %140, align 4, !tbaa !9
  %1811 = fpext float %1810 to double
  %1812 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.500000e+00, double noundef %1809, double noundef %1811)
  br label %1813

1813:                                             ; preds = %1802, %1799
  call void @llvm.lifetime.end.p0(i64 4, ptr %140) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %139) #6
  %1814 = load ptr, ptr %2, align 8, !tbaa !5
  %1815 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1814, i32 0, i32 0
  %1816 = load i32, ptr %1815, align 4, !tbaa !18
  %1817 = add nsw i32 %1816, 1
  store i32 %1817, ptr %1815, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %141) #6
  %1818 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 3
  %1819 = getelementptr inbounds [4 x float], ptr %1818, i64 0, i64 3
  %1820 = load float, ptr %1819, align 4, !tbaa !13
  store float %1820, ptr %141, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %142) #6
  %1821 = load float, ptr %141, align 4, !tbaa !9
  %1822 = fsub float %1821, 8.000000e+00
  store float %1822, ptr %142, align 4, !tbaa !9
  %1823 = load float, ptr %142, align 4, !tbaa !9
  %1824 = fcmp olt float %1823, 0xBE80000000000000
  br i1 %1824, label %1828, label %1825

1825:                                             ; preds = %1813
  %1826 = load float, ptr %142, align 4, !tbaa !9
  %1827 = fcmp olt float 0x3E80000000000000, %1826
  br i1 %1827, label %1828, label %1839

1828:                                             ; preds = %1825, %1813
  %1829 = load ptr, ptr %2, align 8, !tbaa !5
  %1830 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1829, i32 0, i32 1
  %1831 = load i32, ptr %1830, align 4, !tbaa !20
  %1832 = add nsw i32 %1831, 1
  store i32 %1832, ptr %1830, align 4, !tbaa !20
  %1833 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 399)
  %1834 = load float, ptr %141, align 4, !tbaa !9
  %1835 = fpext float %1834 to double
  %1836 = load float, ptr %142, align 4, !tbaa !9
  %1837 = fpext float %1836 to double
  %1838 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.000000e+00, double noundef %1835, double noundef %1837)
  br label %1839

1839:                                             ; preds = %1828, %1825
  call void @llvm.lifetime.end.p0(i64 4, ptr %142) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %141) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %3) #6
  ret void
}

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL10HMM_DivM4F8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL7HMM_Div8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_Zdv8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef nonnull align 16 dereferenceable(64) ptr @_ZdVR8HMM_Mat4f(ptr noundef nonnull align 16 dereferenceable(64), float noundef) #3

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree 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 = { inlinehint mustprogress 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 #4 = { mustprogress 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 #5 = { inlinehint mustprogress uwtable "min-legal-vector-width"="128" "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 #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 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!7, !7, i64 0}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = !{i64 0, i64 64, !13}
!18 = !{!19, !12, i64 0}
!19 = !{!"_ZTS21hmt_testresult_struct", !12, i64 0, !12, i64 4}
!20 = !{!19, !12, i64 4}


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

%union.HMM_Mat4 = type { [4 x %union.HMM_Vec4] }
%union.HMM_Vec4 = type { <4 x float> }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 x i8], align 1

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL6HMM_M4v(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16) local_unnamed_addr #2

; Function Attrs: mustprogress uwtable
define dso_local void @_Z29_hmt_test_Division_Mat4ScalarP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #3 {
.preheader:
  %1 = alloca %union.HMM_Mat4, align 16
  %2 = alloca %union.HMM_Mat4, align 16
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %1) #6
  call void @_ZL6HMM_M4v(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %1)
  %5 = getelementptr inbounds i8, ptr %1, i64 4
  %6 = getelementptr inbounds i8, ptr %1, i64 8
  %7 = getelementptr inbounds i8, ptr %1, i64 12
  store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, ptr %1, align 16, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %1, i64 16
  %9 = getelementptr inbounds i8, ptr %1, i64 20
  %10 = getelementptr inbounds i8, ptr %1, i64 24
  %11 = getelementptr inbounds i8, ptr %1, i64 28
  store <4 x float> <float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00>, ptr %8, align 16, !tbaa !5
  %12 = getelementptr inbounds i8, ptr %1, i64 32
  %13 = getelementptr inbounds i8, ptr %1, i64 36
  %14 = getelementptr inbounds i8, ptr %1, i64 40
  %15 = getelementptr inbounds i8, ptr %1, i64 44
  store <4 x float> <float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01>, ptr %12, align 16, !tbaa !5
  %16 = getelementptr inbounds i8, ptr %1, i64 48
  %17 = getelementptr inbounds i8, ptr %1, i64 52
  %18 = getelementptr inbounds i8, ptr %1, i64 56
  %19 = getelementptr inbounds i8, ptr %1, i64 60
  store <4 x float> <float 1.300000e+01, float 1.400000e+01, float 1.500000e+01, float 1.600000e+01>, ptr %16, align 16, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #6
  call void @_ZL10HMM_DivM4F8HMM_Mat4f(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, float noundef 2.000000e+00)
  %20 = load i32, ptr %0, align 4, !tbaa !8
  %21 = add nsw i32 %20, 1
  store i32 %21, ptr %0, align 4, !tbaa !8
  %22 = load float, ptr %2, align 16, !tbaa !5
  %23 = fadd float %22, -5.000000e-01
  %24 = call float @llvm.fabs.f32(float %23)
  %or.cond = fcmp ogt float %24, 0x3E80000000000000
  br i1 %or.cond, label %25, label %33

25:                                               ; preds = %.preheader
  %26 = getelementptr inbounds i8, ptr %0, i64 4
  %27 = load i32, ptr %26, align 4, !tbaa !11
  %28 = add nsw i32 %27, 1
  store i32 %28, ptr %26, align 4, !tbaa !11
  %29 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 324)
  %30 = fpext float %22 to double
  %31 = fpext float %23 to double
  %32 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e-01, double noundef %30, double noundef %31)
  %.pre = load i32, ptr %0, align 4, !tbaa !8
  br label %33

33:                                               ; preds = %.preheader, %25
  %34 = phi i32 [ %21, %.preheader ], [ %.pre, %25 ]
  %35 = add nsw i32 %34, 1
  store i32 %35, ptr %0, align 4, !tbaa !8
  %36 = getelementptr inbounds i8, ptr %2, i64 4
  %37 = load float, ptr %36, align 4, !tbaa !5
  %38 = fadd float %37, -1.000000e+00
  %39 = call float @llvm.fabs.f32(float %38)
  %or.cond3 = fcmp ogt float %39, 0x3E80000000000000
  br i1 %or.cond3, label %40, label %48

40:                                               ; preds = %33
  %41 = getelementptr inbounds i8, ptr %0, i64 4
  %42 = load i32, ptr %41, align 4, !tbaa !11
  %43 = add nsw i32 %42, 1
  store i32 %43, ptr %41, align 4, !tbaa !11
  %44 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 325)
  %45 = fpext float %37 to double
  %46 = fpext float %38 to double
  %47 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+00, double noundef %45, double noundef %46)
  %.pre594 = load i32, ptr %0, align 4, !tbaa !8
  br label %48

48:                                               ; preds = %33, %40
  %49 = phi i32 [ %35, %33 ], [ %.pre594, %40 ]
  %50 = add nsw i32 %49, 1
  store i32 %50, ptr %0, align 4, !tbaa !8
  %51 = getelementptr inbounds i8, ptr %2, i64 8
  %52 = load float, ptr %51, align 8, !tbaa !5
  %53 = fadd float %52, -1.500000e+00
  %54 = call float @llvm.fabs.f32(float %53)
  %or.cond5 = fcmp ogt float %54, 0x3E80000000000000
  br i1 %or.cond5, label %55, label %63

55:                                               ; preds = %48
  %56 = getelementptr inbounds i8, ptr %0, i64 4
  %57 = load i32, ptr %56, align 4, !tbaa !11
  %58 = add nsw i32 %57, 1
  store i32 %58, ptr %56, align 4, !tbaa !11
  %59 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 326)
  %60 = fpext float %52 to double
  %61 = fpext float %53 to double
  %62 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.500000e+00, double noundef %60, double noundef %61)
  %.pre595 = load i32, ptr %0, align 4, !tbaa !8
  br label %63

63:                                               ; preds = %48, %55
  %64 = phi i32 [ %50, %48 ], [ %.pre595, %55 ]
  %65 = add nsw i32 %64, 1
  store i32 %65, ptr %0, align 4, !tbaa !8
  %66 = getelementptr inbounds i8, ptr %2, i64 12
  %67 = load float, ptr %66, align 4, !tbaa !5
  %68 = fadd float %67, -2.000000e+00
  %69 = call float @llvm.fabs.f32(float %68)
  %or.cond7 = fcmp ogt float %69, 0x3E80000000000000
  br i1 %or.cond7, label %70, label %78

70:                                               ; preds = %63
  %71 = getelementptr inbounds i8, ptr %0, i64 4
  %72 = load i32, ptr %71, align 4, !tbaa !11
  %73 = add nsw i32 %72, 1
  store i32 %73, ptr %71, align 4, !tbaa !11
  %74 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 327)
  %75 = fpext float %67 to double
  %76 = fpext float %68 to double
  %77 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+00, double noundef %75, double noundef %76)
  %.pre596 = load i32, ptr %0, align 4, !tbaa !8
  br label %78

78:                                               ; preds = %63, %70
  %79 = phi i32 [ %65, %63 ], [ %.pre596, %70 ]
  %80 = add nsw i32 %79, 1
  store i32 %80, ptr %0, align 4, !tbaa !8
  %81 = getelementptr inbounds i8, ptr %2, i64 16
  %82 = load float, ptr %81, align 16, !tbaa !5
  %83 = fadd float %82, -2.500000e+00
  %84 = call float @llvm.fabs.f32(float %83)
  %or.cond9 = fcmp ogt float %84, 0x3E80000000000000
  br i1 %or.cond9, label %85, label %93

85:                                               ; preds = %78
  %86 = getelementptr inbounds i8, ptr %0, i64 4
  %87 = load i32, ptr %86, align 4, !tbaa !11
  %88 = add nsw i32 %87, 1
  store i32 %88, ptr %86, align 4, !tbaa !11
  %89 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 328)
  %90 = fpext float %82 to double
  %91 = fpext float %83 to double
  %92 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.500000e+00, double noundef %90, double noundef %91)
  %.pre597 = load i32, ptr %0, align 4, !tbaa !8
  br label %93

93:                                               ; preds = %78, %85
  %94 = phi i32 [ %80, %78 ], [ %.pre597, %85 ]
  %95 = add nsw i32 %94, 1
  store i32 %95, ptr %0, align 4, !tbaa !8
  %96 = getelementptr inbounds i8, ptr %2, i64 20
  %97 = load float, ptr %96, align 4, !tbaa !5
  %98 = fadd float %97, -3.000000e+00
  %99 = call float @llvm.fabs.f32(float %98)
  %or.cond11 = fcmp ogt float %99, 0x3E80000000000000
  br i1 %or.cond11, label %100, label %108

100:                                              ; preds = %93
  %101 = getelementptr inbounds i8, ptr %0, i64 4
  %102 = load i32, ptr %101, align 4, !tbaa !11
  %103 = add nsw i32 %102, 1
  store i32 %103, ptr %101, align 4, !tbaa !11
  %104 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %105 = fpext float %97 to double
  %106 = fpext float %98 to double
  %107 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+00, double noundef %105, double noundef %106)
  %.pre598 = load i32, ptr %0, align 4, !tbaa !8
  br label %108

108:                                              ; preds = %93, %100
  %109 = phi i32 [ %95, %93 ], [ %.pre598, %100 ]
  %110 = add nsw i32 %109, 1
  store i32 %110, ptr %0, align 4, !tbaa !8
  %111 = getelementptr inbounds i8, ptr %2, i64 24
  %112 = load float, ptr %111, align 8, !tbaa !5
  %113 = fadd float %112, -3.500000e+00
  %114 = call float @llvm.fabs.f32(float %113)
  %or.cond13 = fcmp ogt float %114, 0x3E80000000000000
  br i1 %or.cond13, label %115, label %123

115:                                              ; preds = %108
  %116 = getelementptr inbounds i8, ptr %0, i64 4
  %117 = load i32, ptr %116, align 4, !tbaa !11
  %118 = add nsw i32 %117, 1
  store i32 %118, ptr %116, align 4, !tbaa !11
  %119 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 330)
  %120 = fpext float %112 to double
  %121 = fpext float %113 to double
  %122 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.500000e+00, double noundef %120, double noundef %121)
  %.pre599 = load i32, ptr %0, align 4, !tbaa !8
  br label %123

123:                                              ; preds = %108, %115
  %124 = phi i32 [ %110, %108 ], [ %.pre599, %115 ]
  %125 = add nsw i32 %124, 1
  store i32 %125, ptr %0, align 4, !tbaa !8
  %126 = getelementptr inbounds i8, ptr %2, i64 28
  %127 = load float, ptr %126, align 4, !tbaa !5
  %128 = fadd float %127, -4.000000e+00
  %129 = call float @llvm.fabs.f32(float %128)
  %or.cond15 = fcmp ogt float %129, 0x3E80000000000000
  br i1 %or.cond15, label %130, label %138

130:                                              ; preds = %123
  %131 = getelementptr inbounds i8, ptr %0, i64 4
  %132 = load i32, ptr %131, align 4, !tbaa !11
  %133 = add nsw i32 %132, 1
  store i32 %133, ptr %131, align 4, !tbaa !11
  %134 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 331)
  %135 = fpext float %127 to double
  %136 = fpext float %128 to double
  %137 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+00, double noundef %135, double noundef %136)
  %.pre600 = load i32, ptr %0, align 4, !tbaa !8
  br label %138

138:                                              ; preds = %123, %130
  %139 = phi i32 [ %125, %123 ], [ %.pre600, %130 ]
  %140 = add nsw i32 %139, 1
  store i32 %140, ptr %0, align 4, !tbaa !8
  %141 = getelementptr inbounds i8, ptr %2, i64 32
  %142 = load float, ptr %141, align 16, !tbaa !5
  %143 = fadd float %142, -4.500000e+00
  %144 = call float @llvm.fabs.f32(float %143)
  %or.cond17 = fcmp ogt float %144, 0x3E80000000000000
  br i1 %or.cond17, label %145, label %153

145:                                              ; preds = %138
  %146 = getelementptr inbounds i8, ptr %0, i64 4
  %147 = load i32, ptr %146, align 4, !tbaa !11
  %148 = add nsw i32 %147, 1
  store i32 %148, ptr %146, align 4, !tbaa !11
  %149 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 332)
  %150 = fpext float %142 to double
  %151 = fpext float %143 to double
  %152 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.500000e+00, double noundef %150, double noundef %151)
  %.pre601 = load i32, ptr %0, align 4, !tbaa !8
  br label %153

153:                                              ; preds = %138, %145
  %154 = phi i32 [ %140, %138 ], [ %.pre601, %145 ]
  %155 = add nsw i32 %154, 1
  store i32 %155, ptr %0, align 4, !tbaa !8
  %156 = getelementptr inbounds i8, ptr %2, i64 36
  %157 = load float, ptr %156, align 4, !tbaa !5
  %158 = fadd float %157, -5.000000e+00
  %159 = call float @llvm.fabs.f32(float %158)
  %or.cond19 = fcmp ogt float %159, 0x3E80000000000000
  br i1 %or.cond19, label %160, label %168

160:                                              ; preds = %153
  %161 = getelementptr inbounds i8, ptr %0, i64 4
  %162 = load i32, ptr %161, align 4, !tbaa !11
  %163 = add nsw i32 %162, 1
  store i32 %163, ptr %161, align 4, !tbaa !11
  %164 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 333)
  %165 = fpext float %157 to double
  %166 = fpext float %158 to double
  %167 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e+00, double noundef %165, double noundef %166)
  %.pre602 = load i32, ptr %0, align 4, !tbaa !8
  br label %168

168:                                              ; preds = %153, %160
  %169 = phi i32 [ %155, %153 ], [ %.pre602, %160 ]
  %170 = add nsw i32 %169, 1
  store i32 %170, ptr %0, align 4, !tbaa !8
  %171 = getelementptr inbounds i8, ptr %2, i64 40
  %172 = load float, ptr %171, align 8, !tbaa !5
  %173 = fadd float %172, -5.500000e+00
  %174 = call float @llvm.fabs.f32(float %173)
  %or.cond21 = fcmp ogt float %174, 0x3E80000000000000
  br i1 %or.cond21, label %175, label %183

175:                                              ; preds = %168
  %176 = getelementptr inbounds i8, ptr %0, i64 4
  %177 = load i32, ptr %176, align 4, !tbaa !11
  %178 = add nsw i32 %177, 1
  store i32 %178, ptr %176, align 4, !tbaa !11
  %179 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 334)
  %180 = fpext float %172 to double
  %181 = fpext float %173 to double
  %182 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.500000e+00, double noundef %180, double noundef %181)
  %.pre603 = load i32, ptr %0, align 4, !tbaa !8
  br label %183

183:                                              ; preds = %168, %175
  %184 = phi i32 [ %170, %168 ], [ %.pre603, %175 ]
  %185 = add nsw i32 %184, 1
  store i32 %185, ptr %0, align 4, !tbaa !8
  %186 = getelementptr inbounds i8, ptr %2, i64 44
  %187 = load float, ptr %186, align 4, !tbaa !5
  %188 = fadd float %187, -6.000000e+00
  %189 = call float @llvm.fabs.f32(float %188)
  %or.cond23 = fcmp ogt float %189, 0x3E80000000000000
  br i1 %or.cond23, label %190, label %198

190:                                              ; preds = %183
  %191 = getelementptr inbounds i8, ptr %0, i64 4
  %192 = load i32, ptr %191, align 4, !tbaa !11
  %193 = add nsw i32 %192, 1
  store i32 %193, ptr %191, align 4, !tbaa !11
  %194 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 335)
  %195 = fpext float %187 to double
  %196 = fpext float %188 to double
  %197 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.000000e+00, double noundef %195, double noundef %196)
  %.pre604 = load i32, ptr %0, align 4, !tbaa !8
  br label %198

198:                                              ; preds = %183, %190
  %199 = phi i32 [ %185, %183 ], [ %.pre604, %190 ]
  %200 = add nsw i32 %199, 1
  store i32 %200, ptr %0, align 4, !tbaa !8
  %201 = getelementptr inbounds i8, ptr %2, i64 48
  %202 = load float, ptr %201, align 16, !tbaa !5
  %203 = fadd float %202, -6.500000e+00
  %204 = call float @llvm.fabs.f32(float %203)
  %or.cond25 = fcmp ogt float %204, 0x3E80000000000000
  br i1 %or.cond25, label %205, label %213

205:                                              ; preds = %198
  %206 = getelementptr inbounds i8, ptr %0, i64 4
  %207 = load i32, ptr %206, align 4, !tbaa !11
  %208 = add nsw i32 %207, 1
  store i32 %208, ptr %206, align 4, !tbaa !11
  %209 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 336)
  %210 = fpext float %202 to double
  %211 = fpext float %203 to double
  %212 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+00, double noundef %210, double noundef %211)
  %.pre605 = load i32, ptr %0, align 4, !tbaa !8
  br label %213

213:                                              ; preds = %198, %205
  %214 = phi i32 [ %200, %198 ], [ %.pre605, %205 ]
  %215 = add nsw i32 %214, 1
  store i32 %215, ptr %0, align 4, !tbaa !8
  %216 = getelementptr inbounds i8, ptr %2, i64 52
  %217 = load float, ptr %216, align 4, !tbaa !5
  %218 = fadd float %217, -7.000000e+00
  %219 = call float @llvm.fabs.f32(float %218)
  %or.cond27 = fcmp ogt float %219, 0x3E80000000000000
  br i1 %or.cond27, label %220, label %228

220:                                              ; preds = %213
  %221 = getelementptr inbounds i8, ptr %0, i64 4
  %222 = load i32, ptr %221, align 4, !tbaa !11
  %223 = add nsw i32 %222, 1
  store i32 %223, ptr %221, align 4, !tbaa !11
  %224 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %225 = fpext float %217 to double
  %226 = fpext float %218 to double
  %227 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.000000e+00, double noundef %225, double noundef %226)
  %.pre606 = load i32, ptr %0, align 4, !tbaa !8
  br label %228

228:                                              ; preds = %213, %220
  %229 = phi i32 [ %215, %213 ], [ %.pre606, %220 ]
  %230 = add nsw i32 %229, 1
  store i32 %230, ptr %0, align 4, !tbaa !8
  %231 = getelementptr inbounds i8, ptr %2, i64 56
  %232 = load float, ptr %231, align 8, !tbaa !5
  %233 = fadd float %232, -7.500000e+00
  %234 = call float @llvm.fabs.f32(float %233)
  %or.cond29 = fcmp ogt float %234, 0x3E80000000000000
  br i1 %or.cond29, label %235, label %243

235:                                              ; preds = %228
  %236 = getelementptr inbounds i8, ptr %0, i64 4
  %237 = load i32, ptr %236, align 4, !tbaa !11
  %238 = add nsw i32 %237, 1
  store i32 %238, ptr %236, align 4, !tbaa !11
  %239 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 338)
  %240 = fpext float %232 to double
  %241 = fpext float %233 to double
  %242 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.500000e+00, double noundef %240, double noundef %241)
  %.pre607 = load i32, ptr %0, align 4, !tbaa !8
  br label %243

243:                                              ; preds = %228, %235
  %244 = phi i32 [ %230, %228 ], [ %.pre607, %235 ]
  %245 = add nsw i32 %244, 1
  store i32 %245, ptr %0, align 4, !tbaa !8
  %246 = getelementptr inbounds i8, ptr %2, i64 60
  %247 = load float, ptr %246, align 4, !tbaa !5
  %248 = fadd float %247, -8.000000e+00
  %249 = call float @llvm.fabs.f32(float %248)
  %or.cond31 = fcmp ogt float %249, 0x3E80000000000000
  br i1 %or.cond31, label %250, label %258

250:                                              ; preds = %243
  %251 = getelementptr inbounds i8, ptr %0, i64 4
  %252 = load i32, ptr %251, align 4, !tbaa !11
  %253 = add nsw i32 %252, 1
  store i32 %253, ptr %251, align 4, !tbaa !11
  %254 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 339)
  %255 = fpext float %247 to double
  %256 = fpext float %248 to double
  %257 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.000000e+00, double noundef %255, double noundef %256)
  br label %258

258:                                              ; preds = %243, %250
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #6
  call void @_ZL7HMM_Div8HMM_Mat4f(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, float noundef 2.000000e+00)
  %259 = load i32, ptr %0, align 4, !tbaa !8
  %260 = add nsw i32 %259, 1
  store i32 %260, ptr %0, align 4, !tbaa !8
  %261 = load float, ptr %3, align 16, !tbaa !5
  %262 = fadd float %261, -5.000000e-01
  %263 = call float @llvm.fabs.f32(float %262)
  %or.cond33 = fcmp ogt float %263, 0x3E80000000000000
  br i1 %or.cond33, label %264, label %272

264:                                              ; preds = %258
  %265 = getelementptr inbounds i8, ptr %0, i64 4
  %266 = load i32, ptr %265, align 4, !tbaa !11
  %267 = add nsw i32 %266, 1
  store i32 %267, ptr %265, align 4, !tbaa !11
  %268 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 344)
  %269 = fpext float %261 to double
  %270 = fpext float %262 to double
  %271 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e-01, double noundef %269, double noundef %270)
  %.pre608 = load i32, ptr %0, align 4, !tbaa !8
  br label %272

272:                                              ; preds = %258, %264
  %273 = phi i32 [ %260, %258 ], [ %.pre608, %264 ]
  %274 = add nsw i32 %273, 1
  store i32 %274, ptr %0, align 4, !tbaa !8
  %275 = getelementptr inbounds i8, ptr %3, i64 4
  %276 = load float, ptr %275, align 4, !tbaa !5
  %277 = fadd float %276, -1.000000e+00
  %278 = call float @llvm.fabs.f32(float %277)
  %or.cond35 = fcmp ogt float %278, 0x3E80000000000000
  br i1 %or.cond35, label %279, label %287

279:                                              ; preds = %272
  %280 = getelementptr inbounds i8, ptr %0, i64 4
  %281 = load i32, ptr %280, align 4, !tbaa !11
  %282 = add nsw i32 %281, 1
  store i32 %282, ptr %280, align 4, !tbaa !11
  %283 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 345)
  %284 = fpext float %276 to double
  %285 = fpext float %277 to double
  %286 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+00, double noundef %284, double noundef %285)
  %.pre609 = load i32, ptr %0, align 4, !tbaa !8
  br label %287

287:                                              ; preds = %272, %279
  %288 = phi i32 [ %274, %272 ], [ %.pre609, %279 ]
  %289 = add nsw i32 %288, 1
  store i32 %289, ptr %0, align 4, !tbaa !8
  %290 = getelementptr inbounds i8, ptr %3, i64 8
  %291 = load float, ptr %290, align 8, !tbaa !5
  %292 = fadd float %291, -1.500000e+00
  %293 = call float @llvm.fabs.f32(float %292)
  %or.cond37 = fcmp ogt float %293, 0x3E80000000000000
  br i1 %or.cond37, label %294, label %302

294:                                              ; preds = %287
  %295 = getelementptr inbounds i8, ptr %0, i64 4
  %296 = load i32, ptr %295, align 4, !tbaa !11
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %295, align 4, !tbaa !11
  %298 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 346)
  %299 = fpext float %291 to double
  %300 = fpext float %292 to double
  %301 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.500000e+00, double noundef %299, double noundef %300)
  %.pre610 = load i32, ptr %0, align 4, !tbaa !8
  br label %302

302:                                              ; preds = %287, %294
  %303 = phi i32 [ %289, %287 ], [ %.pre610, %294 ]
  %304 = add nsw i32 %303, 1
  store i32 %304, ptr %0, align 4, !tbaa !8
  %305 = getelementptr inbounds i8, ptr %3, i64 12
  %306 = load float, ptr %305, align 4, !tbaa !5
  %307 = fadd float %306, -2.000000e+00
  %308 = call float @llvm.fabs.f32(float %307)
  %or.cond39 = fcmp ogt float %308, 0x3E80000000000000
  br i1 %or.cond39, label %309, label %317

309:                                              ; preds = %302
  %310 = getelementptr inbounds i8, ptr %0, i64 4
  %311 = load i32, ptr %310, align 4, !tbaa !11
  %312 = add nsw i32 %311, 1
  store i32 %312, ptr %310, align 4, !tbaa !11
  %313 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 347)
  %314 = fpext float %306 to double
  %315 = fpext float %307 to double
  %316 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+00, double noundef %314, double noundef %315)
  %.pre611 = load i32, ptr %0, align 4, !tbaa !8
  br label %317

317:                                              ; preds = %302, %309
  %318 = phi i32 [ %304, %302 ], [ %.pre611, %309 ]
  %319 = add nsw i32 %318, 1
  store i32 %319, ptr %0, align 4, !tbaa !8
  %320 = getelementptr inbounds i8, ptr %3, i64 16
  %321 = load float, ptr %320, align 16, !tbaa !5
  %322 = fadd float %321, -2.500000e+00
  %323 = call float @llvm.fabs.f32(float %322)
  %or.cond41 = fcmp ogt float %323, 0x3E80000000000000
  br i1 %or.cond41, label %324, label %332

324:                                              ; preds = %317
  %325 = getelementptr inbounds i8, ptr %0, i64 4
  %326 = load i32, ptr %325, align 4, !tbaa !11
  %327 = add nsw i32 %326, 1
  store i32 %327, ptr %325, align 4, !tbaa !11
  %328 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 348)
  %329 = fpext float %321 to double
  %330 = fpext float %322 to double
  %331 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.500000e+00, double noundef %329, double noundef %330)
  %.pre612 = load i32, ptr %0, align 4, !tbaa !8
  br label %332

332:                                              ; preds = %317, %324
  %333 = phi i32 [ %319, %317 ], [ %.pre612, %324 ]
  %334 = add nsw i32 %333, 1
  store i32 %334, ptr %0, align 4, !tbaa !8
  %335 = getelementptr inbounds i8, ptr %3, i64 20
  %336 = load float, ptr %335, align 4, !tbaa !5
  %337 = fadd float %336, -3.000000e+00
  %338 = call float @llvm.fabs.f32(float %337)
  %or.cond43 = fcmp ogt float %338, 0x3E80000000000000
  br i1 %or.cond43, label %339, label %347

339:                                              ; preds = %332
  %340 = getelementptr inbounds i8, ptr %0, i64 4
  %341 = load i32, ptr %340, align 4, !tbaa !11
  %342 = add nsw i32 %341, 1
  store i32 %342, ptr %340, align 4, !tbaa !11
  %343 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 349)
  %344 = fpext float %336 to double
  %345 = fpext float %337 to double
  %346 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+00, double noundef %344, double noundef %345)
  %.pre613 = load i32, ptr %0, align 4, !tbaa !8
  br label %347

347:                                              ; preds = %332, %339
  %348 = phi i32 [ %334, %332 ], [ %.pre613, %339 ]
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %0, align 4, !tbaa !8
  %350 = getelementptr inbounds i8, ptr %3, i64 24
  %351 = load float, ptr %350, align 8, !tbaa !5
  %352 = fadd float %351, -3.500000e+00
  %353 = call float @llvm.fabs.f32(float %352)
  %or.cond45 = fcmp ogt float %353, 0x3E80000000000000
  br i1 %or.cond45, label %354, label %362

354:                                              ; preds = %347
  %355 = getelementptr inbounds i8, ptr %0, i64 4
  %356 = load i32, ptr %355, align 4, !tbaa !11
  %357 = add nsw i32 %356, 1
  store i32 %357, ptr %355, align 4, !tbaa !11
  %358 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 350)
  %359 = fpext float %351 to double
  %360 = fpext float %352 to double
  %361 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.500000e+00, double noundef %359, double noundef %360)
  %.pre614 = load i32, ptr %0, align 4, !tbaa !8
  br label %362

362:                                              ; preds = %347, %354
  %363 = phi i32 [ %349, %347 ], [ %.pre614, %354 ]
  %364 = add nsw i32 %363, 1
  store i32 %364, ptr %0, align 4, !tbaa !8
  %365 = getelementptr inbounds i8, ptr %3, i64 28
  %366 = load float, ptr %365, align 4, !tbaa !5
  %367 = fadd float %366, -4.000000e+00
  %368 = call float @llvm.fabs.f32(float %367)
  %or.cond47 = fcmp ogt float %368, 0x3E80000000000000
  br i1 %or.cond47, label %369, label %377

369:                                              ; preds = %362
  %370 = getelementptr inbounds i8, ptr %0, i64 4
  %371 = load i32, ptr %370, align 4, !tbaa !11
  %372 = add nsw i32 %371, 1
  store i32 %372, ptr %370, align 4, !tbaa !11
  %373 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 351)
  %374 = fpext float %366 to double
  %375 = fpext float %367 to double
  %376 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+00, double noundef %374, double noundef %375)
  %.pre615 = load i32, ptr %0, align 4, !tbaa !8
  br label %377

377:                                              ; preds = %362, %369
  %378 = phi i32 [ %364, %362 ], [ %.pre615, %369 ]
  %379 = add nsw i32 %378, 1
  store i32 %379, ptr %0, align 4, !tbaa !8
  %380 = getelementptr inbounds i8, ptr %3, i64 32
  %381 = load float, ptr %380, align 16, !tbaa !5
  %382 = fadd float %381, -4.500000e+00
  %383 = call float @llvm.fabs.f32(float %382)
  %or.cond49 = fcmp ogt float %383, 0x3E80000000000000
  br i1 %or.cond49, label %384, label %392

384:                                              ; preds = %377
  %385 = getelementptr inbounds i8, ptr %0, i64 4
  %386 = load i32, ptr %385, align 4, !tbaa !11
  %387 = add nsw i32 %386, 1
  store i32 %387, ptr %385, align 4, !tbaa !11
  %388 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 352)
  %389 = fpext float %381 to double
  %390 = fpext float %382 to double
  %391 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.500000e+00, double noundef %389, double noundef %390)
  %.pre616 = load i32, ptr %0, align 4, !tbaa !8
  br label %392

392:                                              ; preds = %377, %384
  %393 = phi i32 [ %379, %377 ], [ %.pre616, %384 ]
  %394 = add nsw i32 %393, 1
  store i32 %394, ptr %0, align 4, !tbaa !8
  %395 = getelementptr inbounds i8, ptr %3, i64 36
  %396 = load float, ptr %395, align 4, !tbaa !5
  %397 = fadd float %396, -5.000000e+00
  %398 = call float @llvm.fabs.f32(float %397)
  %or.cond51 = fcmp ogt float %398, 0x3E80000000000000
  br i1 %or.cond51, label %399, label %407

399:                                              ; preds = %392
  %400 = getelementptr inbounds i8, ptr %0, i64 4
  %401 = load i32, ptr %400, align 4, !tbaa !11
  %402 = add nsw i32 %401, 1
  store i32 %402, ptr %400, align 4, !tbaa !11
  %403 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 353)
  %404 = fpext float %396 to double
  %405 = fpext float %397 to double
  %406 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e+00, double noundef %404, double noundef %405)
  %.pre617 = load i32, ptr %0, align 4, !tbaa !8
  br label %407

407:                                              ; preds = %392, %399
  %408 = phi i32 [ %394, %392 ], [ %.pre617, %399 ]
  %409 = add nsw i32 %408, 1
  store i32 %409, ptr %0, align 4, !tbaa !8
  %410 = getelementptr inbounds i8, ptr %3, i64 40
  %411 = load float, ptr %410, align 8, !tbaa !5
  %412 = fadd float %411, -5.500000e+00
  %413 = call float @llvm.fabs.f32(float %412)
  %or.cond53 = fcmp ogt float %413, 0x3E80000000000000
  br i1 %or.cond53, label %414, label %422

414:                                              ; preds = %407
  %415 = getelementptr inbounds i8, ptr %0, i64 4
  %416 = load i32, ptr %415, align 4, !tbaa !11
  %417 = add nsw i32 %416, 1
  store i32 %417, ptr %415, align 4, !tbaa !11
  %418 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 354)
  %419 = fpext float %411 to double
  %420 = fpext float %412 to double
  %421 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.500000e+00, double noundef %419, double noundef %420)
  %.pre618 = load i32, ptr %0, align 4, !tbaa !8
  br label %422

422:                                              ; preds = %407, %414
  %423 = phi i32 [ %409, %407 ], [ %.pre618, %414 ]
  %424 = add nsw i32 %423, 1
  store i32 %424, ptr %0, align 4, !tbaa !8
  %425 = getelementptr inbounds i8, ptr %3, i64 44
  %426 = load float, ptr %425, align 4, !tbaa !5
  %427 = fadd float %426, -6.000000e+00
  %428 = call float @llvm.fabs.f32(float %427)
  %or.cond55 = fcmp ogt float %428, 0x3E80000000000000
  br i1 %or.cond55, label %429, label %437

429:                                              ; preds = %422
  %430 = getelementptr inbounds i8, ptr %0, i64 4
  %431 = load i32, ptr %430, align 4, !tbaa !11
  %432 = add nsw i32 %431, 1
  store i32 %432, ptr %430, align 4, !tbaa !11
  %433 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 355)
  %434 = fpext float %426 to double
  %435 = fpext float %427 to double
  %436 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.000000e+00, double noundef %434, double noundef %435)
  %.pre619 = load i32, ptr %0, align 4, !tbaa !8
  br label %437

437:                                              ; preds = %422, %429
  %438 = phi i32 [ %424, %422 ], [ %.pre619, %429 ]
  %439 = add nsw i32 %438, 1
  store i32 %439, ptr %0, align 4, !tbaa !8
  %440 = getelementptr inbounds i8, ptr %3, i64 48
  %441 = load float, ptr %440, align 16, !tbaa !5
  %442 = fadd float %441, -6.500000e+00
  %443 = call float @llvm.fabs.f32(float %442)
  %or.cond57 = fcmp ogt float %443, 0x3E80000000000000
  br i1 %or.cond57, label %444, label %452

444:                                              ; preds = %437
  %445 = getelementptr inbounds i8, ptr %0, i64 4
  %446 = load i32, ptr %445, align 4, !tbaa !11
  %447 = add nsw i32 %446, 1
  store i32 %447, ptr %445, align 4, !tbaa !11
  %448 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 356)
  %449 = fpext float %441 to double
  %450 = fpext float %442 to double
  %451 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+00, double noundef %449, double noundef %450)
  %.pre620 = load i32, ptr %0, align 4, !tbaa !8
  br label %452

452:                                              ; preds = %437, %444
  %453 = phi i32 [ %439, %437 ], [ %.pre620, %444 ]
  %454 = add nsw i32 %453, 1
  store i32 %454, ptr %0, align 4, !tbaa !8
  %455 = getelementptr inbounds i8, ptr %3, i64 52
  %456 = load float, ptr %455, align 4, !tbaa !5
  %457 = fadd float %456, -7.000000e+00
  %458 = call float @llvm.fabs.f32(float %457)
  %or.cond59 = fcmp ogt float %458, 0x3E80000000000000
  br i1 %or.cond59, label %459, label %467

459:                                              ; preds = %452
  %460 = getelementptr inbounds i8, ptr %0, i64 4
  %461 = load i32, ptr %460, align 4, !tbaa !11
  %462 = add nsw i32 %461, 1
  store i32 %462, ptr %460, align 4, !tbaa !11
  %463 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 357)
  %464 = fpext float %456 to double
  %465 = fpext float %457 to double
  %466 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.000000e+00, double noundef %464, double noundef %465)
  %.pre621 = load i32, ptr %0, align 4, !tbaa !8
  br label %467

467:                                              ; preds = %452, %459
  %468 = phi i32 [ %454, %452 ], [ %.pre621, %459 ]
  %469 = add nsw i32 %468, 1
  store i32 %469, ptr %0, align 4, !tbaa !8
  %470 = getelementptr inbounds i8, ptr %3, i64 56
  %471 = load float, ptr %470, align 8, !tbaa !5
  %472 = fadd float %471, -7.500000e+00
  %473 = call float @llvm.fabs.f32(float %472)
  %or.cond61 = fcmp ogt float %473, 0x3E80000000000000
  br i1 %or.cond61, label %474, label %482

474:                                              ; preds = %467
  %475 = getelementptr inbounds i8, ptr %0, i64 4
  %476 = load i32, ptr %475, align 4, !tbaa !11
  %477 = add nsw i32 %476, 1
  store i32 %477, ptr %475, align 4, !tbaa !11
  %478 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 358)
  %479 = fpext float %471 to double
  %480 = fpext float %472 to double
  %481 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.500000e+00, double noundef %479, double noundef %480)
  %.pre622 = load i32, ptr %0, align 4, !tbaa !8
  br label %482

482:                                              ; preds = %467, %474
  %483 = phi i32 [ %469, %467 ], [ %.pre622, %474 ]
  %484 = add nsw i32 %483, 1
  store i32 %484, ptr %0, align 4, !tbaa !8
  %485 = getelementptr inbounds i8, ptr %3, i64 60
  %486 = load float, ptr %485, align 4, !tbaa !5
  %487 = fadd float %486, -8.000000e+00
  %488 = call float @llvm.fabs.f32(float %487)
  %or.cond63 = fcmp ogt float %488, 0x3E80000000000000
  br i1 %or.cond63, label %489, label %497

489:                                              ; preds = %482
  %490 = getelementptr inbounds i8, ptr %0, i64 4
  %491 = load i32, ptr %490, align 4, !tbaa !11
  %492 = add nsw i32 %491, 1
  store i32 %492, ptr %490, align 4, !tbaa !11
  %493 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 359)
  %494 = fpext float %486 to double
  %495 = fpext float %487 to double
  %496 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.000000e+00, double noundef %494, double noundef %495)
  br label %497

497:                                              ; preds = %482, %489
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #6
  call void @_Zdv8HMM_Mat4f(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, float noundef 2.000000e+00)
  %498 = load i32, ptr %0, align 4, !tbaa !8
  %499 = add nsw i32 %498, 1
  store i32 %499, ptr %0, align 4, !tbaa !8
  %500 = load float, ptr %4, align 16, !tbaa !5
  %501 = fadd float %500, -5.000000e-01
  %502 = call float @llvm.fabs.f32(float %501)
  %or.cond65 = fcmp ogt float %502, 0x3E80000000000000
  br i1 %or.cond65, label %503, label %511

503:                                              ; preds = %497
  %504 = getelementptr inbounds i8, ptr %0, i64 4
  %505 = load i32, ptr %504, align 4, !tbaa !11
  %506 = add nsw i32 %505, 1
  store i32 %506, ptr %504, align 4, !tbaa !11
  %507 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 365)
  %508 = fpext float %500 to double
  %509 = fpext float %501 to double
  %510 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e-01, double noundef %508, double noundef %509)
  %.pre623 = load i32, ptr %0, align 4, !tbaa !8
  br label %511

511:                                              ; preds = %497, %503
  %512 = phi i32 [ %499, %497 ], [ %.pre623, %503 ]
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %0, align 4, !tbaa !8
  %514 = getelementptr inbounds i8, ptr %4, i64 4
  %515 = load float, ptr %514, align 4, !tbaa !5
  %516 = fadd float %515, -1.000000e+00
  %517 = call float @llvm.fabs.f32(float %516)
  %or.cond67 = fcmp ogt float %517, 0x3E80000000000000
  br i1 %or.cond67, label %518, label %526

518:                                              ; preds = %511
  %519 = getelementptr inbounds i8, ptr %0, i64 4
  %520 = load i32, ptr %519, align 4, !tbaa !11
  %521 = add nsw i32 %520, 1
  store i32 %521, ptr %519, align 4, !tbaa !11
  %522 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 366)
  %523 = fpext float %515 to double
  %524 = fpext float %516 to double
  %525 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+00, double noundef %523, double noundef %524)
  %.pre624 = load i32, ptr %0, align 4, !tbaa !8
  br label %526

526:                                              ; preds = %511, %518
  %527 = phi i32 [ %513, %511 ], [ %.pre624, %518 ]
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %0, align 4, !tbaa !8
  %529 = getelementptr inbounds i8, ptr %4, i64 8
  %530 = load float, ptr %529, align 8, !tbaa !5
  %531 = fadd float %530, -1.500000e+00
  %532 = call float @llvm.fabs.f32(float %531)
  %or.cond69 = fcmp ogt float %532, 0x3E80000000000000
  br i1 %or.cond69, label %533, label %541

533:                                              ; preds = %526
  %534 = getelementptr inbounds i8, ptr %0, i64 4
  %535 = load i32, ptr %534, align 4, !tbaa !11
  %536 = add nsw i32 %535, 1
  store i32 %536, ptr %534, align 4, !tbaa !11
  %537 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 367)
  %538 = fpext float %530 to double
  %539 = fpext float %531 to double
  %540 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.500000e+00, double noundef %538, double noundef %539)
  %.pre625 = load i32, ptr %0, align 4, !tbaa !8
  br label %541

541:                                              ; preds = %526, %533
  %542 = phi i32 [ %528, %526 ], [ %.pre625, %533 ]
  %543 = add nsw i32 %542, 1
  store i32 %543, ptr %0, align 4, !tbaa !8
  %544 = getelementptr inbounds i8, ptr %4, i64 12
  %545 = load float, ptr %544, align 4, !tbaa !5
  %546 = fadd float %545, -2.000000e+00
  %547 = call float @llvm.fabs.f32(float %546)
  %or.cond71 = fcmp ogt float %547, 0x3E80000000000000
  br i1 %or.cond71, label %548, label %556

548:                                              ; preds = %541
  %549 = getelementptr inbounds i8, ptr %0, i64 4
  %550 = load i32, ptr %549, align 4, !tbaa !11
  %551 = add nsw i32 %550, 1
  store i32 %551, ptr %549, align 4, !tbaa !11
  %552 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 368)
  %553 = fpext float %545 to double
  %554 = fpext float %546 to double
  %555 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+00, double noundef %553, double noundef %554)
  %.pre626 = load i32, ptr %0, align 4, !tbaa !8
  br label %556

556:                                              ; preds = %541, %548
  %557 = phi i32 [ %543, %541 ], [ %.pre626, %548 ]
  %558 = add nsw i32 %557, 1
  store i32 %558, ptr %0, align 4, !tbaa !8
  %559 = getelementptr inbounds i8, ptr %4, i64 16
  %560 = load float, ptr %559, align 16, !tbaa !5
  %561 = fadd float %560, -2.500000e+00
  %562 = call float @llvm.fabs.f32(float %561)
  %or.cond73 = fcmp ogt float %562, 0x3E80000000000000
  br i1 %or.cond73, label %563, label %571

563:                                              ; preds = %556
  %564 = getelementptr inbounds i8, ptr %0, i64 4
  %565 = load i32, ptr %564, align 4, !tbaa !11
  %566 = add nsw i32 %565, 1
  store i32 %566, ptr %564, align 4, !tbaa !11
  %567 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 369)
  %568 = fpext float %560 to double
  %569 = fpext float %561 to double
  %570 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.500000e+00, double noundef %568, double noundef %569)
  %.pre627 = load i32, ptr %0, align 4, !tbaa !8
  br label %571

571:                                              ; preds = %556, %563
  %572 = phi i32 [ %558, %556 ], [ %.pre627, %563 ]
  %573 = add nsw i32 %572, 1
  store i32 %573, ptr %0, align 4, !tbaa !8
  %574 = getelementptr inbounds i8, ptr %4, i64 20
  %575 = load float, ptr %574, align 4, !tbaa !5
  %576 = fadd float %575, -3.000000e+00
  %577 = call float @llvm.fabs.f32(float %576)
  %or.cond75 = fcmp ogt float %577, 0x3E80000000000000
  br i1 %or.cond75, label %578, label %586

578:                                              ; preds = %571
  %579 = getelementptr inbounds i8, ptr %0, i64 4
  %580 = load i32, ptr %579, align 4, !tbaa !11
  %581 = add nsw i32 %580, 1
  store i32 %581, ptr %579, align 4, !tbaa !11
  %582 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 370)
  %583 = fpext float %575 to double
  %584 = fpext float %576 to double
  %585 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+00, double noundef %583, double noundef %584)
  %.pre628 = load i32, ptr %0, align 4, !tbaa !8
  br label %586

586:                                              ; preds = %571, %578
  %587 = phi i32 [ %573, %571 ], [ %.pre628, %578 ]
  %588 = add nsw i32 %587, 1
  store i32 %588, ptr %0, align 4, !tbaa !8
  %589 = getelementptr inbounds i8, ptr %4, i64 24
  %590 = load float, ptr %589, align 8, !tbaa !5
  %591 = fadd float %590, -3.500000e+00
  %592 = call float @llvm.fabs.f32(float %591)
  %or.cond77 = fcmp ogt float %592, 0x3E80000000000000
  br i1 %or.cond77, label %593, label %601

593:                                              ; preds = %586
  %594 = getelementptr inbounds i8, ptr %0, i64 4
  %595 = load i32, ptr %594, align 4, !tbaa !11
  %596 = add nsw i32 %595, 1
  store i32 %596, ptr %594, align 4, !tbaa !11
  %597 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 371)
  %598 = fpext float %590 to double
  %599 = fpext float %591 to double
  %600 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.500000e+00, double noundef %598, double noundef %599)
  %.pre629 = load i32, ptr %0, align 4, !tbaa !8
  br label %601

601:                                              ; preds = %586, %593
  %602 = phi i32 [ %588, %586 ], [ %.pre629, %593 ]
  %603 = add nsw i32 %602, 1
  store i32 %603, ptr %0, align 4, !tbaa !8
  %604 = getelementptr inbounds i8, ptr %4, i64 28
  %605 = load float, ptr %604, align 4, !tbaa !5
  %606 = fadd float %605, -4.000000e+00
  %607 = call float @llvm.fabs.f32(float %606)
  %or.cond79 = fcmp ogt float %607, 0x3E80000000000000
  br i1 %or.cond79, label %608, label %616

608:                                              ; preds = %601
  %609 = getelementptr inbounds i8, ptr %0, i64 4
  %610 = load i32, ptr %609, align 4, !tbaa !11
  %611 = add nsw i32 %610, 1
  store i32 %611, ptr %609, align 4, !tbaa !11
  %612 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 372)
  %613 = fpext float %605 to double
  %614 = fpext float %606 to double
  %615 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+00, double noundef %613, double noundef %614)
  %.pre630 = load i32, ptr %0, align 4, !tbaa !8
  br label %616

616:                                              ; preds = %601, %608
  %617 = phi i32 [ %603, %601 ], [ %.pre630, %608 ]
  %618 = add nsw i32 %617, 1
  store i32 %618, ptr %0, align 4, !tbaa !8
  %619 = getelementptr inbounds i8, ptr %4, i64 32
  %620 = load float, ptr %619, align 16, !tbaa !5
  %621 = fadd float %620, -4.500000e+00
  %622 = call float @llvm.fabs.f32(float %621)
  %or.cond81 = fcmp ogt float %622, 0x3E80000000000000
  br i1 %or.cond81, label %623, label %631

623:                                              ; preds = %616
  %624 = getelementptr inbounds i8, ptr %0, i64 4
  %625 = load i32, ptr %624, align 4, !tbaa !11
  %626 = add nsw i32 %625, 1
  store i32 %626, ptr %624, align 4, !tbaa !11
  %627 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 373)
  %628 = fpext float %620 to double
  %629 = fpext float %621 to double
  %630 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.500000e+00, double noundef %628, double noundef %629)
  %.pre631 = load i32, ptr %0, align 4, !tbaa !8
  br label %631

631:                                              ; preds = %616, %623
  %632 = phi i32 [ %618, %616 ], [ %.pre631, %623 ]
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %0, align 4, !tbaa !8
  %634 = getelementptr inbounds i8, ptr %4, i64 36
  %635 = load float, ptr %634, align 4, !tbaa !5
  %636 = fadd float %635, -5.000000e+00
  %637 = call float @llvm.fabs.f32(float %636)
  %or.cond83 = fcmp ogt float %637, 0x3E80000000000000
  br i1 %or.cond83, label %638, label %646

638:                                              ; preds = %631
  %639 = getelementptr inbounds i8, ptr %0, i64 4
  %640 = load i32, ptr %639, align 4, !tbaa !11
  %641 = add nsw i32 %640, 1
  store i32 %641, ptr %639, align 4, !tbaa !11
  %642 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 374)
  %643 = fpext float %635 to double
  %644 = fpext float %636 to double
  %645 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e+00, double noundef %643, double noundef %644)
  %.pre632 = load i32, ptr %0, align 4, !tbaa !8
  br label %646

646:                                              ; preds = %631, %638
  %647 = phi i32 [ %633, %631 ], [ %.pre632, %638 ]
  %648 = add nsw i32 %647, 1
  store i32 %648, ptr %0, align 4, !tbaa !8
  %649 = getelementptr inbounds i8, ptr %4, i64 40
  %650 = load float, ptr %649, align 8, !tbaa !5
  %651 = fadd float %650, -5.500000e+00
  %652 = call float @llvm.fabs.f32(float %651)
  %or.cond85 = fcmp ogt float %652, 0x3E80000000000000
  br i1 %or.cond85, label %653, label %661

653:                                              ; preds = %646
  %654 = getelementptr inbounds i8, ptr %0, i64 4
  %655 = load i32, ptr %654, align 4, !tbaa !11
  %656 = add nsw i32 %655, 1
  store i32 %656, ptr %654, align 4, !tbaa !11
  %657 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 375)
  %658 = fpext float %650 to double
  %659 = fpext float %651 to double
  %660 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.500000e+00, double noundef %658, double noundef %659)
  %.pre633 = load i32, ptr %0, align 4, !tbaa !8
  br label %661

661:                                              ; preds = %646, %653
  %662 = phi i32 [ %648, %646 ], [ %.pre633, %653 ]
  %663 = add nsw i32 %662, 1
  store i32 %663, ptr %0, align 4, !tbaa !8
  %664 = getelementptr inbounds i8, ptr %4, i64 44
  %665 = load float, ptr %664, align 4, !tbaa !5
  %666 = fadd float %665, -6.000000e+00
  %667 = call float @llvm.fabs.f32(float %666)
  %or.cond87 = fcmp ogt float %667, 0x3E80000000000000
  br i1 %or.cond87, label %668, label %676

668:                                              ; preds = %661
  %669 = getelementptr inbounds i8, ptr %0, i64 4
  %670 = load i32, ptr %669, align 4, !tbaa !11
  %671 = add nsw i32 %670, 1
  store i32 %671, ptr %669, align 4, !tbaa !11
  %672 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 376)
  %673 = fpext float %665 to double
  %674 = fpext float %666 to double
  %675 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.000000e+00, double noundef %673, double noundef %674)
  %.pre634 = load i32, ptr %0, align 4, !tbaa !8
  br label %676

676:                                              ; preds = %661, %668
  %677 = phi i32 [ %663, %661 ], [ %.pre634, %668 ]
  %678 = add nsw i32 %677, 1
  store i32 %678, ptr %0, align 4, !tbaa !8
  %679 = getelementptr inbounds i8, ptr %4, i64 48
  %680 = load float, ptr %679, align 16, !tbaa !5
  %681 = fadd float %680, -6.500000e+00
  %682 = call float @llvm.fabs.f32(float %681)
  %or.cond89 = fcmp ogt float %682, 0x3E80000000000000
  br i1 %or.cond89, label %683, label %691

683:                                              ; preds = %676
  %684 = getelementptr inbounds i8, ptr %0, i64 4
  %685 = load i32, ptr %684, align 4, !tbaa !11
  %686 = add nsw i32 %685, 1
  store i32 %686, ptr %684, align 4, !tbaa !11
  %687 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 377)
  %688 = fpext float %680 to double
  %689 = fpext float %681 to double
  %690 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+00, double noundef %688, double noundef %689)
  %.pre635 = load i32, ptr %0, align 4, !tbaa !8
  br label %691

691:                                              ; preds = %676, %683
  %692 = phi i32 [ %678, %676 ], [ %.pre635, %683 ]
  %693 = add nsw i32 %692, 1
  store i32 %693, ptr %0, align 4, !tbaa !8
  %694 = getelementptr inbounds i8, ptr %4, i64 52
  %695 = load float, ptr %694, align 4, !tbaa !5
  %696 = fadd float %695, -7.000000e+00
  %697 = call float @llvm.fabs.f32(float %696)
  %or.cond91 = fcmp ogt float %697, 0x3E80000000000000
  br i1 %or.cond91, label %698, label %706

698:                                              ; preds = %691
  %699 = getelementptr inbounds i8, ptr %0, i64 4
  %700 = load i32, ptr %699, align 4, !tbaa !11
  %701 = add nsw i32 %700, 1
  store i32 %701, ptr %699, align 4, !tbaa !11
  %702 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 378)
  %703 = fpext float %695 to double
  %704 = fpext float %696 to double
  %705 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.000000e+00, double noundef %703, double noundef %704)
  %.pre636 = load i32, ptr %0, align 4, !tbaa !8
  br label %706

706:                                              ; preds = %691, %698
  %707 = phi i32 [ %693, %691 ], [ %.pre636, %698 ]
  %708 = add nsw i32 %707, 1
  store i32 %708, ptr %0, align 4, !tbaa !8
  %709 = getelementptr inbounds i8, ptr %4, i64 56
  %710 = load float, ptr %709, align 8, !tbaa !5
  %711 = fadd float %710, -7.500000e+00
  %712 = call float @llvm.fabs.f32(float %711)
  %or.cond93 = fcmp ogt float %712, 0x3E80000000000000
  br i1 %or.cond93, label %713, label %721

713:                                              ; preds = %706
  %714 = getelementptr inbounds i8, ptr %0, i64 4
  %715 = load i32, ptr %714, align 4, !tbaa !11
  %716 = add nsw i32 %715, 1
  store i32 %716, ptr %714, align 4, !tbaa !11
  %717 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 379)
  %718 = fpext float %710 to double
  %719 = fpext float %711 to double
  %720 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.500000e+00, double noundef %718, double noundef %719)
  %.pre637 = load i32, ptr %0, align 4, !tbaa !8
  br label %721

721:                                              ; preds = %706, %713
  %722 = phi i32 [ %708, %706 ], [ %.pre637, %713 ]
  %723 = add nsw i32 %722, 1
  store i32 %723, ptr %0, align 4, !tbaa !8
  %724 = getelementptr inbounds i8, ptr %4, i64 60
  %725 = load float, ptr %724, align 4, !tbaa !5
  %726 = fadd float %725, -8.000000e+00
  %727 = call float @llvm.fabs.f32(float %726)
  %or.cond95 = fcmp ogt float %727, 0x3E80000000000000
  br i1 %or.cond95, label %728, label %736

728:                                              ; preds = %721
  %729 = getelementptr inbounds i8, ptr %0, i64 4
  %730 = load i32, ptr %729, align 4, !tbaa !11
  %731 = add nsw i32 %730, 1
  store i32 %731, ptr %729, align 4, !tbaa !11
  %732 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 380)
  %733 = fpext float %725 to double
  %734 = fpext float %726 to double
  %735 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.000000e+00, double noundef %733, double noundef %734)
  br label %736

736:                                              ; preds = %721, %728
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #6
  %737 = call noundef nonnull align 16 dereferenceable(64) ptr @_ZdVR8HMM_Mat4f(ptr noundef nonnull align 16 dereferenceable(64) %1, float noundef 2.000000e+00)
  %738 = load i32, ptr %0, align 4, !tbaa !8
  %739 = add nsw i32 %738, 1
  store i32 %739, ptr %0, align 4, !tbaa !8
  %740 = load float, ptr %1, align 16, !tbaa !5
  %741 = fadd float %740, -5.000000e-01
  %742 = call float @llvm.fabs.f32(float %741)
  %or.cond97 = fcmp ogt float %742, 0x3E80000000000000
  br i1 %or.cond97, label %743, label %751

743:                                              ; preds = %736
  %744 = getelementptr inbounds i8, ptr %0, i64 4
  %745 = load i32, ptr %744, align 4, !tbaa !11
  %746 = add nsw i32 %745, 1
  store i32 %746, ptr %744, align 4, !tbaa !11
  %747 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 384)
  %748 = fpext float %740 to double
  %749 = fpext float %741 to double
  %750 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e-01, double noundef %748, double noundef %749)
  %.pre638 = load i32, ptr %0, align 4, !tbaa !8
  br label %751

751:                                              ; preds = %736, %743
  %752 = phi i32 [ %739, %736 ], [ %.pre638, %743 ]
  %753 = add nsw i32 %752, 1
  store i32 %753, ptr %0, align 4, !tbaa !8
  %754 = load float, ptr %5, align 4, !tbaa !5
  %755 = fadd float %754, -1.000000e+00
  %756 = call float @llvm.fabs.f32(float %755)
  %or.cond99 = fcmp ogt float %756, 0x3E80000000000000
  br i1 %or.cond99, label %757, label %765

757:                                              ; preds = %751
  %758 = getelementptr inbounds i8, ptr %0, i64 4
  %759 = load i32, ptr %758, align 4, !tbaa !11
  %760 = add nsw i32 %759, 1
  store i32 %760, ptr %758, align 4, !tbaa !11
  %761 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 385)
  %762 = fpext float %754 to double
  %763 = fpext float %755 to double
  %764 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+00, double noundef %762, double noundef %763)
  %.pre639 = load i32, ptr %0, align 4, !tbaa !8
  br label %765

765:                                              ; preds = %751, %757
  %766 = phi i32 [ %753, %751 ], [ %.pre639, %757 ]
  %767 = add nsw i32 %766, 1
  store i32 %767, ptr %0, align 4, !tbaa !8
  %768 = load float, ptr %6, align 8, !tbaa !5
  %769 = fadd float %768, -1.500000e+00
  %770 = call float @llvm.fabs.f32(float %769)
  %or.cond101 = fcmp ogt float %770, 0x3E80000000000000
  br i1 %or.cond101, label %771, label %779

771:                                              ; preds = %765
  %772 = getelementptr inbounds i8, ptr %0, i64 4
  %773 = load i32, ptr %772, align 4, !tbaa !11
  %774 = add nsw i32 %773, 1
  store i32 %774, ptr %772, align 4, !tbaa !11
  %775 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 386)
  %776 = fpext float %768 to double
  %777 = fpext float %769 to double
  %778 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.500000e+00, double noundef %776, double noundef %777)
  %.pre640 = load i32, ptr %0, align 4, !tbaa !8
  br label %779

779:                                              ; preds = %765, %771
  %780 = phi i32 [ %767, %765 ], [ %.pre640, %771 ]
  %781 = add nsw i32 %780, 1
  store i32 %781, ptr %0, align 4, !tbaa !8
  %782 = load float, ptr %7, align 4, !tbaa !5
  %783 = fadd float %782, -2.000000e+00
  %784 = call float @llvm.fabs.f32(float %783)
  %or.cond103 = fcmp ogt float %784, 0x3E80000000000000
  br i1 %or.cond103, label %785, label %793

785:                                              ; preds = %779
  %786 = getelementptr inbounds i8, ptr %0, i64 4
  %787 = load i32, ptr %786, align 4, !tbaa !11
  %788 = add nsw i32 %787, 1
  store i32 %788, ptr %786, align 4, !tbaa !11
  %789 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 387)
  %790 = fpext float %782 to double
  %791 = fpext float %783 to double
  %792 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+00, double noundef %790, double noundef %791)
  %.pre641 = load i32, ptr %0, align 4, !tbaa !8
  br label %793

793:                                              ; preds = %779, %785
  %794 = phi i32 [ %781, %779 ], [ %.pre641, %785 ]
  %795 = add nsw i32 %794, 1
  store i32 %795, ptr %0, align 4, !tbaa !8
  %796 = load float, ptr %8, align 16, !tbaa !5
  %797 = fadd float %796, -2.500000e+00
  %798 = call float @llvm.fabs.f32(float %797)
  %or.cond105 = fcmp ogt float %798, 0x3E80000000000000
  br i1 %or.cond105, label %799, label %807

799:                                              ; preds = %793
  %800 = getelementptr inbounds i8, ptr %0, i64 4
  %801 = load i32, ptr %800, align 4, !tbaa !11
  %802 = add nsw i32 %801, 1
  store i32 %802, ptr %800, align 4, !tbaa !11
  %803 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 388)
  %804 = fpext float %796 to double
  %805 = fpext float %797 to double
  %806 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.500000e+00, double noundef %804, double noundef %805)
  %.pre642 = load i32, ptr %0, align 4, !tbaa !8
  br label %807

807:                                              ; preds = %793, %799
  %808 = phi i32 [ %795, %793 ], [ %.pre642, %799 ]
  %809 = add nsw i32 %808, 1
  store i32 %809, ptr %0, align 4, !tbaa !8
  %810 = load float, ptr %9, align 4, !tbaa !5
  %811 = fadd float %810, -3.000000e+00
  %812 = call float @llvm.fabs.f32(float %811)
  %or.cond107 = fcmp ogt float %812, 0x3E80000000000000
  br i1 %or.cond107, label %813, label %821

813:                                              ; preds = %807
  %814 = getelementptr inbounds i8, ptr %0, i64 4
  %815 = load i32, ptr %814, align 4, !tbaa !11
  %816 = add nsw i32 %815, 1
  store i32 %816, ptr %814, align 4, !tbaa !11
  %817 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 389)
  %818 = fpext float %810 to double
  %819 = fpext float %811 to double
  %820 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+00, double noundef %818, double noundef %819)
  %.pre643 = load i32, ptr %0, align 4, !tbaa !8
  br label %821

821:                                              ; preds = %807, %813
  %822 = phi i32 [ %809, %807 ], [ %.pre643, %813 ]
  %823 = add nsw i32 %822, 1
  store i32 %823, ptr %0, align 4, !tbaa !8
  %824 = load float, ptr %10, align 8, !tbaa !5
  %825 = fadd float %824, -3.500000e+00
  %826 = call float @llvm.fabs.f32(float %825)
  %or.cond109 = fcmp ogt float %826, 0x3E80000000000000
  br i1 %or.cond109, label %827, label %835

827:                                              ; preds = %821
  %828 = getelementptr inbounds i8, ptr %0, i64 4
  %829 = load i32, ptr %828, align 4, !tbaa !11
  %830 = add nsw i32 %829, 1
  store i32 %830, ptr %828, align 4, !tbaa !11
  %831 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 390)
  %832 = fpext float %824 to double
  %833 = fpext float %825 to double
  %834 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.500000e+00, double noundef %832, double noundef %833)
  %.pre644 = load i32, ptr %0, align 4, !tbaa !8
  br label %835

835:                                              ; preds = %821, %827
  %836 = phi i32 [ %823, %821 ], [ %.pre644, %827 ]
  %837 = add nsw i32 %836, 1
  store i32 %837, ptr %0, align 4, !tbaa !8
  %838 = load float, ptr %11, align 4, !tbaa !5
  %839 = fadd float %838, -4.000000e+00
  %840 = call float @llvm.fabs.f32(float %839)
  %or.cond111 = fcmp ogt float %840, 0x3E80000000000000
  br i1 %or.cond111, label %841, label %849

841:                                              ; preds = %835
  %842 = getelementptr inbounds i8, ptr %0, i64 4
  %843 = load i32, ptr %842, align 4, !tbaa !11
  %844 = add nsw i32 %843, 1
  store i32 %844, ptr %842, align 4, !tbaa !11
  %845 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 391)
  %846 = fpext float %838 to double
  %847 = fpext float %839 to double
  %848 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+00, double noundef %846, double noundef %847)
  %.pre645 = load i32, ptr %0, align 4, !tbaa !8
  br label %849

849:                                              ; preds = %835, %841
  %850 = phi i32 [ %837, %835 ], [ %.pre645, %841 ]
  %851 = add nsw i32 %850, 1
  store i32 %851, ptr %0, align 4, !tbaa !8
  %852 = load float, ptr %12, align 16, !tbaa !5
  %853 = fadd float %852, -4.500000e+00
  %854 = call float @llvm.fabs.f32(float %853)
  %or.cond113 = fcmp ogt float %854, 0x3E80000000000000
  br i1 %or.cond113, label %855, label %863

855:                                              ; preds = %849
  %856 = getelementptr inbounds i8, ptr %0, i64 4
  %857 = load i32, ptr %856, align 4, !tbaa !11
  %858 = add nsw i32 %857, 1
  store i32 %858, ptr %856, align 4, !tbaa !11
  %859 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 392)
  %860 = fpext float %852 to double
  %861 = fpext float %853 to double
  %862 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.500000e+00, double noundef %860, double noundef %861)
  %.pre646 = load i32, ptr %0, align 4, !tbaa !8
  br label %863

863:                                              ; preds = %849, %855
  %864 = phi i32 [ %851, %849 ], [ %.pre646, %855 ]
  %865 = add nsw i32 %864, 1
  store i32 %865, ptr %0, align 4, !tbaa !8
  %866 = load float, ptr %13, align 4, !tbaa !5
  %867 = fadd float %866, -5.000000e+00
  %868 = call float @llvm.fabs.f32(float %867)
  %or.cond115 = fcmp ogt float %868, 0x3E80000000000000
  br i1 %or.cond115, label %869, label %877

869:                                              ; preds = %863
  %870 = getelementptr inbounds i8, ptr %0, i64 4
  %871 = load i32, ptr %870, align 4, !tbaa !11
  %872 = add nsw i32 %871, 1
  store i32 %872, ptr %870, align 4, !tbaa !11
  %873 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 393)
  %874 = fpext float %866 to double
  %875 = fpext float %867 to double
  %876 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.000000e+00, double noundef %874, double noundef %875)
  %.pre647 = load i32, ptr %0, align 4, !tbaa !8
  br label %877

877:                                              ; preds = %863, %869
  %878 = phi i32 [ %865, %863 ], [ %.pre647, %869 ]
  %879 = add nsw i32 %878, 1
  store i32 %879, ptr %0, align 4, !tbaa !8
  %880 = load float, ptr %14, align 8, !tbaa !5
  %881 = fadd float %880, -5.500000e+00
  %882 = call float @llvm.fabs.f32(float %881)
  %or.cond117 = fcmp ogt float %882, 0x3E80000000000000
  br i1 %or.cond117, label %883, label %891

883:                                              ; preds = %877
  %884 = getelementptr inbounds i8, ptr %0, i64 4
  %885 = load i32, ptr %884, align 4, !tbaa !11
  %886 = add nsw i32 %885, 1
  store i32 %886, ptr %884, align 4, !tbaa !11
  %887 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 394)
  %888 = fpext float %880 to double
  %889 = fpext float %881 to double
  %890 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.500000e+00, double noundef %888, double noundef %889)
  %.pre648 = load i32, ptr %0, align 4, !tbaa !8
  br label %891

891:                                              ; preds = %877, %883
  %892 = phi i32 [ %879, %877 ], [ %.pre648, %883 ]
  %893 = add nsw i32 %892, 1
  store i32 %893, ptr %0, align 4, !tbaa !8
  %894 = load float, ptr %15, align 4, !tbaa !5
  %895 = fadd float %894, -6.000000e+00
  %896 = call float @llvm.fabs.f32(float %895)
  %or.cond119 = fcmp ogt float %896, 0x3E80000000000000
  br i1 %or.cond119, label %897, label %905

897:                                              ; preds = %891
  %898 = getelementptr inbounds i8, ptr %0, i64 4
  %899 = load i32, ptr %898, align 4, !tbaa !11
  %900 = add nsw i32 %899, 1
  store i32 %900, ptr %898, align 4, !tbaa !11
  %901 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 395)
  %902 = fpext float %894 to double
  %903 = fpext float %895 to double
  %904 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.000000e+00, double noundef %902, double noundef %903)
  %.pre649 = load i32, ptr %0, align 4, !tbaa !8
  br label %905

905:                                              ; preds = %891, %897
  %906 = phi i32 [ %893, %891 ], [ %.pre649, %897 ]
  %907 = add nsw i32 %906, 1
  store i32 %907, ptr %0, align 4, !tbaa !8
  %908 = load float, ptr %16, align 16, !tbaa !5
  %909 = fadd float %908, -6.500000e+00
  %910 = call float @llvm.fabs.f32(float %909)
  %or.cond121 = fcmp ogt float %910, 0x3E80000000000000
  br i1 %or.cond121, label %911, label %919

911:                                              ; preds = %905
  %912 = getelementptr inbounds i8, ptr %0, i64 4
  %913 = load i32, ptr %912, align 4, !tbaa !11
  %914 = add nsw i32 %913, 1
  store i32 %914, ptr %912, align 4, !tbaa !11
  %915 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 396)
  %916 = fpext float %908 to double
  %917 = fpext float %909 to double
  %918 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+00, double noundef %916, double noundef %917)
  %.pre650 = load i32, ptr %0, align 4, !tbaa !8
  br label %919

919:                                              ; preds = %905, %911
  %920 = phi i32 [ %907, %905 ], [ %.pre650, %911 ]
  %921 = add nsw i32 %920, 1
  store i32 %921, ptr %0, align 4, !tbaa !8
  %922 = load float, ptr %17, align 4, !tbaa !5
  %923 = fadd float %922, -7.000000e+00
  %924 = call float @llvm.fabs.f32(float %923)
  %or.cond123 = fcmp ogt float %924, 0x3E80000000000000
  br i1 %or.cond123, label %925, label %933

925:                                              ; preds = %919
  %926 = getelementptr inbounds i8, ptr %0, i64 4
  %927 = load i32, ptr %926, align 4, !tbaa !11
  %928 = add nsw i32 %927, 1
  store i32 %928, ptr %926, align 4, !tbaa !11
  %929 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 397)
  %930 = fpext float %922 to double
  %931 = fpext float %923 to double
  %932 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.000000e+00, double noundef %930, double noundef %931)
  %.pre651 = load i32, ptr %0, align 4, !tbaa !8
  br label %933

933:                                              ; preds = %919, %925
  %934 = phi i32 [ %921, %919 ], [ %.pre651, %925 ]
  %935 = add nsw i32 %934, 1
  store i32 %935, ptr %0, align 4, !tbaa !8
  %936 = load float, ptr %18, align 8, !tbaa !5
  %937 = fadd float %936, -7.500000e+00
  %938 = call float @llvm.fabs.f32(float %937)
  %or.cond125 = fcmp ogt float %938, 0x3E80000000000000
  br i1 %or.cond125, label %939, label %947

939:                                              ; preds = %933
  %940 = getelementptr inbounds i8, ptr %0, i64 4
  %941 = load i32, ptr %940, align 4, !tbaa !11
  %942 = add nsw i32 %941, 1
  store i32 %942, ptr %940, align 4, !tbaa !11
  %943 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 398)
  %944 = fpext float %936 to double
  %945 = fpext float %937 to double
  %946 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.500000e+00, double noundef %944, double noundef %945)
  %.pre652 = load i32, ptr %0, align 4, !tbaa !8
  br label %947

947:                                              ; preds = %933, %939
  %948 = phi i32 [ %935, %933 ], [ %.pre652, %939 ]
  %949 = add nsw i32 %948, 1
  store i32 %949, ptr %0, align 4, !tbaa !8
  %950 = load float, ptr %19, align 4, !tbaa !5
  %951 = fadd float %950, -8.000000e+00
  %952 = call float @llvm.fabs.f32(float %951)
  %or.cond127 = fcmp ogt float %952, 0x3E80000000000000
  br i1 %or.cond127, label %953, label %961

953:                                              ; preds = %947
  %954 = getelementptr inbounds i8, ptr %0, i64 4
  %955 = load i32, ptr %954, align 4, !tbaa !11
  %956 = add nsw i32 %955, 1
  store i32 %956, ptr %954, align 4, !tbaa !11
  %957 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 399)
  %958 = fpext float %950 to double
  %959 = fpext float %951 to double
  %960 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.000000e+00, double noundef %958, double noundef %959)
  br label %961

961:                                              ; preds = %947, %953
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %1) #6
  ret void
}

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL10HMM_DivM4F8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) local_unnamed_addr #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL7HMM_Div8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_Zdv8HMM_Mat4f(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, float noundef) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef nonnull align 16 dereferenceable(64) ptr @_ZdVR8HMM_Mat4f(ptr noundef nonnull align 16 dereferenceable(64), float noundef) local_unnamed_addr #2

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { inlinehint mustprogress 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 = { mustprogress 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 #4 = { inlinehint mustprogress uwtable "min-legal-vector-width"="128" "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 #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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C++ TBAA"}
!8 = !{!9, !10, i64 0}
!9 = !{!"_ZTS21hmt_testresult_struct", !10, i64 0, !10, i64 4}
!10 = !{!"int", !6, i64 0}
!11 = !{!9, !10, i64 4}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,MemCpyOptPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass