; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z33_hmt_test_Multiplication_Mat4Mat4P21hmt_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: inlinehint mustprogress uwtable
declare hidden void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16) #3

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z33_hmt_test_Multiplication_Mat4Mat4P21hmt_testresult_struct(ptr noundef %0) #4 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca %union.HMM_Mat4, align 16
  %12 = alloca %union.HMM_Mat4, align 16
  %13 = alloca %union.HMM_Mat4, align 16
  %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 float, align 4
  %44 = alloca float, align 4
  %45 = alloca float, align 4
  %46 = alloca %union.HMM_Mat4, align 16
  %47 = alloca %union.HMM_Mat4, align 16
  %48 = alloca %union.HMM_Mat4, align 16
  %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 float, align 4
  %78 = alloca float, align 4
  %79 = alloca float, align 4
  %80 = alloca float, align 4
  %81 = alloca %union.HMM_Mat4, align 16
  %82 = alloca %union.HMM_Mat4, align 16
  %83 = alloca %union.HMM_Mat4, align 16
  %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
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %3) #5
  call void @_ZL6HMM_M4v(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %3)
  call void @llvm.lifetime.start.p0(i64 64, ptr %4) #5
  call void @_ZL6HMM_M4v(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %4)
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #5
  store i32 1, ptr %5, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #5
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %116

116:                                              ; preds = %140, %1
  %117 = load i32, ptr %6, align 4, !tbaa !9
  %118 = icmp slt i32 %117, 4
  br i1 %118, label %120, label %119

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

120:                                              ; preds = %116
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #5
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %121

121:                                              ; preds = %136, %120
  %122 = load i32, ptr %8, align 4, !tbaa !9
  %123 = icmp slt i32 %122, 4
  br i1 %123, label %125, label %124

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

125:                                              ; preds = %121
  %126 = load i32, ptr %5, align 4, !tbaa !9
  %127 = sitofp i32 %126 to float
  %128 = load i32, ptr %6, align 4, !tbaa !9
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds [4 x [4 x float]], ptr %3, i64 0, i64 %129
  %131 = load i32, ptr %8, align 4, !tbaa !9
  %132 = sext i32 %131 to i64
  %133 = getelementptr inbounds [4 x float], ptr %130, i64 0, i64 %132
  store float %127, ptr %133, align 4, !tbaa !11
  %134 = load i32, ptr %5, align 4, !tbaa !9
  %135 = add nsw i32 %134, 1
  store i32 %135, ptr %5, align 4, !tbaa !9
  br label %136

136:                                              ; preds = %125
  %137 = load i32, ptr %8, align 4, !tbaa !9
  %138 = add nsw i32 %137, 1
  store i32 %138, ptr %8, align 4, !tbaa !9
  br label %121, !llvm.loop !12

139:                                              ; preds = %124
  br label %140

140:                                              ; preds = %139
  %141 = load i32, ptr %6, align 4, !tbaa !9
  %142 = add nsw i32 %141, 1
  store i32 %142, ptr %6, align 4, !tbaa !9
  br label %116, !llvm.loop !14

143:                                              ; preds = %119
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  store i32 0, ptr %9, align 4, !tbaa !9
  br label %144

144:                                              ; preds = %168, %143
  %145 = load i32, ptr %9, align 4, !tbaa !9
  %146 = icmp slt i32 %145, 4
  br i1 %146, label %148, label %147

147:                                              ; preds = %144
  store i32 8, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  br label %171

148:                                              ; preds = %144
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  store i32 0, ptr %10, align 4, !tbaa !9
  br label %149

149:                                              ; preds = %164, %148
  %150 = load i32, ptr %10, align 4, !tbaa !9
  %151 = icmp slt i32 %150, 4
  br i1 %151, label %153, label %152

152:                                              ; preds = %149
  store i32 11, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  br label %167

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

164:                                              ; preds = %153
  %165 = load i32, ptr %10, align 4, !tbaa !9
  %166 = add nsw i32 %165, 1
  store i32 %166, ptr %10, align 4, !tbaa !9
  br label %149, !llvm.loop !15

167:                                              ; preds = %152
  br label %168

168:                                              ; preds = %167
  %169 = load i32, ptr %9, align 4, !tbaa !9
  %170 = add nsw i32 %169, 1
  store i32 %170, ptr %9, align 4, !tbaa !9
  br label %144, !llvm.loop !16

171:                                              ; preds = %147
  call void @llvm.lifetime.start.p0(i64 64, ptr %11) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %12, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %13, ptr align 16 %4, i64 64, i1 false), !tbaa.struct !17
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %11, ptr noundef byval(%union.HMM_Mat4) align 16 %12, ptr noundef byval(%union.HMM_Mat4) align 16 %13)
  %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 %14) #5
  %176 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 0
  %177 = getelementptr inbounds [4 x float], ptr %176, i64 0, i64 0
  %178 = load float, ptr %177, align 16, !tbaa !11
  store float %178, ptr %14, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #5
  %179 = load float, ptr %14, align 4, !tbaa !20
  %180 = fsub float %179, 5.380000e+02
  store float %180, ptr %15, align 4, !tbaa !20
  %181 = load float, ptr %15, align 4, !tbaa !20
  %182 = fcmp olt float %181, 0xBE80000000000000
  br i1 %182, label %186, label %183

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

186:                                              ; preds = %183, %171
  %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 !22
  %190 = add nsw i32 %189, 1
  store i32 %190, ptr %188, align 4, !tbaa !22
  %191 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 561)
  %192 = load float, ptr %14, align 4, !tbaa !20
  %193 = fpext float %192 to double
  %194 = load float, ptr %15, align 4, !tbaa !20
  %195 = fpext float %194 to double
  %196 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.380000e+02, double noundef %193, double noundef %195)
  br label %197

197:                                              ; preds = %186, %183
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #5
  %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 %16) #5
  %202 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 0
  %203 = getelementptr inbounds [4 x float], ptr %202, i64 0, i64 1
  %204 = load float, ptr %203, align 4, !tbaa !11
  store float %204, ptr %16, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #5
  %205 = load float, ptr %16, align 4, !tbaa !20
  %206 = fsub float %205, 6.120000e+02
  store float %206, ptr %17, align 4, !tbaa !20
  %207 = load float, ptr %17, align 4, !tbaa !20
  %208 = fcmp olt float %207, 0xBE80000000000000
  br i1 %208, label %212, label %209

209:                                              ; preds = %197
  %210 = load float, ptr %17, align 4, !tbaa !20
  %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 !22
  %216 = add nsw i32 %215, 1
  store i32 %216, ptr %214, align 4, !tbaa !22
  %217 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 562)
  %218 = load float, ptr %16, align 4, !tbaa !20
  %219 = fpext float %218 to double
  %220 = load float, ptr %17, align 4, !tbaa !20
  %221 = fpext float %220 to double
  %222 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.120000e+02, double noundef %219, double noundef %221)
  br label %223

223:                                              ; preds = %212, %209
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #5
  %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 %18) #5
  %228 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 0
  %229 = getelementptr inbounds [4 x float], ptr %228, i64 0, i64 2
  %230 = load float, ptr %229, align 8, !tbaa !11
  store float %230, ptr %18, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #5
  %231 = load float, ptr %18, align 4, !tbaa !20
  %232 = fsub float %231, 6.860000e+02
  store float %232, ptr %19, align 4, !tbaa !20
  %233 = load float, ptr %19, align 4, !tbaa !20
  %234 = fcmp olt float %233, 0xBE80000000000000
  br i1 %234, label %238, label %235

235:                                              ; preds = %223
  %236 = load float, ptr %19, align 4, !tbaa !20
  %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 !22
  %242 = add nsw i32 %241, 1
  store i32 %242, ptr %240, align 4, !tbaa !22
  %243 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 563)
  %244 = load float, ptr %18, align 4, !tbaa !20
  %245 = fpext float %244 to double
  %246 = load float, ptr %19, align 4, !tbaa !20
  %247 = fpext float %246 to double
  %248 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.860000e+02, double noundef %245, double noundef %247)
  br label %249

249:                                              ; preds = %238, %235
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #5
  %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 %20) #5
  %254 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 0
  %255 = getelementptr inbounds [4 x float], ptr %254, i64 0, i64 3
  %256 = load float, ptr %255, align 4, !tbaa !11
  store float %256, ptr %20, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #5
  %257 = load float, ptr %20, align 4, !tbaa !20
  %258 = fsub float %257, 7.600000e+02
  store float %258, ptr %21, align 4, !tbaa !20
  %259 = load float, ptr %21, align 4, !tbaa !20
  %260 = fcmp olt float %259, 0xBE80000000000000
  br i1 %260, label %264, label %261

261:                                              ; preds = %249
  %262 = load float, ptr %21, align 4, !tbaa !20
  %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 !22
  %268 = add nsw i32 %267, 1
  store i32 %268, ptr %266, align 4, !tbaa !22
  %269 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 564)
  %270 = load float, ptr %20, align 4, !tbaa !20
  %271 = fpext float %270 to double
  %272 = load float, ptr %21, align 4, !tbaa !20
  %273 = fpext float %272 to double
  %274 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.600000e+02, double noundef %271, double noundef %273)
  br label %275

275:                                              ; preds = %264, %261
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #5
  %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 %22) #5
  %280 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 1
  %281 = getelementptr inbounds [4 x float], ptr %280, i64 0, i64 0
  %282 = load float, ptr %281, align 16, !tbaa !11
  store float %282, ptr %22, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #5
  %283 = load float, ptr %22, align 4, !tbaa !20
  %284 = fsub float %283, 6.500000e+02
  store float %284, ptr %23, align 4, !tbaa !20
  %285 = load float, ptr %23, align 4, !tbaa !20
  %286 = fcmp olt float %285, 0xBE80000000000000
  br i1 %286, label %290, label %287

287:                                              ; preds = %275
  %288 = load float, ptr %23, align 4, !tbaa !20
  %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 !22
  %294 = add nsw i32 %293, 1
  store i32 %294, ptr %292, align 4, !tbaa !22
  %295 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 565)
  %296 = load float, ptr %22, align 4, !tbaa !20
  %297 = fpext float %296 to double
  %298 = load float, ptr %23, align 4, !tbaa !20
  %299 = fpext float %298 to double
  %300 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+02, double noundef %297, double noundef %299)
  br label %301

301:                                              ; preds = %290, %287
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  %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 %24) #5
  %306 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 1
  %307 = getelementptr inbounds [4 x float], ptr %306, i64 0, i64 1
  %308 = load float, ptr %307, align 4, !tbaa !11
  store float %308, ptr %24, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #5
  %309 = load float, ptr %24, align 4, !tbaa !20
  %310 = fsub float %309, 7.400000e+02
  store float %310, ptr %25, align 4, !tbaa !20
  %311 = load float, ptr %25, align 4, !tbaa !20
  %312 = fcmp olt float %311, 0xBE80000000000000
  br i1 %312, label %316, label %313

313:                                              ; preds = %301
  %314 = load float, ptr %25, align 4, !tbaa !20
  %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 !22
  %320 = add nsw i32 %319, 1
  store i32 %320, ptr %318, align 4, !tbaa !22
  %321 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 566)
  %322 = load float, ptr %24, align 4, !tbaa !20
  %323 = fpext float %322 to double
  %324 = load float, ptr %25, align 4, !tbaa !20
  %325 = fpext float %324 to double
  %326 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.400000e+02, double noundef %323, double noundef %325)
  br label %327

327:                                              ; preds = %316, %313
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #5
  %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 %26) #5
  %332 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 1
  %333 = getelementptr inbounds [4 x float], ptr %332, i64 0, i64 2
  %334 = load float, ptr %333, align 8, !tbaa !11
  store float %334, ptr %26, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #5
  %335 = load float, ptr %26, align 4, !tbaa !20
  %336 = fsub float %335, 8.300000e+02
  store float %336, ptr %27, align 4, !tbaa !20
  %337 = load float, ptr %27, align 4, !tbaa !20
  %338 = fcmp olt float %337, 0xBE80000000000000
  br i1 %338, label %342, label %339

339:                                              ; preds = %327
  %340 = load float, ptr %27, align 4, !tbaa !20
  %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 !22
  %346 = add nsw i32 %345, 1
  store i32 %346, ptr %344, align 4, !tbaa !22
  %347 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 567)
  %348 = load float, ptr %26, align 4, !tbaa !20
  %349 = fpext float %348 to double
  %350 = load float, ptr %27, align 4, !tbaa !20
  %351 = fpext float %350 to double
  %352 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.300000e+02, double noundef %349, double noundef %351)
  br label %353

353:                                              ; preds = %342, %339
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  %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 %28) #5
  %358 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 1
  %359 = getelementptr inbounds [4 x float], ptr %358, i64 0, i64 3
  %360 = load float, ptr %359, align 4, !tbaa !11
  store float %360, ptr %28, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #5
  %361 = load float, ptr %28, align 4, !tbaa !20
  %362 = fsub float %361, 9.200000e+02
  store float %362, ptr %29, align 4, !tbaa !20
  %363 = load float, ptr %29, align 4, !tbaa !20
  %364 = fcmp olt float %363, 0xBE80000000000000
  br i1 %364, label %368, label %365

365:                                              ; preds = %353
  %366 = load float, ptr %29, align 4, !tbaa !20
  %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 !22
  %372 = add nsw i32 %371, 1
  store i32 %372, ptr %370, align 4, !tbaa !22
  %373 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 568)
  %374 = load float, ptr %28, align 4, !tbaa !20
  %375 = fpext float %374 to double
  %376 = load float, ptr %29, align 4, !tbaa !20
  %377 = fpext float %376 to double
  %378 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.200000e+02, double noundef %375, double noundef %377)
  br label %379

379:                                              ; preds = %368, %365
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #5
  %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 %30) #5
  %384 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 2
  %385 = getelementptr inbounds [4 x float], ptr %384, i64 0, i64 0
  %386 = load float, ptr %385, align 16, !tbaa !11
  store float %386, ptr %30, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #5
  %387 = load float, ptr %30, align 4, !tbaa !20
  %388 = fsub float %387, 7.620000e+02
  store float %388, ptr %31, align 4, !tbaa !20
  %389 = load float, ptr %31, align 4, !tbaa !20
  %390 = fcmp olt float %389, 0xBE80000000000000
  br i1 %390, label %394, label %391

391:                                              ; preds = %379
  %392 = load float, ptr %31, align 4, !tbaa !20
  %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 !22
  %398 = add nsw i32 %397, 1
  store i32 %398, ptr %396, align 4, !tbaa !22
  %399 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 569)
  %400 = load float, ptr %30, align 4, !tbaa !20
  %401 = fpext float %400 to double
  %402 = load float, ptr %31, align 4, !tbaa !20
  %403 = fpext float %402 to double
  %404 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.620000e+02, double noundef %401, double noundef %403)
  br label %405

405:                                              ; preds = %394, %391
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #5
  %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 %32) #5
  %410 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 2
  %411 = getelementptr inbounds [4 x float], ptr %410, i64 0, i64 1
  %412 = load float, ptr %411, align 4, !tbaa !11
  store float %412, ptr %32, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #5
  %413 = load float, ptr %32, align 4, !tbaa !20
  %414 = fsub float %413, 8.680000e+02
  store float %414, ptr %33, align 4, !tbaa !20
  %415 = load float, ptr %33, align 4, !tbaa !20
  %416 = fcmp olt float %415, 0xBE80000000000000
  br i1 %416, label %420, label %417

417:                                              ; preds = %405
  %418 = load float, ptr %33, align 4, !tbaa !20
  %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 !22
  %424 = add nsw i32 %423, 1
  store i32 %424, ptr %422, align 4, !tbaa !22
  %425 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 570)
  %426 = load float, ptr %32, align 4, !tbaa !20
  %427 = fpext float %426 to double
  %428 = load float, ptr %33, align 4, !tbaa !20
  %429 = fpext float %428 to double
  %430 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.680000e+02, double noundef %427, double noundef %429)
  br label %431

431:                                              ; preds = %420, %417
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  %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 %34) #5
  %436 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 2
  %437 = getelementptr inbounds [4 x float], ptr %436, i64 0, i64 2
  %438 = load float, ptr %437, align 8, !tbaa !11
  store float %438, ptr %34, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #5
  %439 = load float, ptr %34, align 4, !tbaa !20
  %440 = fsub float %439, 9.740000e+02
  store float %440, ptr %35, align 4, !tbaa !20
  %441 = load float, ptr %35, align 4, !tbaa !20
  %442 = fcmp olt float %441, 0xBE80000000000000
  br i1 %442, label %446, label %443

443:                                              ; preds = %431
  %444 = load float, ptr %35, align 4, !tbaa !20
  %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 !22
  %450 = add nsw i32 %449, 1
  store i32 %450, ptr %448, align 4, !tbaa !22
  %451 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 571)
  %452 = load float, ptr %34, align 4, !tbaa !20
  %453 = fpext float %452 to double
  %454 = load float, ptr %35, align 4, !tbaa !20
  %455 = fpext float %454 to double
  %456 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.740000e+02, double noundef %453, double noundef %455)
  br label %457

457:                                              ; preds = %446, %443
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #5
  %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 %36) #5
  %462 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 2
  %463 = getelementptr inbounds [4 x float], ptr %462, i64 0, i64 3
  %464 = load float, ptr %463, align 4, !tbaa !11
  store float %464, ptr %36, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #5
  %465 = load float, ptr %36, align 4, !tbaa !20
  %466 = fsub float %465, 1.080000e+03
  store float %466, ptr %37, align 4, !tbaa !20
  %467 = load float, ptr %37, align 4, !tbaa !20
  %468 = fcmp olt float %467, 0xBE80000000000000
  br i1 %468, label %472, label %469

469:                                              ; preds = %457
  %470 = load float, ptr %37, align 4, !tbaa !20
  %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 !22
  %476 = add nsw i32 %475, 1
  store i32 %476, ptr %474, align 4, !tbaa !22
  %477 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 572)
  %478 = load float, ptr %36, align 4, !tbaa !20
  %479 = fpext float %478 to double
  %480 = load float, ptr %37, align 4, !tbaa !20
  %481 = fpext float %480 to double
  %482 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.080000e+03, double noundef %479, double noundef %481)
  br label %483

483:                                              ; preds = %472, %469
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #5
  %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 %38) #5
  %488 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 3
  %489 = getelementptr inbounds [4 x float], ptr %488, i64 0, i64 0
  %490 = load float, ptr %489, align 16, !tbaa !11
  store float %490, ptr %38, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #5
  %491 = load float, ptr %38, align 4, !tbaa !20
  %492 = fsub float %491, 8.740000e+02
  store float %492, ptr %39, align 4, !tbaa !20
  %493 = load float, ptr %39, align 4, !tbaa !20
  %494 = fcmp olt float %493, 0xBE80000000000000
  br i1 %494, label %498, label %495

495:                                              ; preds = %483
  %496 = load float, ptr %39, align 4, !tbaa !20
  %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 !22
  %502 = add nsw i32 %501, 1
  store i32 %502, ptr %500, align 4, !tbaa !22
  %503 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 573)
  %504 = load float, ptr %38, align 4, !tbaa !20
  %505 = fpext float %504 to double
  %506 = load float, ptr %39, align 4, !tbaa !20
  %507 = fpext float %506 to double
  %508 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.740000e+02, double noundef %505, double noundef %507)
  br label %509

509:                                              ; preds = %498, %495
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #5
  %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 %40) #5
  %514 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 3
  %515 = getelementptr inbounds [4 x float], ptr %514, i64 0, i64 1
  %516 = load float, ptr %515, align 4, !tbaa !11
  store float %516, ptr %40, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #5
  %517 = load float, ptr %40, align 4, !tbaa !20
  %518 = fsub float %517, 9.960000e+02
  store float %518, ptr %41, align 4, !tbaa !20
  %519 = load float, ptr %41, align 4, !tbaa !20
  %520 = fcmp olt float %519, 0xBE80000000000000
  br i1 %520, label %524, label %521

521:                                              ; preds = %509
  %522 = load float, ptr %41, align 4, !tbaa !20
  %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 !22
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %526, align 4, !tbaa !22
  %529 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 574)
  %530 = load float, ptr %40, align 4, !tbaa !20
  %531 = fpext float %530 to double
  %532 = load float, ptr %41, align 4, !tbaa !20
  %533 = fpext float %532 to double
  %534 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.960000e+02, double noundef %531, double noundef %533)
  br label %535

535:                                              ; preds = %524, %521
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #5
  %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 %42) #5
  %540 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 3
  %541 = getelementptr inbounds [4 x float], ptr %540, i64 0, i64 2
  %542 = load float, ptr %541, align 8, !tbaa !11
  store float %542, ptr %42, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #5
  %543 = load float, ptr %42, align 4, !tbaa !20
  %544 = fsub float %543, 1.118000e+03
  store float %544, ptr %43, align 4, !tbaa !20
  %545 = load float, ptr %43, align 4, !tbaa !20
  %546 = fcmp olt float %545, 0xBE80000000000000
  br i1 %546, label %550, label %547

547:                                              ; preds = %535
  %548 = load float, ptr %43, align 4, !tbaa !20
  %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 !22
  %554 = add nsw i32 %553, 1
  store i32 %554, ptr %552, align 4, !tbaa !22
  %555 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 575)
  %556 = load float, ptr %42, align 4, !tbaa !20
  %557 = fpext float %556 to double
  %558 = load float, ptr %43, align 4, !tbaa !20
  %559 = fpext float %558 to double
  %560 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.118000e+03, double noundef %557, double noundef %559)
  br label %561

561:                                              ; preds = %550, %547
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #5
  %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 %44) #5
  %566 = getelementptr inbounds [4 x [4 x float]], ptr %11, i64 0, i64 3
  %567 = getelementptr inbounds [4 x float], ptr %566, i64 0, i64 3
  %568 = load float, ptr %567, align 4, !tbaa !11
  store float %568, ptr %44, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #5
  %569 = load float, ptr %44, align 4, !tbaa !20
  %570 = fsub float %569, 1.240000e+03
  store float %570, ptr %45, align 4, !tbaa !20
  %571 = load float, ptr %45, align 4, !tbaa !20
  %572 = fcmp olt float %571, 0xBE80000000000000
  br i1 %572, label %576, label %573

573:                                              ; preds = %561
  %574 = load float, ptr %45, align 4, !tbaa !20
  %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 !22
  %580 = add nsw i32 %579, 1
  store i32 %580, ptr %578, align 4, !tbaa !22
  %581 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 576)
  %582 = load float, ptr %44, align 4, !tbaa !20
  %583 = fpext float %582 to double
  %584 = load float, ptr %45, align 4, !tbaa !20
  %585 = fpext float %584 to double
  %586 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.240000e+03, double noundef %583, double noundef %585)
  br label %587

587:                                              ; preds = %576, %573
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %11) #5
  call void @llvm.lifetime.start.p0(i64 64, ptr %46) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %47, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %48, ptr align 16 %4, i64 64, i1 false), !tbaa.struct !17
  call void @_ZL7HMM_Mul8HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %46, ptr noundef byval(%union.HMM_Mat4) align 16 %47, ptr noundef byval(%union.HMM_Mat4) align 16 %48)
  %588 = load ptr, ptr %2, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %588, i32 0, i32 0
  %590 = load i32, ptr %589, align 4, !tbaa !18
  %591 = add nsw i32 %590, 1
  store i32 %591, ptr %589, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #5
  %592 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 0
  %593 = getelementptr inbounds [4 x float], ptr %592, i64 0, i64 0
  %594 = load float, ptr %593, align 16, !tbaa !11
  store float %594, ptr %49, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #5
  %595 = load float, ptr %49, align 4, !tbaa !20
  %596 = fsub float %595, 5.380000e+02
  store float %596, ptr %50, align 4, !tbaa !20
  %597 = load float, ptr %50, align 4, !tbaa !20
  %598 = fcmp olt float %597, 0xBE80000000000000
  br i1 %598, label %602, label %599

599:                                              ; preds = %587
  %600 = load float, ptr %50, align 4, !tbaa !20
  %601 = fcmp olt float 0x3E80000000000000, %600
  br i1 %601, label %602, label %613

602:                                              ; preds = %599, %587
  %603 = load ptr, ptr %2, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %603, i32 0, i32 1
  %605 = load i32, ptr %604, align 4, !tbaa !22
  %606 = add nsw i32 %605, 1
  store i32 %606, ptr %604, align 4, !tbaa !22
  %607 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 581)
  %608 = load float, ptr %49, align 4, !tbaa !20
  %609 = fpext float %608 to double
  %610 = load float, ptr %50, align 4, !tbaa !20
  %611 = fpext float %610 to double
  %612 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.380000e+02, double noundef %609, double noundef %611)
  br label %613

613:                                              ; preds = %602, %599
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #5
  %614 = load ptr, ptr %2, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %614, i32 0, i32 0
  %616 = load i32, ptr %615, align 4, !tbaa !18
  %617 = add nsw i32 %616, 1
  store i32 %617, ptr %615, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #5
  %618 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 0
  %619 = getelementptr inbounds [4 x float], ptr %618, i64 0, i64 1
  %620 = load float, ptr %619, align 4, !tbaa !11
  store float %620, ptr %51, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #5
  %621 = load float, ptr %51, align 4, !tbaa !20
  %622 = fsub float %621, 6.120000e+02
  store float %622, ptr %52, align 4, !tbaa !20
  %623 = load float, ptr %52, align 4, !tbaa !20
  %624 = fcmp olt float %623, 0xBE80000000000000
  br i1 %624, label %628, label %625

625:                                              ; preds = %613
  %626 = load float, ptr %52, align 4, !tbaa !20
  %627 = fcmp olt float 0x3E80000000000000, %626
  br i1 %627, label %628, label %639

628:                                              ; preds = %625, %613
  %629 = load ptr, ptr %2, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %629, i32 0, i32 1
  %631 = load i32, ptr %630, align 4, !tbaa !22
  %632 = add nsw i32 %631, 1
  store i32 %632, ptr %630, align 4, !tbaa !22
  %633 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 582)
  %634 = load float, ptr %51, align 4, !tbaa !20
  %635 = fpext float %634 to double
  %636 = load float, ptr %52, align 4, !tbaa !20
  %637 = fpext float %636 to double
  %638 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.120000e+02, double noundef %635, double noundef %637)
  br label %639

639:                                              ; preds = %628, %625
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #5
  %640 = load ptr, ptr %2, align 8, !tbaa !5
  %641 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %640, i32 0, i32 0
  %642 = load i32, ptr %641, align 4, !tbaa !18
  %643 = add nsw i32 %642, 1
  store i32 %643, ptr %641, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #5
  %644 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 0
  %645 = getelementptr inbounds [4 x float], ptr %644, i64 0, i64 2
  %646 = load float, ptr %645, align 8, !tbaa !11
  store float %646, ptr %53, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #5
  %647 = load float, ptr %53, align 4, !tbaa !20
  %648 = fsub float %647, 6.860000e+02
  store float %648, ptr %54, align 4, !tbaa !20
  %649 = load float, ptr %54, align 4, !tbaa !20
  %650 = fcmp olt float %649, 0xBE80000000000000
  br i1 %650, label %654, label %651

651:                                              ; preds = %639
  %652 = load float, ptr %54, align 4, !tbaa !20
  %653 = fcmp olt float 0x3E80000000000000, %652
  br i1 %653, label %654, label %665

654:                                              ; preds = %651, %639
  %655 = load ptr, ptr %2, align 8, !tbaa !5
  %656 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %655, i32 0, i32 1
  %657 = load i32, ptr %656, align 4, !tbaa !22
  %658 = add nsw i32 %657, 1
  store i32 %658, ptr %656, align 4, !tbaa !22
  %659 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 583)
  %660 = load float, ptr %53, align 4, !tbaa !20
  %661 = fpext float %660 to double
  %662 = load float, ptr %54, align 4, !tbaa !20
  %663 = fpext float %662 to double
  %664 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.860000e+02, double noundef %661, double noundef %663)
  br label %665

665:                                              ; preds = %654, %651
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #5
  %666 = load ptr, ptr %2, align 8, !tbaa !5
  %667 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %666, i32 0, i32 0
  %668 = load i32, ptr %667, align 4, !tbaa !18
  %669 = add nsw i32 %668, 1
  store i32 %669, ptr %667, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #5
  %670 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 0
  %671 = getelementptr inbounds [4 x float], ptr %670, i64 0, i64 3
  %672 = load float, ptr %671, align 4, !tbaa !11
  store float %672, ptr %55, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #5
  %673 = load float, ptr %55, align 4, !tbaa !20
  %674 = fsub float %673, 7.600000e+02
  store float %674, ptr %56, align 4, !tbaa !20
  %675 = load float, ptr %56, align 4, !tbaa !20
  %676 = fcmp olt float %675, 0xBE80000000000000
  br i1 %676, label %680, label %677

677:                                              ; preds = %665
  %678 = load float, ptr %56, align 4, !tbaa !20
  %679 = fcmp olt float 0x3E80000000000000, %678
  br i1 %679, label %680, label %691

680:                                              ; preds = %677, %665
  %681 = load ptr, ptr %2, align 8, !tbaa !5
  %682 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %681, i32 0, i32 1
  %683 = load i32, ptr %682, align 4, !tbaa !22
  %684 = add nsw i32 %683, 1
  store i32 %684, ptr %682, align 4, !tbaa !22
  %685 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 584)
  %686 = load float, ptr %55, align 4, !tbaa !20
  %687 = fpext float %686 to double
  %688 = load float, ptr %56, align 4, !tbaa !20
  %689 = fpext float %688 to double
  %690 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.600000e+02, double noundef %687, double noundef %689)
  br label %691

691:                                              ; preds = %680, %677
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #5
  %692 = load ptr, ptr %2, align 8, !tbaa !5
  %693 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %692, i32 0, i32 0
  %694 = load i32, ptr %693, align 4, !tbaa !18
  %695 = add nsw i32 %694, 1
  store i32 %695, ptr %693, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #5
  %696 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 1
  %697 = getelementptr inbounds [4 x float], ptr %696, i64 0, i64 0
  %698 = load float, ptr %697, align 16, !tbaa !11
  store float %698, ptr %57, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #5
  %699 = load float, ptr %57, align 4, !tbaa !20
  %700 = fsub float %699, 6.500000e+02
  store float %700, ptr %58, align 4, !tbaa !20
  %701 = load float, ptr %58, align 4, !tbaa !20
  %702 = fcmp olt float %701, 0xBE80000000000000
  br i1 %702, label %706, label %703

703:                                              ; preds = %691
  %704 = load float, ptr %58, align 4, !tbaa !20
  %705 = fcmp olt float 0x3E80000000000000, %704
  br i1 %705, label %706, label %717

706:                                              ; preds = %703, %691
  %707 = load ptr, ptr %2, align 8, !tbaa !5
  %708 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %707, i32 0, i32 1
  %709 = load i32, ptr %708, align 4, !tbaa !22
  %710 = add nsw i32 %709, 1
  store i32 %710, ptr %708, align 4, !tbaa !22
  %711 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 585)
  %712 = load float, ptr %57, align 4, !tbaa !20
  %713 = fpext float %712 to double
  %714 = load float, ptr %58, align 4, !tbaa !20
  %715 = fpext float %714 to double
  %716 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+02, double noundef %713, double noundef %715)
  br label %717

717:                                              ; preds = %706, %703
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #5
  %718 = load ptr, ptr %2, align 8, !tbaa !5
  %719 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %718, i32 0, i32 0
  %720 = load i32, ptr %719, align 4, !tbaa !18
  %721 = add nsw i32 %720, 1
  store i32 %721, ptr %719, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #5
  %722 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 1
  %723 = getelementptr inbounds [4 x float], ptr %722, i64 0, i64 1
  %724 = load float, ptr %723, align 4, !tbaa !11
  store float %724, ptr %59, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #5
  %725 = load float, ptr %59, align 4, !tbaa !20
  %726 = fsub float %725, 7.400000e+02
  store float %726, ptr %60, align 4, !tbaa !20
  %727 = load float, ptr %60, align 4, !tbaa !20
  %728 = fcmp olt float %727, 0xBE80000000000000
  br i1 %728, label %732, label %729

729:                                              ; preds = %717
  %730 = load float, ptr %60, align 4, !tbaa !20
  %731 = fcmp olt float 0x3E80000000000000, %730
  br i1 %731, label %732, label %743

732:                                              ; preds = %729, %717
  %733 = load ptr, ptr %2, align 8, !tbaa !5
  %734 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %733, i32 0, i32 1
  %735 = load i32, ptr %734, align 4, !tbaa !22
  %736 = add nsw i32 %735, 1
  store i32 %736, ptr %734, align 4, !tbaa !22
  %737 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 586)
  %738 = load float, ptr %59, align 4, !tbaa !20
  %739 = fpext float %738 to double
  %740 = load float, ptr %60, align 4, !tbaa !20
  %741 = fpext float %740 to double
  %742 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.400000e+02, double noundef %739, double noundef %741)
  br label %743

743:                                              ; preds = %732, %729
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #5
  %744 = load ptr, ptr %2, align 8, !tbaa !5
  %745 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %744, i32 0, i32 0
  %746 = load i32, ptr %745, align 4, !tbaa !18
  %747 = add nsw i32 %746, 1
  store i32 %747, ptr %745, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #5
  %748 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 1
  %749 = getelementptr inbounds [4 x float], ptr %748, i64 0, i64 2
  %750 = load float, ptr %749, align 8, !tbaa !11
  store float %750, ptr %61, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #5
  %751 = load float, ptr %61, align 4, !tbaa !20
  %752 = fsub float %751, 8.300000e+02
  store float %752, ptr %62, align 4, !tbaa !20
  %753 = load float, ptr %62, align 4, !tbaa !20
  %754 = fcmp olt float %753, 0xBE80000000000000
  br i1 %754, label %758, label %755

755:                                              ; preds = %743
  %756 = load float, ptr %62, align 4, !tbaa !20
  %757 = fcmp olt float 0x3E80000000000000, %756
  br i1 %757, label %758, label %769

758:                                              ; preds = %755, %743
  %759 = load ptr, ptr %2, align 8, !tbaa !5
  %760 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %759, i32 0, i32 1
  %761 = load i32, ptr %760, align 4, !tbaa !22
  %762 = add nsw i32 %761, 1
  store i32 %762, ptr %760, align 4, !tbaa !22
  %763 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 587)
  %764 = load float, ptr %61, align 4, !tbaa !20
  %765 = fpext float %764 to double
  %766 = load float, ptr %62, align 4, !tbaa !20
  %767 = fpext float %766 to double
  %768 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.300000e+02, double noundef %765, double noundef %767)
  br label %769

769:                                              ; preds = %758, %755
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #5
  %770 = load ptr, ptr %2, align 8, !tbaa !5
  %771 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %770, i32 0, i32 0
  %772 = load i32, ptr %771, align 4, !tbaa !18
  %773 = add nsw i32 %772, 1
  store i32 %773, ptr %771, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #5
  %774 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 1
  %775 = getelementptr inbounds [4 x float], ptr %774, i64 0, i64 3
  %776 = load float, ptr %775, align 4, !tbaa !11
  store float %776, ptr %63, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #5
  %777 = load float, ptr %63, align 4, !tbaa !20
  %778 = fsub float %777, 9.200000e+02
  store float %778, ptr %64, align 4, !tbaa !20
  %779 = load float, ptr %64, align 4, !tbaa !20
  %780 = fcmp olt float %779, 0xBE80000000000000
  br i1 %780, label %784, label %781

781:                                              ; preds = %769
  %782 = load float, ptr %64, align 4, !tbaa !20
  %783 = fcmp olt float 0x3E80000000000000, %782
  br i1 %783, label %784, label %795

784:                                              ; preds = %781, %769
  %785 = load ptr, ptr %2, align 8, !tbaa !5
  %786 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %785, i32 0, i32 1
  %787 = load i32, ptr %786, align 4, !tbaa !22
  %788 = add nsw i32 %787, 1
  store i32 %788, ptr %786, align 4, !tbaa !22
  %789 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 588)
  %790 = load float, ptr %63, align 4, !tbaa !20
  %791 = fpext float %790 to double
  %792 = load float, ptr %64, align 4, !tbaa !20
  %793 = fpext float %792 to double
  %794 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.200000e+02, double noundef %791, double noundef %793)
  br label %795

795:                                              ; preds = %784, %781
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #5
  %796 = load ptr, ptr %2, align 8, !tbaa !5
  %797 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %796, i32 0, i32 0
  %798 = load i32, ptr %797, align 4, !tbaa !18
  %799 = add nsw i32 %798, 1
  store i32 %799, ptr %797, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #5
  %800 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 2
  %801 = getelementptr inbounds [4 x float], ptr %800, i64 0, i64 0
  %802 = load float, ptr %801, align 16, !tbaa !11
  store float %802, ptr %65, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #5
  %803 = load float, ptr %65, align 4, !tbaa !20
  %804 = fsub float %803, 7.620000e+02
  store float %804, ptr %66, align 4, !tbaa !20
  %805 = load float, ptr %66, align 4, !tbaa !20
  %806 = fcmp olt float %805, 0xBE80000000000000
  br i1 %806, label %810, label %807

807:                                              ; preds = %795
  %808 = load float, ptr %66, align 4, !tbaa !20
  %809 = fcmp olt float 0x3E80000000000000, %808
  br i1 %809, label %810, label %821

810:                                              ; preds = %807, %795
  %811 = load ptr, ptr %2, align 8, !tbaa !5
  %812 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %811, i32 0, i32 1
  %813 = load i32, ptr %812, align 4, !tbaa !22
  %814 = add nsw i32 %813, 1
  store i32 %814, ptr %812, align 4, !tbaa !22
  %815 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 589)
  %816 = load float, ptr %65, align 4, !tbaa !20
  %817 = fpext float %816 to double
  %818 = load float, ptr %66, align 4, !tbaa !20
  %819 = fpext float %818 to double
  %820 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.620000e+02, double noundef %817, double noundef %819)
  br label %821

821:                                              ; preds = %810, %807
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #5
  %822 = load ptr, ptr %2, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %822, i32 0, i32 0
  %824 = load i32, ptr %823, align 4, !tbaa !18
  %825 = add nsw i32 %824, 1
  store i32 %825, ptr %823, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #5
  %826 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 2
  %827 = getelementptr inbounds [4 x float], ptr %826, i64 0, i64 1
  %828 = load float, ptr %827, align 4, !tbaa !11
  store float %828, ptr %67, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #5
  %829 = load float, ptr %67, align 4, !tbaa !20
  %830 = fsub float %829, 8.680000e+02
  store float %830, ptr %68, align 4, !tbaa !20
  %831 = load float, ptr %68, align 4, !tbaa !20
  %832 = fcmp olt float %831, 0xBE80000000000000
  br i1 %832, label %836, label %833

833:                                              ; preds = %821
  %834 = load float, ptr %68, align 4, !tbaa !20
  %835 = fcmp olt float 0x3E80000000000000, %834
  br i1 %835, label %836, label %847

836:                                              ; preds = %833, %821
  %837 = load ptr, ptr %2, align 8, !tbaa !5
  %838 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %837, i32 0, i32 1
  %839 = load i32, ptr %838, align 4, !tbaa !22
  %840 = add nsw i32 %839, 1
  store i32 %840, ptr %838, align 4, !tbaa !22
  %841 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 590)
  %842 = load float, ptr %67, align 4, !tbaa !20
  %843 = fpext float %842 to double
  %844 = load float, ptr %68, align 4, !tbaa !20
  %845 = fpext float %844 to double
  %846 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.680000e+02, double noundef %843, double noundef %845)
  br label %847

847:                                              ; preds = %836, %833
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #5
  %848 = load ptr, ptr %2, align 8, !tbaa !5
  %849 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %848, i32 0, i32 0
  %850 = load i32, ptr %849, align 4, !tbaa !18
  %851 = add nsw i32 %850, 1
  store i32 %851, ptr %849, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #5
  %852 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 2
  %853 = getelementptr inbounds [4 x float], ptr %852, i64 0, i64 2
  %854 = load float, ptr %853, align 8, !tbaa !11
  store float %854, ptr %69, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #5
  %855 = load float, ptr %69, align 4, !tbaa !20
  %856 = fsub float %855, 9.740000e+02
  store float %856, ptr %70, align 4, !tbaa !20
  %857 = load float, ptr %70, align 4, !tbaa !20
  %858 = fcmp olt float %857, 0xBE80000000000000
  br i1 %858, label %862, label %859

859:                                              ; preds = %847
  %860 = load float, ptr %70, align 4, !tbaa !20
  %861 = fcmp olt float 0x3E80000000000000, %860
  br i1 %861, label %862, label %873

862:                                              ; preds = %859, %847
  %863 = load ptr, ptr %2, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %863, i32 0, i32 1
  %865 = load i32, ptr %864, align 4, !tbaa !22
  %866 = add nsw i32 %865, 1
  store i32 %866, ptr %864, align 4, !tbaa !22
  %867 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 591)
  %868 = load float, ptr %69, align 4, !tbaa !20
  %869 = fpext float %868 to double
  %870 = load float, ptr %70, align 4, !tbaa !20
  %871 = fpext float %870 to double
  %872 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.740000e+02, double noundef %869, double noundef %871)
  br label %873

873:                                              ; preds = %862, %859
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #5
  %874 = load ptr, ptr %2, align 8, !tbaa !5
  %875 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %874, i32 0, i32 0
  %876 = load i32, ptr %875, align 4, !tbaa !18
  %877 = add nsw i32 %876, 1
  store i32 %877, ptr %875, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #5
  %878 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 2
  %879 = getelementptr inbounds [4 x float], ptr %878, i64 0, i64 3
  %880 = load float, ptr %879, align 4, !tbaa !11
  store float %880, ptr %71, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #5
  %881 = load float, ptr %71, align 4, !tbaa !20
  %882 = fsub float %881, 1.080000e+03
  store float %882, ptr %72, align 4, !tbaa !20
  %883 = load float, ptr %72, align 4, !tbaa !20
  %884 = fcmp olt float %883, 0xBE80000000000000
  br i1 %884, label %888, label %885

885:                                              ; preds = %873
  %886 = load float, ptr %72, align 4, !tbaa !20
  %887 = fcmp olt float 0x3E80000000000000, %886
  br i1 %887, label %888, label %899

888:                                              ; preds = %885, %873
  %889 = load ptr, ptr %2, align 8, !tbaa !5
  %890 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %889, i32 0, i32 1
  %891 = load i32, ptr %890, align 4, !tbaa !22
  %892 = add nsw i32 %891, 1
  store i32 %892, ptr %890, align 4, !tbaa !22
  %893 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 592)
  %894 = load float, ptr %71, align 4, !tbaa !20
  %895 = fpext float %894 to double
  %896 = load float, ptr %72, align 4, !tbaa !20
  %897 = fpext float %896 to double
  %898 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.080000e+03, double noundef %895, double noundef %897)
  br label %899

899:                                              ; preds = %888, %885
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #5
  %900 = load ptr, ptr %2, align 8, !tbaa !5
  %901 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %900, i32 0, i32 0
  %902 = load i32, ptr %901, align 4, !tbaa !18
  %903 = add nsw i32 %902, 1
  store i32 %903, ptr %901, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #5
  %904 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 3
  %905 = getelementptr inbounds [4 x float], ptr %904, i64 0, i64 0
  %906 = load float, ptr %905, align 16, !tbaa !11
  store float %906, ptr %73, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #5
  %907 = load float, ptr %73, align 4, !tbaa !20
  %908 = fsub float %907, 8.740000e+02
  store float %908, ptr %74, align 4, !tbaa !20
  %909 = load float, ptr %74, align 4, !tbaa !20
  %910 = fcmp olt float %909, 0xBE80000000000000
  br i1 %910, label %914, label %911

911:                                              ; preds = %899
  %912 = load float, ptr %74, align 4, !tbaa !20
  %913 = fcmp olt float 0x3E80000000000000, %912
  br i1 %913, label %914, label %925

914:                                              ; preds = %911, %899
  %915 = load ptr, ptr %2, align 8, !tbaa !5
  %916 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %915, i32 0, i32 1
  %917 = load i32, ptr %916, align 4, !tbaa !22
  %918 = add nsw i32 %917, 1
  store i32 %918, ptr %916, align 4, !tbaa !22
  %919 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 593)
  %920 = load float, ptr %73, align 4, !tbaa !20
  %921 = fpext float %920 to double
  %922 = load float, ptr %74, align 4, !tbaa !20
  %923 = fpext float %922 to double
  %924 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.740000e+02, double noundef %921, double noundef %923)
  br label %925

925:                                              ; preds = %914, %911
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #5
  %926 = load ptr, ptr %2, align 8, !tbaa !5
  %927 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %926, i32 0, i32 0
  %928 = load i32, ptr %927, align 4, !tbaa !18
  %929 = add nsw i32 %928, 1
  store i32 %929, ptr %927, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #5
  %930 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 3
  %931 = getelementptr inbounds [4 x float], ptr %930, i64 0, i64 1
  %932 = load float, ptr %931, align 4, !tbaa !11
  store float %932, ptr %75, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #5
  %933 = load float, ptr %75, align 4, !tbaa !20
  %934 = fsub float %933, 9.960000e+02
  store float %934, ptr %76, align 4, !tbaa !20
  %935 = load float, ptr %76, align 4, !tbaa !20
  %936 = fcmp olt float %935, 0xBE80000000000000
  br i1 %936, label %940, label %937

937:                                              ; preds = %925
  %938 = load float, ptr %76, align 4, !tbaa !20
  %939 = fcmp olt float 0x3E80000000000000, %938
  br i1 %939, label %940, label %951

940:                                              ; preds = %937, %925
  %941 = load ptr, ptr %2, align 8, !tbaa !5
  %942 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %941, i32 0, i32 1
  %943 = load i32, ptr %942, align 4, !tbaa !22
  %944 = add nsw i32 %943, 1
  store i32 %944, ptr %942, align 4, !tbaa !22
  %945 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 594)
  %946 = load float, ptr %75, align 4, !tbaa !20
  %947 = fpext float %946 to double
  %948 = load float, ptr %76, align 4, !tbaa !20
  %949 = fpext float %948 to double
  %950 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.960000e+02, double noundef %947, double noundef %949)
  br label %951

951:                                              ; preds = %940, %937
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #5
  %952 = load ptr, ptr %2, align 8, !tbaa !5
  %953 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %952, i32 0, i32 0
  %954 = load i32, ptr %953, align 4, !tbaa !18
  %955 = add nsw i32 %954, 1
  store i32 %955, ptr %953, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #5
  %956 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 3
  %957 = getelementptr inbounds [4 x float], ptr %956, i64 0, i64 2
  %958 = load float, ptr %957, align 8, !tbaa !11
  store float %958, ptr %77, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #5
  %959 = load float, ptr %77, align 4, !tbaa !20
  %960 = fsub float %959, 1.118000e+03
  store float %960, ptr %78, align 4, !tbaa !20
  %961 = load float, ptr %78, align 4, !tbaa !20
  %962 = fcmp olt float %961, 0xBE80000000000000
  br i1 %962, label %966, label %963

963:                                              ; preds = %951
  %964 = load float, ptr %78, align 4, !tbaa !20
  %965 = fcmp olt float 0x3E80000000000000, %964
  br i1 %965, label %966, label %977

966:                                              ; preds = %963, %951
  %967 = load ptr, ptr %2, align 8, !tbaa !5
  %968 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %967, i32 0, i32 1
  %969 = load i32, ptr %968, align 4, !tbaa !22
  %970 = add nsw i32 %969, 1
  store i32 %970, ptr %968, align 4, !tbaa !22
  %971 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 595)
  %972 = load float, ptr %77, align 4, !tbaa !20
  %973 = fpext float %972 to double
  %974 = load float, ptr %78, align 4, !tbaa !20
  %975 = fpext float %974 to double
  %976 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.118000e+03, double noundef %973, double noundef %975)
  br label %977

977:                                              ; preds = %966, %963
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #5
  %978 = load ptr, ptr %2, align 8, !tbaa !5
  %979 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %978, i32 0, i32 0
  %980 = load i32, ptr %979, align 4, !tbaa !18
  %981 = add nsw i32 %980, 1
  store i32 %981, ptr %979, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #5
  %982 = getelementptr inbounds [4 x [4 x float]], ptr %46, i64 0, i64 3
  %983 = getelementptr inbounds [4 x float], ptr %982, i64 0, i64 3
  %984 = load float, ptr %983, align 4, !tbaa !11
  store float %984, ptr %79, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #5
  %985 = load float, ptr %79, align 4, !tbaa !20
  %986 = fsub float %985, 1.240000e+03
  store float %986, ptr %80, align 4, !tbaa !20
  %987 = load float, ptr %80, align 4, !tbaa !20
  %988 = fcmp olt float %987, 0xBE80000000000000
  br i1 %988, label %992, label %989

989:                                              ; preds = %977
  %990 = load float, ptr %80, align 4, !tbaa !20
  %991 = fcmp olt float 0x3E80000000000000, %990
  br i1 %991, label %992, label %1003

992:                                              ; preds = %989, %977
  %993 = load ptr, ptr %2, align 8, !tbaa !5
  %994 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %993, i32 0, i32 1
  %995 = load i32, ptr %994, align 4, !tbaa !22
  %996 = add nsw i32 %995, 1
  store i32 %996, ptr %994, align 4, !tbaa !22
  %997 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 596)
  %998 = load float, ptr %79, align 4, !tbaa !20
  %999 = fpext float %998 to double
  %1000 = load float, ptr %80, align 4, !tbaa !20
  %1001 = fpext float %1000 to double
  %1002 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.240000e+03, double noundef %999, double noundef %1001)
  br label %1003

1003:                                             ; preds = %992, %989
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %46) #5
  call void @llvm.lifetime.start.p0(i64 64, ptr %81) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %82, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %83, ptr align 16 %4, i64 64, i1 false), !tbaa.struct !17
  call void @_Zml8HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %81, ptr noundef byval(%union.HMM_Mat4) align 16 %82, ptr noundef byval(%union.HMM_Mat4) align 16 %83)
  %1004 = load ptr, ptr %2, align 8, !tbaa !5
  %1005 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1004, i32 0, i32 0
  %1006 = load i32, ptr %1005, align 4, !tbaa !18
  %1007 = add nsw i32 %1006, 1
  store i32 %1007, ptr %1005, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #5
  %1008 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 0
  %1009 = getelementptr inbounds [4 x float], ptr %1008, i64 0, i64 0
  %1010 = load float, ptr %1009, align 16, !tbaa !11
  store float %1010, ptr %84, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #5
  %1011 = load float, ptr %84, align 4, !tbaa !20
  %1012 = fsub float %1011, 5.380000e+02
  store float %1012, ptr %85, align 4, !tbaa !20
  %1013 = load float, ptr %85, align 4, !tbaa !20
  %1014 = fcmp olt float %1013, 0xBE80000000000000
  br i1 %1014, label %1018, label %1015

1015:                                             ; preds = %1003
  %1016 = load float, ptr %85, align 4, !tbaa !20
  %1017 = fcmp olt float 0x3E80000000000000, %1016
  br i1 %1017, label %1018, label %1029

1018:                                             ; preds = %1015, %1003
  %1019 = load ptr, ptr %2, align 8, !tbaa !5
  %1020 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1019, i32 0, i32 1
  %1021 = load i32, ptr %1020, align 4, !tbaa !22
  %1022 = add nsw i32 %1021, 1
  store i32 %1022, ptr %1020, align 4, !tbaa !22
  %1023 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 602)
  %1024 = load float, ptr %84, align 4, !tbaa !20
  %1025 = fpext float %1024 to double
  %1026 = load float, ptr %85, align 4, !tbaa !20
  %1027 = fpext float %1026 to double
  %1028 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.380000e+02, double noundef %1025, double noundef %1027)
  br label %1029

1029:                                             ; preds = %1018, %1015
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #5
  %1030 = load ptr, ptr %2, align 8, !tbaa !5
  %1031 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1030, i32 0, i32 0
  %1032 = load i32, ptr %1031, align 4, !tbaa !18
  %1033 = add nsw i32 %1032, 1
  store i32 %1033, ptr %1031, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #5
  %1034 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 0
  %1035 = getelementptr inbounds [4 x float], ptr %1034, i64 0, i64 1
  %1036 = load float, ptr %1035, align 4, !tbaa !11
  store float %1036, ptr %86, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #5
  %1037 = load float, ptr %86, align 4, !tbaa !20
  %1038 = fsub float %1037, 6.120000e+02
  store float %1038, ptr %87, align 4, !tbaa !20
  %1039 = load float, ptr %87, align 4, !tbaa !20
  %1040 = fcmp olt float %1039, 0xBE80000000000000
  br i1 %1040, label %1044, label %1041

1041:                                             ; preds = %1029
  %1042 = load float, ptr %87, align 4, !tbaa !20
  %1043 = fcmp olt float 0x3E80000000000000, %1042
  br i1 %1043, label %1044, label %1055

1044:                                             ; preds = %1041, %1029
  %1045 = load ptr, ptr %2, align 8, !tbaa !5
  %1046 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1045, i32 0, i32 1
  %1047 = load i32, ptr %1046, align 4, !tbaa !22
  %1048 = add nsw i32 %1047, 1
  store i32 %1048, ptr %1046, align 4, !tbaa !22
  %1049 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 603)
  %1050 = load float, ptr %86, align 4, !tbaa !20
  %1051 = fpext float %1050 to double
  %1052 = load float, ptr %87, align 4, !tbaa !20
  %1053 = fpext float %1052 to double
  %1054 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.120000e+02, double noundef %1051, double noundef %1053)
  br label %1055

1055:                                             ; preds = %1044, %1041
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #5
  %1056 = load ptr, ptr %2, align 8, !tbaa !5
  %1057 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1056, i32 0, i32 0
  %1058 = load i32, ptr %1057, align 4, !tbaa !18
  %1059 = add nsw i32 %1058, 1
  store i32 %1059, ptr %1057, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #5
  %1060 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 0
  %1061 = getelementptr inbounds [4 x float], ptr %1060, i64 0, i64 2
  %1062 = load float, ptr %1061, align 8, !tbaa !11
  store float %1062, ptr %88, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %89) #5
  %1063 = load float, ptr %88, align 4, !tbaa !20
  %1064 = fsub float %1063, 6.860000e+02
  store float %1064, ptr %89, align 4, !tbaa !20
  %1065 = load float, ptr %89, align 4, !tbaa !20
  %1066 = fcmp olt float %1065, 0xBE80000000000000
  br i1 %1066, label %1070, label %1067

1067:                                             ; preds = %1055
  %1068 = load float, ptr %89, align 4, !tbaa !20
  %1069 = fcmp olt float 0x3E80000000000000, %1068
  br i1 %1069, label %1070, label %1081

1070:                                             ; preds = %1067, %1055
  %1071 = load ptr, ptr %2, align 8, !tbaa !5
  %1072 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1071, i32 0, i32 1
  %1073 = load i32, ptr %1072, align 4, !tbaa !22
  %1074 = add nsw i32 %1073, 1
  store i32 %1074, ptr %1072, align 4, !tbaa !22
  %1075 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 604)
  %1076 = load float, ptr %88, align 4, !tbaa !20
  %1077 = fpext float %1076 to double
  %1078 = load float, ptr %89, align 4, !tbaa !20
  %1079 = fpext float %1078 to double
  %1080 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.860000e+02, double noundef %1077, double noundef %1079)
  br label %1081

1081:                                             ; preds = %1070, %1067
  call void @llvm.lifetime.end.p0(i64 4, ptr %89) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #5
  %1082 = load ptr, ptr %2, align 8, !tbaa !5
  %1083 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1082, i32 0, i32 0
  %1084 = load i32, ptr %1083, align 4, !tbaa !18
  %1085 = add nsw i32 %1084, 1
  store i32 %1085, ptr %1083, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #5
  %1086 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 0
  %1087 = getelementptr inbounds [4 x float], ptr %1086, i64 0, i64 3
  %1088 = load float, ptr %1087, align 4, !tbaa !11
  store float %1088, ptr %90, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #5
  %1089 = load float, ptr %90, align 4, !tbaa !20
  %1090 = fsub float %1089, 7.600000e+02
  store float %1090, ptr %91, align 4, !tbaa !20
  %1091 = load float, ptr %91, align 4, !tbaa !20
  %1092 = fcmp olt float %1091, 0xBE80000000000000
  br i1 %1092, label %1096, label %1093

1093:                                             ; preds = %1081
  %1094 = load float, ptr %91, align 4, !tbaa !20
  %1095 = fcmp olt float 0x3E80000000000000, %1094
  br i1 %1095, label %1096, label %1107

1096:                                             ; preds = %1093, %1081
  %1097 = load ptr, ptr %2, align 8, !tbaa !5
  %1098 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1097, i32 0, i32 1
  %1099 = load i32, ptr %1098, align 4, !tbaa !22
  %1100 = add nsw i32 %1099, 1
  store i32 %1100, ptr %1098, align 4, !tbaa !22
  %1101 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 605)
  %1102 = load float, ptr %90, align 4, !tbaa !20
  %1103 = fpext float %1102 to double
  %1104 = load float, ptr %91, align 4, !tbaa !20
  %1105 = fpext float %1104 to double
  %1106 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.600000e+02, double noundef %1103, double noundef %1105)
  br label %1107

1107:                                             ; preds = %1096, %1093
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #5
  %1108 = load ptr, ptr %2, align 8, !tbaa !5
  %1109 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1108, i32 0, i32 0
  %1110 = load i32, ptr %1109, align 4, !tbaa !18
  %1111 = add nsw i32 %1110, 1
  store i32 %1111, ptr %1109, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #5
  %1112 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 1
  %1113 = getelementptr inbounds [4 x float], ptr %1112, i64 0, i64 0
  %1114 = load float, ptr %1113, align 16, !tbaa !11
  store float %1114, ptr %92, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #5
  %1115 = load float, ptr %92, align 4, !tbaa !20
  %1116 = fsub float %1115, 6.500000e+02
  store float %1116, ptr %93, align 4, !tbaa !20
  %1117 = load float, ptr %93, align 4, !tbaa !20
  %1118 = fcmp olt float %1117, 0xBE80000000000000
  br i1 %1118, label %1122, label %1119

1119:                                             ; preds = %1107
  %1120 = load float, ptr %93, align 4, !tbaa !20
  %1121 = fcmp olt float 0x3E80000000000000, %1120
  br i1 %1121, label %1122, label %1133

1122:                                             ; preds = %1119, %1107
  %1123 = load ptr, ptr %2, align 8, !tbaa !5
  %1124 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1123, i32 0, i32 1
  %1125 = load i32, ptr %1124, align 4, !tbaa !22
  %1126 = add nsw i32 %1125, 1
  store i32 %1126, ptr %1124, align 4, !tbaa !22
  %1127 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 606)
  %1128 = load float, ptr %92, align 4, !tbaa !20
  %1129 = fpext float %1128 to double
  %1130 = load float, ptr %93, align 4, !tbaa !20
  %1131 = fpext float %1130 to double
  %1132 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 6.500000e+02, double noundef %1129, double noundef %1131)
  br label %1133

1133:                                             ; preds = %1122, %1119
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #5
  %1134 = load ptr, ptr %2, align 8, !tbaa !5
  %1135 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1134, i32 0, i32 0
  %1136 = load i32, ptr %1135, align 4, !tbaa !18
  %1137 = add nsw i32 %1136, 1
  store i32 %1137, ptr %1135, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #5
  %1138 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 1
  %1139 = getelementptr inbounds [4 x float], ptr %1138, i64 0, i64 1
  %1140 = load float, ptr %1139, align 4, !tbaa !11
  store float %1140, ptr %94, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #5
  %1141 = load float, ptr %94, align 4, !tbaa !20
  %1142 = fsub float %1141, 7.400000e+02
  store float %1142, ptr %95, align 4, !tbaa !20
  %1143 = load float, ptr %95, align 4, !tbaa !20
  %1144 = fcmp olt float %1143, 0xBE80000000000000
  br i1 %1144, label %1148, label %1145

1145:                                             ; preds = %1133
  %1146 = load float, ptr %95, align 4, !tbaa !20
  %1147 = fcmp olt float 0x3E80000000000000, %1146
  br i1 %1147, label %1148, label %1159

1148:                                             ; preds = %1145, %1133
  %1149 = load ptr, ptr %2, align 8, !tbaa !5
  %1150 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1149, i32 0, i32 1
  %1151 = load i32, ptr %1150, align 4, !tbaa !22
  %1152 = add nsw i32 %1151, 1
  store i32 %1152, ptr %1150, align 4, !tbaa !22
  %1153 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 607)
  %1154 = load float, ptr %94, align 4, !tbaa !20
  %1155 = fpext float %1154 to double
  %1156 = load float, ptr %95, align 4, !tbaa !20
  %1157 = fpext float %1156 to double
  %1158 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.400000e+02, double noundef %1155, double noundef %1157)
  br label %1159

1159:                                             ; preds = %1148, %1145
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #5
  %1160 = load ptr, ptr %2, align 8, !tbaa !5
  %1161 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1160, i32 0, i32 0
  %1162 = load i32, ptr %1161, align 4, !tbaa !18
  %1163 = add nsw i32 %1162, 1
  store i32 %1163, ptr %1161, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #5
  %1164 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 1
  %1165 = getelementptr inbounds [4 x float], ptr %1164, i64 0, i64 2
  %1166 = load float, ptr %1165, align 8, !tbaa !11
  store float %1166, ptr %96, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #5
  %1167 = load float, ptr %96, align 4, !tbaa !20
  %1168 = fsub float %1167, 8.300000e+02
  store float %1168, ptr %97, align 4, !tbaa !20
  %1169 = load float, ptr %97, align 4, !tbaa !20
  %1170 = fcmp olt float %1169, 0xBE80000000000000
  br i1 %1170, label %1174, label %1171

1171:                                             ; preds = %1159
  %1172 = load float, ptr %97, align 4, !tbaa !20
  %1173 = fcmp olt float 0x3E80000000000000, %1172
  br i1 %1173, label %1174, label %1185

1174:                                             ; preds = %1171, %1159
  %1175 = load ptr, ptr %2, align 8, !tbaa !5
  %1176 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1175, i32 0, i32 1
  %1177 = load i32, ptr %1176, align 4, !tbaa !22
  %1178 = add nsw i32 %1177, 1
  store i32 %1178, ptr %1176, align 4, !tbaa !22
  %1179 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 608)
  %1180 = load float, ptr %96, align 4, !tbaa !20
  %1181 = fpext float %1180 to double
  %1182 = load float, ptr %97, align 4, !tbaa !20
  %1183 = fpext float %1182 to double
  %1184 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.300000e+02, double noundef %1181, double noundef %1183)
  br label %1185

1185:                                             ; preds = %1174, %1171
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #5
  %1186 = load ptr, ptr %2, align 8, !tbaa !5
  %1187 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1186, i32 0, i32 0
  %1188 = load i32, ptr %1187, align 4, !tbaa !18
  %1189 = add nsw i32 %1188, 1
  store i32 %1189, ptr %1187, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #5
  %1190 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 1
  %1191 = getelementptr inbounds [4 x float], ptr %1190, i64 0, i64 3
  %1192 = load float, ptr %1191, align 4, !tbaa !11
  store float %1192, ptr %98, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #5
  %1193 = load float, ptr %98, align 4, !tbaa !20
  %1194 = fsub float %1193, 9.200000e+02
  store float %1194, ptr %99, align 4, !tbaa !20
  %1195 = load float, ptr %99, align 4, !tbaa !20
  %1196 = fcmp olt float %1195, 0xBE80000000000000
  br i1 %1196, label %1200, label %1197

1197:                                             ; preds = %1185
  %1198 = load float, ptr %99, align 4, !tbaa !20
  %1199 = fcmp olt float 0x3E80000000000000, %1198
  br i1 %1199, label %1200, label %1211

1200:                                             ; preds = %1197, %1185
  %1201 = load ptr, ptr %2, align 8, !tbaa !5
  %1202 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1201, i32 0, i32 1
  %1203 = load i32, ptr %1202, align 4, !tbaa !22
  %1204 = add nsw i32 %1203, 1
  store i32 %1204, ptr %1202, align 4, !tbaa !22
  %1205 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 609)
  %1206 = load float, ptr %98, align 4, !tbaa !20
  %1207 = fpext float %1206 to double
  %1208 = load float, ptr %99, align 4, !tbaa !20
  %1209 = fpext float %1208 to double
  %1210 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.200000e+02, double noundef %1207, double noundef %1209)
  br label %1211

1211:                                             ; preds = %1200, %1197
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #5
  %1212 = load ptr, ptr %2, align 8, !tbaa !5
  %1213 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1212, i32 0, i32 0
  %1214 = load i32, ptr %1213, align 4, !tbaa !18
  %1215 = add nsw i32 %1214, 1
  store i32 %1215, ptr %1213, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #5
  %1216 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 2
  %1217 = getelementptr inbounds [4 x float], ptr %1216, i64 0, i64 0
  %1218 = load float, ptr %1217, align 16, !tbaa !11
  store float %1218, ptr %100, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %101) #5
  %1219 = load float, ptr %100, align 4, !tbaa !20
  %1220 = fsub float %1219, 7.620000e+02
  store float %1220, ptr %101, align 4, !tbaa !20
  %1221 = load float, ptr %101, align 4, !tbaa !20
  %1222 = fcmp olt float %1221, 0xBE80000000000000
  br i1 %1222, label %1226, label %1223

1223:                                             ; preds = %1211
  %1224 = load float, ptr %101, align 4, !tbaa !20
  %1225 = fcmp olt float 0x3E80000000000000, %1224
  br i1 %1225, label %1226, label %1237

1226:                                             ; preds = %1223, %1211
  %1227 = load ptr, ptr %2, align 8, !tbaa !5
  %1228 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1227, i32 0, i32 1
  %1229 = load i32, ptr %1228, align 4, !tbaa !22
  %1230 = add nsw i32 %1229, 1
  store i32 %1230, ptr %1228, align 4, !tbaa !22
  %1231 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 610)
  %1232 = load float, ptr %100, align 4, !tbaa !20
  %1233 = fpext float %1232 to double
  %1234 = load float, ptr %101, align 4, !tbaa !20
  %1235 = fpext float %1234 to double
  %1236 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 7.620000e+02, double noundef %1233, double noundef %1235)
  br label %1237

1237:                                             ; preds = %1226, %1223
  call void @llvm.lifetime.end.p0(i64 4, ptr %101) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #5
  %1238 = load ptr, ptr %2, align 8, !tbaa !5
  %1239 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1238, i32 0, i32 0
  %1240 = load i32, ptr %1239, align 4, !tbaa !18
  %1241 = add nsw i32 %1240, 1
  store i32 %1241, ptr %1239, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #5
  %1242 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 2
  %1243 = getelementptr inbounds [4 x float], ptr %1242, i64 0, i64 1
  %1244 = load float, ptr %1243, align 4, !tbaa !11
  store float %1244, ptr %102, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #5
  %1245 = load float, ptr %102, align 4, !tbaa !20
  %1246 = fsub float %1245, 8.680000e+02
  store float %1246, ptr %103, align 4, !tbaa !20
  %1247 = load float, ptr %103, align 4, !tbaa !20
  %1248 = fcmp olt float %1247, 0xBE80000000000000
  br i1 %1248, label %1252, label %1249

1249:                                             ; preds = %1237
  %1250 = load float, ptr %103, align 4, !tbaa !20
  %1251 = fcmp olt float 0x3E80000000000000, %1250
  br i1 %1251, label %1252, label %1263

1252:                                             ; preds = %1249, %1237
  %1253 = load ptr, ptr %2, align 8, !tbaa !5
  %1254 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1253, i32 0, i32 1
  %1255 = load i32, ptr %1254, align 4, !tbaa !22
  %1256 = add nsw i32 %1255, 1
  store i32 %1256, ptr %1254, align 4, !tbaa !22
  %1257 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 611)
  %1258 = load float, ptr %102, align 4, !tbaa !20
  %1259 = fpext float %1258 to double
  %1260 = load float, ptr %103, align 4, !tbaa !20
  %1261 = fpext float %1260 to double
  %1262 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.680000e+02, double noundef %1259, double noundef %1261)
  br label %1263

1263:                                             ; preds = %1252, %1249
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #5
  %1264 = load ptr, ptr %2, align 8, !tbaa !5
  %1265 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1264, i32 0, i32 0
  %1266 = load i32, ptr %1265, align 4, !tbaa !18
  %1267 = add nsw i32 %1266, 1
  store i32 %1267, ptr %1265, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #5
  %1268 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 2
  %1269 = getelementptr inbounds [4 x float], ptr %1268, i64 0, i64 2
  %1270 = load float, ptr %1269, align 8, !tbaa !11
  store float %1270, ptr %104, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #5
  %1271 = load float, ptr %104, align 4, !tbaa !20
  %1272 = fsub float %1271, 9.740000e+02
  store float %1272, ptr %105, align 4, !tbaa !20
  %1273 = load float, ptr %105, align 4, !tbaa !20
  %1274 = fcmp olt float %1273, 0xBE80000000000000
  br i1 %1274, label %1278, label %1275

1275:                                             ; preds = %1263
  %1276 = load float, ptr %105, align 4, !tbaa !20
  %1277 = fcmp olt float 0x3E80000000000000, %1276
  br i1 %1277, label %1278, label %1289

1278:                                             ; preds = %1275, %1263
  %1279 = load ptr, ptr %2, align 8, !tbaa !5
  %1280 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1279, i32 0, i32 1
  %1281 = load i32, ptr %1280, align 4, !tbaa !22
  %1282 = add nsw i32 %1281, 1
  store i32 %1282, ptr %1280, align 4, !tbaa !22
  %1283 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 612)
  %1284 = load float, ptr %104, align 4, !tbaa !20
  %1285 = fpext float %1284 to double
  %1286 = load float, ptr %105, align 4, !tbaa !20
  %1287 = fpext float %1286 to double
  %1288 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.740000e+02, double noundef %1285, double noundef %1287)
  br label %1289

1289:                                             ; preds = %1278, %1275
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #5
  %1290 = load ptr, ptr %2, align 8, !tbaa !5
  %1291 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1290, i32 0, i32 0
  %1292 = load i32, ptr %1291, align 4, !tbaa !18
  %1293 = add nsw i32 %1292, 1
  store i32 %1293, ptr %1291, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #5
  %1294 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 2
  %1295 = getelementptr inbounds [4 x float], ptr %1294, i64 0, i64 3
  %1296 = load float, ptr %1295, align 4, !tbaa !11
  store float %1296, ptr %106, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #5
  %1297 = load float, ptr %106, align 4, !tbaa !20
  %1298 = fsub float %1297, 1.080000e+03
  store float %1298, ptr %107, align 4, !tbaa !20
  %1299 = load float, ptr %107, align 4, !tbaa !20
  %1300 = fcmp olt float %1299, 0xBE80000000000000
  br i1 %1300, label %1304, label %1301

1301:                                             ; preds = %1289
  %1302 = load float, ptr %107, align 4, !tbaa !20
  %1303 = fcmp olt float 0x3E80000000000000, %1302
  br i1 %1303, label %1304, label %1315

1304:                                             ; preds = %1301, %1289
  %1305 = load ptr, ptr %2, align 8, !tbaa !5
  %1306 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1305, i32 0, i32 1
  %1307 = load i32, ptr %1306, align 4, !tbaa !22
  %1308 = add nsw i32 %1307, 1
  store i32 %1308, ptr %1306, align 4, !tbaa !22
  %1309 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 613)
  %1310 = load float, ptr %106, align 4, !tbaa !20
  %1311 = fpext float %1310 to double
  %1312 = load float, ptr %107, align 4, !tbaa !20
  %1313 = fpext float %1312 to double
  %1314 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.080000e+03, double noundef %1311, double noundef %1313)
  br label %1315

1315:                                             ; preds = %1304, %1301
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #5
  %1316 = load ptr, ptr %2, align 8, !tbaa !5
  %1317 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1316, i32 0, i32 0
  %1318 = load i32, ptr %1317, align 4, !tbaa !18
  %1319 = add nsw i32 %1318, 1
  store i32 %1319, ptr %1317, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %108) #5
  %1320 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 3
  %1321 = getelementptr inbounds [4 x float], ptr %1320, i64 0, i64 0
  %1322 = load float, ptr %1321, align 16, !tbaa !11
  store float %1322, ptr %108, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #5
  %1323 = load float, ptr %108, align 4, !tbaa !20
  %1324 = fsub float %1323, 8.740000e+02
  store float %1324, ptr %109, align 4, !tbaa !20
  %1325 = load float, ptr %109, align 4, !tbaa !20
  %1326 = fcmp olt float %1325, 0xBE80000000000000
  br i1 %1326, label %1330, label %1327

1327:                                             ; preds = %1315
  %1328 = load float, ptr %109, align 4, !tbaa !20
  %1329 = fcmp olt float 0x3E80000000000000, %1328
  br i1 %1329, label %1330, label %1341

1330:                                             ; preds = %1327, %1315
  %1331 = load ptr, ptr %2, align 8, !tbaa !5
  %1332 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1331, i32 0, i32 1
  %1333 = load i32, ptr %1332, align 4, !tbaa !22
  %1334 = add nsw i32 %1333, 1
  store i32 %1334, ptr %1332, align 4, !tbaa !22
  %1335 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 614)
  %1336 = load float, ptr %108, align 4, !tbaa !20
  %1337 = fpext float %1336 to double
  %1338 = load float, ptr %109, align 4, !tbaa !20
  %1339 = fpext float %1338 to double
  %1340 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 8.740000e+02, double noundef %1337, double noundef %1339)
  br label %1341

1341:                                             ; preds = %1330, %1327
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %108) #5
  %1342 = load ptr, ptr %2, align 8, !tbaa !5
  %1343 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1342, i32 0, i32 0
  %1344 = load i32, ptr %1343, align 4, !tbaa !18
  %1345 = add nsw i32 %1344, 1
  store i32 %1345, ptr %1343, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %110) #5
  %1346 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 3
  %1347 = getelementptr inbounds [4 x float], ptr %1346, i64 0, i64 1
  %1348 = load float, ptr %1347, align 4, !tbaa !11
  store float %1348, ptr %110, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %111) #5
  %1349 = load float, ptr %110, align 4, !tbaa !20
  %1350 = fsub float %1349, 9.960000e+02
  store float %1350, ptr %111, align 4, !tbaa !20
  %1351 = load float, ptr %111, align 4, !tbaa !20
  %1352 = fcmp olt float %1351, 0xBE80000000000000
  br i1 %1352, label %1356, label %1353

1353:                                             ; preds = %1341
  %1354 = load float, ptr %111, align 4, !tbaa !20
  %1355 = fcmp olt float 0x3E80000000000000, %1354
  br i1 %1355, label %1356, label %1367

1356:                                             ; preds = %1353, %1341
  %1357 = load ptr, ptr %2, align 8, !tbaa !5
  %1358 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1357, i32 0, i32 1
  %1359 = load i32, ptr %1358, align 4, !tbaa !22
  %1360 = add nsw i32 %1359, 1
  store i32 %1360, ptr %1358, align 4, !tbaa !22
  %1361 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 615)
  %1362 = load float, ptr %110, align 4, !tbaa !20
  %1363 = fpext float %1362 to double
  %1364 = load float, ptr %111, align 4, !tbaa !20
  %1365 = fpext float %1364 to double
  %1366 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 9.960000e+02, double noundef %1363, double noundef %1365)
  br label %1367

1367:                                             ; preds = %1356, %1353
  call void @llvm.lifetime.end.p0(i64 4, ptr %111) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %110) #5
  %1368 = load ptr, ptr %2, align 8, !tbaa !5
  %1369 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1368, i32 0, i32 0
  %1370 = load i32, ptr %1369, align 4, !tbaa !18
  %1371 = add nsw i32 %1370, 1
  store i32 %1371, ptr %1369, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #5
  %1372 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 3
  %1373 = getelementptr inbounds [4 x float], ptr %1372, i64 0, i64 2
  %1374 = load float, ptr %1373, align 8, !tbaa !11
  store float %1374, ptr %112, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %113) #5
  %1375 = load float, ptr %112, align 4, !tbaa !20
  %1376 = fsub float %1375, 1.118000e+03
  store float %1376, ptr %113, align 4, !tbaa !20
  %1377 = load float, ptr %113, align 4, !tbaa !20
  %1378 = fcmp olt float %1377, 0xBE80000000000000
  br i1 %1378, label %1382, label %1379

1379:                                             ; preds = %1367
  %1380 = load float, ptr %113, align 4, !tbaa !20
  %1381 = fcmp olt float 0x3E80000000000000, %1380
  br i1 %1381, label %1382, label %1393

1382:                                             ; preds = %1379, %1367
  %1383 = load ptr, ptr %2, align 8, !tbaa !5
  %1384 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1383, i32 0, i32 1
  %1385 = load i32, ptr %1384, align 4, !tbaa !22
  %1386 = add nsw i32 %1385, 1
  store i32 %1386, ptr %1384, align 4, !tbaa !22
  %1387 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 616)
  %1388 = load float, ptr %112, align 4, !tbaa !20
  %1389 = fpext float %1388 to double
  %1390 = load float, ptr %113, align 4, !tbaa !20
  %1391 = fpext float %1390 to double
  %1392 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.118000e+03, double noundef %1389, double noundef %1391)
  br label %1393

1393:                                             ; preds = %1382, %1379
  call void @llvm.lifetime.end.p0(i64 4, ptr %113) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #5
  %1394 = load ptr, ptr %2, align 8, !tbaa !5
  %1395 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1394, i32 0, i32 0
  %1396 = load i32, ptr %1395, align 4, !tbaa !18
  %1397 = add nsw i32 %1396, 1
  store i32 %1397, ptr %1395, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %114) #5
  %1398 = getelementptr inbounds [4 x [4 x float]], ptr %81, i64 0, i64 3
  %1399 = getelementptr inbounds [4 x float], ptr %1398, i64 0, i64 3
  %1400 = load float, ptr %1399, align 4, !tbaa !11
  store float %1400, ptr %114, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 4, ptr %115) #5
  %1401 = load float, ptr %114, align 4, !tbaa !20
  %1402 = fsub float %1401, 1.240000e+03
  store float %1402, ptr %115, align 4, !tbaa !20
  %1403 = load float, ptr %115, align 4, !tbaa !20
  %1404 = fcmp olt float %1403, 0xBE80000000000000
  br i1 %1404, label %1408, label %1405

1405:                                             ; preds = %1393
  %1406 = load float, ptr %115, align 4, !tbaa !20
  %1407 = fcmp olt float 0x3E80000000000000, %1406
  br i1 %1407, label %1408, label %1419

1408:                                             ; preds = %1405, %1393
  %1409 = load ptr, ptr %2, align 8, !tbaa !5
  %1410 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1409, i32 0, i32 1
  %1411 = load i32, ptr %1410, align 4, !tbaa !22
  %1412 = add nsw i32 %1411, 1
  store i32 %1412, ptr %1410, align 4, !tbaa !22
  %1413 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 617)
  %1414 = load float, ptr %114, align 4, !tbaa !20
  %1415 = fpext float %1414 to double
  %1416 = load float, ptr %115, align 4, !tbaa !20
  %1417 = fpext float %1416 to double
  %1418 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.240000e+03, double noundef %1415, double noundef %1417)
  br label %1419

1419:                                             ; preds = %1408, %1405
  call void @llvm.lifetime.end.p0(i64 4, ptr %115) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %114) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %81) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %4) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %3) #5
  ret void
}

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_Zml8HMM_Mat4S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16) #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 = { 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 = !{!"int", !7, i64 0}
!11 = !{!7, !7, i64 0}
!12 = distinct !{!12, !13}
!13 = !{!"llvm.loop.mustprogress"}
!14 = distinct !{!14, !13}
!15 = distinct !{!15, !13}
!16 = distinct !{!16, !13}
!17 = !{i64 0, i64 64, !11}
!18 = !{!19, !10, i64 0}
!19 = !{!"_ZTS21hmt_testresult_struct", !10, i64 0, !10, i64 4}
!20 = !{!21, !21, i64 0}
!21 = !{!"float", !7, i64 0}
!22 = !{!19, !10, 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: inlinehint mustprogress uwtable
declare hidden void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16) local_unnamed_addr #2

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z33_hmt_test_Multiplication_Mat4Mat4P21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #3 {
.preheader451:
  %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
  %5 = alloca %union.HMM_Mat4, align 16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %1) #5
  call void @_ZL6HMM_M4v(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %1)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #5
  call void @_ZL6HMM_M4v(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2)
  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
  %6 = getelementptr inbounds i8, ptr %1, i64 16
  store <4 x float> <float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00>, ptr %6, align 16, !tbaa !5
  %7 = getelementptr inbounds i8, ptr %1, i64 32
  store <4 x float> <float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01>, ptr %7, align 16, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %1, i64 48
  store <4 x float> <float 1.300000e+01, float 1.400000e+01, float 1.500000e+01, float 1.600000e+01>, ptr %8, align 16, !tbaa !5
  store <4 x float> <float 1.700000e+01, float 1.800000e+01, float 1.900000e+01, float 2.000000e+01>, ptr %2, align 16, !tbaa !5
  %9 = getelementptr inbounds i8, ptr %2, i64 16
  store <4 x float> <float 2.100000e+01, float 2.200000e+01, float 2.300000e+01, float 2.400000e+01>, ptr %9, align 16, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %2, i64 32
  store <4 x float> <float 2.500000e+01, float 2.600000e+01, float 2.700000e+01, float 2.800000e+01>, ptr %10, align 16, !tbaa !5
  %11 = getelementptr inbounds i8, ptr %2, i64 48
  store <4 x float> <float 2.900000e+01, float 3.000000e+01, float 3.100000e+01, float 3.200000e+01>, ptr %11, align 16, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #5
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2)
  %12 = load i32, ptr %0, align 4, !tbaa !8
  %13 = add nsw i32 %12, 1
  store i32 %13, ptr %0, align 4, !tbaa !8
  %14 = load float, ptr %3, align 16, !tbaa !5
  %15 = fadd float %14, -5.380000e+02
  %16 = call float @llvm.fabs.f32(float %15)
  %or.cond = fcmp ogt float %16, 0x3E80000000000000
  br i1 %or.cond, label %17, label %25

17:                                               ; preds = %.preheader451
  %18 = getelementptr inbounds i8, ptr %0, i64 4
  %19 = load i32, ptr %18, align 4, !tbaa !11
  %20 = add nsw i32 %19, 1
  store i32 %20, ptr %18, align 4, !tbaa !11
  %21 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 561)
  %22 = fpext float %14 to double
  %23 = fpext float %15 to double
  %24 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.380000e+02, double noundef %22, double noundef %23)
  %.pre = load i32, ptr %0, align 4, !tbaa !8
  br label %25

25:                                               ; preds = %.preheader451, %17
  %26 = phi i32 [ %13, %.preheader451 ], [ %.pre, %17 ]
  %27 = add nsw i32 %26, 1
  store i32 %27, ptr %0, align 4, !tbaa !8
  %28 = getelementptr inbounds i8, ptr %3, i64 4
  %29 = load float, ptr %28, align 4, !tbaa !5
  %30 = fadd float %29, -6.120000e+02
  %31 = call float @llvm.fabs.f32(float %30)
  %or.cond3 = fcmp ogt float %31, 0x3E80000000000000
  br i1 %or.cond3, label %32, label %40

32:                                               ; preds = %25
  %33 = getelementptr inbounds i8, ptr %0, i64 4
  %34 = load i32, ptr %33, align 4, !tbaa !11
  %35 = add nsw i32 %34, 1
  store i32 %35, ptr %33, align 4, !tbaa !11
  %36 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 562)
  %37 = fpext float %29 to double
  %38 = fpext float %30 to double
  %39 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.120000e+02, double noundef %37, double noundef %38)
  %.pre465 = load i32, ptr %0, align 4, !tbaa !8
  br label %40

40:                                               ; preds = %25, %32
  %41 = phi i32 [ %27, %25 ], [ %.pre465, %32 ]
  %42 = add nsw i32 %41, 1
  store i32 %42, ptr %0, align 4, !tbaa !8
  %43 = getelementptr inbounds i8, ptr %3, i64 8
  %44 = load float, ptr %43, align 8, !tbaa !5
  %45 = fadd float %44, -6.860000e+02
  %46 = call float @llvm.fabs.f32(float %45)
  %or.cond5 = fcmp ogt float %46, 0x3E80000000000000
  br i1 %or.cond5, label %47, label %55

47:                                               ; preds = %40
  %48 = getelementptr inbounds i8, ptr %0, i64 4
  %49 = load i32, ptr %48, align 4, !tbaa !11
  %50 = add nsw i32 %49, 1
  store i32 %50, ptr %48, align 4, !tbaa !11
  %51 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 563)
  %52 = fpext float %44 to double
  %53 = fpext float %45 to double
  %54 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.860000e+02, double noundef %52, double noundef %53)
  %.pre466 = load i32, ptr %0, align 4, !tbaa !8
  br label %55

55:                                               ; preds = %40, %47
  %56 = phi i32 [ %42, %40 ], [ %.pre466, %47 ]
  %57 = add nsw i32 %56, 1
  store i32 %57, ptr %0, align 4, !tbaa !8
  %58 = getelementptr inbounds i8, ptr %3, i64 12
  %59 = load float, ptr %58, align 4, !tbaa !5
  %60 = fadd float %59, -7.600000e+02
  %61 = call float @llvm.fabs.f32(float %60)
  %or.cond7 = fcmp ogt float %61, 0x3E80000000000000
  br i1 %or.cond7, label %62, label %70

62:                                               ; preds = %55
  %63 = getelementptr inbounds i8, ptr %0, i64 4
  %64 = load i32, ptr %63, align 4, !tbaa !11
  %65 = add nsw i32 %64, 1
  store i32 %65, ptr %63, align 4, !tbaa !11
  %66 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 564)
  %67 = fpext float %59 to double
  %68 = fpext float %60 to double
  %69 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.600000e+02, double noundef %67, double noundef %68)
  %.pre467 = load i32, ptr %0, align 4, !tbaa !8
  br label %70

70:                                               ; preds = %55, %62
  %71 = phi i32 [ %57, %55 ], [ %.pre467, %62 ]
  %72 = add nsw i32 %71, 1
  store i32 %72, ptr %0, align 4, !tbaa !8
  %73 = getelementptr inbounds i8, ptr %3, i64 16
  %74 = load float, ptr %73, align 16, !tbaa !5
  %75 = fadd float %74, -6.500000e+02
  %76 = call float @llvm.fabs.f32(float %75)
  %or.cond9 = fcmp ogt float %76, 0x3E80000000000000
  br i1 %or.cond9, label %77, label %85

77:                                               ; preds = %70
  %78 = getelementptr inbounds i8, ptr %0, i64 4
  %79 = load i32, ptr %78, align 4, !tbaa !11
  %80 = add nsw i32 %79, 1
  store i32 %80, ptr %78, align 4, !tbaa !11
  %81 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 565)
  %82 = fpext float %74 to double
  %83 = fpext float %75 to double
  %84 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+02, double noundef %82, double noundef %83)
  %.pre468 = load i32, ptr %0, align 4, !tbaa !8
  br label %85

85:                                               ; preds = %70, %77
  %86 = phi i32 [ %72, %70 ], [ %.pre468, %77 ]
  %87 = add nsw i32 %86, 1
  store i32 %87, ptr %0, align 4, !tbaa !8
  %88 = getelementptr inbounds i8, ptr %3, i64 20
  %89 = load float, ptr %88, align 4, !tbaa !5
  %90 = fadd float %89, -7.400000e+02
  %91 = call float @llvm.fabs.f32(float %90)
  %or.cond11 = fcmp ogt float %91, 0x3E80000000000000
  br i1 %or.cond11, label %92, label %100

92:                                               ; preds = %85
  %93 = getelementptr inbounds i8, ptr %0, i64 4
  %94 = load i32, ptr %93, align 4, !tbaa !11
  %95 = add nsw i32 %94, 1
  store i32 %95, ptr %93, align 4, !tbaa !11
  %96 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 566)
  %97 = fpext float %89 to double
  %98 = fpext float %90 to double
  %99 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.400000e+02, double noundef %97, double noundef %98)
  %.pre469 = load i32, ptr %0, align 4, !tbaa !8
  br label %100

100:                                              ; preds = %85, %92
  %101 = phi i32 [ %87, %85 ], [ %.pre469, %92 ]
  %102 = add nsw i32 %101, 1
  store i32 %102, ptr %0, align 4, !tbaa !8
  %103 = getelementptr inbounds i8, ptr %3, i64 24
  %104 = load float, ptr %103, align 8, !tbaa !5
  %105 = fadd float %104, -8.300000e+02
  %106 = call float @llvm.fabs.f32(float %105)
  %or.cond13 = fcmp ogt float %106, 0x3E80000000000000
  br i1 %or.cond13, label %107, label %115

107:                                              ; preds = %100
  %108 = getelementptr inbounds i8, ptr %0, i64 4
  %109 = load i32, ptr %108, align 4, !tbaa !11
  %110 = add nsw i32 %109, 1
  store i32 %110, ptr %108, align 4, !tbaa !11
  %111 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 567)
  %112 = fpext float %104 to double
  %113 = fpext float %105 to double
  %114 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.300000e+02, double noundef %112, double noundef %113)
  %.pre470 = load i32, ptr %0, align 4, !tbaa !8
  br label %115

115:                                              ; preds = %100, %107
  %116 = phi i32 [ %102, %100 ], [ %.pre470, %107 ]
  %117 = add nsw i32 %116, 1
  store i32 %117, ptr %0, align 4, !tbaa !8
  %118 = getelementptr inbounds i8, ptr %3, i64 28
  %119 = load float, ptr %118, align 4, !tbaa !5
  %120 = fadd float %119, -9.200000e+02
  %121 = call float @llvm.fabs.f32(float %120)
  %or.cond15 = fcmp ogt float %121, 0x3E80000000000000
  br i1 %or.cond15, label %122, label %130

122:                                              ; preds = %115
  %123 = getelementptr inbounds i8, ptr %0, i64 4
  %124 = load i32, ptr %123, align 4, !tbaa !11
  %125 = add nsw i32 %124, 1
  store i32 %125, ptr %123, align 4, !tbaa !11
  %126 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 568)
  %127 = fpext float %119 to double
  %128 = fpext float %120 to double
  %129 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.200000e+02, double noundef %127, double noundef %128)
  %.pre471 = load i32, ptr %0, align 4, !tbaa !8
  br label %130

130:                                              ; preds = %115, %122
  %131 = phi i32 [ %117, %115 ], [ %.pre471, %122 ]
  %132 = add nsw i32 %131, 1
  store i32 %132, ptr %0, align 4, !tbaa !8
  %133 = getelementptr inbounds i8, ptr %3, i64 32
  %134 = load float, ptr %133, align 16, !tbaa !5
  %135 = fadd float %134, -7.620000e+02
  %136 = call float @llvm.fabs.f32(float %135)
  %or.cond17 = fcmp ogt float %136, 0x3E80000000000000
  br i1 %or.cond17, label %137, label %145

137:                                              ; preds = %130
  %138 = getelementptr inbounds i8, ptr %0, i64 4
  %139 = load i32, ptr %138, align 4, !tbaa !11
  %140 = add nsw i32 %139, 1
  store i32 %140, ptr %138, align 4, !tbaa !11
  %141 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 569)
  %142 = fpext float %134 to double
  %143 = fpext float %135 to double
  %144 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.620000e+02, double noundef %142, double noundef %143)
  %.pre472 = load i32, ptr %0, align 4, !tbaa !8
  br label %145

145:                                              ; preds = %130, %137
  %146 = phi i32 [ %132, %130 ], [ %.pre472, %137 ]
  %147 = add nsw i32 %146, 1
  store i32 %147, ptr %0, align 4, !tbaa !8
  %148 = getelementptr inbounds i8, ptr %3, i64 36
  %149 = load float, ptr %148, align 4, !tbaa !5
  %150 = fadd float %149, -8.680000e+02
  %151 = call float @llvm.fabs.f32(float %150)
  %or.cond19 = fcmp ogt float %151, 0x3E80000000000000
  br i1 %or.cond19, label %152, label %160

152:                                              ; preds = %145
  %153 = getelementptr inbounds i8, ptr %0, i64 4
  %154 = load i32, ptr %153, align 4, !tbaa !11
  %155 = add nsw i32 %154, 1
  store i32 %155, ptr %153, align 4, !tbaa !11
  %156 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 570)
  %157 = fpext float %149 to double
  %158 = fpext float %150 to double
  %159 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.680000e+02, double noundef %157, double noundef %158)
  %.pre473 = load i32, ptr %0, align 4, !tbaa !8
  br label %160

160:                                              ; preds = %145, %152
  %161 = phi i32 [ %147, %145 ], [ %.pre473, %152 ]
  %162 = add nsw i32 %161, 1
  store i32 %162, ptr %0, align 4, !tbaa !8
  %163 = getelementptr inbounds i8, ptr %3, i64 40
  %164 = load float, ptr %163, align 8, !tbaa !5
  %165 = fadd float %164, -9.740000e+02
  %166 = call float @llvm.fabs.f32(float %165)
  %or.cond21 = fcmp ogt float %166, 0x3E80000000000000
  br i1 %or.cond21, label %167, label %175

167:                                              ; preds = %160
  %168 = getelementptr inbounds i8, ptr %0, i64 4
  %169 = load i32, ptr %168, align 4, !tbaa !11
  %170 = add nsw i32 %169, 1
  store i32 %170, ptr %168, align 4, !tbaa !11
  %171 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 571)
  %172 = fpext float %164 to double
  %173 = fpext float %165 to double
  %174 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.740000e+02, double noundef %172, double noundef %173)
  %.pre474 = load i32, ptr %0, align 4, !tbaa !8
  br label %175

175:                                              ; preds = %160, %167
  %176 = phi i32 [ %162, %160 ], [ %.pre474, %167 ]
  %177 = add nsw i32 %176, 1
  store i32 %177, ptr %0, align 4, !tbaa !8
  %178 = getelementptr inbounds i8, ptr %3, i64 44
  %179 = load float, ptr %178, align 4, !tbaa !5
  %180 = fadd float %179, -1.080000e+03
  %181 = call float @llvm.fabs.f32(float %180)
  %or.cond23 = fcmp ogt float %181, 0x3E80000000000000
  br i1 %or.cond23, label %182, label %190

182:                                              ; preds = %175
  %183 = getelementptr inbounds i8, ptr %0, i64 4
  %184 = load i32, ptr %183, align 4, !tbaa !11
  %185 = add nsw i32 %184, 1
  store i32 %185, ptr %183, align 4, !tbaa !11
  %186 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 572)
  %187 = fpext float %179 to double
  %188 = fpext float %180 to double
  %189 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.080000e+03, double noundef %187, double noundef %188)
  %.pre475 = load i32, ptr %0, align 4, !tbaa !8
  br label %190

190:                                              ; preds = %175, %182
  %191 = phi i32 [ %177, %175 ], [ %.pre475, %182 ]
  %192 = add nsw i32 %191, 1
  store i32 %192, ptr %0, align 4, !tbaa !8
  %193 = getelementptr inbounds i8, ptr %3, i64 48
  %194 = load float, ptr %193, align 16, !tbaa !5
  %195 = fadd float %194, -8.740000e+02
  %196 = call float @llvm.fabs.f32(float %195)
  %or.cond25 = fcmp ogt float %196, 0x3E80000000000000
  br i1 %or.cond25, label %197, label %205

197:                                              ; preds = %190
  %198 = getelementptr inbounds i8, ptr %0, i64 4
  %199 = load i32, ptr %198, align 4, !tbaa !11
  %200 = add nsw i32 %199, 1
  store i32 %200, ptr %198, align 4, !tbaa !11
  %201 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 573)
  %202 = fpext float %194 to double
  %203 = fpext float %195 to double
  %204 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.740000e+02, double noundef %202, double noundef %203)
  %.pre476 = load i32, ptr %0, align 4, !tbaa !8
  br label %205

205:                                              ; preds = %190, %197
  %206 = phi i32 [ %192, %190 ], [ %.pre476, %197 ]
  %207 = add nsw i32 %206, 1
  store i32 %207, ptr %0, align 4, !tbaa !8
  %208 = getelementptr inbounds i8, ptr %3, i64 52
  %209 = load float, ptr %208, align 4, !tbaa !5
  %210 = fadd float %209, -9.960000e+02
  %211 = call float @llvm.fabs.f32(float %210)
  %or.cond27 = fcmp ogt float %211, 0x3E80000000000000
  br i1 %or.cond27, label %212, label %220

212:                                              ; preds = %205
  %213 = getelementptr inbounds i8, ptr %0, i64 4
  %214 = load i32, ptr %213, align 4, !tbaa !11
  %215 = add nsw i32 %214, 1
  store i32 %215, ptr %213, align 4, !tbaa !11
  %216 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 574)
  %217 = fpext float %209 to double
  %218 = fpext float %210 to double
  %219 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.960000e+02, double noundef %217, double noundef %218)
  %.pre477 = load i32, ptr %0, align 4, !tbaa !8
  br label %220

220:                                              ; preds = %205, %212
  %221 = phi i32 [ %207, %205 ], [ %.pre477, %212 ]
  %222 = add nsw i32 %221, 1
  store i32 %222, ptr %0, align 4, !tbaa !8
  %223 = getelementptr inbounds i8, ptr %3, i64 56
  %224 = load float, ptr %223, align 8, !tbaa !5
  %225 = fadd float %224, -1.118000e+03
  %226 = call float @llvm.fabs.f32(float %225)
  %or.cond29 = fcmp ogt float %226, 0x3E80000000000000
  br i1 %or.cond29, label %227, label %235

227:                                              ; preds = %220
  %228 = getelementptr inbounds i8, ptr %0, i64 4
  %229 = load i32, ptr %228, align 4, !tbaa !11
  %230 = add nsw i32 %229, 1
  store i32 %230, ptr %228, align 4, !tbaa !11
  %231 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 575)
  %232 = fpext float %224 to double
  %233 = fpext float %225 to double
  %234 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.118000e+03, double noundef %232, double noundef %233)
  %.pre478 = load i32, ptr %0, align 4, !tbaa !8
  br label %235

235:                                              ; preds = %220, %227
  %236 = phi i32 [ %222, %220 ], [ %.pre478, %227 ]
  %237 = add nsw i32 %236, 1
  store i32 %237, ptr %0, align 4, !tbaa !8
  %238 = getelementptr inbounds i8, ptr %3, i64 60
  %239 = load float, ptr %238, align 4, !tbaa !5
  %240 = fadd float %239, -1.240000e+03
  %241 = call float @llvm.fabs.f32(float %240)
  %or.cond31 = fcmp ogt float %241, 0x3E80000000000000
  br i1 %or.cond31, label %242, label %250

242:                                              ; preds = %235
  %243 = getelementptr inbounds i8, ptr %0, i64 4
  %244 = load i32, ptr %243, align 4, !tbaa !11
  %245 = add nsw i32 %244, 1
  store i32 %245, ptr %243, align 4, !tbaa !11
  %246 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 576)
  %247 = fpext float %239 to double
  %248 = fpext float %240 to double
  %249 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.240000e+03, double noundef %247, double noundef %248)
  br label %250

250:                                              ; preds = %235, %242
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #5
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #5
  call void @_ZL7HMM_Mul8HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2)
  %251 = load i32, ptr %0, align 4, !tbaa !8
  %252 = add nsw i32 %251, 1
  store i32 %252, ptr %0, align 4, !tbaa !8
  %253 = load float, ptr %4, align 16, !tbaa !5
  %254 = fadd float %253, -5.380000e+02
  %255 = call float @llvm.fabs.f32(float %254)
  %or.cond33 = fcmp ogt float %255, 0x3E80000000000000
  br i1 %or.cond33, label %256, label %264

256:                                              ; preds = %250
  %257 = getelementptr inbounds i8, ptr %0, i64 4
  %258 = load i32, ptr %257, align 4, !tbaa !11
  %259 = add nsw i32 %258, 1
  store i32 %259, ptr %257, align 4, !tbaa !11
  %260 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 581)
  %261 = fpext float %253 to double
  %262 = fpext float %254 to double
  %263 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.380000e+02, double noundef %261, double noundef %262)
  %.pre479 = load i32, ptr %0, align 4, !tbaa !8
  br label %264

264:                                              ; preds = %250, %256
  %265 = phi i32 [ %252, %250 ], [ %.pre479, %256 ]
  %266 = add nsw i32 %265, 1
  store i32 %266, ptr %0, align 4, !tbaa !8
  %267 = getelementptr inbounds i8, ptr %4, i64 4
  %268 = load float, ptr %267, align 4, !tbaa !5
  %269 = fadd float %268, -6.120000e+02
  %270 = call float @llvm.fabs.f32(float %269)
  %or.cond35 = fcmp ogt float %270, 0x3E80000000000000
  br i1 %or.cond35, label %271, label %279

271:                                              ; preds = %264
  %272 = getelementptr inbounds i8, ptr %0, i64 4
  %273 = load i32, ptr %272, align 4, !tbaa !11
  %274 = add nsw i32 %273, 1
  store i32 %274, ptr %272, align 4, !tbaa !11
  %275 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 582)
  %276 = fpext float %268 to double
  %277 = fpext float %269 to double
  %278 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.120000e+02, double noundef %276, double noundef %277)
  %.pre480 = load i32, ptr %0, align 4, !tbaa !8
  br label %279

279:                                              ; preds = %264, %271
  %280 = phi i32 [ %266, %264 ], [ %.pre480, %271 ]
  %281 = add nsw i32 %280, 1
  store i32 %281, ptr %0, align 4, !tbaa !8
  %282 = getelementptr inbounds i8, ptr %4, i64 8
  %283 = load float, ptr %282, align 8, !tbaa !5
  %284 = fadd float %283, -6.860000e+02
  %285 = call float @llvm.fabs.f32(float %284)
  %or.cond37 = fcmp ogt float %285, 0x3E80000000000000
  br i1 %or.cond37, label %286, label %294

286:                                              ; preds = %279
  %287 = getelementptr inbounds i8, ptr %0, i64 4
  %288 = load i32, ptr %287, align 4, !tbaa !11
  %289 = add nsw i32 %288, 1
  store i32 %289, ptr %287, align 4, !tbaa !11
  %290 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 583)
  %291 = fpext float %283 to double
  %292 = fpext float %284 to double
  %293 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.860000e+02, double noundef %291, double noundef %292)
  %.pre481 = load i32, ptr %0, align 4, !tbaa !8
  br label %294

294:                                              ; preds = %279, %286
  %295 = phi i32 [ %281, %279 ], [ %.pre481, %286 ]
  %296 = add nsw i32 %295, 1
  store i32 %296, ptr %0, align 4, !tbaa !8
  %297 = getelementptr inbounds i8, ptr %4, i64 12
  %298 = load float, ptr %297, align 4, !tbaa !5
  %299 = fadd float %298, -7.600000e+02
  %300 = call float @llvm.fabs.f32(float %299)
  %or.cond39 = fcmp ogt float %300, 0x3E80000000000000
  br i1 %or.cond39, label %301, label %309

301:                                              ; preds = %294
  %302 = getelementptr inbounds i8, ptr %0, i64 4
  %303 = load i32, ptr %302, align 4, !tbaa !11
  %304 = add nsw i32 %303, 1
  store i32 %304, ptr %302, align 4, !tbaa !11
  %305 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 584)
  %306 = fpext float %298 to double
  %307 = fpext float %299 to double
  %308 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.600000e+02, double noundef %306, double noundef %307)
  %.pre482 = load i32, ptr %0, align 4, !tbaa !8
  br label %309

309:                                              ; preds = %294, %301
  %310 = phi i32 [ %296, %294 ], [ %.pre482, %301 ]
  %311 = add nsw i32 %310, 1
  store i32 %311, ptr %0, align 4, !tbaa !8
  %312 = getelementptr inbounds i8, ptr %4, i64 16
  %313 = load float, ptr %312, align 16, !tbaa !5
  %314 = fadd float %313, -6.500000e+02
  %315 = call float @llvm.fabs.f32(float %314)
  %or.cond41 = fcmp ogt float %315, 0x3E80000000000000
  br i1 %or.cond41, label %316, label %324

316:                                              ; preds = %309
  %317 = getelementptr inbounds i8, ptr %0, i64 4
  %318 = load i32, ptr %317, align 4, !tbaa !11
  %319 = add nsw i32 %318, 1
  store i32 %319, ptr %317, align 4, !tbaa !11
  %320 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 585)
  %321 = fpext float %313 to double
  %322 = fpext float %314 to double
  %323 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+02, double noundef %321, double noundef %322)
  %.pre483 = load i32, ptr %0, align 4, !tbaa !8
  br label %324

324:                                              ; preds = %309, %316
  %325 = phi i32 [ %311, %309 ], [ %.pre483, %316 ]
  %326 = add nsw i32 %325, 1
  store i32 %326, ptr %0, align 4, !tbaa !8
  %327 = getelementptr inbounds i8, ptr %4, i64 20
  %328 = load float, ptr %327, align 4, !tbaa !5
  %329 = fadd float %328, -7.400000e+02
  %330 = call float @llvm.fabs.f32(float %329)
  %or.cond43 = fcmp ogt float %330, 0x3E80000000000000
  br i1 %or.cond43, label %331, label %339

331:                                              ; preds = %324
  %332 = getelementptr inbounds i8, ptr %0, i64 4
  %333 = load i32, ptr %332, align 4, !tbaa !11
  %334 = add nsw i32 %333, 1
  store i32 %334, ptr %332, align 4, !tbaa !11
  %335 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 586)
  %336 = fpext float %328 to double
  %337 = fpext float %329 to double
  %338 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.400000e+02, double noundef %336, double noundef %337)
  %.pre484 = load i32, ptr %0, align 4, !tbaa !8
  br label %339

339:                                              ; preds = %324, %331
  %340 = phi i32 [ %326, %324 ], [ %.pre484, %331 ]
  %341 = add nsw i32 %340, 1
  store i32 %341, ptr %0, align 4, !tbaa !8
  %342 = getelementptr inbounds i8, ptr %4, i64 24
  %343 = load float, ptr %342, align 8, !tbaa !5
  %344 = fadd float %343, -8.300000e+02
  %345 = call float @llvm.fabs.f32(float %344)
  %or.cond45 = fcmp ogt float %345, 0x3E80000000000000
  br i1 %or.cond45, label %346, label %354

346:                                              ; preds = %339
  %347 = getelementptr inbounds i8, ptr %0, i64 4
  %348 = load i32, ptr %347, align 4, !tbaa !11
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %347, align 4, !tbaa !11
  %350 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 587)
  %351 = fpext float %343 to double
  %352 = fpext float %344 to double
  %353 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.300000e+02, double noundef %351, double noundef %352)
  %.pre485 = load i32, ptr %0, align 4, !tbaa !8
  br label %354

354:                                              ; preds = %339, %346
  %355 = phi i32 [ %341, %339 ], [ %.pre485, %346 ]
  %356 = add nsw i32 %355, 1
  store i32 %356, ptr %0, align 4, !tbaa !8
  %357 = getelementptr inbounds i8, ptr %4, i64 28
  %358 = load float, ptr %357, align 4, !tbaa !5
  %359 = fadd float %358, -9.200000e+02
  %360 = call float @llvm.fabs.f32(float %359)
  %or.cond47 = fcmp ogt float %360, 0x3E80000000000000
  br i1 %or.cond47, label %361, label %369

361:                                              ; preds = %354
  %362 = getelementptr inbounds i8, ptr %0, i64 4
  %363 = load i32, ptr %362, align 4, !tbaa !11
  %364 = add nsw i32 %363, 1
  store i32 %364, ptr %362, align 4, !tbaa !11
  %365 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 588)
  %366 = fpext float %358 to double
  %367 = fpext float %359 to double
  %368 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.200000e+02, double noundef %366, double noundef %367)
  %.pre486 = load i32, ptr %0, align 4, !tbaa !8
  br label %369

369:                                              ; preds = %354, %361
  %370 = phi i32 [ %356, %354 ], [ %.pre486, %361 ]
  %371 = add nsw i32 %370, 1
  store i32 %371, ptr %0, align 4, !tbaa !8
  %372 = getelementptr inbounds i8, ptr %4, i64 32
  %373 = load float, ptr %372, align 16, !tbaa !5
  %374 = fadd float %373, -7.620000e+02
  %375 = call float @llvm.fabs.f32(float %374)
  %or.cond49 = fcmp ogt float %375, 0x3E80000000000000
  br i1 %or.cond49, label %376, label %384

376:                                              ; preds = %369
  %377 = getelementptr inbounds i8, ptr %0, i64 4
  %378 = load i32, ptr %377, align 4, !tbaa !11
  %379 = add nsw i32 %378, 1
  store i32 %379, ptr %377, align 4, !tbaa !11
  %380 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 589)
  %381 = fpext float %373 to double
  %382 = fpext float %374 to double
  %383 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.620000e+02, double noundef %381, double noundef %382)
  %.pre487 = load i32, ptr %0, align 4, !tbaa !8
  br label %384

384:                                              ; preds = %369, %376
  %385 = phi i32 [ %371, %369 ], [ %.pre487, %376 ]
  %386 = add nsw i32 %385, 1
  store i32 %386, ptr %0, align 4, !tbaa !8
  %387 = getelementptr inbounds i8, ptr %4, i64 36
  %388 = load float, ptr %387, align 4, !tbaa !5
  %389 = fadd float %388, -8.680000e+02
  %390 = call float @llvm.fabs.f32(float %389)
  %or.cond51 = fcmp ogt float %390, 0x3E80000000000000
  br i1 %or.cond51, label %391, label %399

391:                                              ; preds = %384
  %392 = getelementptr inbounds i8, ptr %0, i64 4
  %393 = load i32, ptr %392, align 4, !tbaa !11
  %394 = add nsw i32 %393, 1
  store i32 %394, ptr %392, align 4, !tbaa !11
  %395 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 590)
  %396 = fpext float %388 to double
  %397 = fpext float %389 to double
  %398 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.680000e+02, double noundef %396, double noundef %397)
  %.pre488 = load i32, ptr %0, align 4, !tbaa !8
  br label %399

399:                                              ; preds = %384, %391
  %400 = phi i32 [ %386, %384 ], [ %.pre488, %391 ]
  %401 = add nsw i32 %400, 1
  store i32 %401, ptr %0, align 4, !tbaa !8
  %402 = getelementptr inbounds i8, ptr %4, i64 40
  %403 = load float, ptr %402, align 8, !tbaa !5
  %404 = fadd float %403, -9.740000e+02
  %405 = call float @llvm.fabs.f32(float %404)
  %or.cond53 = fcmp ogt float %405, 0x3E80000000000000
  br i1 %or.cond53, label %406, label %414

406:                                              ; preds = %399
  %407 = getelementptr inbounds i8, ptr %0, i64 4
  %408 = load i32, ptr %407, align 4, !tbaa !11
  %409 = add nsw i32 %408, 1
  store i32 %409, ptr %407, align 4, !tbaa !11
  %410 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 591)
  %411 = fpext float %403 to double
  %412 = fpext float %404 to double
  %413 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.740000e+02, double noundef %411, double noundef %412)
  %.pre489 = load i32, ptr %0, align 4, !tbaa !8
  br label %414

414:                                              ; preds = %399, %406
  %415 = phi i32 [ %401, %399 ], [ %.pre489, %406 ]
  %416 = add nsw i32 %415, 1
  store i32 %416, ptr %0, align 4, !tbaa !8
  %417 = getelementptr inbounds i8, ptr %4, i64 44
  %418 = load float, ptr %417, align 4, !tbaa !5
  %419 = fadd float %418, -1.080000e+03
  %420 = call float @llvm.fabs.f32(float %419)
  %or.cond55 = fcmp ogt float %420, 0x3E80000000000000
  br i1 %or.cond55, label %421, label %429

421:                                              ; preds = %414
  %422 = getelementptr inbounds i8, ptr %0, i64 4
  %423 = load i32, ptr %422, align 4, !tbaa !11
  %424 = add nsw i32 %423, 1
  store i32 %424, ptr %422, align 4, !tbaa !11
  %425 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 592)
  %426 = fpext float %418 to double
  %427 = fpext float %419 to double
  %428 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.080000e+03, double noundef %426, double noundef %427)
  %.pre490 = load i32, ptr %0, align 4, !tbaa !8
  br label %429

429:                                              ; preds = %414, %421
  %430 = phi i32 [ %416, %414 ], [ %.pre490, %421 ]
  %431 = add nsw i32 %430, 1
  store i32 %431, ptr %0, align 4, !tbaa !8
  %432 = getelementptr inbounds i8, ptr %4, i64 48
  %433 = load float, ptr %432, align 16, !tbaa !5
  %434 = fadd float %433, -8.740000e+02
  %435 = call float @llvm.fabs.f32(float %434)
  %or.cond57 = fcmp ogt float %435, 0x3E80000000000000
  br i1 %or.cond57, label %436, label %444

436:                                              ; preds = %429
  %437 = getelementptr inbounds i8, ptr %0, i64 4
  %438 = load i32, ptr %437, align 4, !tbaa !11
  %439 = add nsw i32 %438, 1
  store i32 %439, ptr %437, align 4, !tbaa !11
  %440 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 593)
  %441 = fpext float %433 to double
  %442 = fpext float %434 to double
  %443 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.740000e+02, double noundef %441, double noundef %442)
  %.pre491 = load i32, ptr %0, align 4, !tbaa !8
  br label %444

444:                                              ; preds = %429, %436
  %445 = phi i32 [ %431, %429 ], [ %.pre491, %436 ]
  %446 = add nsw i32 %445, 1
  store i32 %446, ptr %0, align 4, !tbaa !8
  %447 = getelementptr inbounds i8, ptr %4, i64 52
  %448 = load float, ptr %447, align 4, !tbaa !5
  %449 = fadd float %448, -9.960000e+02
  %450 = call float @llvm.fabs.f32(float %449)
  %or.cond59 = fcmp ogt float %450, 0x3E80000000000000
  br i1 %or.cond59, label %451, label %459

451:                                              ; preds = %444
  %452 = getelementptr inbounds i8, ptr %0, i64 4
  %453 = load i32, ptr %452, align 4, !tbaa !11
  %454 = add nsw i32 %453, 1
  store i32 %454, ptr %452, align 4, !tbaa !11
  %455 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 594)
  %456 = fpext float %448 to double
  %457 = fpext float %449 to double
  %458 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.960000e+02, double noundef %456, double noundef %457)
  %.pre492 = load i32, ptr %0, align 4, !tbaa !8
  br label %459

459:                                              ; preds = %444, %451
  %460 = phi i32 [ %446, %444 ], [ %.pre492, %451 ]
  %461 = add nsw i32 %460, 1
  store i32 %461, ptr %0, align 4, !tbaa !8
  %462 = getelementptr inbounds i8, ptr %4, i64 56
  %463 = load float, ptr %462, align 8, !tbaa !5
  %464 = fadd float %463, -1.118000e+03
  %465 = call float @llvm.fabs.f32(float %464)
  %or.cond61 = fcmp ogt float %465, 0x3E80000000000000
  br i1 %or.cond61, label %466, label %474

466:                                              ; preds = %459
  %467 = getelementptr inbounds i8, ptr %0, i64 4
  %468 = load i32, ptr %467, align 4, !tbaa !11
  %469 = add nsw i32 %468, 1
  store i32 %469, ptr %467, align 4, !tbaa !11
  %470 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 595)
  %471 = fpext float %463 to double
  %472 = fpext float %464 to double
  %473 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.118000e+03, double noundef %471, double noundef %472)
  %.pre493 = load i32, ptr %0, align 4, !tbaa !8
  br label %474

474:                                              ; preds = %459, %466
  %475 = phi i32 [ %461, %459 ], [ %.pre493, %466 ]
  %476 = add nsw i32 %475, 1
  store i32 %476, ptr %0, align 4, !tbaa !8
  %477 = getelementptr inbounds i8, ptr %4, i64 60
  %478 = load float, ptr %477, align 4, !tbaa !5
  %479 = fadd float %478, -1.240000e+03
  %480 = call float @llvm.fabs.f32(float %479)
  %or.cond63 = fcmp ogt float %480, 0x3E80000000000000
  br i1 %or.cond63, label %481, label %489

481:                                              ; preds = %474
  %482 = getelementptr inbounds i8, ptr %0, i64 4
  %483 = load i32, ptr %482, align 4, !tbaa !11
  %484 = add nsw i32 %483, 1
  store i32 %484, ptr %482, align 4, !tbaa !11
  %485 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 596)
  %486 = fpext float %478 to double
  %487 = fpext float %479 to double
  %488 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.240000e+03, double noundef %486, double noundef %487)
  br label %489

489:                                              ; preds = %474, %481
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #5
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #5
  call void @_Zml8HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %5, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %1, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2)
  %490 = load i32, ptr %0, align 4, !tbaa !8
  %491 = add nsw i32 %490, 1
  store i32 %491, ptr %0, align 4, !tbaa !8
  %492 = load float, ptr %5, align 16, !tbaa !5
  %493 = fadd float %492, -5.380000e+02
  %494 = call float @llvm.fabs.f32(float %493)
  %or.cond65 = fcmp ogt float %494, 0x3E80000000000000
  br i1 %or.cond65, label %495, label %503

495:                                              ; preds = %489
  %496 = getelementptr inbounds i8, ptr %0, i64 4
  %497 = load i32, ptr %496, align 4, !tbaa !11
  %498 = add nsw i32 %497, 1
  store i32 %498, ptr %496, align 4, !tbaa !11
  %499 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 602)
  %500 = fpext float %492 to double
  %501 = fpext float %493 to double
  %502 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.380000e+02, double noundef %500, double noundef %501)
  %.pre494 = load i32, ptr %0, align 4, !tbaa !8
  br label %503

503:                                              ; preds = %489, %495
  %504 = phi i32 [ %491, %489 ], [ %.pre494, %495 ]
  %505 = add nsw i32 %504, 1
  store i32 %505, ptr %0, align 4, !tbaa !8
  %506 = getelementptr inbounds i8, ptr %5, i64 4
  %507 = load float, ptr %506, align 4, !tbaa !5
  %508 = fadd float %507, -6.120000e+02
  %509 = call float @llvm.fabs.f32(float %508)
  %or.cond67 = fcmp ogt float %509, 0x3E80000000000000
  br i1 %or.cond67, label %510, label %518

510:                                              ; preds = %503
  %511 = getelementptr inbounds i8, ptr %0, i64 4
  %512 = load i32, ptr %511, align 4, !tbaa !11
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %511, align 4, !tbaa !11
  %514 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 603)
  %515 = fpext float %507 to double
  %516 = fpext float %508 to double
  %517 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.120000e+02, double noundef %515, double noundef %516)
  %.pre495 = load i32, ptr %0, align 4, !tbaa !8
  br label %518

518:                                              ; preds = %503, %510
  %519 = phi i32 [ %505, %503 ], [ %.pre495, %510 ]
  %520 = add nsw i32 %519, 1
  store i32 %520, ptr %0, align 4, !tbaa !8
  %521 = getelementptr inbounds i8, ptr %5, i64 8
  %522 = load float, ptr %521, align 8, !tbaa !5
  %523 = fadd float %522, -6.860000e+02
  %524 = call float @llvm.fabs.f32(float %523)
  %or.cond69 = fcmp ogt float %524, 0x3E80000000000000
  br i1 %or.cond69, label %525, label %533

525:                                              ; preds = %518
  %526 = getelementptr inbounds i8, ptr %0, i64 4
  %527 = load i32, ptr %526, align 4, !tbaa !11
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %526, align 4, !tbaa !11
  %529 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 604)
  %530 = fpext float %522 to double
  %531 = fpext float %523 to double
  %532 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.860000e+02, double noundef %530, double noundef %531)
  %.pre496 = load i32, ptr %0, align 4, !tbaa !8
  br label %533

533:                                              ; preds = %518, %525
  %534 = phi i32 [ %520, %518 ], [ %.pre496, %525 ]
  %535 = add nsw i32 %534, 1
  store i32 %535, ptr %0, align 4, !tbaa !8
  %536 = getelementptr inbounds i8, ptr %5, i64 12
  %537 = load float, ptr %536, align 4, !tbaa !5
  %538 = fadd float %537, -7.600000e+02
  %539 = call float @llvm.fabs.f32(float %538)
  %or.cond71 = fcmp ogt float %539, 0x3E80000000000000
  br i1 %or.cond71, label %540, label %548

540:                                              ; preds = %533
  %541 = getelementptr inbounds i8, ptr %0, i64 4
  %542 = load i32, ptr %541, align 4, !tbaa !11
  %543 = add nsw i32 %542, 1
  store i32 %543, ptr %541, align 4, !tbaa !11
  %544 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 605)
  %545 = fpext float %537 to double
  %546 = fpext float %538 to double
  %547 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.600000e+02, double noundef %545, double noundef %546)
  %.pre497 = load i32, ptr %0, align 4, !tbaa !8
  br label %548

548:                                              ; preds = %533, %540
  %549 = phi i32 [ %535, %533 ], [ %.pre497, %540 ]
  %550 = add nsw i32 %549, 1
  store i32 %550, ptr %0, align 4, !tbaa !8
  %551 = getelementptr inbounds i8, ptr %5, i64 16
  %552 = load float, ptr %551, align 16, !tbaa !5
  %553 = fadd float %552, -6.500000e+02
  %554 = call float @llvm.fabs.f32(float %553)
  %or.cond73 = fcmp ogt float %554, 0x3E80000000000000
  br i1 %or.cond73, label %555, label %563

555:                                              ; preds = %548
  %556 = getelementptr inbounds i8, ptr %0, i64 4
  %557 = load i32, ptr %556, align 4, !tbaa !11
  %558 = add nsw i32 %557, 1
  store i32 %558, ptr %556, align 4, !tbaa !11
  %559 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 606)
  %560 = fpext float %552 to double
  %561 = fpext float %553 to double
  %562 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 6.500000e+02, double noundef %560, double noundef %561)
  %.pre498 = load i32, ptr %0, align 4, !tbaa !8
  br label %563

563:                                              ; preds = %548, %555
  %564 = phi i32 [ %550, %548 ], [ %.pre498, %555 ]
  %565 = add nsw i32 %564, 1
  store i32 %565, ptr %0, align 4, !tbaa !8
  %566 = getelementptr inbounds i8, ptr %5, i64 20
  %567 = load float, ptr %566, align 4, !tbaa !5
  %568 = fadd float %567, -7.400000e+02
  %569 = call float @llvm.fabs.f32(float %568)
  %or.cond75 = fcmp ogt float %569, 0x3E80000000000000
  br i1 %or.cond75, label %570, label %578

570:                                              ; preds = %563
  %571 = getelementptr inbounds i8, ptr %0, i64 4
  %572 = load i32, ptr %571, align 4, !tbaa !11
  %573 = add nsw i32 %572, 1
  store i32 %573, ptr %571, align 4, !tbaa !11
  %574 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 607)
  %575 = fpext float %567 to double
  %576 = fpext float %568 to double
  %577 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.400000e+02, double noundef %575, double noundef %576)
  %.pre499 = load i32, ptr %0, align 4, !tbaa !8
  br label %578

578:                                              ; preds = %563, %570
  %579 = phi i32 [ %565, %563 ], [ %.pre499, %570 ]
  %580 = add nsw i32 %579, 1
  store i32 %580, ptr %0, align 4, !tbaa !8
  %581 = getelementptr inbounds i8, ptr %5, i64 24
  %582 = load float, ptr %581, align 8, !tbaa !5
  %583 = fadd float %582, -8.300000e+02
  %584 = call float @llvm.fabs.f32(float %583)
  %or.cond77 = fcmp ogt float %584, 0x3E80000000000000
  br i1 %or.cond77, label %585, label %593

585:                                              ; preds = %578
  %586 = getelementptr inbounds i8, ptr %0, i64 4
  %587 = load i32, ptr %586, align 4, !tbaa !11
  %588 = add nsw i32 %587, 1
  store i32 %588, ptr %586, align 4, !tbaa !11
  %589 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 608)
  %590 = fpext float %582 to double
  %591 = fpext float %583 to double
  %592 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.300000e+02, double noundef %590, double noundef %591)
  %.pre500 = load i32, ptr %0, align 4, !tbaa !8
  br label %593

593:                                              ; preds = %578, %585
  %594 = phi i32 [ %580, %578 ], [ %.pre500, %585 ]
  %595 = add nsw i32 %594, 1
  store i32 %595, ptr %0, align 4, !tbaa !8
  %596 = getelementptr inbounds i8, ptr %5, i64 28
  %597 = load float, ptr %596, align 4, !tbaa !5
  %598 = fadd float %597, -9.200000e+02
  %599 = call float @llvm.fabs.f32(float %598)
  %or.cond79 = fcmp ogt float %599, 0x3E80000000000000
  br i1 %or.cond79, label %600, label %608

600:                                              ; preds = %593
  %601 = getelementptr inbounds i8, ptr %0, i64 4
  %602 = load i32, ptr %601, align 4, !tbaa !11
  %603 = add nsw i32 %602, 1
  store i32 %603, ptr %601, align 4, !tbaa !11
  %604 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 609)
  %605 = fpext float %597 to double
  %606 = fpext float %598 to double
  %607 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.200000e+02, double noundef %605, double noundef %606)
  %.pre501 = load i32, ptr %0, align 4, !tbaa !8
  br label %608

608:                                              ; preds = %593, %600
  %609 = phi i32 [ %595, %593 ], [ %.pre501, %600 ]
  %610 = add nsw i32 %609, 1
  store i32 %610, ptr %0, align 4, !tbaa !8
  %611 = getelementptr inbounds i8, ptr %5, i64 32
  %612 = load float, ptr %611, align 16, !tbaa !5
  %613 = fadd float %612, -7.620000e+02
  %614 = call float @llvm.fabs.f32(float %613)
  %or.cond81 = fcmp ogt float %614, 0x3E80000000000000
  br i1 %or.cond81, label %615, label %623

615:                                              ; preds = %608
  %616 = getelementptr inbounds i8, ptr %0, i64 4
  %617 = load i32, ptr %616, align 4, !tbaa !11
  %618 = add nsw i32 %617, 1
  store i32 %618, ptr %616, align 4, !tbaa !11
  %619 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 610)
  %620 = fpext float %612 to double
  %621 = fpext float %613 to double
  %622 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 7.620000e+02, double noundef %620, double noundef %621)
  %.pre502 = load i32, ptr %0, align 4, !tbaa !8
  br label %623

623:                                              ; preds = %608, %615
  %624 = phi i32 [ %610, %608 ], [ %.pre502, %615 ]
  %625 = add nsw i32 %624, 1
  store i32 %625, ptr %0, align 4, !tbaa !8
  %626 = getelementptr inbounds i8, ptr %5, i64 36
  %627 = load float, ptr %626, align 4, !tbaa !5
  %628 = fadd float %627, -8.680000e+02
  %629 = call float @llvm.fabs.f32(float %628)
  %or.cond83 = fcmp ogt float %629, 0x3E80000000000000
  br i1 %or.cond83, label %630, label %638

630:                                              ; preds = %623
  %631 = getelementptr inbounds i8, ptr %0, i64 4
  %632 = load i32, ptr %631, align 4, !tbaa !11
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %631, align 4, !tbaa !11
  %634 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 611)
  %635 = fpext float %627 to double
  %636 = fpext float %628 to double
  %637 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.680000e+02, double noundef %635, double noundef %636)
  %.pre503 = load i32, ptr %0, align 4, !tbaa !8
  br label %638

638:                                              ; preds = %623, %630
  %639 = phi i32 [ %625, %623 ], [ %.pre503, %630 ]
  %640 = add nsw i32 %639, 1
  store i32 %640, ptr %0, align 4, !tbaa !8
  %641 = getelementptr inbounds i8, ptr %5, i64 40
  %642 = load float, ptr %641, align 8, !tbaa !5
  %643 = fadd float %642, -9.740000e+02
  %644 = call float @llvm.fabs.f32(float %643)
  %or.cond85 = fcmp ogt float %644, 0x3E80000000000000
  br i1 %or.cond85, label %645, label %653

645:                                              ; preds = %638
  %646 = getelementptr inbounds i8, ptr %0, i64 4
  %647 = load i32, ptr %646, align 4, !tbaa !11
  %648 = add nsw i32 %647, 1
  store i32 %648, ptr %646, align 4, !tbaa !11
  %649 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 612)
  %650 = fpext float %642 to double
  %651 = fpext float %643 to double
  %652 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.740000e+02, double noundef %650, double noundef %651)
  %.pre504 = load i32, ptr %0, align 4, !tbaa !8
  br label %653

653:                                              ; preds = %638, %645
  %654 = phi i32 [ %640, %638 ], [ %.pre504, %645 ]
  %655 = add nsw i32 %654, 1
  store i32 %655, ptr %0, align 4, !tbaa !8
  %656 = getelementptr inbounds i8, ptr %5, i64 44
  %657 = load float, ptr %656, align 4, !tbaa !5
  %658 = fadd float %657, -1.080000e+03
  %659 = call float @llvm.fabs.f32(float %658)
  %or.cond87 = fcmp ogt float %659, 0x3E80000000000000
  br i1 %or.cond87, label %660, label %668

660:                                              ; preds = %653
  %661 = getelementptr inbounds i8, ptr %0, i64 4
  %662 = load i32, ptr %661, align 4, !tbaa !11
  %663 = add nsw i32 %662, 1
  store i32 %663, ptr %661, align 4, !tbaa !11
  %664 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 613)
  %665 = fpext float %657 to double
  %666 = fpext float %658 to double
  %667 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.080000e+03, double noundef %665, double noundef %666)
  %.pre505 = load i32, ptr %0, align 4, !tbaa !8
  br label %668

668:                                              ; preds = %653, %660
  %669 = phi i32 [ %655, %653 ], [ %.pre505, %660 ]
  %670 = add nsw i32 %669, 1
  store i32 %670, ptr %0, align 4, !tbaa !8
  %671 = getelementptr inbounds i8, ptr %5, i64 48
  %672 = load float, ptr %671, align 16, !tbaa !5
  %673 = fadd float %672, -8.740000e+02
  %674 = call float @llvm.fabs.f32(float %673)
  %or.cond89 = fcmp ogt float %674, 0x3E80000000000000
  br i1 %or.cond89, label %675, label %683

675:                                              ; preds = %668
  %676 = getelementptr inbounds i8, ptr %0, i64 4
  %677 = load i32, ptr %676, align 4, !tbaa !11
  %678 = add nsw i32 %677, 1
  store i32 %678, ptr %676, align 4, !tbaa !11
  %679 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 614)
  %680 = fpext float %672 to double
  %681 = fpext float %673 to double
  %682 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 8.740000e+02, double noundef %680, double noundef %681)
  %.pre506 = load i32, ptr %0, align 4, !tbaa !8
  br label %683

683:                                              ; preds = %668, %675
  %684 = phi i32 [ %670, %668 ], [ %.pre506, %675 ]
  %685 = add nsw i32 %684, 1
  store i32 %685, ptr %0, align 4, !tbaa !8
  %686 = getelementptr inbounds i8, ptr %5, i64 52
  %687 = load float, ptr %686, align 4, !tbaa !5
  %688 = fadd float %687, -9.960000e+02
  %689 = call float @llvm.fabs.f32(float %688)
  %or.cond91 = fcmp ogt float %689, 0x3E80000000000000
  br i1 %or.cond91, label %690, label %698

690:                                              ; preds = %683
  %691 = getelementptr inbounds i8, ptr %0, i64 4
  %692 = load i32, ptr %691, align 4, !tbaa !11
  %693 = add nsw i32 %692, 1
  store i32 %693, ptr %691, align 4, !tbaa !11
  %694 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 615)
  %695 = fpext float %687 to double
  %696 = fpext float %688 to double
  %697 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 9.960000e+02, double noundef %695, double noundef %696)
  %.pre507 = load i32, ptr %0, align 4, !tbaa !8
  br label %698

698:                                              ; preds = %683, %690
  %699 = phi i32 [ %685, %683 ], [ %.pre507, %690 ]
  %700 = add nsw i32 %699, 1
  store i32 %700, ptr %0, align 4, !tbaa !8
  %701 = getelementptr inbounds i8, ptr %5, i64 56
  %702 = load float, ptr %701, align 8, !tbaa !5
  %703 = fadd float %702, -1.118000e+03
  %704 = call float @llvm.fabs.f32(float %703)
  %or.cond93 = fcmp ogt float %704, 0x3E80000000000000
  br i1 %or.cond93, label %705, label %713

705:                                              ; preds = %698
  %706 = getelementptr inbounds i8, ptr %0, i64 4
  %707 = load i32, ptr %706, align 4, !tbaa !11
  %708 = add nsw i32 %707, 1
  store i32 %708, ptr %706, align 4, !tbaa !11
  %709 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 616)
  %710 = fpext float %702 to double
  %711 = fpext float %703 to double
  %712 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.118000e+03, double noundef %710, double noundef %711)
  %.pre508 = load i32, ptr %0, align 4, !tbaa !8
  br label %713

713:                                              ; preds = %698, %705
  %714 = phi i32 [ %700, %698 ], [ %.pre508, %705 ]
  %715 = add nsw i32 %714, 1
  store i32 %715, ptr %0, align 4, !tbaa !8
  %716 = getelementptr inbounds i8, ptr %5, i64 60
  %717 = load float, ptr %716, align 4, !tbaa !5
  %718 = fadd float %717, -1.240000e+03
  %719 = call float @llvm.fabs.f32(float %718)
  %or.cond95 = fcmp ogt float %719, 0x3E80000000000000
  br i1 %or.cond95, label %720, label %728

720:                                              ; preds = %713
  %721 = getelementptr inbounds i8, ptr %0, i64 4
  %722 = load i32, ptr %721, align 4, !tbaa !11
  %723 = add nsw i32 %722, 1
  store i32 %723, ptr %721, align 4, !tbaa !11
  %724 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 617)
  %725 = fpext float %717 to double
  %726 = fpext float %718 to double
  %727 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.240000e+03, double noundef %725, double noundef %726)
  br label %728

728:                                              ; preds = %713, %720
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %1) #5
  ret void
}

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

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

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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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: DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,MemCpyOptPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass