; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z30_hmt_test_InvMatrix_InvGeneralP21hmt_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_Mat2 = type { [2 x [2 x float]] }
%union.HMM_Mat3 = type { [3 x [3 x float]] }
%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.16 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 x i8], align 1
@__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16
@__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix.47 = external hidden unnamed_addr constant %union.HMM_Mat2, align 4

; 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: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL7HMM_M2Df(float noundef) #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL7HMM_M3Df(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, float noundef) #4

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct(ptr noundef %0) #5 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca %union.HMM_Mat4, align 16
  %6 = alloca %union.HMM_Mat4, align 16
  %7 = alloca %union.HMM_Mat4, align 16
  %8 = alloca %union.HMM_Mat4, align 16
  %9 = alloca %union.HMM_Mat4, align 16
  %10 = alloca float, align 4
  %11 = alloca %union.HMM_Mat4, align 16
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca float, align 4
  %20 = alloca float, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca float, align 4
  %34 = alloca float, align 4
  %35 = alloca float, align 4
  %36 = alloca float, align 4
  %37 = alloca float, align 4
  %38 = alloca float, align 4
  %39 = alloca float, align 4
  %40 = alloca float, align 4
  %41 = alloca float, align 4
  %42 = alloca float, align 4
  %43 = alloca 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 %union.HMM_Mat4, align 16
  %50 = alloca %union.HMM_Mat4, align 16
  %51 = alloca %union.HMM_Mat4, align 16
  %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 float, align 4
  %82 = alloca float, align 4
  %83 = alloca float, align 4
  %84 = alloca float, align 4
  %85 = alloca float, align 4
  %86 = alloca %union.HMM_Mat3, align 4
  %87 = alloca %union.HMM_Mat3, align 4
  %88 = alloca %union.HMM_Mat3, align 4
  %89 = alloca %union.HMM_Mat3, align 8
  %90 = alloca %union.HMM_Mat3, align 4
  %91 = alloca %union.HMM_Mat3, align 8
  %92 = alloca %union.HMM_Mat3, align 8
  %93 = alloca float, align 4
  %94 = alloca %union.HMM_Mat3, align 8
  %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 %union.HMM_Mat3, align 4
  %116 = alloca %union.HMM_Mat3, align 8
  %117 = alloca %union.HMM_Mat3, align 4
  %118 = alloca %union.HMM_Mat3, align 8
  %119 = alloca %union.HMM_Mat3, align 8
  %120 = alloca %union.HMM_Mat3, align 8
  %121 = alloca float, align 4
  %122 = alloca float, align 4
  %123 = alloca float, align 4
  %124 = alloca float, align 4
  %125 = alloca float, align 4
  %126 = alloca float, align 4
  %127 = alloca float, align 4
  %128 = alloca float, align 4
  %129 = alloca float, align 4
  %130 = alloca float, align 4
  %131 = alloca float, align 4
  %132 = alloca float, align 4
  %133 = alloca float, align 4
  %134 = alloca float, align 4
  %135 = alloca float, align 4
  %136 = alloca float, align 4
  %137 = alloca float, align 4
  %138 = alloca float, align 4
  %139 = alloca float, align 4
  %140 = alloca float, align 4
  %141 = alloca %union.HMM_Mat2, align 4
  %142 = alloca %union.HMM_Mat2, align 4
  %143 = alloca %union.HMM_Mat2, align 4
  %144 = alloca %union.HMM_Mat2, align 4
  %145 = alloca %union.HMM_Mat2, align 4
  %146 = alloca %union.HMM_Mat2, align 4
  %147 = alloca %union.HMM_Mat2, align 4
  %148 = alloca float, align 4
  %149 = alloca %union.HMM_Mat2, align 4
  %150 = alloca float, align 4
  %151 = alloca float, align 4
  %152 = alloca float, align 4
  %153 = alloca float, align 4
  %154 = alloca float, align 4
  %155 = alloca float, align 4
  %156 = alloca float, align 4
  %157 = alloca float, align 4
  %158 = alloca float, align 4
  %159 = alloca float, align 4
  %160 = alloca %union.HMM_Mat2, align 4
  %161 = alloca %union.HMM_Mat2, align 4
  %162 = alloca %union.HMM_Mat2, align 4
  %163 = alloca %union.HMM_Mat2, align 4
  %164 = alloca %union.HMM_Mat2, align 4
  %165 = alloca %union.HMM_Mat2, align 4
  %166 = alloca float, align 4
  %167 = alloca float, align 4
  %168 = alloca float, align 4
  %169 = alloca float, align 4
  %170 = alloca float, align 4
  %171 = alloca float, align 4
  %172 = alloca float, align 4
  %173 = alloca float, align 4
  %174 = alloca float, align 4
  %175 = alloca float, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %3) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %3, ptr align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %4) #7
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %4, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr %5) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %6, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  call void @_ZL16HMM_InvGeneralM48HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %5, ptr noundef byval(%union.HMM_Mat4) align 16 %6)
  call void @llvm.lifetime.start.p0(i64 64, ptr %7) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %8, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %9, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !9
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %7, ptr noundef byval(%union.HMM_Mat4) align 16 %8, ptr noundef byval(%union.HMM_Mat4) align 16 %9)
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %11, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  %176 = call noundef float @_ZL17HMM_DeterminantM48HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16 %11)
  store float %176, ptr %10, align 4, !tbaa !11
  %177 = load ptr, ptr %2, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %177, i32 0, i32 0
  %179 = load i32, ptr %178, align 4, !tbaa !13
  %180 = add nsw i32 %179, 1
  store i32 %180, ptr %178, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  %181 = load float, ptr %10, align 4, !tbaa !11
  store float %181, ptr %12, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #7
  %182 = load float, ptr %12, align 4, !tbaa !11
  %183 = fsub float %182, -8.000000e+01
  store float %183, ptr %13, align 4, !tbaa !11
  %184 = load float, ptr %13, align 4, !tbaa !11
  %185 = fcmp olt float %184, 0xBE80000000000000
  br i1 %185, label %189, label %186

186:                                              ; preds = %1
  %187 = load float, ptr %13, align 4, !tbaa !11
  %188 = fcmp olt float 0x3E80000000000000, %187
  br i1 %188, label %189, label %200

189:                                              ; preds = %186, %1
  %190 = load ptr, ptr %2, align 8, !tbaa !5
  %191 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %190, i32 0, i32 1
  %192 = load i32, ptr %191, align 4, !tbaa !16
  %193 = add nsw i32 %192, 1
  store i32 %193, ptr %191, align 4, !tbaa !16
  %194 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 130)
  %195 = load float, ptr %12, align 4, !tbaa !11
  %196 = fpext float %195 to double
  %197 = load float, ptr %13, align 4, !tbaa !11
  %198 = fpext float %197 to double
  %199 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef -8.000000e+01, double noundef %196, double noundef %198)
  br label %200

200:                                              ; preds = %189, %186
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  %201 = load ptr, ptr %2, align 8, !tbaa !5
  %202 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %201, i32 0, i32 0
  %203 = load i32, ptr %202, align 4, !tbaa !13
  %204 = add nsw i32 %203, 1
  store i32 %204, ptr %202, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  %205 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %206 = getelementptr inbounds [4 x float], ptr %205, i64 0, i64 0
  %207 = load float, ptr %206, align 16, !tbaa !10
  store float %207, ptr %14, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #7
  %208 = load float, ptr %14, align 4, !tbaa !11
  %209 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %210 = getelementptr inbounds [4 x float], ptr %209, i64 0, i64 0
  %211 = load float, ptr %210, align 16, !tbaa !10
  %212 = fsub float %208, %211
  store float %212, ptr %15, align 4, !tbaa !11
  %213 = load float, ptr %15, align 4, !tbaa !11
  %214 = fcmp olt float %213, 0xBEE4F8B580000000
  br i1 %214, label %218, label %215

215:                                              ; preds = %200
  %216 = load float, ptr %15, align 4, !tbaa !11
  %217 = fcmp olt float 0x3EE4F8B580000000, %216
  br i1 %217, label %218, label %231

218:                                              ; preds = %215, %200
  %219 = load ptr, ptr %2, align 8, !tbaa !5
  %220 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %219, i32 0, i32 1
  %221 = load i32, ptr %220, align 4, !tbaa !16
  %222 = add nsw i32 %221, 1
  store i32 %222, ptr %220, align 4, !tbaa !16
  %223 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 132)
  %224 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %225 = getelementptr inbounds [4 x float], ptr %224, i64 0, i64 0
  %226 = load float, ptr %225, align 16, !tbaa !10
  %227 = fpext float %226 to double
  %228 = load float, ptr %14, align 4, !tbaa !11
  %229 = fpext float %228 to double
  %230 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %227, double noundef %229)
  br label %231

231:                                              ; preds = %218, %215
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #7
  %232 = load ptr, ptr %2, align 8, !tbaa !5
  %233 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %232, i32 0, i32 0
  %234 = load i32, ptr %233, align 4, !tbaa !13
  %235 = add nsw i32 %234, 1
  store i32 %235, ptr %233, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #7
  %236 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %237 = getelementptr inbounds [4 x float], ptr %236, i64 0, i64 1
  %238 = load float, ptr %237, align 4, !tbaa !10
  store float %238, ptr %16, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #7
  %239 = load float, ptr %16, align 4, !tbaa !11
  %240 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %241 = getelementptr inbounds [4 x float], ptr %240, i64 0, i64 1
  %242 = load float, ptr %241, align 4, !tbaa !10
  %243 = fsub float %239, %242
  store float %243, ptr %17, align 4, !tbaa !11
  %244 = load float, ptr %17, align 4, !tbaa !11
  %245 = fcmp olt float %244, 0xBEE4F8B580000000
  br i1 %245, label %249, label %246

246:                                              ; preds = %231
  %247 = load float, ptr %17, align 4, !tbaa !11
  %248 = fcmp olt float 0x3EE4F8B580000000, %247
  br i1 %248, label %249, label %262

249:                                              ; preds = %246, %231
  %250 = load ptr, ptr %2, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %250, i32 0, i32 1
  %252 = load i32, ptr %251, align 4, !tbaa !16
  %253 = add nsw i32 %252, 1
  store i32 %253, ptr %251, align 4, !tbaa !16
  %254 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 133)
  %255 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %256 = getelementptr inbounds [4 x float], ptr %255, i64 0, i64 1
  %257 = load float, ptr %256, align 4, !tbaa !10
  %258 = fpext float %257 to double
  %259 = load float, ptr %16, align 4, !tbaa !11
  %260 = fpext float %259 to double
  %261 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %258, double noundef %260)
  br label %262

262:                                              ; preds = %249, %246
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #7
  %263 = load ptr, ptr %2, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %263, i32 0, i32 0
  %265 = load i32, ptr %264, align 4, !tbaa !13
  %266 = add nsw i32 %265, 1
  store i32 %266, ptr %264, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #7
  %267 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %268 = getelementptr inbounds [4 x float], ptr %267, i64 0, i64 2
  %269 = load float, ptr %268, align 8, !tbaa !10
  store float %269, ptr %18, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #7
  %270 = load float, ptr %18, align 4, !tbaa !11
  %271 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %272 = getelementptr inbounds [4 x float], ptr %271, i64 0, i64 2
  %273 = load float, ptr %272, align 8, !tbaa !10
  %274 = fsub float %270, %273
  store float %274, ptr %19, align 4, !tbaa !11
  %275 = load float, ptr %19, align 4, !tbaa !11
  %276 = fcmp olt float %275, 0xBEE4F8B580000000
  br i1 %276, label %280, label %277

277:                                              ; preds = %262
  %278 = load float, ptr %19, align 4, !tbaa !11
  %279 = fcmp olt float 0x3EE4F8B580000000, %278
  br i1 %279, label %280, label %293

280:                                              ; preds = %277, %262
  %281 = load ptr, ptr %2, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %281, i32 0, i32 1
  %283 = load i32, ptr %282, align 4, !tbaa !16
  %284 = add nsw i32 %283, 1
  store i32 %284, ptr %282, align 4, !tbaa !16
  %285 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 134)
  %286 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %287 = getelementptr inbounds [4 x float], ptr %286, i64 0, i64 2
  %288 = load float, ptr %287, align 8, !tbaa !10
  %289 = fpext float %288 to double
  %290 = load float, ptr %18, align 4, !tbaa !11
  %291 = fpext float %290 to double
  %292 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %289, double noundef %291)
  br label %293

293:                                              ; preds = %280, %277
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #7
  %294 = load ptr, ptr %2, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %294, i32 0, i32 0
  %296 = load i32, ptr %295, align 4, !tbaa !13
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %295, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #7
  %298 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %299 = getelementptr inbounds [4 x float], ptr %298, i64 0, i64 3
  %300 = load float, ptr %299, align 4, !tbaa !10
  store float %300, ptr %20, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #7
  %301 = load float, ptr %20, align 4, !tbaa !11
  %302 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %303 = getelementptr inbounds [4 x float], ptr %302, i64 0, i64 3
  %304 = load float, ptr %303, align 4, !tbaa !10
  %305 = fsub float %301, %304
  store float %305, ptr %21, align 4, !tbaa !11
  %306 = load float, ptr %21, align 4, !tbaa !11
  %307 = fcmp olt float %306, 0xBEE4F8B580000000
  br i1 %307, label %311, label %308

308:                                              ; preds = %293
  %309 = load float, ptr %21, align 4, !tbaa !11
  %310 = fcmp olt float 0x3EE4F8B580000000, %309
  br i1 %310, label %311, label %324

311:                                              ; preds = %308, %293
  %312 = load ptr, ptr %2, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %312, i32 0, i32 1
  %314 = load i32, ptr %313, align 4, !tbaa !16
  %315 = add nsw i32 %314, 1
  store i32 %315, ptr %313, align 4, !tbaa !16
  %316 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 135)
  %317 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %318 = getelementptr inbounds [4 x float], ptr %317, i64 0, i64 3
  %319 = load float, ptr %318, align 4, !tbaa !10
  %320 = fpext float %319 to double
  %321 = load float, ptr %20, align 4, !tbaa !11
  %322 = fpext float %321 to double
  %323 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %320, double noundef %322)
  br label %324

324:                                              ; preds = %311, %308
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #7
  %325 = load ptr, ptr %2, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %325, i32 0, i32 0
  %327 = load i32, ptr %326, align 4, !tbaa !13
  %328 = add nsw i32 %327, 1
  store i32 %328, ptr %326, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #7
  %329 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %330 = getelementptr inbounds [4 x float], ptr %329, i64 0, i64 0
  %331 = load float, ptr %330, align 16, !tbaa !10
  store float %331, ptr %22, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #7
  %332 = load float, ptr %22, align 4, !tbaa !11
  %333 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %334 = getelementptr inbounds [4 x float], ptr %333, i64 0, i64 0
  %335 = load float, ptr %334, align 16, !tbaa !10
  %336 = fsub float %332, %335
  store float %336, ptr %23, align 4, !tbaa !11
  %337 = load float, ptr %23, align 4, !tbaa !11
  %338 = fcmp olt float %337, 0xBEE4F8B580000000
  br i1 %338, label %342, label %339

339:                                              ; preds = %324
  %340 = load float, ptr %23, align 4, !tbaa !11
  %341 = fcmp olt float 0x3EE4F8B580000000, %340
  br i1 %341, label %342, label %355

342:                                              ; preds = %339, %324
  %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 !16
  %346 = add nsw i32 %345, 1
  store i32 %346, ptr %344, align 4, !tbaa !16
  %347 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 136)
  %348 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %349 = getelementptr inbounds [4 x float], ptr %348, i64 0, i64 0
  %350 = load float, ptr %349, align 16, !tbaa !10
  %351 = fpext float %350 to double
  %352 = load float, ptr %22, align 4, !tbaa !11
  %353 = fpext float %352 to double
  %354 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %351, double noundef %353)
  br label %355

355:                                              ; preds = %342, %339
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #7
  %356 = load ptr, ptr %2, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %356, i32 0, i32 0
  %358 = load i32, ptr %357, align 4, !tbaa !13
  %359 = add nsw i32 %358, 1
  store i32 %359, ptr %357, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #7
  %360 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %361 = getelementptr inbounds [4 x float], ptr %360, i64 0, i64 1
  %362 = load float, ptr %361, align 4, !tbaa !10
  store float %362, ptr %24, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #7
  %363 = load float, ptr %24, align 4, !tbaa !11
  %364 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %365 = getelementptr inbounds [4 x float], ptr %364, i64 0, i64 1
  %366 = load float, ptr %365, align 4, !tbaa !10
  %367 = fsub float %363, %366
  store float %367, ptr %25, align 4, !tbaa !11
  %368 = load float, ptr %25, align 4, !tbaa !11
  %369 = fcmp olt float %368, 0xBEE4F8B580000000
  br i1 %369, label %373, label %370

370:                                              ; preds = %355
  %371 = load float, ptr %25, align 4, !tbaa !11
  %372 = fcmp olt float 0x3EE4F8B580000000, %371
  br i1 %372, label %373, label %386

373:                                              ; preds = %370, %355
  %374 = load ptr, ptr %2, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %374, i32 0, i32 1
  %376 = load i32, ptr %375, align 4, !tbaa !16
  %377 = add nsw i32 %376, 1
  store i32 %377, ptr %375, align 4, !tbaa !16
  %378 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 137)
  %379 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %380 = getelementptr inbounds [4 x float], ptr %379, i64 0, i64 1
  %381 = load float, ptr %380, align 4, !tbaa !10
  %382 = fpext float %381 to double
  %383 = load float, ptr %24, align 4, !tbaa !11
  %384 = fpext float %383 to double
  %385 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %382, double noundef %384)
  br label %386

386:                                              ; preds = %373, %370
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #7
  %387 = load ptr, ptr %2, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %387, i32 0, i32 0
  %389 = load i32, ptr %388, align 4, !tbaa !13
  %390 = add nsw i32 %389, 1
  store i32 %390, ptr %388, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #7
  %391 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %392 = getelementptr inbounds [4 x float], ptr %391, i64 0, i64 2
  %393 = load float, ptr %392, align 8, !tbaa !10
  store float %393, ptr %26, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #7
  %394 = load float, ptr %26, align 4, !tbaa !11
  %395 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %396 = getelementptr inbounds [4 x float], ptr %395, i64 0, i64 2
  %397 = load float, ptr %396, align 8, !tbaa !10
  %398 = fsub float %394, %397
  store float %398, ptr %27, align 4, !tbaa !11
  %399 = load float, ptr %27, align 4, !tbaa !11
  %400 = fcmp olt float %399, 0xBEE4F8B580000000
  br i1 %400, label %404, label %401

401:                                              ; preds = %386
  %402 = load float, ptr %27, align 4, !tbaa !11
  %403 = fcmp olt float 0x3EE4F8B580000000, %402
  br i1 %403, label %404, label %417

404:                                              ; preds = %401, %386
  %405 = load ptr, ptr %2, align 8, !tbaa !5
  %406 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %405, i32 0, i32 1
  %407 = load i32, ptr %406, align 4, !tbaa !16
  %408 = add nsw i32 %407, 1
  store i32 %408, ptr %406, align 4, !tbaa !16
  %409 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 138)
  %410 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %411 = getelementptr inbounds [4 x float], ptr %410, i64 0, i64 2
  %412 = load float, ptr %411, align 8, !tbaa !10
  %413 = fpext float %412 to double
  %414 = load float, ptr %26, align 4, !tbaa !11
  %415 = fpext float %414 to double
  %416 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %413, double noundef %415)
  br label %417

417:                                              ; preds = %404, %401
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #7
  %418 = load ptr, ptr %2, align 8, !tbaa !5
  %419 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %418, i32 0, i32 0
  %420 = load i32, ptr %419, align 4, !tbaa !13
  %421 = add nsw i32 %420, 1
  store i32 %421, ptr %419, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #7
  %422 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %423 = getelementptr inbounds [4 x float], ptr %422, i64 0, i64 3
  %424 = load float, ptr %423, align 4, !tbaa !10
  store float %424, ptr %28, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #7
  %425 = load float, ptr %28, align 4, !tbaa !11
  %426 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %427 = getelementptr inbounds [4 x float], ptr %426, i64 0, i64 3
  %428 = load float, ptr %427, align 4, !tbaa !10
  %429 = fsub float %425, %428
  store float %429, ptr %29, align 4, !tbaa !11
  %430 = load float, ptr %29, align 4, !tbaa !11
  %431 = fcmp olt float %430, 0xBEE4F8B580000000
  br i1 %431, label %435, label %432

432:                                              ; preds = %417
  %433 = load float, ptr %29, align 4, !tbaa !11
  %434 = fcmp olt float 0x3EE4F8B580000000, %433
  br i1 %434, label %435, label %448

435:                                              ; preds = %432, %417
  %436 = load ptr, ptr %2, align 8, !tbaa !5
  %437 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %436, i32 0, i32 1
  %438 = load i32, ptr %437, align 4, !tbaa !16
  %439 = add nsw i32 %438, 1
  store i32 %439, ptr %437, align 4, !tbaa !16
  %440 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 139)
  %441 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %442 = getelementptr inbounds [4 x float], ptr %441, i64 0, i64 3
  %443 = load float, ptr %442, align 4, !tbaa !10
  %444 = fpext float %443 to double
  %445 = load float, ptr %28, align 4, !tbaa !11
  %446 = fpext float %445 to double
  %447 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %444, double noundef %446)
  br label %448

448:                                              ; preds = %435, %432
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #7
  %449 = load ptr, ptr %2, align 8, !tbaa !5
  %450 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %449, i32 0, i32 0
  %451 = load i32, ptr %450, align 4, !tbaa !13
  %452 = add nsw i32 %451, 1
  store i32 %452, ptr %450, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #7
  %453 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %454 = getelementptr inbounds [4 x float], ptr %453, i64 0, i64 0
  %455 = load float, ptr %454, align 16, !tbaa !10
  store float %455, ptr %30, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #7
  %456 = load float, ptr %30, align 4, !tbaa !11
  %457 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %458 = getelementptr inbounds [4 x float], ptr %457, i64 0, i64 0
  %459 = load float, ptr %458, align 16, !tbaa !10
  %460 = fsub float %456, %459
  store float %460, ptr %31, align 4, !tbaa !11
  %461 = load float, ptr %31, align 4, !tbaa !11
  %462 = fcmp olt float %461, 0xBEE4F8B580000000
  br i1 %462, label %466, label %463

463:                                              ; preds = %448
  %464 = load float, ptr %31, align 4, !tbaa !11
  %465 = fcmp olt float 0x3EE4F8B580000000, %464
  br i1 %465, label %466, label %479

466:                                              ; preds = %463, %448
  %467 = load ptr, ptr %2, align 8, !tbaa !5
  %468 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %467, i32 0, i32 1
  %469 = load i32, ptr %468, align 4, !tbaa !16
  %470 = add nsw i32 %469, 1
  store i32 %470, ptr %468, align 4, !tbaa !16
  %471 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 140)
  %472 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %473 = getelementptr inbounds [4 x float], ptr %472, i64 0, i64 0
  %474 = load float, ptr %473, align 16, !tbaa !10
  %475 = fpext float %474 to double
  %476 = load float, ptr %30, align 4, !tbaa !11
  %477 = fpext float %476 to double
  %478 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %475, double noundef %477)
  br label %479

479:                                              ; preds = %466, %463
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #7
  %480 = load ptr, ptr %2, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %480, i32 0, i32 0
  %482 = load i32, ptr %481, align 4, !tbaa !13
  %483 = add nsw i32 %482, 1
  store i32 %483, ptr %481, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #7
  %484 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %485 = getelementptr inbounds [4 x float], ptr %484, i64 0, i64 1
  %486 = load float, ptr %485, align 4, !tbaa !10
  store float %486, ptr %32, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  %487 = load float, ptr %32, align 4, !tbaa !11
  %488 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %489 = getelementptr inbounds [4 x float], ptr %488, i64 0, i64 1
  %490 = load float, ptr %489, align 4, !tbaa !10
  %491 = fsub float %487, %490
  store float %491, ptr %33, align 4, !tbaa !11
  %492 = load float, ptr %33, align 4, !tbaa !11
  %493 = fcmp olt float %492, 0xBEE4F8B580000000
  br i1 %493, label %497, label %494

494:                                              ; preds = %479
  %495 = load float, ptr %33, align 4, !tbaa !11
  %496 = fcmp olt float 0x3EE4F8B580000000, %495
  br i1 %496, label %497, label %510

497:                                              ; preds = %494, %479
  %498 = load ptr, ptr %2, align 8, !tbaa !5
  %499 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %498, i32 0, i32 1
  %500 = load i32, ptr %499, align 4, !tbaa !16
  %501 = add nsw i32 %500, 1
  store i32 %501, ptr %499, align 4, !tbaa !16
  %502 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 141)
  %503 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %504 = getelementptr inbounds [4 x float], ptr %503, i64 0, i64 1
  %505 = load float, ptr %504, align 4, !tbaa !10
  %506 = fpext float %505 to double
  %507 = load float, ptr %32, align 4, !tbaa !11
  %508 = fpext float %507 to double
  %509 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %506, double noundef %508)
  br label %510

510:                                              ; preds = %497, %494
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #7
  %511 = load ptr, ptr %2, align 8, !tbaa !5
  %512 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %511, i32 0, i32 0
  %513 = load i32, ptr %512, align 4, !tbaa !13
  %514 = add nsw i32 %513, 1
  store i32 %514, ptr %512, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #7
  %515 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %516 = getelementptr inbounds [4 x float], ptr %515, i64 0, i64 2
  %517 = load float, ptr %516, align 8, !tbaa !10
  store float %517, ptr %34, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #7
  %518 = load float, ptr %34, align 4, !tbaa !11
  %519 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %520 = getelementptr inbounds [4 x float], ptr %519, i64 0, i64 2
  %521 = load float, ptr %520, align 8, !tbaa !10
  %522 = fsub float %518, %521
  store float %522, ptr %35, align 4, !tbaa !11
  %523 = load float, ptr %35, align 4, !tbaa !11
  %524 = fcmp olt float %523, 0xBEE4F8B580000000
  br i1 %524, label %528, label %525

525:                                              ; preds = %510
  %526 = load float, ptr %35, align 4, !tbaa !11
  %527 = fcmp olt float 0x3EE4F8B580000000, %526
  br i1 %527, label %528, label %541

528:                                              ; preds = %525, %510
  %529 = load ptr, ptr %2, align 8, !tbaa !5
  %530 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %529, i32 0, i32 1
  %531 = load i32, ptr %530, align 4, !tbaa !16
  %532 = add nsw i32 %531, 1
  store i32 %532, ptr %530, align 4, !tbaa !16
  %533 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 142)
  %534 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %535 = getelementptr inbounds [4 x float], ptr %534, i64 0, i64 2
  %536 = load float, ptr %535, align 8, !tbaa !10
  %537 = fpext float %536 to double
  %538 = load float, ptr %34, align 4, !tbaa !11
  %539 = fpext float %538 to double
  %540 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %537, double noundef %539)
  br label %541

541:                                              ; preds = %528, %525
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #7
  %542 = load ptr, ptr %2, align 8, !tbaa !5
  %543 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %542, i32 0, i32 0
  %544 = load i32, ptr %543, align 4, !tbaa !13
  %545 = add nsw i32 %544, 1
  store i32 %545, ptr %543, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #7
  %546 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %547 = getelementptr inbounds [4 x float], ptr %546, i64 0, i64 3
  %548 = load float, ptr %547, align 4, !tbaa !10
  store float %548, ptr %36, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #7
  %549 = load float, ptr %36, align 4, !tbaa !11
  %550 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %551 = getelementptr inbounds [4 x float], ptr %550, i64 0, i64 3
  %552 = load float, ptr %551, align 4, !tbaa !10
  %553 = fsub float %549, %552
  store float %553, ptr %37, align 4, !tbaa !11
  %554 = load float, ptr %37, align 4, !tbaa !11
  %555 = fcmp olt float %554, 0xBEE4F8B580000000
  br i1 %555, label %559, label %556

556:                                              ; preds = %541
  %557 = load float, ptr %37, align 4, !tbaa !11
  %558 = fcmp olt float 0x3EE4F8B580000000, %557
  br i1 %558, label %559, label %572

559:                                              ; preds = %556, %541
  %560 = load ptr, ptr %2, align 8, !tbaa !5
  %561 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %560, i32 0, i32 1
  %562 = load i32, ptr %561, align 4, !tbaa !16
  %563 = add nsw i32 %562, 1
  store i32 %563, ptr %561, align 4, !tbaa !16
  %564 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 143)
  %565 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %566 = getelementptr inbounds [4 x float], ptr %565, i64 0, i64 3
  %567 = load float, ptr %566, align 4, !tbaa !10
  %568 = fpext float %567 to double
  %569 = load float, ptr %36, align 4, !tbaa !11
  %570 = fpext float %569 to double
  %571 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %568, double noundef %570)
  br label %572

572:                                              ; preds = %559, %556
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #7
  %573 = load ptr, ptr %2, align 8, !tbaa !5
  %574 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %573, i32 0, i32 0
  %575 = load i32, ptr %574, align 4, !tbaa !13
  %576 = add nsw i32 %575, 1
  store i32 %576, ptr %574, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #7
  %577 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %578 = getelementptr inbounds [4 x float], ptr %577, i64 0, i64 0
  %579 = load float, ptr %578, align 16, !tbaa !10
  store float %579, ptr %38, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #7
  %580 = load float, ptr %38, align 4, !tbaa !11
  %581 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %582 = getelementptr inbounds [4 x float], ptr %581, i64 0, i64 0
  %583 = load float, ptr %582, align 16, !tbaa !10
  %584 = fsub float %580, %583
  store float %584, ptr %39, align 4, !tbaa !11
  %585 = load float, ptr %39, align 4, !tbaa !11
  %586 = fcmp olt float %585, 0xBEE4F8B580000000
  br i1 %586, label %590, label %587

587:                                              ; preds = %572
  %588 = load float, ptr %39, align 4, !tbaa !11
  %589 = fcmp olt float 0x3EE4F8B580000000, %588
  br i1 %589, label %590, label %603

590:                                              ; preds = %587, %572
  %591 = load ptr, ptr %2, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %591, i32 0, i32 1
  %593 = load i32, ptr %592, align 4, !tbaa !16
  %594 = add nsw i32 %593, 1
  store i32 %594, ptr %592, align 4, !tbaa !16
  %595 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 144)
  %596 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %597 = getelementptr inbounds [4 x float], ptr %596, i64 0, i64 0
  %598 = load float, ptr %597, align 16, !tbaa !10
  %599 = fpext float %598 to double
  %600 = load float, ptr %38, align 4, !tbaa !11
  %601 = fpext float %600 to double
  %602 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %599, double noundef %601)
  br label %603

603:                                              ; preds = %590, %587
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #7
  %604 = load ptr, ptr %2, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %604, i32 0, i32 0
  %606 = load i32, ptr %605, align 4, !tbaa !13
  %607 = add nsw i32 %606, 1
  store i32 %607, ptr %605, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #7
  %608 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %609 = getelementptr inbounds [4 x float], ptr %608, i64 0, i64 1
  %610 = load float, ptr %609, align 4, !tbaa !10
  store float %610, ptr %40, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #7
  %611 = load float, ptr %40, align 4, !tbaa !11
  %612 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %613 = getelementptr inbounds [4 x float], ptr %612, i64 0, i64 1
  %614 = load float, ptr %613, align 4, !tbaa !10
  %615 = fsub float %611, %614
  store float %615, ptr %41, align 4, !tbaa !11
  %616 = load float, ptr %41, align 4, !tbaa !11
  %617 = fcmp olt float %616, 0xBEE4F8B580000000
  br i1 %617, label %621, label %618

618:                                              ; preds = %603
  %619 = load float, ptr %41, align 4, !tbaa !11
  %620 = fcmp olt float 0x3EE4F8B580000000, %619
  br i1 %620, label %621, label %634

621:                                              ; preds = %618, %603
  %622 = load ptr, ptr %2, align 8, !tbaa !5
  %623 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %622, i32 0, i32 1
  %624 = load i32, ptr %623, align 4, !tbaa !16
  %625 = add nsw i32 %624, 1
  store i32 %625, ptr %623, align 4, !tbaa !16
  %626 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 145)
  %627 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %628 = getelementptr inbounds [4 x float], ptr %627, i64 0, i64 1
  %629 = load float, ptr %628, align 4, !tbaa !10
  %630 = fpext float %629 to double
  %631 = load float, ptr %40, align 4, !tbaa !11
  %632 = fpext float %631 to double
  %633 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %630, double noundef %632)
  br label %634

634:                                              ; preds = %621, %618
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #7
  %635 = load ptr, ptr %2, align 8, !tbaa !5
  %636 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %635, i32 0, i32 0
  %637 = load i32, ptr %636, align 4, !tbaa !13
  %638 = add nsw i32 %637, 1
  store i32 %638, ptr %636, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #7
  %639 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %640 = getelementptr inbounds [4 x float], ptr %639, i64 0, i64 2
  %641 = load float, ptr %640, align 8, !tbaa !10
  store float %641, ptr %42, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #7
  %642 = load float, ptr %42, align 4, !tbaa !11
  %643 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %644 = getelementptr inbounds [4 x float], ptr %643, i64 0, i64 2
  %645 = load float, ptr %644, align 8, !tbaa !10
  %646 = fsub float %642, %645
  store float %646, ptr %43, align 4, !tbaa !11
  %647 = load float, ptr %43, align 4, !tbaa !11
  %648 = fcmp olt float %647, 0xBEE4F8B580000000
  br i1 %648, label %652, label %649

649:                                              ; preds = %634
  %650 = load float, ptr %43, align 4, !tbaa !11
  %651 = fcmp olt float 0x3EE4F8B580000000, %650
  br i1 %651, label %652, label %665

652:                                              ; preds = %649, %634
  %653 = load ptr, ptr %2, align 8, !tbaa !5
  %654 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %653, i32 0, i32 1
  %655 = load i32, ptr %654, align 4, !tbaa !16
  %656 = add nsw i32 %655, 1
  store i32 %656, ptr %654, align 4, !tbaa !16
  %657 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 146)
  %658 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %659 = getelementptr inbounds [4 x float], ptr %658, i64 0, i64 2
  %660 = load float, ptr %659, align 8, !tbaa !10
  %661 = fpext float %660 to double
  %662 = load float, ptr %42, align 4, !tbaa !11
  %663 = fpext float %662 to double
  %664 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %661, double noundef %663)
  br label %665

665:                                              ; preds = %652, %649
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #7
  %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 !13
  %669 = add nsw i32 %668, 1
  store i32 %669, ptr %667, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #7
  %670 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %671 = getelementptr inbounds [4 x float], ptr %670, i64 0, i64 3
  %672 = load float, ptr %671, align 4, !tbaa !10
  store float %672, ptr %44, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #7
  %673 = load float, ptr %44, align 4, !tbaa !11
  %674 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %675 = getelementptr inbounds [4 x float], ptr %674, i64 0, i64 3
  %676 = load float, ptr %675, align 4, !tbaa !10
  %677 = fsub float %673, %676
  store float %677, ptr %45, align 4, !tbaa !11
  %678 = load float, ptr %45, align 4, !tbaa !11
  %679 = fcmp olt float %678, 0xBEE4F8B580000000
  br i1 %679, label %683, label %680

680:                                              ; preds = %665
  %681 = load float, ptr %45, align 4, !tbaa !11
  %682 = fcmp olt float 0x3EE4F8B580000000, %681
  br i1 %682, label %683, label %696

683:                                              ; preds = %680, %665
  %684 = load ptr, ptr %2, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %684, i32 0, i32 1
  %686 = load i32, ptr %685, align 4, !tbaa !16
  %687 = add nsw i32 %686, 1
  store i32 %687, ptr %685, align 4, !tbaa !16
  %688 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 147)
  %689 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %690 = getelementptr inbounds [4 x float], ptr %689, i64 0, i64 3
  %691 = load float, ptr %690, align 4, !tbaa !10
  %692 = fpext float %691 to double
  %693 = load float, ptr %44, align 4, !tbaa !11
  %694 = fpext float %693 to double
  %695 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %692, double noundef %694)
  br label %696

696:                                              ; preds = %683, %680
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr %46) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %47, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  call void @_ZL14HMM_InvGeneral8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %46, ptr noundef byval(%union.HMM_Mat4) align 16 %47)
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %5, ptr align 16 %46, i64 64, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.end.p0(i64 64, ptr %46) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr %48) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %49, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %50, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !9
  call void @_ZL7HMM_Mul8HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %48, ptr noundef byval(%union.HMM_Mat4) align 16 %49, ptr noundef byval(%union.HMM_Mat4) align 16 %50)
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %7, ptr align 16 %48, i64 64, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.end.p0(i64 64, ptr %48) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %51, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !9
  %697 = call noundef float @_ZL15HMM_Determinant8HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16 %51)
  store float %697, ptr %10, align 4, !tbaa !11
  %698 = load ptr, ptr %2, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %698, i32 0, i32 0
  %700 = load i32, ptr %699, align 4, !tbaa !13
  %701 = add nsw i32 %700, 1
  store i32 %701, ptr %699, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #7
  %702 = load float, ptr %10, align 4, !tbaa !11
  store float %702, ptr %52, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #7
  %703 = load float, ptr %52, align 4, !tbaa !11
  %704 = fsub float %703, -8.000000e+01
  store float %704, ptr %53, align 4, !tbaa !11
  %705 = load float, ptr %53, align 4, !tbaa !11
  %706 = fcmp olt float %705, 0xBE80000000000000
  br i1 %706, label %710, label %707

707:                                              ; preds = %696
  %708 = load float, ptr %53, align 4, !tbaa !11
  %709 = fcmp olt float 0x3E80000000000000, %708
  br i1 %709, label %710, label %721

710:                                              ; preds = %707, %696
  %711 = load ptr, ptr %2, align 8, !tbaa !5
  %712 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %711, i32 0, i32 1
  %713 = load i32, ptr %712, align 4, !tbaa !16
  %714 = add nsw i32 %713, 1
  store i32 %714, ptr %712, align 4, !tbaa !16
  %715 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 154)
  %716 = load float, ptr %52, align 4, !tbaa !11
  %717 = fpext float %716 to double
  %718 = load float, ptr %53, align 4, !tbaa !11
  %719 = fpext float %718 to double
  %720 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef -8.000000e+01, double noundef %717, double noundef %719)
  br label %721

721:                                              ; preds = %710, %707
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #7
  %722 = load ptr, ptr %2, align 8, !tbaa !5
  %723 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %722, i32 0, i32 0
  %724 = load i32, ptr %723, align 4, !tbaa !13
  %725 = add nsw i32 %724, 1
  store i32 %725, ptr %723, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #7
  %726 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %727 = getelementptr inbounds [4 x float], ptr %726, i64 0, i64 0
  %728 = load float, ptr %727, align 16, !tbaa !10
  store float %728, ptr %54, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #7
  %729 = load float, ptr %54, align 4, !tbaa !11
  %730 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %731 = getelementptr inbounds [4 x float], ptr %730, i64 0, i64 0
  %732 = load float, ptr %731, align 16, !tbaa !10
  %733 = fsub float %729, %732
  store float %733, ptr %55, align 4, !tbaa !11
  %734 = load float, ptr %55, align 4, !tbaa !11
  %735 = fcmp olt float %734, 0xBEE4F8B580000000
  br i1 %735, label %739, label %736

736:                                              ; preds = %721
  %737 = load float, ptr %55, align 4, !tbaa !11
  %738 = fcmp olt float 0x3EE4F8B580000000, %737
  br i1 %738, label %739, label %752

739:                                              ; preds = %736, %721
  %740 = load ptr, ptr %2, align 8, !tbaa !5
  %741 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %740, i32 0, i32 1
  %742 = load i32, ptr %741, align 4, !tbaa !16
  %743 = add nsw i32 %742, 1
  store i32 %743, ptr %741, align 4, !tbaa !16
  %744 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 156)
  %745 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %746 = getelementptr inbounds [4 x float], ptr %745, i64 0, i64 0
  %747 = load float, ptr %746, align 16, !tbaa !10
  %748 = fpext float %747 to double
  %749 = load float, ptr %54, align 4, !tbaa !11
  %750 = fpext float %749 to double
  %751 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %748, double noundef %750)
  br label %752

752:                                              ; preds = %739, %736
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #7
  %753 = load ptr, ptr %2, align 8, !tbaa !5
  %754 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %753, i32 0, i32 0
  %755 = load i32, ptr %754, align 4, !tbaa !13
  %756 = add nsw i32 %755, 1
  store i32 %756, ptr %754, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #7
  %757 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %758 = getelementptr inbounds [4 x float], ptr %757, i64 0, i64 1
  %759 = load float, ptr %758, align 4, !tbaa !10
  store float %759, ptr %56, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #7
  %760 = load float, ptr %56, align 4, !tbaa !11
  %761 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %762 = getelementptr inbounds [4 x float], ptr %761, i64 0, i64 1
  %763 = load float, ptr %762, align 4, !tbaa !10
  %764 = fsub float %760, %763
  store float %764, ptr %57, align 4, !tbaa !11
  %765 = load float, ptr %57, align 4, !tbaa !11
  %766 = fcmp olt float %765, 0xBEE4F8B580000000
  br i1 %766, label %770, label %767

767:                                              ; preds = %752
  %768 = load float, ptr %57, align 4, !tbaa !11
  %769 = fcmp olt float 0x3EE4F8B580000000, %768
  br i1 %769, label %770, label %783

770:                                              ; preds = %767, %752
  %771 = load ptr, ptr %2, align 8, !tbaa !5
  %772 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %771, i32 0, i32 1
  %773 = load i32, ptr %772, align 4, !tbaa !16
  %774 = add nsw i32 %773, 1
  store i32 %774, ptr %772, align 4, !tbaa !16
  %775 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 157)
  %776 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %777 = getelementptr inbounds [4 x float], ptr %776, i64 0, i64 1
  %778 = load float, ptr %777, align 4, !tbaa !10
  %779 = fpext float %778 to double
  %780 = load float, ptr %56, align 4, !tbaa !11
  %781 = fpext float %780 to double
  %782 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %779, double noundef %781)
  br label %783

783:                                              ; preds = %770, %767
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #7
  %784 = load ptr, ptr %2, align 8, !tbaa !5
  %785 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %784, i32 0, i32 0
  %786 = load i32, ptr %785, align 4, !tbaa !13
  %787 = add nsw i32 %786, 1
  store i32 %787, ptr %785, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #7
  %788 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %789 = getelementptr inbounds [4 x float], ptr %788, i64 0, i64 2
  %790 = load float, ptr %789, align 8, !tbaa !10
  store float %790, ptr %58, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #7
  %791 = load float, ptr %58, align 4, !tbaa !11
  %792 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %793 = getelementptr inbounds [4 x float], ptr %792, i64 0, i64 2
  %794 = load float, ptr %793, align 8, !tbaa !10
  %795 = fsub float %791, %794
  store float %795, ptr %59, align 4, !tbaa !11
  %796 = load float, ptr %59, align 4, !tbaa !11
  %797 = fcmp olt float %796, 0xBEE4F8B580000000
  br i1 %797, label %801, label %798

798:                                              ; preds = %783
  %799 = load float, ptr %59, align 4, !tbaa !11
  %800 = fcmp olt float 0x3EE4F8B580000000, %799
  br i1 %800, label %801, label %814

801:                                              ; preds = %798, %783
  %802 = load ptr, ptr %2, align 8, !tbaa !5
  %803 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %802, i32 0, i32 1
  %804 = load i32, ptr %803, align 4, !tbaa !16
  %805 = add nsw i32 %804, 1
  store i32 %805, ptr %803, align 4, !tbaa !16
  %806 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 158)
  %807 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %808 = getelementptr inbounds [4 x float], ptr %807, i64 0, i64 2
  %809 = load float, ptr %808, align 8, !tbaa !10
  %810 = fpext float %809 to double
  %811 = load float, ptr %58, align 4, !tbaa !11
  %812 = fpext float %811 to double
  %813 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %810, double noundef %812)
  br label %814

814:                                              ; preds = %801, %798
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #7
  %815 = load ptr, ptr %2, align 8, !tbaa !5
  %816 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %815, i32 0, i32 0
  %817 = load i32, ptr %816, align 4, !tbaa !13
  %818 = add nsw i32 %817, 1
  store i32 %818, ptr %816, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #7
  %819 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 0
  %820 = getelementptr inbounds [4 x float], ptr %819, i64 0, i64 3
  %821 = load float, ptr %820, align 4, !tbaa !10
  store float %821, ptr %60, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #7
  %822 = load float, ptr %60, align 4, !tbaa !11
  %823 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %824 = getelementptr inbounds [4 x float], ptr %823, i64 0, i64 3
  %825 = load float, ptr %824, align 4, !tbaa !10
  %826 = fsub float %822, %825
  store float %826, ptr %61, align 4, !tbaa !11
  %827 = load float, ptr %61, align 4, !tbaa !11
  %828 = fcmp olt float %827, 0xBEE4F8B580000000
  br i1 %828, label %832, label %829

829:                                              ; preds = %814
  %830 = load float, ptr %61, align 4, !tbaa !11
  %831 = fcmp olt float 0x3EE4F8B580000000, %830
  br i1 %831, label %832, label %845

832:                                              ; preds = %829, %814
  %833 = load ptr, ptr %2, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %833, i32 0, i32 1
  %835 = load i32, ptr %834, align 4, !tbaa !16
  %836 = add nsw i32 %835, 1
  store i32 %836, ptr %834, align 4, !tbaa !16
  %837 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 159)
  %838 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 0
  %839 = getelementptr inbounds [4 x float], ptr %838, i64 0, i64 3
  %840 = load float, ptr %839, align 4, !tbaa !10
  %841 = fpext float %840 to double
  %842 = load float, ptr %60, align 4, !tbaa !11
  %843 = fpext float %842 to double
  %844 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %841, double noundef %843)
  br label %845

845:                                              ; preds = %832, %829
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #7
  %846 = load ptr, ptr %2, align 8, !tbaa !5
  %847 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %846, i32 0, i32 0
  %848 = load i32, ptr %847, align 4, !tbaa !13
  %849 = add nsw i32 %848, 1
  store i32 %849, ptr %847, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #7
  %850 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %851 = getelementptr inbounds [4 x float], ptr %850, i64 0, i64 0
  %852 = load float, ptr %851, align 16, !tbaa !10
  store float %852, ptr %62, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #7
  %853 = load float, ptr %62, align 4, !tbaa !11
  %854 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %855 = getelementptr inbounds [4 x float], ptr %854, i64 0, i64 0
  %856 = load float, ptr %855, align 16, !tbaa !10
  %857 = fsub float %853, %856
  store float %857, ptr %63, align 4, !tbaa !11
  %858 = load float, ptr %63, align 4, !tbaa !11
  %859 = fcmp olt float %858, 0xBEE4F8B580000000
  br i1 %859, label %863, label %860

860:                                              ; preds = %845
  %861 = load float, ptr %63, align 4, !tbaa !11
  %862 = fcmp olt float 0x3EE4F8B580000000, %861
  br i1 %862, label %863, label %876

863:                                              ; preds = %860, %845
  %864 = load ptr, ptr %2, align 8, !tbaa !5
  %865 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %864, i32 0, i32 1
  %866 = load i32, ptr %865, align 4, !tbaa !16
  %867 = add nsw i32 %866, 1
  store i32 %867, ptr %865, align 4, !tbaa !16
  %868 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 160)
  %869 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %870 = getelementptr inbounds [4 x float], ptr %869, i64 0, i64 0
  %871 = load float, ptr %870, align 16, !tbaa !10
  %872 = fpext float %871 to double
  %873 = load float, ptr %62, align 4, !tbaa !11
  %874 = fpext float %873 to double
  %875 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %872, double noundef %874)
  br label %876

876:                                              ; preds = %863, %860
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #7
  %877 = load ptr, ptr %2, align 8, !tbaa !5
  %878 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %877, i32 0, i32 0
  %879 = load i32, ptr %878, align 4, !tbaa !13
  %880 = add nsw i32 %879, 1
  store i32 %880, ptr %878, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #7
  %881 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %882 = getelementptr inbounds [4 x float], ptr %881, i64 0, i64 1
  %883 = load float, ptr %882, align 4, !tbaa !10
  store float %883, ptr %64, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #7
  %884 = load float, ptr %64, align 4, !tbaa !11
  %885 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %886 = getelementptr inbounds [4 x float], ptr %885, i64 0, i64 1
  %887 = load float, ptr %886, align 4, !tbaa !10
  %888 = fsub float %884, %887
  store float %888, ptr %65, align 4, !tbaa !11
  %889 = load float, ptr %65, align 4, !tbaa !11
  %890 = fcmp olt float %889, 0xBEE4F8B580000000
  br i1 %890, label %894, label %891

891:                                              ; preds = %876
  %892 = load float, ptr %65, align 4, !tbaa !11
  %893 = fcmp olt float 0x3EE4F8B580000000, %892
  br i1 %893, label %894, label %907

894:                                              ; preds = %891, %876
  %895 = load ptr, ptr %2, align 8, !tbaa !5
  %896 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %895, i32 0, i32 1
  %897 = load i32, ptr %896, align 4, !tbaa !16
  %898 = add nsw i32 %897, 1
  store i32 %898, ptr %896, align 4, !tbaa !16
  %899 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 161)
  %900 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %901 = getelementptr inbounds [4 x float], ptr %900, i64 0, i64 1
  %902 = load float, ptr %901, align 4, !tbaa !10
  %903 = fpext float %902 to double
  %904 = load float, ptr %64, align 4, !tbaa !11
  %905 = fpext float %904 to double
  %906 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %903, double noundef %905)
  br label %907

907:                                              ; preds = %894, %891
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #7
  %908 = load ptr, ptr %2, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %908, i32 0, i32 0
  %910 = load i32, ptr %909, align 4, !tbaa !13
  %911 = add nsw i32 %910, 1
  store i32 %911, ptr %909, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #7
  %912 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %913 = getelementptr inbounds [4 x float], ptr %912, i64 0, i64 2
  %914 = load float, ptr %913, align 8, !tbaa !10
  store float %914, ptr %66, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #7
  %915 = load float, ptr %66, align 4, !tbaa !11
  %916 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %917 = getelementptr inbounds [4 x float], ptr %916, i64 0, i64 2
  %918 = load float, ptr %917, align 8, !tbaa !10
  %919 = fsub float %915, %918
  store float %919, ptr %67, align 4, !tbaa !11
  %920 = load float, ptr %67, align 4, !tbaa !11
  %921 = fcmp olt float %920, 0xBEE4F8B580000000
  br i1 %921, label %925, label %922

922:                                              ; preds = %907
  %923 = load float, ptr %67, align 4, !tbaa !11
  %924 = fcmp olt float 0x3EE4F8B580000000, %923
  br i1 %924, label %925, label %938

925:                                              ; preds = %922, %907
  %926 = load ptr, ptr %2, align 8, !tbaa !5
  %927 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %926, i32 0, i32 1
  %928 = load i32, ptr %927, align 4, !tbaa !16
  %929 = add nsw i32 %928, 1
  store i32 %929, ptr %927, align 4, !tbaa !16
  %930 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 162)
  %931 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %932 = getelementptr inbounds [4 x float], ptr %931, i64 0, i64 2
  %933 = load float, ptr %932, align 8, !tbaa !10
  %934 = fpext float %933 to double
  %935 = load float, ptr %66, align 4, !tbaa !11
  %936 = fpext float %935 to double
  %937 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %934, double noundef %936)
  br label %938

938:                                              ; preds = %925, %922
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #7
  %939 = load ptr, ptr %2, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %939, i32 0, i32 0
  %941 = load i32, ptr %940, align 4, !tbaa !13
  %942 = add nsw i32 %941, 1
  store i32 %942, ptr %940, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #7
  %943 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 1
  %944 = getelementptr inbounds [4 x float], ptr %943, i64 0, i64 3
  %945 = load float, ptr %944, align 4, !tbaa !10
  store float %945, ptr %68, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #7
  %946 = load float, ptr %68, align 4, !tbaa !11
  %947 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %948 = getelementptr inbounds [4 x float], ptr %947, i64 0, i64 3
  %949 = load float, ptr %948, align 4, !tbaa !10
  %950 = fsub float %946, %949
  store float %950, ptr %69, align 4, !tbaa !11
  %951 = load float, ptr %69, align 4, !tbaa !11
  %952 = fcmp olt float %951, 0xBEE4F8B580000000
  br i1 %952, label %956, label %953

953:                                              ; preds = %938
  %954 = load float, ptr %69, align 4, !tbaa !11
  %955 = fcmp olt float 0x3EE4F8B580000000, %954
  br i1 %955, label %956, label %969

956:                                              ; preds = %953, %938
  %957 = load ptr, ptr %2, align 8, !tbaa !5
  %958 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %957, i32 0, i32 1
  %959 = load i32, ptr %958, align 4, !tbaa !16
  %960 = add nsw i32 %959, 1
  store i32 %960, ptr %958, align 4, !tbaa !16
  %961 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 163)
  %962 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 1
  %963 = getelementptr inbounds [4 x float], ptr %962, i64 0, i64 3
  %964 = load float, ptr %963, align 4, !tbaa !10
  %965 = fpext float %964 to double
  %966 = load float, ptr %68, align 4, !tbaa !11
  %967 = fpext float %966 to double
  %968 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %965, double noundef %967)
  br label %969

969:                                              ; preds = %956, %953
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #7
  %970 = load ptr, ptr %2, align 8, !tbaa !5
  %971 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %970, i32 0, i32 0
  %972 = load i32, ptr %971, align 4, !tbaa !13
  %973 = add nsw i32 %972, 1
  store i32 %973, ptr %971, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #7
  %974 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %975 = getelementptr inbounds [4 x float], ptr %974, i64 0, i64 0
  %976 = load float, ptr %975, align 16, !tbaa !10
  store float %976, ptr %70, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #7
  %977 = load float, ptr %70, align 4, !tbaa !11
  %978 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %979 = getelementptr inbounds [4 x float], ptr %978, i64 0, i64 0
  %980 = load float, ptr %979, align 16, !tbaa !10
  %981 = fsub float %977, %980
  store float %981, ptr %71, align 4, !tbaa !11
  %982 = load float, ptr %71, align 4, !tbaa !11
  %983 = fcmp olt float %982, 0xBEE4F8B580000000
  br i1 %983, label %987, label %984

984:                                              ; preds = %969
  %985 = load float, ptr %71, align 4, !tbaa !11
  %986 = fcmp olt float 0x3EE4F8B580000000, %985
  br i1 %986, label %987, label %1000

987:                                              ; preds = %984, %969
  %988 = load ptr, ptr %2, align 8, !tbaa !5
  %989 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %988, i32 0, i32 1
  %990 = load i32, ptr %989, align 4, !tbaa !16
  %991 = add nsw i32 %990, 1
  store i32 %991, ptr %989, align 4, !tbaa !16
  %992 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 164)
  %993 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %994 = getelementptr inbounds [4 x float], ptr %993, i64 0, i64 0
  %995 = load float, ptr %994, align 16, !tbaa !10
  %996 = fpext float %995 to double
  %997 = load float, ptr %70, align 4, !tbaa !11
  %998 = fpext float %997 to double
  %999 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %996, double noundef %998)
  br label %1000

1000:                                             ; preds = %987, %984
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #7
  %1001 = load ptr, ptr %2, align 8, !tbaa !5
  %1002 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1001, i32 0, i32 0
  %1003 = load i32, ptr %1002, align 4, !tbaa !13
  %1004 = add nsw i32 %1003, 1
  store i32 %1004, ptr %1002, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #7
  %1005 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %1006 = getelementptr inbounds [4 x float], ptr %1005, i64 0, i64 1
  %1007 = load float, ptr %1006, align 4, !tbaa !10
  store float %1007, ptr %72, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #7
  %1008 = load float, ptr %72, align 4, !tbaa !11
  %1009 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1010 = getelementptr inbounds [4 x float], ptr %1009, i64 0, i64 1
  %1011 = load float, ptr %1010, align 4, !tbaa !10
  %1012 = fsub float %1008, %1011
  store float %1012, ptr %73, align 4, !tbaa !11
  %1013 = load float, ptr %73, align 4, !tbaa !11
  %1014 = fcmp olt float %1013, 0xBEE4F8B580000000
  br i1 %1014, label %1018, label %1015

1015:                                             ; preds = %1000
  %1016 = load float, ptr %73, align 4, !tbaa !11
  %1017 = fcmp olt float 0x3EE4F8B580000000, %1016
  br i1 %1017, label %1018, label %1031

1018:                                             ; preds = %1015, %1000
  %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 !16
  %1022 = add nsw i32 %1021, 1
  store i32 %1022, ptr %1020, align 4, !tbaa !16
  %1023 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 165)
  %1024 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1025 = getelementptr inbounds [4 x float], ptr %1024, i64 0, i64 1
  %1026 = load float, ptr %1025, align 4, !tbaa !10
  %1027 = fpext float %1026 to double
  %1028 = load float, ptr %72, align 4, !tbaa !11
  %1029 = fpext float %1028 to double
  %1030 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1027, double noundef %1029)
  br label %1031

1031:                                             ; preds = %1018, %1015
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #7
  %1032 = load ptr, ptr %2, align 8, !tbaa !5
  %1033 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1032, i32 0, i32 0
  %1034 = load i32, ptr %1033, align 4, !tbaa !13
  %1035 = add nsw i32 %1034, 1
  store i32 %1035, ptr %1033, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #7
  %1036 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %1037 = getelementptr inbounds [4 x float], ptr %1036, i64 0, i64 2
  %1038 = load float, ptr %1037, align 8, !tbaa !10
  store float %1038, ptr %74, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #7
  %1039 = load float, ptr %74, align 4, !tbaa !11
  %1040 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1041 = getelementptr inbounds [4 x float], ptr %1040, i64 0, i64 2
  %1042 = load float, ptr %1041, align 8, !tbaa !10
  %1043 = fsub float %1039, %1042
  store float %1043, ptr %75, align 4, !tbaa !11
  %1044 = load float, ptr %75, align 4, !tbaa !11
  %1045 = fcmp olt float %1044, 0xBEE4F8B580000000
  br i1 %1045, label %1049, label %1046

1046:                                             ; preds = %1031
  %1047 = load float, ptr %75, align 4, !tbaa !11
  %1048 = fcmp olt float 0x3EE4F8B580000000, %1047
  br i1 %1048, label %1049, label %1062

1049:                                             ; preds = %1046, %1031
  %1050 = load ptr, ptr %2, align 8, !tbaa !5
  %1051 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1050, i32 0, i32 1
  %1052 = load i32, ptr %1051, align 4, !tbaa !16
  %1053 = add nsw i32 %1052, 1
  store i32 %1053, ptr %1051, align 4, !tbaa !16
  %1054 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 166)
  %1055 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1056 = getelementptr inbounds [4 x float], ptr %1055, i64 0, i64 2
  %1057 = load float, ptr %1056, align 8, !tbaa !10
  %1058 = fpext float %1057 to double
  %1059 = load float, ptr %74, align 4, !tbaa !11
  %1060 = fpext float %1059 to double
  %1061 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1058, double noundef %1060)
  br label %1062

1062:                                             ; preds = %1049, %1046
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #7
  %1063 = load ptr, ptr %2, align 8, !tbaa !5
  %1064 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1063, i32 0, i32 0
  %1065 = load i32, ptr %1064, align 4, !tbaa !13
  %1066 = add nsw i32 %1065, 1
  store i32 %1066, ptr %1064, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #7
  %1067 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 2
  %1068 = getelementptr inbounds [4 x float], ptr %1067, i64 0, i64 3
  %1069 = load float, ptr %1068, align 4, !tbaa !10
  store float %1069, ptr %76, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #7
  %1070 = load float, ptr %76, align 4, !tbaa !11
  %1071 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1072 = getelementptr inbounds [4 x float], ptr %1071, i64 0, i64 3
  %1073 = load float, ptr %1072, align 4, !tbaa !10
  %1074 = fsub float %1070, %1073
  store float %1074, ptr %77, align 4, !tbaa !11
  %1075 = load float, ptr %77, align 4, !tbaa !11
  %1076 = fcmp olt float %1075, 0xBEE4F8B580000000
  br i1 %1076, label %1080, label %1077

1077:                                             ; preds = %1062
  %1078 = load float, ptr %77, align 4, !tbaa !11
  %1079 = fcmp olt float 0x3EE4F8B580000000, %1078
  br i1 %1079, label %1080, label %1093

1080:                                             ; preds = %1077, %1062
  %1081 = load ptr, ptr %2, align 8, !tbaa !5
  %1082 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1081, i32 0, i32 1
  %1083 = load i32, ptr %1082, align 4, !tbaa !16
  %1084 = add nsw i32 %1083, 1
  store i32 %1084, ptr %1082, align 4, !tbaa !16
  %1085 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 167)
  %1086 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 2
  %1087 = getelementptr inbounds [4 x float], ptr %1086, i64 0, i64 3
  %1088 = load float, ptr %1087, align 4, !tbaa !10
  %1089 = fpext float %1088 to double
  %1090 = load float, ptr %76, align 4, !tbaa !11
  %1091 = fpext float %1090 to double
  %1092 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1089, double noundef %1091)
  br label %1093

1093:                                             ; preds = %1080, %1077
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #7
  %1094 = load ptr, ptr %2, align 8, !tbaa !5
  %1095 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1094, i32 0, i32 0
  %1096 = load i32, ptr %1095, align 4, !tbaa !13
  %1097 = add nsw i32 %1096, 1
  store i32 %1097, ptr %1095, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #7
  %1098 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %1099 = getelementptr inbounds [4 x float], ptr %1098, i64 0, i64 0
  %1100 = load float, ptr %1099, align 16, !tbaa !10
  store float %1100, ptr %78, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #7
  %1101 = load float, ptr %78, align 4, !tbaa !11
  %1102 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1103 = getelementptr inbounds [4 x float], ptr %1102, i64 0, i64 0
  %1104 = load float, ptr %1103, align 16, !tbaa !10
  %1105 = fsub float %1101, %1104
  store float %1105, ptr %79, align 4, !tbaa !11
  %1106 = load float, ptr %79, align 4, !tbaa !11
  %1107 = fcmp olt float %1106, 0xBEE4F8B580000000
  br i1 %1107, label %1111, label %1108

1108:                                             ; preds = %1093
  %1109 = load float, ptr %79, align 4, !tbaa !11
  %1110 = fcmp olt float 0x3EE4F8B580000000, %1109
  br i1 %1110, label %1111, label %1124

1111:                                             ; preds = %1108, %1093
  %1112 = load ptr, ptr %2, align 8, !tbaa !5
  %1113 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1112, i32 0, i32 1
  %1114 = load i32, ptr %1113, align 4, !tbaa !16
  %1115 = add nsw i32 %1114, 1
  store i32 %1115, ptr %1113, align 4, !tbaa !16
  %1116 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 168)
  %1117 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1118 = getelementptr inbounds [4 x float], ptr %1117, i64 0, i64 0
  %1119 = load float, ptr %1118, align 16, !tbaa !10
  %1120 = fpext float %1119 to double
  %1121 = load float, ptr %78, align 4, !tbaa !11
  %1122 = fpext float %1121 to double
  %1123 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1120, double noundef %1122)
  br label %1124

1124:                                             ; preds = %1111, %1108
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #7
  %1125 = load ptr, ptr %2, align 8, !tbaa !5
  %1126 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1125, i32 0, i32 0
  %1127 = load i32, ptr %1126, align 4, !tbaa !13
  %1128 = add nsw i32 %1127, 1
  store i32 %1128, ptr %1126, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #7
  %1129 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %1130 = getelementptr inbounds [4 x float], ptr %1129, i64 0, i64 1
  %1131 = load float, ptr %1130, align 4, !tbaa !10
  store float %1131, ptr %80, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #7
  %1132 = load float, ptr %80, align 4, !tbaa !11
  %1133 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1134 = getelementptr inbounds [4 x float], ptr %1133, i64 0, i64 1
  %1135 = load float, ptr %1134, align 4, !tbaa !10
  %1136 = fsub float %1132, %1135
  store float %1136, ptr %81, align 4, !tbaa !11
  %1137 = load float, ptr %81, align 4, !tbaa !11
  %1138 = fcmp olt float %1137, 0xBEE4F8B580000000
  br i1 %1138, label %1142, label %1139

1139:                                             ; preds = %1124
  %1140 = load float, ptr %81, align 4, !tbaa !11
  %1141 = fcmp olt float 0x3EE4F8B580000000, %1140
  br i1 %1141, label %1142, label %1155

1142:                                             ; preds = %1139, %1124
  %1143 = load ptr, ptr %2, align 8, !tbaa !5
  %1144 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1143, i32 0, i32 1
  %1145 = load i32, ptr %1144, align 4, !tbaa !16
  %1146 = add nsw i32 %1145, 1
  store i32 %1146, ptr %1144, align 4, !tbaa !16
  %1147 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 169)
  %1148 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1149 = getelementptr inbounds [4 x float], ptr %1148, i64 0, i64 1
  %1150 = load float, ptr %1149, align 4, !tbaa !10
  %1151 = fpext float %1150 to double
  %1152 = load float, ptr %80, align 4, !tbaa !11
  %1153 = fpext float %1152 to double
  %1154 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1151, double noundef %1153)
  br label %1155

1155:                                             ; preds = %1142, %1139
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #7
  %1156 = load ptr, ptr %2, align 8, !tbaa !5
  %1157 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1156, i32 0, i32 0
  %1158 = load i32, ptr %1157, align 4, !tbaa !13
  %1159 = add nsw i32 %1158, 1
  store i32 %1159, ptr %1157, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #7
  %1160 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %1161 = getelementptr inbounds [4 x float], ptr %1160, i64 0, i64 2
  %1162 = load float, ptr %1161, align 8, !tbaa !10
  store float %1162, ptr %82, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #7
  %1163 = load float, ptr %82, align 4, !tbaa !11
  %1164 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1165 = getelementptr inbounds [4 x float], ptr %1164, i64 0, i64 2
  %1166 = load float, ptr %1165, align 8, !tbaa !10
  %1167 = fsub float %1163, %1166
  store float %1167, ptr %83, align 4, !tbaa !11
  %1168 = load float, ptr %83, align 4, !tbaa !11
  %1169 = fcmp olt float %1168, 0xBEE4F8B580000000
  br i1 %1169, label %1173, label %1170

1170:                                             ; preds = %1155
  %1171 = load float, ptr %83, align 4, !tbaa !11
  %1172 = fcmp olt float 0x3EE4F8B580000000, %1171
  br i1 %1172, label %1173, label %1186

1173:                                             ; preds = %1170, %1155
  %1174 = load ptr, ptr %2, align 8, !tbaa !5
  %1175 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1174, i32 0, i32 1
  %1176 = load i32, ptr %1175, align 4, !tbaa !16
  %1177 = add nsw i32 %1176, 1
  store i32 %1177, ptr %1175, align 4, !tbaa !16
  %1178 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 170)
  %1179 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1180 = getelementptr inbounds [4 x float], ptr %1179, i64 0, i64 2
  %1181 = load float, ptr %1180, align 8, !tbaa !10
  %1182 = fpext float %1181 to double
  %1183 = load float, ptr %82, align 4, !tbaa !11
  %1184 = fpext float %1183 to double
  %1185 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1182, double noundef %1184)
  br label %1186

1186:                                             ; preds = %1173, %1170
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #7
  %1187 = load ptr, ptr %2, align 8, !tbaa !5
  %1188 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1187, i32 0, i32 0
  %1189 = load i32, ptr %1188, align 4, !tbaa !13
  %1190 = add nsw i32 %1189, 1
  store i32 %1190, ptr %1188, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #7
  %1191 = getelementptr inbounds [4 x [4 x float]], ptr %7, i64 0, i64 3
  %1192 = getelementptr inbounds [4 x float], ptr %1191, i64 0, i64 3
  %1193 = load float, ptr %1192, align 4, !tbaa !10
  store float %1193, ptr %84, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #7
  %1194 = load float, ptr %84, align 4, !tbaa !11
  %1195 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1196 = getelementptr inbounds [4 x float], ptr %1195, i64 0, i64 3
  %1197 = load float, ptr %1196, align 4, !tbaa !10
  %1198 = fsub float %1194, %1197
  store float %1198, ptr %85, align 4, !tbaa !11
  %1199 = load float, ptr %85, align 4, !tbaa !11
  %1200 = fcmp olt float %1199, 0xBEE4F8B580000000
  br i1 %1200, label %1204, label %1201

1201:                                             ; preds = %1186
  %1202 = load float, ptr %85, align 4, !tbaa !11
  %1203 = fcmp olt float 0x3EE4F8B580000000, %1202
  br i1 %1203, label %1204, label %1217

1204:                                             ; preds = %1201, %1186
  %1205 = load ptr, ptr %2, align 8, !tbaa !5
  %1206 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1205, i32 0, i32 1
  %1207 = load i32, ptr %1206, align 4, !tbaa !16
  %1208 = add nsw i32 %1207, 1
  store i32 %1208, ptr %1206, align 4, !tbaa !16
  %1209 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 171)
  %1210 = getelementptr inbounds [4 x [4 x float]], ptr %4, i64 0, i64 3
  %1211 = getelementptr inbounds [4 x float], ptr %1210, i64 0, i64 3
  %1212 = load float, ptr %1211, align 4, !tbaa !10
  %1213 = fpext float %1212 to double
  %1214 = load float, ptr %84, align 4, !tbaa !11
  %1215 = fpext float %1214 to double
  %1216 = call i32 (ptr, ...) @printf(ptr noundef @.str.16, double noundef %1213, double noundef %1215)
  br label %1217

1217:                                             ; preds = %1204, %1201
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %5) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %3) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr %86) #7
  call void @llvm.memset.p0.i64(ptr align 4 %86, i8 0, i64 36, i1 false)
  %1218 = getelementptr inbounds %union.HMM_Mat3, ptr %86, i32 0, i32 0
  %1219 = getelementptr inbounds [3 x [3 x float]], ptr %1218, i32 0, i32 0
  %1220 = getelementptr inbounds [3 x float], ptr %1219, i32 0, i32 0
  store float 1.200000e+01, ptr %1220, align 4
  %1221 = getelementptr inbounds [3 x float], ptr %1219, i32 0, i32 1
  store float 2.000000e+00, ptr %1221, align 4
  %1222 = getelementptr inbounds [3 x float], ptr %1219, i32 0, i32 2
  store float 1.000000e+00, ptr %1222, align 4
  %1223 = getelementptr inbounds [3 x [3 x float]], ptr %1218, i32 0, i32 1
  %1224 = getelementptr inbounds [3 x float], ptr %1223, i32 0, i32 2
  store float 1.000000e+00, ptr %1224, align 4
  %1225 = getelementptr inbounds [3 x [3 x float]], ptr %1218, i32 0, i32 2
  %1226 = getelementptr inbounds [3 x float], ptr %1225, i32 0, i32 1
  store float 1.000000e+00, ptr %1226, align 4
  %1227 = getelementptr inbounds [3 x float], ptr %1225, i32 0, i32 2
  store float 5.000000e+00, ptr %1227, align 4
  call void @llvm.lifetime.start.p0(i64 36, ptr %87) #7
  call void @_ZL7HMM_M3Df(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %87, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 36, ptr %88) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %89, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL16HMM_InvGeneralM38HMM_Mat3(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %88, ptr noundef byval(%union.HMM_Mat3) align 8 %89)
  call void @llvm.lifetime.start.p0(i64 36, ptr %90) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %91, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %92, ptr align 4 %88, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL9HMM_MulM38HMM_Mat3S_(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %90, ptr noundef byval(%union.HMM_Mat3) align 8 %91, ptr noundef byval(%union.HMM_Mat3) align 8 %92)
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %94, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  %1228 = call noundef float @_ZL17HMM_DeterminantM38HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8 %94)
  store float %1228, ptr %93, align 4, !tbaa !11
  %1229 = load ptr, ptr %2, align 8, !tbaa !5
  %1230 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1229, i32 0, i32 0
  %1231 = load i32, ptr %1230, align 4, !tbaa !13
  %1232 = add nsw i32 %1231, 1
  store i32 %1232, ptr %1230, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #7
  %1233 = load float, ptr %93, align 4, !tbaa !11
  store float %1233, ptr %95, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #7
  %1234 = load float, ptr %95, align 4, !tbaa !11
  %1235 = fsub float %1234, -1.200000e+01
  store float %1235, ptr %96, align 4, !tbaa !11
  %1236 = load float, ptr %96, align 4, !tbaa !11
  %1237 = fcmp olt float %1236, 0xBE80000000000000
  br i1 %1237, label %1241, label %1238

1238:                                             ; preds = %1217
  %1239 = load float, ptr %96, align 4, !tbaa !11
  %1240 = fcmp olt float 0x3E80000000000000, %1239
  br i1 %1240, label %1241, label %1252

1241:                                             ; preds = %1238, %1217
  %1242 = load ptr, ptr %2, align 8, !tbaa !5
  %1243 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1242, i32 0, i32 1
  %1244 = load i32, ptr %1243, align 4, !tbaa !16
  %1245 = add nsw i32 %1244, 1
  store i32 %1245, ptr %1243, align 4, !tbaa !16
  %1246 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 187)
  %1247 = load float, ptr %95, align 4, !tbaa !11
  %1248 = fpext float %1247 to double
  %1249 = load float, ptr %96, align 4, !tbaa !11
  %1250 = fpext float %1249 to double
  %1251 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef -1.200000e+01, double noundef %1248, double noundef %1250)
  br label %1252

1252:                                             ; preds = %1241, %1238
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #7
  %1253 = load ptr, ptr %2, align 8, !tbaa !5
  %1254 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1253, i32 0, i32 0
  %1255 = load i32, ptr %1254, align 4, !tbaa !13
  %1256 = add nsw i32 %1255, 1
  store i32 %1256, ptr %1254, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #7
  %1257 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1258 = getelementptr inbounds [3 x float], ptr %1257, i64 0, i64 0
  %1259 = load float, ptr %1258, align 4, !tbaa !10
  store float %1259, ptr %97, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #7
  %1260 = load float, ptr %97, align 4, !tbaa !11
  %1261 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1262 = getelementptr inbounds [3 x float], ptr %1261, i64 0, i64 0
  %1263 = load float, ptr %1262, align 4, !tbaa !10
  %1264 = fsub float %1260, %1263
  store float %1264, ptr %98, align 4, !tbaa !11
  %1265 = load float, ptr %98, align 4, !tbaa !11
  %1266 = fcmp olt float %1265, 0xBE80000000000000
  br i1 %1266, label %1270, label %1267

1267:                                             ; preds = %1252
  %1268 = load float, ptr %98, align 4, !tbaa !11
  %1269 = fcmp olt float 0x3E80000000000000, %1268
  br i1 %1269, label %1270, label %1285

1270:                                             ; preds = %1267, %1252
  %1271 = load ptr, ptr %2, align 8, !tbaa !5
  %1272 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1271, i32 0, i32 1
  %1273 = load i32, ptr %1272, align 4, !tbaa !16
  %1274 = add nsw i32 %1273, 1
  store i32 %1274, ptr %1272, align 4, !tbaa !16
  %1275 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 189)
  %1276 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1277 = getelementptr inbounds [3 x float], ptr %1276, i64 0, i64 0
  %1278 = load float, ptr %1277, align 4, !tbaa !10
  %1279 = fpext float %1278 to double
  %1280 = load float, ptr %97, align 4, !tbaa !11
  %1281 = fpext float %1280 to double
  %1282 = load float, ptr %98, align 4, !tbaa !11
  %1283 = fpext float %1282 to double
  %1284 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1279, double noundef %1281, double noundef %1283)
  br label %1285

1285:                                             ; preds = %1270, %1267
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #7
  %1286 = load ptr, ptr %2, align 8, !tbaa !5
  %1287 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1286, i32 0, i32 0
  %1288 = load i32, ptr %1287, align 4, !tbaa !13
  %1289 = add nsw i32 %1288, 1
  store i32 %1289, ptr %1287, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #7
  %1290 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1291 = getelementptr inbounds [3 x float], ptr %1290, i64 0, i64 1
  %1292 = load float, ptr %1291, align 4, !tbaa !10
  store float %1292, ptr %99, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #7
  %1293 = load float, ptr %99, align 4, !tbaa !11
  %1294 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1295 = getelementptr inbounds [3 x float], ptr %1294, i64 0, i64 1
  %1296 = load float, ptr %1295, align 4, !tbaa !10
  %1297 = fsub float %1293, %1296
  store float %1297, ptr %100, align 4, !tbaa !11
  %1298 = load float, ptr %100, align 4, !tbaa !11
  %1299 = fcmp olt float %1298, 0xBE80000000000000
  br i1 %1299, label %1303, label %1300

1300:                                             ; preds = %1285
  %1301 = load float, ptr %100, align 4, !tbaa !11
  %1302 = fcmp olt float 0x3E80000000000000, %1301
  br i1 %1302, label %1303, label %1318

1303:                                             ; preds = %1300, %1285
  %1304 = load ptr, ptr %2, align 8, !tbaa !5
  %1305 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1304, i32 0, i32 1
  %1306 = load i32, ptr %1305, align 4, !tbaa !16
  %1307 = add nsw i32 %1306, 1
  store i32 %1307, ptr %1305, align 4, !tbaa !16
  %1308 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 190)
  %1309 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1310 = getelementptr inbounds [3 x float], ptr %1309, i64 0, i64 1
  %1311 = load float, ptr %1310, align 4, !tbaa !10
  %1312 = fpext float %1311 to double
  %1313 = load float, ptr %99, align 4, !tbaa !11
  %1314 = fpext float %1313 to double
  %1315 = load float, ptr %100, align 4, !tbaa !11
  %1316 = fpext float %1315 to double
  %1317 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1312, double noundef %1314, double noundef %1316)
  br label %1318

1318:                                             ; preds = %1303, %1300
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #7
  %1319 = load ptr, ptr %2, align 8, !tbaa !5
  %1320 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1319, i32 0, i32 0
  %1321 = load i32, ptr %1320, align 4, !tbaa !13
  %1322 = add nsw i32 %1321, 1
  store i32 %1322, ptr %1320, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %101) #7
  %1323 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1324 = getelementptr inbounds [3 x float], ptr %1323, i64 0, i64 2
  %1325 = load float, ptr %1324, align 4, !tbaa !10
  store float %1325, ptr %101, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #7
  %1326 = load float, ptr %101, align 4, !tbaa !11
  %1327 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1328 = getelementptr inbounds [3 x float], ptr %1327, i64 0, i64 2
  %1329 = load float, ptr %1328, align 4, !tbaa !10
  %1330 = fsub float %1326, %1329
  store float %1330, ptr %102, align 4, !tbaa !11
  %1331 = load float, ptr %102, align 4, !tbaa !11
  %1332 = fcmp olt float %1331, 0xBE80000000000000
  br i1 %1332, label %1336, label %1333

1333:                                             ; preds = %1318
  %1334 = load float, ptr %102, align 4, !tbaa !11
  %1335 = fcmp olt float 0x3E80000000000000, %1334
  br i1 %1335, label %1336, label %1351

1336:                                             ; preds = %1333, %1318
  %1337 = load ptr, ptr %2, align 8, !tbaa !5
  %1338 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1337, i32 0, i32 1
  %1339 = load i32, ptr %1338, align 4, !tbaa !16
  %1340 = add nsw i32 %1339, 1
  store i32 %1340, ptr %1338, align 4, !tbaa !16
  %1341 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 191)
  %1342 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1343 = getelementptr inbounds [3 x float], ptr %1342, i64 0, i64 2
  %1344 = load float, ptr %1343, align 4, !tbaa !10
  %1345 = fpext float %1344 to double
  %1346 = load float, ptr %101, align 4, !tbaa !11
  %1347 = fpext float %1346 to double
  %1348 = load float, ptr %102, align 4, !tbaa !11
  %1349 = fpext float %1348 to double
  %1350 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1345, double noundef %1347, double noundef %1349)
  br label %1351

1351:                                             ; preds = %1336, %1333
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %101) #7
  %1352 = load ptr, ptr %2, align 8, !tbaa !5
  %1353 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1352, i32 0, i32 0
  %1354 = load i32, ptr %1353, align 4, !tbaa !13
  %1355 = add nsw i32 %1354, 1
  store i32 %1355, ptr %1353, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #7
  %1356 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1357 = getelementptr inbounds [3 x float], ptr %1356, i64 0, i64 0
  %1358 = load float, ptr %1357, align 4, !tbaa !10
  store float %1358, ptr %103, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #7
  %1359 = load float, ptr %103, align 4, !tbaa !11
  %1360 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1361 = getelementptr inbounds [3 x float], ptr %1360, i64 0, i64 0
  %1362 = load float, ptr %1361, align 4, !tbaa !10
  %1363 = fsub float %1359, %1362
  store float %1363, ptr %104, align 4, !tbaa !11
  %1364 = load float, ptr %104, align 4, !tbaa !11
  %1365 = fcmp olt float %1364, 0xBE80000000000000
  br i1 %1365, label %1369, label %1366

1366:                                             ; preds = %1351
  %1367 = load float, ptr %104, align 4, !tbaa !11
  %1368 = fcmp olt float 0x3E80000000000000, %1367
  br i1 %1368, label %1369, label %1384

1369:                                             ; preds = %1366, %1351
  %1370 = load ptr, ptr %2, align 8, !tbaa !5
  %1371 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1370, i32 0, i32 1
  %1372 = load i32, ptr %1371, align 4, !tbaa !16
  %1373 = add nsw i32 %1372, 1
  store i32 %1373, ptr %1371, align 4, !tbaa !16
  %1374 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 192)
  %1375 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1376 = getelementptr inbounds [3 x float], ptr %1375, i64 0, i64 0
  %1377 = load float, ptr %1376, align 4, !tbaa !10
  %1378 = fpext float %1377 to double
  %1379 = load float, ptr %103, align 4, !tbaa !11
  %1380 = fpext float %1379 to double
  %1381 = load float, ptr %104, align 4, !tbaa !11
  %1382 = fpext float %1381 to double
  %1383 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1378, double noundef %1380, double noundef %1382)
  br label %1384

1384:                                             ; preds = %1369, %1366
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #7
  %1385 = load ptr, ptr %2, align 8, !tbaa !5
  %1386 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1385, i32 0, i32 0
  %1387 = load i32, ptr %1386, align 4, !tbaa !13
  %1388 = add nsw i32 %1387, 1
  store i32 %1388, ptr %1386, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #7
  %1389 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1390 = getelementptr inbounds [3 x float], ptr %1389, i64 0, i64 1
  %1391 = load float, ptr %1390, align 4, !tbaa !10
  store float %1391, ptr %105, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #7
  %1392 = load float, ptr %105, align 4, !tbaa !11
  %1393 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1394 = getelementptr inbounds [3 x float], ptr %1393, i64 0, i64 1
  %1395 = load float, ptr %1394, align 4, !tbaa !10
  %1396 = fsub float %1392, %1395
  store float %1396, ptr %106, align 4, !tbaa !11
  %1397 = load float, ptr %106, align 4, !tbaa !11
  %1398 = fcmp olt float %1397, 0xBE80000000000000
  br i1 %1398, label %1402, label %1399

1399:                                             ; preds = %1384
  %1400 = load float, ptr %106, align 4, !tbaa !11
  %1401 = fcmp olt float 0x3E80000000000000, %1400
  br i1 %1401, label %1402, label %1417

1402:                                             ; preds = %1399, %1384
  %1403 = load ptr, ptr %2, align 8, !tbaa !5
  %1404 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1403, i32 0, i32 1
  %1405 = load i32, ptr %1404, align 4, !tbaa !16
  %1406 = add nsw i32 %1405, 1
  store i32 %1406, ptr %1404, align 4, !tbaa !16
  %1407 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 193)
  %1408 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1409 = getelementptr inbounds [3 x float], ptr %1408, i64 0, i64 1
  %1410 = load float, ptr %1409, align 4, !tbaa !10
  %1411 = fpext float %1410 to double
  %1412 = load float, ptr %105, align 4, !tbaa !11
  %1413 = fpext float %1412 to double
  %1414 = load float, ptr %106, align 4, !tbaa !11
  %1415 = fpext float %1414 to double
  %1416 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1411, double noundef %1413, double noundef %1415)
  br label %1417

1417:                                             ; preds = %1402, %1399
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #7
  %1418 = load ptr, ptr %2, align 8, !tbaa !5
  %1419 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1418, i32 0, i32 0
  %1420 = load i32, ptr %1419, align 4, !tbaa !13
  %1421 = add nsw i32 %1420, 1
  store i32 %1421, ptr %1419, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #7
  %1422 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1423 = getelementptr inbounds [3 x float], ptr %1422, i64 0, i64 2
  %1424 = load float, ptr %1423, align 4, !tbaa !10
  store float %1424, ptr %107, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %108) #7
  %1425 = load float, ptr %107, align 4, !tbaa !11
  %1426 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1427 = getelementptr inbounds [3 x float], ptr %1426, i64 0, i64 2
  %1428 = load float, ptr %1427, align 4, !tbaa !10
  %1429 = fsub float %1425, %1428
  store float %1429, ptr %108, align 4, !tbaa !11
  %1430 = load float, ptr %108, align 4, !tbaa !11
  %1431 = fcmp olt float %1430, 0xBE80000000000000
  br i1 %1431, label %1435, label %1432

1432:                                             ; preds = %1417
  %1433 = load float, ptr %108, align 4, !tbaa !11
  %1434 = fcmp olt float 0x3E80000000000000, %1433
  br i1 %1434, label %1435, label %1450

1435:                                             ; preds = %1432, %1417
  %1436 = load ptr, ptr %2, align 8, !tbaa !5
  %1437 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1436, i32 0, i32 1
  %1438 = load i32, ptr %1437, align 4, !tbaa !16
  %1439 = add nsw i32 %1438, 1
  store i32 %1439, ptr %1437, align 4, !tbaa !16
  %1440 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 194)
  %1441 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1442 = getelementptr inbounds [3 x float], ptr %1441, i64 0, i64 2
  %1443 = load float, ptr %1442, align 4, !tbaa !10
  %1444 = fpext float %1443 to double
  %1445 = load float, ptr %107, align 4, !tbaa !11
  %1446 = fpext float %1445 to double
  %1447 = load float, ptr %108, align 4, !tbaa !11
  %1448 = fpext float %1447 to double
  %1449 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1444, double noundef %1446, double noundef %1448)
  br label %1450

1450:                                             ; preds = %1435, %1432
  call void @llvm.lifetime.end.p0(i64 4, ptr %108) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #7
  %1451 = load ptr, ptr %2, align 8, !tbaa !5
  %1452 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1451, i32 0, i32 0
  %1453 = load i32, ptr %1452, align 4, !tbaa !13
  %1454 = add nsw i32 %1453, 1
  store i32 %1454, ptr %1452, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #7
  %1455 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1456 = getelementptr inbounds [3 x float], ptr %1455, i64 0, i64 0
  %1457 = load float, ptr %1456, align 4, !tbaa !10
  store float %1457, ptr %109, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %110) #7
  %1458 = load float, ptr %109, align 4, !tbaa !11
  %1459 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1460 = getelementptr inbounds [3 x float], ptr %1459, i64 0, i64 0
  %1461 = load float, ptr %1460, align 4, !tbaa !10
  %1462 = fsub float %1458, %1461
  store float %1462, ptr %110, align 4, !tbaa !11
  %1463 = load float, ptr %110, align 4, !tbaa !11
  %1464 = fcmp olt float %1463, 0xBE80000000000000
  br i1 %1464, label %1468, label %1465

1465:                                             ; preds = %1450
  %1466 = load float, ptr %110, align 4, !tbaa !11
  %1467 = fcmp olt float 0x3E80000000000000, %1466
  br i1 %1467, label %1468, label %1483

1468:                                             ; preds = %1465, %1450
  %1469 = load ptr, ptr %2, align 8, !tbaa !5
  %1470 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1469, i32 0, i32 1
  %1471 = load i32, ptr %1470, align 4, !tbaa !16
  %1472 = add nsw i32 %1471, 1
  store i32 %1472, ptr %1470, align 4, !tbaa !16
  %1473 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 195)
  %1474 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1475 = getelementptr inbounds [3 x float], ptr %1474, i64 0, i64 0
  %1476 = load float, ptr %1475, align 4, !tbaa !10
  %1477 = fpext float %1476 to double
  %1478 = load float, ptr %109, align 4, !tbaa !11
  %1479 = fpext float %1478 to double
  %1480 = load float, ptr %110, align 4, !tbaa !11
  %1481 = fpext float %1480 to double
  %1482 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1477, double noundef %1479, double noundef %1481)
  br label %1483

1483:                                             ; preds = %1468, %1465
  call void @llvm.lifetime.end.p0(i64 4, ptr %110) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #7
  %1484 = load ptr, ptr %2, align 8, !tbaa !5
  %1485 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1484, i32 0, i32 0
  %1486 = load i32, ptr %1485, align 4, !tbaa !13
  %1487 = add nsw i32 %1486, 1
  store i32 %1487, ptr %1485, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %111) #7
  %1488 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1489 = getelementptr inbounds [3 x float], ptr %1488, i64 0, i64 1
  %1490 = load float, ptr %1489, align 4, !tbaa !10
  store float %1490, ptr %111, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #7
  %1491 = load float, ptr %111, align 4, !tbaa !11
  %1492 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1493 = getelementptr inbounds [3 x float], ptr %1492, i64 0, i64 1
  %1494 = load float, ptr %1493, align 4, !tbaa !10
  %1495 = fsub float %1491, %1494
  store float %1495, ptr %112, align 4, !tbaa !11
  %1496 = load float, ptr %112, align 4, !tbaa !11
  %1497 = fcmp olt float %1496, 0xBE80000000000000
  br i1 %1497, label %1501, label %1498

1498:                                             ; preds = %1483
  %1499 = load float, ptr %112, align 4, !tbaa !11
  %1500 = fcmp olt float 0x3E80000000000000, %1499
  br i1 %1500, label %1501, label %1516

1501:                                             ; preds = %1498, %1483
  %1502 = load ptr, ptr %2, align 8, !tbaa !5
  %1503 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1502, i32 0, i32 1
  %1504 = load i32, ptr %1503, align 4, !tbaa !16
  %1505 = add nsw i32 %1504, 1
  store i32 %1505, ptr %1503, align 4, !tbaa !16
  %1506 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 196)
  %1507 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1508 = getelementptr inbounds [3 x float], ptr %1507, i64 0, i64 1
  %1509 = load float, ptr %1508, align 4, !tbaa !10
  %1510 = fpext float %1509 to double
  %1511 = load float, ptr %111, align 4, !tbaa !11
  %1512 = fpext float %1511 to double
  %1513 = load float, ptr %112, align 4, !tbaa !11
  %1514 = fpext float %1513 to double
  %1515 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1510, double noundef %1512, double noundef %1514)
  br label %1516

1516:                                             ; preds = %1501, %1498
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %111) #7
  %1517 = load ptr, ptr %2, align 8, !tbaa !5
  %1518 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1517, i32 0, i32 0
  %1519 = load i32, ptr %1518, align 4, !tbaa !13
  %1520 = add nsw i32 %1519, 1
  store i32 %1520, ptr %1518, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %113) #7
  %1521 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1522 = getelementptr inbounds [3 x float], ptr %1521, i64 0, i64 2
  %1523 = load float, ptr %1522, align 4, !tbaa !10
  store float %1523, ptr %113, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %114) #7
  %1524 = load float, ptr %113, align 4, !tbaa !11
  %1525 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1526 = getelementptr inbounds [3 x float], ptr %1525, i64 0, i64 2
  %1527 = load float, ptr %1526, align 4, !tbaa !10
  %1528 = fsub float %1524, %1527
  store float %1528, ptr %114, align 4, !tbaa !11
  %1529 = load float, ptr %114, align 4, !tbaa !11
  %1530 = fcmp olt float %1529, 0xBE80000000000000
  br i1 %1530, label %1534, label %1531

1531:                                             ; preds = %1516
  %1532 = load float, ptr %114, align 4, !tbaa !11
  %1533 = fcmp olt float 0x3E80000000000000, %1532
  br i1 %1533, label %1534, label %1549

1534:                                             ; preds = %1531, %1516
  %1535 = load ptr, ptr %2, align 8, !tbaa !5
  %1536 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1535, i32 0, i32 1
  %1537 = load i32, ptr %1536, align 4, !tbaa !16
  %1538 = add nsw i32 %1537, 1
  store i32 %1538, ptr %1536, align 4, !tbaa !16
  %1539 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 197)
  %1540 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1541 = getelementptr inbounds [3 x float], ptr %1540, i64 0, i64 2
  %1542 = load float, ptr %1541, align 4, !tbaa !10
  %1543 = fpext float %1542 to double
  %1544 = load float, ptr %113, align 4, !tbaa !11
  %1545 = fpext float %1544 to double
  %1546 = load float, ptr %114, align 4, !tbaa !11
  %1547 = fpext float %1546 to double
  %1548 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1543, double noundef %1545, double noundef %1547)
  br label %1549

1549:                                             ; preds = %1534, %1531
  call void @llvm.lifetime.end.p0(i64 4, ptr %114) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %113) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr %115) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %116, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL14HMM_InvGeneral8HMM_Mat3(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %115, ptr noundef byval(%union.HMM_Mat3) align 8 %116)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %88, ptr align 4 %115, i64 36, i1 false), !tbaa.struct !17
  call void @llvm.lifetime.end.p0(i64 36, ptr %115) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr %117) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %118, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %119, ptr align 4 %88, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL7HMM_Mul8HMM_Mat3S_(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %117, ptr noundef byval(%union.HMM_Mat3) align 8 %118, ptr noundef byval(%union.HMM_Mat3) align 8 %119)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %90, ptr align 4 %117, i64 36, i1 false), !tbaa.struct !17
  call void @llvm.lifetime.end.p0(i64 36, ptr %117) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %120, ptr align 4 %86, i64 36, i1 false), !tbaa.struct !17
  %1550 = call noundef float @_ZL15HMM_Determinant8HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8 %120)
  store float %1550, ptr %93, align 4, !tbaa !11
  %1551 = load ptr, ptr %2, align 8, !tbaa !5
  %1552 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1551, i32 0, i32 0
  %1553 = load i32, ptr %1552, align 4, !tbaa !13
  %1554 = add nsw i32 %1553, 1
  store i32 %1554, ptr %1552, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %121) #7
  %1555 = load float, ptr %93, align 4, !tbaa !11
  store float %1555, ptr %121, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %122) #7
  %1556 = load float, ptr %121, align 4, !tbaa !11
  %1557 = fsub float %1556, -1.200000e+01
  store float %1557, ptr %122, align 4, !tbaa !11
  %1558 = load float, ptr %122, align 4, !tbaa !11
  %1559 = fcmp olt float %1558, 0xBE80000000000000
  br i1 %1559, label %1563, label %1560

1560:                                             ; preds = %1549
  %1561 = load float, ptr %122, align 4, !tbaa !11
  %1562 = fcmp olt float 0x3E80000000000000, %1561
  br i1 %1562, label %1563, label %1574

1563:                                             ; preds = %1560, %1549
  %1564 = load ptr, ptr %2, align 8, !tbaa !5
  %1565 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1564, i32 0, i32 1
  %1566 = load i32, ptr %1565, align 4, !tbaa !16
  %1567 = add nsw i32 %1566, 1
  store i32 %1567, ptr %1565, align 4, !tbaa !16
  %1568 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 203)
  %1569 = load float, ptr %121, align 4, !tbaa !11
  %1570 = fpext float %1569 to double
  %1571 = load float, ptr %122, align 4, !tbaa !11
  %1572 = fpext float %1571 to double
  %1573 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef -1.200000e+01, double noundef %1570, double noundef %1572)
  br label %1574

1574:                                             ; preds = %1563, %1560
  call void @llvm.lifetime.end.p0(i64 4, ptr %122) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %121) #7
  %1575 = load ptr, ptr %2, align 8, !tbaa !5
  %1576 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1575, i32 0, i32 0
  %1577 = load i32, ptr %1576, align 4, !tbaa !13
  %1578 = add nsw i32 %1577, 1
  store i32 %1578, ptr %1576, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %123) #7
  %1579 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1580 = getelementptr inbounds [3 x float], ptr %1579, i64 0, i64 0
  %1581 = load float, ptr %1580, align 4, !tbaa !10
  store float %1581, ptr %123, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %124) #7
  %1582 = load float, ptr %123, align 4, !tbaa !11
  %1583 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1584 = getelementptr inbounds [3 x float], ptr %1583, i64 0, i64 0
  %1585 = load float, ptr %1584, align 4, !tbaa !10
  %1586 = fsub float %1582, %1585
  store float %1586, ptr %124, align 4, !tbaa !11
  %1587 = load float, ptr %124, align 4, !tbaa !11
  %1588 = fcmp olt float %1587, 0xBE80000000000000
  br i1 %1588, label %1592, label %1589

1589:                                             ; preds = %1574
  %1590 = load float, ptr %124, align 4, !tbaa !11
  %1591 = fcmp olt float 0x3E80000000000000, %1590
  br i1 %1591, label %1592, label %1607

1592:                                             ; preds = %1589, %1574
  %1593 = load ptr, ptr %2, align 8, !tbaa !5
  %1594 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1593, i32 0, i32 1
  %1595 = load i32, ptr %1594, align 4, !tbaa !16
  %1596 = add nsw i32 %1595, 1
  store i32 %1596, ptr %1594, align 4, !tbaa !16
  %1597 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 205)
  %1598 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1599 = getelementptr inbounds [3 x float], ptr %1598, i64 0, i64 0
  %1600 = load float, ptr %1599, align 4, !tbaa !10
  %1601 = fpext float %1600 to double
  %1602 = load float, ptr %123, align 4, !tbaa !11
  %1603 = fpext float %1602 to double
  %1604 = load float, ptr %124, align 4, !tbaa !11
  %1605 = fpext float %1604 to double
  %1606 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1601, double noundef %1603, double noundef %1605)
  br label %1607

1607:                                             ; preds = %1592, %1589
  call void @llvm.lifetime.end.p0(i64 4, ptr %124) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %123) #7
  %1608 = load ptr, ptr %2, align 8, !tbaa !5
  %1609 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1608, i32 0, i32 0
  %1610 = load i32, ptr %1609, align 4, !tbaa !13
  %1611 = add nsw i32 %1610, 1
  store i32 %1611, ptr %1609, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %125) #7
  %1612 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1613 = getelementptr inbounds [3 x float], ptr %1612, i64 0, i64 1
  %1614 = load float, ptr %1613, align 4, !tbaa !10
  store float %1614, ptr %125, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %126) #7
  %1615 = load float, ptr %125, align 4, !tbaa !11
  %1616 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1617 = getelementptr inbounds [3 x float], ptr %1616, i64 0, i64 1
  %1618 = load float, ptr %1617, align 4, !tbaa !10
  %1619 = fsub float %1615, %1618
  store float %1619, ptr %126, align 4, !tbaa !11
  %1620 = load float, ptr %126, align 4, !tbaa !11
  %1621 = fcmp olt float %1620, 0xBE80000000000000
  br i1 %1621, label %1625, label %1622

1622:                                             ; preds = %1607
  %1623 = load float, ptr %126, align 4, !tbaa !11
  %1624 = fcmp olt float 0x3E80000000000000, %1623
  br i1 %1624, label %1625, label %1640

1625:                                             ; preds = %1622, %1607
  %1626 = load ptr, ptr %2, align 8, !tbaa !5
  %1627 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1626, i32 0, i32 1
  %1628 = load i32, ptr %1627, align 4, !tbaa !16
  %1629 = add nsw i32 %1628, 1
  store i32 %1629, ptr %1627, align 4, !tbaa !16
  %1630 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 206)
  %1631 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1632 = getelementptr inbounds [3 x float], ptr %1631, i64 0, i64 1
  %1633 = load float, ptr %1632, align 4, !tbaa !10
  %1634 = fpext float %1633 to double
  %1635 = load float, ptr %125, align 4, !tbaa !11
  %1636 = fpext float %1635 to double
  %1637 = load float, ptr %126, align 4, !tbaa !11
  %1638 = fpext float %1637 to double
  %1639 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1634, double noundef %1636, double noundef %1638)
  br label %1640

1640:                                             ; preds = %1625, %1622
  call void @llvm.lifetime.end.p0(i64 4, ptr %126) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %125) #7
  %1641 = load ptr, ptr %2, align 8, !tbaa !5
  %1642 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1641, i32 0, i32 0
  %1643 = load i32, ptr %1642, align 4, !tbaa !13
  %1644 = add nsw i32 %1643, 1
  store i32 %1644, ptr %1642, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %127) #7
  %1645 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 0
  %1646 = getelementptr inbounds [3 x float], ptr %1645, i64 0, i64 2
  %1647 = load float, ptr %1646, align 4, !tbaa !10
  store float %1647, ptr %127, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %128) #7
  %1648 = load float, ptr %127, align 4, !tbaa !11
  %1649 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1650 = getelementptr inbounds [3 x float], ptr %1649, i64 0, i64 2
  %1651 = load float, ptr %1650, align 4, !tbaa !10
  %1652 = fsub float %1648, %1651
  store float %1652, ptr %128, align 4, !tbaa !11
  %1653 = load float, ptr %128, align 4, !tbaa !11
  %1654 = fcmp olt float %1653, 0xBE80000000000000
  br i1 %1654, label %1658, label %1655

1655:                                             ; preds = %1640
  %1656 = load float, ptr %128, align 4, !tbaa !11
  %1657 = fcmp olt float 0x3E80000000000000, %1656
  br i1 %1657, label %1658, label %1673

1658:                                             ; preds = %1655, %1640
  %1659 = load ptr, ptr %2, align 8, !tbaa !5
  %1660 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1659, i32 0, i32 1
  %1661 = load i32, ptr %1660, align 4, !tbaa !16
  %1662 = add nsw i32 %1661, 1
  store i32 %1662, ptr %1660, align 4, !tbaa !16
  %1663 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 207)
  %1664 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 0
  %1665 = getelementptr inbounds [3 x float], ptr %1664, i64 0, i64 2
  %1666 = load float, ptr %1665, align 4, !tbaa !10
  %1667 = fpext float %1666 to double
  %1668 = load float, ptr %127, align 4, !tbaa !11
  %1669 = fpext float %1668 to double
  %1670 = load float, ptr %128, align 4, !tbaa !11
  %1671 = fpext float %1670 to double
  %1672 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1667, double noundef %1669, double noundef %1671)
  br label %1673

1673:                                             ; preds = %1658, %1655
  call void @llvm.lifetime.end.p0(i64 4, ptr %128) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %127) #7
  %1674 = load ptr, ptr %2, align 8, !tbaa !5
  %1675 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1674, i32 0, i32 0
  %1676 = load i32, ptr %1675, align 4, !tbaa !13
  %1677 = add nsw i32 %1676, 1
  store i32 %1677, ptr %1675, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %129) #7
  %1678 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1679 = getelementptr inbounds [3 x float], ptr %1678, i64 0, i64 0
  %1680 = load float, ptr %1679, align 4, !tbaa !10
  store float %1680, ptr %129, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %130) #7
  %1681 = load float, ptr %129, align 4, !tbaa !11
  %1682 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1683 = getelementptr inbounds [3 x float], ptr %1682, i64 0, i64 0
  %1684 = load float, ptr %1683, align 4, !tbaa !10
  %1685 = fsub float %1681, %1684
  store float %1685, ptr %130, align 4, !tbaa !11
  %1686 = load float, ptr %130, align 4, !tbaa !11
  %1687 = fcmp olt float %1686, 0xBE80000000000000
  br i1 %1687, label %1691, label %1688

1688:                                             ; preds = %1673
  %1689 = load float, ptr %130, align 4, !tbaa !11
  %1690 = fcmp olt float 0x3E80000000000000, %1689
  br i1 %1690, label %1691, label %1706

1691:                                             ; preds = %1688, %1673
  %1692 = load ptr, ptr %2, align 8, !tbaa !5
  %1693 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1692, i32 0, i32 1
  %1694 = load i32, ptr %1693, align 4, !tbaa !16
  %1695 = add nsw i32 %1694, 1
  store i32 %1695, ptr %1693, align 4, !tbaa !16
  %1696 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 208)
  %1697 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1698 = getelementptr inbounds [3 x float], ptr %1697, i64 0, i64 0
  %1699 = load float, ptr %1698, align 4, !tbaa !10
  %1700 = fpext float %1699 to double
  %1701 = load float, ptr %129, align 4, !tbaa !11
  %1702 = fpext float %1701 to double
  %1703 = load float, ptr %130, align 4, !tbaa !11
  %1704 = fpext float %1703 to double
  %1705 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1700, double noundef %1702, double noundef %1704)
  br label %1706

1706:                                             ; preds = %1691, %1688
  call void @llvm.lifetime.end.p0(i64 4, ptr %130) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %129) #7
  %1707 = load ptr, ptr %2, align 8, !tbaa !5
  %1708 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1707, i32 0, i32 0
  %1709 = load i32, ptr %1708, align 4, !tbaa !13
  %1710 = add nsw i32 %1709, 1
  store i32 %1710, ptr %1708, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %131) #7
  %1711 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1712 = getelementptr inbounds [3 x float], ptr %1711, i64 0, i64 1
  %1713 = load float, ptr %1712, align 4, !tbaa !10
  store float %1713, ptr %131, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %132) #7
  %1714 = load float, ptr %131, align 4, !tbaa !11
  %1715 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1716 = getelementptr inbounds [3 x float], ptr %1715, i64 0, i64 1
  %1717 = load float, ptr %1716, align 4, !tbaa !10
  %1718 = fsub float %1714, %1717
  store float %1718, ptr %132, align 4, !tbaa !11
  %1719 = load float, ptr %132, align 4, !tbaa !11
  %1720 = fcmp olt float %1719, 0xBE80000000000000
  br i1 %1720, label %1724, label %1721

1721:                                             ; preds = %1706
  %1722 = load float, ptr %132, align 4, !tbaa !11
  %1723 = fcmp olt float 0x3E80000000000000, %1722
  br i1 %1723, label %1724, label %1739

1724:                                             ; preds = %1721, %1706
  %1725 = load ptr, ptr %2, align 8, !tbaa !5
  %1726 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1725, i32 0, i32 1
  %1727 = load i32, ptr %1726, align 4, !tbaa !16
  %1728 = add nsw i32 %1727, 1
  store i32 %1728, ptr %1726, align 4, !tbaa !16
  %1729 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 209)
  %1730 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1731 = getelementptr inbounds [3 x float], ptr %1730, i64 0, i64 1
  %1732 = load float, ptr %1731, align 4, !tbaa !10
  %1733 = fpext float %1732 to double
  %1734 = load float, ptr %131, align 4, !tbaa !11
  %1735 = fpext float %1734 to double
  %1736 = load float, ptr %132, align 4, !tbaa !11
  %1737 = fpext float %1736 to double
  %1738 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1733, double noundef %1735, double noundef %1737)
  br label %1739

1739:                                             ; preds = %1724, %1721
  call void @llvm.lifetime.end.p0(i64 4, ptr %132) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %131) #7
  %1740 = load ptr, ptr %2, align 8, !tbaa !5
  %1741 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1740, i32 0, i32 0
  %1742 = load i32, ptr %1741, align 4, !tbaa !13
  %1743 = add nsw i32 %1742, 1
  store i32 %1743, ptr %1741, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %133) #7
  %1744 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 1
  %1745 = getelementptr inbounds [3 x float], ptr %1744, i64 0, i64 2
  %1746 = load float, ptr %1745, align 4, !tbaa !10
  store float %1746, ptr %133, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %134) #7
  %1747 = load float, ptr %133, align 4, !tbaa !11
  %1748 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1749 = getelementptr inbounds [3 x float], ptr %1748, i64 0, i64 2
  %1750 = load float, ptr %1749, align 4, !tbaa !10
  %1751 = fsub float %1747, %1750
  store float %1751, ptr %134, align 4, !tbaa !11
  %1752 = load float, ptr %134, align 4, !tbaa !11
  %1753 = fcmp olt float %1752, 0xBE80000000000000
  br i1 %1753, label %1757, label %1754

1754:                                             ; preds = %1739
  %1755 = load float, ptr %134, align 4, !tbaa !11
  %1756 = fcmp olt float 0x3E80000000000000, %1755
  br i1 %1756, label %1757, label %1772

1757:                                             ; preds = %1754, %1739
  %1758 = load ptr, ptr %2, align 8, !tbaa !5
  %1759 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1758, i32 0, i32 1
  %1760 = load i32, ptr %1759, align 4, !tbaa !16
  %1761 = add nsw i32 %1760, 1
  store i32 %1761, ptr %1759, align 4, !tbaa !16
  %1762 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 210)
  %1763 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 1
  %1764 = getelementptr inbounds [3 x float], ptr %1763, i64 0, i64 2
  %1765 = load float, ptr %1764, align 4, !tbaa !10
  %1766 = fpext float %1765 to double
  %1767 = load float, ptr %133, align 4, !tbaa !11
  %1768 = fpext float %1767 to double
  %1769 = load float, ptr %134, align 4, !tbaa !11
  %1770 = fpext float %1769 to double
  %1771 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1766, double noundef %1768, double noundef %1770)
  br label %1772

1772:                                             ; preds = %1757, %1754
  call void @llvm.lifetime.end.p0(i64 4, ptr %134) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %133) #7
  %1773 = load ptr, ptr %2, align 8, !tbaa !5
  %1774 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1773, i32 0, i32 0
  %1775 = load i32, ptr %1774, align 4, !tbaa !13
  %1776 = add nsw i32 %1775, 1
  store i32 %1776, ptr %1774, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %135) #7
  %1777 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1778 = getelementptr inbounds [3 x float], ptr %1777, i64 0, i64 0
  %1779 = load float, ptr %1778, align 4, !tbaa !10
  store float %1779, ptr %135, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %136) #7
  %1780 = load float, ptr %135, align 4, !tbaa !11
  %1781 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1782 = getelementptr inbounds [3 x float], ptr %1781, i64 0, i64 0
  %1783 = load float, ptr %1782, align 4, !tbaa !10
  %1784 = fsub float %1780, %1783
  store float %1784, ptr %136, align 4, !tbaa !11
  %1785 = load float, ptr %136, align 4, !tbaa !11
  %1786 = fcmp olt float %1785, 0xBE80000000000000
  br i1 %1786, label %1790, label %1787

1787:                                             ; preds = %1772
  %1788 = load float, ptr %136, align 4, !tbaa !11
  %1789 = fcmp olt float 0x3E80000000000000, %1788
  br i1 %1789, label %1790, label %1805

1790:                                             ; preds = %1787, %1772
  %1791 = load ptr, ptr %2, align 8, !tbaa !5
  %1792 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1791, i32 0, i32 1
  %1793 = load i32, ptr %1792, align 4, !tbaa !16
  %1794 = add nsw i32 %1793, 1
  store i32 %1794, ptr %1792, align 4, !tbaa !16
  %1795 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 211)
  %1796 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1797 = getelementptr inbounds [3 x float], ptr %1796, i64 0, i64 0
  %1798 = load float, ptr %1797, align 4, !tbaa !10
  %1799 = fpext float %1798 to double
  %1800 = load float, ptr %135, align 4, !tbaa !11
  %1801 = fpext float %1800 to double
  %1802 = load float, ptr %136, align 4, !tbaa !11
  %1803 = fpext float %1802 to double
  %1804 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1799, double noundef %1801, double noundef %1803)
  br label %1805

1805:                                             ; preds = %1790, %1787
  call void @llvm.lifetime.end.p0(i64 4, ptr %136) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %135) #7
  %1806 = load ptr, ptr %2, align 8, !tbaa !5
  %1807 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1806, i32 0, i32 0
  %1808 = load i32, ptr %1807, align 4, !tbaa !13
  %1809 = add nsw i32 %1808, 1
  store i32 %1809, ptr %1807, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %137) #7
  %1810 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1811 = getelementptr inbounds [3 x float], ptr %1810, i64 0, i64 1
  %1812 = load float, ptr %1811, align 4, !tbaa !10
  store float %1812, ptr %137, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %138) #7
  %1813 = load float, ptr %137, align 4, !tbaa !11
  %1814 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1815 = getelementptr inbounds [3 x float], ptr %1814, i64 0, i64 1
  %1816 = load float, ptr %1815, align 4, !tbaa !10
  %1817 = fsub float %1813, %1816
  store float %1817, ptr %138, align 4, !tbaa !11
  %1818 = load float, ptr %138, align 4, !tbaa !11
  %1819 = fcmp olt float %1818, 0xBE80000000000000
  br i1 %1819, label %1823, label %1820

1820:                                             ; preds = %1805
  %1821 = load float, ptr %138, align 4, !tbaa !11
  %1822 = fcmp olt float 0x3E80000000000000, %1821
  br i1 %1822, label %1823, label %1838

1823:                                             ; preds = %1820, %1805
  %1824 = load ptr, ptr %2, align 8, !tbaa !5
  %1825 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1824, i32 0, i32 1
  %1826 = load i32, ptr %1825, align 4, !tbaa !16
  %1827 = add nsw i32 %1826, 1
  store i32 %1827, ptr %1825, align 4, !tbaa !16
  %1828 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 212)
  %1829 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1830 = getelementptr inbounds [3 x float], ptr %1829, i64 0, i64 1
  %1831 = load float, ptr %1830, align 4, !tbaa !10
  %1832 = fpext float %1831 to double
  %1833 = load float, ptr %137, align 4, !tbaa !11
  %1834 = fpext float %1833 to double
  %1835 = load float, ptr %138, align 4, !tbaa !11
  %1836 = fpext float %1835 to double
  %1837 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1832, double noundef %1834, double noundef %1836)
  br label %1838

1838:                                             ; preds = %1823, %1820
  call void @llvm.lifetime.end.p0(i64 4, ptr %138) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %137) #7
  %1839 = load ptr, ptr %2, align 8, !tbaa !5
  %1840 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1839, i32 0, i32 0
  %1841 = load i32, ptr %1840, align 4, !tbaa !13
  %1842 = add nsw i32 %1841, 1
  store i32 %1842, ptr %1840, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %139) #7
  %1843 = getelementptr inbounds [3 x [3 x float]], ptr %90, i64 0, i64 2
  %1844 = getelementptr inbounds [3 x float], ptr %1843, i64 0, i64 2
  %1845 = load float, ptr %1844, align 4, !tbaa !10
  store float %1845, ptr %139, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %140) #7
  %1846 = load float, ptr %139, align 4, !tbaa !11
  %1847 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1848 = getelementptr inbounds [3 x float], ptr %1847, i64 0, i64 2
  %1849 = load float, ptr %1848, align 4, !tbaa !10
  %1850 = fsub float %1846, %1849
  store float %1850, ptr %140, align 4, !tbaa !11
  %1851 = load float, ptr %140, align 4, !tbaa !11
  %1852 = fcmp olt float %1851, 0xBE80000000000000
  br i1 %1852, label %1856, label %1853

1853:                                             ; preds = %1838
  %1854 = load float, ptr %140, align 4, !tbaa !11
  %1855 = fcmp olt float 0x3E80000000000000, %1854
  br i1 %1855, label %1856, label %1871

1856:                                             ; preds = %1853, %1838
  %1857 = load ptr, ptr %2, align 8, !tbaa !5
  %1858 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1857, i32 0, i32 1
  %1859 = load i32, ptr %1858, align 4, !tbaa !16
  %1860 = add nsw i32 %1859, 1
  store i32 %1860, ptr %1858, align 4, !tbaa !16
  %1861 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 213)
  %1862 = getelementptr inbounds [3 x [3 x float]], ptr %87, i64 0, i64 2
  %1863 = getelementptr inbounds [3 x float], ptr %1862, i64 0, i64 2
  %1864 = load float, ptr %1863, align 4, !tbaa !10
  %1865 = fpext float %1864 to double
  %1866 = load float, ptr %139, align 4, !tbaa !11
  %1867 = fpext float %1866 to double
  %1868 = load float, ptr %140, align 4, !tbaa !11
  %1869 = fpext float %1868 to double
  %1870 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1865, double noundef %1867, double noundef %1869)
  br label %1871

1871:                                             ; preds = %1856, %1853
  call void @llvm.lifetime.end.p0(i64 4, ptr %140) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %139) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %90) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %88) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %87) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %86) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr %141) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %141, ptr align 4 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix.47, i64 16, i1 false)
  call void @llvm.lifetime.start.p0(i64 16, ptr %142) #7
  %1872 = call { <2 x float>, <2 x float> } @_ZL7HMM_M2Df(float noundef 1.000000e+00)
  %1873 = getelementptr inbounds %union.HMM_Mat2, ptr %142, i32 0, i32 0
  %1874 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1873, i32 0, i32 0
  %1875 = extractvalue { <2 x float>, <2 x float> } %1872, 0
  store <2 x float> %1875, ptr %1874, align 4
  %1876 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1873, i32 0, i32 1
  %1877 = extractvalue { <2 x float>, <2 x float> } %1872, 1
  store <2 x float> %1877, ptr %1876, align 4
  call void @llvm.lifetime.start.p0(i64 16, ptr %143) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %144, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  %1878 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %144, i32 0, i32 0
  %1879 = load <2 x float>, ptr %1878, align 4
  %1880 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %144, i32 0, i32 1
  %1881 = load <2 x float>, ptr %1880, align 4
  %1882 = call { <2 x float>, <2 x float> } @_ZL16HMM_InvGeneralM28HMM_Mat2(<2 x float> %1879, <2 x float> %1881)
  %1883 = getelementptr inbounds %union.HMM_Mat2, ptr %143, i32 0, i32 0
  %1884 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1883, i32 0, i32 0
  %1885 = extractvalue { <2 x float>, <2 x float> } %1882, 0
  store <2 x float> %1885, ptr %1884, align 4
  %1886 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1883, i32 0, i32 1
  %1887 = extractvalue { <2 x float>, <2 x float> } %1882, 1
  store <2 x float> %1887, ptr %1886, align 4
  call void @llvm.lifetime.start.p0(i64 16, ptr %145) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %146, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %147, ptr align 4 %143, i64 16, i1 false), !tbaa.struct !18
  %1888 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %146, i32 0, i32 0
  %1889 = load <2 x float>, ptr %1888, align 4
  %1890 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %146, i32 0, i32 1
  %1891 = load <2 x float>, ptr %1890, align 4
  %1892 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %147, i32 0, i32 0
  %1893 = load <2 x float>, ptr %1892, align 4
  %1894 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %147, i32 0, i32 1
  %1895 = load <2 x float>, ptr %1894, align 4
  %1896 = call { <2 x float>, <2 x float> } @_ZL9HMM_MulM28HMM_Mat2S_(<2 x float> %1889, <2 x float> %1891, <2 x float> %1893, <2 x float> %1895)
  %1897 = getelementptr inbounds %union.HMM_Mat2, ptr %145, i32 0, i32 0
  %1898 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1897, i32 0, i32 0
  %1899 = extractvalue { <2 x float>, <2 x float> } %1896, 0
  store <2 x float> %1899, ptr %1898, align 4
  %1900 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %1897, i32 0, i32 1
  %1901 = extractvalue { <2 x float>, <2 x float> } %1896, 1
  store <2 x float> %1901, ptr %1900, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %148) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %149, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  %1902 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %149, i32 0, i32 0
  %1903 = load <2 x float>, ptr %1902, align 4
  %1904 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %149, i32 0, i32 1
  %1905 = load <2 x float>, ptr %1904, align 4
  %1906 = call noundef float @_ZL17HMM_DeterminantM28HMM_Mat2(<2 x float> %1903, <2 x float> %1905)
  store float %1906, ptr %148, align 4, !tbaa !11
  %1907 = load ptr, ptr %2, align 8, !tbaa !5
  %1908 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1907, i32 0, i32 0
  %1909 = load i32, ptr %1908, align 4, !tbaa !13
  %1910 = add nsw i32 %1909, 1
  store i32 %1910, ptr %1908, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %150) #7
  %1911 = load float, ptr %148, align 4, !tbaa !11
  store float %1911, ptr %150, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %151) #7
  %1912 = load float, ptr %150, align 4, !tbaa !11
  %1913 = fsub float %1912, 5.800000e+01
  store float %1913, ptr %151, align 4, !tbaa !11
  %1914 = load float, ptr %151, align 4, !tbaa !11
  %1915 = fcmp olt float %1914, 0xBE80000000000000
  br i1 %1915, label %1919, label %1916

1916:                                             ; preds = %1871
  %1917 = load float, ptr %151, align 4, !tbaa !11
  %1918 = fcmp olt float 0x3E80000000000000, %1917
  br i1 %1918, label %1919, label %1930

1919:                                             ; preds = %1916, %1871
  %1920 = load ptr, ptr %2, align 8, !tbaa !5
  %1921 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1920, i32 0, i32 1
  %1922 = load i32, ptr %1921, align 4, !tbaa !16
  %1923 = add nsw i32 %1922, 1
  store i32 %1923, ptr %1921, align 4, !tbaa !16
  %1924 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 228)
  %1925 = load float, ptr %150, align 4, !tbaa !11
  %1926 = fpext float %1925 to double
  %1927 = load float, ptr %151, align 4, !tbaa !11
  %1928 = fpext float %1927 to double
  %1929 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.800000e+01, double noundef %1926, double noundef %1928)
  br label %1930

1930:                                             ; preds = %1919, %1916
  call void @llvm.lifetime.end.p0(i64 4, ptr %151) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %150) #7
  %1931 = load ptr, ptr %2, align 8, !tbaa !5
  %1932 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1931, i32 0, i32 0
  %1933 = load i32, ptr %1932, align 4, !tbaa !13
  %1934 = add nsw i32 %1933, 1
  store i32 %1934, ptr %1932, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %152) #7
  %1935 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 0
  %1936 = getelementptr inbounds [2 x float], ptr %1935, i64 0, i64 0
  %1937 = load float, ptr %1936, align 4, !tbaa !10
  store float %1937, ptr %152, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %153) #7
  %1938 = load float, ptr %152, align 4, !tbaa !11
  %1939 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %1940 = getelementptr inbounds [2 x float], ptr %1939, i64 0, i64 0
  %1941 = load float, ptr %1940, align 4, !tbaa !10
  %1942 = fsub float %1938, %1941
  store float %1942, ptr %153, align 4, !tbaa !11
  %1943 = load float, ptr %153, align 4, !tbaa !11
  %1944 = fcmp olt float %1943, 0xBE80000000000000
  br i1 %1944, label %1948, label %1945

1945:                                             ; preds = %1930
  %1946 = load float, ptr %153, align 4, !tbaa !11
  %1947 = fcmp olt float 0x3E80000000000000, %1946
  br i1 %1947, label %1948, label %1963

1948:                                             ; preds = %1945, %1930
  %1949 = load ptr, ptr %2, align 8, !tbaa !5
  %1950 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1949, i32 0, i32 1
  %1951 = load i32, ptr %1950, align 4, !tbaa !16
  %1952 = add nsw i32 %1951, 1
  store i32 %1952, ptr %1950, align 4, !tbaa !16
  %1953 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 230)
  %1954 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %1955 = getelementptr inbounds [2 x float], ptr %1954, i64 0, i64 0
  %1956 = load float, ptr %1955, align 4, !tbaa !10
  %1957 = fpext float %1956 to double
  %1958 = load float, ptr %152, align 4, !tbaa !11
  %1959 = fpext float %1958 to double
  %1960 = load float, ptr %153, align 4, !tbaa !11
  %1961 = fpext float %1960 to double
  %1962 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1957, double noundef %1959, double noundef %1961)
  br label %1963

1963:                                             ; preds = %1948, %1945
  call void @llvm.lifetime.end.p0(i64 4, ptr %153) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %152) #7
  %1964 = load ptr, ptr %2, align 8, !tbaa !5
  %1965 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1964, i32 0, i32 0
  %1966 = load i32, ptr %1965, align 4, !tbaa !13
  %1967 = add nsw i32 %1966, 1
  store i32 %1967, ptr %1965, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %154) #7
  %1968 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 0
  %1969 = getelementptr inbounds [2 x float], ptr %1968, i64 0, i64 1
  %1970 = load float, ptr %1969, align 4, !tbaa !10
  store float %1970, ptr %154, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %155) #7
  %1971 = load float, ptr %154, align 4, !tbaa !11
  %1972 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %1973 = getelementptr inbounds [2 x float], ptr %1972, i64 0, i64 1
  %1974 = load float, ptr %1973, align 4, !tbaa !10
  %1975 = fsub float %1971, %1974
  store float %1975, ptr %155, align 4, !tbaa !11
  %1976 = load float, ptr %155, align 4, !tbaa !11
  %1977 = fcmp olt float %1976, 0xBE80000000000000
  br i1 %1977, label %1981, label %1978

1978:                                             ; preds = %1963
  %1979 = load float, ptr %155, align 4, !tbaa !11
  %1980 = fcmp olt float 0x3E80000000000000, %1979
  br i1 %1980, label %1981, label %1996

1981:                                             ; preds = %1978, %1963
  %1982 = load ptr, ptr %2, align 8, !tbaa !5
  %1983 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1982, i32 0, i32 1
  %1984 = load i32, ptr %1983, align 4, !tbaa !16
  %1985 = add nsw i32 %1984, 1
  store i32 %1985, ptr %1983, align 4, !tbaa !16
  %1986 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 231)
  %1987 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %1988 = getelementptr inbounds [2 x float], ptr %1987, i64 0, i64 1
  %1989 = load float, ptr %1988, align 4, !tbaa !10
  %1990 = fpext float %1989 to double
  %1991 = load float, ptr %154, align 4, !tbaa !11
  %1992 = fpext float %1991 to double
  %1993 = load float, ptr %155, align 4, !tbaa !11
  %1994 = fpext float %1993 to double
  %1995 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1990, double noundef %1992, double noundef %1994)
  br label %1996

1996:                                             ; preds = %1981, %1978
  call void @llvm.lifetime.end.p0(i64 4, ptr %155) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %154) #7
  %1997 = load ptr, ptr %2, align 8, !tbaa !5
  %1998 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1997, i32 0, i32 0
  %1999 = load i32, ptr %1998, align 4, !tbaa !13
  %2000 = add nsw i32 %1999, 1
  store i32 %2000, ptr %1998, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %156) #7
  %2001 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 1
  %2002 = getelementptr inbounds [2 x float], ptr %2001, i64 0, i64 0
  %2003 = load float, ptr %2002, align 4, !tbaa !10
  store float %2003, ptr %156, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %157) #7
  %2004 = load float, ptr %156, align 4, !tbaa !11
  %2005 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2006 = getelementptr inbounds [2 x float], ptr %2005, i64 0, i64 0
  %2007 = load float, ptr %2006, align 4, !tbaa !10
  %2008 = fsub float %2004, %2007
  store float %2008, ptr %157, align 4, !tbaa !11
  %2009 = load float, ptr %157, align 4, !tbaa !11
  %2010 = fcmp olt float %2009, 0xBE80000000000000
  br i1 %2010, label %2014, label %2011

2011:                                             ; preds = %1996
  %2012 = load float, ptr %157, align 4, !tbaa !11
  %2013 = fcmp olt float 0x3E80000000000000, %2012
  br i1 %2013, label %2014, label %2029

2014:                                             ; preds = %2011, %1996
  %2015 = load ptr, ptr %2, align 8, !tbaa !5
  %2016 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2015, i32 0, i32 1
  %2017 = load i32, ptr %2016, align 4, !tbaa !16
  %2018 = add nsw i32 %2017, 1
  store i32 %2018, ptr %2016, align 4, !tbaa !16
  %2019 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 232)
  %2020 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2021 = getelementptr inbounds [2 x float], ptr %2020, i64 0, i64 0
  %2022 = load float, ptr %2021, align 4, !tbaa !10
  %2023 = fpext float %2022 to double
  %2024 = load float, ptr %156, align 4, !tbaa !11
  %2025 = fpext float %2024 to double
  %2026 = load float, ptr %157, align 4, !tbaa !11
  %2027 = fpext float %2026 to double
  %2028 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2023, double noundef %2025, double noundef %2027)
  br label %2029

2029:                                             ; preds = %2014, %2011
  call void @llvm.lifetime.end.p0(i64 4, ptr %157) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %156) #7
  %2030 = load ptr, ptr %2, align 8, !tbaa !5
  %2031 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2030, i32 0, i32 0
  %2032 = load i32, ptr %2031, align 4, !tbaa !13
  %2033 = add nsw i32 %2032, 1
  store i32 %2033, ptr %2031, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %158) #7
  %2034 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 1
  %2035 = getelementptr inbounds [2 x float], ptr %2034, i64 0, i64 1
  %2036 = load float, ptr %2035, align 4, !tbaa !10
  store float %2036, ptr %158, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %159) #7
  %2037 = load float, ptr %158, align 4, !tbaa !11
  %2038 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2039 = getelementptr inbounds [2 x float], ptr %2038, i64 0, i64 1
  %2040 = load float, ptr %2039, align 4, !tbaa !10
  %2041 = fsub float %2037, %2040
  store float %2041, ptr %159, align 4, !tbaa !11
  %2042 = load float, ptr %159, align 4, !tbaa !11
  %2043 = fcmp olt float %2042, 0xBE80000000000000
  br i1 %2043, label %2047, label %2044

2044:                                             ; preds = %2029
  %2045 = load float, ptr %159, align 4, !tbaa !11
  %2046 = fcmp olt float 0x3E80000000000000, %2045
  br i1 %2046, label %2047, label %2062

2047:                                             ; preds = %2044, %2029
  %2048 = load ptr, ptr %2, align 8, !tbaa !5
  %2049 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2048, i32 0, i32 1
  %2050 = load i32, ptr %2049, align 4, !tbaa !16
  %2051 = add nsw i32 %2050, 1
  store i32 %2051, ptr %2049, align 4, !tbaa !16
  %2052 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 233)
  %2053 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2054 = getelementptr inbounds [2 x float], ptr %2053, i64 0, i64 1
  %2055 = load float, ptr %2054, align 4, !tbaa !10
  %2056 = fpext float %2055 to double
  %2057 = load float, ptr %158, align 4, !tbaa !11
  %2058 = fpext float %2057 to double
  %2059 = load float, ptr %159, align 4, !tbaa !11
  %2060 = fpext float %2059 to double
  %2061 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2056, double noundef %2058, double noundef %2060)
  br label %2062

2062:                                             ; preds = %2047, %2044
  call void @llvm.lifetime.end.p0(i64 4, ptr %159) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %158) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr %160) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %161, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  %2063 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %161, i32 0, i32 0
  %2064 = load <2 x float>, ptr %2063, align 4
  %2065 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %161, i32 0, i32 1
  %2066 = load <2 x float>, ptr %2065, align 4
  %2067 = call { <2 x float>, <2 x float> } @_ZL14HMM_InvGeneral8HMM_Mat2(<2 x float> %2064, <2 x float> %2066)
  %2068 = getelementptr inbounds %union.HMM_Mat2, ptr %160, i32 0, i32 0
  %2069 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %2068, i32 0, i32 0
  %2070 = extractvalue { <2 x float>, <2 x float> } %2067, 0
  store <2 x float> %2070, ptr %2069, align 4
  %2071 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %2068, i32 0, i32 1
  %2072 = extractvalue { <2 x float>, <2 x float> } %2067, 1
  store <2 x float> %2072, ptr %2071, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %143, ptr align 4 %160, i64 16, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 16, ptr %160) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr %162) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %163, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %164, ptr align 4 %143, i64 16, i1 false), !tbaa.struct !18
  %2073 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %163, i32 0, i32 0
  %2074 = load <2 x float>, ptr %2073, align 4
  %2075 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %163, i32 0, i32 1
  %2076 = load <2 x float>, ptr %2075, align 4
  %2077 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %164, i32 0, i32 0
  %2078 = load <2 x float>, ptr %2077, align 4
  %2079 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %164, i32 0, i32 1
  %2080 = load <2 x float>, ptr %2079, align 4
  %2081 = call { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2S_(<2 x float> %2074, <2 x float> %2076, <2 x float> %2078, <2 x float> %2080)
  %2082 = getelementptr inbounds %union.HMM_Mat2, ptr %162, i32 0, i32 0
  %2083 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %2082, i32 0, i32 0
  %2084 = extractvalue { <2 x float>, <2 x float> } %2081, 0
  store <2 x float> %2084, ptr %2083, align 4
  %2085 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %2082, i32 0, i32 1
  %2086 = extractvalue { <2 x float>, <2 x float> } %2081, 1
  store <2 x float> %2086, ptr %2085, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %145, ptr align 4 %162, i64 16, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 16, ptr %162) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %165, ptr align 4 %141, i64 16, i1 false), !tbaa.struct !18
  %2087 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %165, i32 0, i32 0
  %2088 = load <2 x float>, ptr %2087, align 4
  %2089 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %165, i32 0, i32 1
  %2090 = load <2 x float>, ptr %2089, align 4
  %2091 = call noundef float @_ZL15HMM_Determinant8HMM_Mat2(<2 x float> %2088, <2 x float> %2090)
  store float %2091, ptr %148, align 4, !tbaa !11
  %2092 = load ptr, ptr %2, align 8, !tbaa !5
  %2093 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2092, i32 0, i32 0
  %2094 = load i32, ptr %2093, align 4, !tbaa !13
  %2095 = add nsw i32 %2094, 1
  store i32 %2095, ptr %2093, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %166) #7
  %2096 = load float, ptr %148, align 4, !tbaa !11
  store float %2096, ptr %166, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %167) #7
  %2097 = load float, ptr %166, align 4, !tbaa !11
  %2098 = fsub float %2097, 5.800000e+01
  store float %2098, ptr %167, align 4, !tbaa !11
  %2099 = load float, ptr %167, align 4, !tbaa !11
  %2100 = fcmp olt float %2099, 0xBE80000000000000
  br i1 %2100, label %2104, label %2101

2101:                                             ; preds = %2062
  %2102 = load float, ptr %167, align 4, !tbaa !11
  %2103 = fcmp olt float 0x3E80000000000000, %2102
  br i1 %2103, label %2104, label %2115

2104:                                             ; preds = %2101, %2062
  %2105 = load ptr, ptr %2, align 8, !tbaa !5
  %2106 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2105, i32 0, i32 1
  %2107 = load i32, ptr %2106, align 4, !tbaa !16
  %2108 = add nsw i32 %2107, 1
  store i32 %2108, ptr %2106, align 4, !tbaa !16
  %2109 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 239)
  %2110 = load float, ptr %166, align 4, !tbaa !11
  %2111 = fpext float %2110 to double
  %2112 = load float, ptr %167, align 4, !tbaa !11
  %2113 = fpext float %2112 to double
  %2114 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 5.800000e+01, double noundef %2111, double noundef %2113)
  br label %2115

2115:                                             ; preds = %2104, %2101
  call void @llvm.lifetime.end.p0(i64 4, ptr %167) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %166) #7
  %2116 = load ptr, ptr %2, align 8, !tbaa !5
  %2117 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2116, i32 0, i32 0
  %2118 = load i32, ptr %2117, align 4, !tbaa !13
  %2119 = add nsw i32 %2118, 1
  store i32 %2119, ptr %2117, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %168) #7
  %2120 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 0
  %2121 = getelementptr inbounds [2 x float], ptr %2120, i64 0, i64 0
  %2122 = load float, ptr %2121, align 4, !tbaa !10
  store float %2122, ptr %168, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %169) #7
  %2123 = load float, ptr %168, align 4, !tbaa !11
  %2124 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %2125 = getelementptr inbounds [2 x float], ptr %2124, i64 0, i64 0
  %2126 = load float, ptr %2125, align 4, !tbaa !10
  %2127 = fsub float %2123, %2126
  store float %2127, ptr %169, align 4, !tbaa !11
  %2128 = load float, ptr %169, align 4, !tbaa !11
  %2129 = fcmp olt float %2128, 0xBE80000000000000
  br i1 %2129, label %2133, label %2130

2130:                                             ; preds = %2115
  %2131 = load float, ptr %169, align 4, !tbaa !11
  %2132 = fcmp olt float 0x3E80000000000000, %2131
  br i1 %2132, label %2133, label %2148

2133:                                             ; preds = %2130, %2115
  %2134 = load ptr, ptr %2, align 8, !tbaa !5
  %2135 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2134, i32 0, i32 1
  %2136 = load i32, ptr %2135, align 4, !tbaa !16
  %2137 = add nsw i32 %2136, 1
  store i32 %2137, ptr %2135, align 4, !tbaa !16
  %2138 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 241)
  %2139 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %2140 = getelementptr inbounds [2 x float], ptr %2139, i64 0, i64 0
  %2141 = load float, ptr %2140, align 4, !tbaa !10
  %2142 = fpext float %2141 to double
  %2143 = load float, ptr %168, align 4, !tbaa !11
  %2144 = fpext float %2143 to double
  %2145 = load float, ptr %169, align 4, !tbaa !11
  %2146 = fpext float %2145 to double
  %2147 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2142, double noundef %2144, double noundef %2146)
  br label %2148

2148:                                             ; preds = %2133, %2130
  call void @llvm.lifetime.end.p0(i64 4, ptr %169) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %168) #7
  %2149 = load ptr, ptr %2, align 8, !tbaa !5
  %2150 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2149, i32 0, i32 0
  %2151 = load i32, ptr %2150, align 4, !tbaa !13
  %2152 = add nsw i32 %2151, 1
  store i32 %2152, ptr %2150, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %170) #7
  %2153 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 0
  %2154 = getelementptr inbounds [2 x float], ptr %2153, i64 0, i64 1
  %2155 = load float, ptr %2154, align 4, !tbaa !10
  store float %2155, ptr %170, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %171) #7
  %2156 = load float, ptr %170, align 4, !tbaa !11
  %2157 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %2158 = getelementptr inbounds [2 x float], ptr %2157, i64 0, i64 1
  %2159 = load float, ptr %2158, align 4, !tbaa !10
  %2160 = fsub float %2156, %2159
  store float %2160, ptr %171, align 4, !tbaa !11
  %2161 = load float, ptr %171, align 4, !tbaa !11
  %2162 = fcmp olt float %2161, 0xBE80000000000000
  br i1 %2162, label %2166, label %2163

2163:                                             ; preds = %2148
  %2164 = load float, ptr %171, align 4, !tbaa !11
  %2165 = fcmp olt float 0x3E80000000000000, %2164
  br i1 %2165, label %2166, label %2181

2166:                                             ; preds = %2163, %2148
  %2167 = load ptr, ptr %2, align 8, !tbaa !5
  %2168 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2167, i32 0, i32 1
  %2169 = load i32, ptr %2168, align 4, !tbaa !16
  %2170 = add nsw i32 %2169, 1
  store i32 %2170, ptr %2168, align 4, !tbaa !16
  %2171 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 242)
  %2172 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 0
  %2173 = getelementptr inbounds [2 x float], ptr %2172, i64 0, i64 1
  %2174 = load float, ptr %2173, align 4, !tbaa !10
  %2175 = fpext float %2174 to double
  %2176 = load float, ptr %170, align 4, !tbaa !11
  %2177 = fpext float %2176 to double
  %2178 = load float, ptr %171, align 4, !tbaa !11
  %2179 = fpext float %2178 to double
  %2180 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2175, double noundef %2177, double noundef %2179)
  br label %2181

2181:                                             ; preds = %2166, %2163
  call void @llvm.lifetime.end.p0(i64 4, ptr %171) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %170) #7
  %2182 = load ptr, ptr %2, align 8, !tbaa !5
  %2183 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2182, i32 0, i32 0
  %2184 = load i32, ptr %2183, align 4, !tbaa !13
  %2185 = add nsw i32 %2184, 1
  store i32 %2185, ptr %2183, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %172) #7
  %2186 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 1
  %2187 = getelementptr inbounds [2 x float], ptr %2186, i64 0, i64 0
  %2188 = load float, ptr %2187, align 4, !tbaa !10
  store float %2188, ptr %172, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %173) #7
  %2189 = load float, ptr %172, align 4, !tbaa !11
  %2190 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2191 = getelementptr inbounds [2 x float], ptr %2190, i64 0, i64 0
  %2192 = load float, ptr %2191, align 4, !tbaa !10
  %2193 = fsub float %2189, %2192
  store float %2193, ptr %173, align 4, !tbaa !11
  %2194 = load float, ptr %173, align 4, !tbaa !11
  %2195 = fcmp olt float %2194, 0xBE80000000000000
  br i1 %2195, label %2199, label %2196

2196:                                             ; preds = %2181
  %2197 = load float, ptr %173, align 4, !tbaa !11
  %2198 = fcmp olt float 0x3E80000000000000, %2197
  br i1 %2198, label %2199, label %2214

2199:                                             ; preds = %2196, %2181
  %2200 = load ptr, ptr %2, align 8, !tbaa !5
  %2201 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2200, i32 0, i32 1
  %2202 = load i32, ptr %2201, align 4, !tbaa !16
  %2203 = add nsw i32 %2202, 1
  store i32 %2203, ptr %2201, align 4, !tbaa !16
  %2204 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 243)
  %2205 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2206 = getelementptr inbounds [2 x float], ptr %2205, i64 0, i64 0
  %2207 = load float, ptr %2206, align 4, !tbaa !10
  %2208 = fpext float %2207 to double
  %2209 = load float, ptr %172, align 4, !tbaa !11
  %2210 = fpext float %2209 to double
  %2211 = load float, ptr %173, align 4, !tbaa !11
  %2212 = fpext float %2211 to double
  %2213 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2208, double noundef %2210, double noundef %2212)
  br label %2214

2214:                                             ; preds = %2199, %2196
  call void @llvm.lifetime.end.p0(i64 4, ptr %173) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %172) #7
  %2215 = load ptr, ptr %2, align 8, !tbaa !5
  %2216 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2215, i32 0, i32 0
  %2217 = load i32, ptr %2216, align 4, !tbaa !13
  %2218 = add nsw i32 %2217, 1
  store i32 %2218, ptr %2216, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %174) #7
  %2219 = getelementptr inbounds [2 x [2 x float]], ptr %145, i64 0, i64 1
  %2220 = getelementptr inbounds [2 x float], ptr %2219, i64 0, i64 1
  %2221 = load float, ptr %2220, align 4, !tbaa !10
  store float %2221, ptr %174, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %175) #7
  %2222 = load float, ptr %174, align 4, !tbaa !11
  %2223 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2224 = getelementptr inbounds [2 x float], ptr %2223, i64 0, i64 1
  %2225 = load float, ptr %2224, align 4, !tbaa !10
  %2226 = fsub float %2222, %2225
  store float %2226, ptr %175, align 4, !tbaa !11
  %2227 = load float, ptr %175, align 4, !tbaa !11
  %2228 = fcmp olt float %2227, 0xBE80000000000000
  br i1 %2228, label %2232, label %2229

2229:                                             ; preds = %2214
  %2230 = load float, ptr %175, align 4, !tbaa !11
  %2231 = fcmp olt float 0x3E80000000000000, %2230
  br i1 %2231, label %2232, label %2247

2232:                                             ; preds = %2229, %2214
  %2233 = load ptr, ptr %2, align 8, !tbaa !5
  %2234 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %2233, i32 0, i32 1
  %2235 = load i32, ptr %2234, align 4, !tbaa !16
  %2236 = add nsw i32 %2235, 1
  store i32 %2236, ptr %2234, align 4, !tbaa !16
  %2237 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 244)
  %2238 = getelementptr inbounds [2 x [2 x float]], ptr %142, i64 0, i64 1
  %2239 = getelementptr inbounds [2 x float], ptr %2238, i64 0, i64 1
  %2240 = load float, ptr %2239, align 4, !tbaa !10
  %2241 = fpext float %2240 to double
  %2242 = load float, ptr %174, align 4, !tbaa !11
  %2243 = fpext float %2242 to double
  %2244 = load float, ptr %175, align 4, !tbaa !11
  %2245 = fpext float %2244 to double
  %2246 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %2241, double noundef %2243, double noundef %2245)
  br label %2247

2247:                                             ; preds = %2232, %2229
  call void @llvm.lifetime.end.p0(i64 4, ptr %175) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %174) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %148) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %145) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %143) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %142) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %141) #7
  ret void
}

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM48HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16) #6

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16) #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL16HMM_InvGeneralM38HMM_Mat3(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL9HMM_MulM38HMM_Mat3S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8, ptr noundef byval(%union.HMM_Mat3) align 8) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM38HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL14HMM_InvGeneral8HMM_Mat3(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8) #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL7HMM_Mul8HMM_Mat3S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8, ptr noundef byval(%union.HMM_Mat3) align 8) #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8) #4

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL16HMM_InvGeneralM28HMM_Mat2(<2 x float>, <2 x float>) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL9HMM_MulM28HMM_Mat2S_(<2 x float>, <2 x float>, <2 x float>, <2 x float>) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM28HMM_Mat2(<2 x float>, <2 x float>) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL14HMM_InvGeneral8HMM_Mat2(<2 x float>, <2 x float>) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2S_(<2 x float>, <2 x float>, <2 x float>, <2 x float>) #6

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat2(<2 x float>, <2 x float>) #6

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 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { 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 #5 = { mustprogress uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { inlinehint mustprogress uwtable "min-legal-vector-width"="64" "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 #7 = { 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 = !{i64 0, i64 64, !10}
!10 = !{!7, !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!14, !15, i64 0}
!14 = !{!"_ZTS21hmt_testresult_struct", !15, i64 0, !15, i64 4}
!15 = !{!"int", !7, i64 0}
!16 = !{!14, !15, i64 4}
!17 = !{i64 0, i64 36, !10}
!18 = !{i64 0, i64 16, !10}


; 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_Mat2 = type { [2 x [2 x float]] }
%union.HMM_Mat3 = type { [3 x [3 x float]] }
%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.16 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 x i8], align 1
@__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16
@__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix.47 = external hidden unnamed_addr constant %union.HMM_Mat2, align 4

; 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 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: 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 #2

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL7HMM_M2Df(float noundef) local_unnamed_addr #3

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #4 {
  %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
  %6 = alloca %union.HMM_Mat4, align 16
  %7 = alloca %union.HMM_Mat3, align 4
  %8 = alloca %union.HMM_Mat3, align 8
  %9 = alloca %union.HMM_Mat3, align 8
  %10 = alloca %union.HMM_Mat3, align 4
  %11 = alloca %union.HMM_Mat3, align 8
  %12 = alloca %union.HMM_Mat3, align 8
  %13 = alloca %union.HMM_Mat3, align 8
  %14 = alloca %union.HMM_Mat3, align 8
  %15 = alloca %union.HMM_Mat3, align 4
  %16 = alloca %union.HMM_Mat3, align 8
  %17 = alloca %union.HMM_Mat3, align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #7
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #7
  call void @_ZL16HMM_InvGeneralM48HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #7
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3)
  %18 = call noundef float @_ZL17HMM_DeterminantM48HMM_Mat4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix)
  %19 = load i32, ptr %0, align 4, !tbaa !5
  %20 = add nsw i32 %19, 1
  store i32 %20, ptr %0, align 4, !tbaa !5
  %21 = fadd float %18, 8.000000e+01
  %22 = call float @llvm.fabs.f32(float %21)
  %or.cond = fcmp ogt float %22, 0x3E80000000000000
  br i1 %or.cond, label %23, label %31

23:                                               ; preds = %1
  %24 = getelementptr inbounds i8, ptr %0, i64 4
  %25 = load i32, ptr %24, align 4, !tbaa !10
  %26 = add nsw i32 %25, 1
  store i32 %26, ptr %24, align 4, !tbaa !10
  %27 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 130)
  %28 = fpext float %18 to double
  %29 = fpext float %21 to double
  %30 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef -8.000000e+01, double noundef %28, double noundef %29)
  %.pre = load i32, ptr %0, align 4, !tbaa !5
  br label %31

31:                                               ; preds = %1, %23
  %32 = phi i32 [ %20, %1 ], [ %.pre, %23 ]
  %33 = add nsw i32 %32, 1
  store i32 %33, ptr %0, align 4, !tbaa !5
  %34 = load float, ptr %4, align 16, !tbaa !11
  %35 = load float, ptr %2, align 16, !tbaa !11
  %36 = fsub float %34, %35
  %37 = call float @llvm.fabs.f32(float %36)
  %or.cond3 = fcmp ogt float %37, 0x3EE4F8B580000000
  br i1 %or.cond3, label %38, label %47

38:                                               ; preds = %31
  %39 = getelementptr inbounds i8, ptr %0, i64 4
  %40 = load i32, ptr %39, align 4, !tbaa !10
  %41 = add nsw i32 %40, 1
  store i32 %41, ptr %39, align 4, !tbaa !10
  %42 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 132)
  %43 = load float, ptr %2, align 16, !tbaa !11
  %44 = fpext float %43 to double
  %45 = fpext float %34 to double
  %46 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %44, double noundef %45)
  %.pre694 = load i32, ptr %0, align 4, !tbaa !5
  br label %47

47:                                               ; preds = %31, %38
  %48 = phi i32 [ %33, %31 ], [ %.pre694, %38 ]
  %49 = add nsw i32 %48, 1
  store i32 %49, ptr %0, align 4, !tbaa !5
  %50 = getelementptr inbounds i8, ptr %4, i64 4
  %51 = load float, ptr %50, align 4, !tbaa !11
  %52 = getelementptr inbounds i8, ptr %2, i64 4
  %53 = load float, ptr %52, align 4, !tbaa !11
  %54 = fsub float %51, %53
  %55 = call float @llvm.fabs.f32(float %54)
  %or.cond5 = fcmp ogt float %55, 0x3EE4F8B580000000
  br i1 %or.cond5, label %56, label %65

56:                                               ; preds = %47
  %57 = getelementptr inbounds i8, ptr %0, i64 4
  %58 = load i32, ptr %57, align 4, !tbaa !10
  %59 = add nsw i32 %58, 1
  store i32 %59, ptr %57, align 4, !tbaa !10
  %60 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 133)
  %61 = load float, ptr %52, align 4, !tbaa !11
  %62 = fpext float %61 to double
  %63 = fpext float %51 to double
  %64 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %62, double noundef %63)
  %.pre695 = load i32, ptr %0, align 4, !tbaa !5
  br label %65

65:                                               ; preds = %47, %56
  %66 = phi i32 [ %49, %47 ], [ %.pre695, %56 ]
  %67 = add nsw i32 %66, 1
  store i32 %67, ptr %0, align 4, !tbaa !5
  %68 = getelementptr inbounds i8, ptr %4, i64 8
  %69 = load float, ptr %68, align 8, !tbaa !11
  %70 = getelementptr inbounds i8, ptr %2, i64 8
  %71 = load float, ptr %70, align 8, !tbaa !11
  %72 = fsub float %69, %71
  %73 = call float @llvm.fabs.f32(float %72)
  %or.cond7 = fcmp ogt float %73, 0x3EE4F8B580000000
  br i1 %or.cond7, label %74, label %83

74:                                               ; preds = %65
  %75 = getelementptr inbounds i8, ptr %0, i64 4
  %76 = load i32, ptr %75, align 4, !tbaa !10
  %77 = add nsw i32 %76, 1
  store i32 %77, ptr %75, align 4, !tbaa !10
  %78 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 134)
  %79 = load float, ptr %70, align 8, !tbaa !11
  %80 = fpext float %79 to double
  %81 = fpext float %69 to double
  %82 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %80, double noundef %81)
  %.pre696 = load i32, ptr %0, align 4, !tbaa !5
  br label %83

83:                                               ; preds = %65, %74
  %84 = phi i32 [ %67, %65 ], [ %.pre696, %74 ]
  %85 = add nsw i32 %84, 1
  store i32 %85, ptr %0, align 4, !tbaa !5
  %86 = getelementptr inbounds i8, ptr %4, i64 12
  %87 = load float, ptr %86, align 4, !tbaa !11
  %88 = getelementptr inbounds i8, ptr %2, i64 12
  %89 = load float, ptr %88, align 4, !tbaa !11
  %90 = fsub float %87, %89
  %91 = call float @llvm.fabs.f32(float %90)
  %or.cond9 = fcmp ogt float %91, 0x3EE4F8B580000000
  br i1 %or.cond9, label %92, label %101

92:                                               ; preds = %83
  %93 = getelementptr inbounds i8, ptr %0, i64 4
  %94 = load i32, ptr %93, align 4, !tbaa !10
  %95 = add nsw i32 %94, 1
  store i32 %95, ptr %93, align 4, !tbaa !10
  %96 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 135)
  %97 = load float, ptr %88, align 4, !tbaa !11
  %98 = fpext float %97 to double
  %99 = fpext float %87 to double
  %100 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %98, double noundef %99)
  %.pre697 = load i32, ptr %0, align 4, !tbaa !5
  br label %101

101:                                              ; preds = %83, %92
  %102 = phi i32 [ %85, %83 ], [ %.pre697, %92 ]
  %103 = add nsw i32 %102, 1
  store i32 %103, ptr %0, align 4, !tbaa !5
  %104 = getelementptr inbounds i8, ptr %4, i64 16
  %105 = load float, ptr %104, align 16, !tbaa !11
  %106 = getelementptr inbounds i8, ptr %2, i64 16
  %107 = load float, ptr %106, align 16, !tbaa !11
  %108 = fsub float %105, %107
  %109 = call float @llvm.fabs.f32(float %108)
  %or.cond11 = fcmp ogt float %109, 0x3EE4F8B580000000
  br i1 %or.cond11, label %110, label %119

110:                                              ; preds = %101
  %111 = getelementptr inbounds i8, ptr %0, i64 4
  %112 = load i32, ptr %111, align 4, !tbaa !10
  %113 = add nsw i32 %112, 1
  store i32 %113, ptr %111, align 4, !tbaa !10
  %114 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 136)
  %115 = load float, ptr %106, align 16, !tbaa !11
  %116 = fpext float %115 to double
  %117 = fpext float %105 to double
  %118 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %116, double noundef %117)
  %.pre698 = load i32, ptr %0, align 4, !tbaa !5
  br label %119

119:                                              ; preds = %101, %110
  %120 = phi i32 [ %103, %101 ], [ %.pre698, %110 ]
  %121 = add nsw i32 %120, 1
  store i32 %121, ptr %0, align 4, !tbaa !5
  %122 = getelementptr inbounds i8, ptr %4, i64 20
  %123 = load float, ptr %122, align 4, !tbaa !11
  %124 = getelementptr inbounds i8, ptr %2, i64 20
  %125 = load float, ptr %124, align 4, !tbaa !11
  %126 = fsub float %123, %125
  %127 = call float @llvm.fabs.f32(float %126)
  %or.cond13 = fcmp ogt float %127, 0x3EE4F8B580000000
  br i1 %or.cond13, label %128, label %137

128:                                              ; preds = %119
  %129 = getelementptr inbounds i8, ptr %0, i64 4
  %130 = load i32, ptr %129, align 4, !tbaa !10
  %131 = add nsw i32 %130, 1
  store i32 %131, ptr %129, align 4, !tbaa !10
  %132 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 137)
  %133 = load float, ptr %124, align 4, !tbaa !11
  %134 = fpext float %133 to double
  %135 = fpext float %123 to double
  %136 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %134, double noundef %135)
  %.pre699 = load i32, ptr %0, align 4, !tbaa !5
  br label %137

137:                                              ; preds = %119, %128
  %138 = phi i32 [ %121, %119 ], [ %.pre699, %128 ]
  %139 = add nsw i32 %138, 1
  store i32 %139, ptr %0, align 4, !tbaa !5
  %140 = getelementptr inbounds i8, ptr %4, i64 24
  %141 = load float, ptr %140, align 8, !tbaa !11
  %142 = getelementptr inbounds i8, ptr %2, i64 24
  %143 = load float, ptr %142, align 8, !tbaa !11
  %144 = fsub float %141, %143
  %145 = call float @llvm.fabs.f32(float %144)
  %or.cond15 = fcmp ogt float %145, 0x3EE4F8B580000000
  br i1 %or.cond15, label %146, label %155

146:                                              ; preds = %137
  %147 = getelementptr inbounds i8, ptr %0, i64 4
  %148 = load i32, ptr %147, align 4, !tbaa !10
  %149 = add nsw i32 %148, 1
  store i32 %149, ptr %147, align 4, !tbaa !10
  %150 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 138)
  %151 = load float, ptr %142, align 8, !tbaa !11
  %152 = fpext float %151 to double
  %153 = fpext float %141 to double
  %154 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %152, double noundef %153)
  %.pre700 = load i32, ptr %0, align 4, !tbaa !5
  br label %155

155:                                              ; preds = %137, %146
  %156 = phi i32 [ %139, %137 ], [ %.pre700, %146 ]
  %157 = add nsw i32 %156, 1
  store i32 %157, ptr %0, align 4, !tbaa !5
  %158 = getelementptr inbounds i8, ptr %4, i64 28
  %159 = load float, ptr %158, align 4, !tbaa !11
  %160 = getelementptr inbounds i8, ptr %2, i64 28
  %161 = load float, ptr %160, align 4, !tbaa !11
  %162 = fsub float %159, %161
  %163 = call float @llvm.fabs.f32(float %162)
  %or.cond17 = fcmp ogt float %163, 0x3EE4F8B580000000
  br i1 %or.cond17, label %164, label %173

164:                                              ; preds = %155
  %165 = getelementptr inbounds i8, ptr %0, i64 4
  %166 = load i32, ptr %165, align 4, !tbaa !10
  %167 = add nsw i32 %166, 1
  store i32 %167, ptr %165, align 4, !tbaa !10
  %168 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 139)
  %169 = load float, ptr %160, align 4, !tbaa !11
  %170 = fpext float %169 to double
  %171 = fpext float %159 to double
  %172 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %170, double noundef %171)
  %.pre701 = load i32, ptr %0, align 4, !tbaa !5
  br label %173

173:                                              ; preds = %155, %164
  %174 = phi i32 [ %157, %155 ], [ %.pre701, %164 ]
  %175 = add nsw i32 %174, 1
  store i32 %175, ptr %0, align 4, !tbaa !5
  %176 = getelementptr inbounds i8, ptr %4, i64 32
  %177 = load float, ptr %176, align 16, !tbaa !11
  %178 = getelementptr inbounds i8, ptr %2, i64 32
  %179 = load float, ptr %178, align 16, !tbaa !11
  %180 = fsub float %177, %179
  %181 = call float @llvm.fabs.f32(float %180)
  %or.cond19 = fcmp ogt float %181, 0x3EE4F8B580000000
  br i1 %or.cond19, label %182, label %191

182:                                              ; preds = %173
  %183 = getelementptr inbounds i8, ptr %0, i64 4
  %184 = load i32, ptr %183, align 4, !tbaa !10
  %185 = add nsw i32 %184, 1
  store i32 %185, ptr %183, align 4, !tbaa !10
  %186 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 140)
  %187 = load float, ptr %178, align 16, !tbaa !11
  %188 = fpext float %187 to double
  %189 = fpext float %177 to double
  %190 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %188, double noundef %189)
  %.pre702 = load i32, ptr %0, align 4, !tbaa !5
  br label %191

191:                                              ; preds = %173, %182
  %192 = phi i32 [ %175, %173 ], [ %.pre702, %182 ]
  %193 = add nsw i32 %192, 1
  store i32 %193, ptr %0, align 4, !tbaa !5
  %194 = getelementptr inbounds i8, ptr %4, i64 36
  %195 = load float, ptr %194, align 4, !tbaa !11
  %196 = getelementptr inbounds i8, ptr %2, i64 36
  %197 = load float, ptr %196, align 4, !tbaa !11
  %198 = fsub float %195, %197
  %199 = call float @llvm.fabs.f32(float %198)
  %or.cond21 = fcmp ogt float %199, 0x3EE4F8B580000000
  br i1 %or.cond21, label %200, label %209

200:                                              ; preds = %191
  %201 = getelementptr inbounds i8, ptr %0, i64 4
  %202 = load i32, ptr %201, align 4, !tbaa !10
  %203 = add nsw i32 %202, 1
  store i32 %203, ptr %201, align 4, !tbaa !10
  %204 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 141)
  %205 = load float, ptr %196, align 4, !tbaa !11
  %206 = fpext float %205 to double
  %207 = fpext float %195 to double
  %208 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %206, double noundef %207)
  %.pre703 = load i32, ptr %0, align 4, !tbaa !5
  br label %209

209:                                              ; preds = %191, %200
  %210 = phi i32 [ %193, %191 ], [ %.pre703, %200 ]
  %211 = add nsw i32 %210, 1
  store i32 %211, ptr %0, align 4, !tbaa !5
  %212 = getelementptr inbounds i8, ptr %4, i64 40
  %213 = load float, ptr %212, align 8, !tbaa !11
  %214 = getelementptr inbounds i8, ptr %2, i64 40
  %215 = load float, ptr %214, align 8, !tbaa !11
  %216 = fsub float %213, %215
  %217 = call float @llvm.fabs.f32(float %216)
  %or.cond23 = fcmp ogt float %217, 0x3EE4F8B580000000
  br i1 %or.cond23, label %218, label %227

218:                                              ; preds = %209
  %219 = getelementptr inbounds i8, ptr %0, i64 4
  %220 = load i32, ptr %219, align 4, !tbaa !10
  %221 = add nsw i32 %220, 1
  store i32 %221, ptr %219, align 4, !tbaa !10
  %222 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 142)
  %223 = load float, ptr %214, align 8, !tbaa !11
  %224 = fpext float %223 to double
  %225 = fpext float %213 to double
  %226 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %224, double noundef %225)
  %.pre704 = load i32, ptr %0, align 4, !tbaa !5
  br label %227

227:                                              ; preds = %209, %218
  %228 = phi i32 [ %211, %209 ], [ %.pre704, %218 ]
  %229 = add nsw i32 %228, 1
  store i32 %229, ptr %0, align 4, !tbaa !5
  %230 = getelementptr inbounds i8, ptr %4, i64 44
  %231 = load float, ptr %230, align 4, !tbaa !11
  %232 = getelementptr inbounds i8, ptr %2, i64 44
  %233 = load float, ptr %232, align 4, !tbaa !11
  %234 = fsub float %231, %233
  %235 = call float @llvm.fabs.f32(float %234)
  %or.cond25 = fcmp ogt float %235, 0x3EE4F8B580000000
  br i1 %or.cond25, label %236, label %245

236:                                              ; preds = %227
  %237 = getelementptr inbounds i8, ptr %0, i64 4
  %238 = load i32, ptr %237, align 4, !tbaa !10
  %239 = add nsw i32 %238, 1
  store i32 %239, ptr %237, align 4, !tbaa !10
  %240 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 143)
  %241 = load float, ptr %232, align 4, !tbaa !11
  %242 = fpext float %241 to double
  %243 = fpext float %231 to double
  %244 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %242, double noundef %243)
  %.pre705 = load i32, ptr %0, align 4, !tbaa !5
  br label %245

245:                                              ; preds = %227, %236
  %246 = phi i32 [ %229, %227 ], [ %.pre705, %236 ]
  %247 = add nsw i32 %246, 1
  store i32 %247, ptr %0, align 4, !tbaa !5
  %248 = getelementptr inbounds i8, ptr %4, i64 48
  %249 = load float, ptr %248, align 16, !tbaa !11
  %250 = getelementptr inbounds i8, ptr %2, i64 48
  %251 = load float, ptr %250, align 16, !tbaa !11
  %252 = fsub float %249, %251
  %253 = call float @llvm.fabs.f32(float %252)
  %or.cond27 = fcmp ogt float %253, 0x3EE4F8B580000000
  br i1 %or.cond27, label %254, label %263

254:                                              ; preds = %245
  %255 = getelementptr inbounds i8, ptr %0, i64 4
  %256 = load i32, ptr %255, align 4, !tbaa !10
  %257 = add nsw i32 %256, 1
  store i32 %257, ptr %255, align 4, !tbaa !10
  %258 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 144)
  %259 = load float, ptr %250, align 16, !tbaa !11
  %260 = fpext float %259 to double
  %261 = fpext float %249 to double
  %262 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %260, double noundef %261)
  %.pre706 = load i32, ptr %0, align 4, !tbaa !5
  br label %263

263:                                              ; preds = %245, %254
  %264 = phi i32 [ %247, %245 ], [ %.pre706, %254 ]
  %265 = add nsw i32 %264, 1
  store i32 %265, ptr %0, align 4, !tbaa !5
  %266 = getelementptr inbounds i8, ptr %4, i64 52
  %267 = load float, ptr %266, align 4, !tbaa !11
  %268 = getelementptr inbounds i8, ptr %2, i64 52
  %269 = load float, ptr %268, align 4, !tbaa !11
  %270 = fsub float %267, %269
  %271 = call float @llvm.fabs.f32(float %270)
  %or.cond29 = fcmp ogt float %271, 0x3EE4F8B580000000
  br i1 %or.cond29, label %272, label %281

272:                                              ; preds = %263
  %273 = getelementptr inbounds i8, ptr %0, i64 4
  %274 = load i32, ptr %273, align 4, !tbaa !10
  %275 = add nsw i32 %274, 1
  store i32 %275, ptr %273, align 4, !tbaa !10
  %276 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 145)
  %277 = load float, ptr %268, align 4, !tbaa !11
  %278 = fpext float %277 to double
  %279 = fpext float %267 to double
  %280 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %278, double noundef %279)
  %.pre707 = load i32, ptr %0, align 4, !tbaa !5
  br label %281

281:                                              ; preds = %263, %272
  %282 = phi i32 [ %265, %263 ], [ %.pre707, %272 ]
  %283 = add nsw i32 %282, 1
  store i32 %283, ptr %0, align 4, !tbaa !5
  %284 = getelementptr inbounds i8, ptr %4, i64 56
  %285 = load float, ptr %284, align 8, !tbaa !11
  %286 = getelementptr inbounds i8, ptr %2, i64 56
  %287 = load float, ptr %286, align 8, !tbaa !11
  %288 = fsub float %285, %287
  %289 = call float @llvm.fabs.f32(float %288)
  %or.cond31 = fcmp ogt float %289, 0x3EE4F8B580000000
  br i1 %or.cond31, label %290, label %299

290:                                              ; preds = %281
  %291 = getelementptr inbounds i8, ptr %0, i64 4
  %292 = load i32, ptr %291, align 4, !tbaa !10
  %293 = add nsw i32 %292, 1
  store i32 %293, ptr %291, align 4, !tbaa !10
  %294 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 146)
  %295 = load float, ptr %286, align 8, !tbaa !11
  %296 = fpext float %295 to double
  %297 = fpext float %285 to double
  %298 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %296, double noundef %297)
  %.pre708 = load i32, ptr %0, align 4, !tbaa !5
  br label %299

299:                                              ; preds = %281, %290
  %300 = phi i32 [ %283, %281 ], [ %.pre708, %290 ]
  %301 = add nsw i32 %300, 1
  store i32 %301, ptr %0, align 4, !tbaa !5
  %302 = getelementptr inbounds i8, ptr %4, i64 60
  %303 = load float, ptr %302, align 4, !tbaa !11
  %304 = getelementptr inbounds i8, ptr %2, i64 60
  %305 = load float, ptr %304, align 4, !tbaa !11
  %306 = fsub float %303, %305
  %307 = call float @llvm.fabs.f32(float %306)
  %or.cond33 = fcmp ogt float %307, 0x3EE4F8B580000000
  br i1 %or.cond33, label %308, label %317

308:                                              ; preds = %299
  %309 = getelementptr inbounds i8, ptr %0, i64 4
  %310 = load i32, ptr %309, align 4, !tbaa !10
  %311 = add nsw i32 %310, 1
  store i32 %311, ptr %309, align 4, !tbaa !10
  %312 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 147)
  %313 = load float, ptr %304, align 4, !tbaa !11
  %314 = fpext float %313 to double
  %315 = fpext float %303 to double
  %316 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %314, double noundef %315)
  br label %317

317:                                              ; preds = %299, %308
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #7
  call void @_ZL14HMM_InvGeneral8HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %5, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %3, ptr noundef nonnull align 16 dereferenceable(64) %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %6) #7
  call void @_ZL7HMM_Mul8HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %6, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %4, ptr noundef nonnull align 16 dereferenceable(64) %6, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %6) #7
  %318 = call noundef float @_ZL15HMM_Determinant8HMM_Mat4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix)
  %319 = load i32, ptr %0, align 4, !tbaa !5
  %320 = add nsw i32 %319, 1
  store i32 %320, ptr %0, align 4, !tbaa !5
  %321 = fadd float %318, 8.000000e+01
  %322 = call float @llvm.fabs.f32(float %321)
  %or.cond35 = fcmp ogt float %322, 0x3E80000000000000
  br i1 %or.cond35, label %323, label %331

323:                                              ; preds = %317
  %324 = getelementptr inbounds i8, ptr %0, i64 4
  %325 = load i32, ptr %324, align 4, !tbaa !10
  %326 = add nsw i32 %325, 1
  store i32 %326, ptr %324, align 4, !tbaa !10
  %327 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 154)
  %328 = fpext float %318 to double
  %329 = fpext float %321 to double
  %330 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef -8.000000e+01, double noundef %328, double noundef %329)
  %.pre709 = load i32, ptr %0, align 4, !tbaa !5
  br label %331

331:                                              ; preds = %317, %323
  %332 = phi i32 [ %320, %317 ], [ %.pre709, %323 ]
  %333 = add nsw i32 %332, 1
  store i32 %333, ptr %0, align 4, !tbaa !5
  %334 = load float, ptr %4, align 16, !tbaa !11
  %335 = load float, ptr %2, align 16, !tbaa !11
  %336 = fsub float %334, %335
  %337 = call float @llvm.fabs.f32(float %336)
  %or.cond37 = fcmp ogt float %337, 0x3EE4F8B580000000
  br i1 %or.cond37, label %338, label %347

338:                                              ; preds = %331
  %339 = getelementptr inbounds i8, ptr %0, i64 4
  %340 = load i32, ptr %339, align 4, !tbaa !10
  %341 = add nsw i32 %340, 1
  store i32 %341, ptr %339, align 4, !tbaa !10
  %342 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 156)
  %343 = load float, ptr %2, align 16, !tbaa !11
  %344 = fpext float %343 to double
  %345 = fpext float %334 to double
  %346 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %344, double noundef %345)
  %.pre710 = load i32, ptr %0, align 4, !tbaa !5
  br label %347

347:                                              ; preds = %331, %338
  %348 = phi i32 [ %333, %331 ], [ %.pre710, %338 ]
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %0, align 4, !tbaa !5
  %350 = load float, ptr %50, align 4, !tbaa !11
  %351 = load float, ptr %52, align 4, !tbaa !11
  %352 = fsub float %350, %351
  %353 = call float @llvm.fabs.f32(float %352)
  %or.cond39 = fcmp ogt float %353, 0x3EE4F8B580000000
  br i1 %or.cond39, label %354, label %363

354:                                              ; preds = %347
  %355 = getelementptr inbounds i8, ptr %0, i64 4
  %356 = load i32, ptr %355, align 4, !tbaa !10
  %357 = add nsw i32 %356, 1
  store i32 %357, ptr %355, align 4, !tbaa !10
  %358 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 157)
  %359 = load float, ptr %52, align 4, !tbaa !11
  %360 = fpext float %359 to double
  %361 = fpext float %350 to double
  %362 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %360, double noundef %361)
  %.pre711 = load i32, ptr %0, align 4, !tbaa !5
  br label %363

363:                                              ; preds = %347, %354
  %364 = phi i32 [ %349, %347 ], [ %.pre711, %354 ]
  %365 = add nsw i32 %364, 1
  store i32 %365, ptr %0, align 4, !tbaa !5
  %366 = load float, ptr %68, align 8, !tbaa !11
  %367 = load float, ptr %70, align 8, !tbaa !11
  %368 = fsub float %366, %367
  %369 = call float @llvm.fabs.f32(float %368)
  %or.cond41 = fcmp ogt float %369, 0x3EE4F8B580000000
  br i1 %or.cond41, label %370, label %379

370:                                              ; preds = %363
  %371 = getelementptr inbounds i8, ptr %0, i64 4
  %372 = load i32, ptr %371, align 4, !tbaa !10
  %373 = add nsw i32 %372, 1
  store i32 %373, ptr %371, align 4, !tbaa !10
  %374 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 158)
  %375 = load float, ptr %70, align 8, !tbaa !11
  %376 = fpext float %375 to double
  %377 = fpext float %366 to double
  %378 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %376, double noundef %377)
  %.pre712 = load i32, ptr %0, align 4, !tbaa !5
  br label %379

379:                                              ; preds = %363, %370
  %380 = phi i32 [ %365, %363 ], [ %.pre712, %370 ]
  %381 = add nsw i32 %380, 1
  store i32 %381, ptr %0, align 4, !tbaa !5
  %382 = load float, ptr %86, align 4, !tbaa !11
  %383 = load float, ptr %88, align 4, !tbaa !11
  %384 = fsub float %382, %383
  %385 = call float @llvm.fabs.f32(float %384)
  %or.cond43 = fcmp ogt float %385, 0x3EE4F8B580000000
  br i1 %or.cond43, label %386, label %395

386:                                              ; preds = %379
  %387 = getelementptr inbounds i8, ptr %0, i64 4
  %388 = load i32, ptr %387, align 4, !tbaa !10
  %389 = add nsw i32 %388, 1
  store i32 %389, ptr %387, align 4, !tbaa !10
  %390 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 159)
  %391 = load float, ptr %88, align 4, !tbaa !11
  %392 = fpext float %391 to double
  %393 = fpext float %382 to double
  %394 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %392, double noundef %393)
  %.pre713 = load i32, ptr %0, align 4, !tbaa !5
  br label %395

395:                                              ; preds = %379, %386
  %396 = phi i32 [ %381, %379 ], [ %.pre713, %386 ]
  %397 = add nsw i32 %396, 1
  store i32 %397, ptr %0, align 4, !tbaa !5
  %398 = load float, ptr %104, align 16, !tbaa !11
  %399 = load float, ptr %106, align 16, !tbaa !11
  %400 = fsub float %398, %399
  %401 = call float @llvm.fabs.f32(float %400)
  %or.cond45 = fcmp ogt float %401, 0x3EE4F8B580000000
  br i1 %or.cond45, label %402, label %411

402:                                              ; preds = %395
  %403 = getelementptr inbounds i8, ptr %0, i64 4
  %404 = load i32, ptr %403, align 4, !tbaa !10
  %405 = add nsw i32 %404, 1
  store i32 %405, ptr %403, align 4, !tbaa !10
  %406 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 160)
  %407 = load float, ptr %106, align 16, !tbaa !11
  %408 = fpext float %407 to double
  %409 = fpext float %398 to double
  %410 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %408, double noundef %409)
  %.pre714 = load i32, ptr %0, align 4, !tbaa !5
  br label %411

411:                                              ; preds = %395, %402
  %412 = phi i32 [ %397, %395 ], [ %.pre714, %402 ]
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %0, align 4, !tbaa !5
  %414 = load float, ptr %122, align 4, !tbaa !11
  %415 = load float, ptr %124, align 4, !tbaa !11
  %416 = fsub float %414, %415
  %417 = call float @llvm.fabs.f32(float %416)
  %or.cond47 = fcmp ogt float %417, 0x3EE4F8B580000000
  br i1 %or.cond47, label %418, label %427

418:                                              ; preds = %411
  %419 = getelementptr inbounds i8, ptr %0, i64 4
  %420 = load i32, ptr %419, align 4, !tbaa !10
  %421 = add nsw i32 %420, 1
  store i32 %421, ptr %419, align 4, !tbaa !10
  %422 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 161)
  %423 = load float, ptr %124, align 4, !tbaa !11
  %424 = fpext float %423 to double
  %425 = fpext float %414 to double
  %426 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %424, double noundef %425)
  %.pre715 = load i32, ptr %0, align 4, !tbaa !5
  br label %427

427:                                              ; preds = %411, %418
  %428 = phi i32 [ %413, %411 ], [ %.pre715, %418 ]
  %429 = add nsw i32 %428, 1
  store i32 %429, ptr %0, align 4, !tbaa !5
  %430 = load float, ptr %140, align 8, !tbaa !11
  %431 = load float, ptr %142, align 8, !tbaa !11
  %432 = fsub float %430, %431
  %433 = call float @llvm.fabs.f32(float %432)
  %or.cond49 = fcmp ogt float %433, 0x3EE4F8B580000000
  br i1 %or.cond49, label %434, label %443

434:                                              ; preds = %427
  %435 = getelementptr inbounds i8, ptr %0, i64 4
  %436 = load i32, ptr %435, align 4, !tbaa !10
  %437 = add nsw i32 %436, 1
  store i32 %437, ptr %435, align 4, !tbaa !10
  %438 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 162)
  %439 = load float, ptr %142, align 8, !tbaa !11
  %440 = fpext float %439 to double
  %441 = fpext float %430 to double
  %442 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %440, double noundef %441)
  %.pre716 = load i32, ptr %0, align 4, !tbaa !5
  br label %443

443:                                              ; preds = %427, %434
  %444 = phi i32 [ %429, %427 ], [ %.pre716, %434 ]
  %445 = add nsw i32 %444, 1
  store i32 %445, ptr %0, align 4, !tbaa !5
  %446 = load float, ptr %158, align 4, !tbaa !11
  %447 = load float, ptr %160, align 4, !tbaa !11
  %448 = fsub float %446, %447
  %449 = call float @llvm.fabs.f32(float %448)
  %or.cond51 = fcmp ogt float %449, 0x3EE4F8B580000000
  br i1 %or.cond51, label %450, label %459

450:                                              ; preds = %443
  %451 = getelementptr inbounds i8, ptr %0, i64 4
  %452 = load i32, ptr %451, align 4, !tbaa !10
  %453 = add nsw i32 %452, 1
  store i32 %453, ptr %451, align 4, !tbaa !10
  %454 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 163)
  %455 = load float, ptr %160, align 4, !tbaa !11
  %456 = fpext float %455 to double
  %457 = fpext float %446 to double
  %458 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %456, double noundef %457)
  %.pre717 = load i32, ptr %0, align 4, !tbaa !5
  br label %459

459:                                              ; preds = %443, %450
  %460 = phi i32 [ %445, %443 ], [ %.pre717, %450 ]
  %461 = add nsw i32 %460, 1
  store i32 %461, ptr %0, align 4, !tbaa !5
  %462 = load float, ptr %176, align 16, !tbaa !11
  %463 = load float, ptr %178, align 16, !tbaa !11
  %464 = fsub float %462, %463
  %465 = call float @llvm.fabs.f32(float %464)
  %or.cond53 = fcmp ogt float %465, 0x3EE4F8B580000000
  br i1 %or.cond53, label %466, label %475

466:                                              ; preds = %459
  %467 = getelementptr inbounds i8, ptr %0, i64 4
  %468 = load i32, ptr %467, align 4, !tbaa !10
  %469 = add nsw i32 %468, 1
  store i32 %469, ptr %467, align 4, !tbaa !10
  %470 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 164)
  %471 = load float, ptr %178, align 16, !tbaa !11
  %472 = fpext float %471 to double
  %473 = fpext float %462 to double
  %474 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %472, double noundef %473)
  %.pre718 = load i32, ptr %0, align 4, !tbaa !5
  br label %475

475:                                              ; preds = %459, %466
  %476 = phi i32 [ %461, %459 ], [ %.pre718, %466 ]
  %477 = add nsw i32 %476, 1
  store i32 %477, ptr %0, align 4, !tbaa !5
  %478 = load float, ptr %194, align 4, !tbaa !11
  %479 = load float, ptr %196, align 4, !tbaa !11
  %480 = fsub float %478, %479
  %481 = call float @llvm.fabs.f32(float %480)
  %or.cond55 = fcmp ogt float %481, 0x3EE4F8B580000000
  br i1 %or.cond55, label %482, label %491

482:                                              ; preds = %475
  %483 = getelementptr inbounds i8, ptr %0, i64 4
  %484 = load i32, ptr %483, align 4, !tbaa !10
  %485 = add nsw i32 %484, 1
  store i32 %485, ptr %483, align 4, !tbaa !10
  %486 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 165)
  %487 = load float, ptr %196, align 4, !tbaa !11
  %488 = fpext float %487 to double
  %489 = fpext float %478 to double
  %490 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %488, double noundef %489)
  %.pre719 = load i32, ptr %0, align 4, !tbaa !5
  br label %491

491:                                              ; preds = %475, %482
  %492 = phi i32 [ %477, %475 ], [ %.pre719, %482 ]
  %493 = add nsw i32 %492, 1
  store i32 %493, ptr %0, align 4, !tbaa !5
  %494 = load float, ptr %212, align 8, !tbaa !11
  %495 = load float, ptr %214, align 8, !tbaa !11
  %496 = fsub float %494, %495
  %497 = call float @llvm.fabs.f32(float %496)
  %or.cond57 = fcmp ogt float %497, 0x3EE4F8B580000000
  br i1 %or.cond57, label %498, label %507

498:                                              ; preds = %491
  %499 = getelementptr inbounds i8, ptr %0, i64 4
  %500 = load i32, ptr %499, align 4, !tbaa !10
  %501 = add nsw i32 %500, 1
  store i32 %501, ptr %499, align 4, !tbaa !10
  %502 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 166)
  %503 = load float, ptr %214, align 8, !tbaa !11
  %504 = fpext float %503 to double
  %505 = fpext float %494 to double
  %506 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %504, double noundef %505)
  %.pre720 = load i32, ptr %0, align 4, !tbaa !5
  br label %507

507:                                              ; preds = %491, %498
  %508 = phi i32 [ %493, %491 ], [ %.pre720, %498 ]
  %509 = add nsw i32 %508, 1
  store i32 %509, ptr %0, align 4, !tbaa !5
  %510 = load float, ptr %230, align 4, !tbaa !11
  %511 = load float, ptr %232, align 4, !tbaa !11
  %512 = fsub float %510, %511
  %513 = call float @llvm.fabs.f32(float %512)
  %or.cond59 = fcmp ogt float %513, 0x3EE4F8B580000000
  br i1 %or.cond59, label %514, label %523

514:                                              ; preds = %507
  %515 = getelementptr inbounds i8, ptr %0, i64 4
  %516 = load i32, ptr %515, align 4, !tbaa !10
  %517 = add nsw i32 %516, 1
  store i32 %517, ptr %515, align 4, !tbaa !10
  %518 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 167)
  %519 = load float, ptr %232, align 4, !tbaa !11
  %520 = fpext float %519 to double
  %521 = fpext float %510 to double
  %522 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %520, double noundef %521)
  %.pre721 = load i32, ptr %0, align 4, !tbaa !5
  br label %523

523:                                              ; preds = %507, %514
  %524 = phi i32 [ %509, %507 ], [ %.pre721, %514 ]
  %525 = add nsw i32 %524, 1
  store i32 %525, ptr %0, align 4, !tbaa !5
  %526 = load float, ptr %248, align 16, !tbaa !11
  %527 = load float, ptr %250, align 16, !tbaa !11
  %528 = fsub float %526, %527
  %529 = call float @llvm.fabs.f32(float %528)
  %or.cond61 = fcmp ogt float %529, 0x3EE4F8B580000000
  br i1 %or.cond61, label %530, label %539

530:                                              ; preds = %523
  %531 = getelementptr inbounds i8, ptr %0, i64 4
  %532 = load i32, ptr %531, align 4, !tbaa !10
  %533 = add nsw i32 %532, 1
  store i32 %533, ptr %531, align 4, !tbaa !10
  %534 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 168)
  %535 = load float, ptr %250, align 16, !tbaa !11
  %536 = fpext float %535 to double
  %537 = fpext float %526 to double
  %538 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %536, double noundef %537)
  %.pre722 = load i32, ptr %0, align 4, !tbaa !5
  br label %539

539:                                              ; preds = %523, %530
  %540 = phi i32 [ %525, %523 ], [ %.pre722, %530 ]
  %541 = add nsw i32 %540, 1
  store i32 %541, ptr %0, align 4, !tbaa !5
  %542 = load float, ptr %266, align 4, !tbaa !11
  %543 = load float, ptr %268, align 4, !tbaa !11
  %544 = fsub float %542, %543
  %545 = call float @llvm.fabs.f32(float %544)
  %or.cond63 = fcmp ogt float %545, 0x3EE4F8B580000000
  br i1 %or.cond63, label %546, label %555

546:                                              ; preds = %539
  %547 = getelementptr inbounds i8, ptr %0, i64 4
  %548 = load i32, ptr %547, align 4, !tbaa !10
  %549 = add nsw i32 %548, 1
  store i32 %549, ptr %547, align 4, !tbaa !10
  %550 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 169)
  %551 = load float, ptr %268, align 4, !tbaa !11
  %552 = fpext float %551 to double
  %553 = fpext float %542 to double
  %554 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %552, double noundef %553)
  %.pre723 = load i32, ptr %0, align 4, !tbaa !5
  br label %555

555:                                              ; preds = %539, %546
  %556 = phi i32 [ %541, %539 ], [ %.pre723, %546 ]
  %557 = add nsw i32 %556, 1
  store i32 %557, ptr %0, align 4, !tbaa !5
  %558 = load float, ptr %284, align 8, !tbaa !11
  %559 = load float, ptr %286, align 8, !tbaa !11
  %560 = fsub float %558, %559
  %561 = call float @llvm.fabs.f32(float %560)
  %or.cond65 = fcmp ogt float %561, 0x3EE4F8B580000000
  br i1 %or.cond65, label %562, label %571

562:                                              ; preds = %555
  %563 = getelementptr inbounds i8, ptr %0, i64 4
  %564 = load i32, ptr %563, align 4, !tbaa !10
  %565 = add nsw i32 %564, 1
  store i32 %565, ptr %563, align 4, !tbaa !10
  %566 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 170)
  %567 = load float, ptr %286, align 8, !tbaa !11
  %568 = fpext float %567 to double
  %569 = fpext float %558 to double
  %570 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %568, double noundef %569)
  %.pre724 = load i32, ptr %0, align 4, !tbaa !5
  br label %571

571:                                              ; preds = %555, %562
  %572 = phi i32 [ %557, %555 ], [ %.pre724, %562 ]
  %573 = add nsw i32 %572, 1
  store i32 %573, ptr %0, align 4, !tbaa !5
  %574 = load float, ptr %302, align 4, !tbaa !11
  %575 = load float, ptr %304, align 4, !tbaa !11
  %576 = fsub float %574, %575
  %577 = call float @llvm.fabs.f32(float %576)
  %or.cond67 = fcmp ogt float %577, 0x3EE4F8B580000000
  br i1 %or.cond67, label %578, label %587

578:                                              ; preds = %571
  %579 = getelementptr inbounds i8, ptr %0, i64 4
  %580 = load i32, ptr %579, align 4, !tbaa !10
  %581 = add nsw i32 %580, 1
  store i32 %581, ptr %579, align 4, !tbaa !10
  %582 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 171)
  %583 = load float, ptr %304, align 4, !tbaa !11
  %584 = fpext float %583 to double
  %585 = fpext float %574 to double
  %586 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.16, double noundef %584, double noundef %585)
  br label %587

587:                                              ; preds = %571, %578
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %7) #7
  call void @_ZL7HMM_M3Df(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %7, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %8) #7
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %9, align 8
  %.sroa.11362.0..sroa_idx = getelementptr inbounds i8, ptr %9, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx, align 8
  %.sroa.12.0..sroa_idx = getelementptr inbounds i8, ptr %9, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx, align 4
  %.sroa.12378.0..sroa_idx = getelementptr inbounds i8, ptr %9, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx, align 4
  call void @_ZL16HMM_InvGeneralM38HMM_Mat3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %8, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %9)
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %10) #7
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %11, align 8
  %.sroa.11362.0..sroa_idx363 = getelementptr inbounds i8, ptr %11, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx363, align 8
  %.sroa.12.0..sroa_idx373 = getelementptr inbounds i8, ptr %11, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx373, align 4
  %.sroa.12378.0..sroa_idx379 = getelementptr inbounds i8, ptr %11, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx379, align 4
  call void @_ZL9HMM_MulM38HMM_Mat3S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %10, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %11, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %8)
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %12, align 8
  %.sroa.11362.0..sroa_idx365 = getelementptr inbounds i8, ptr %12, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx365, align 8
  %.sroa.12.0..sroa_idx374 = getelementptr inbounds i8, ptr %12, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx374, align 4
  %.sroa.12378.0..sroa_idx381 = getelementptr inbounds i8, ptr %12, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx381, align 4
  %588 = call noundef float @_ZL17HMM_DeterminantM38HMM_Mat3(ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %12)
  %589 = load i32, ptr %0, align 4, !tbaa !5
  %590 = add nsw i32 %589, 1
  store i32 %590, ptr %0, align 4, !tbaa !5
  %591 = fadd float %588, 1.200000e+01
  %592 = call float @llvm.fabs.f32(float %591)
  %or.cond69 = fcmp ogt float %592, 0x3E80000000000000
  br i1 %or.cond69, label %593, label %601

593:                                              ; preds = %587
  %594 = getelementptr inbounds i8, ptr %0, i64 4
  %595 = load i32, ptr %594, align 4, !tbaa !10
  %596 = add nsw i32 %595, 1
  store i32 %596, ptr %594, align 4, !tbaa !10
  %597 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 187)
  %598 = fpext float %588 to double
  %599 = fpext float %591 to double
  %600 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef -1.200000e+01, double noundef %598, double noundef %599)
  %.pre725 = load i32, ptr %0, align 4, !tbaa !5
  br label %601

601:                                              ; preds = %587, %593
  %602 = phi i32 [ %590, %587 ], [ %.pre725, %593 ]
  %603 = add nsw i32 %602, 1
  store i32 %603, ptr %0, align 4, !tbaa !5
  %604 = load float, ptr %10, align 4, !tbaa !11
  %605 = load float, ptr %7, align 4, !tbaa !11
  %606 = fsub float %604, %605
  %607 = call float @llvm.fabs.f32(float %606)
  %or.cond71 = fcmp ogt float %607, 0x3E80000000000000
  br i1 %or.cond71, label %608, label %618

608:                                              ; preds = %601
  %609 = getelementptr inbounds i8, ptr %0, i64 4
  %610 = load i32, ptr %609, align 4, !tbaa !10
  %611 = add nsw i32 %610, 1
  store i32 %611, ptr %609, align 4, !tbaa !10
  %612 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 189)
  %613 = load float, ptr %7, align 4, !tbaa !11
  %614 = fpext float %613 to double
  %615 = fpext float %604 to double
  %616 = fpext float %606 to double
  %617 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %614, double noundef %615, double noundef %616)
  %.pre726 = load i32, ptr %0, align 4, !tbaa !5
  br label %618

618:                                              ; preds = %601, %608
  %619 = phi i32 [ %603, %601 ], [ %.pre726, %608 ]
  %620 = add nsw i32 %619, 1
  store i32 %620, ptr %0, align 4, !tbaa !5
  %621 = getelementptr inbounds i8, ptr %10, i64 4
  %622 = load float, ptr %621, align 4, !tbaa !11
  %623 = getelementptr inbounds i8, ptr %7, i64 4
  %624 = load float, ptr %623, align 4, !tbaa !11
  %625 = fsub float %622, %624
  %626 = call float @llvm.fabs.f32(float %625)
  %or.cond73 = fcmp ogt float %626, 0x3E80000000000000
  br i1 %or.cond73, label %627, label %637

627:                                              ; preds = %618
  %628 = getelementptr inbounds i8, ptr %0, i64 4
  %629 = load i32, ptr %628, align 4, !tbaa !10
  %630 = add nsw i32 %629, 1
  store i32 %630, ptr %628, align 4, !tbaa !10
  %631 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 190)
  %632 = load float, ptr %623, align 4, !tbaa !11
  %633 = fpext float %632 to double
  %634 = fpext float %622 to double
  %635 = fpext float %625 to double
  %636 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %633, double noundef %634, double noundef %635)
  %.pre727 = load i32, ptr %0, align 4, !tbaa !5
  br label %637

637:                                              ; preds = %618, %627
  %638 = phi i32 [ %620, %618 ], [ %.pre727, %627 ]
  %639 = add nsw i32 %638, 1
  store i32 %639, ptr %0, align 4, !tbaa !5
  %640 = getelementptr inbounds i8, ptr %10, i64 8
  %641 = load float, ptr %640, align 4, !tbaa !11
  %642 = getelementptr inbounds i8, ptr %7, i64 8
  %643 = load float, ptr %642, align 4, !tbaa !11
  %644 = fsub float %641, %643
  %645 = call float @llvm.fabs.f32(float %644)
  %or.cond75 = fcmp ogt float %645, 0x3E80000000000000
  br i1 %or.cond75, label %646, label %656

646:                                              ; preds = %637
  %647 = getelementptr inbounds i8, ptr %0, i64 4
  %648 = load i32, ptr %647, align 4, !tbaa !10
  %649 = add nsw i32 %648, 1
  store i32 %649, ptr %647, align 4, !tbaa !10
  %650 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 191)
  %651 = load float, ptr %642, align 4, !tbaa !11
  %652 = fpext float %651 to double
  %653 = fpext float %641 to double
  %654 = fpext float %644 to double
  %655 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %652, double noundef %653, double noundef %654)
  %.pre728 = load i32, ptr %0, align 4, !tbaa !5
  br label %656

656:                                              ; preds = %637, %646
  %657 = phi i32 [ %639, %637 ], [ %.pre728, %646 ]
  %658 = add nsw i32 %657, 1
  store i32 %658, ptr %0, align 4, !tbaa !5
  %659 = getelementptr inbounds i8, ptr %10, i64 12
  %660 = load float, ptr %659, align 4, !tbaa !11
  %661 = getelementptr inbounds i8, ptr %7, i64 12
  %662 = load float, ptr %661, align 4, !tbaa !11
  %663 = fsub float %660, %662
  %664 = call float @llvm.fabs.f32(float %663)
  %or.cond77 = fcmp ogt float %664, 0x3E80000000000000
  br i1 %or.cond77, label %665, label %675

665:                                              ; preds = %656
  %666 = getelementptr inbounds i8, ptr %0, i64 4
  %667 = load i32, ptr %666, align 4, !tbaa !10
  %668 = add nsw i32 %667, 1
  store i32 %668, ptr %666, align 4, !tbaa !10
  %669 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 192)
  %670 = load float, ptr %661, align 4, !tbaa !11
  %671 = fpext float %670 to double
  %672 = fpext float %660 to double
  %673 = fpext float %663 to double
  %674 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %671, double noundef %672, double noundef %673)
  %.pre729 = load i32, ptr %0, align 4, !tbaa !5
  br label %675

675:                                              ; preds = %656, %665
  %676 = phi i32 [ %658, %656 ], [ %.pre729, %665 ]
  %677 = add nsw i32 %676, 1
  store i32 %677, ptr %0, align 4, !tbaa !5
  %678 = getelementptr inbounds i8, ptr %10, i64 16
  %679 = load float, ptr %678, align 4, !tbaa !11
  %680 = getelementptr inbounds i8, ptr %7, i64 16
  %681 = load float, ptr %680, align 4, !tbaa !11
  %682 = fsub float %679, %681
  %683 = call float @llvm.fabs.f32(float %682)
  %or.cond79 = fcmp ogt float %683, 0x3E80000000000000
  br i1 %or.cond79, label %684, label %694

684:                                              ; preds = %675
  %685 = getelementptr inbounds i8, ptr %0, i64 4
  %686 = load i32, ptr %685, align 4, !tbaa !10
  %687 = add nsw i32 %686, 1
  store i32 %687, ptr %685, align 4, !tbaa !10
  %688 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 193)
  %689 = load float, ptr %680, align 4, !tbaa !11
  %690 = fpext float %689 to double
  %691 = fpext float %679 to double
  %692 = fpext float %682 to double
  %693 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %690, double noundef %691, double noundef %692)
  %.pre730 = load i32, ptr %0, align 4, !tbaa !5
  br label %694

694:                                              ; preds = %675, %684
  %695 = phi i32 [ %677, %675 ], [ %.pre730, %684 ]
  %696 = add nsw i32 %695, 1
  store i32 %696, ptr %0, align 4, !tbaa !5
  %697 = getelementptr inbounds i8, ptr %10, i64 20
  %698 = load float, ptr %697, align 4, !tbaa !11
  %699 = getelementptr inbounds i8, ptr %7, i64 20
  %700 = load float, ptr %699, align 4, !tbaa !11
  %701 = fsub float %698, %700
  %702 = call float @llvm.fabs.f32(float %701)
  %or.cond81 = fcmp ogt float %702, 0x3E80000000000000
  br i1 %or.cond81, label %703, label %713

703:                                              ; preds = %694
  %704 = getelementptr inbounds i8, ptr %0, i64 4
  %705 = load i32, ptr %704, align 4, !tbaa !10
  %706 = add nsw i32 %705, 1
  store i32 %706, ptr %704, align 4, !tbaa !10
  %707 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 194)
  %708 = load float, ptr %699, align 4, !tbaa !11
  %709 = fpext float %708 to double
  %710 = fpext float %698 to double
  %711 = fpext float %701 to double
  %712 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %709, double noundef %710, double noundef %711)
  %.pre731 = load i32, ptr %0, align 4, !tbaa !5
  br label %713

713:                                              ; preds = %694, %703
  %714 = phi i32 [ %696, %694 ], [ %.pre731, %703 ]
  %715 = add nsw i32 %714, 1
  store i32 %715, ptr %0, align 4, !tbaa !5
  %716 = getelementptr inbounds i8, ptr %10, i64 24
  %717 = load float, ptr %716, align 4, !tbaa !11
  %718 = getelementptr inbounds i8, ptr %7, i64 24
  %719 = load float, ptr %718, align 4, !tbaa !11
  %720 = fsub float %717, %719
  %721 = call float @llvm.fabs.f32(float %720)
  %or.cond83 = fcmp ogt float %721, 0x3E80000000000000
  br i1 %or.cond83, label %722, label %732

722:                                              ; preds = %713
  %723 = getelementptr inbounds i8, ptr %0, i64 4
  %724 = load i32, ptr %723, align 4, !tbaa !10
  %725 = add nsw i32 %724, 1
  store i32 %725, ptr %723, align 4, !tbaa !10
  %726 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 195)
  %727 = load float, ptr %718, align 4, !tbaa !11
  %728 = fpext float %727 to double
  %729 = fpext float %717 to double
  %730 = fpext float %720 to double
  %731 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %728, double noundef %729, double noundef %730)
  %.pre732 = load i32, ptr %0, align 4, !tbaa !5
  br label %732

732:                                              ; preds = %713, %722
  %733 = phi i32 [ %715, %713 ], [ %.pre732, %722 ]
  %734 = add nsw i32 %733, 1
  store i32 %734, ptr %0, align 4, !tbaa !5
  %735 = getelementptr inbounds i8, ptr %10, i64 28
  %736 = load float, ptr %735, align 4, !tbaa !11
  %737 = getelementptr inbounds i8, ptr %7, i64 28
  %738 = load float, ptr %737, align 4, !tbaa !11
  %739 = fsub float %736, %738
  %740 = call float @llvm.fabs.f32(float %739)
  %or.cond85 = fcmp ogt float %740, 0x3E80000000000000
  br i1 %or.cond85, label %741, label %751

741:                                              ; preds = %732
  %742 = getelementptr inbounds i8, ptr %0, i64 4
  %743 = load i32, ptr %742, align 4, !tbaa !10
  %744 = add nsw i32 %743, 1
  store i32 %744, ptr %742, align 4, !tbaa !10
  %745 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 196)
  %746 = load float, ptr %737, align 4, !tbaa !11
  %747 = fpext float %746 to double
  %748 = fpext float %736 to double
  %749 = fpext float %739 to double
  %750 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %747, double noundef %748, double noundef %749)
  %.pre733 = load i32, ptr %0, align 4, !tbaa !5
  br label %751

751:                                              ; preds = %732, %741
  %752 = phi i32 [ %734, %732 ], [ %.pre733, %741 ]
  %753 = add nsw i32 %752, 1
  store i32 %753, ptr %0, align 4, !tbaa !5
  %754 = getelementptr inbounds i8, ptr %10, i64 32
  %755 = load float, ptr %754, align 4, !tbaa !11
  %756 = getelementptr inbounds i8, ptr %7, i64 32
  %757 = load float, ptr %756, align 4, !tbaa !11
  %758 = fsub float %755, %757
  %759 = call float @llvm.fabs.f32(float %758)
  %or.cond87 = fcmp ogt float %759, 0x3E80000000000000
  br i1 %or.cond87, label %760, label %770

760:                                              ; preds = %751
  %761 = getelementptr inbounds i8, ptr %0, i64 4
  %762 = load i32, ptr %761, align 4, !tbaa !10
  %763 = add nsw i32 %762, 1
  store i32 %763, ptr %761, align 4, !tbaa !10
  %764 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 197)
  %765 = load float, ptr %756, align 4, !tbaa !11
  %766 = fpext float %765 to double
  %767 = fpext float %755 to double
  %768 = fpext float %758 to double
  %769 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %766, double noundef %767, double noundef %768)
  br label %770

770:                                              ; preds = %751, %760
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %13) #7
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %14, align 8
  %.sroa.11362.0..sroa_idx367 = getelementptr inbounds i8, ptr %14, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx367, align 8
  %.sroa.12.0..sroa_idx375 = getelementptr inbounds i8, ptr %14, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx375, align 4
  %.sroa.12378.0..sroa_idx383 = getelementptr inbounds i8, ptr %14, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx383, align 4
  call void @_ZL14HMM_InvGeneral8HMM_Mat3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %13, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %14)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(36) %8, ptr noundef nonnull align 8 dereferenceable(36) %13, i64 36, i1 false), !tbaa.struct !13
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %13) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %15) #7
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %16, align 8
  %.sroa.11362.0..sroa_idx369 = getelementptr inbounds i8, ptr %16, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx369, align 8
  %.sroa.12.0..sroa_idx376 = getelementptr inbounds i8, ptr %16, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx376, align 4
  %.sroa.12378.0..sroa_idx385 = getelementptr inbounds i8, ptr %16, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx385, align 4
  call void @_ZL7HMM_Mul8HMM_Mat3S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %15, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %16, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %8)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(36) %10, ptr noundef nonnull align 4 dereferenceable(36) %15, i64 36, i1 false), !tbaa.struct !13
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %15) #7
  store <2 x float> <float 1.200000e+01, float 2.000000e+00>, ptr %17, align 8
  %.sroa.11362.0..sroa_idx371 = getelementptr inbounds i8, ptr %17, i64 8
  store float 1.000000e+00, ptr %.sroa.11362.0..sroa_idx371, align 8
  %.sroa.12.0..sroa_idx377 = getelementptr inbounds i8, ptr %17, i64 12
  store i64 0, ptr %.sroa.12.0..sroa_idx377, align 4
  %.sroa.12378.0..sroa_idx387 = getelementptr inbounds i8, ptr %17, i64 20
  store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00>, ptr %.sroa.12378.0..sroa_idx387, align 4
  %771 = call noundef float @_ZL15HMM_Determinant8HMM_Mat3(ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %17)
  %772 = load i32, ptr %0, align 4, !tbaa !5
  %773 = add nsw i32 %772, 1
  store i32 %773, ptr %0, align 4, !tbaa !5
  %774 = fadd float %771, 1.200000e+01
  %775 = call float @llvm.fabs.f32(float %774)
  %or.cond89 = fcmp ogt float %775, 0x3E80000000000000
  br i1 %or.cond89, label %776, label %784

776:                                              ; preds = %770
  %777 = getelementptr inbounds i8, ptr %0, i64 4
  %778 = load i32, ptr %777, align 4, !tbaa !10
  %779 = add nsw i32 %778, 1
  store i32 %779, ptr %777, align 4, !tbaa !10
  %780 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 203)
  %781 = fpext float %771 to double
  %782 = fpext float %774 to double
  %783 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef -1.200000e+01, double noundef %781, double noundef %782)
  %.pre734 = load i32, ptr %0, align 4, !tbaa !5
  br label %784

784:                                              ; preds = %770, %776
  %785 = phi i32 [ %773, %770 ], [ %.pre734, %776 ]
  %786 = add nsw i32 %785, 1
  store i32 %786, ptr %0, align 4, !tbaa !5
  %787 = load float, ptr %10, align 4, !tbaa !11
  %788 = load float, ptr %7, align 4, !tbaa !11
  %789 = fsub float %787, %788
  %790 = call float @llvm.fabs.f32(float %789)
  %or.cond91 = fcmp ogt float %790, 0x3E80000000000000
  br i1 %or.cond91, label %791, label %801

791:                                              ; preds = %784
  %792 = getelementptr inbounds i8, ptr %0, i64 4
  %793 = load i32, ptr %792, align 4, !tbaa !10
  %794 = add nsw i32 %793, 1
  store i32 %794, ptr %792, align 4, !tbaa !10
  %795 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 205)
  %796 = load float, ptr %7, align 4, !tbaa !11
  %797 = fpext float %796 to double
  %798 = fpext float %787 to double
  %799 = fpext float %789 to double
  %800 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %797, double noundef %798, double noundef %799)
  %.pre735 = load i32, ptr %0, align 4, !tbaa !5
  br label %801

801:                                              ; preds = %784, %791
  %802 = phi i32 [ %786, %784 ], [ %.pre735, %791 ]
  %803 = add nsw i32 %802, 1
  store i32 %803, ptr %0, align 4, !tbaa !5
  %804 = load float, ptr %621, align 4, !tbaa !11
  %805 = load float, ptr %623, align 4, !tbaa !11
  %806 = fsub float %804, %805
  %807 = call float @llvm.fabs.f32(float %806)
  %or.cond93 = fcmp ogt float %807, 0x3E80000000000000
  br i1 %or.cond93, label %808, label %818

808:                                              ; preds = %801
  %809 = getelementptr inbounds i8, ptr %0, i64 4
  %810 = load i32, ptr %809, align 4, !tbaa !10
  %811 = add nsw i32 %810, 1
  store i32 %811, ptr %809, align 4, !tbaa !10
  %812 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 206)
  %813 = load float, ptr %623, align 4, !tbaa !11
  %814 = fpext float %813 to double
  %815 = fpext float %804 to double
  %816 = fpext float %806 to double
  %817 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %814, double noundef %815, double noundef %816)
  %.pre736 = load i32, ptr %0, align 4, !tbaa !5
  br label %818

818:                                              ; preds = %801, %808
  %819 = phi i32 [ %803, %801 ], [ %.pre736, %808 ]
  %820 = add nsw i32 %819, 1
  store i32 %820, ptr %0, align 4, !tbaa !5
  %821 = load float, ptr %640, align 4, !tbaa !11
  %822 = load float, ptr %642, align 4, !tbaa !11
  %823 = fsub float %821, %822
  %824 = call float @llvm.fabs.f32(float %823)
  %or.cond95 = fcmp ogt float %824, 0x3E80000000000000
  br i1 %or.cond95, label %825, label %835

825:                                              ; preds = %818
  %826 = getelementptr inbounds i8, ptr %0, i64 4
  %827 = load i32, ptr %826, align 4, !tbaa !10
  %828 = add nsw i32 %827, 1
  store i32 %828, ptr %826, align 4, !tbaa !10
  %829 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 207)
  %830 = load float, ptr %642, align 4, !tbaa !11
  %831 = fpext float %830 to double
  %832 = fpext float %821 to double
  %833 = fpext float %823 to double
  %834 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %831, double noundef %832, double noundef %833)
  %.pre737 = load i32, ptr %0, align 4, !tbaa !5
  br label %835

835:                                              ; preds = %818, %825
  %836 = phi i32 [ %820, %818 ], [ %.pre737, %825 ]
  %837 = add nsw i32 %836, 1
  store i32 %837, ptr %0, align 4, !tbaa !5
  %838 = load float, ptr %659, align 4, !tbaa !11
  %839 = load float, ptr %661, align 4, !tbaa !11
  %840 = fsub float %838, %839
  %841 = call float @llvm.fabs.f32(float %840)
  %or.cond97 = fcmp ogt float %841, 0x3E80000000000000
  br i1 %or.cond97, label %842, label %852

842:                                              ; preds = %835
  %843 = getelementptr inbounds i8, ptr %0, i64 4
  %844 = load i32, ptr %843, align 4, !tbaa !10
  %845 = add nsw i32 %844, 1
  store i32 %845, ptr %843, align 4, !tbaa !10
  %846 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 208)
  %847 = load float, ptr %661, align 4, !tbaa !11
  %848 = fpext float %847 to double
  %849 = fpext float %838 to double
  %850 = fpext float %840 to double
  %851 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %848, double noundef %849, double noundef %850)
  %.pre738 = load i32, ptr %0, align 4, !tbaa !5
  br label %852

852:                                              ; preds = %835, %842
  %853 = phi i32 [ %837, %835 ], [ %.pre738, %842 ]
  %854 = add nsw i32 %853, 1
  store i32 %854, ptr %0, align 4, !tbaa !5
  %855 = load float, ptr %678, align 4, !tbaa !11
  %856 = load float, ptr %680, align 4, !tbaa !11
  %857 = fsub float %855, %856
  %858 = call float @llvm.fabs.f32(float %857)
  %or.cond99 = fcmp ogt float %858, 0x3E80000000000000
  br i1 %or.cond99, label %859, label %869

859:                                              ; preds = %852
  %860 = getelementptr inbounds i8, ptr %0, i64 4
  %861 = load i32, ptr %860, align 4, !tbaa !10
  %862 = add nsw i32 %861, 1
  store i32 %862, ptr %860, align 4, !tbaa !10
  %863 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 209)
  %864 = load float, ptr %680, align 4, !tbaa !11
  %865 = fpext float %864 to double
  %866 = fpext float %855 to double
  %867 = fpext float %857 to double
  %868 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %865, double noundef %866, double noundef %867)
  %.pre739 = load i32, ptr %0, align 4, !tbaa !5
  br label %869

869:                                              ; preds = %852, %859
  %870 = phi i32 [ %854, %852 ], [ %.pre739, %859 ]
  %871 = add nsw i32 %870, 1
  store i32 %871, ptr %0, align 4, !tbaa !5
  %872 = load float, ptr %697, align 4, !tbaa !11
  %873 = load float, ptr %699, align 4, !tbaa !11
  %874 = fsub float %872, %873
  %875 = call float @llvm.fabs.f32(float %874)
  %or.cond101 = fcmp ogt float %875, 0x3E80000000000000
  br i1 %or.cond101, label %876, label %886

876:                                              ; preds = %869
  %877 = getelementptr inbounds i8, ptr %0, i64 4
  %878 = load i32, ptr %877, align 4, !tbaa !10
  %879 = add nsw i32 %878, 1
  store i32 %879, ptr %877, align 4, !tbaa !10
  %880 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 210)
  %881 = load float, ptr %699, align 4, !tbaa !11
  %882 = fpext float %881 to double
  %883 = fpext float %872 to double
  %884 = fpext float %874 to double
  %885 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %882, double noundef %883, double noundef %884)
  %.pre740 = load i32, ptr %0, align 4, !tbaa !5
  br label %886

886:                                              ; preds = %869, %876
  %887 = phi i32 [ %871, %869 ], [ %.pre740, %876 ]
  %888 = add nsw i32 %887, 1
  store i32 %888, ptr %0, align 4, !tbaa !5
  %889 = load float, ptr %716, align 4, !tbaa !11
  %890 = load float, ptr %718, align 4, !tbaa !11
  %891 = fsub float %889, %890
  %892 = call float @llvm.fabs.f32(float %891)
  %or.cond103 = fcmp ogt float %892, 0x3E80000000000000
  br i1 %or.cond103, label %893, label %903

893:                                              ; preds = %886
  %894 = getelementptr inbounds i8, ptr %0, i64 4
  %895 = load i32, ptr %894, align 4, !tbaa !10
  %896 = add nsw i32 %895, 1
  store i32 %896, ptr %894, align 4, !tbaa !10
  %897 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 211)
  %898 = load float, ptr %718, align 4, !tbaa !11
  %899 = fpext float %898 to double
  %900 = fpext float %889 to double
  %901 = fpext float %891 to double
  %902 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %899, double noundef %900, double noundef %901)
  %.pre741 = load i32, ptr %0, align 4, !tbaa !5
  br label %903

903:                                              ; preds = %886, %893
  %904 = phi i32 [ %888, %886 ], [ %.pre741, %893 ]
  %905 = add nsw i32 %904, 1
  store i32 %905, ptr %0, align 4, !tbaa !5
  %906 = load float, ptr %735, align 4, !tbaa !11
  %907 = load float, ptr %737, align 4, !tbaa !11
  %908 = fsub float %906, %907
  %909 = call float @llvm.fabs.f32(float %908)
  %or.cond105 = fcmp ogt float %909, 0x3E80000000000000
  br i1 %or.cond105, label %910, label %920

910:                                              ; preds = %903
  %911 = getelementptr inbounds i8, ptr %0, i64 4
  %912 = load i32, ptr %911, align 4, !tbaa !10
  %913 = add nsw i32 %912, 1
  store i32 %913, ptr %911, align 4, !tbaa !10
  %914 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 212)
  %915 = load float, ptr %737, align 4, !tbaa !11
  %916 = fpext float %915 to double
  %917 = fpext float %906 to double
  %918 = fpext float %908 to double
  %919 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %916, double noundef %917, double noundef %918)
  %.pre742 = load i32, ptr %0, align 4, !tbaa !5
  br label %920

920:                                              ; preds = %903, %910
  %921 = phi i32 [ %905, %903 ], [ %.pre742, %910 ]
  %922 = add nsw i32 %921, 1
  store i32 %922, ptr %0, align 4, !tbaa !5
  %923 = load float, ptr %754, align 4, !tbaa !11
  %924 = load float, ptr %756, align 4, !tbaa !11
  %925 = fsub float %923, %924
  %926 = call float @llvm.fabs.f32(float %925)
  %or.cond107 = fcmp ogt float %926, 0x3E80000000000000
  br i1 %or.cond107, label %927, label %937

927:                                              ; preds = %920
  %928 = getelementptr inbounds i8, ptr %0, i64 4
  %929 = load i32, ptr %928, align 4, !tbaa !10
  %930 = add nsw i32 %929, 1
  store i32 %930, ptr %928, align 4, !tbaa !10
  %931 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 213)
  %932 = load float, ptr %756, align 4, !tbaa !11
  %933 = fpext float %932 to double
  %934 = fpext float %923 to double
  %935 = fpext float %925 to double
  %936 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %933, double noundef %934, double noundef %935)
  br label %937

937:                                              ; preds = %920, %927
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %8) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %7) #7
  %.sroa.0233.0.copyload = load <2 x float>, ptr @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix.47, align 4
  %.sroa.9.0.copyload = load <2 x float>, ptr getelementptr inbounds (i8, ptr @__const._Z30_hmt_test_InvMatrix_InvGeneralP21hmt_testresult_struct.Matrix.47, i64 8), align 4
  %938 = call { <2 x float>, <2 x float> } @_ZL7HMM_M2Df(float noundef 1.000000e+00)
  %939 = extractvalue { <2 x float>, <2 x float> } %938, 0
  %940 = extractvalue { <2 x float>, <2 x float> } %938, 1
  %941 = call { <2 x float>, <2 x float> } @_ZL16HMM_InvGeneralM28HMM_Mat2(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload)
  %942 = extractvalue { <2 x float>, <2 x float> } %941, 0
  %943 = extractvalue { <2 x float>, <2 x float> } %941, 1
  %944 = call { <2 x float>, <2 x float> } @_ZL9HMM_MulM28HMM_Mat2S_(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload, <2 x float> %942, <2 x float> %943)
  %945 = extractvalue { <2 x float>, <2 x float> } %944, 0
  %946 = extractvalue { <2 x float>, <2 x float> } %944, 1
  %947 = call noundef float @_ZL17HMM_DeterminantM28HMM_Mat2(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload)
  %948 = load i32, ptr %0, align 4, !tbaa !5
  %949 = add nsw i32 %948, 1
  store i32 %949, ptr %0, align 4, !tbaa !5
  %950 = fadd float %947, -5.800000e+01
  %951 = call float @llvm.fabs.f32(float %950)
  %or.cond109 = fcmp ogt float %951, 0x3E80000000000000
  br i1 %or.cond109, label %952, label %960

952:                                              ; preds = %937
  %953 = getelementptr inbounds i8, ptr %0, i64 4
  %954 = load i32, ptr %953, align 4, !tbaa !10
  %955 = add nsw i32 %954, 1
  store i32 %955, ptr %953, align 4, !tbaa !10
  %956 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 228)
  %957 = fpext float %947 to double
  %958 = fpext float %950 to double
  %959 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.800000e+01, double noundef %957, double noundef %958)
  %.pre743 = load i32, ptr %0, align 4, !tbaa !5
  br label %960

960:                                              ; preds = %937, %952
  %961 = phi i32 [ %949, %937 ], [ %.pre743, %952 ]
  %962 = add nsw i32 %961, 1
  store i32 %962, ptr %0, align 4, !tbaa !5
  %.sroa.0208.0.vec.extract = extractelement <2 x float> %939, i64 0
  %963 = fsub <2 x float> %945, %939
  %964 = extractelement <2 x float> %963, i64 0
  %965 = call float @llvm.fabs.f32(float %964)
  %or.cond111 = fcmp ogt float %965, 0x3E80000000000000
  br i1 %or.cond111, label %966, label %975

966:                                              ; preds = %960
  %.sroa.0194.0.vec.extract = extractelement <2 x float> %945, i64 0
  %967 = getelementptr inbounds i8, ptr %0, i64 4
  %968 = load i32, ptr %967, align 4, !tbaa !10
  %969 = add nsw i32 %968, 1
  store i32 %969, ptr %967, align 4, !tbaa !10
  %970 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 230)
  %971 = fpext float %.sroa.0208.0.vec.extract to double
  %972 = fpext float %.sroa.0194.0.vec.extract to double
  %973 = fpext float %964 to double
  %974 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %971, double noundef %972, double noundef %973)
  %.pre744 = load i32, ptr %0, align 4, !tbaa !5
  br label %975

975:                                              ; preds = %960, %966
  %976 = phi i32 [ %962, %960 ], [ %.pre744, %966 ]
  %977 = add nsw i32 %976, 1
  store i32 %977, ptr %0, align 4, !tbaa !5
  %.sroa.0194.4.vec.extract = extractelement <2 x float> %945, i64 1
  %.sroa.0208.4.vec.extract = extractelement <2 x float> %939, i64 1
  %978 = fsub float %.sroa.0194.4.vec.extract, %.sroa.0208.4.vec.extract
  %979 = call float @llvm.fabs.f32(float %978)
  %or.cond113 = fcmp ogt float %979, 0x3E80000000000000
  br i1 %or.cond113, label %980, label %989

980:                                              ; preds = %975
  %981 = getelementptr inbounds i8, ptr %0, i64 4
  %982 = load i32, ptr %981, align 4, !tbaa !10
  %983 = add nsw i32 %982, 1
  store i32 %983, ptr %981, align 4, !tbaa !10
  %984 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 231)
  %985 = fpext float %.sroa.0208.4.vec.extract to double
  %986 = fpext float %.sroa.0194.4.vec.extract to double
  %987 = fpext float %978 to double
  %988 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %985, double noundef %986, double noundef %987)
  %.pre745 = load i32, ptr %0, align 4, !tbaa !5
  br label %989

989:                                              ; preds = %975, %980
  %990 = phi i32 [ %977, %975 ], [ %.pre745, %980 ]
  %991 = add nsw i32 %990, 1
  store i32 %991, ptr %0, align 4, !tbaa !5
  %.sroa.11.8.vec.extract = extractelement <2 x float> %940, i64 0
  %992 = fsub <2 x float> %946, %940
  %993 = extractelement <2 x float> %992, i64 0
  %994 = call float @llvm.fabs.f32(float %993)
  %or.cond115 = fcmp ogt float %994, 0x3E80000000000000
  br i1 %or.cond115, label %995, label %1004

995:                                              ; preds = %989
  %.sroa.8.8.vec.extract = extractelement <2 x float> %946, i64 0
  %996 = getelementptr inbounds i8, ptr %0, i64 4
  %997 = load i32, ptr %996, align 4, !tbaa !10
  %998 = add nsw i32 %997, 1
  store i32 %998, ptr %996, align 4, !tbaa !10
  %999 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 232)
  %1000 = fpext float %.sroa.11.8.vec.extract to double
  %1001 = fpext float %.sroa.8.8.vec.extract to double
  %1002 = fpext float %993 to double
  %1003 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1000, double noundef %1001, double noundef %1002)
  %.pre746 = load i32, ptr %0, align 4, !tbaa !5
  br label %1004

1004:                                             ; preds = %989, %995
  %1005 = phi i32 [ %991, %989 ], [ %.pre746, %995 ]
  %1006 = add nsw i32 %1005, 1
  store i32 %1006, ptr %0, align 4, !tbaa !5
  %.sroa.8.12.vec.extract = extractelement <2 x float> %946, i64 1
  %.sroa.11.12.vec.extract = extractelement <2 x float> %940, i64 1
  %1007 = fsub float %.sroa.8.12.vec.extract, %.sroa.11.12.vec.extract
  %1008 = call float @llvm.fabs.f32(float %1007)
  %or.cond117 = fcmp ogt float %1008, 0x3E80000000000000
  br i1 %or.cond117, label %1009, label %1018

1009:                                             ; preds = %1004
  %1010 = getelementptr inbounds i8, ptr %0, i64 4
  %1011 = load i32, ptr %1010, align 4, !tbaa !10
  %1012 = add nsw i32 %1011, 1
  store i32 %1012, ptr %1010, align 4, !tbaa !10
  %1013 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 233)
  %1014 = fpext float %.sroa.11.12.vec.extract to double
  %1015 = fpext float %.sroa.8.12.vec.extract to double
  %1016 = fpext float %1007 to double
  %1017 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1014, double noundef %1015, double noundef %1016)
  br label %1018

1018:                                             ; preds = %1004, %1009
  %1019 = call { <2 x float>, <2 x float> } @_ZL14HMM_InvGeneral8HMM_Mat2(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload)
  %1020 = extractvalue { <2 x float>, <2 x float> } %1019, 0
  %1021 = extractvalue { <2 x float>, <2 x float> } %1019, 1
  %1022 = call { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2S_(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload, <2 x float> %1020, <2 x float> %1021)
  %1023 = extractvalue { <2 x float>, <2 x float> } %1022, 0
  %1024 = extractvalue { <2 x float>, <2 x float> } %1022, 1
  %1025 = call noundef float @_ZL15HMM_Determinant8HMM_Mat2(<2 x float> %.sroa.0233.0.copyload, <2 x float> %.sroa.9.0.copyload)
  %1026 = load i32, ptr %0, align 4, !tbaa !5
  %1027 = add nsw i32 %1026, 1
  store i32 %1027, ptr %0, align 4, !tbaa !5
  %1028 = fadd float %1025, -5.800000e+01
  %1029 = call float @llvm.fabs.f32(float %1028)
  %or.cond119 = fcmp ogt float %1029, 0x3E80000000000000
  br i1 %or.cond119, label %1030, label %1038

1030:                                             ; preds = %1018
  %1031 = getelementptr inbounds i8, ptr %0, i64 4
  %1032 = load i32, ptr %1031, align 4, !tbaa !10
  %1033 = add nsw i32 %1032, 1
  store i32 %1033, ptr %1031, align 4, !tbaa !10
  %1034 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 239)
  %1035 = fpext float %1025 to double
  %1036 = fpext float %1028 to double
  %1037 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 5.800000e+01, double noundef %1035, double noundef %1036)
  %.pre747 = load i32, ptr %0, align 4, !tbaa !5
  br label %1038

1038:                                             ; preds = %1018, %1030
  %1039 = phi i32 [ %1027, %1018 ], [ %.pre747, %1030 ]
  %1040 = add nsw i32 %1039, 1
  store i32 %1040, ptr %0, align 4, !tbaa !5
  %1041 = fsub <2 x float> %1023, %939
  %1042 = extractelement <2 x float> %1041, i64 0
  %1043 = call float @llvm.fabs.f32(float %1042)
  %or.cond121 = fcmp ogt float %1043, 0x3E80000000000000
  br i1 %or.cond121, label %1044, label %1053

1044:                                             ; preds = %1038
  %.sroa.0194.0.vec.extract196 = extractelement <2 x float> %1023, i64 0
  %1045 = getelementptr inbounds i8, ptr %0, i64 4
  %1046 = load i32, ptr %1045, align 4, !tbaa !10
  %1047 = add nsw i32 %1046, 1
  store i32 %1047, ptr %1045, align 4, !tbaa !10
  %1048 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 241)
  %1049 = fpext float %.sroa.0208.0.vec.extract to double
  %1050 = fpext float %.sroa.0194.0.vec.extract196 to double
  %1051 = fpext float %1042 to double
  %1052 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1049, double noundef %1050, double noundef %1051)
  %.pre748 = load i32, ptr %0, align 4, !tbaa !5
  br label %1053

1053:                                             ; preds = %1038, %1044
  %1054 = phi i32 [ %1040, %1038 ], [ %.pre748, %1044 ]
  %1055 = add nsw i32 %1054, 1
  store i32 %1055, ptr %0, align 4, !tbaa !5
  %.sroa.0194.4.vec.extract198 = extractelement <2 x float> %1023, i64 1
  %1056 = fsub float %.sroa.0194.4.vec.extract198, %.sroa.0208.4.vec.extract
  %1057 = call float @llvm.fabs.f32(float %1056)
  %or.cond123 = fcmp ogt float %1057, 0x3E80000000000000
  br i1 %or.cond123, label %1058, label %1067

1058:                                             ; preds = %1053
  %1059 = getelementptr inbounds i8, ptr %0, i64 4
  %1060 = load i32, ptr %1059, align 4, !tbaa !10
  %1061 = add nsw i32 %1060, 1
  store i32 %1061, ptr %1059, align 4, !tbaa !10
  %1062 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 242)
  %1063 = fpext float %.sroa.0208.4.vec.extract to double
  %1064 = fpext float %.sroa.0194.4.vec.extract198 to double
  %1065 = fpext float %1056 to double
  %1066 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1063, double noundef %1064, double noundef %1065)
  %.pre749 = load i32, ptr %0, align 4, !tbaa !5
  br label %1067

1067:                                             ; preds = %1053, %1058
  %1068 = phi i32 [ %1055, %1053 ], [ %.pre749, %1058 ]
  %1069 = add nsw i32 %1068, 1
  store i32 %1069, ptr %0, align 4, !tbaa !5
  %1070 = fsub <2 x float> %1024, %940
  %1071 = extractelement <2 x float> %1070, i64 0
  %1072 = call float @llvm.fabs.f32(float %1071)
  %or.cond125 = fcmp ogt float %1072, 0x3E80000000000000
  br i1 %or.cond125, label %1073, label %1082

1073:                                             ; preds = %1067
  %.sroa.8.8.vec.extract200 = extractelement <2 x float> %1024, i64 0
  %1074 = getelementptr inbounds i8, ptr %0, i64 4
  %1075 = load i32, ptr %1074, align 4, !tbaa !10
  %1076 = add nsw i32 %1075, 1
  store i32 %1076, ptr %1074, align 4, !tbaa !10
  %1077 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 243)
  %1078 = fpext float %.sroa.11.8.vec.extract to double
  %1079 = fpext float %.sroa.8.8.vec.extract200 to double
  %1080 = fpext float %1071 to double
  %1081 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1078, double noundef %1079, double noundef %1080)
  %.pre750 = load i32, ptr %0, align 4, !tbaa !5
  br label %1082

1082:                                             ; preds = %1067, %1073
  %1083 = phi i32 [ %1069, %1067 ], [ %.pre750, %1073 ]
  %1084 = add nsw i32 %1083, 1
  store i32 %1084, ptr %0, align 4, !tbaa !5
  %.sroa.8.12.vec.extract202 = extractelement <2 x float> %1024, i64 1
  %1085 = fsub float %.sroa.8.12.vec.extract202, %.sroa.11.12.vec.extract
  %1086 = call float @llvm.fabs.f32(float %1085)
  %or.cond127 = fcmp ogt float %1086, 0x3E80000000000000
  br i1 %or.cond127, label %1087, label %1096

1087:                                             ; preds = %1082
  %1088 = getelementptr inbounds i8, ptr %0, i64 4
  %1089 = load i32, ptr %1088, align 4, !tbaa !10
  %1090 = add nsw i32 %1089, 1
  store i32 %1090, ptr %1088, align 4, !tbaa !10
  %1091 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 244)
  %1092 = fpext float %.sroa.11.12.vec.extract to double
  %1093 = fpext float %.sroa.8.12.vec.extract202 to double
  %1094 = fpext float %1085 to double
  %1095 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %1092, double noundef %1093, double noundef %1094)
  br label %1096

1096:                                             ; preds = %1082, %1087
  ret void
}

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

; 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 #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM48HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL14HMM_InvGeneral8HMM_Mat4(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16) local_unnamed_addr #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) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat4(ptr noundef byval(%union.HMM_Mat4) align 16) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL16HMM_InvGeneralM38HMM_Mat3(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL9HMM_MulM38HMM_Mat3S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8, ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM38HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL14HMM_InvGeneral8HMM_Mat3(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL7HMM_Mul8HMM_Mat3S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat3) align 4, ptr noundef byval(%union.HMM_Mat3) align 8, ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat3(ptr noundef byval(%union.HMM_Mat3) align 8) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL16HMM_InvGeneralM28HMM_Mat2(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL9HMM_MulM28HMM_Mat2S_(<2 x float>, <2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL17HMM_DeterminantM28HMM_Mat2(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL14HMM_InvGeneral8HMM_Mat2(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2S_(<2 x float>, <2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef float @_ZL15HMM_Determinant8HMM_Mat2(<2 x float>, <2 x float>) local_unnamed_addr #5

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { inlinehint mustprogress uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { 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, !7, i64 0}
!6 = !{!"_ZTS21hmt_testresult_struct", !7, i64 0, !7, i64 4}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C++ TBAA"}
!10 = !{!6, !7, i64 4}
!11 = !{!8, !8, i64 0}
!12 = !{i64 0, i64 64, !11}
!13 = !{i64 0, i64 36, !11}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,MemCpyOptPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass