; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z29_hmt_test_InvMatrix_TransposeP21hmt_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.18 = external hidden unnamed_addr constant [34 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix = external hidden unnamed_addr constant %union.HMM_Mat2, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect = external hidden unnamed_addr constant %union.HMM_Mat2, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.42 = external hidden unnamed_addr constant %union.HMM_Mat3, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43 = external hidden unnamed_addr constant %union.HMM_Mat3, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.44 = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45 = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16

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

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

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct(ptr noundef %0) #4 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat2, align 4
  %4 = alloca %union.HMM_Mat2, align 4
  %5 = alloca %union.HMM_Mat2, align 4
  %6 = alloca %union.HMM_Mat2, align 4
  %7 = alloca float, align 4
  %8 = alloca float, align 4
  %9 = alloca float, align 4
  %10 = alloca float, align 4
  %11 = alloca float, align 4
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca %union.HMM_Mat2, align 4
  %16 = alloca %union.HMM_Mat2, 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 %union.HMM_Mat3, align 4
  %26 = alloca %union.HMM_Mat3, align 4
  %27 = alloca %union.HMM_Mat3, align 4
  %28 = alloca %union.HMM_Mat3, align 8
  %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 float, align 4
  %47 = alloca %union.HMM_Mat3, align 4
  %48 = alloca %union.HMM_Mat3, align 8
  %49 = alloca float, align 4
  %50 = alloca float, align 4
  %51 = alloca float, align 4
  %52 = alloca float, align 4
  %53 = alloca float, align 4
  %54 = alloca float, align 4
  %55 = alloca float, align 4
  %56 = alloca float, align 4
  %57 = alloca float, align 4
  %58 = alloca float, align 4
  %59 = alloca float, align 4
  %60 = alloca float, align 4
  %61 = alloca float, align 4
  %62 = alloca float, align 4
  %63 = alloca float, align 4
  %64 = alloca float, align 4
  %65 = alloca float, align 4
  %66 = alloca float, align 4
  %67 = alloca %union.HMM_Mat4, align 16
  %68 = alloca %union.HMM_Mat4, align 16
  %69 = alloca %union.HMM_Mat4, align 16
  %70 = alloca %union.HMM_Mat4, align 16
  %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 float, align 4
  %87 = alloca float, align 4
  %88 = alloca float, align 4
  %89 = alloca %union.HMM_Mat4, align 16
  %90 = alloca %union.HMM_Mat4, align 16
  %91 = alloca float, align 4
  %92 = alloca float, align 4
  %93 = alloca float, align 4
  %94 = alloca float, align 4
  %95 = alloca float, align 4
  %96 = alloca float, align 4
  %97 = alloca float, align 4
  %98 = alloca float, align 4
  %99 = alloca float, align 4
  %100 = alloca float, align 4
  %101 = alloca float, align 4
  %102 = alloca float, align 4
  %103 = alloca float, align 4
  %104 = alloca float, align 4
  %105 = alloca float, align 4
  %106 = alloca float, align 4
  %107 = alloca float, align 4
  %108 = alloca float, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %3) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %3, ptr align 4 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix, i64 16, i1 false)
  call void @llvm.lifetime.start.p0(i64 16, ptr %4) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %4, ptr align 4 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect, i64 16, i1 false)
  call void @llvm.lifetime.start.p0(i64 16, ptr %5) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !9
  %109 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %6, i32 0, i32 0
  %110 = load <2 x float>, ptr %109, align 4
  %111 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %6, i32 0, i32 1
  %112 = load <2 x float>, ptr %111, align 4
  %113 = call { <2 x float>, <2 x float> } @_ZL15HMM_TransposeM28HMM_Mat2(<2 x float> %110, <2 x float> %112)
  %114 = getelementptr inbounds %union.HMM_Mat2, ptr %5, i32 0, i32 0
  %115 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %114, i32 0, i32 0
  %116 = extractvalue { <2 x float>, <2 x float> } %113, 0
  store <2 x float> %116, ptr %115, align 4
  %117 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %114, i32 0, i32 1
  %118 = extractvalue { <2 x float>, <2 x float> } %113, 1
  store <2 x float> %118, ptr %117, align 4
  %119 = load ptr, ptr %2, align 8, !tbaa !5
  %120 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %119, i32 0, i32 0
  %121 = load i32, ptr %120, align 4, !tbaa !11
  %122 = add nsw i32 %121, 1
  store i32 %122, ptr %120, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #7
  %123 = getelementptr inbounds [2 x [2 x float]], ptr %5, i64 0, i64 0
  %124 = getelementptr inbounds [2 x float], ptr %123, i64 0, i64 0
  %125 = load float, ptr %124, align 4, !tbaa !10
  store float %125, ptr %7, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #7
  %126 = load float, ptr %7, align 4, !tbaa !14
  %127 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %128 = getelementptr inbounds [2 x float], ptr %127, i64 0, i64 0
  %129 = load float, ptr %128, align 4, !tbaa !10
  %130 = fsub float %126, %129
  store float %130, ptr %8, align 4, !tbaa !14
  %131 = load float, ptr %8, align 4, !tbaa !14
  %132 = fcmp olt float %131, 0xBE80000000000000
  br i1 %132, label %136, label %133

133:                                              ; preds = %1
  %134 = load float, ptr %8, align 4, !tbaa !14
  %135 = fcmp olt float 0x3E80000000000000, %134
  br i1 %135, label %136, label %151

136:                                              ; preds = %133, %1
  %137 = load ptr, ptr %2, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %137, i32 0, i32 1
  %139 = load i32, ptr %138, align 4, !tbaa !16
  %140 = add nsw i32 %139, 1
  store i32 %140, ptr %138, align 4, !tbaa !16
  %141 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 17)
  %142 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %143 = getelementptr inbounds [2 x float], ptr %142, i64 0, i64 0
  %144 = load float, ptr %143, align 4, !tbaa !10
  %145 = fpext float %144 to double
  %146 = load float, ptr %7, align 4, !tbaa !14
  %147 = fpext float %146 to double
  %148 = load float, ptr %8, align 4, !tbaa !14
  %149 = fpext float %148 to double
  %150 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %145, double noundef %147, double noundef %149)
  br label %151

151:                                              ; preds = %136, %133
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #7
  %152 = load ptr, ptr %2, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %152, i32 0, i32 0
  %154 = load i32, ptr %153, align 4, !tbaa !11
  %155 = add nsw i32 %154, 1
  store i32 %155, ptr %153, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #7
  %156 = getelementptr inbounds [2 x [2 x float]], ptr %5, i64 0, i64 0
  %157 = getelementptr inbounds [2 x float], ptr %156, i64 0, i64 1
  %158 = load float, ptr %157, align 4, !tbaa !10
  store float %158, ptr %9, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #7
  %159 = load float, ptr %9, align 4, !tbaa !14
  %160 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %161 = getelementptr inbounds [2 x float], ptr %160, i64 0, i64 1
  %162 = load float, ptr %161, align 4, !tbaa !10
  %163 = fsub float %159, %162
  store float %163, ptr %10, align 4, !tbaa !14
  %164 = load float, ptr %10, align 4, !tbaa !14
  %165 = fcmp olt float %164, 0xBE80000000000000
  br i1 %165, label %169, label %166

166:                                              ; preds = %151
  %167 = load float, ptr %10, align 4, !tbaa !14
  %168 = fcmp olt float 0x3E80000000000000, %167
  br i1 %168, label %169, label %184

169:                                              ; preds = %166, %151
  %170 = load ptr, ptr %2, align 8, !tbaa !5
  %171 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %170, i32 0, i32 1
  %172 = load i32, ptr %171, align 4, !tbaa !16
  %173 = add nsw i32 %172, 1
  store i32 %173, ptr %171, align 4, !tbaa !16
  %174 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 18)
  %175 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %176 = getelementptr inbounds [2 x float], ptr %175, i64 0, i64 1
  %177 = load float, ptr %176, align 4, !tbaa !10
  %178 = fpext float %177 to double
  %179 = load float, ptr %9, align 4, !tbaa !14
  %180 = fpext float %179 to double
  %181 = load float, ptr %10, align 4, !tbaa !14
  %182 = fpext float %181 to double
  %183 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %178, double noundef %180, double noundef %182)
  br label %184

184:                                              ; preds = %169, %166
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #7
  %185 = load ptr, ptr %2, align 8, !tbaa !5
  %186 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %185, i32 0, i32 0
  %187 = load i32, ptr %186, align 4, !tbaa !11
  %188 = add nsw i32 %187, 1
  store i32 %188, ptr %186, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #7
  %189 = getelementptr inbounds [2 x [2 x float]], ptr %5, i64 0, i64 1
  %190 = getelementptr inbounds [2 x float], ptr %189, i64 0, i64 0
  %191 = load float, ptr %190, align 4, !tbaa !10
  store float %191, ptr %11, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  %192 = load float, ptr %11, align 4, !tbaa !14
  %193 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %194 = getelementptr inbounds [2 x float], ptr %193, i64 0, i64 0
  %195 = load float, ptr %194, align 4, !tbaa !10
  %196 = fsub float %192, %195
  store float %196, ptr %12, align 4, !tbaa !14
  %197 = load float, ptr %12, align 4, !tbaa !14
  %198 = fcmp olt float %197, 0xBE80000000000000
  br i1 %198, label %202, label %199

199:                                              ; preds = %184
  %200 = load float, ptr %12, align 4, !tbaa !14
  %201 = fcmp olt float 0x3E80000000000000, %200
  br i1 %201, label %202, label %217

202:                                              ; preds = %199, %184
  %203 = load ptr, ptr %2, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %203, i32 0, i32 1
  %205 = load i32, ptr %204, align 4, !tbaa !16
  %206 = add nsw i32 %205, 1
  store i32 %206, ptr %204, align 4, !tbaa !16
  %207 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 19)
  %208 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %209 = getelementptr inbounds [2 x float], ptr %208, i64 0, i64 0
  %210 = load float, ptr %209, align 4, !tbaa !10
  %211 = fpext float %210 to double
  %212 = load float, ptr %11, align 4, !tbaa !14
  %213 = fpext float %212 to double
  %214 = load float, ptr %12, align 4, !tbaa !14
  %215 = fpext float %214 to double
  %216 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %211, double noundef %213, double noundef %215)
  br label %217

217:                                              ; preds = %202, %199
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #7
  %218 = load ptr, ptr %2, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %218, i32 0, i32 0
  %220 = load i32, ptr %219, align 4, !tbaa !11
  %221 = add nsw i32 %220, 1
  store i32 %221, ptr %219, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #7
  %222 = getelementptr inbounds [2 x [2 x float]], ptr %5, i64 0, i64 1
  %223 = getelementptr inbounds [2 x float], ptr %222, i64 0, i64 1
  %224 = load float, ptr %223, align 4, !tbaa !10
  store float %224, ptr %13, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  %225 = load float, ptr %13, align 4, !tbaa !14
  %226 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %227 = getelementptr inbounds [2 x float], ptr %226, i64 0, i64 1
  %228 = load float, ptr %227, align 4, !tbaa !10
  %229 = fsub float %225, %228
  store float %229, ptr %14, align 4, !tbaa !14
  %230 = load float, ptr %14, align 4, !tbaa !14
  %231 = fcmp olt float %230, 0xBE80000000000000
  br i1 %231, label %235, label %232

232:                                              ; preds = %217
  %233 = load float, ptr %14, align 4, !tbaa !14
  %234 = fcmp olt float 0x3E80000000000000, %233
  br i1 %234, label %235, label %250

235:                                              ; preds = %232, %217
  %236 = load ptr, ptr %2, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %236, i32 0, i32 1
  %238 = load i32, ptr %237, align 4, !tbaa !16
  %239 = add nsw i32 %238, 1
  store i32 %239, ptr %237, align 4, !tbaa !16
  %240 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 20)
  %241 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %242 = getelementptr inbounds [2 x float], ptr %241, i64 0, i64 1
  %243 = load float, ptr %242, align 4, !tbaa !10
  %244 = fpext float %243 to double
  %245 = load float, ptr %13, align 4, !tbaa !14
  %246 = fpext float %245 to double
  %247 = load float, ptr %14, align 4, !tbaa !14
  %248 = fpext float %247 to double
  %249 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %244, double noundef %246, double noundef %248)
  br label %250

250:                                              ; preds = %235, %232
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %5) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr %15) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %16, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !9
  %251 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %16, i32 0, i32 0
  %252 = load <2 x float>, ptr %251, align 4
  %253 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %16, i32 0, i32 1
  %254 = load <2 x float>, ptr %253, align 4
  %255 = call { <2 x float>, <2 x float> } @_ZL13HMM_Transpose8HMM_Mat2(<2 x float> %252, <2 x float> %254)
  %256 = getelementptr inbounds %union.HMM_Mat2, ptr %15, i32 0, i32 0
  %257 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %256, i32 0, i32 0
  %258 = extractvalue { <2 x float>, <2 x float> } %255, 0
  store <2 x float> %258, ptr %257, align 4
  %259 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %256, i32 0, i32 1
  %260 = extractvalue { <2 x float>, <2 x float> } %255, 1
  store <2 x float> %260, ptr %259, align 4
  %261 = load ptr, ptr %2, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %261, i32 0, i32 0
  %263 = load i32, ptr %262, align 4, !tbaa !11
  %264 = add nsw i32 %263, 1
  store i32 %264, ptr %262, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #7
  %265 = getelementptr inbounds [2 x [2 x float]], ptr %15, i64 0, i64 0
  %266 = getelementptr inbounds [2 x float], ptr %265, i64 0, i64 0
  %267 = load float, ptr %266, align 4, !tbaa !10
  store float %267, ptr %17, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #7
  %268 = load float, ptr %17, align 4, !tbaa !14
  %269 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %270 = getelementptr inbounds [2 x float], ptr %269, i64 0, i64 0
  %271 = load float, ptr %270, align 4, !tbaa !10
  %272 = fsub float %268, %271
  store float %272, ptr %18, align 4, !tbaa !14
  %273 = load float, ptr %18, align 4, !tbaa !14
  %274 = fcmp olt float %273, 0xBE80000000000000
  br i1 %274, label %278, label %275

275:                                              ; preds = %250
  %276 = load float, ptr %18, align 4, !tbaa !14
  %277 = fcmp olt float 0x3E80000000000000, %276
  br i1 %277, label %278, label %293

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

293:                                              ; preds = %278, %275
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #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 !11
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %295, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #7
  %298 = getelementptr inbounds [2 x [2 x float]], ptr %15, i64 0, i64 0
  %299 = getelementptr inbounds [2 x float], ptr %298, i64 0, i64 1
  %300 = load float, ptr %299, align 4, !tbaa !10
  store float %300, ptr %19, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #7
  %301 = load float, ptr %19, align 4, !tbaa !14
  %302 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %303 = getelementptr inbounds [2 x float], ptr %302, i64 0, i64 1
  %304 = load float, ptr %303, align 4, !tbaa !10
  %305 = fsub float %301, %304
  store float %305, ptr %20, align 4, !tbaa !14
  %306 = load float, ptr %20, align 4, !tbaa !14
  %307 = fcmp olt float %306, 0xBE80000000000000
  br i1 %307, label %311, label %308

308:                                              ; preds = %293
  %309 = load float, ptr %20, align 4, !tbaa !14
  %310 = fcmp olt float 0x3E80000000000000, %309
  br i1 %310, label %311, label %326

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 26)
  %317 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 0
  %318 = getelementptr inbounds [2 x float], ptr %317, i64 0, i64 1
  %319 = load float, ptr %318, align 4, !tbaa !10
  %320 = fpext float %319 to double
  %321 = load float, ptr %19, align 4, !tbaa !14
  %322 = fpext float %321 to double
  %323 = load float, ptr %20, align 4, !tbaa !14
  %324 = fpext float %323 to double
  %325 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %320, double noundef %322, double noundef %324)
  br label %326

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

341:                                              ; preds = %326
  %342 = load float, ptr %22, align 4, !tbaa !14
  %343 = fcmp olt float 0x3E80000000000000, %342
  br i1 %343, label %344, label %359

344:                                              ; preds = %341, %326
  %345 = load ptr, ptr %2, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %345, i32 0, i32 1
  %347 = load i32, ptr %346, align 4, !tbaa !16
  %348 = add nsw i32 %347, 1
  store i32 %348, ptr %346, align 4, !tbaa !16
  %349 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 27)
  %350 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %351 = getelementptr inbounds [2 x float], ptr %350, i64 0, i64 0
  %352 = load float, ptr %351, align 4, !tbaa !10
  %353 = fpext float %352 to double
  %354 = load float, ptr %21, align 4, !tbaa !14
  %355 = fpext float %354 to double
  %356 = load float, ptr %22, align 4, !tbaa !14
  %357 = fpext float %356 to double
  %358 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %353, double noundef %355, double noundef %357)
  br label %359

359:                                              ; preds = %344, %341
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #7
  %360 = load ptr, ptr %2, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %360, i32 0, i32 0
  %362 = load i32, ptr %361, align 4, !tbaa !11
  %363 = add nsw i32 %362, 1
  store i32 %363, ptr %361, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #7
  %364 = getelementptr inbounds [2 x [2 x float]], ptr %15, i64 0, i64 1
  %365 = getelementptr inbounds [2 x float], ptr %364, i64 0, i64 1
  %366 = load float, ptr %365, align 4, !tbaa !10
  store float %366, ptr %23, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #7
  %367 = load float, ptr %23, align 4, !tbaa !14
  %368 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %369 = getelementptr inbounds [2 x float], ptr %368, i64 0, i64 1
  %370 = load float, ptr %369, align 4, !tbaa !10
  %371 = fsub float %367, %370
  store float %371, ptr %24, align 4, !tbaa !14
  %372 = load float, ptr %24, align 4, !tbaa !14
  %373 = fcmp olt float %372, 0xBE80000000000000
  br i1 %373, label %377, label %374

374:                                              ; preds = %359
  %375 = load float, ptr %24, align 4, !tbaa !14
  %376 = fcmp olt float 0x3E80000000000000, %375
  br i1 %376, label %377, label %392

377:                                              ; preds = %374, %359
  %378 = load ptr, ptr %2, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %378, i32 0, i32 1
  %380 = load i32, ptr %379, align 4, !tbaa !16
  %381 = add nsw i32 %380, 1
  store i32 %381, ptr %379, align 4, !tbaa !16
  %382 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 28)
  %383 = getelementptr inbounds [2 x [2 x float]], ptr %4, i64 0, i64 1
  %384 = getelementptr inbounds [2 x float], ptr %383, i64 0, i64 1
  %385 = load float, ptr %384, align 4, !tbaa !10
  %386 = fpext float %385 to double
  %387 = load float, ptr %23, align 4, !tbaa !14
  %388 = fpext float %387 to double
  %389 = load float, ptr %24, align 4, !tbaa !14
  %390 = fpext float %389 to double
  %391 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %386, double noundef %388, double noundef %390)
  br label %392

392:                                              ; preds = %377, %374
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %3) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr %25) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %25, ptr align 4 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.42, i64 36, i1 false)
  call void @llvm.lifetime.start.p0(i64 36, ptr %26) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %26, ptr align 4 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 36, i1 false)
  call void @llvm.lifetime.start.p0(i64 36, ptr %27) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %28, ptr align 4 %25, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL15HMM_TransposeM38HMM_Mat3(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %27, ptr noundef byval(%union.HMM_Mat3) align 8 %28)
  %393 = load ptr, ptr %2, align 8, !tbaa !5
  %394 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %393, i32 0, i32 0
  %395 = load i32, ptr %394, align 4, !tbaa !11
  %396 = add nsw i32 %395, 1
  store i32 %396, ptr %394, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #7
  %397 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 0
  %398 = getelementptr inbounds [3 x float], ptr %397, i64 0, i64 0
  %399 = load float, ptr %398, align 4, !tbaa !10
  store float %399, ptr %29, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #7
  %400 = load float, ptr %29, align 4, !tbaa !14
  %401 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %402 = getelementptr inbounds [3 x float], ptr %401, i64 0, i64 0
  %403 = load float, ptr %402, align 4, !tbaa !10
  %404 = fsub float %400, %403
  store float %404, ptr %30, align 4, !tbaa !14
  %405 = load float, ptr %30, align 4, !tbaa !14
  %406 = fcmp olt float %405, 0xBE80000000000000
  br i1 %406, label %410, label %407

407:                                              ; preds = %392
  %408 = load float, ptr %30, align 4, !tbaa !14
  %409 = fcmp olt float 0x3E80000000000000, %408
  br i1 %409, label %410, label %425

410:                                              ; preds = %407, %392
  %411 = load ptr, ptr %2, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %411, i32 0, i32 1
  %413 = load i32, ptr %412, align 4, !tbaa !16
  %414 = add nsw i32 %413, 1
  store i32 %414, ptr %412, align 4, !tbaa !16
  %415 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 47)
  %416 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %417 = getelementptr inbounds [3 x float], ptr %416, i64 0, i64 0
  %418 = load float, ptr %417, align 4, !tbaa !10
  %419 = fpext float %418 to double
  %420 = load float, ptr %29, align 4, !tbaa !14
  %421 = fpext float %420 to double
  %422 = load float, ptr %30, align 4, !tbaa !14
  %423 = fpext float %422 to double
  %424 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %419, double noundef %421, double noundef %423)
  br label %425

425:                                              ; preds = %410, %407
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #7
  %426 = load ptr, ptr %2, align 8, !tbaa !5
  %427 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %426, i32 0, i32 0
  %428 = load i32, ptr %427, align 4, !tbaa !11
  %429 = add nsw i32 %428, 1
  store i32 %429, ptr %427, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #7
  %430 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 0
  %431 = getelementptr inbounds [3 x float], ptr %430, i64 0, i64 1
  %432 = load float, ptr %431, align 4, !tbaa !10
  store float %432, ptr %31, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #7
  %433 = load float, ptr %31, align 4, !tbaa !14
  %434 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %435 = getelementptr inbounds [3 x float], ptr %434, i64 0, i64 1
  %436 = load float, ptr %435, align 4, !tbaa !10
  %437 = fsub float %433, %436
  store float %437, ptr %32, align 4, !tbaa !14
  %438 = load float, ptr %32, align 4, !tbaa !14
  %439 = fcmp olt float %438, 0xBE80000000000000
  br i1 %439, label %443, label %440

440:                                              ; preds = %425
  %441 = load float, ptr %32, align 4, !tbaa !14
  %442 = fcmp olt float 0x3E80000000000000, %441
  br i1 %442, label %443, label %458

443:                                              ; preds = %440, %425
  %444 = load ptr, ptr %2, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %444, i32 0, i32 1
  %446 = load i32, ptr %445, align 4, !tbaa !16
  %447 = add nsw i32 %446, 1
  store i32 %447, ptr %445, align 4, !tbaa !16
  %448 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 48)
  %449 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %450 = getelementptr inbounds [3 x float], ptr %449, i64 0, i64 1
  %451 = load float, ptr %450, align 4, !tbaa !10
  %452 = fpext float %451 to double
  %453 = load float, ptr %31, align 4, !tbaa !14
  %454 = fpext float %453 to double
  %455 = load float, ptr %32, align 4, !tbaa !14
  %456 = fpext float %455 to double
  %457 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %452, double noundef %454, double noundef %456)
  br label %458

458:                                              ; preds = %443, %440
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #7
  %459 = load ptr, ptr %2, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %459, i32 0, i32 0
  %461 = load i32, ptr %460, align 4, !tbaa !11
  %462 = add nsw i32 %461, 1
  store i32 %462, ptr %460, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  %463 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 0
  %464 = getelementptr inbounds [3 x float], ptr %463, i64 0, i64 2
  %465 = load float, ptr %464, align 4, !tbaa !10
  store float %465, ptr %33, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #7
  %466 = load float, ptr %33, align 4, !tbaa !14
  %467 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %468 = getelementptr inbounds [3 x float], ptr %467, i64 0, i64 2
  %469 = load float, ptr %468, align 4, !tbaa !10
  %470 = fsub float %466, %469
  store float %470, ptr %34, align 4, !tbaa !14
  %471 = load float, ptr %34, align 4, !tbaa !14
  %472 = fcmp olt float %471, 0xBE80000000000000
  br i1 %472, label %476, label %473

473:                                              ; preds = %458
  %474 = load float, ptr %34, align 4, !tbaa !14
  %475 = fcmp olt float 0x3E80000000000000, %474
  br i1 %475, label %476, label %491

476:                                              ; preds = %473, %458
  %477 = load ptr, ptr %2, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %477, i32 0, i32 1
  %479 = load i32, ptr %478, align 4, !tbaa !16
  %480 = add nsw i32 %479, 1
  store i32 %480, ptr %478, align 4, !tbaa !16
  %481 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 49)
  %482 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %483 = getelementptr inbounds [3 x float], ptr %482, i64 0, i64 2
  %484 = load float, ptr %483, align 4, !tbaa !10
  %485 = fpext float %484 to double
  %486 = load float, ptr %33, align 4, !tbaa !14
  %487 = fpext float %486 to double
  %488 = load float, ptr %34, align 4, !tbaa !14
  %489 = fpext float %488 to double
  %490 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %485, double noundef %487, double noundef %489)
  br label %491

491:                                              ; preds = %476, %473
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  %492 = load ptr, ptr %2, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %492, i32 0, i32 0
  %494 = load i32, ptr %493, align 4, !tbaa !11
  %495 = add nsw i32 %494, 1
  store i32 %495, ptr %493, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #7
  %496 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 1
  %497 = getelementptr inbounds [3 x float], ptr %496, i64 0, i64 0
  %498 = load float, ptr %497, align 4, !tbaa !10
  store float %498, ptr %35, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #7
  %499 = load float, ptr %35, align 4, !tbaa !14
  %500 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %501 = getelementptr inbounds [3 x float], ptr %500, i64 0, i64 0
  %502 = load float, ptr %501, align 4, !tbaa !10
  %503 = fsub float %499, %502
  store float %503, ptr %36, align 4, !tbaa !14
  %504 = load float, ptr %36, align 4, !tbaa !14
  %505 = fcmp olt float %504, 0xBE80000000000000
  br i1 %505, label %509, label %506

506:                                              ; preds = %491
  %507 = load float, ptr %36, align 4, !tbaa !14
  %508 = fcmp olt float 0x3E80000000000000, %507
  br i1 %508, label %509, label %524

509:                                              ; preds = %506, %491
  %510 = load ptr, ptr %2, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %510, i32 0, i32 1
  %512 = load i32, ptr %511, align 4, !tbaa !16
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %511, align 4, !tbaa !16
  %514 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 50)
  %515 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %516 = getelementptr inbounds [3 x float], ptr %515, i64 0, i64 0
  %517 = load float, ptr %516, align 4, !tbaa !10
  %518 = fpext float %517 to double
  %519 = load float, ptr %35, align 4, !tbaa !14
  %520 = fpext float %519 to double
  %521 = load float, ptr %36, align 4, !tbaa !14
  %522 = fpext float %521 to double
  %523 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %518, double noundef %520, double noundef %522)
  br label %524

524:                                              ; preds = %509, %506
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #7
  %525 = load ptr, ptr %2, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %525, i32 0, i32 0
  %527 = load i32, ptr %526, align 4, !tbaa !11
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %526, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #7
  %529 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 1
  %530 = getelementptr inbounds [3 x float], ptr %529, i64 0, i64 1
  %531 = load float, ptr %530, align 4, !tbaa !10
  store float %531, ptr %37, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #7
  %532 = load float, ptr %37, align 4, !tbaa !14
  %533 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %534 = getelementptr inbounds [3 x float], ptr %533, i64 0, i64 1
  %535 = load float, ptr %534, align 4, !tbaa !10
  %536 = fsub float %532, %535
  store float %536, ptr %38, align 4, !tbaa !14
  %537 = load float, ptr %38, align 4, !tbaa !14
  %538 = fcmp olt float %537, 0xBE80000000000000
  br i1 %538, label %542, label %539

539:                                              ; preds = %524
  %540 = load float, ptr %38, align 4, !tbaa !14
  %541 = fcmp olt float 0x3E80000000000000, %540
  br i1 %541, label %542, label %557

542:                                              ; preds = %539, %524
  %543 = load ptr, ptr %2, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %543, i32 0, i32 1
  %545 = load i32, ptr %544, align 4, !tbaa !16
  %546 = add nsw i32 %545, 1
  store i32 %546, ptr %544, align 4, !tbaa !16
  %547 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 51)
  %548 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %549 = getelementptr inbounds [3 x float], ptr %548, i64 0, i64 1
  %550 = load float, ptr %549, align 4, !tbaa !10
  %551 = fpext float %550 to double
  %552 = load float, ptr %37, align 4, !tbaa !14
  %553 = fpext float %552 to double
  %554 = load float, ptr %38, align 4, !tbaa !14
  %555 = fpext float %554 to double
  %556 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %551, double noundef %553, double noundef %555)
  br label %557

557:                                              ; preds = %542, %539
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #7
  %558 = load ptr, ptr %2, align 8, !tbaa !5
  %559 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %558, i32 0, i32 0
  %560 = load i32, ptr %559, align 4, !tbaa !11
  %561 = add nsw i32 %560, 1
  store i32 %561, ptr %559, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #7
  %562 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 1
  %563 = getelementptr inbounds [3 x float], ptr %562, i64 0, i64 2
  %564 = load float, ptr %563, align 4, !tbaa !10
  store float %564, ptr %39, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #7
  %565 = load float, ptr %39, align 4, !tbaa !14
  %566 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %567 = getelementptr inbounds [3 x float], ptr %566, i64 0, i64 2
  %568 = load float, ptr %567, align 4, !tbaa !10
  %569 = fsub float %565, %568
  store float %569, ptr %40, align 4, !tbaa !14
  %570 = load float, ptr %40, align 4, !tbaa !14
  %571 = fcmp olt float %570, 0xBE80000000000000
  br i1 %571, label %575, label %572

572:                                              ; preds = %557
  %573 = load float, ptr %40, align 4, !tbaa !14
  %574 = fcmp olt float 0x3E80000000000000, %573
  br i1 %574, label %575, label %590

575:                                              ; preds = %572, %557
  %576 = load ptr, ptr %2, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %576, i32 0, i32 1
  %578 = load i32, ptr %577, align 4, !tbaa !16
  %579 = add nsw i32 %578, 1
  store i32 %579, ptr %577, align 4, !tbaa !16
  %580 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 52)
  %581 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %582 = getelementptr inbounds [3 x float], ptr %581, i64 0, i64 2
  %583 = load float, ptr %582, align 4, !tbaa !10
  %584 = fpext float %583 to double
  %585 = load float, ptr %39, align 4, !tbaa !14
  %586 = fpext float %585 to double
  %587 = load float, ptr %40, align 4, !tbaa !14
  %588 = fpext float %587 to double
  %589 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %584, double noundef %586, double noundef %588)
  br label %590

590:                                              ; preds = %575, %572
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #7
  %591 = load ptr, ptr %2, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %591, i32 0, i32 0
  %593 = load i32, ptr %592, align 4, !tbaa !11
  %594 = add nsw i32 %593, 1
  store i32 %594, ptr %592, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #7
  %595 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 2
  %596 = getelementptr inbounds [3 x float], ptr %595, i64 0, i64 0
  %597 = load float, ptr %596, align 4, !tbaa !10
  store float %597, ptr %41, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #7
  %598 = load float, ptr %41, align 4, !tbaa !14
  %599 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %600 = getelementptr inbounds [3 x float], ptr %599, i64 0, i64 0
  %601 = load float, ptr %600, align 4, !tbaa !10
  %602 = fsub float %598, %601
  store float %602, ptr %42, align 4, !tbaa !14
  %603 = load float, ptr %42, align 4, !tbaa !14
  %604 = fcmp olt float %603, 0xBE80000000000000
  br i1 %604, label %608, label %605

605:                                              ; preds = %590
  %606 = load float, ptr %42, align 4, !tbaa !14
  %607 = fcmp olt float 0x3E80000000000000, %606
  br i1 %607, label %608, label %623

608:                                              ; preds = %605, %590
  %609 = load ptr, ptr %2, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %609, i32 0, i32 1
  %611 = load i32, ptr %610, align 4, !tbaa !16
  %612 = add nsw i32 %611, 1
  store i32 %612, ptr %610, align 4, !tbaa !16
  %613 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 53)
  %614 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %615 = getelementptr inbounds [3 x float], ptr %614, i64 0, i64 0
  %616 = load float, ptr %615, align 4, !tbaa !10
  %617 = fpext float %616 to double
  %618 = load float, ptr %41, align 4, !tbaa !14
  %619 = fpext float %618 to double
  %620 = load float, ptr %42, align 4, !tbaa !14
  %621 = fpext float %620 to double
  %622 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %617, double noundef %619, double noundef %621)
  br label %623

623:                                              ; preds = %608, %605
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #7
  %624 = load ptr, ptr %2, align 8, !tbaa !5
  %625 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %624, i32 0, i32 0
  %626 = load i32, ptr %625, align 4, !tbaa !11
  %627 = add nsw i32 %626, 1
  store i32 %627, ptr %625, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #7
  %628 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 2
  %629 = getelementptr inbounds [3 x float], ptr %628, i64 0, i64 1
  %630 = load float, ptr %629, align 4, !tbaa !10
  store float %630, ptr %43, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #7
  %631 = load float, ptr %43, align 4, !tbaa !14
  %632 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %633 = getelementptr inbounds [3 x float], ptr %632, i64 0, i64 1
  %634 = load float, ptr %633, align 4, !tbaa !10
  %635 = fsub float %631, %634
  store float %635, ptr %44, align 4, !tbaa !14
  %636 = load float, ptr %44, align 4, !tbaa !14
  %637 = fcmp olt float %636, 0xBE80000000000000
  br i1 %637, label %641, label %638

638:                                              ; preds = %623
  %639 = load float, ptr %44, align 4, !tbaa !14
  %640 = fcmp olt float 0x3E80000000000000, %639
  br i1 %640, label %641, label %656

641:                                              ; preds = %638, %623
  %642 = load ptr, ptr %2, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %642, i32 0, i32 1
  %644 = load i32, ptr %643, align 4, !tbaa !16
  %645 = add nsw i32 %644, 1
  store i32 %645, ptr %643, align 4, !tbaa !16
  %646 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 54)
  %647 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %648 = getelementptr inbounds [3 x float], ptr %647, i64 0, i64 1
  %649 = load float, ptr %648, align 4, !tbaa !10
  %650 = fpext float %649 to double
  %651 = load float, ptr %43, align 4, !tbaa !14
  %652 = fpext float %651 to double
  %653 = load float, ptr %44, align 4, !tbaa !14
  %654 = fpext float %653 to double
  %655 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %650, double noundef %652, double noundef %654)
  br label %656

656:                                              ; preds = %641, %638
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #7
  %657 = load ptr, ptr %2, align 8, !tbaa !5
  %658 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %657, i32 0, i32 0
  %659 = load i32, ptr %658, align 4, !tbaa !11
  %660 = add nsw i32 %659, 1
  store i32 %660, ptr %658, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #7
  %661 = getelementptr inbounds [3 x [3 x float]], ptr %27, i64 0, i64 2
  %662 = getelementptr inbounds [3 x float], ptr %661, i64 0, i64 2
  %663 = load float, ptr %662, align 4, !tbaa !10
  store float %663, ptr %45, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #7
  %664 = load float, ptr %45, align 4, !tbaa !14
  %665 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %666 = getelementptr inbounds [3 x float], ptr %665, i64 0, i64 2
  %667 = load float, ptr %666, align 4, !tbaa !10
  %668 = fsub float %664, %667
  store float %668, ptr %46, align 4, !tbaa !14
  %669 = load float, ptr %46, align 4, !tbaa !14
  %670 = fcmp olt float %669, 0xBE80000000000000
  br i1 %670, label %674, label %671

671:                                              ; preds = %656
  %672 = load float, ptr %46, align 4, !tbaa !14
  %673 = fcmp olt float 0x3E80000000000000, %672
  br i1 %673, label %674, label %689

674:                                              ; preds = %671, %656
  %675 = load ptr, ptr %2, align 8, !tbaa !5
  %676 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %675, i32 0, i32 1
  %677 = load i32, ptr %676, align 4, !tbaa !16
  %678 = add nsw i32 %677, 1
  store i32 %678, ptr %676, align 4, !tbaa !16
  %679 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 55)
  %680 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %681 = getelementptr inbounds [3 x float], ptr %680, i64 0, i64 2
  %682 = load float, ptr %681, align 4, !tbaa !10
  %683 = fpext float %682 to double
  %684 = load float, ptr %45, align 4, !tbaa !14
  %685 = fpext float %684 to double
  %686 = load float, ptr %46, align 4, !tbaa !14
  %687 = fpext float %686 to double
  %688 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %683, double noundef %685, double noundef %687)
  br label %689

689:                                              ; preds = %674, %671
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %27) #7
  call void @llvm.lifetime.start.p0(i64 36, ptr %47) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 4 %25, i64 36, i1 false), !tbaa.struct !17
  call void @_ZL13HMM_Transpose8HMM_Mat3(ptr dead_on_unwind writable sret(%union.HMM_Mat3) align 4 %47, ptr noundef byval(%union.HMM_Mat3) align 8 %48)
  %690 = load ptr, ptr %2, align 8, !tbaa !5
  %691 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %690, i32 0, i32 0
  %692 = load i32, ptr %691, align 4, !tbaa !11
  %693 = add nsw i32 %692, 1
  store i32 %693, ptr %691, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #7
  %694 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 0
  %695 = getelementptr inbounds [3 x float], ptr %694, i64 0, i64 0
  %696 = load float, ptr %695, align 4, !tbaa !10
  store float %696, ptr %49, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #7
  %697 = load float, ptr %49, align 4, !tbaa !14
  %698 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %699 = getelementptr inbounds [3 x float], ptr %698, i64 0, i64 0
  %700 = load float, ptr %699, align 4, !tbaa !10
  %701 = fsub float %697, %700
  store float %701, ptr %50, align 4, !tbaa !14
  %702 = load float, ptr %50, align 4, !tbaa !14
  %703 = fcmp olt float %702, 0xBE80000000000000
  br i1 %703, label %707, label %704

704:                                              ; preds = %689
  %705 = load float, ptr %50, align 4, !tbaa !14
  %706 = fcmp olt float 0x3E80000000000000, %705
  br i1 %706, label %707, label %722

707:                                              ; preds = %704, %689
  %708 = load ptr, ptr %2, align 8, !tbaa !5
  %709 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %708, i32 0, i32 1
  %710 = load i32, ptr %709, align 4, !tbaa !16
  %711 = add nsw i32 %710, 1
  store i32 %711, ptr %709, align 4, !tbaa !16
  %712 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 60)
  %713 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %714 = getelementptr inbounds [3 x float], ptr %713, i64 0, i64 0
  %715 = load float, ptr %714, align 4, !tbaa !10
  %716 = fpext float %715 to double
  %717 = load float, ptr %49, align 4, !tbaa !14
  %718 = fpext float %717 to double
  %719 = load float, ptr %50, align 4, !tbaa !14
  %720 = fpext float %719 to double
  %721 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %716, double noundef %718, double noundef %720)
  br label %722

722:                                              ; preds = %707, %704
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #7
  %723 = load ptr, ptr %2, align 8, !tbaa !5
  %724 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %723, i32 0, i32 0
  %725 = load i32, ptr %724, align 4, !tbaa !11
  %726 = add nsw i32 %725, 1
  store i32 %726, ptr %724, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #7
  %727 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 0
  %728 = getelementptr inbounds [3 x float], ptr %727, i64 0, i64 1
  %729 = load float, ptr %728, align 4, !tbaa !10
  store float %729, ptr %51, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #7
  %730 = load float, ptr %51, align 4, !tbaa !14
  %731 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %732 = getelementptr inbounds [3 x float], ptr %731, i64 0, i64 1
  %733 = load float, ptr %732, align 4, !tbaa !10
  %734 = fsub float %730, %733
  store float %734, ptr %52, align 4, !tbaa !14
  %735 = load float, ptr %52, align 4, !tbaa !14
  %736 = fcmp olt float %735, 0xBE80000000000000
  br i1 %736, label %740, label %737

737:                                              ; preds = %722
  %738 = load float, ptr %52, align 4, !tbaa !14
  %739 = fcmp olt float 0x3E80000000000000, %738
  br i1 %739, label %740, label %755

740:                                              ; preds = %737, %722
  %741 = load ptr, ptr %2, align 8, !tbaa !5
  %742 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %741, i32 0, i32 1
  %743 = load i32, ptr %742, align 4, !tbaa !16
  %744 = add nsw i32 %743, 1
  store i32 %744, ptr %742, align 4, !tbaa !16
  %745 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 61)
  %746 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %747 = getelementptr inbounds [3 x float], ptr %746, i64 0, i64 1
  %748 = load float, ptr %747, align 4, !tbaa !10
  %749 = fpext float %748 to double
  %750 = load float, ptr %51, align 4, !tbaa !14
  %751 = fpext float %750 to double
  %752 = load float, ptr %52, align 4, !tbaa !14
  %753 = fpext float %752 to double
  %754 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %749, double noundef %751, double noundef %753)
  br label %755

755:                                              ; preds = %740, %737
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #7
  %756 = load ptr, ptr %2, align 8, !tbaa !5
  %757 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %756, i32 0, i32 0
  %758 = load i32, ptr %757, align 4, !tbaa !11
  %759 = add nsw i32 %758, 1
  store i32 %759, ptr %757, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #7
  %760 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 0
  %761 = getelementptr inbounds [3 x float], ptr %760, i64 0, i64 2
  %762 = load float, ptr %761, align 4, !tbaa !10
  store float %762, ptr %53, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #7
  %763 = load float, ptr %53, align 4, !tbaa !14
  %764 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %765 = getelementptr inbounds [3 x float], ptr %764, i64 0, i64 2
  %766 = load float, ptr %765, align 4, !tbaa !10
  %767 = fsub float %763, %766
  store float %767, ptr %54, align 4, !tbaa !14
  %768 = load float, ptr %54, align 4, !tbaa !14
  %769 = fcmp olt float %768, 0xBE80000000000000
  br i1 %769, label %773, label %770

770:                                              ; preds = %755
  %771 = load float, ptr %54, align 4, !tbaa !14
  %772 = fcmp olt float 0x3E80000000000000, %771
  br i1 %772, label %773, label %788

773:                                              ; preds = %770, %755
  %774 = load ptr, ptr %2, align 8, !tbaa !5
  %775 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %774, i32 0, i32 1
  %776 = load i32, ptr %775, align 4, !tbaa !16
  %777 = add nsw i32 %776, 1
  store i32 %777, ptr %775, align 4, !tbaa !16
  %778 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 62)
  %779 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 0
  %780 = getelementptr inbounds [3 x float], ptr %779, i64 0, i64 2
  %781 = load float, ptr %780, align 4, !tbaa !10
  %782 = fpext float %781 to double
  %783 = load float, ptr %53, align 4, !tbaa !14
  %784 = fpext float %783 to double
  %785 = load float, ptr %54, align 4, !tbaa !14
  %786 = fpext float %785 to double
  %787 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %782, double noundef %784, double noundef %786)
  br label %788

788:                                              ; preds = %773, %770
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #7
  %789 = load ptr, ptr %2, align 8, !tbaa !5
  %790 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %789, i32 0, i32 0
  %791 = load i32, ptr %790, align 4, !tbaa !11
  %792 = add nsw i32 %791, 1
  store i32 %792, ptr %790, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #7
  %793 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 1
  %794 = getelementptr inbounds [3 x float], ptr %793, i64 0, i64 0
  %795 = load float, ptr %794, align 4, !tbaa !10
  store float %795, ptr %55, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #7
  %796 = load float, ptr %55, align 4, !tbaa !14
  %797 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %798 = getelementptr inbounds [3 x float], ptr %797, i64 0, i64 0
  %799 = load float, ptr %798, align 4, !tbaa !10
  %800 = fsub float %796, %799
  store float %800, ptr %56, align 4, !tbaa !14
  %801 = load float, ptr %56, align 4, !tbaa !14
  %802 = fcmp olt float %801, 0xBE80000000000000
  br i1 %802, label %806, label %803

803:                                              ; preds = %788
  %804 = load float, ptr %56, align 4, !tbaa !14
  %805 = fcmp olt float 0x3E80000000000000, %804
  br i1 %805, label %806, label %821

806:                                              ; preds = %803, %788
  %807 = load ptr, ptr %2, align 8, !tbaa !5
  %808 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %807, i32 0, i32 1
  %809 = load i32, ptr %808, align 4, !tbaa !16
  %810 = add nsw i32 %809, 1
  store i32 %810, ptr %808, align 4, !tbaa !16
  %811 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 63)
  %812 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %813 = getelementptr inbounds [3 x float], ptr %812, i64 0, i64 0
  %814 = load float, ptr %813, align 4, !tbaa !10
  %815 = fpext float %814 to double
  %816 = load float, ptr %55, align 4, !tbaa !14
  %817 = fpext float %816 to double
  %818 = load float, ptr %56, align 4, !tbaa !14
  %819 = fpext float %818 to double
  %820 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %815, double noundef %817, double noundef %819)
  br label %821

821:                                              ; preds = %806, %803
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #7
  %822 = load ptr, ptr %2, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %822, i32 0, i32 0
  %824 = load i32, ptr %823, align 4, !tbaa !11
  %825 = add nsw i32 %824, 1
  store i32 %825, ptr %823, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #7
  %826 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 1
  %827 = getelementptr inbounds [3 x float], ptr %826, i64 0, i64 1
  %828 = load float, ptr %827, align 4, !tbaa !10
  store float %828, ptr %57, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #7
  %829 = load float, ptr %57, align 4, !tbaa !14
  %830 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %831 = getelementptr inbounds [3 x float], ptr %830, i64 0, i64 1
  %832 = load float, ptr %831, align 4, !tbaa !10
  %833 = fsub float %829, %832
  store float %833, ptr %58, align 4, !tbaa !14
  %834 = load float, ptr %58, align 4, !tbaa !14
  %835 = fcmp olt float %834, 0xBE80000000000000
  br i1 %835, label %839, label %836

836:                                              ; preds = %821
  %837 = load float, ptr %58, align 4, !tbaa !14
  %838 = fcmp olt float 0x3E80000000000000, %837
  br i1 %838, label %839, label %854

839:                                              ; preds = %836, %821
  %840 = load ptr, ptr %2, align 8, !tbaa !5
  %841 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %840, i32 0, i32 1
  %842 = load i32, ptr %841, align 4, !tbaa !16
  %843 = add nsw i32 %842, 1
  store i32 %843, ptr %841, align 4, !tbaa !16
  %844 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 64)
  %845 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %846 = getelementptr inbounds [3 x float], ptr %845, i64 0, i64 1
  %847 = load float, ptr %846, align 4, !tbaa !10
  %848 = fpext float %847 to double
  %849 = load float, ptr %57, align 4, !tbaa !14
  %850 = fpext float %849 to double
  %851 = load float, ptr %58, align 4, !tbaa !14
  %852 = fpext float %851 to double
  %853 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %848, double noundef %850, double noundef %852)
  br label %854

854:                                              ; preds = %839, %836
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #7
  %855 = load ptr, ptr %2, align 8, !tbaa !5
  %856 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %855, i32 0, i32 0
  %857 = load i32, ptr %856, align 4, !tbaa !11
  %858 = add nsw i32 %857, 1
  store i32 %858, ptr %856, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #7
  %859 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 1
  %860 = getelementptr inbounds [3 x float], ptr %859, i64 0, i64 2
  %861 = load float, ptr %860, align 4, !tbaa !10
  store float %861, ptr %59, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #7
  %862 = load float, ptr %59, align 4, !tbaa !14
  %863 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %864 = getelementptr inbounds [3 x float], ptr %863, i64 0, i64 2
  %865 = load float, ptr %864, align 4, !tbaa !10
  %866 = fsub float %862, %865
  store float %866, ptr %60, align 4, !tbaa !14
  %867 = load float, ptr %60, align 4, !tbaa !14
  %868 = fcmp olt float %867, 0xBE80000000000000
  br i1 %868, label %872, label %869

869:                                              ; preds = %854
  %870 = load float, ptr %60, align 4, !tbaa !14
  %871 = fcmp olt float 0x3E80000000000000, %870
  br i1 %871, label %872, label %887

872:                                              ; preds = %869, %854
  %873 = load ptr, ptr %2, align 8, !tbaa !5
  %874 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %873, i32 0, i32 1
  %875 = load i32, ptr %874, align 4, !tbaa !16
  %876 = add nsw i32 %875, 1
  store i32 %876, ptr %874, align 4, !tbaa !16
  %877 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 65)
  %878 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 1
  %879 = getelementptr inbounds [3 x float], ptr %878, i64 0, i64 2
  %880 = load float, ptr %879, align 4, !tbaa !10
  %881 = fpext float %880 to double
  %882 = load float, ptr %59, align 4, !tbaa !14
  %883 = fpext float %882 to double
  %884 = load float, ptr %60, align 4, !tbaa !14
  %885 = fpext float %884 to double
  %886 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %881, double noundef %883, double noundef %885)
  br label %887

887:                                              ; preds = %872, %869
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #7
  %888 = load ptr, ptr %2, align 8, !tbaa !5
  %889 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %888, i32 0, i32 0
  %890 = load i32, ptr %889, align 4, !tbaa !11
  %891 = add nsw i32 %890, 1
  store i32 %891, ptr %889, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #7
  %892 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 2
  %893 = getelementptr inbounds [3 x float], ptr %892, i64 0, i64 0
  %894 = load float, ptr %893, align 4, !tbaa !10
  store float %894, ptr %61, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #7
  %895 = load float, ptr %61, align 4, !tbaa !14
  %896 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %897 = getelementptr inbounds [3 x float], ptr %896, i64 0, i64 0
  %898 = load float, ptr %897, align 4, !tbaa !10
  %899 = fsub float %895, %898
  store float %899, ptr %62, align 4, !tbaa !14
  %900 = load float, ptr %62, align 4, !tbaa !14
  %901 = fcmp olt float %900, 0xBE80000000000000
  br i1 %901, label %905, label %902

902:                                              ; preds = %887
  %903 = load float, ptr %62, align 4, !tbaa !14
  %904 = fcmp olt float 0x3E80000000000000, %903
  br i1 %904, label %905, label %920

905:                                              ; preds = %902, %887
  %906 = load ptr, ptr %2, align 8, !tbaa !5
  %907 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %906, i32 0, i32 1
  %908 = load i32, ptr %907, align 4, !tbaa !16
  %909 = add nsw i32 %908, 1
  store i32 %909, ptr %907, align 4, !tbaa !16
  %910 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 66)
  %911 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %912 = getelementptr inbounds [3 x float], ptr %911, i64 0, i64 0
  %913 = load float, ptr %912, align 4, !tbaa !10
  %914 = fpext float %913 to double
  %915 = load float, ptr %61, align 4, !tbaa !14
  %916 = fpext float %915 to double
  %917 = load float, ptr %62, align 4, !tbaa !14
  %918 = fpext float %917 to double
  %919 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %914, double noundef %916, double noundef %918)
  br label %920

920:                                              ; preds = %905, %902
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #7
  %921 = load ptr, ptr %2, align 8, !tbaa !5
  %922 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %921, i32 0, i32 0
  %923 = load i32, ptr %922, align 4, !tbaa !11
  %924 = add nsw i32 %923, 1
  store i32 %924, ptr %922, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #7
  %925 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 2
  %926 = getelementptr inbounds [3 x float], ptr %925, i64 0, i64 1
  %927 = load float, ptr %926, align 4, !tbaa !10
  store float %927, ptr %63, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #7
  %928 = load float, ptr %63, align 4, !tbaa !14
  %929 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %930 = getelementptr inbounds [3 x float], ptr %929, i64 0, i64 1
  %931 = load float, ptr %930, align 4, !tbaa !10
  %932 = fsub float %928, %931
  store float %932, ptr %64, align 4, !tbaa !14
  %933 = load float, ptr %64, align 4, !tbaa !14
  %934 = fcmp olt float %933, 0xBE80000000000000
  br i1 %934, label %938, label %935

935:                                              ; preds = %920
  %936 = load float, ptr %64, align 4, !tbaa !14
  %937 = fcmp olt float 0x3E80000000000000, %936
  br i1 %937, label %938, label %953

938:                                              ; preds = %935, %920
  %939 = load ptr, ptr %2, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %939, i32 0, i32 1
  %941 = load i32, ptr %940, align 4, !tbaa !16
  %942 = add nsw i32 %941, 1
  store i32 %942, ptr %940, align 4, !tbaa !16
  %943 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 67)
  %944 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %945 = getelementptr inbounds [3 x float], ptr %944, i64 0, i64 1
  %946 = load float, ptr %945, align 4, !tbaa !10
  %947 = fpext float %946 to double
  %948 = load float, ptr %63, align 4, !tbaa !14
  %949 = fpext float %948 to double
  %950 = load float, ptr %64, align 4, !tbaa !14
  %951 = fpext float %950 to double
  %952 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %947, double noundef %949, double noundef %951)
  br label %953

953:                                              ; preds = %938, %935
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #7
  %954 = load ptr, ptr %2, align 8, !tbaa !5
  %955 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %954, i32 0, i32 0
  %956 = load i32, ptr %955, align 4, !tbaa !11
  %957 = add nsw i32 %956, 1
  store i32 %957, ptr %955, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #7
  %958 = getelementptr inbounds [3 x [3 x float]], ptr %47, i64 0, i64 2
  %959 = getelementptr inbounds [3 x float], ptr %958, i64 0, i64 2
  %960 = load float, ptr %959, align 4, !tbaa !10
  store float %960, ptr %65, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #7
  %961 = load float, ptr %65, align 4, !tbaa !14
  %962 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %963 = getelementptr inbounds [3 x float], ptr %962, i64 0, i64 2
  %964 = load float, ptr %963, align 4, !tbaa !10
  %965 = fsub float %961, %964
  store float %965, ptr %66, align 4, !tbaa !14
  %966 = load float, ptr %66, align 4, !tbaa !14
  %967 = fcmp olt float %966, 0xBE80000000000000
  br i1 %967, label %971, label %968

968:                                              ; preds = %953
  %969 = load float, ptr %66, align 4, !tbaa !14
  %970 = fcmp olt float 0x3E80000000000000, %969
  br i1 %970, label %971, label %986

971:                                              ; preds = %968, %953
  %972 = load ptr, ptr %2, align 8, !tbaa !5
  %973 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %972, i32 0, i32 1
  %974 = load i32, ptr %973, align 4, !tbaa !16
  %975 = add nsw i32 %974, 1
  store i32 %975, ptr %973, align 4, !tbaa !16
  %976 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 68)
  %977 = getelementptr inbounds [3 x [3 x float]], ptr %26, i64 0, i64 2
  %978 = getelementptr inbounds [3 x float], ptr %977, i64 0, i64 2
  %979 = load float, ptr %978, align 4, !tbaa !10
  %980 = fpext float %979 to double
  %981 = load float, ptr %65, align 4, !tbaa !14
  %982 = fpext float %981 to double
  %983 = load float, ptr %66, align 4, !tbaa !14
  %984 = fpext float %983 to double
  %985 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %980, double noundef %982, double noundef %984)
  br label %986

986:                                              ; preds = %971, %968
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %47) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %26) #7
  call void @llvm.lifetime.end.p0(i64 36, ptr %25) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr %67) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %67, ptr align 16 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.44, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %68) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %68, ptr align 16 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %69) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %70, ptr align 16 %67, i64 64, i1 false), !tbaa.struct !18
  call void @_ZL15HMM_TransposeM48HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %69, ptr noundef byval(%union.HMM_Mat4) align 16 %70)
  %987 = load ptr, ptr %2, align 8, !tbaa !5
  %988 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %987, i32 0, i32 0
  %989 = load i32, ptr %988, align 4, !tbaa !11
  %990 = add nsw i32 %989, 1
  store i32 %990, ptr %988, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #7
  %991 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 0
  %992 = getelementptr inbounds [4 x float], ptr %991, i64 0, i64 0
  %993 = load float, ptr %992, align 16, !tbaa !10
  store float %993, ptr %71, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #7
  %994 = load float, ptr %71, align 4, !tbaa !14
  %995 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %996 = getelementptr inbounds [4 x float], ptr %995, i64 0, i64 0
  %997 = load float, ptr %996, align 16, !tbaa !10
  %998 = fsub float %994, %997
  store float %998, ptr %72, align 4, !tbaa !14
  %999 = load float, ptr %72, align 4, !tbaa !14
  %1000 = fcmp olt float %999, 0xBE80000000000000
  br i1 %1000, label %1004, label %1001

1001:                                             ; preds = %986
  %1002 = load float, ptr %72, align 4, !tbaa !14
  %1003 = fcmp olt float 0x3E80000000000000, %1002
  br i1 %1003, label %1004, label %1019

1004:                                             ; preds = %1001, %986
  %1005 = load ptr, ptr %2, align 8, !tbaa !5
  %1006 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1005, i32 0, i32 1
  %1007 = load i32, ptr %1006, align 4, !tbaa !16
  %1008 = add nsw i32 %1007, 1
  store i32 %1008, ptr %1006, align 4, !tbaa !16
  %1009 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 87)
  %1010 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1011 = getelementptr inbounds [4 x float], ptr %1010, i64 0, i64 0
  %1012 = load float, ptr %1011, align 16, !tbaa !10
  %1013 = fpext float %1012 to double
  %1014 = load float, ptr %71, align 4, !tbaa !14
  %1015 = fpext float %1014 to double
  %1016 = load float, ptr %72, align 4, !tbaa !14
  %1017 = fpext float %1016 to double
  %1018 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1013, double noundef %1015, double noundef %1017)
  br label %1019

1019:                                             ; preds = %1004, %1001
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #7
  %1020 = load ptr, ptr %2, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1020, i32 0, i32 0
  %1022 = load i32, ptr %1021, align 4, !tbaa !11
  %1023 = add nsw i32 %1022, 1
  store i32 %1023, ptr %1021, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #7
  %1024 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 0
  %1025 = getelementptr inbounds [4 x float], ptr %1024, i64 0, i64 1
  %1026 = load float, ptr %1025, align 4, !tbaa !10
  store float %1026, ptr %73, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #7
  %1027 = load float, ptr %73, align 4, !tbaa !14
  %1028 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1029 = getelementptr inbounds [4 x float], ptr %1028, i64 0, i64 1
  %1030 = load float, ptr %1029, align 4, !tbaa !10
  %1031 = fsub float %1027, %1030
  store float %1031, ptr %74, align 4, !tbaa !14
  %1032 = load float, ptr %74, align 4, !tbaa !14
  %1033 = fcmp olt float %1032, 0xBE80000000000000
  br i1 %1033, label %1037, label %1034

1034:                                             ; preds = %1019
  %1035 = load float, ptr %74, align 4, !tbaa !14
  %1036 = fcmp olt float 0x3E80000000000000, %1035
  br i1 %1036, label %1037, label %1052

1037:                                             ; preds = %1034, %1019
  %1038 = load ptr, ptr %2, align 8, !tbaa !5
  %1039 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1038, i32 0, i32 1
  %1040 = load i32, ptr %1039, align 4, !tbaa !16
  %1041 = add nsw i32 %1040, 1
  store i32 %1041, ptr %1039, align 4, !tbaa !16
  %1042 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 88)
  %1043 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1044 = getelementptr inbounds [4 x float], ptr %1043, i64 0, i64 1
  %1045 = load float, ptr %1044, align 4, !tbaa !10
  %1046 = fpext float %1045 to double
  %1047 = load float, ptr %73, align 4, !tbaa !14
  %1048 = fpext float %1047 to double
  %1049 = load float, ptr %74, align 4, !tbaa !14
  %1050 = fpext float %1049 to double
  %1051 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1046, double noundef %1048, double noundef %1050)
  br label %1052

1052:                                             ; preds = %1037, %1034
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #7
  %1053 = load ptr, ptr %2, align 8, !tbaa !5
  %1054 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1053, i32 0, i32 0
  %1055 = load i32, ptr %1054, align 4, !tbaa !11
  %1056 = add nsw i32 %1055, 1
  store i32 %1056, ptr %1054, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #7
  %1057 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 0
  %1058 = getelementptr inbounds [4 x float], ptr %1057, i64 0, i64 2
  %1059 = load float, ptr %1058, align 8, !tbaa !10
  store float %1059, ptr %75, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #7
  %1060 = load float, ptr %75, align 4, !tbaa !14
  %1061 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1062 = getelementptr inbounds [4 x float], ptr %1061, i64 0, i64 2
  %1063 = load float, ptr %1062, align 8, !tbaa !10
  %1064 = fsub float %1060, %1063
  store float %1064, ptr %76, align 4, !tbaa !14
  %1065 = load float, ptr %76, align 4, !tbaa !14
  %1066 = fcmp olt float %1065, 0xBE80000000000000
  br i1 %1066, label %1070, label %1067

1067:                                             ; preds = %1052
  %1068 = load float, ptr %76, align 4, !tbaa !14
  %1069 = fcmp olt float 0x3E80000000000000, %1068
  br i1 %1069, label %1070, label %1085

1070:                                             ; preds = %1067, %1052
  %1071 = load ptr, ptr %2, align 8, !tbaa !5
  %1072 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1071, i32 0, i32 1
  %1073 = load i32, ptr %1072, align 4, !tbaa !16
  %1074 = add nsw i32 %1073, 1
  store i32 %1074, ptr %1072, align 4, !tbaa !16
  %1075 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 89)
  %1076 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1077 = getelementptr inbounds [4 x float], ptr %1076, i64 0, i64 2
  %1078 = load float, ptr %1077, align 8, !tbaa !10
  %1079 = fpext float %1078 to double
  %1080 = load float, ptr %75, align 4, !tbaa !14
  %1081 = fpext float %1080 to double
  %1082 = load float, ptr %76, align 4, !tbaa !14
  %1083 = fpext float %1082 to double
  %1084 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1079, double noundef %1081, double noundef %1083)
  br label %1085

1085:                                             ; preds = %1070, %1067
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #7
  %1086 = load ptr, ptr %2, align 8, !tbaa !5
  %1087 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1086, i32 0, i32 0
  %1088 = load i32, ptr %1087, align 4, !tbaa !11
  %1089 = add nsw i32 %1088, 1
  store i32 %1089, ptr %1087, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #7
  %1090 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 1
  %1091 = getelementptr inbounds [4 x float], ptr %1090, i64 0, i64 0
  %1092 = load float, ptr %1091, align 16, !tbaa !10
  store float %1092, ptr %77, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #7
  %1093 = load float, ptr %77, align 4, !tbaa !14
  %1094 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1095 = getelementptr inbounds [4 x float], ptr %1094, i64 0, i64 0
  %1096 = load float, ptr %1095, align 16, !tbaa !10
  %1097 = fsub float %1093, %1096
  store float %1097, ptr %78, align 4, !tbaa !14
  %1098 = load float, ptr %78, align 4, !tbaa !14
  %1099 = fcmp olt float %1098, 0xBE80000000000000
  br i1 %1099, label %1103, label %1100

1100:                                             ; preds = %1085
  %1101 = load float, ptr %78, align 4, !tbaa !14
  %1102 = fcmp olt float 0x3E80000000000000, %1101
  br i1 %1102, label %1103, label %1118

1103:                                             ; preds = %1100, %1085
  %1104 = load ptr, ptr %2, align 8, !tbaa !5
  %1105 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1104, i32 0, i32 1
  %1106 = load i32, ptr %1105, align 4, !tbaa !16
  %1107 = add nsw i32 %1106, 1
  store i32 %1107, ptr %1105, align 4, !tbaa !16
  %1108 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 90)
  %1109 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1110 = getelementptr inbounds [4 x float], ptr %1109, i64 0, i64 0
  %1111 = load float, ptr %1110, align 16, !tbaa !10
  %1112 = fpext float %1111 to double
  %1113 = load float, ptr %77, align 4, !tbaa !14
  %1114 = fpext float %1113 to double
  %1115 = load float, ptr %78, align 4, !tbaa !14
  %1116 = fpext float %1115 to double
  %1117 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1112, double noundef %1114, double noundef %1116)
  br label %1118

1118:                                             ; preds = %1103, %1100
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #7
  %1119 = load ptr, ptr %2, align 8, !tbaa !5
  %1120 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1119, i32 0, i32 0
  %1121 = load i32, ptr %1120, align 4, !tbaa !11
  %1122 = add nsw i32 %1121, 1
  store i32 %1122, ptr %1120, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #7
  %1123 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 1
  %1124 = getelementptr inbounds [4 x float], ptr %1123, i64 0, i64 1
  %1125 = load float, ptr %1124, align 4, !tbaa !10
  store float %1125, ptr %79, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #7
  %1126 = load float, ptr %79, align 4, !tbaa !14
  %1127 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1128 = getelementptr inbounds [4 x float], ptr %1127, i64 0, i64 1
  %1129 = load float, ptr %1128, align 4, !tbaa !10
  %1130 = fsub float %1126, %1129
  store float %1130, ptr %80, align 4, !tbaa !14
  %1131 = load float, ptr %80, align 4, !tbaa !14
  %1132 = fcmp olt float %1131, 0xBE80000000000000
  br i1 %1132, label %1136, label %1133

1133:                                             ; preds = %1118
  %1134 = load float, ptr %80, align 4, !tbaa !14
  %1135 = fcmp olt float 0x3E80000000000000, %1134
  br i1 %1135, label %1136, label %1151

1136:                                             ; preds = %1133, %1118
  %1137 = load ptr, ptr %2, align 8, !tbaa !5
  %1138 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1137, i32 0, i32 1
  %1139 = load i32, ptr %1138, align 4, !tbaa !16
  %1140 = add nsw i32 %1139, 1
  store i32 %1140, ptr %1138, align 4, !tbaa !16
  %1141 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 91)
  %1142 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1143 = getelementptr inbounds [4 x float], ptr %1142, i64 0, i64 1
  %1144 = load float, ptr %1143, align 4, !tbaa !10
  %1145 = fpext float %1144 to double
  %1146 = load float, ptr %79, align 4, !tbaa !14
  %1147 = fpext float %1146 to double
  %1148 = load float, ptr %80, align 4, !tbaa !14
  %1149 = fpext float %1148 to double
  %1150 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1145, double noundef %1147, double noundef %1149)
  br label %1151

1151:                                             ; preds = %1136, %1133
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #7
  %1152 = load ptr, ptr %2, align 8, !tbaa !5
  %1153 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1152, i32 0, i32 0
  %1154 = load i32, ptr %1153, align 4, !tbaa !11
  %1155 = add nsw i32 %1154, 1
  store i32 %1155, ptr %1153, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #7
  %1156 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 1
  %1157 = getelementptr inbounds [4 x float], ptr %1156, i64 0, i64 2
  %1158 = load float, ptr %1157, align 8, !tbaa !10
  store float %1158, ptr %81, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #7
  %1159 = load float, ptr %81, align 4, !tbaa !14
  %1160 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1161 = getelementptr inbounds [4 x float], ptr %1160, i64 0, i64 2
  %1162 = load float, ptr %1161, align 8, !tbaa !10
  %1163 = fsub float %1159, %1162
  store float %1163, ptr %82, align 4, !tbaa !14
  %1164 = load float, ptr %82, align 4, !tbaa !14
  %1165 = fcmp olt float %1164, 0xBE80000000000000
  br i1 %1165, label %1169, label %1166

1166:                                             ; preds = %1151
  %1167 = load float, ptr %82, align 4, !tbaa !14
  %1168 = fcmp olt float 0x3E80000000000000, %1167
  br i1 %1168, label %1169, label %1184

1169:                                             ; preds = %1166, %1151
  %1170 = load ptr, ptr %2, align 8, !tbaa !5
  %1171 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1170, i32 0, i32 1
  %1172 = load i32, ptr %1171, align 4, !tbaa !16
  %1173 = add nsw i32 %1172, 1
  store i32 %1173, ptr %1171, align 4, !tbaa !16
  %1174 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 92)
  %1175 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1176 = getelementptr inbounds [4 x float], ptr %1175, i64 0, i64 2
  %1177 = load float, ptr %1176, align 8, !tbaa !10
  %1178 = fpext float %1177 to double
  %1179 = load float, ptr %81, align 4, !tbaa !14
  %1180 = fpext float %1179 to double
  %1181 = load float, ptr %82, align 4, !tbaa !14
  %1182 = fpext float %1181 to double
  %1183 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1178, double noundef %1180, double noundef %1182)
  br label %1184

1184:                                             ; preds = %1169, %1166
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #7
  %1185 = load ptr, ptr %2, align 8, !tbaa !5
  %1186 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1185, i32 0, i32 0
  %1187 = load i32, ptr %1186, align 4, !tbaa !11
  %1188 = add nsw i32 %1187, 1
  store i32 %1188, ptr %1186, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #7
  %1189 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 2
  %1190 = getelementptr inbounds [4 x float], ptr %1189, i64 0, i64 0
  %1191 = load float, ptr %1190, align 16, !tbaa !10
  store float %1191, ptr %83, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #7
  %1192 = load float, ptr %83, align 4, !tbaa !14
  %1193 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1194 = getelementptr inbounds [4 x float], ptr %1193, i64 0, i64 0
  %1195 = load float, ptr %1194, align 16, !tbaa !10
  %1196 = fsub float %1192, %1195
  store float %1196, ptr %84, align 4, !tbaa !14
  %1197 = load float, ptr %84, align 4, !tbaa !14
  %1198 = fcmp olt float %1197, 0xBE80000000000000
  br i1 %1198, label %1202, label %1199

1199:                                             ; preds = %1184
  %1200 = load float, ptr %84, align 4, !tbaa !14
  %1201 = fcmp olt float 0x3E80000000000000, %1200
  br i1 %1201, label %1202, label %1217

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

1217:                                             ; preds = %1202, %1199
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #7
  %1218 = load ptr, ptr %2, align 8, !tbaa !5
  %1219 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1218, i32 0, i32 0
  %1220 = load i32, ptr %1219, align 4, !tbaa !11
  %1221 = add nsw i32 %1220, 1
  store i32 %1221, ptr %1219, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #7
  %1222 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 2
  %1223 = getelementptr inbounds [4 x float], ptr %1222, i64 0, i64 1
  %1224 = load float, ptr %1223, align 4, !tbaa !10
  store float %1224, ptr %85, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #7
  %1225 = load float, ptr %85, align 4, !tbaa !14
  %1226 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1227 = getelementptr inbounds [4 x float], ptr %1226, i64 0, i64 1
  %1228 = load float, ptr %1227, align 4, !tbaa !10
  %1229 = fsub float %1225, %1228
  store float %1229, ptr %86, align 4, !tbaa !14
  %1230 = load float, ptr %86, align 4, !tbaa !14
  %1231 = fcmp olt float %1230, 0xBE80000000000000
  br i1 %1231, label %1235, label %1232

1232:                                             ; preds = %1217
  %1233 = load float, ptr %86, align 4, !tbaa !14
  %1234 = fcmp olt float 0x3E80000000000000, %1233
  br i1 %1234, label %1235, label %1250

1235:                                             ; preds = %1232, %1217
  %1236 = load ptr, ptr %2, align 8, !tbaa !5
  %1237 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1236, i32 0, i32 1
  %1238 = load i32, ptr %1237, align 4, !tbaa !16
  %1239 = add nsw i32 %1238, 1
  store i32 %1239, ptr %1237, align 4, !tbaa !16
  %1240 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 94)
  %1241 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1242 = getelementptr inbounds [4 x float], ptr %1241, i64 0, i64 1
  %1243 = load float, ptr %1242, align 4, !tbaa !10
  %1244 = fpext float %1243 to double
  %1245 = load float, ptr %85, align 4, !tbaa !14
  %1246 = fpext float %1245 to double
  %1247 = load float, ptr %86, align 4, !tbaa !14
  %1248 = fpext float %1247 to double
  %1249 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1244, double noundef %1246, double noundef %1248)
  br label %1250

1250:                                             ; preds = %1235, %1232
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #7
  %1251 = load ptr, ptr %2, align 8, !tbaa !5
  %1252 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1251, i32 0, i32 0
  %1253 = load i32, ptr %1252, align 4, !tbaa !11
  %1254 = add nsw i32 %1253, 1
  store i32 %1254, ptr %1252, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #7
  %1255 = getelementptr inbounds [4 x [4 x float]], ptr %69, i64 0, i64 2
  %1256 = getelementptr inbounds [4 x float], ptr %1255, i64 0, i64 2
  %1257 = load float, ptr %1256, align 8, !tbaa !10
  store float %1257, ptr %87, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #7
  %1258 = load float, ptr %87, align 4, !tbaa !14
  %1259 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1260 = getelementptr inbounds [4 x float], ptr %1259, i64 0, i64 2
  %1261 = load float, ptr %1260, align 8, !tbaa !10
  %1262 = fsub float %1258, %1261
  store float %1262, ptr %88, align 4, !tbaa !14
  %1263 = load float, ptr %88, align 4, !tbaa !14
  %1264 = fcmp olt float %1263, 0xBE80000000000000
  br i1 %1264, label %1268, label %1265

1265:                                             ; preds = %1250
  %1266 = load float, ptr %88, align 4, !tbaa !14
  %1267 = fcmp olt float 0x3E80000000000000, %1266
  br i1 %1267, label %1268, label %1283

1268:                                             ; preds = %1265, %1250
  %1269 = load ptr, ptr %2, align 8, !tbaa !5
  %1270 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1269, i32 0, i32 1
  %1271 = load i32, ptr %1270, align 4, !tbaa !16
  %1272 = add nsw i32 %1271, 1
  store i32 %1272, ptr %1270, align 4, !tbaa !16
  %1273 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 95)
  %1274 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1275 = getelementptr inbounds [4 x float], ptr %1274, i64 0, i64 2
  %1276 = load float, ptr %1275, align 8, !tbaa !10
  %1277 = fpext float %1276 to double
  %1278 = load float, ptr %87, align 4, !tbaa !14
  %1279 = fpext float %1278 to double
  %1280 = load float, ptr %88, align 4, !tbaa !14
  %1281 = fpext float %1280 to double
  %1282 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1277, double noundef %1279, double noundef %1281)
  br label %1283

1283:                                             ; preds = %1268, %1265
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %69) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr %89) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %90, ptr align 16 %67, i64 64, i1 false), !tbaa.struct !18
  call void @_ZL13HMM_Transpose8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %89, ptr noundef byval(%union.HMM_Mat4) align 16 %90)
  %1284 = load ptr, ptr %2, align 8, !tbaa !5
  %1285 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1284, i32 0, i32 0
  %1286 = load i32, ptr %1285, align 4, !tbaa !11
  %1287 = add nsw i32 %1286, 1
  store i32 %1287, ptr %1285, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #7
  %1288 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 0
  %1289 = getelementptr inbounds [4 x float], ptr %1288, i64 0, i64 0
  %1290 = load float, ptr %1289, align 16, !tbaa !10
  store float %1290, ptr %91, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #7
  %1291 = load float, ptr %91, align 4, !tbaa !14
  %1292 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1293 = getelementptr inbounds [4 x float], ptr %1292, i64 0, i64 0
  %1294 = load float, ptr %1293, align 16, !tbaa !10
  %1295 = fsub float %1291, %1294
  store float %1295, ptr %92, align 4, !tbaa !14
  %1296 = load float, ptr %92, align 4, !tbaa !14
  %1297 = fcmp olt float %1296, 0xBE80000000000000
  br i1 %1297, label %1301, label %1298

1298:                                             ; preds = %1283
  %1299 = load float, ptr %92, align 4, !tbaa !14
  %1300 = fcmp olt float 0x3E80000000000000, %1299
  br i1 %1300, label %1301, label %1316

1301:                                             ; preds = %1298, %1283
  %1302 = load ptr, ptr %2, align 8, !tbaa !5
  %1303 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1302, i32 0, i32 1
  %1304 = load i32, ptr %1303, align 4, !tbaa !16
  %1305 = add nsw i32 %1304, 1
  store i32 %1305, ptr %1303, align 4, !tbaa !16
  %1306 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 100)
  %1307 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1308 = getelementptr inbounds [4 x float], ptr %1307, i64 0, i64 0
  %1309 = load float, ptr %1308, align 16, !tbaa !10
  %1310 = fpext float %1309 to double
  %1311 = load float, ptr %91, align 4, !tbaa !14
  %1312 = fpext float %1311 to double
  %1313 = load float, ptr %92, align 4, !tbaa !14
  %1314 = fpext float %1313 to double
  %1315 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1310, double noundef %1312, double noundef %1314)
  br label %1316

1316:                                             ; preds = %1301, %1298
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #7
  %1317 = load ptr, ptr %2, align 8, !tbaa !5
  %1318 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1317, i32 0, i32 0
  %1319 = load i32, ptr %1318, align 4, !tbaa !11
  %1320 = add nsw i32 %1319, 1
  store i32 %1320, ptr %1318, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #7
  %1321 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 0
  %1322 = getelementptr inbounds [4 x float], ptr %1321, i64 0, i64 1
  %1323 = load float, ptr %1322, align 4, !tbaa !10
  store float %1323, ptr %93, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #7
  %1324 = load float, ptr %93, align 4, !tbaa !14
  %1325 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1326 = getelementptr inbounds [4 x float], ptr %1325, i64 0, i64 1
  %1327 = load float, ptr %1326, align 4, !tbaa !10
  %1328 = fsub float %1324, %1327
  store float %1328, ptr %94, align 4, !tbaa !14
  %1329 = load float, ptr %94, align 4, !tbaa !14
  %1330 = fcmp olt float %1329, 0xBE80000000000000
  br i1 %1330, label %1334, label %1331

1331:                                             ; preds = %1316
  %1332 = load float, ptr %94, align 4, !tbaa !14
  %1333 = fcmp olt float 0x3E80000000000000, %1332
  br i1 %1333, label %1334, label %1349

1334:                                             ; preds = %1331, %1316
  %1335 = load ptr, ptr %2, align 8, !tbaa !5
  %1336 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1335, i32 0, i32 1
  %1337 = load i32, ptr %1336, align 4, !tbaa !16
  %1338 = add nsw i32 %1337, 1
  store i32 %1338, ptr %1336, align 4, !tbaa !16
  %1339 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 101)
  %1340 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1341 = getelementptr inbounds [4 x float], ptr %1340, i64 0, i64 1
  %1342 = load float, ptr %1341, align 4, !tbaa !10
  %1343 = fpext float %1342 to double
  %1344 = load float, ptr %93, align 4, !tbaa !14
  %1345 = fpext float %1344 to double
  %1346 = load float, ptr %94, align 4, !tbaa !14
  %1347 = fpext float %1346 to double
  %1348 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1343, double noundef %1345, double noundef %1347)
  br label %1349

1349:                                             ; preds = %1334, %1331
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #7
  %1350 = load ptr, ptr %2, align 8, !tbaa !5
  %1351 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1350, i32 0, i32 0
  %1352 = load i32, ptr %1351, align 4, !tbaa !11
  %1353 = add nsw i32 %1352, 1
  store i32 %1353, ptr %1351, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #7
  %1354 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 0
  %1355 = getelementptr inbounds [4 x float], ptr %1354, i64 0, i64 2
  %1356 = load float, ptr %1355, align 8, !tbaa !10
  store float %1356, ptr %95, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #7
  %1357 = load float, ptr %95, align 4, !tbaa !14
  %1358 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1359 = getelementptr inbounds [4 x float], ptr %1358, i64 0, i64 2
  %1360 = load float, ptr %1359, align 8, !tbaa !10
  %1361 = fsub float %1357, %1360
  store float %1361, ptr %96, align 4, !tbaa !14
  %1362 = load float, ptr %96, align 4, !tbaa !14
  %1363 = fcmp olt float %1362, 0xBE80000000000000
  br i1 %1363, label %1367, label %1364

1364:                                             ; preds = %1349
  %1365 = load float, ptr %96, align 4, !tbaa !14
  %1366 = fcmp olt float 0x3E80000000000000, %1365
  br i1 %1366, label %1367, label %1382

1367:                                             ; preds = %1364, %1349
  %1368 = load ptr, ptr %2, align 8, !tbaa !5
  %1369 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1368, i32 0, i32 1
  %1370 = load i32, ptr %1369, align 4, !tbaa !16
  %1371 = add nsw i32 %1370, 1
  store i32 %1371, ptr %1369, align 4, !tbaa !16
  %1372 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 102)
  %1373 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 0
  %1374 = getelementptr inbounds [4 x float], ptr %1373, i64 0, i64 2
  %1375 = load float, ptr %1374, align 8, !tbaa !10
  %1376 = fpext float %1375 to double
  %1377 = load float, ptr %95, align 4, !tbaa !14
  %1378 = fpext float %1377 to double
  %1379 = load float, ptr %96, align 4, !tbaa !14
  %1380 = fpext float %1379 to double
  %1381 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1376, double noundef %1378, double noundef %1380)
  br label %1382

1382:                                             ; preds = %1367, %1364
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #7
  %1383 = load ptr, ptr %2, align 8, !tbaa !5
  %1384 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1383, i32 0, i32 0
  %1385 = load i32, ptr %1384, align 4, !tbaa !11
  %1386 = add nsw i32 %1385, 1
  store i32 %1386, ptr %1384, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #7
  %1387 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 1
  %1388 = getelementptr inbounds [4 x float], ptr %1387, i64 0, i64 0
  %1389 = load float, ptr %1388, align 16, !tbaa !10
  store float %1389, ptr %97, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #7
  %1390 = load float, ptr %97, align 4, !tbaa !14
  %1391 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1392 = getelementptr inbounds [4 x float], ptr %1391, i64 0, i64 0
  %1393 = load float, ptr %1392, align 16, !tbaa !10
  %1394 = fsub float %1390, %1393
  store float %1394, ptr %98, align 4, !tbaa !14
  %1395 = load float, ptr %98, align 4, !tbaa !14
  %1396 = fcmp olt float %1395, 0xBE80000000000000
  br i1 %1396, label %1400, label %1397

1397:                                             ; preds = %1382
  %1398 = load float, ptr %98, align 4, !tbaa !14
  %1399 = fcmp olt float 0x3E80000000000000, %1398
  br i1 %1399, label %1400, label %1415

1400:                                             ; preds = %1397, %1382
  %1401 = load ptr, ptr %2, align 8, !tbaa !5
  %1402 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1401, i32 0, i32 1
  %1403 = load i32, ptr %1402, align 4, !tbaa !16
  %1404 = add nsw i32 %1403, 1
  store i32 %1404, ptr %1402, align 4, !tbaa !16
  %1405 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 103)
  %1406 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1407 = getelementptr inbounds [4 x float], ptr %1406, i64 0, i64 0
  %1408 = load float, ptr %1407, align 16, !tbaa !10
  %1409 = fpext float %1408 to double
  %1410 = load float, ptr %97, align 4, !tbaa !14
  %1411 = fpext float %1410 to double
  %1412 = load float, ptr %98, align 4, !tbaa !14
  %1413 = fpext float %1412 to double
  %1414 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1409, double noundef %1411, double noundef %1413)
  br label %1415

1415:                                             ; preds = %1400, %1397
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #7
  %1416 = load ptr, ptr %2, align 8, !tbaa !5
  %1417 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1416, i32 0, i32 0
  %1418 = load i32, ptr %1417, align 4, !tbaa !11
  %1419 = add nsw i32 %1418, 1
  store i32 %1419, ptr %1417, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #7
  %1420 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 1
  %1421 = getelementptr inbounds [4 x float], ptr %1420, i64 0, i64 1
  %1422 = load float, ptr %1421, align 4, !tbaa !10
  store float %1422, ptr %99, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #7
  %1423 = load float, ptr %99, align 4, !tbaa !14
  %1424 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1425 = getelementptr inbounds [4 x float], ptr %1424, i64 0, i64 1
  %1426 = load float, ptr %1425, align 4, !tbaa !10
  %1427 = fsub float %1423, %1426
  store float %1427, ptr %100, align 4, !tbaa !14
  %1428 = load float, ptr %100, align 4, !tbaa !14
  %1429 = fcmp olt float %1428, 0xBE80000000000000
  br i1 %1429, label %1433, label %1430

1430:                                             ; preds = %1415
  %1431 = load float, ptr %100, align 4, !tbaa !14
  %1432 = fcmp olt float 0x3E80000000000000, %1431
  br i1 %1432, label %1433, label %1448

1433:                                             ; preds = %1430, %1415
  %1434 = load ptr, ptr %2, align 8, !tbaa !5
  %1435 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1434, i32 0, i32 1
  %1436 = load i32, ptr %1435, align 4, !tbaa !16
  %1437 = add nsw i32 %1436, 1
  store i32 %1437, ptr %1435, align 4, !tbaa !16
  %1438 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 104)
  %1439 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1440 = getelementptr inbounds [4 x float], ptr %1439, i64 0, i64 1
  %1441 = load float, ptr %1440, align 4, !tbaa !10
  %1442 = fpext float %1441 to double
  %1443 = load float, ptr %99, align 4, !tbaa !14
  %1444 = fpext float %1443 to double
  %1445 = load float, ptr %100, align 4, !tbaa !14
  %1446 = fpext float %1445 to double
  %1447 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1442, double noundef %1444, double noundef %1446)
  br label %1448

1448:                                             ; preds = %1433, %1430
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #7
  %1449 = load ptr, ptr %2, align 8, !tbaa !5
  %1450 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1449, i32 0, i32 0
  %1451 = load i32, ptr %1450, align 4, !tbaa !11
  %1452 = add nsw i32 %1451, 1
  store i32 %1452, ptr %1450, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %101) #7
  %1453 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 1
  %1454 = getelementptr inbounds [4 x float], ptr %1453, i64 0, i64 2
  %1455 = load float, ptr %1454, align 8, !tbaa !10
  store float %1455, ptr %101, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #7
  %1456 = load float, ptr %101, align 4, !tbaa !14
  %1457 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1458 = getelementptr inbounds [4 x float], ptr %1457, i64 0, i64 2
  %1459 = load float, ptr %1458, align 8, !tbaa !10
  %1460 = fsub float %1456, %1459
  store float %1460, ptr %102, align 4, !tbaa !14
  %1461 = load float, ptr %102, align 4, !tbaa !14
  %1462 = fcmp olt float %1461, 0xBE80000000000000
  br i1 %1462, label %1466, label %1463

1463:                                             ; preds = %1448
  %1464 = load float, ptr %102, align 4, !tbaa !14
  %1465 = fcmp olt float 0x3E80000000000000, %1464
  br i1 %1465, label %1466, label %1481

1466:                                             ; preds = %1463, %1448
  %1467 = load ptr, ptr %2, align 8, !tbaa !5
  %1468 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1467, i32 0, i32 1
  %1469 = load i32, ptr %1468, align 4, !tbaa !16
  %1470 = add nsw i32 %1469, 1
  store i32 %1470, ptr %1468, align 4, !tbaa !16
  %1471 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 105)
  %1472 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 1
  %1473 = getelementptr inbounds [4 x float], ptr %1472, i64 0, i64 2
  %1474 = load float, ptr %1473, align 8, !tbaa !10
  %1475 = fpext float %1474 to double
  %1476 = load float, ptr %101, align 4, !tbaa !14
  %1477 = fpext float %1476 to double
  %1478 = load float, ptr %102, align 4, !tbaa !14
  %1479 = fpext float %1478 to double
  %1480 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1475, double noundef %1477, double noundef %1479)
  br label %1481

1481:                                             ; preds = %1466, %1463
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %101) #7
  %1482 = load ptr, ptr %2, align 8, !tbaa !5
  %1483 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1482, i32 0, i32 0
  %1484 = load i32, ptr %1483, align 4, !tbaa !11
  %1485 = add nsw i32 %1484, 1
  store i32 %1485, ptr %1483, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #7
  %1486 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 2
  %1487 = getelementptr inbounds [4 x float], ptr %1486, i64 0, i64 0
  %1488 = load float, ptr %1487, align 16, !tbaa !10
  store float %1488, ptr %103, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #7
  %1489 = load float, ptr %103, align 4, !tbaa !14
  %1490 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1491 = getelementptr inbounds [4 x float], ptr %1490, i64 0, i64 0
  %1492 = load float, ptr %1491, align 16, !tbaa !10
  %1493 = fsub float %1489, %1492
  store float %1493, ptr %104, align 4, !tbaa !14
  %1494 = load float, ptr %104, align 4, !tbaa !14
  %1495 = fcmp olt float %1494, 0xBE80000000000000
  br i1 %1495, label %1499, label %1496

1496:                                             ; preds = %1481
  %1497 = load float, ptr %104, align 4, !tbaa !14
  %1498 = fcmp olt float 0x3E80000000000000, %1497
  br i1 %1498, label %1499, label %1514

1499:                                             ; preds = %1496, %1481
  %1500 = load ptr, ptr %2, align 8, !tbaa !5
  %1501 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1500, i32 0, i32 1
  %1502 = load i32, ptr %1501, align 4, !tbaa !16
  %1503 = add nsw i32 %1502, 1
  store i32 %1503, ptr %1501, align 4, !tbaa !16
  %1504 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 106)
  %1505 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1506 = getelementptr inbounds [4 x float], ptr %1505, i64 0, i64 0
  %1507 = load float, ptr %1506, align 16, !tbaa !10
  %1508 = fpext float %1507 to double
  %1509 = load float, ptr %103, align 4, !tbaa !14
  %1510 = fpext float %1509 to double
  %1511 = load float, ptr %104, align 4, !tbaa !14
  %1512 = fpext float %1511 to double
  %1513 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1508, double noundef %1510, double noundef %1512)
  br label %1514

1514:                                             ; preds = %1499, %1496
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #7
  %1515 = load ptr, ptr %2, align 8, !tbaa !5
  %1516 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1515, i32 0, i32 0
  %1517 = load i32, ptr %1516, align 4, !tbaa !11
  %1518 = add nsw i32 %1517, 1
  store i32 %1518, ptr %1516, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #7
  %1519 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 2
  %1520 = getelementptr inbounds [4 x float], ptr %1519, i64 0, i64 1
  %1521 = load float, ptr %1520, align 4, !tbaa !10
  store float %1521, ptr %105, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #7
  %1522 = load float, ptr %105, align 4, !tbaa !14
  %1523 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1524 = getelementptr inbounds [4 x float], ptr %1523, i64 0, i64 1
  %1525 = load float, ptr %1524, align 4, !tbaa !10
  %1526 = fsub float %1522, %1525
  store float %1526, ptr %106, align 4, !tbaa !14
  %1527 = load float, ptr %106, align 4, !tbaa !14
  %1528 = fcmp olt float %1527, 0xBE80000000000000
  br i1 %1528, label %1532, label %1529

1529:                                             ; preds = %1514
  %1530 = load float, ptr %106, align 4, !tbaa !14
  %1531 = fcmp olt float 0x3E80000000000000, %1530
  br i1 %1531, label %1532, label %1547

1532:                                             ; preds = %1529, %1514
  %1533 = load ptr, ptr %2, align 8, !tbaa !5
  %1534 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1533, i32 0, i32 1
  %1535 = load i32, ptr %1534, align 4, !tbaa !16
  %1536 = add nsw i32 %1535, 1
  store i32 %1536, ptr %1534, align 4, !tbaa !16
  %1537 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 107)
  %1538 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1539 = getelementptr inbounds [4 x float], ptr %1538, i64 0, i64 1
  %1540 = load float, ptr %1539, align 4, !tbaa !10
  %1541 = fpext float %1540 to double
  %1542 = load float, ptr %105, align 4, !tbaa !14
  %1543 = fpext float %1542 to double
  %1544 = load float, ptr %106, align 4, !tbaa !14
  %1545 = fpext float %1544 to double
  %1546 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1541, double noundef %1543, double noundef %1545)
  br label %1547

1547:                                             ; preds = %1532, %1529
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #7
  %1548 = load ptr, ptr %2, align 8, !tbaa !5
  %1549 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1548, i32 0, i32 0
  %1550 = load i32, ptr %1549, align 4, !tbaa !11
  %1551 = add nsw i32 %1550, 1
  store i32 %1551, ptr %1549, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #7
  %1552 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 2
  %1553 = getelementptr inbounds [4 x float], ptr %1552, i64 0, i64 2
  %1554 = load float, ptr %1553, align 8, !tbaa !10
  store float %1554, ptr %107, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %108) #7
  %1555 = load float, ptr %107, align 4, !tbaa !14
  %1556 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1557 = getelementptr inbounds [4 x float], ptr %1556, i64 0, i64 2
  %1558 = load float, ptr %1557, align 8, !tbaa !10
  %1559 = fsub float %1555, %1558
  store float %1559, ptr %108, align 4, !tbaa !14
  %1560 = load float, ptr %108, align 4, !tbaa !14
  %1561 = fcmp olt float %1560, 0xBE80000000000000
  br i1 %1561, label %1565, label %1562

1562:                                             ; preds = %1547
  %1563 = load float, ptr %108, align 4, !tbaa !14
  %1564 = fcmp olt float 0x3E80000000000000, %1563
  br i1 %1564, label %1565, label %1580

1565:                                             ; preds = %1562, %1547
  %1566 = load ptr, ptr %2, align 8, !tbaa !5
  %1567 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1566, i32 0, i32 1
  %1568 = load i32, ptr %1567, align 4, !tbaa !16
  %1569 = add nsw i32 %1568, 1
  store i32 %1569, ptr %1567, align 4, !tbaa !16
  %1570 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 108)
  %1571 = getelementptr inbounds [4 x [4 x float]], ptr %68, i64 0, i64 2
  %1572 = getelementptr inbounds [4 x float], ptr %1571, i64 0, i64 2
  %1573 = load float, ptr %1572, align 8, !tbaa !10
  %1574 = fpext float %1573 to double
  %1575 = load float, ptr %107, align 4, !tbaa !14
  %1576 = fpext float %1575 to double
  %1577 = load float, ptr %108, align 4, !tbaa !14
  %1578 = fpext float %1577 to double
  %1579 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef %1574, double noundef %1576, double noundef %1578)
  br label %1580

1580:                                             ; preds = %1565, %1562
  call void @llvm.lifetime.end.p0(i64 4, ptr %108) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %89) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %68) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %67) #7
  ret void
}

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL15HMM_TransposeM38HMM_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 @_ZL13HMM_Transpose8HMM_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 @_ZL13HMM_Transpose8HMM_Mat4(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, ptr noundef byval(%union.HMM_Mat4) align 16) #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 = { inlinehint mustprogress uwtable "min-legal-vector-width"="128" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #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 = { 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 #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 16, !10}
!10 = !{!7, !7, i64 0}
!11 = !{!12, !13, i64 0}
!12 = !{!"_ZTS21hmt_testresult_struct", !13, i64 0, !13, i64 4}
!13 = !{!"int", !7, i64 0}
!14 = !{!15, !15, i64 0}
!15 = !{!"float", !7, i64 0}
!16 = !{!12, !13, i64 4}
!17 = !{i64 0, i64 36, !10}
!18 = !{i64 0, i64 64, !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.18 = external hidden unnamed_addr constant [34 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix = external hidden unnamed_addr constant %union.HMM_Mat2, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect = external hidden unnamed_addr constant %union.HMM_Mat2, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.42 = external hidden unnamed_addr constant %union.HMM_Mat3, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43 = external hidden unnamed_addr constant %union.HMM_Mat3, align 4
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.44 = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16
@__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45 = external hidden unnamed_addr constant { [4 x [4 x float]] }, align 16

; 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 void @_ZL15HMM_TransposeM48HMM_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: mustprogress uwtable
define dso_local void @_Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #4 {
  %2 = alloca %union.HMM_Mat3, align 4
  %3 = alloca %union.HMM_Mat3, align 8
  %4 = alloca %union.HMM_Mat3, align 4
  %5 = alloca %union.HMM_Mat3, align 8
  %6 = alloca %union.HMM_Mat4, align 16
  %7 = alloca %union.HMM_Mat4, align 16
  %.sroa.0396.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix, align 4
  %.sroa.5398.0.copyload = load <2 x float>, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix, i64 8), align 4
  %.sroa.0380.0.copyload = load float, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect, align 4
  %.sroa.7384.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect, i64 4), align 4
  %.sroa.11388.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect, i64 8), align 4
  %.sroa.15392.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect, i64 12), align 4
  %8 = tail call { <2 x float>, <2 x float> } @_ZL15HMM_TransposeM28HMM_Mat2(<2 x float> %.sroa.0396.0.copyload, <2 x float> %.sroa.5398.0.copyload)
  %9 = extractvalue { <2 x float>, <2 x float> } %8, 0
  %10 = extractvalue { <2 x float>, <2 x float> } %8, 1
  %11 = load i32, ptr %0, align 4, !tbaa !5
  %12 = add nsw i32 %11, 1
  store i32 %12, ptr %0, align 4, !tbaa !5
  %.sroa.0378.0.vec.extract = extractelement <2 x float> %9, i64 0
  %13 = fsub float %.sroa.0378.0.vec.extract, %.sroa.0380.0.copyload
  %14 = tail call float @llvm.fabs.f32(float %13)
  %or.cond = fcmp ogt float %14, 0x3E80000000000000
  br i1 %or.cond, label %15, label %24

15:                                               ; preds = %1
  %16 = getelementptr inbounds i8, ptr %0, i64 4
  %17 = load i32, ptr %16, align 4, !tbaa !10
  %18 = add nsw i32 %17, 1
  store i32 %18, ptr %16, align 4, !tbaa !10
  %19 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 17)
  %20 = fpext float %.sroa.0380.0.copyload to double
  %21 = fpext float %.sroa.0378.0.vec.extract to double
  %22 = fpext float %13 to double
  %23 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %20, double noundef %21, double noundef %22)
  %.pre = load i32, ptr %0, align 4, !tbaa !5
  br label %24

24:                                               ; preds = %1, %15
  %25 = phi i32 [ %12, %1 ], [ %.pre, %15 ]
  %26 = add nsw i32 %25, 1
  store i32 %26, ptr %0, align 4, !tbaa !5
  %.sroa.0378.4.vec.extract = extractelement <2 x float> %9, i64 1
  %27 = fsub float %.sroa.0378.4.vec.extract, %.sroa.7384.0.copyload
  %28 = tail call float @llvm.fabs.f32(float %27)
  %or.cond3 = fcmp ogt float %28, 0x3E80000000000000
  br i1 %or.cond3, label %29, label %38

29:                                               ; preds = %24
  %30 = getelementptr inbounds i8, ptr %0, i64 4
  %31 = load i32, ptr %30, align 4, !tbaa !10
  %32 = add nsw i32 %31, 1
  store i32 %32, ptr %30, align 4, !tbaa !10
  %33 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 18)
  %34 = fpext float %.sroa.7384.0.copyload to double
  %35 = fpext float %.sroa.0378.4.vec.extract to double
  %36 = fpext float %27 to double
  %37 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %34, double noundef %35, double noundef %36)
  %.pre488 = load i32, ptr %0, align 4, !tbaa !5
  br label %38

38:                                               ; preds = %24, %29
  %39 = phi i32 [ %26, %24 ], [ %.pre488, %29 ]
  %40 = add nsw i32 %39, 1
  store i32 %40, ptr %0, align 4, !tbaa !5
  %.sroa.5379.8.vec.extract = extractelement <2 x float> %10, i64 0
  %41 = fsub float %.sroa.5379.8.vec.extract, %.sroa.11388.0.copyload
  %42 = tail call float @llvm.fabs.f32(float %41)
  %or.cond5 = fcmp ogt float %42, 0x3E80000000000000
  br i1 %or.cond5, label %43, label %52

43:                                               ; preds = %38
  %44 = getelementptr inbounds i8, ptr %0, i64 4
  %45 = load i32, ptr %44, align 4, !tbaa !10
  %46 = add nsw i32 %45, 1
  store i32 %46, ptr %44, align 4, !tbaa !10
  %47 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 19)
  %48 = fpext float %.sroa.11388.0.copyload to double
  %49 = fpext float %.sroa.5379.8.vec.extract to double
  %50 = fpext float %41 to double
  %51 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %48, double noundef %49, double noundef %50)
  %.pre489 = load i32, ptr %0, align 4, !tbaa !5
  br label %52

52:                                               ; preds = %38, %43
  %53 = phi i32 [ %40, %38 ], [ %.pre489, %43 ]
  %54 = add nsw i32 %53, 1
  store i32 %54, ptr %0, align 4, !tbaa !5
  %.sroa.5379.12.vec.extract = extractelement <2 x float> %10, i64 1
  %55 = fsub float %.sroa.5379.12.vec.extract, %.sroa.15392.0.copyload
  %56 = tail call float @llvm.fabs.f32(float %55)
  %or.cond7 = fcmp ogt float %56, 0x3E80000000000000
  br i1 %or.cond7, label %57, label %66

57:                                               ; preds = %52
  %58 = getelementptr inbounds i8, ptr %0, i64 4
  %59 = load i32, ptr %58, align 4, !tbaa !10
  %60 = add nsw i32 %59, 1
  store i32 %60, ptr %58, align 4, !tbaa !10
  %61 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 20)
  %62 = fpext float %.sroa.15392.0.copyload to double
  %63 = fpext float %.sroa.5379.12.vec.extract to double
  %64 = fpext float %55 to double
  %65 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %62, double noundef %63, double noundef %64)
  br label %66

66:                                               ; preds = %52, %57
  %67 = tail call { <2 x float>, <2 x float> } @_ZL13HMM_Transpose8HMM_Mat2(<2 x float> %.sroa.0396.0.copyload, <2 x float> %.sroa.5398.0.copyload)
  %68 = extractvalue { <2 x float>, <2 x float> } %67, 0
  %69 = extractvalue { <2 x float>, <2 x float> } %67, 1
  %70 = load i32, ptr %0, align 4, !tbaa !5
  %71 = add nsw i32 %70, 1
  store i32 %71, ptr %0, align 4, !tbaa !5
  %.sroa.0355.0.vec.extract = extractelement <2 x float> %68, i64 0
  %72 = fsub float %.sroa.0355.0.vec.extract, %.sroa.0380.0.copyload
  %73 = tail call float @llvm.fabs.f32(float %72)
  %or.cond9 = fcmp ogt float %73, 0x3E80000000000000
  br i1 %or.cond9, label %74, label %83

74:                                               ; preds = %66
  %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 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 25)
  %79 = fpext float %.sroa.0380.0.copyload to double
  %80 = fpext float %.sroa.0355.0.vec.extract to double
  %81 = fpext float %72 to double
  %82 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %79, double noundef %80, double noundef %81)
  %.pre490 = load i32, ptr %0, align 4, !tbaa !5
  br label %83

83:                                               ; preds = %66, %74
  %84 = phi i32 [ %71, %66 ], [ %.pre490, %74 ]
  %85 = add nsw i32 %84, 1
  store i32 %85, ptr %0, align 4, !tbaa !5
  %.sroa.0355.4.vec.extract = extractelement <2 x float> %68, i64 1
  %86 = fsub float %.sroa.0355.4.vec.extract, %.sroa.7384.0.copyload
  %87 = tail call float @llvm.fabs.f32(float %86)
  %or.cond11 = fcmp ogt float %87, 0x3E80000000000000
  br i1 %or.cond11, label %88, label %97

88:                                               ; preds = %83
  %89 = getelementptr inbounds i8, ptr %0, i64 4
  %90 = load i32, ptr %89, align 4, !tbaa !10
  %91 = add nsw i32 %90, 1
  store i32 %91, ptr %89, align 4, !tbaa !10
  %92 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 26)
  %93 = fpext float %.sroa.7384.0.copyload to double
  %94 = fpext float %.sroa.0355.4.vec.extract to double
  %95 = fpext float %86 to double
  %96 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %93, double noundef %94, double noundef %95)
  %.pre491 = load i32, ptr %0, align 4, !tbaa !5
  br label %97

97:                                               ; preds = %83, %88
  %98 = phi i32 [ %85, %83 ], [ %.pre491, %88 ]
  %99 = add nsw i32 %98, 1
  store i32 %99, ptr %0, align 4, !tbaa !5
  %.sroa.5.8.vec.extract = extractelement <2 x float> %69, i64 0
  %100 = fsub float %.sroa.5.8.vec.extract, %.sroa.11388.0.copyload
  %101 = tail call float @llvm.fabs.f32(float %100)
  %or.cond13 = fcmp ogt float %101, 0x3E80000000000000
  br i1 %or.cond13, label %102, label %111

102:                                              ; preds = %97
  %103 = getelementptr inbounds i8, ptr %0, i64 4
  %104 = load i32, ptr %103, align 4, !tbaa !10
  %105 = add nsw i32 %104, 1
  store i32 %105, ptr %103, align 4, !tbaa !10
  %106 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 27)
  %107 = fpext float %.sroa.11388.0.copyload to double
  %108 = fpext float %.sroa.5.8.vec.extract to double
  %109 = fpext float %100 to double
  %110 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %107, double noundef %108, double noundef %109)
  %.pre492 = load i32, ptr %0, align 4, !tbaa !5
  br label %111

111:                                              ; preds = %97, %102
  %112 = phi i32 [ %99, %97 ], [ %.pre492, %102 ]
  %113 = add nsw i32 %112, 1
  store i32 %113, ptr %0, align 4, !tbaa !5
  %.sroa.5.12.vec.extract = extractelement <2 x float> %69, i64 1
  %114 = fsub float %.sroa.5.12.vec.extract, %.sroa.15392.0.copyload
  %115 = tail call float @llvm.fabs.f32(float %114)
  %or.cond15 = fcmp ogt float %115, 0x3E80000000000000
  br i1 %or.cond15, label %116, label %125

116:                                              ; preds = %111
  %117 = getelementptr inbounds i8, ptr %0, i64 4
  %118 = load i32, ptr %117, align 4, !tbaa !10
  %119 = add nsw i32 %118, 1
  store i32 %119, ptr %117, align 4, !tbaa !10
  %120 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 28)
  %121 = fpext float %.sroa.15392.0.copyload to double
  %122 = fpext float %.sroa.5.12.vec.extract to double
  %123 = fpext float %114 to double
  %124 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %121, double noundef %122, double noundef %123)
  br label %125

125:                                              ; preds = %111, %116
  %.sroa.0297.0.copyload = load float, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, align 4
  %.sroa.7301.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 4), align 4
  %.sroa.11305.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 8), align 4
  %.sroa.15309.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 12), align 4
  %.sroa.19313.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 16), align 4
  %.sroa.23317.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 20), align 4
  %.sroa.27321.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 24), align 4
  %.sroa.31325.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 28), align 4
  %.sroa.35329.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.43, i64 32), align 4
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %2) #8
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(36) %3, ptr noundef nonnull align 4 dereferenceable(36) @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.42, i64 36, i1 false), !tbaa.struct !11
  call void @_ZL15HMM_TransposeM38HMM_Mat3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %2, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %3)
  %126 = load i32, ptr %0, align 4, !tbaa !5
  %127 = add nsw i32 %126, 1
  store i32 %127, ptr %0, align 4, !tbaa !5
  %128 = load float, ptr %2, align 4, !tbaa !12
  %129 = fsub float %128, %.sroa.0297.0.copyload
  %130 = call float @llvm.fabs.f32(float %129)
  %or.cond17 = fcmp ogt float %130, 0x3E80000000000000
  br i1 %or.cond17, label %131, label %140

131:                                              ; preds = %125
  %132 = getelementptr inbounds i8, ptr %0, i64 4
  %133 = load i32, ptr %132, align 4, !tbaa !10
  %134 = add nsw i32 %133, 1
  store i32 %134, ptr %132, align 4, !tbaa !10
  %135 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 47)
  %136 = fpext float %.sroa.0297.0.copyload to double
  %137 = fpext float %128 to double
  %138 = fpext float %129 to double
  %139 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %136, double noundef %137, double noundef %138)
  %.pre493 = load i32, ptr %0, align 4, !tbaa !5
  br label %140

140:                                              ; preds = %125, %131
  %141 = phi i32 [ %127, %125 ], [ %.pre493, %131 ]
  %142 = add nsw i32 %141, 1
  store i32 %142, ptr %0, align 4, !tbaa !5
  %143 = getelementptr inbounds i8, ptr %2, i64 4
  %144 = load float, ptr %143, align 4, !tbaa !12
  %145 = fsub float %144, %.sroa.7301.0.copyload
  %146 = call float @llvm.fabs.f32(float %145)
  %or.cond19 = fcmp ogt float %146, 0x3E80000000000000
  br i1 %or.cond19, label %147, label %156

147:                                              ; preds = %140
  %148 = getelementptr inbounds i8, ptr %0, i64 4
  %149 = load i32, ptr %148, align 4, !tbaa !10
  %150 = add nsw i32 %149, 1
  store i32 %150, ptr %148, align 4, !tbaa !10
  %151 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 48)
  %152 = fpext float %.sroa.7301.0.copyload to double
  %153 = fpext float %144 to double
  %154 = fpext float %145 to double
  %155 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %152, double noundef %153, double noundef %154)
  %.pre494 = load i32, ptr %0, align 4, !tbaa !5
  br label %156

156:                                              ; preds = %140, %147
  %157 = phi i32 [ %142, %140 ], [ %.pre494, %147 ]
  %158 = add nsw i32 %157, 1
  store i32 %158, ptr %0, align 4, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %2, i64 8
  %160 = load float, ptr %159, align 4, !tbaa !12
  %161 = fsub float %160, %.sroa.11305.0.copyload
  %162 = call float @llvm.fabs.f32(float %161)
  %or.cond21 = fcmp ogt float %162, 0x3E80000000000000
  br i1 %or.cond21, label %163, label %172

163:                                              ; preds = %156
  %164 = getelementptr inbounds i8, ptr %0, i64 4
  %165 = load i32, ptr %164, align 4, !tbaa !10
  %166 = add nsw i32 %165, 1
  store i32 %166, ptr %164, align 4, !tbaa !10
  %167 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 49)
  %168 = fpext float %.sroa.11305.0.copyload to double
  %169 = fpext float %160 to double
  %170 = fpext float %161 to double
  %171 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %168, double noundef %169, double noundef %170)
  %.pre495 = load i32, ptr %0, align 4, !tbaa !5
  br label %172

172:                                              ; preds = %156, %163
  %173 = phi i32 [ %158, %156 ], [ %.pre495, %163 ]
  %174 = add nsw i32 %173, 1
  store i32 %174, ptr %0, align 4, !tbaa !5
  %175 = getelementptr inbounds i8, ptr %2, i64 12
  %176 = load float, ptr %175, align 4, !tbaa !12
  %177 = fsub float %176, %.sroa.15309.0.copyload
  %178 = call float @llvm.fabs.f32(float %177)
  %or.cond23 = fcmp ogt float %178, 0x3E80000000000000
  br i1 %or.cond23, label %179, label %188

179:                                              ; preds = %172
  %180 = getelementptr inbounds i8, ptr %0, i64 4
  %181 = load i32, ptr %180, align 4, !tbaa !10
  %182 = add nsw i32 %181, 1
  store i32 %182, ptr %180, align 4, !tbaa !10
  %183 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 50)
  %184 = fpext float %.sroa.15309.0.copyload to double
  %185 = fpext float %176 to double
  %186 = fpext float %177 to double
  %187 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %184, double noundef %185, double noundef %186)
  %.pre496 = load i32, ptr %0, align 4, !tbaa !5
  br label %188

188:                                              ; preds = %172, %179
  %189 = phi i32 [ %174, %172 ], [ %.pre496, %179 ]
  %190 = add nsw i32 %189, 1
  store i32 %190, ptr %0, align 4, !tbaa !5
  %191 = getelementptr inbounds i8, ptr %2, i64 16
  %192 = load float, ptr %191, align 4, !tbaa !12
  %193 = fsub float %192, %.sroa.19313.0.copyload
  %194 = call float @llvm.fabs.f32(float %193)
  %or.cond25 = fcmp ogt float %194, 0x3E80000000000000
  br i1 %or.cond25, label %195, label %204

195:                                              ; preds = %188
  %196 = getelementptr inbounds i8, ptr %0, i64 4
  %197 = load i32, ptr %196, align 4, !tbaa !10
  %198 = add nsw i32 %197, 1
  store i32 %198, ptr %196, align 4, !tbaa !10
  %199 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 51)
  %200 = fpext float %.sroa.19313.0.copyload to double
  %201 = fpext float %192 to double
  %202 = fpext float %193 to double
  %203 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %200, double noundef %201, double noundef %202)
  %.pre497 = load i32, ptr %0, align 4, !tbaa !5
  br label %204

204:                                              ; preds = %188, %195
  %205 = phi i32 [ %190, %188 ], [ %.pre497, %195 ]
  %206 = add nsw i32 %205, 1
  store i32 %206, ptr %0, align 4, !tbaa !5
  %207 = getelementptr inbounds i8, ptr %2, i64 20
  %208 = load float, ptr %207, align 4, !tbaa !12
  %209 = fsub float %208, %.sroa.23317.0.copyload
  %210 = call float @llvm.fabs.f32(float %209)
  %or.cond27 = fcmp ogt float %210, 0x3E80000000000000
  br i1 %or.cond27, label %211, label %220

211:                                              ; preds = %204
  %212 = getelementptr inbounds i8, ptr %0, i64 4
  %213 = load i32, ptr %212, align 4, !tbaa !10
  %214 = add nsw i32 %213, 1
  store i32 %214, ptr %212, align 4, !tbaa !10
  %215 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 52)
  %216 = fpext float %.sroa.23317.0.copyload to double
  %217 = fpext float %208 to double
  %218 = fpext float %209 to double
  %219 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %216, double noundef %217, double noundef %218)
  %.pre498 = load i32, ptr %0, align 4, !tbaa !5
  br label %220

220:                                              ; preds = %204, %211
  %221 = phi i32 [ %206, %204 ], [ %.pre498, %211 ]
  %222 = add nsw i32 %221, 1
  store i32 %222, ptr %0, align 4, !tbaa !5
  %223 = getelementptr inbounds i8, ptr %2, i64 24
  %224 = load float, ptr %223, align 4, !tbaa !12
  %225 = fsub float %224, %.sroa.27321.0.copyload
  %226 = call float @llvm.fabs.f32(float %225)
  %or.cond29 = fcmp ogt float %226, 0x3E80000000000000
  br i1 %or.cond29, label %227, label %236

227:                                              ; preds = %220
  %228 = getelementptr inbounds i8, ptr %0, i64 4
  %229 = load i32, ptr %228, align 4, !tbaa !10
  %230 = add nsw i32 %229, 1
  store i32 %230, ptr %228, align 4, !tbaa !10
  %231 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 53)
  %232 = fpext float %.sroa.27321.0.copyload to double
  %233 = fpext float %224 to double
  %234 = fpext float %225 to double
  %235 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %232, double noundef %233, double noundef %234)
  %.pre499 = load i32, ptr %0, align 4, !tbaa !5
  br label %236

236:                                              ; preds = %220, %227
  %237 = phi i32 [ %222, %220 ], [ %.pre499, %227 ]
  %238 = add nsw i32 %237, 1
  store i32 %238, ptr %0, align 4, !tbaa !5
  %239 = getelementptr inbounds i8, ptr %2, i64 28
  %240 = load float, ptr %239, align 4, !tbaa !12
  %241 = fsub float %240, %.sroa.31325.0.copyload
  %242 = call float @llvm.fabs.f32(float %241)
  %or.cond31 = fcmp ogt float %242, 0x3E80000000000000
  br i1 %or.cond31, label %243, label %252

243:                                              ; preds = %236
  %244 = getelementptr inbounds i8, ptr %0, i64 4
  %245 = load i32, ptr %244, align 4, !tbaa !10
  %246 = add nsw i32 %245, 1
  store i32 %246, ptr %244, align 4, !tbaa !10
  %247 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 54)
  %248 = fpext float %.sroa.31325.0.copyload to double
  %249 = fpext float %240 to double
  %250 = fpext float %241 to double
  %251 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %248, double noundef %249, double noundef %250)
  %.pre500 = load i32, ptr %0, align 4, !tbaa !5
  br label %252

252:                                              ; preds = %236, %243
  %253 = phi i32 [ %238, %236 ], [ %.pre500, %243 ]
  %254 = add nsw i32 %253, 1
  store i32 %254, ptr %0, align 4, !tbaa !5
  %255 = getelementptr inbounds i8, ptr %2, i64 32
  %256 = load float, ptr %255, align 4, !tbaa !12
  %257 = fsub float %256, %.sroa.35329.0.copyload
  %258 = call float @llvm.fabs.f32(float %257)
  %or.cond33 = fcmp ogt float %258, 0x3E80000000000000
  br i1 %or.cond33, label %259, label %268

259:                                              ; preds = %252
  %260 = getelementptr inbounds i8, ptr %0, i64 4
  %261 = load i32, ptr %260, align 4, !tbaa !10
  %262 = add nsw i32 %261, 1
  store i32 %262, ptr %260, align 4, !tbaa !10
  %263 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 55)
  %264 = fpext float %.sroa.35329.0.copyload to double
  %265 = fpext float %256 to double
  %266 = fpext float %257 to double
  %267 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %264, double noundef %265, double noundef %266)
  br label %268

268:                                              ; preds = %252, %259
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %2) #8
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %4) #8
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(36) %5, ptr noundef nonnull align 4 dereferenceable(36) @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.42, i64 36, i1 false), !tbaa.struct !11
  call void @_ZL13HMM_Transpose8HMM_Mat3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat3) align 4 %4, ptr noundef nonnull byval(%union.HMM_Mat3) align 8 %5)
  %269 = load i32, ptr %0, align 4, !tbaa !5
  %270 = add nsw i32 %269, 1
  store i32 %270, ptr %0, align 4, !tbaa !5
  %271 = load float, ptr %4, align 4, !tbaa !12
  %272 = fsub float %271, %.sroa.0297.0.copyload
  %273 = call float @llvm.fabs.f32(float %272)
  %or.cond35 = fcmp ogt float %273, 0x3E80000000000000
  br i1 %or.cond35, label %274, label %283

274:                                              ; preds = %268
  %275 = getelementptr inbounds i8, ptr %0, i64 4
  %276 = load i32, ptr %275, align 4, !tbaa !10
  %277 = add nsw i32 %276, 1
  store i32 %277, ptr %275, align 4, !tbaa !10
  %278 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 60)
  %279 = fpext float %.sroa.0297.0.copyload to double
  %280 = fpext float %271 to double
  %281 = fpext float %272 to double
  %282 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %279, double noundef %280, double noundef %281)
  %.pre501 = load i32, ptr %0, align 4, !tbaa !5
  br label %283

283:                                              ; preds = %268, %274
  %284 = phi i32 [ %270, %268 ], [ %.pre501, %274 ]
  %285 = add nsw i32 %284, 1
  store i32 %285, ptr %0, align 4, !tbaa !5
  %286 = getelementptr inbounds i8, ptr %4, i64 4
  %287 = load float, ptr %286, align 4, !tbaa !12
  %288 = fsub float %287, %.sroa.7301.0.copyload
  %289 = call float @llvm.fabs.f32(float %288)
  %or.cond37 = fcmp ogt float %289, 0x3E80000000000000
  br i1 %or.cond37, label %290, label %299

290:                                              ; preds = %283
  %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 61)
  %295 = fpext float %.sroa.7301.0.copyload to double
  %296 = fpext float %287 to double
  %297 = fpext float %288 to double
  %298 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %295, double noundef %296, double noundef %297)
  %.pre502 = load i32, ptr %0, align 4, !tbaa !5
  br label %299

299:                                              ; preds = %283, %290
  %300 = phi i32 [ %285, %283 ], [ %.pre502, %290 ]
  %301 = add nsw i32 %300, 1
  store i32 %301, ptr %0, align 4, !tbaa !5
  %302 = getelementptr inbounds i8, ptr %4, i64 8
  %303 = load float, ptr %302, align 4, !tbaa !12
  %304 = fsub float %303, %.sroa.11305.0.copyload
  %305 = call float @llvm.fabs.f32(float %304)
  %or.cond39 = fcmp ogt float %305, 0x3E80000000000000
  br i1 %or.cond39, label %306, label %315

306:                                              ; preds = %299
  %307 = getelementptr inbounds i8, ptr %0, i64 4
  %308 = load i32, ptr %307, align 4, !tbaa !10
  %309 = add nsw i32 %308, 1
  store i32 %309, ptr %307, align 4, !tbaa !10
  %310 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 62)
  %311 = fpext float %.sroa.11305.0.copyload to double
  %312 = fpext float %303 to double
  %313 = fpext float %304 to double
  %314 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %311, double noundef %312, double noundef %313)
  %.pre503 = load i32, ptr %0, align 4, !tbaa !5
  br label %315

315:                                              ; preds = %299, %306
  %316 = phi i32 [ %301, %299 ], [ %.pre503, %306 ]
  %317 = add nsw i32 %316, 1
  store i32 %317, ptr %0, align 4, !tbaa !5
  %318 = getelementptr inbounds i8, ptr %4, i64 12
  %319 = load float, ptr %318, align 4, !tbaa !12
  %320 = fsub float %319, %.sroa.15309.0.copyload
  %321 = call float @llvm.fabs.f32(float %320)
  %or.cond41 = fcmp ogt float %321, 0x3E80000000000000
  br i1 %or.cond41, label %322, label %331

322:                                              ; preds = %315
  %323 = getelementptr inbounds i8, ptr %0, i64 4
  %324 = load i32, ptr %323, align 4, !tbaa !10
  %325 = add nsw i32 %324, 1
  store i32 %325, ptr %323, align 4, !tbaa !10
  %326 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 63)
  %327 = fpext float %.sroa.15309.0.copyload to double
  %328 = fpext float %319 to double
  %329 = fpext float %320 to double
  %330 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %327, double noundef %328, double noundef %329)
  %.pre504 = load i32, ptr %0, align 4, !tbaa !5
  br label %331

331:                                              ; preds = %315, %322
  %332 = phi i32 [ %317, %315 ], [ %.pre504, %322 ]
  %333 = add nsw i32 %332, 1
  store i32 %333, ptr %0, align 4, !tbaa !5
  %334 = getelementptr inbounds i8, ptr %4, i64 16
  %335 = load float, ptr %334, align 4, !tbaa !12
  %336 = fsub float %335, %.sroa.19313.0.copyload
  %337 = call float @llvm.fabs.f32(float %336)
  %or.cond43 = fcmp ogt float %337, 0x3E80000000000000
  br i1 %or.cond43, 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 64)
  %343 = fpext float %.sroa.19313.0.copyload to double
  %344 = fpext float %335 to double
  %345 = fpext float %336 to double
  %346 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %343, double noundef %344, double noundef %345)
  %.pre505 = load i32, ptr %0, align 4, !tbaa !5
  br label %347

347:                                              ; preds = %331, %338
  %348 = phi i32 [ %333, %331 ], [ %.pre505, %338 ]
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %0, align 4, !tbaa !5
  %350 = getelementptr inbounds i8, ptr %4, i64 20
  %351 = load float, ptr %350, align 4, !tbaa !12
  %352 = fsub float %351, %.sroa.23317.0.copyload
  %353 = call float @llvm.fabs.f32(float %352)
  %or.cond45 = fcmp ogt float %353, 0x3E80000000000000
  br i1 %or.cond45, 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 65)
  %359 = fpext float %.sroa.23317.0.copyload to double
  %360 = fpext float %351 to double
  %361 = fpext float %352 to double
  %362 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %359, double noundef %360, double noundef %361)
  %.pre506 = load i32, ptr %0, align 4, !tbaa !5
  br label %363

363:                                              ; preds = %347, %354
  %364 = phi i32 [ %349, %347 ], [ %.pre506, %354 ]
  %365 = add nsw i32 %364, 1
  store i32 %365, ptr %0, align 4, !tbaa !5
  %366 = getelementptr inbounds i8, ptr %4, i64 24
  %367 = load float, ptr %366, align 4, !tbaa !12
  %368 = fsub float %367, %.sroa.27321.0.copyload
  %369 = call float @llvm.fabs.f32(float %368)
  %or.cond47 = fcmp ogt float %369, 0x3E80000000000000
  br i1 %or.cond47, 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 66)
  %375 = fpext float %.sroa.27321.0.copyload to double
  %376 = fpext float %367 to double
  %377 = fpext float %368 to double
  %378 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %375, double noundef %376, double noundef %377)
  %.pre507 = load i32, ptr %0, align 4, !tbaa !5
  br label %379

379:                                              ; preds = %363, %370
  %380 = phi i32 [ %365, %363 ], [ %.pre507, %370 ]
  %381 = add nsw i32 %380, 1
  store i32 %381, ptr %0, align 4, !tbaa !5
  %382 = getelementptr inbounds i8, ptr %4, i64 28
  %383 = load float, ptr %382, align 4, !tbaa !12
  %384 = fsub float %383, %.sroa.31325.0.copyload
  %385 = call float @llvm.fabs.f32(float %384)
  %or.cond49 = fcmp ogt float %385, 0x3E80000000000000
  br i1 %or.cond49, 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 67)
  %391 = fpext float %.sroa.31325.0.copyload to double
  %392 = fpext float %383 to double
  %393 = fpext float %384 to double
  %394 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %391, double noundef %392, double noundef %393)
  %.pre508 = load i32, ptr %0, align 4, !tbaa !5
  br label %395

395:                                              ; preds = %379, %386
  %396 = phi i32 [ %381, %379 ], [ %.pre508, %386 ]
  %397 = add nsw i32 %396, 1
  store i32 %397, ptr %0, align 4, !tbaa !5
  %398 = getelementptr inbounds i8, ptr %4, i64 32
  %399 = load float, ptr %398, align 4, !tbaa !12
  %400 = fsub float %399, %.sroa.35329.0.copyload
  %401 = call float @llvm.fabs.f32(float %400)
  %or.cond51 = fcmp ogt float %401, 0x3E80000000000000
  br i1 %or.cond51, 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 68)
  %407 = fpext float %.sroa.35329.0.copyload to double
  %408 = fpext float %399 to double
  %409 = fpext float %400 to double
  %410 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %407, double noundef %408, double noundef %409)
  br label %411

411:                                              ; preds = %395, %402
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %4) #8
  %.sroa.0.0.copyload = load float, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, align 16
  %.sroa.7.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 4), align 4
  %.sroa.11.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 8), align 8
  %.sroa.15186.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 16), align 16
  %.sroa.19.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 20), align 4
  %.sroa.23.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 24), align 8
  %.sroa.27196.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 32), align 16
  %.sroa.31.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 36), align 4
  %.sroa.35.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Expect.45, i64 40), align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %6) #8
  call void @_ZL15HMM_TransposeM48HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %6, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.44)
  %412 = load i32, ptr %0, align 4, !tbaa !5
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %0, align 4, !tbaa !5
  %414 = load float, ptr %6, align 16, !tbaa !12
  %415 = fsub float %414, %.sroa.0.0.copyload
  %416 = call float @llvm.fabs.f32(float %415)
  %or.cond53 = fcmp ogt float %416, 0x3E80000000000000
  br i1 %or.cond53, label %417, label %426

417:                                              ; preds = %411
  %418 = getelementptr inbounds i8, ptr %0, i64 4
  %419 = load i32, ptr %418, align 4, !tbaa !10
  %420 = add nsw i32 %419, 1
  store i32 %420, ptr %418, align 4, !tbaa !10
  %421 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 87)
  %422 = fpext float %.sroa.0.0.copyload to double
  %423 = fpext float %414 to double
  %424 = fpext float %415 to double
  %425 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %422, double noundef %423, double noundef %424)
  %.pre509 = load i32, ptr %0, align 4, !tbaa !5
  br label %426

426:                                              ; preds = %411, %417
  %427 = phi i32 [ %413, %411 ], [ %.pre509, %417 ]
  %428 = add nsw i32 %427, 1
  store i32 %428, ptr %0, align 4, !tbaa !5
  %429 = getelementptr inbounds i8, ptr %6, i64 4
  %430 = load float, ptr %429, align 4, !tbaa !12
  %431 = fsub float %430, %.sroa.7.0.copyload
  %432 = call float @llvm.fabs.f32(float %431)
  %or.cond55 = fcmp ogt float %432, 0x3E80000000000000
  br i1 %or.cond55, label %433, label %442

433:                                              ; preds = %426
  %434 = getelementptr inbounds i8, ptr %0, i64 4
  %435 = load i32, ptr %434, align 4, !tbaa !10
  %436 = add nsw i32 %435, 1
  store i32 %436, ptr %434, align 4, !tbaa !10
  %437 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 88)
  %438 = fpext float %.sroa.7.0.copyload to double
  %439 = fpext float %430 to double
  %440 = fpext float %431 to double
  %441 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %438, double noundef %439, double noundef %440)
  %.pre510 = load i32, ptr %0, align 4, !tbaa !5
  br label %442

442:                                              ; preds = %426, %433
  %443 = phi i32 [ %428, %426 ], [ %.pre510, %433 ]
  %444 = add nsw i32 %443, 1
  store i32 %444, ptr %0, align 4, !tbaa !5
  %445 = getelementptr inbounds i8, ptr %6, i64 8
  %446 = load float, ptr %445, align 8, !tbaa !12
  %447 = fsub float %446, %.sroa.11.0.copyload
  %448 = call float @llvm.fabs.f32(float %447)
  %or.cond57 = fcmp ogt float %448, 0x3E80000000000000
  br i1 %or.cond57, label %449, label %458

449:                                              ; preds = %442
  %450 = getelementptr inbounds i8, ptr %0, i64 4
  %451 = load i32, ptr %450, align 4, !tbaa !10
  %452 = add nsw i32 %451, 1
  store i32 %452, ptr %450, align 4, !tbaa !10
  %453 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 89)
  %454 = fpext float %.sroa.11.0.copyload to double
  %455 = fpext float %446 to double
  %456 = fpext float %447 to double
  %457 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %454, double noundef %455, double noundef %456)
  %.pre511 = load i32, ptr %0, align 4, !tbaa !5
  br label %458

458:                                              ; preds = %442, %449
  %459 = phi i32 [ %444, %442 ], [ %.pre511, %449 ]
  %460 = add nsw i32 %459, 1
  store i32 %460, ptr %0, align 4, !tbaa !5
  %461 = getelementptr inbounds i8, ptr %6, i64 16
  %462 = load float, ptr %461, align 16, !tbaa !12
  %463 = fsub float %462, %.sroa.15186.0.copyload
  %464 = call float @llvm.fabs.f32(float %463)
  %or.cond59 = fcmp ogt float %464, 0x3E80000000000000
  br i1 %or.cond59, label %465, label %474

465:                                              ; preds = %458
  %466 = getelementptr inbounds i8, ptr %0, i64 4
  %467 = load i32, ptr %466, align 4, !tbaa !10
  %468 = add nsw i32 %467, 1
  store i32 %468, ptr %466, align 4, !tbaa !10
  %469 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 90)
  %470 = fpext float %.sroa.15186.0.copyload to double
  %471 = fpext float %462 to double
  %472 = fpext float %463 to double
  %473 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %470, double noundef %471, double noundef %472)
  %.pre512 = load i32, ptr %0, align 4, !tbaa !5
  br label %474

474:                                              ; preds = %458, %465
  %475 = phi i32 [ %460, %458 ], [ %.pre512, %465 ]
  %476 = add nsw i32 %475, 1
  store i32 %476, ptr %0, align 4, !tbaa !5
  %477 = getelementptr inbounds i8, ptr %6, i64 20
  %478 = load float, ptr %477, align 4, !tbaa !12
  %479 = fsub float %478, %.sroa.19.0.copyload
  %480 = call float @llvm.fabs.f32(float %479)
  %or.cond61 = fcmp ogt float %480, 0x3E80000000000000
  br i1 %or.cond61, label %481, label %490

481:                                              ; preds = %474
  %482 = getelementptr inbounds i8, ptr %0, i64 4
  %483 = load i32, ptr %482, align 4, !tbaa !10
  %484 = add nsw i32 %483, 1
  store i32 %484, ptr %482, align 4, !tbaa !10
  %485 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 91)
  %486 = fpext float %.sroa.19.0.copyload to double
  %487 = fpext float %478 to double
  %488 = fpext float %479 to double
  %489 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %486, double noundef %487, double noundef %488)
  %.pre513 = load i32, ptr %0, align 4, !tbaa !5
  br label %490

490:                                              ; preds = %474, %481
  %491 = phi i32 [ %476, %474 ], [ %.pre513, %481 ]
  %492 = add nsw i32 %491, 1
  store i32 %492, ptr %0, align 4, !tbaa !5
  %493 = getelementptr inbounds i8, ptr %6, i64 24
  %494 = load float, ptr %493, align 8, !tbaa !12
  %495 = fsub float %494, %.sroa.23.0.copyload
  %496 = call float @llvm.fabs.f32(float %495)
  %or.cond63 = fcmp ogt float %496, 0x3E80000000000000
  br i1 %or.cond63, label %497, label %506

497:                                              ; preds = %490
  %498 = getelementptr inbounds i8, ptr %0, i64 4
  %499 = load i32, ptr %498, align 4, !tbaa !10
  %500 = add nsw i32 %499, 1
  store i32 %500, ptr %498, align 4, !tbaa !10
  %501 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 92)
  %502 = fpext float %.sroa.23.0.copyload to double
  %503 = fpext float %494 to double
  %504 = fpext float %495 to double
  %505 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %502, double noundef %503, double noundef %504)
  %.pre514 = load i32, ptr %0, align 4, !tbaa !5
  br label %506

506:                                              ; preds = %490, %497
  %507 = phi i32 [ %492, %490 ], [ %.pre514, %497 ]
  %508 = add nsw i32 %507, 1
  store i32 %508, ptr %0, align 4, !tbaa !5
  %509 = getelementptr inbounds i8, ptr %6, i64 32
  %510 = load float, ptr %509, align 16, !tbaa !12
  %511 = fsub float %510, %.sroa.27196.0.copyload
  %512 = call float @llvm.fabs.f32(float %511)
  %or.cond65 = fcmp ogt float %512, 0x3E80000000000000
  br i1 %or.cond65, label %513, label %522

513:                                              ; preds = %506
  %514 = getelementptr inbounds i8, ptr %0, i64 4
  %515 = load i32, ptr %514, align 4, !tbaa !10
  %516 = add nsw i32 %515, 1
  store i32 %516, ptr %514, align 4, !tbaa !10
  %517 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 93)
  %518 = fpext float %.sroa.27196.0.copyload to double
  %519 = fpext float %510 to double
  %520 = fpext float %511 to double
  %521 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %518, double noundef %519, double noundef %520)
  %.pre515 = load i32, ptr %0, align 4, !tbaa !5
  br label %522

522:                                              ; preds = %506, %513
  %523 = phi i32 [ %508, %506 ], [ %.pre515, %513 ]
  %524 = add nsw i32 %523, 1
  store i32 %524, ptr %0, align 4, !tbaa !5
  %525 = getelementptr inbounds i8, ptr %6, i64 36
  %526 = load float, ptr %525, align 4, !tbaa !12
  %527 = fsub float %526, %.sroa.31.0.copyload
  %528 = call float @llvm.fabs.f32(float %527)
  %or.cond67 = fcmp ogt float %528, 0x3E80000000000000
  br i1 %or.cond67, label %529, label %538

529:                                              ; preds = %522
  %530 = getelementptr inbounds i8, ptr %0, i64 4
  %531 = load i32, ptr %530, align 4, !tbaa !10
  %532 = add nsw i32 %531, 1
  store i32 %532, ptr %530, align 4, !tbaa !10
  %533 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 94)
  %534 = fpext float %.sroa.31.0.copyload to double
  %535 = fpext float %526 to double
  %536 = fpext float %527 to double
  %537 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %534, double noundef %535, double noundef %536)
  %.pre516 = load i32, ptr %0, align 4, !tbaa !5
  br label %538

538:                                              ; preds = %522, %529
  %539 = phi i32 [ %524, %522 ], [ %.pre516, %529 ]
  %540 = add nsw i32 %539, 1
  store i32 %540, ptr %0, align 4, !tbaa !5
  %541 = getelementptr inbounds i8, ptr %6, i64 40
  %542 = load float, ptr %541, align 8, !tbaa !12
  %543 = fsub float %542, %.sroa.35.0.copyload
  %544 = call float @llvm.fabs.f32(float %543)
  %or.cond69 = fcmp ogt float %544, 0x3E80000000000000
  br i1 %or.cond69, label %545, label %554

545:                                              ; preds = %538
  %546 = getelementptr inbounds i8, ptr %0, i64 4
  %547 = load i32, ptr %546, align 4, !tbaa !10
  %548 = add nsw i32 %547, 1
  store i32 %548, ptr %546, align 4, !tbaa !10
  %549 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 95)
  %550 = fpext float %.sroa.35.0.copyload to double
  %551 = fpext float %542 to double
  %552 = fpext float %543 to double
  %553 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %550, double noundef %551, double noundef %552)
  br label %554

554:                                              ; preds = %538, %545
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %6) #8
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %7) #8
  call void @_ZL13HMM_Transpose8HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %7, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 @__const._Z29_hmt_test_InvMatrix_TransposeP21hmt_testresult_struct.Matrix.44)
  %555 = load i32, ptr %0, align 4, !tbaa !5
  %556 = add nsw i32 %555, 1
  store i32 %556, ptr %0, align 4, !tbaa !5
  %557 = load float, ptr %7, align 16, !tbaa !12
  %558 = fsub float %557, %.sroa.0.0.copyload
  %559 = call float @llvm.fabs.f32(float %558)
  %or.cond71 = fcmp ogt float %559, 0x3E80000000000000
  br i1 %or.cond71, label %560, label %569

560:                                              ; preds = %554
  %561 = getelementptr inbounds i8, ptr %0, i64 4
  %562 = load i32, ptr %561, align 4, !tbaa !10
  %563 = add nsw i32 %562, 1
  store i32 %563, ptr %561, align 4, !tbaa !10
  %564 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 100)
  %565 = fpext float %.sroa.0.0.copyload to double
  %566 = fpext float %557 to double
  %567 = fpext float %558 to double
  %568 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %565, double noundef %566, double noundef %567)
  %.pre517 = load i32, ptr %0, align 4, !tbaa !5
  br label %569

569:                                              ; preds = %554, %560
  %570 = phi i32 [ %556, %554 ], [ %.pre517, %560 ]
  %571 = add nsw i32 %570, 1
  store i32 %571, ptr %0, align 4, !tbaa !5
  %572 = getelementptr inbounds i8, ptr %7, i64 4
  %573 = load float, ptr %572, align 4, !tbaa !12
  %574 = fsub float %573, %.sroa.7.0.copyload
  %575 = call float @llvm.fabs.f32(float %574)
  %or.cond73 = fcmp ogt float %575, 0x3E80000000000000
  br i1 %or.cond73, label %576, label %585

576:                                              ; preds = %569
  %577 = getelementptr inbounds i8, ptr %0, i64 4
  %578 = load i32, ptr %577, align 4, !tbaa !10
  %579 = add nsw i32 %578, 1
  store i32 %579, ptr %577, align 4, !tbaa !10
  %580 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 101)
  %581 = fpext float %.sroa.7.0.copyload to double
  %582 = fpext float %573 to double
  %583 = fpext float %574 to double
  %584 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %581, double noundef %582, double noundef %583)
  %.pre518 = load i32, ptr %0, align 4, !tbaa !5
  br label %585

585:                                              ; preds = %569, %576
  %586 = phi i32 [ %571, %569 ], [ %.pre518, %576 ]
  %587 = add nsw i32 %586, 1
  store i32 %587, ptr %0, align 4, !tbaa !5
  %588 = getelementptr inbounds i8, ptr %7, i64 8
  %589 = load float, ptr %588, align 8, !tbaa !12
  %590 = fsub float %589, %.sroa.11.0.copyload
  %591 = call float @llvm.fabs.f32(float %590)
  %or.cond75 = fcmp ogt float %591, 0x3E80000000000000
  br i1 %or.cond75, label %592, label %601

592:                                              ; preds = %585
  %593 = getelementptr inbounds i8, ptr %0, i64 4
  %594 = load i32, ptr %593, align 4, !tbaa !10
  %595 = add nsw i32 %594, 1
  store i32 %595, ptr %593, align 4, !tbaa !10
  %596 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 102)
  %597 = fpext float %.sroa.11.0.copyload to double
  %598 = fpext float %589 to double
  %599 = fpext float %590 to double
  %600 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %597, double noundef %598, double noundef %599)
  %.pre519 = load i32, ptr %0, align 4, !tbaa !5
  br label %601

601:                                              ; preds = %585, %592
  %602 = phi i32 [ %587, %585 ], [ %.pre519, %592 ]
  %603 = add nsw i32 %602, 1
  store i32 %603, ptr %0, align 4, !tbaa !5
  %604 = getelementptr inbounds i8, ptr %7, i64 16
  %605 = load float, ptr %604, align 16, !tbaa !12
  %606 = fsub float %605, %.sroa.15186.0.copyload
  %607 = call float @llvm.fabs.f32(float %606)
  %or.cond77 = fcmp ogt float %607, 0x3E80000000000000
  br i1 %or.cond77, label %608, label %617

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 103)
  %613 = fpext float %.sroa.15186.0.copyload to double
  %614 = fpext float %605 to double
  %615 = fpext float %606 to double
  %616 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %613, double noundef %614, double noundef %615)
  %.pre520 = load i32, ptr %0, align 4, !tbaa !5
  br label %617

617:                                              ; preds = %601, %608
  %618 = phi i32 [ %603, %601 ], [ %.pre520, %608 ]
  %619 = add nsw i32 %618, 1
  store i32 %619, ptr %0, align 4, !tbaa !5
  %620 = getelementptr inbounds i8, ptr %7, i64 20
  %621 = load float, ptr %620, align 4, !tbaa !12
  %622 = fsub float %621, %.sroa.19.0.copyload
  %623 = call float @llvm.fabs.f32(float %622)
  %or.cond79 = fcmp ogt float %623, 0x3E80000000000000
  br i1 %or.cond79, label %624, label %633

624:                                              ; preds = %617
  %625 = getelementptr inbounds i8, ptr %0, i64 4
  %626 = load i32, ptr %625, align 4, !tbaa !10
  %627 = add nsw i32 %626, 1
  store i32 %627, ptr %625, align 4, !tbaa !10
  %628 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 104)
  %629 = fpext float %.sroa.19.0.copyload to double
  %630 = fpext float %621 to double
  %631 = fpext float %622 to double
  %632 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %629, double noundef %630, double noundef %631)
  %.pre521 = load i32, ptr %0, align 4, !tbaa !5
  br label %633

633:                                              ; preds = %617, %624
  %634 = phi i32 [ %619, %617 ], [ %.pre521, %624 ]
  %635 = add nsw i32 %634, 1
  store i32 %635, ptr %0, align 4, !tbaa !5
  %636 = getelementptr inbounds i8, ptr %7, i64 24
  %637 = load float, ptr %636, align 8, !tbaa !12
  %638 = fsub float %637, %.sroa.23.0.copyload
  %639 = call float @llvm.fabs.f32(float %638)
  %or.cond81 = fcmp ogt float %639, 0x3E80000000000000
  br i1 %or.cond81, label %640, label %649

640:                                              ; preds = %633
  %641 = getelementptr inbounds i8, ptr %0, i64 4
  %642 = load i32, ptr %641, align 4, !tbaa !10
  %643 = add nsw i32 %642, 1
  store i32 %643, ptr %641, align 4, !tbaa !10
  %644 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 105)
  %645 = fpext float %.sroa.23.0.copyload to double
  %646 = fpext float %637 to double
  %647 = fpext float %638 to double
  %648 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %645, double noundef %646, double noundef %647)
  %.pre522 = load i32, ptr %0, align 4, !tbaa !5
  br label %649

649:                                              ; preds = %633, %640
  %650 = phi i32 [ %635, %633 ], [ %.pre522, %640 ]
  %651 = add nsw i32 %650, 1
  store i32 %651, ptr %0, align 4, !tbaa !5
  %652 = getelementptr inbounds i8, ptr %7, i64 32
  %653 = load float, ptr %652, align 16, !tbaa !12
  %654 = fsub float %653, %.sroa.27196.0.copyload
  %655 = call float @llvm.fabs.f32(float %654)
  %or.cond83 = fcmp ogt float %655, 0x3E80000000000000
  br i1 %or.cond83, label %656, label %665

656:                                              ; preds = %649
  %657 = getelementptr inbounds i8, ptr %0, i64 4
  %658 = load i32, ptr %657, align 4, !tbaa !10
  %659 = add nsw i32 %658, 1
  store i32 %659, ptr %657, align 4, !tbaa !10
  %660 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 106)
  %661 = fpext float %.sroa.27196.0.copyload to double
  %662 = fpext float %653 to double
  %663 = fpext float %654 to double
  %664 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %661, double noundef %662, double noundef %663)
  %.pre523 = load i32, ptr %0, align 4, !tbaa !5
  br label %665

665:                                              ; preds = %649, %656
  %666 = phi i32 [ %651, %649 ], [ %.pre523, %656 ]
  %667 = add nsw i32 %666, 1
  store i32 %667, ptr %0, align 4, !tbaa !5
  %668 = getelementptr inbounds i8, ptr %7, i64 36
  %669 = load float, ptr %668, align 4, !tbaa !12
  %670 = fsub float %669, %.sroa.31.0.copyload
  %671 = call float @llvm.fabs.f32(float %670)
  %or.cond85 = fcmp ogt float %671, 0x3E80000000000000
  br i1 %or.cond85, label %672, label %681

672:                                              ; preds = %665
  %673 = getelementptr inbounds i8, ptr %0, i64 4
  %674 = load i32, ptr %673, align 4, !tbaa !10
  %675 = add nsw i32 %674, 1
  store i32 %675, ptr %673, align 4, !tbaa !10
  %676 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 107)
  %677 = fpext float %.sroa.31.0.copyload to double
  %678 = fpext float %669 to double
  %679 = fpext float %670 to double
  %680 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %677, double noundef %678, double noundef %679)
  %.pre524 = load i32, ptr %0, align 4, !tbaa !5
  br label %681

681:                                              ; preds = %665, %672
  %682 = phi i32 [ %667, %665 ], [ %.pre524, %672 ]
  %683 = add nsw i32 %682, 1
  store i32 %683, ptr %0, align 4, !tbaa !5
  %684 = getelementptr inbounds i8, ptr %7, i64 40
  %685 = load float, ptr %684, align 8, !tbaa !12
  %686 = fsub float %685, %.sroa.35.0.copyload
  %687 = call float @llvm.fabs.f32(float %686)
  %or.cond87 = fcmp ogt float %687, 0x3E80000000000000
  br i1 %or.cond87, label %688, label %697

688:                                              ; preds = %681
  %689 = getelementptr inbounds i8, ptr %0, i64 4
  %690 = load i32, ptr %689, align 4, !tbaa !10
  %691 = add nsw i32 %690, 1
  store i32 %691, ptr %689, align 4, !tbaa !10
  %692 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 108)
  %693 = fpext float %.sroa.35.0.copyload to double
  %694 = fpext float %685 to double
  %695 = fpext float %686 to double
  %696 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef %693, double noundef %694, double noundef %695)
  br label %697

697:                                              ; preds = %681, %688
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %7) #8
  ret void
}

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

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

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

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

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

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

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"="128" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #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 = { 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 #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { 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 = !{i64 0, i64 36, !12}
!12 = !{!8, !8, i64 0}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,InferFunctionAttrsPass,InstCombinePass,SROAPass,SimplifyCFGPass,TailCallElimPass