; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z29_hmt_test_InvMatrix_InvRotateP21hmt_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_Vec3 = type { %struct.anon.3 }
%struct.anon.3 = type { float, float, 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.50 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.62 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.63 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.64 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.65 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.68 = external hidden unnamed_addr constant [24 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis.73 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4

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

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

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

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

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct(ptr noundef %0) #5 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Vec3, align 4
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca %union.HMM_Vec3, align 4
  %6 = alloca %union.HMM_Vec3, align 4
  %7 = alloca { <2 x float>, float }, align 4
  %8 = alloca { <2 x float>, float }, align 8
  %9 = alloca { <2 x float>, float }, align 4
  %10 = alloca %union.HMM_Mat4, align 16
  %11 = alloca %union.HMM_Mat4, align 16
  %12 = alloca %union.HMM_Mat4, align 16
  %13 = alloca %union.HMM_Mat4, align 16
  %14 = alloca %union.HMM_Mat4, align 16
  %15 = alloca %union.HMM_Mat4, align 16
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca float, align 4
  %20 = alloca float, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca float, align 4
  %34 = alloca float, align 4
  %35 = alloca float, align 4
  %36 = alloca float, align 4
  %37 = alloca float, align 4
  %38 = alloca float, align 4
  %39 = alloca float, align 4
  %40 = alloca float, align 4
  %41 = alloca float, align 4
  %42 = alloca float, align 4
  %43 = alloca float, align 4
  %44 = alloca float, align 4
  %45 = alloca float, align 4
  %46 = alloca float, align 4
  %47 = alloca float, align 4
  %48 = alloca %union.HMM_Vec3, align 4
  %49 = alloca %union.HMM_Mat4, align 16
  %50 = alloca %union.HMM_Vec3, align 4
  %51 = alloca %union.HMM_Vec3, align 4
  %52 = alloca { <2 x float>, float }, align 4
  %53 = alloca { <2 x float>, float }, align 8
  %54 = alloca { <2 x float>, float }, align 4
  %55 = alloca %union.HMM_Mat4, align 16
  %56 = alloca %union.HMM_Mat4, align 16
  %57 = alloca %union.HMM_Mat4, align 16
  %58 = alloca %union.HMM_Mat4, align 16
  %59 = alloca %union.HMM_Mat4, align 16
  %60 = alloca %union.HMM_Mat4, align 16
  %61 = alloca float, align 4
  %62 = alloca float, align 4
  %63 = alloca float, align 4
  %64 = alloca float, align 4
  %65 = alloca float, align 4
  %66 = alloca float, align 4
  %67 = alloca float, align 4
  %68 = alloca float, align 4
  %69 = alloca float, align 4
  %70 = alloca float, align 4
  %71 = alloca float, align 4
  %72 = alloca float, align 4
  %73 = alloca float, align 4
  %74 = alloca float, align 4
  %75 = alloca float, align 4
  %76 = alloca float, align 4
  %77 = alloca float, align 4
  %78 = alloca float, align 4
  %79 = alloca float, align 4
  %80 = alloca float, align 4
  %81 = alloca float, align 4
  %82 = alloca float, align 4
  %83 = alloca float, align 4
  %84 = alloca float, align 4
  %85 = alloca float, align 4
  %86 = alloca float, align 4
  %87 = alloca float, align 4
  %88 = alloca float, align 4
  %89 = alloca float, align 4
  %90 = alloca float, align 4
  %91 = alloca float, align 4
  %92 = alloca float, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 12, ptr %3) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %3, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %4) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %3, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %6, i64 12, i1 false)
  %93 = getelementptr inbounds { <2 x float>, float }, ptr %7, i32 0, i32 0
  %94 = load <2 x float>, ptr %93, align 4
  %95 = getelementptr inbounds { <2 x float>, float }, ptr %7, i32 0, i32 1
  %96 = load float, ptr %95, align 4
  %97 = call { <2 x float>, float } @_ZL10HMM_NormV38HMM_Vec3(<2 x float> %94, float %96)
  %98 = getelementptr inbounds %union.HMM_Vec3, ptr %5, i32 0, i32 0
  store { <2 x float>, float } %97, ptr %8, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %98, ptr align 8 %8, i64 12, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %9, ptr align 4 %5, i64 12, i1 false)
  %99 = getelementptr inbounds { <2 x float>, float }, ptr %9, i32 0, i32 0
  %100 = load <2 x float>, ptr %99, align 4
  %101 = getelementptr inbounds { <2 x float>, float }, ptr %9, i32 0, i32 1
  %102 = load float, ptr %101, align 4
  call void @_ZL13HMM_Rotate_RHf8HMM_Vec3(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %4, float noundef 0x3FE0C15240000000, <2 x float> %100, float %102)
  call void @llvm.lifetime.start.p0(i64 64, ptr %10) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %10, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr %11) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %12, ptr align 16 %4, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL13HMM_InvRotate8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %11, ptr noundef byval(%union.HMM_Mat4) align 16 %12)
  call void @llvm.lifetime.start.p0(i64 64, ptr %13) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %14, ptr align 16 %4, i64 64, i1 false), !tbaa.struct !11
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %15, ptr align 16 %11, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %13, ptr noundef byval(%union.HMM_Mat4) align 16 %14, ptr noundef byval(%union.HMM_Mat4) align 16 %15)
  %103 = load ptr, ptr %2, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %103, i32 0, i32 0
  %105 = load i32, ptr %104, align 4, !tbaa !12
  %106 = add nsw i32 %105, 1
  store i32 %106, ptr %104, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %107 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %108 = getelementptr inbounds [4 x float], ptr %107, i64 0, i64 0
  %109 = load float, ptr %108, align 16, !tbaa !10
  store float %109, ptr %16, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %110 = load float, ptr %16, align 4, !tbaa !15
  %111 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %112 = getelementptr inbounds [4 x float], ptr %111, i64 0, i64 0
  %113 = load float, ptr %112, align 16, !tbaa !10
  %114 = fsub float %110, %113
  store float %114, ptr %17, align 4, !tbaa !15
  %115 = load float, ptr %17, align 4, !tbaa !15
  %116 = fcmp olt float %115, 0xBF50624DE0000000
  br i1 %116, label %120, label %117

117:                                              ; preds = %1
  %118 = load float, ptr %17, align 4, !tbaa !15
  %119 = fcmp olt float 0x3F50624DE0000000, %118
  br i1 %119, label %120, label %133

120:                                              ; preds = %117, %1
  %121 = load ptr, ptr %2, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %121, i32 0, i32 1
  %123 = load i32, ptr %122, align 4, !tbaa !17
  %124 = add nsw i32 %123, 1
  store i32 %124, ptr %122, align 4, !tbaa !17
  %125 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %126 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %127 = getelementptr inbounds [4 x float], ptr %126, i64 0, i64 0
  %128 = load float, ptr %127, align 16, !tbaa !10
  %129 = fpext float %128 to double
  %130 = load float, ptr %16, align 4, !tbaa !15
  %131 = fpext float %130 to double
  %132 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.50, double noundef %129, double noundef %131)
  br label %133

133:                                              ; preds = %120, %117
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  %134 = load ptr, ptr %2, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %134, i32 0, i32 0
  %136 = load i32, ptr %135, align 4, !tbaa !12
  %137 = add nsw i32 %136, 1
  store i32 %137, ptr %135, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  %138 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %139 = getelementptr inbounds [4 x float], ptr %138, i64 0, i64 1
  %140 = load float, ptr %139, align 4, !tbaa !10
  store float %140, ptr %18, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  %141 = load float, ptr %18, align 4, !tbaa !15
  %142 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %143 = getelementptr inbounds [4 x float], ptr %142, i64 0, i64 1
  %144 = load float, ptr %143, align 4, !tbaa !10
  %145 = fsub float %141, %144
  store float %145, ptr %19, align 4, !tbaa !15
  %146 = load float, ptr %19, align 4, !tbaa !15
  %147 = fcmp olt float %146, 0xBF50624DE0000000
  br i1 %147, label %151, label %148

148:                                              ; preds = %133
  %149 = load float, ptr %19, align 4, !tbaa !15
  %150 = fcmp olt float 0x3F50624DE0000000, %149
  br i1 %150, label %151, label %164

151:                                              ; preds = %148, %133
  %152 = load ptr, ptr %2, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %152, i32 0, i32 1
  %154 = load i32, ptr %153, align 4, !tbaa !17
  %155 = add nsw i32 %154, 1
  store i32 %155, ptr %153, align 4, !tbaa !17
  %156 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %157 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %158 = getelementptr inbounds [4 x float], ptr %157, i64 0, i64 1
  %159 = load float, ptr %158, align 4, !tbaa !10
  %160 = fpext float %159 to double
  %161 = load float, ptr %18, align 4, !tbaa !15
  %162 = fpext float %161 to double
  %163 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.51, double noundef %160, double noundef %162)
  br label %164

164:                                              ; preds = %151, %148
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  %165 = load ptr, ptr %2, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %165, i32 0, i32 0
  %167 = load i32, ptr %166, align 4, !tbaa !12
  %168 = add nsw i32 %167, 1
  store i32 %168, ptr %166, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  %169 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %170 = getelementptr inbounds [4 x float], ptr %169, i64 0, i64 2
  %171 = load float, ptr %170, align 8, !tbaa !10
  store float %171, ptr %20, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  %172 = load float, ptr %20, align 4, !tbaa !15
  %173 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %174 = getelementptr inbounds [4 x float], ptr %173, i64 0, i64 2
  %175 = load float, ptr %174, align 8, !tbaa !10
  %176 = fsub float %172, %175
  store float %176, ptr %21, align 4, !tbaa !15
  %177 = load float, ptr %21, align 4, !tbaa !15
  %178 = fcmp olt float %177, 0xBF50624DE0000000
  br i1 %178, label %182, label %179

179:                                              ; preds = %164
  %180 = load float, ptr %21, align 4, !tbaa !15
  %181 = fcmp olt float 0x3F50624DE0000000, %180
  br i1 %181, label %182, label %195

182:                                              ; preds = %179, %164
  %183 = load ptr, ptr %2, align 8, !tbaa !5
  %184 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %183, i32 0, i32 1
  %185 = load i32, ptr %184, align 4, !tbaa !17
  %186 = add nsw i32 %185, 1
  store i32 %186, ptr %184, align 4, !tbaa !17
  %187 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %188 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %189 = getelementptr inbounds [4 x float], ptr %188, i64 0, i64 2
  %190 = load float, ptr %189, align 8, !tbaa !10
  %191 = fpext float %190 to double
  %192 = load float, ptr %20, align 4, !tbaa !15
  %193 = fpext float %192 to double
  %194 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.52, double noundef %191, double noundef %193)
  br label %195

195:                                              ; preds = %182, %179
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  %196 = load ptr, ptr %2, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %196, i32 0, i32 0
  %198 = load i32, ptr %197, align 4, !tbaa !12
  %199 = add nsw i32 %198, 1
  store i32 %199, ptr %197, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %200 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %201 = getelementptr inbounds [4 x float], ptr %200, i64 0, i64 3
  %202 = load float, ptr %201, align 4, !tbaa !10
  store float %202, ptr %22, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %203 = load float, ptr %22, align 4, !tbaa !15
  %204 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %205 = getelementptr inbounds [4 x float], ptr %204, i64 0, i64 3
  %206 = load float, ptr %205, align 4, !tbaa !10
  %207 = fsub float %203, %206
  store float %207, ptr %23, align 4, !tbaa !15
  %208 = load float, ptr %23, align 4, !tbaa !15
  %209 = fcmp olt float %208, 0xBF50624DE0000000
  br i1 %209, label %213, label %210

210:                                              ; preds = %195
  %211 = load float, ptr %23, align 4, !tbaa !15
  %212 = fcmp olt float 0x3F50624DE0000000, %211
  br i1 %212, label %213, label %226

213:                                              ; preds = %210, %195
  %214 = load ptr, ptr %2, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %214, i32 0, i32 1
  %216 = load i32, ptr %215, align 4, !tbaa !17
  %217 = add nsw i32 %216, 1
  store i32 %217, ptr %215, align 4, !tbaa !17
  %218 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %219 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 0
  %220 = getelementptr inbounds [4 x float], ptr %219, i64 0, i64 3
  %221 = load float, ptr %220, align 4, !tbaa !10
  %222 = fpext float %221 to double
  %223 = load float, ptr %22, align 4, !tbaa !15
  %224 = fpext float %223 to double
  %225 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.53, double noundef %222, double noundef %224)
  br label %226

226:                                              ; preds = %213, %210
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  %227 = load ptr, ptr %2, align 8, !tbaa !5
  %228 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %227, i32 0, i32 0
  %229 = load i32, ptr %228, align 4, !tbaa !12
  %230 = add nsw i32 %229, 1
  store i32 %230, ptr %228, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %231 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %232 = getelementptr inbounds [4 x float], ptr %231, i64 0, i64 0
  %233 = load float, ptr %232, align 16, !tbaa !10
  store float %233, ptr %24, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  %234 = load float, ptr %24, align 4, !tbaa !15
  %235 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %236 = getelementptr inbounds [4 x float], ptr %235, i64 0, i64 0
  %237 = load float, ptr %236, align 16, !tbaa !10
  %238 = fsub float %234, %237
  store float %238, ptr %25, align 4, !tbaa !15
  %239 = load float, ptr %25, align 4, !tbaa !15
  %240 = fcmp olt float %239, 0xBF50624DE0000000
  br i1 %240, label %244, label %241

241:                                              ; preds = %226
  %242 = load float, ptr %25, align 4, !tbaa !15
  %243 = fcmp olt float 0x3F50624DE0000000, %242
  br i1 %243, label %244, label %257

244:                                              ; preds = %241, %226
  %245 = load ptr, ptr %2, align 8, !tbaa !5
  %246 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %245, i32 0, i32 1
  %247 = load i32, ptr %246, align 4, !tbaa !17
  %248 = add nsw i32 %247, 1
  store i32 %248, ptr %246, align 4, !tbaa !17
  %249 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %250 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %251 = getelementptr inbounds [4 x float], ptr %250, i64 0, i64 0
  %252 = load float, ptr %251, align 16, !tbaa !10
  %253 = fpext float %252 to double
  %254 = load float, ptr %24, align 4, !tbaa !15
  %255 = fpext float %254 to double
  %256 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.54, double noundef %253, double noundef %255)
  br label %257

257:                                              ; preds = %244, %241
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  %258 = load ptr, ptr %2, align 8, !tbaa !5
  %259 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %258, i32 0, i32 0
  %260 = load i32, ptr %259, align 4, !tbaa !12
  %261 = add nsw i32 %260, 1
  store i32 %261, ptr %259, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %262 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %263 = getelementptr inbounds [4 x float], ptr %262, i64 0, i64 1
  %264 = load float, ptr %263, align 4, !tbaa !10
  store float %264, ptr %26, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  %265 = load float, ptr %26, align 4, !tbaa !15
  %266 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %267 = getelementptr inbounds [4 x float], ptr %266, i64 0, i64 1
  %268 = load float, ptr %267, align 4, !tbaa !10
  %269 = fsub float %265, %268
  store float %269, ptr %27, align 4, !tbaa !15
  %270 = load float, ptr %27, align 4, !tbaa !15
  %271 = fcmp olt float %270, 0xBF50624DE0000000
  br i1 %271, label %275, label %272

272:                                              ; preds = %257
  %273 = load float, ptr %27, align 4, !tbaa !15
  %274 = fcmp olt float 0x3F50624DE0000000, %273
  br i1 %274, label %275, label %288

275:                                              ; preds = %272, %257
  %276 = load ptr, ptr %2, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %276, i32 0, i32 1
  %278 = load i32, ptr %277, align 4, !tbaa !17
  %279 = add nsw i32 %278, 1
  store i32 %279, ptr %277, align 4, !tbaa !17
  %280 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %281 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %282 = getelementptr inbounds [4 x float], ptr %281, i64 0, i64 1
  %283 = load float, ptr %282, align 4, !tbaa !10
  %284 = fpext float %283 to double
  %285 = load float, ptr %26, align 4, !tbaa !15
  %286 = fpext float %285 to double
  %287 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.55, double noundef %284, double noundef %286)
  br label %288

288:                                              ; preds = %275, %272
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  %289 = load ptr, ptr %2, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %289, i32 0, i32 0
  %291 = load i32, ptr %290, align 4, !tbaa !12
  %292 = add nsw i32 %291, 1
  store i32 %292, ptr %290, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %293 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %294 = getelementptr inbounds [4 x float], ptr %293, i64 0, i64 2
  %295 = load float, ptr %294, align 8, !tbaa !10
  store float %295, ptr %28, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  %296 = load float, ptr %28, align 4, !tbaa !15
  %297 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %298 = getelementptr inbounds [4 x float], ptr %297, i64 0, i64 2
  %299 = load float, ptr %298, align 8, !tbaa !10
  %300 = fsub float %296, %299
  store float %300, ptr %29, align 4, !tbaa !15
  %301 = load float, ptr %29, align 4, !tbaa !15
  %302 = fcmp olt float %301, 0xBF50624DE0000000
  br i1 %302, label %306, label %303

303:                                              ; preds = %288
  %304 = load float, ptr %29, align 4, !tbaa !15
  %305 = fcmp olt float 0x3F50624DE0000000, %304
  br i1 %305, label %306, label %319

306:                                              ; preds = %303, %288
  %307 = load ptr, ptr %2, align 8, !tbaa !5
  %308 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %307, i32 0, i32 1
  %309 = load i32, ptr %308, align 4, !tbaa !17
  %310 = add nsw i32 %309, 1
  store i32 %310, ptr %308, align 4, !tbaa !17
  %311 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %312 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %313 = getelementptr inbounds [4 x float], ptr %312, i64 0, i64 2
  %314 = load float, ptr %313, align 8, !tbaa !10
  %315 = fpext float %314 to double
  %316 = load float, ptr %28, align 4, !tbaa !15
  %317 = fpext float %316 to double
  %318 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.56, double noundef %315, double noundef %317)
  br label %319

319:                                              ; preds = %306, %303
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  %320 = load ptr, ptr %2, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %320, i32 0, i32 0
  %322 = load i32, ptr %321, align 4, !tbaa !12
  %323 = add nsw i32 %322, 1
  store i32 %323, ptr %321, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %324 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %325 = getelementptr inbounds [4 x float], ptr %324, i64 0, i64 3
  %326 = load float, ptr %325, align 4, !tbaa !10
  store float %326, ptr %30, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %327 = load float, ptr %30, align 4, !tbaa !15
  %328 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %329 = getelementptr inbounds [4 x float], ptr %328, i64 0, i64 3
  %330 = load float, ptr %329, align 4, !tbaa !10
  %331 = fsub float %327, %330
  store float %331, ptr %31, align 4, !tbaa !15
  %332 = load float, ptr %31, align 4, !tbaa !15
  %333 = fcmp olt float %332, 0xBF50624DE0000000
  br i1 %333, label %337, label %334

334:                                              ; preds = %319
  %335 = load float, ptr %31, align 4, !tbaa !15
  %336 = fcmp olt float 0x3F50624DE0000000, %335
  br i1 %336, label %337, label %350

337:                                              ; preds = %334, %319
  %338 = load ptr, ptr %2, align 8, !tbaa !5
  %339 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %338, i32 0, i32 1
  %340 = load i32, ptr %339, align 4, !tbaa !17
  %341 = add nsw i32 %340, 1
  store i32 %341, ptr %339, align 4, !tbaa !17
  %342 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %343 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 1
  %344 = getelementptr inbounds [4 x float], ptr %343, i64 0, i64 3
  %345 = load float, ptr %344, align 4, !tbaa !10
  %346 = fpext float %345 to double
  %347 = load float, ptr %30, align 4, !tbaa !15
  %348 = fpext float %347 to double
  %349 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.57, double noundef %346, double noundef %348)
  br label %350

350:                                              ; preds = %337, %334
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  %351 = load ptr, ptr %2, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %351, i32 0, i32 0
  %353 = load i32, ptr %352, align 4, !tbaa !12
  %354 = add nsw i32 %353, 1
  store i32 %354, ptr %352, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  %355 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %356 = getelementptr inbounds [4 x float], ptr %355, i64 0, i64 0
  %357 = load float, ptr %356, align 16, !tbaa !10
  store float %357, ptr %32, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  %358 = load float, ptr %32, align 4, !tbaa !15
  %359 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %360 = getelementptr inbounds [4 x float], ptr %359, i64 0, i64 0
  %361 = load float, ptr %360, align 16, !tbaa !10
  %362 = fsub float %358, %361
  store float %362, ptr %33, align 4, !tbaa !15
  %363 = load float, ptr %33, align 4, !tbaa !15
  %364 = fcmp olt float %363, 0xBF50624DE0000000
  br i1 %364, label %368, label %365

365:                                              ; preds = %350
  %366 = load float, ptr %33, align 4, !tbaa !15
  %367 = fcmp olt float 0x3F50624DE0000000, %366
  br i1 %367, label %368, label %381

368:                                              ; preds = %365, %350
  %369 = load ptr, ptr %2, align 8, !tbaa !5
  %370 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %369, i32 0, i32 1
  %371 = load i32, ptr %370, align 4, !tbaa !17
  %372 = add nsw i32 %371, 1
  store i32 %372, ptr %370, align 4, !tbaa !17
  %373 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %374 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %375 = getelementptr inbounds [4 x float], ptr %374, i64 0, i64 0
  %376 = load float, ptr %375, align 16, !tbaa !10
  %377 = fpext float %376 to double
  %378 = load float, ptr %32, align 4, !tbaa !15
  %379 = fpext float %378 to double
  %380 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.58, double noundef %377, double noundef %379)
  br label %381

381:                                              ; preds = %368, %365
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  %382 = load ptr, ptr %2, align 8, !tbaa !5
  %383 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %382, i32 0, i32 0
  %384 = load i32, ptr %383, align 4, !tbaa !12
  %385 = add nsw i32 %384, 1
  store i32 %385, ptr %383, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  %386 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %387 = getelementptr inbounds [4 x float], ptr %386, i64 0, i64 1
  %388 = load float, ptr %387, align 4, !tbaa !10
  store float %388, ptr %34, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  %389 = load float, ptr %34, align 4, !tbaa !15
  %390 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %391 = getelementptr inbounds [4 x float], ptr %390, i64 0, i64 1
  %392 = load float, ptr %391, align 4, !tbaa !10
  %393 = fsub float %389, %392
  store float %393, ptr %35, align 4, !tbaa !15
  %394 = load float, ptr %35, align 4, !tbaa !15
  %395 = fcmp olt float %394, 0xBF50624DE0000000
  br i1 %395, label %399, label %396

396:                                              ; preds = %381
  %397 = load float, ptr %35, align 4, !tbaa !15
  %398 = fcmp olt float 0x3F50624DE0000000, %397
  br i1 %398, label %399, label %412

399:                                              ; preds = %396, %381
  %400 = load ptr, ptr %2, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %400, i32 0, i32 1
  %402 = load i32, ptr %401, align 4, !tbaa !17
  %403 = add nsw i32 %402, 1
  store i32 %403, ptr %401, align 4, !tbaa !17
  %404 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %405 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %406 = getelementptr inbounds [4 x float], ptr %405, i64 0, i64 1
  %407 = load float, ptr %406, align 4, !tbaa !10
  %408 = fpext float %407 to double
  %409 = load float, ptr %34, align 4, !tbaa !15
  %410 = fpext float %409 to double
  %411 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.59, double noundef %408, double noundef %410)
  br label %412

412:                                              ; preds = %399, %396
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  %413 = load ptr, ptr %2, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %413, i32 0, i32 0
  %415 = load i32, ptr %414, align 4, !tbaa !12
  %416 = add nsw i32 %415, 1
  store i32 %416, ptr %414, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %417 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %418 = getelementptr inbounds [4 x float], ptr %417, i64 0, i64 2
  %419 = load float, ptr %418, align 8, !tbaa !10
  store float %419, ptr %36, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  %420 = load float, ptr %36, align 4, !tbaa !15
  %421 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %422 = getelementptr inbounds [4 x float], ptr %421, i64 0, i64 2
  %423 = load float, ptr %422, align 8, !tbaa !10
  %424 = fsub float %420, %423
  store float %424, ptr %37, align 4, !tbaa !15
  %425 = load float, ptr %37, align 4, !tbaa !15
  %426 = fcmp olt float %425, 0xBF50624DE0000000
  br i1 %426, label %430, label %427

427:                                              ; preds = %412
  %428 = load float, ptr %37, align 4, !tbaa !15
  %429 = fcmp olt float 0x3F50624DE0000000, %428
  br i1 %429, label %430, label %443

430:                                              ; preds = %427, %412
  %431 = load ptr, ptr %2, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %431, i32 0, i32 1
  %433 = load i32, ptr %432, align 4, !tbaa !17
  %434 = add nsw i32 %433, 1
  store i32 %434, ptr %432, align 4, !tbaa !17
  %435 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %436 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %437 = getelementptr inbounds [4 x float], ptr %436, i64 0, i64 2
  %438 = load float, ptr %437, align 8, !tbaa !10
  %439 = fpext float %438 to double
  %440 = load float, ptr %36, align 4, !tbaa !15
  %441 = fpext float %440 to double
  %442 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.60, double noundef %439, double noundef %441)
  br label %443

443:                                              ; preds = %430, %427
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  %444 = load ptr, ptr %2, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %444, i32 0, i32 0
  %446 = load i32, ptr %445, align 4, !tbaa !12
  %447 = add nsw i32 %446, 1
  store i32 %447, ptr %445, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  %448 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %449 = getelementptr inbounds [4 x float], ptr %448, i64 0, i64 3
  %450 = load float, ptr %449, align 4, !tbaa !10
  store float %450, ptr %38, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  %451 = load float, ptr %38, align 4, !tbaa !15
  %452 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %453 = getelementptr inbounds [4 x float], ptr %452, i64 0, i64 3
  %454 = load float, ptr %453, align 4, !tbaa !10
  %455 = fsub float %451, %454
  store float %455, ptr %39, align 4, !tbaa !15
  %456 = load float, ptr %39, align 4, !tbaa !15
  %457 = fcmp olt float %456, 0xBF50624DE0000000
  br i1 %457, label %461, label %458

458:                                              ; preds = %443
  %459 = load float, ptr %39, align 4, !tbaa !15
  %460 = fcmp olt float 0x3F50624DE0000000, %459
  br i1 %460, label %461, label %474

461:                                              ; preds = %458, %443
  %462 = load ptr, ptr %2, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %462, i32 0, i32 1
  %464 = load i32, ptr %463, align 4, !tbaa !17
  %465 = add nsw i32 %464, 1
  store i32 %465, ptr %463, align 4, !tbaa !17
  %466 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %467 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 2
  %468 = getelementptr inbounds [4 x float], ptr %467, i64 0, i64 3
  %469 = load float, ptr %468, align 4, !tbaa !10
  %470 = fpext float %469 to double
  %471 = load float, ptr %38, align 4, !tbaa !15
  %472 = fpext float %471 to double
  %473 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.61, double noundef %470, double noundef %472)
  br label %474

474:                                              ; preds = %461, %458
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  %475 = load ptr, ptr %2, align 8, !tbaa !5
  %476 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %475, i32 0, i32 0
  %477 = load i32, ptr %476, align 4, !tbaa !12
  %478 = add nsw i32 %477, 1
  store i32 %478, ptr %476, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #6
  %479 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %480 = getelementptr inbounds [4 x float], ptr %479, i64 0, i64 0
  %481 = load float, ptr %480, align 16, !tbaa !10
  store float %481, ptr %40, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  %482 = load float, ptr %40, align 4, !tbaa !15
  %483 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %484 = getelementptr inbounds [4 x float], ptr %483, i64 0, i64 0
  %485 = load float, ptr %484, align 16, !tbaa !10
  %486 = fsub float %482, %485
  store float %486, ptr %41, align 4, !tbaa !15
  %487 = load float, ptr %41, align 4, !tbaa !15
  %488 = fcmp olt float %487, 0xBF50624DE0000000
  br i1 %488, label %492, label %489

489:                                              ; preds = %474
  %490 = load float, ptr %41, align 4, !tbaa !15
  %491 = fcmp olt float 0x3F50624DE0000000, %490
  br i1 %491, label %492, label %505

492:                                              ; preds = %489, %474
  %493 = load ptr, ptr %2, align 8, !tbaa !5
  %494 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %493, i32 0, i32 1
  %495 = load i32, ptr %494, align 4, !tbaa !17
  %496 = add nsw i32 %495, 1
  store i32 %496, ptr %494, align 4, !tbaa !17
  %497 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %498 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %499 = getelementptr inbounds [4 x float], ptr %498, i64 0, i64 0
  %500 = load float, ptr %499, align 16, !tbaa !10
  %501 = fpext float %500 to double
  %502 = load float, ptr %40, align 4, !tbaa !15
  %503 = fpext float %502 to double
  %504 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.62, double noundef %501, double noundef %503)
  br label %505

505:                                              ; preds = %492, %489
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #6
  %506 = load ptr, ptr %2, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %506, i32 0, i32 0
  %508 = load i32, ptr %507, align 4, !tbaa !12
  %509 = add nsw i32 %508, 1
  store i32 %509, ptr %507, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  %510 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %511 = getelementptr inbounds [4 x float], ptr %510, i64 0, i64 1
  %512 = load float, ptr %511, align 4, !tbaa !10
  store float %512, ptr %42, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %513 = load float, ptr %42, align 4, !tbaa !15
  %514 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %515 = getelementptr inbounds [4 x float], ptr %514, i64 0, i64 1
  %516 = load float, ptr %515, align 4, !tbaa !10
  %517 = fsub float %513, %516
  store float %517, ptr %43, align 4, !tbaa !15
  %518 = load float, ptr %43, align 4, !tbaa !15
  %519 = fcmp olt float %518, 0xBF50624DE0000000
  br i1 %519, label %523, label %520

520:                                              ; preds = %505
  %521 = load float, ptr %43, align 4, !tbaa !15
  %522 = fcmp olt float 0x3F50624DE0000000, %521
  br i1 %522, label %523, label %536

523:                                              ; preds = %520, %505
  %524 = load ptr, ptr %2, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %524, i32 0, i32 1
  %526 = load i32, ptr %525, align 4, !tbaa !17
  %527 = add nsw i32 %526, 1
  store i32 %527, ptr %525, align 4, !tbaa !17
  %528 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %529 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %530 = getelementptr inbounds [4 x float], ptr %529, i64 0, i64 1
  %531 = load float, ptr %530, align 4, !tbaa !10
  %532 = fpext float %531 to double
  %533 = load float, ptr %42, align 4, !tbaa !15
  %534 = fpext float %533 to double
  %535 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.63, double noundef %532, double noundef %534)
  br label %536

536:                                              ; preds = %523, %520
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  %537 = load ptr, ptr %2, align 8, !tbaa !5
  %538 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %537, i32 0, i32 0
  %539 = load i32, ptr %538, align 4, !tbaa !12
  %540 = add nsw i32 %539, 1
  store i32 %540, ptr %538, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  %541 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %542 = getelementptr inbounds [4 x float], ptr %541, i64 0, i64 2
  %543 = load float, ptr %542, align 8, !tbaa !10
  store float %543, ptr %44, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %544 = load float, ptr %44, align 4, !tbaa !15
  %545 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %546 = getelementptr inbounds [4 x float], ptr %545, i64 0, i64 2
  %547 = load float, ptr %546, align 8, !tbaa !10
  %548 = fsub float %544, %547
  store float %548, ptr %45, align 4, !tbaa !15
  %549 = load float, ptr %45, align 4, !tbaa !15
  %550 = fcmp olt float %549, 0xBF50624DE0000000
  br i1 %550, label %554, label %551

551:                                              ; preds = %536
  %552 = load float, ptr %45, align 4, !tbaa !15
  %553 = fcmp olt float 0x3F50624DE0000000, %552
  br i1 %553, label %554, label %567

554:                                              ; preds = %551, %536
  %555 = load ptr, ptr %2, align 8, !tbaa !5
  %556 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %555, i32 0, i32 1
  %557 = load i32, ptr %556, align 4, !tbaa !17
  %558 = add nsw i32 %557, 1
  store i32 %558, ptr %556, align 4, !tbaa !17
  %559 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %560 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %561 = getelementptr inbounds [4 x float], ptr %560, i64 0, i64 2
  %562 = load float, ptr %561, align 8, !tbaa !10
  %563 = fpext float %562 to double
  %564 = load float, ptr %44, align 4, !tbaa !15
  %565 = fpext float %564 to double
  %566 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.64, double noundef %563, double noundef %565)
  br label %567

567:                                              ; preds = %554, %551
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  %568 = load ptr, ptr %2, align 8, !tbaa !5
  %569 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %568, i32 0, i32 0
  %570 = load i32, ptr %569, align 4, !tbaa !12
  %571 = add nsw i32 %570, 1
  store i32 %571, ptr %569, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %572 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %573 = getelementptr inbounds [4 x float], ptr %572, i64 0, i64 3
  %574 = load float, ptr %573, align 4, !tbaa !10
  store float %574, ptr %46, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #6
  %575 = load float, ptr %46, align 4, !tbaa !15
  %576 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %577 = getelementptr inbounds [4 x float], ptr %576, i64 0, i64 3
  %578 = load float, ptr %577, align 4, !tbaa !10
  %579 = fsub float %575, %578
  store float %579, ptr %47, align 4, !tbaa !15
  %580 = load float, ptr %47, align 4, !tbaa !15
  %581 = fcmp olt float %580, 0xBF50624DE0000000
  br i1 %581, label %585, label %582

582:                                              ; preds = %567
  %583 = load float, ptr %47, align 4, !tbaa !15
  %584 = fcmp olt float 0x3F50624DE0000000, %583
  br i1 %584, label %585, label %598

585:                                              ; preds = %582, %567
  %586 = load ptr, ptr %2, align 8, !tbaa !5
  %587 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %586, i32 0, i32 1
  %588 = load i32, ptr %587, align 4, !tbaa !17
  %589 = add nsw i32 %588, 1
  store i32 %589, ptr %587, align 4, !tbaa !17
  %590 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 329)
  %591 = getelementptr inbounds [4 x [4 x float]], ptr %10, i64 0, i64 3
  %592 = getelementptr inbounds [4 x float], ptr %591, i64 0, i64 3
  %593 = load float, ptr %592, align 4, !tbaa !10
  %594 = fpext float %593 to double
  %595 = load float, ptr %46, align 4, !tbaa !15
  %596 = fpext float %595 to double
  %597 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.65, double noundef %594, double noundef %596)
  br label %598

598:                                              ; preds = %585, %582
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %3) #6
  call void @llvm.lifetime.start.p0(i64 12, ptr %48) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis.73, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %49) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %51, ptr align 4 %48, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %52, ptr align 4 %51, i64 12, i1 false)
  %599 = getelementptr inbounds { <2 x float>, float }, ptr %52, i32 0, i32 0
  %600 = load <2 x float>, ptr %599, align 4
  %601 = getelementptr inbounds { <2 x float>, float }, ptr %52, i32 0, i32 1
  %602 = load float, ptr %601, align 4
  %603 = call { <2 x float>, float } @_ZL10HMM_NormV38HMM_Vec3(<2 x float> %600, float %602)
  %604 = getelementptr inbounds %union.HMM_Vec3, ptr %50, i32 0, i32 0
  store { <2 x float>, float } %603, ptr %53, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %604, ptr align 8 %53, i64 12, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %54, ptr align 4 %50, i64 12, i1 false)
  %605 = getelementptr inbounds { <2 x float>, float }, ptr %54, i32 0, i32 0
  %606 = load <2 x float>, ptr %605, align 4
  %607 = getelementptr inbounds { <2 x float>, float }, ptr %54, i32 0, i32 1
  %608 = load float, ptr %607, align 4
  call void @_ZL13HMM_Rotate_LHf8HMM_Vec3(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %49, float noundef 0x3FE0C15240000000, <2 x float> %606, float %608)
  call void @llvm.lifetime.start.p0(i64 64, ptr %55) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %55, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr %56) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %57, ptr align 16 %49, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL13HMM_InvRotate8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %56, ptr noundef byval(%union.HMM_Mat4) align 16 %57)
  call void @llvm.lifetime.start.p0(i64 64, ptr %58) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %59, ptr align 16 %49, i64 64, i1 false), !tbaa.struct !11
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %60, ptr align 16 %56, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %58, ptr noundef byval(%union.HMM_Mat4) align 16 %59, ptr noundef byval(%union.HMM_Mat4) align 16 %60)
  %609 = load ptr, ptr %2, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %609, i32 0, i32 0
  %611 = load i32, ptr %610, align 4, !tbaa !12
  %612 = add nsw i32 %611, 1
  store i32 %612, ptr %610, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #6
  %613 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 0
  %614 = getelementptr inbounds [4 x float], ptr %613, i64 0, i64 0
  %615 = load float, ptr %614, align 16, !tbaa !10
  store float %615, ptr %61, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #6
  %616 = load float, ptr %61, align 4, !tbaa !15
  %617 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %618 = getelementptr inbounds [4 x float], ptr %617, i64 0, i64 0
  %619 = load float, ptr %618, align 16, !tbaa !10
  %620 = fsub float %616, %619
  store float %620, ptr %62, align 4, !tbaa !15
  %621 = load float, ptr %62, align 4, !tbaa !15
  %622 = fcmp olt float %621, 0xBF50624DE0000000
  br i1 %622, label %626, label %623

623:                                              ; preds = %598
  %624 = load float, ptr %62, align 4, !tbaa !15
  %625 = fcmp olt float 0x3F50624DE0000000, %624
  br i1 %625, label %626, label %639

626:                                              ; preds = %623, %598
  %627 = load ptr, ptr %2, align 8, !tbaa !5
  %628 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %627, i32 0, i32 1
  %629 = load i32, ptr %628, align 4, !tbaa !17
  %630 = add nsw i32 %629, 1
  store i32 %630, ptr %628, align 4, !tbaa !17
  %631 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %632 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %633 = getelementptr inbounds [4 x float], ptr %632, i64 0, i64 0
  %634 = load float, ptr %633, align 16, !tbaa !10
  %635 = fpext float %634 to double
  %636 = load float, ptr %61, align 4, !tbaa !15
  %637 = fpext float %636 to double
  %638 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.50, double noundef %635, double noundef %637)
  br label %639

639:                                              ; preds = %626, %623
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #6
  %640 = load ptr, ptr %2, align 8, !tbaa !5
  %641 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %640, i32 0, i32 0
  %642 = load i32, ptr %641, align 4, !tbaa !12
  %643 = add nsw i32 %642, 1
  store i32 %643, ptr %641, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #6
  %644 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 0
  %645 = getelementptr inbounds [4 x float], ptr %644, i64 0, i64 1
  %646 = load float, ptr %645, align 4, !tbaa !10
  store float %646, ptr %63, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #6
  %647 = load float, ptr %63, align 4, !tbaa !15
  %648 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %649 = getelementptr inbounds [4 x float], ptr %648, i64 0, i64 1
  %650 = load float, ptr %649, align 4, !tbaa !10
  %651 = fsub float %647, %650
  store float %651, ptr %64, align 4, !tbaa !15
  %652 = load float, ptr %64, align 4, !tbaa !15
  %653 = fcmp olt float %652, 0xBF50624DE0000000
  br i1 %653, label %657, label %654

654:                                              ; preds = %639
  %655 = load float, ptr %64, align 4, !tbaa !15
  %656 = fcmp olt float 0x3F50624DE0000000, %655
  br i1 %656, label %657, label %670

657:                                              ; preds = %654, %639
  %658 = load ptr, ptr %2, align 8, !tbaa !5
  %659 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %658, i32 0, i32 1
  %660 = load i32, ptr %659, align 4, !tbaa !17
  %661 = add nsw i32 %660, 1
  store i32 %661, ptr %659, align 4, !tbaa !17
  %662 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %663 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %664 = getelementptr inbounds [4 x float], ptr %663, i64 0, i64 1
  %665 = load float, ptr %664, align 4, !tbaa !10
  %666 = fpext float %665 to double
  %667 = load float, ptr %63, align 4, !tbaa !15
  %668 = fpext float %667 to double
  %669 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.51, double noundef %666, double noundef %668)
  br label %670

670:                                              ; preds = %657, %654
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  %671 = load ptr, ptr %2, align 8, !tbaa !5
  %672 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %671, i32 0, i32 0
  %673 = load i32, ptr %672, align 4, !tbaa !12
  %674 = add nsw i32 %673, 1
  store i32 %674, ptr %672, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #6
  %675 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 0
  %676 = getelementptr inbounds [4 x float], ptr %675, i64 0, i64 2
  %677 = load float, ptr %676, align 8, !tbaa !10
  store float %677, ptr %65, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #6
  %678 = load float, ptr %65, align 4, !tbaa !15
  %679 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %680 = getelementptr inbounds [4 x float], ptr %679, i64 0, i64 2
  %681 = load float, ptr %680, align 8, !tbaa !10
  %682 = fsub float %678, %681
  store float %682, ptr %66, align 4, !tbaa !15
  %683 = load float, ptr %66, align 4, !tbaa !15
  %684 = fcmp olt float %683, 0xBF50624DE0000000
  br i1 %684, label %688, label %685

685:                                              ; preds = %670
  %686 = load float, ptr %66, align 4, !tbaa !15
  %687 = fcmp olt float 0x3F50624DE0000000, %686
  br i1 %687, label %688, label %701

688:                                              ; preds = %685, %670
  %689 = load ptr, ptr %2, align 8, !tbaa !5
  %690 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %689, i32 0, i32 1
  %691 = load i32, ptr %690, align 4, !tbaa !17
  %692 = add nsw i32 %691, 1
  store i32 %692, ptr %690, align 4, !tbaa !17
  %693 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %694 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %695 = getelementptr inbounds [4 x float], ptr %694, i64 0, i64 2
  %696 = load float, ptr %695, align 8, !tbaa !10
  %697 = fpext float %696 to double
  %698 = load float, ptr %65, align 4, !tbaa !15
  %699 = fpext float %698 to double
  %700 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.52, double noundef %697, double noundef %699)
  br label %701

701:                                              ; preds = %688, %685
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #6
  %702 = load ptr, ptr %2, align 8, !tbaa !5
  %703 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %702, i32 0, i32 0
  %704 = load i32, ptr %703, align 4, !tbaa !12
  %705 = add nsw i32 %704, 1
  store i32 %705, ptr %703, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #6
  %706 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 0
  %707 = getelementptr inbounds [4 x float], ptr %706, i64 0, i64 3
  %708 = load float, ptr %707, align 4, !tbaa !10
  store float %708, ptr %67, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #6
  %709 = load float, ptr %67, align 4, !tbaa !15
  %710 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %711 = getelementptr inbounds [4 x float], ptr %710, i64 0, i64 3
  %712 = load float, ptr %711, align 4, !tbaa !10
  %713 = fsub float %709, %712
  store float %713, ptr %68, align 4, !tbaa !15
  %714 = load float, ptr %68, align 4, !tbaa !15
  %715 = fcmp olt float %714, 0xBF50624DE0000000
  br i1 %715, label %719, label %716

716:                                              ; preds = %701
  %717 = load float, ptr %68, align 4, !tbaa !15
  %718 = fcmp olt float 0x3F50624DE0000000, %717
  br i1 %718, label %719, label %732

719:                                              ; preds = %716, %701
  %720 = load ptr, ptr %2, align 8, !tbaa !5
  %721 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %720, i32 0, i32 1
  %722 = load i32, ptr %721, align 4, !tbaa !17
  %723 = add nsw i32 %722, 1
  store i32 %723, ptr %721, align 4, !tbaa !17
  %724 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %725 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 0
  %726 = getelementptr inbounds [4 x float], ptr %725, i64 0, i64 3
  %727 = load float, ptr %726, align 4, !tbaa !10
  %728 = fpext float %727 to double
  %729 = load float, ptr %67, align 4, !tbaa !15
  %730 = fpext float %729 to double
  %731 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.53, double noundef %728, double noundef %730)
  br label %732

732:                                              ; preds = %719, %716
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #6
  %733 = load ptr, ptr %2, align 8, !tbaa !5
  %734 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %733, i32 0, i32 0
  %735 = load i32, ptr %734, align 4, !tbaa !12
  %736 = add nsw i32 %735, 1
  store i32 %736, ptr %734, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #6
  %737 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 1
  %738 = getelementptr inbounds [4 x float], ptr %737, i64 0, i64 0
  %739 = load float, ptr %738, align 16, !tbaa !10
  store float %739, ptr %69, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #6
  %740 = load float, ptr %69, align 4, !tbaa !15
  %741 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %742 = getelementptr inbounds [4 x float], ptr %741, i64 0, i64 0
  %743 = load float, ptr %742, align 16, !tbaa !10
  %744 = fsub float %740, %743
  store float %744, ptr %70, align 4, !tbaa !15
  %745 = load float, ptr %70, align 4, !tbaa !15
  %746 = fcmp olt float %745, 0xBF50624DE0000000
  br i1 %746, label %750, label %747

747:                                              ; preds = %732
  %748 = load float, ptr %70, align 4, !tbaa !15
  %749 = fcmp olt float 0x3F50624DE0000000, %748
  br i1 %749, label %750, label %763

750:                                              ; preds = %747, %732
  %751 = load ptr, ptr %2, align 8, !tbaa !5
  %752 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %751, i32 0, i32 1
  %753 = load i32, ptr %752, align 4, !tbaa !17
  %754 = add nsw i32 %753, 1
  store i32 %754, ptr %752, align 4, !tbaa !17
  %755 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %756 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %757 = getelementptr inbounds [4 x float], ptr %756, i64 0, i64 0
  %758 = load float, ptr %757, align 16, !tbaa !10
  %759 = fpext float %758 to double
  %760 = load float, ptr %69, align 4, !tbaa !15
  %761 = fpext float %760 to double
  %762 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.54, double noundef %759, double noundef %761)
  br label %763

763:                                              ; preds = %750, %747
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #6
  %764 = load ptr, ptr %2, align 8, !tbaa !5
  %765 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %764, i32 0, i32 0
  %766 = load i32, ptr %765, align 4, !tbaa !12
  %767 = add nsw i32 %766, 1
  store i32 %767, ptr %765, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #6
  %768 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 1
  %769 = getelementptr inbounds [4 x float], ptr %768, i64 0, i64 1
  %770 = load float, ptr %769, align 4, !tbaa !10
  store float %770, ptr %71, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #6
  %771 = load float, ptr %71, align 4, !tbaa !15
  %772 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %773 = getelementptr inbounds [4 x float], ptr %772, i64 0, i64 1
  %774 = load float, ptr %773, align 4, !tbaa !10
  %775 = fsub float %771, %774
  store float %775, ptr %72, align 4, !tbaa !15
  %776 = load float, ptr %72, align 4, !tbaa !15
  %777 = fcmp olt float %776, 0xBF50624DE0000000
  br i1 %777, label %781, label %778

778:                                              ; preds = %763
  %779 = load float, ptr %72, align 4, !tbaa !15
  %780 = fcmp olt float 0x3F50624DE0000000, %779
  br i1 %780, label %781, label %794

781:                                              ; preds = %778, %763
  %782 = load ptr, ptr %2, align 8, !tbaa !5
  %783 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %782, i32 0, i32 1
  %784 = load i32, ptr %783, align 4, !tbaa !17
  %785 = add nsw i32 %784, 1
  store i32 %785, ptr %783, align 4, !tbaa !17
  %786 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %787 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %788 = getelementptr inbounds [4 x float], ptr %787, i64 0, i64 1
  %789 = load float, ptr %788, align 4, !tbaa !10
  %790 = fpext float %789 to double
  %791 = load float, ptr %71, align 4, !tbaa !15
  %792 = fpext float %791 to double
  %793 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.55, double noundef %790, double noundef %792)
  br label %794

794:                                              ; preds = %781, %778
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #6
  %795 = load ptr, ptr %2, align 8, !tbaa !5
  %796 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %795, i32 0, i32 0
  %797 = load i32, ptr %796, align 4, !tbaa !12
  %798 = add nsw i32 %797, 1
  store i32 %798, ptr %796, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #6
  %799 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 1
  %800 = getelementptr inbounds [4 x float], ptr %799, i64 0, i64 2
  %801 = load float, ptr %800, align 8, !tbaa !10
  store float %801, ptr %73, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #6
  %802 = load float, ptr %73, align 4, !tbaa !15
  %803 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %804 = getelementptr inbounds [4 x float], ptr %803, i64 0, i64 2
  %805 = load float, ptr %804, align 8, !tbaa !10
  %806 = fsub float %802, %805
  store float %806, ptr %74, align 4, !tbaa !15
  %807 = load float, ptr %74, align 4, !tbaa !15
  %808 = fcmp olt float %807, 0xBF50624DE0000000
  br i1 %808, label %812, label %809

809:                                              ; preds = %794
  %810 = load float, ptr %74, align 4, !tbaa !15
  %811 = fcmp olt float 0x3F50624DE0000000, %810
  br i1 %811, label %812, label %825

812:                                              ; preds = %809, %794
  %813 = load ptr, ptr %2, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %813, i32 0, i32 1
  %815 = load i32, ptr %814, align 4, !tbaa !17
  %816 = add nsw i32 %815, 1
  store i32 %816, ptr %814, align 4, !tbaa !17
  %817 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %818 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %819 = getelementptr inbounds [4 x float], ptr %818, i64 0, i64 2
  %820 = load float, ptr %819, align 8, !tbaa !10
  %821 = fpext float %820 to double
  %822 = load float, ptr %73, align 4, !tbaa !15
  %823 = fpext float %822 to double
  %824 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.56, double noundef %821, double noundef %823)
  br label %825

825:                                              ; preds = %812, %809
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #6
  %826 = load ptr, ptr %2, align 8, !tbaa !5
  %827 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %826, i32 0, i32 0
  %828 = load i32, ptr %827, align 4, !tbaa !12
  %829 = add nsw i32 %828, 1
  store i32 %829, ptr %827, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #6
  %830 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 1
  %831 = getelementptr inbounds [4 x float], ptr %830, i64 0, i64 3
  %832 = load float, ptr %831, align 4, !tbaa !10
  store float %832, ptr %75, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #6
  %833 = load float, ptr %75, align 4, !tbaa !15
  %834 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %835 = getelementptr inbounds [4 x float], ptr %834, i64 0, i64 3
  %836 = load float, ptr %835, align 4, !tbaa !10
  %837 = fsub float %833, %836
  store float %837, ptr %76, align 4, !tbaa !15
  %838 = load float, ptr %76, align 4, !tbaa !15
  %839 = fcmp olt float %838, 0xBF50624DE0000000
  br i1 %839, label %843, label %840

840:                                              ; preds = %825
  %841 = load float, ptr %76, align 4, !tbaa !15
  %842 = fcmp olt float 0x3F50624DE0000000, %841
  br i1 %842, label %843, label %856

843:                                              ; preds = %840, %825
  %844 = load ptr, ptr %2, align 8, !tbaa !5
  %845 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %844, i32 0, i32 1
  %846 = load i32, ptr %845, align 4, !tbaa !17
  %847 = add nsw i32 %846, 1
  store i32 %847, ptr %845, align 4, !tbaa !17
  %848 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %849 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 1
  %850 = getelementptr inbounds [4 x float], ptr %849, i64 0, i64 3
  %851 = load float, ptr %850, align 4, !tbaa !10
  %852 = fpext float %851 to double
  %853 = load float, ptr %75, align 4, !tbaa !15
  %854 = fpext float %853 to double
  %855 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.57, double noundef %852, double noundef %854)
  br label %856

856:                                              ; preds = %843, %840
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #6
  %857 = load ptr, ptr %2, align 8, !tbaa !5
  %858 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %857, i32 0, i32 0
  %859 = load i32, ptr %858, align 4, !tbaa !12
  %860 = add nsw i32 %859, 1
  store i32 %860, ptr %858, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #6
  %861 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 2
  %862 = getelementptr inbounds [4 x float], ptr %861, i64 0, i64 0
  %863 = load float, ptr %862, align 16, !tbaa !10
  store float %863, ptr %77, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #6
  %864 = load float, ptr %77, align 4, !tbaa !15
  %865 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %866 = getelementptr inbounds [4 x float], ptr %865, i64 0, i64 0
  %867 = load float, ptr %866, align 16, !tbaa !10
  %868 = fsub float %864, %867
  store float %868, ptr %78, align 4, !tbaa !15
  %869 = load float, ptr %78, align 4, !tbaa !15
  %870 = fcmp olt float %869, 0xBF50624DE0000000
  br i1 %870, label %874, label %871

871:                                              ; preds = %856
  %872 = load float, ptr %78, align 4, !tbaa !15
  %873 = fcmp olt float 0x3F50624DE0000000, %872
  br i1 %873, label %874, label %887

874:                                              ; preds = %871, %856
  %875 = load ptr, ptr %2, align 8, !tbaa !5
  %876 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %875, i32 0, i32 1
  %877 = load i32, ptr %876, align 4, !tbaa !17
  %878 = add nsw i32 %877, 1
  store i32 %878, ptr %876, align 4, !tbaa !17
  %879 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %880 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %881 = getelementptr inbounds [4 x float], ptr %880, i64 0, i64 0
  %882 = load float, ptr %881, align 16, !tbaa !10
  %883 = fpext float %882 to double
  %884 = load float, ptr %77, align 4, !tbaa !15
  %885 = fpext float %884 to double
  %886 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.58, double noundef %883, double noundef %885)
  br label %887

887:                                              ; preds = %874, %871
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #6
  %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 !12
  %891 = add nsw i32 %890, 1
  store i32 %891, ptr %889, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #6
  %892 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 2
  %893 = getelementptr inbounds [4 x float], ptr %892, i64 0, i64 1
  %894 = load float, ptr %893, align 4, !tbaa !10
  store float %894, ptr %79, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #6
  %895 = load float, ptr %79, align 4, !tbaa !15
  %896 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %897 = getelementptr inbounds [4 x float], ptr %896, i64 0, i64 1
  %898 = load float, ptr %897, align 4, !tbaa !10
  %899 = fsub float %895, %898
  store float %899, ptr %80, align 4, !tbaa !15
  %900 = load float, ptr %80, align 4, !tbaa !15
  %901 = fcmp olt float %900, 0xBF50624DE0000000
  br i1 %901, label %905, label %902

902:                                              ; preds = %887
  %903 = load float, ptr %80, align 4, !tbaa !15
  %904 = fcmp olt float 0x3F50624DE0000000, %903
  br i1 %904, label %905, label %918

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 !17
  %909 = add nsw i32 %908, 1
  store i32 %909, ptr %907, align 4, !tbaa !17
  %910 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %911 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %912 = getelementptr inbounds [4 x float], ptr %911, i64 0, i64 1
  %913 = load float, ptr %912, align 4, !tbaa !10
  %914 = fpext float %913 to double
  %915 = load float, ptr %79, align 4, !tbaa !15
  %916 = fpext float %915 to double
  %917 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.59, double noundef %914, double noundef %916)
  br label %918

918:                                              ; preds = %905, %902
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #6
  %919 = load ptr, ptr %2, align 8, !tbaa !5
  %920 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %919, i32 0, i32 0
  %921 = load i32, ptr %920, align 4, !tbaa !12
  %922 = add nsw i32 %921, 1
  store i32 %922, ptr %920, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #6
  %923 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 2
  %924 = getelementptr inbounds [4 x float], ptr %923, i64 0, i64 2
  %925 = load float, ptr %924, align 8, !tbaa !10
  store float %925, ptr %81, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #6
  %926 = load float, ptr %81, align 4, !tbaa !15
  %927 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %928 = getelementptr inbounds [4 x float], ptr %927, i64 0, i64 2
  %929 = load float, ptr %928, align 8, !tbaa !10
  %930 = fsub float %926, %929
  store float %930, ptr %82, align 4, !tbaa !15
  %931 = load float, ptr %82, align 4, !tbaa !15
  %932 = fcmp olt float %931, 0xBF50624DE0000000
  br i1 %932, label %936, label %933

933:                                              ; preds = %918
  %934 = load float, ptr %82, align 4, !tbaa !15
  %935 = fcmp olt float 0x3F50624DE0000000, %934
  br i1 %935, label %936, label %949

936:                                              ; preds = %933, %918
  %937 = load ptr, ptr %2, align 8, !tbaa !5
  %938 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %937, i32 0, i32 1
  %939 = load i32, ptr %938, align 4, !tbaa !17
  %940 = add nsw i32 %939, 1
  store i32 %940, ptr %938, align 4, !tbaa !17
  %941 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %942 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %943 = getelementptr inbounds [4 x float], ptr %942, i64 0, i64 2
  %944 = load float, ptr %943, align 8, !tbaa !10
  %945 = fpext float %944 to double
  %946 = load float, ptr %81, align 4, !tbaa !15
  %947 = fpext float %946 to double
  %948 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.60, double noundef %945, double noundef %947)
  br label %949

949:                                              ; preds = %936, %933
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #6
  %950 = load ptr, ptr %2, align 8, !tbaa !5
  %951 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %950, i32 0, i32 0
  %952 = load i32, ptr %951, align 4, !tbaa !12
  %953 = add nsw i32 %952, 1
  store i32 %953, ptr %951, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #6
  %954 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 2
  %955 = getelementptr inbounds [4 x float], ptr %954, i64 0, i64 3
  %956 = load float, ptr %955, align 4, !tbaa !10
  store float %956, ptr %83, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #6
  %957 = load float, ptr %83, align 4, !tbaa !15
  %958 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %959 = getelementptr inbounds [4 x float], ptr %958, i64 0, i64 3
  %960 = load float, ptr %959, align 4, !tbaa !10
  %961 = fsub float %957, %960
  store float %961, ptr %84, align 4, !tbaa !15
  %962 = load float, ptr %84, align 4, !tbaa !15
  %963 = fcmp olt float %962, 0xBF50624DE0000000
  br i1 %963, label %967, label %964

964:                                              ; preds = %949
  %965 = load float, ptr %84, align 4, !tbaa !15
  %966 = fcmp olt float 0x3F50624DE0000000, %965
  br i1 %966, label %967, label %980

967:                                              ; preds = %964, %949
  %968 = load ptr, ptr %2, align 8, !tbaa !5
  %969 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %968, i32 0, i32 1
  %970 = load i32, ptr %969, align 4, !tbaa !17
  %971 = add nsw i32 %970, 1
  store i32 %971, ptr %969, align 4, !tbaa !17
  %972 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %973 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 2
  %974 = getelementptr inbounds [4 x float], ptr %973, i64 0, i64 3
  %975 = load float, ptr %974, align 4, !tbaa !10
  %976 = fpext float %975 to double
  %977 = load float, ptr %83, align 4, !tbaa !15
  %978 = fpext float %977 to double
  %979 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.61, double noundef %976, double noundef %978)
  br label %980

980:                                              ; preds = %967, %964
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  %981 = load ptr, ptr %2, align 8, !tbaa !5
  %982 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %981, i32 0, i32 0
  %983 = load i32, ptr %982, align 4, !tbaa !12
  %984 = add nsw i32 %983, 1
  store i32 %984, ptr %982, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #6
  %985 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 3
  %986 = getelementptr inbounds [4 x float], ptr %985, i64 0, i64 0
  %987 = load float, ptr %986, align 16, !tbaa !10
  store float %987, ptr %85, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #6
  %988 = load float, ptr %85, align 4, !tbaa !15
  %989 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %990 = getelementptr inbounds [4 x float], ptr %989, i64 0, i64 0
  %991 = load float, ptr %990, align 16, !tbaa !10
  %992 = fsub float %988, %991
  store float %992, ptr %86, align 4, !tbaa !15
  %993 = load float, ptr %86, align 4, !tbaa !15
  %994 = fcmp olt float %993, 0xBF50624DE0000000
  br i1 %994, label %998, label %995

995:                                              ; preds = %980
  %996 = load float, ptr %86, align 4, !tbaa !15
  %997 = fcmp olt float 0x3F50624DE0000000, %996
  br i1 %997, label %998, label %1011

998:                                              ; preds = %995, %980
  %999 = load ptr, ptr %2, align 8, !tbaa !5
  %1000 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %999, i32 0, i32 1
  %1001 = load i32, ptr %1000, align 4, !tbaa !17
  %1002 = add nsw i32 %1001, 1
  store i32 %1002, ptr %1000, align 4, !tbaa !17
  %1003 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %1004 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1005 = getelementptr inbounds [4 x float], ptr %1004, i64 0, i64 0
  %1006 = load float, ptr %1005, align 16, !tbaa !10
  %1007 = fpext float %1006 to double
  %1008 = load float, ptr %85, align 4, !tbaa !15
  %1009 = fpext float %1008 to double
  %1010 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.62, double noundef %1007, double noundef %1009)
  br label %1011

1011:                                             ; preds = %998, %995
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #6
  %1012 = load ptr, ptr %2, align 8, !tbaa !5
  %1013 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1012, i32 0, i32 0
  %1014 = load i32, ptr %1013, align 4, !tbaa !12
  %1015 = add nsw i32 %1014, 1
  store i32 %1015, ptr %1013, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #6
  %1016 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 3
  %1017 = getelementptr inbounds [4 x float], ptr %1016, i64 0, i64 1
  %1018 = load float, ptr %1017, align 4, !tbaa !10
  store float %1018, ptr %87, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #6
  %1019 = load float, ptr %87, align 4, !tbaa !15
  %1020 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1021 = getelementptr inbounds [4 x float], ptr %1020, i64 0, i64 1
  %1022 = load float, ptr %1021, align 4, !tbaa !10
  %1023 = fsub float %1019, %1022
  store float %1023, ptr %88, align 4, !tbaa !15
  %1024 = load float, ptr %88, align 4, !tbaa !15
  %1025 = fcmp olt float %1024, 0xBF50624DE0000000
  br i1 %1025, label %1029, label %1026

1026:                                             ; preds = %1011
  %1027 = load float, ptr %88, align 4, !tbaa !15
  %1028 = fcmp olt float 0x3F50624DE0000000, %1027
  br i1 %1028, label %1029, label %1042

1029:                                             ; preds = %1026, %1011
  %1030 = load ptr, ptr %2, align 8, !tbaa !5
  %1031 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1030, i32 0, i32 1
  %1032 = load i32, ptr %1031, align 4, !tbaa !17
  %1033 = add nsw i32 %1032, 1
  store i32 %1033, ptr %1031, align 4, !tbaa !17
  %1034 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %1035 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1036 = getelementptr inbounds [4 x float], ptr %1035, i64 0, i64 1
  %1037 = load float, ptr %1036, align 4, !tbaa !10
  %1038 = fpext float %1037 to double
  %1039 = load float, ptr %87, align 4, !tbaa !15
  %1040 = fpext float %1039 to double
  %1041 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.63, double noundef %1038, double noundef %1040)
  br label %1042

1042:                                             ; preds = %1029, %1026
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #6
  %1043 = load ptr, ptr %2, align 8, !tbaa !5
  %1044 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1043, i32 0, i32 0
  %1045 = load i32, ptr %1044, align 4, !tbaa !12
  %1046 = add nsw i32 %1045, 1
  store i32 %1046, ptr %1044, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %89) #6
  %1047 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 3
  %1048 = getelementptr inbounds [4 x float], ptr %1047, i64 0, i64 2
  %1049 = load float, ptr %1048, align 8, !tbaa !10
  store float %1049, ptr %89, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #6
  %1050 = load float, ptr %89, align 4, !tbaa !15
  %1051 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1052 = getelementptr inbounds [4 x float], ptr %1051, i64 0, i64 2
  %1053 = load float, ptr %1052, align 8, !tbaa !10
  %1054 = fsub float %1050, %1053
  store float %1054, ptr %90, align 4, !tbaa !15
  %1055 = load float, ptr %90, align 4, !tbaa !15
  %1056 = fcmp olt float %1055, 0xBF50624DE0000000
  br i1 %1056, label %1060, label %1057

1057:                                             ; preds = %1042
  %1058 = load float, ptr %90, align 4, !tbaa !15
  %1059 = fcmp olt float 0x3F50624DE0000000, %1058
  br i1 %1059, label %1060, label %1073

1060:                                             ; preds = %1057, %1042
  %1061 = load ptr, ptr %2, align 8, !tbaa !5
  %1062 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1061, i32 0, i32 1
  %1063 = load i32, ptr %1062, align 4, !tbaa !17
  %1064 = add nsw i32 %1063, 1
  store i32 %1064, ptr %1062, align 4, !tbaa !17
  %1065 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %1066 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1067 = getelementptr inbounds [4 x float], ptr %1066, i64 0, i64 2
  %1068 = load float, ptr %1067, align 8, !tbaa !10
  %1069 = fpext float %1068 to double
  %1070 = load float, ptr %89, align 4, !tbaa !15
  %1071 = fpext float %1070 to double
  %1072 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.64, double noundef %1069, double noundef %1071)
  br label %1073

1073:                                             ; preds = %1060, %1057
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %89) #6
  %1074 = load ptr, ptr %2, align 8, !tbaa !5
  %1075 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1074, i32 0, i32 0
  %1076 = load i32, ptr %1075, align 4, !tbaa !12
  %1077 = add nsw i32 %1076, 1
  store i32 %1077, ptr %1075, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #6
  %1078 = getelementptr inbounds [4 x [4 x float]], ptr %58, i64 0, i64 3
  %1079 = getelementptr inbounds [4 x float], ptr %1078, i64 0, i64 3
  %1080 = load float, ptr %1079, align 4, !tbaa !10
  store float %1080, ptr %91, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #6
  %1081 = load float, ptr %91, align 4, !tbaa !15
  %1082 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1083 = getelementptr inbounds [4 x float], ptr %1082, i64 0, i64 3
  %1084 = load float, ptr %1083, align 4, !tbaa !10
  %1085 = fsub float %1081, %1084
  store float %1085, ptr %92, align 4, !tbaa !15
  %1086 = load float, ptr %92, align 4, !tbaa !15
  %1087 = fcmp olt float %1086, 0xBF50624DE0000000
  br i1 %1087, label %1091, label %1088

1088:                                             ; preds = %1073
  %1089 = load float, ptr %92, align 4, !tbaa !15
  %1090 = fcmp olt float 0x3F50624DE0000000, %1089
  br i1 %1090, label %1091, label %1104

1091:                                             ; preds = %1088, %1073
  %1092 = load ptr, ptr %2, align 8, !tbaa !5
  %1093 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1092, i32 0, i32 1
  %1094 = load i32, ptr %1093, align 4, !tbaa !17
  %1095 = add nsw i32 %1094, 1
  store i32 %1095, ptr %1093, align 4, !tbaa !17
  %1096 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 337)
  %1097 = getelementptr inbounds [4 x [4 x float]], ptr %55, i64 0, i64 3
  %1098 = getelementptr inbounds [4 x float], ptr %1097, i64 0, i64 3
  %1099 = load float, ptr %1098, align 4, !tbaa !10
  %1100 = fpext float %1099 to double
  %1101 = load float, ptr %91, align 4, !tbaa !15
  %1102 = fpext float %1101 to double
  %1103 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.65, double noundef %1100, double noundef %1102)
  br label %1104

1104:                                             ; preds = %1091, %1088
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %58) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %48) #6
  ret void
}

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

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

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

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


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%union.HMM_Vec3 = type { %struct.anon.3 }
%struct.anon.3 = type { float, float, 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.50 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.62 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.63 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.64 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.65 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.68 = external hidden unnamed_addr constant [24 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis.73 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4

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

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

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

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #4 {
  %2 = alloca %union.HMM_Mat4, align 16
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca %union.HMM_Mat4, align 16
  %6 = alloca %union.HMM_Mat4, align 16
  %7 = alloca %union.HMM_Mat4, align 16
  %8 = alloca %union.HMM_Mat4, align 16
  %9 = alloca %union.HMM_Mat4, align 16
  %.sroa.0212.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis, align 4
  %.sroa.4213.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis, i64 8), align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #6
  %10 = tail call { <2 x float>, float } @_ZL10HMM_NormV38HMM_Vec3(<2 x float> %.sroa.0212.0.copyload, float %.sroa.4213.0.copyload)
  %.fca.0.extract202 = extractvalue { <2 x float>, float } %10, 0
  %.fca.1.extract203 = extractvalue { <2 x float>, float } %10, 1
  call void @_ZL13HMM_Rotate_RHf8HMM_Vec3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, float noundef 0x3FE0C15240000000, <2 x float> %.fca.0.extract202, float %.fca.1.extract203)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #6
  call void @_ZL13HMM_InvRotate8HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #6
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %5, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4)
  %11 = load i32, ptr %0, align 4, !tbaa !5
  %12 = add nsw i32 %11, 1
  store i32 %12, ptr %0, align 4, !tbaa !5
  %13 = load float, ptr %5, align 16, !tbaa !10
  %14 = load float, ptr %3, align 16, !tbaa !10
  %15 = fsub float %13, %14
  %16 = call float @llvm.fabs.f32(float %15)
  %or.cond = fcmp ogt float %16, 0x3F50624DE0000000
  br i1 %or.cond, label %17, label %26

17:                                               ; preds = %1
  %18 = getelementptr inbounds i8, ptr %0, i64 4
  %19 = load i32, ptr %18, align 4, !tbaa !11
  %20 = add nsw i32 %19, 1
  store i32 %20, ptr %18, align 4, !tbaa !11
  %21 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %22 = load float, ptr %3, align 16, !tbaa !10
  %23 = fpext float %22 to double
  %24 = fpext float %13 to double
  %25 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.50, double noundef %23, double noundef %24)
  %.pre = load i32, ptr %0, align 4, !tbaa !5
  br label %26

26:                                               ; preds = %1, %17
  %27 = phi i32 [ %12, %1 ], [ %.pre, %17 ]
  %28 = add nsw i32 %27, 1
  store i32 %28, ptr %0, align 4, !tbaa !5
  %29 = getelementptr inbounds i8, ptr %5, i64 4
  %30 = load float, ptr %29, align 4, !tbaa !10
  %31 = getelementptr inbounds i8, ptr %3, i64 4
  %32 = load float, ptr %31, align 4, !tbaa !10
  %33 = fsub float %30, %32
  %34 = call float @llvm.fabs.f32(float %33)
  %or.cond3 = fcmp ogt float %34, 0x3F50624DE0000000
  br i1 %or.cond3, label %35, label %44

35:                                               ; preds = %26
  %36 = getelementptr inbounds i8, ptr %0, i64 4
  %37 = load i32, ptr %36, align 4, !tbaa !11
  %38 = add nsw i32 %37, 1
  store i32 %38, ptr %36, align 4, !tbaa !11
  %39 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %40 = load float, ptr %31, align 4, !tbaa !10
  %41 = fpext float %40 to double
  %42 = fpext float %30 to double
  %43 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.51, double noundef %41, double noundef %42)
  %.pre278 = load i32, ptr %0, align 4, !tbaa !5
  br label %44

44:                                               ; preds = %26, %35
  %45 = phi i32 [ %28, %26 ], [ %.pre278, %35 ]
  %46 = add nsw i32 %45, 1
  store i32 %46, ptr %0, align 4, !tbaa !5
  %47 = getelementptr inbounds i8, ptr %5, i64 8
  %48 = load float, ptr %47, align 8, !tbaa !10
  %49 = getelementptr inbounds i8, ptr %3, i64 8
  %50 = load float, ptr %49, align 8, !tbaa !10
  %51 = fsub float %48, %50
  %52 = call float @llvm.fabs.f32(float %51)
  %or.cond5 = fcmp ogt float %52, 0x3F50624DE0000000
  br i1 %or.cond5, label %53, label %62

53:                                               ; preds = %44
  %54 = getelementptr inbounds i8, ptr %0, i64 4
  %55 = load i32, ptr %54, align 4, !tbaa !11
  %56 = add nsw i32 %55, 1
  store i32 %56, ptr %54, align 4, !tbaa !11
  %57 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %58 = load float, ptr %49, align 8, !tbaa !10
  %59 = fpext float %58 to double
  %60 = fpext float %48 to double
  %61 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.52, double noundef %59, double noundef %60)
  %.pre279 = load i32, ptr %0, align 4, !tbaa !5
  br label %62

62:                                               ; preds = %44, %53
  %63 = phi i32 [ %46, %44 ], [ %.pre279, %53 ]
  %64 = add nsw i32 %63, 1
  store i32 %64, ptr %0, align 4, !tbaa !5
  %65 = getelementptr inbounds i8, ptr %5, i64 12
  %66 = load float, ptr %65, align 4, !tbaa !10
  %67 = getelementptr inbounds i8, ptr %3, i64 12
  %68 = load float, ptr %67, align 4, !tbaa !10
  %69 = fsub float %66, %68
  %70 = call float @llvm.fabs.f32(float %69)
  %or.cond7 = fcmp ogt float %70, 0x3F50624DE0000000
  br i1 %or.cond7, label %71, label %80

71:                                               ; preds = %62
  %72 = getelementptr inbounds i8, ptr %0, i64 4
  %73 = load i32, ptr %72, align 4, !tbaa !11
  %74 = add nsw i32 %73, 1
  store i32 %74, ptr %72, align 4, !tbaa !11
  %75 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %76 = load float, ptr %67, align 4, !tbaa !10
  %77 = fpext float %76 to double
  %78 = fpext float %66 to double
  %79 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.53, double noundef %77, double noundef %78)
  %.pre280 = load i32, ptr %0, align 4, !tbaa !5
  br label %80

80:                                               ; preds = %62, %71
  %81 = phi i32 [ %64, %62 ], [ %.pre280, %71 ]
  %82 = add nsw i32 %81, 1
  store i32 %82, ptr %0, align 4, !tbaa !5
  %83 = getelementptr inbounds i8, ptr %5, i64 16
  %84 = load float, ptr %83, align 16, !tbaa !10
  %85 = getelementptr inbounds i8, ptr %3, i64 16
  %86 = load float, ptr %85, align 16, !tbaa !10
  %87 = fsub float %84, %86
  %88 = call float @llvm.fabs.f32(float %87)
  %or.cond9 = fcmp ogt float %88, 0x3F50624DE0000000
  br i1 %or.cond9, label %89, label %98

89:                                               ; preds = %80
  %90 = getelementptr inbounds i8, ptr %0, i64 4
  %91 = load i32, ptr %90, align 4, !tbaa !11
  %92 = add nsw i32 %91, 1
  store i32 %92, ptr %90, align 4, !tbaa !11
  %93 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %94 = load float, ptr %85, align 16, !tbaa !10
  %95 = fpext float %94 to double
  %96 = fpext float %84 to double
  %97 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.54, double noundef %95, double noundef %96)
  %.pre281 = load i32, ptr %0, align 4, !tbaa !5
  br label %98

98:                                               ; preds = %80, %89
  %99 = phi i32 [ %82, %80 ], [ %.pre281, %89 ]
  %100 = add nsw i32 %99, 1
  store i32 %100, ptr %0, align 4, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %5, i64 20
  %102 = load float, ptr %101, align 4, !tbaa !10
  %103 = getelementptr inbounds i8, ptr %3, i64 20
  %104 = load float, ptr %103, align 4, !tbaa !10
  %105 = fsub float %102, %104
  %106 = call float @llvm.fabs.f32(float %105)
  %or.cond11 = fcmp ogt float %106, 0x3F50624DE0000000
  br i1 %or.cond11, label %107, label %116

107:                                              ; preds = %98
  %108 = getelementptr inbounds i8, ptr %0, i64 4
  %109 = load i32, ptr %108, align 4, !tbaa !11
  %110 = add nsw i32 %109, 1
  store i32 %110, ptr %108, align 4, !tbaa !11
  %111 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %112 = load float, ptr %103, align 4, !tbaa !10
  %113 = fpext float %112 to double
  %114 = fpext float %102 to double
  %115 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.55, double noundef %113, double noundef %114)
  %.pre282 = load i32, ptr %0, align 4, !tbaa !5
  br label %116

116:                                              ; preds = %98, %107
  %117 = phi i32 [ %100, %98 ], [ %.pre282, %107 ]
  %118 = add nsw i32 %117, 1
  store i32 %118, ptr %0, align 4, !tbaa !5
  %119 = getelementptr inbounds i8, ptr %5, i64 24
  %120 = load float, ptr %119, align 8, !tbaa !10
  %121 = getelementptr inbounds i8, ptr %3, i64 24
  %122 = load float, ptr %121, align 8, !tbaa !10
  %123 = fsub float %120, %122
  %124 = call float @llvm.fabs.f32(float %123)
  %or.cond13 = fcmp ogt float %124, 0x3F50624DE0000000
  br i1 %or.cond13, label %125, label %134

125:                                              ; preds = %116
  %126 = getelementptr inbounds i8, ptr %0, i64 4
  %127 = load i32, ptr %126, align 4, !tbaa !11
  %128 = add nsw i32 %127, 1
  store i32 %128, ptr %126, align 4, !tbaa !11
  %129 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %130 = load float, ptr %121, align 8, !tbaa !10
  %131 = fpext float %130 to double
  %132 = fpext float %120 to double
  %133 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.56, double noundef %131, double noundef %132)
  %.pre283 = load i32, ptr %0, align 4, !tbaa !5
  br label %134

134:                                              ; preds = %116, %125
  %135 = phi i32 [ %118, %116 ], [ %.pre283, %125 ]
  %136 = add nsw i32 %135, 1
  store i32 %136, ptr %0, align 4, !tbaa !5
  %137 = getelementptr inbounds i8, ptr %5, i64 28
  %138 = load float, ptr %137, align 4, !tbaa !10
  %139 = getelementptr inbounds i8, ptr %3, i64 28
  %140 = load float, ptr %139, align 4, !tbaa !10
  %141 = fsub float %138, %140
  %142 = call float @llvm.fabs.f32(float %141)
  %or.cond15 = fcmp ogt float %142, 0x3F50624DE0000000
  br i1 %or.cond15, label %143, label %152

143:                                              ; preds = %134
  %144 = getelementptr inbounds i8, ptr %0, i64 4
  %145 = load i32, ptr %144, align 4, !tbaa !11
  %146 = add nsw i32 %145, 1
  store i32 %146, ptr %144, align 4, !tbaa !11
  %147 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %148 = load float, ptr %139, align 4, !tbaa !10
  %149 = fpext float %148 to double
  %150 = fpext float %138 to double
  %151 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.57, double noundef %149, double noundef %150)
  %.pre284 = load i32, ptr %0, align 4, !tbaa !5
  br label %152

152:                                              ; preds = %134, %143
  %153 = phi i32 [ %136, %134 ], [ %.pre284, %143 ]
  %154 = add nsw i32 %153, 1
  store i32 %154, ptr %0, align 4, !tbaa !5
  %155 = getelementptr inbounds i8, ptr %5, i64 32
  %156 = load float, ptr %155, align 16, !tbaa !10
  %157 = getelementptr inbounds i8, ptr %3, i64 32
  %158 = load float, ptr %157, align 16, !tbaa !10
  %159 = fsub float %156, %158
  %160 = call float @llvm.fabs.f32(float %159)
  %or.cond17 = fcmp ogt float %160, 0x3F50624DE0000000
  br i1 %or.cond17, label %161, label %170

161:                                              ; preds = %152
  %162 = getelementptr inbounds i8, ptr %0, i64 4
  %163 = load i32, ptr %162, align 4, !tbaa !11
  %164 = add nsw i32 %163, 1
  store i32 %164, ptr %162, align 4, !tbaa !11
  %165 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %166 = load float, ptr %157, align 16, !tbaa !10
  %167 = fpext float %166 to double
  %168 = fpext float %156 to double
  %169 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.58, double noundef %167, double noundef %168)
  %.pre285 = load i32, ptr %0, align 4, !tbaa !5
  br label %170

170:                                              ; preds = %152, %161
  %171 = phi i32 [ %154, %152 ], [ %.pre285, %161 ]
  %172 = add nsw i32 %171, 1
  store i32 %172, ptr %0, align 4, !tbaa !5
  %173 = getelementptr inbounds i8, ptr %5, i64 36
  %174 = load float, ptr %173, align 4, !tbaa !10
  %175 = getelementptr inbounds i8, ptr %3, i64 36
  %176 = load float, ptr %175, align 4, !tbaa !10
  %177 = fsub float %174, %176
  %178 = call float @llvm.fabs.f32(float %177)
  %or.cond19 = fcmp ogt float %178, 0x3F50624DE0000000
  br i1 %or.cond19, label %179, label %188

179:                                              ; preds = %170
  %180 = getelementptr inbounds i8, ptr %0, i64 4
  %181 = load i32, ptr %180, align 4, !tbaa !11
  %182 = add nsw i32 %181, 1
  store i32 %182, ptr %180, align 4, !tbaa !11
  %183 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %184 = load float, ptr %175, align 4, !tbaa !10
  %185 = fpext float %184 to double
  %186 = fpext float %174 to double
  %187 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.59, double noundef %185, double noundef %186)
  %.pre286 = load i32, ptr %0, align 4, !tbaa !5
  br label %188

188:                                              ; preds = %170, %179
  %189 = phi i32 [ %172, %170 ], [ %.pre286, %179 ]
  %190 = add nsw i32 %189, 1
  store i32 %190, ptr %0, align 4, !tbaa !5
  %191 = getelementptr inbounds i8, ptr %5, i64 40
  %192 = load float, ptr %191, align 8, !tbaa !10
  %193 = getelementptr inbounds i8, ptr %3, i64 40
  %194 = load float, ptr %193, align 8, !tbaa !10
  %195 = fsub float %192, %194
  %196 = call float @llvm.fabs.f32(float %195)
  %or.cond21 = fcmp ogt float %196, 0x3F50624DE0000000
  br i1 %or.cond21, label %197, label %206

197:                                              ; preds = %188
  %198 = getelementptr inbounds i8, ptr %0, i64 4
  %199 = load i32, ptr %198, align 4, !tbaa !11
  %200 = add nsw i32 %199, 1
  store i32 %200, ptr %198, align 4, !tbaa !11
  %201 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %202 = load float, ptr %193, align 8, !tbaa !10
  %203 = fpext float %202 to double
  %204 = fpext float %192 to double
  %205 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.60, double noundef %203, double noundef %204)
  %.pre287 = load i32, ptr %0, align 4, !tbaa !5
  br label %206

206:                                              ; preds = %188, %197
  %207 = phi i32 [ %190, %188 ], [ %.pre287, %197 ]
  %208 = add nsw i32 %207, 1
  store i32 %208, ptr %0, align 4, !tbaa !5
  %209 = getelementptr inbounds i8, ptr %5, i64 44
  %210 = load float, ptr %209, align 4, !tbaa !10
  %211 = getelementptr inbounds i8, ptr %3, i64 44
  %212 = load float, ptr %211, align 4, !tbaa !10
  %213 = fsub float %210, %212
  %214 = call float @llvm.fabs.f32(float %213)
  %or.cond23 = fcmp ogt float %214, 0x3F50624DE0000000
  br i1 %or.cond23, label %215, label %224

215:                                              ; preds = %206
  %216 = getelementptr inbounds i8, ptr %0, i64 4
  %217 = load i32, ptr %216, align 4, !tbaa !11
  %218 = add nsw i32 %217, 1
  store i32 %218, ptr %216, align 4, !tbaa !11
  %219 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %220 = load float, ptr %211, align 4, !tbaa !10
  %221 = fpext float %220 to double
  %222 = fpext float %210 to double
  %223 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.61, double noundef %221, double noundef %222)
  %.pre288 = load i32, ptr %0, align 4, !tbaa !5
  br label %224

224:                                              ; preds = %206, %215
  %225 = phi i32 [ %208, %206 ], [ %.pre288, %215 ]
  %226 = add nsw i32 %225, 1
  store i32 %226, ptr %0, align 4, !tbaa !5
  %227 = getelementptr inbounds i8, ptr %5, i64 48
  %228 = load float, ptr %227, align 16, !tbaa !10
  %229 = getelementptr inbounds i8, ptr %3, i64 48
  %230 = load float, ptr %229, align 16, !tbaa !10
  %231 = fsub float %228, %230
  %232 = call float @llvm.fabs.f32(float %231)
  %or.cond25 = fcmp ogt float %232, 0x3F50624DE0000000
  br i1 %or.cond25, label %233, label %242

233:                                              ; preds = %224
  %234 = getelementptr inbounds i8, ptr %0, i64 4
  %235 = load i32, ptr %234, align 4, !tbaa !11
  %236 = add nsw i32 %235, 1
  store i32 %236, ptr %234, align 4, !tbaa !11
  %237 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %238 = load float, ptr %229, align 16, !tbaa !10
  %239 = fpext float %238 to double
  %240 = fpext float %228 to double
  %241 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.62, double noundef %239, double noundef %240)
  %.pre289 = load i32, ptr %0, align 4, !tbaa !5
  br label %242

242:                                              ; preds = %224, %233
  %243 = phi i32 [ %226, %224 ], [ %.pre289, %233 ]
  %244 = add nsw i32 %243, 1
  store i32 %244, ptr %0, align 4, !tbaa !5
  %245 = getelementptr inbounds i8, ptr %5, i64 52
  %246 = load float, ptr %245, align 4, !tbaa !10
  %247 = getelementptr inbounds i8, ptr %3, i64 52
  %248 = load float, ptr %247, align 4, !tbaa !10
  %249 = fsub float %246, %248
  %250 = call float @llvm.fabs.f32(float %249)
  %or.cond27 = fcmp ogt float %250, 0x3F50624DE0000000
  br i1 %or.cond27, label %251, label %260

251:                                              ; preds = %242
  %252 = getelementptr inbounds i8, ptr %0, i64 4
  %253 = load i32, ptr %252, align 4, !tbaa !11
  %254 = add nsw i32 %253, 1
  store i32 %254, ptr %252, align 4, !tbaa !11
  %255 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %256 = load float, ptr %247, align 4, !tbaa !10
  %257 = fpext float %256 to double
  %258 = fpext float %246 to double
  %259 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.63, double noundef %257, double noundef %258)
  %.pre290 = load i32, ptr %0, align 4, !tbaa !5
  br label %260

260:                                              ; preds = %242, %251
  %261 = phi i32 [ %244, %242 ], [ %.pre290, %251 ]
  %262 = add nsw i32 %261, 1
  store i32 %262, ptr %0, align 4, !tbaa !5
  %263 = getelementptr inbounds i8, ptr %5, i64 56
  %264 = load float, ptr %263, align 8, !tbaa !10
  %265 = getelementptr inbounds i8, ptr %3, i64 56
  %266 = load float, ptr %265, align 8, !tbaa !10
  %267 = fsub float %264, %266
  %268 = call float @llvm.fabs.f32(float %267)
  %or.cond29 = fcmp ogt float %268, 0x3F50624DE0000000
  br i1 %or.cond29, label %269, label %278

269:                                              ; preds = %260
  %270 = getelementptr inbounds i8, ptr %0, i64 4
  %271 = load i32, ptr %270, align 4, !tbaa !11
  %272 = add nsw i32 %271, 1
  store i32 %272, ptr %270, align 4, !tbaa !11
  %273 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %274 = load float, ptr %265, align 8, !tbaa !10
  %275 = fpext float %274 to double
  %276 = fpext float %264 to double
  %277 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.64, double noundef %275, double noundef %276)
  %.pre291 = load i32, ptr %0, align 4, !tbaa !5
  br label %278

278:                                              ; preds = %260, %269
  %279 = phi i32 [ %262, %260 ], [ %.pre291, %269 ]
  %280 = add nsw i32 %279, 1
  store i32 %280, ptr %0, align 4, !tbaa !5
  %281 = getelementptr inbounds i8, ptr %5, i64 60
  %282 = load float, ptr %281, align 4, !tbaa !10
  %283 = getelementptr inbounds i8, ptr %3, i64 60
  %284 = load float, ptr %283, align 4, !tbaa !10
  %285 = fsub float %282, %284
  %286 = call float @llvm.fabs.f32(float %285)
  %or.cond31 = fcmp ogt float %286, 0x3F50624DE0000000
  br i1 %or.cond31, label %287, label %296

287:                                              ; preds = %278
  %288 = getelementptr inbounds i8, ptr %0, i64 4
  %289 = load i32, ptr %288, align 4, !tbaa !11
  %290 = add nsw i32 %289, 1
  store i32 %290, ptr %288, align 4, !tbaa !11
  %291 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 329)
  %292 = load float, ptr %283, align 4, !tbaa !10
  %293 = fpext float %292 to double
  %294 = fpext float %282 to double
  %295 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.65, double noundef %293, double noundef %294)
  br label %296

296:                                              ; preds = %278, %287
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #6
  %.sroa.0135.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis.73, align 4
  %.sroa.4.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvRotateP21hmt_testresult_struct.Axis.73, i64 8), align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %6) #6
  %297 = call { <2 x float>, float } @_ZL10HMM_NormV38HMM_Vec3(<2 x float> %.sroa.0135.0.copyload, float %.sroa.4.0.copyload)
  %.fca.0.extract = extractvalue { <2 x float>, float } %297, 0
  %.fca.1.extract = extractvalue { <2 x float>, float } %297, 1
  call void @_ZL13HMM_Rotate_LHf8HMM_Vec3(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %6, float noundef 0x3FE0C15240000000, <2 x float> %.fca.0.extract, float %.fca.1.extract)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %7) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %7, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %8) #6
  call void @_ZL13HMM_InvRotate8HMM_Mat4(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %8, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %6)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %9) #6
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %9, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %6, ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %8)
  %298 = load i32, ptr %0, align 4, !tbaa !5
  %299 = add nsw i32 %298, 1
  store i32 %299, ptr %0, align 4, !tbaa !5
  %300 = load float, ptr %9, align 16, !tbaa !10
  %301 = load float, ptr %7, align 16, !tbaa !10
  %302 = fsub float %300, %301
  %303 = call float @llvm.fabs.f32(float %302)
  %or.cond33 = fcmp ogt float %303, 0x3F50624DE0000000
  br i1 %or.cond33, label %304, label %313

304:                                              ; preds = %296
  %305 = getelementptr inbounds i8, ptr %0, i64 4
  %306 = load i32, ptr %305, align 4, !tbaa !11
  %307 = add nsw i32 %306, 1
  store i32 %307, ptr %305, align 4, !tbaa !11
  %308 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %309 = load float, ptr %7, align 16, !tbaa !10
  %310 = fpext float %309 to double
  %311 = fpext float %300 to double
  %312 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.50, double noundef %310, double noundef %311)
  %.pre292 = load i32, ptr %0, align 4, !tbaa !5
  br label %313

313:                                              ; preds = %296, %304
  %314 = phi i32 [ %299, %296 ], [ %.pre292, %304 ]
  %315 = add nsw i32 %314, 1
  store i32 %315, ptr %0, align 4, !tbaa !5
  %316 = getelementptr inbounds i8, ptr %9, i64 4
  %317 = load float, ptr %316, align 4, !tbaa !10
  %318 = getelementptr inbounds i8, ptr %7, i64 4
  %319 = load float, ptr %318, align 4, !tbaa !10
  %320 = fsub float %317, %319
  %321 = call float @llvm.fabs.f32(float %320)
  %or.cond35 = fcmp ogt float %321, 0x3F50624DE0000000
  br i1 %or.cond35, label %322, label %331

322:                                              ; preds = %313
  %323 = getelementptr inbounds i8, ptr %0, i64 4
  %324 = load i32, ptr %323, align 4, !tbaa !11
  %325 = add nsw i32 %324, 1
  store i32 %325, ptr %323, align 4, !tbaa !11
  %326 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %327 = load float, ptr %318, align 4, !tbaa !10
  %328 = fpext float %327 to double
  %329 = fpext float %317 to double
  %330 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.51, double noundef %328, double noundef %329)
  %.pre293 = load i32, ptr %0, align 4, !tbaa !5
  br label %331

331:                                              ; preds = %313, %322
  %332 = phi i32 [ %315, %313 ], [ %.pre293, %322 ]
  %333 = add nsw i32 %332, 1
  store i32 %333, ptr %0, align 4, !tbaa !5
  %334 = getelementptr inbounds i8, ptr %9, i64 8
  %335 = load float, ptr %334, align 8, !tbaa !10
  %336 = getelementptr inbounds i8, ptr %7, i64 8
  %337 = load float, ptr %336, align 8, !tbaa !10
  %338 = fsub float %335, %337
  %339 = call float @llvm.fabs.f32(float %338)
  %or.cond37 = fcmp ogt float %339, 0x3F50624DE0000000
  br i1 %or.cond37, label %340, label %349

340:                                              ; preds = %331
  %341 = getelementptr inbounds i8, ptr %0, i64 4
  %342 = load i32, ptr %341, align 4, !tbaa !11
  %343 = add nsw i32 %342, 1
  store i32 %343, ptr %341, align 4, !tbaa !11
  %344 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %345 = load float, ptr %336, align 8, !tbaa !10
  %346 = fpext float %345 to double
  %347 = fpext float %335 to double
  %348 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.52, double noundef %346, double noundef %347)
  %.pre294 = load i32, ptr %0, align 4, !tbaa !5
  br label %349

349:                                              ; preds = %331, %340
  %350 = phi i32 [ %333, %331 ], [ %.pre294, %340 ]
  %351 = add nsw i32 %350, 1
  store i32 %351, ptr %0, align 4, !tbaa !5
  %352 = getelementptr inbounds i8, ptr %9, i64 12
  %353 = load float, ptr %352, align 4, !tbaa !10
  %354 = getelementptr inbounds i8, ptr %7, i64 12
  %355 = load float, ptr %354, align 4, !tbaa !10
  %356 = fsub float %353, %355
  %357 = call float @llvm.fabs.f32(float %356)
  %or.cond39 = fcmp ogt float %357, 0x3F50624DE0000000
  br i1 %or.cond39, label %358, label %367

358:                                              ; preds = %349
  %359 = getelementptr inbounds i8, ptr %0, i64 4
  %360 = load i32, ptr %359, align 4, !tbaa !11
  %361 = add nsw i32 %360, 1
  store i32 %361, ptr %359, align 4, !tbaa !11
  %362 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %363 = load float, ptr %354, align 4, !tbaa !10
  %364 = fpext float %363 to double
  %365 = fpext float %353 to double
  %366 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.53, double noundef %364, double noundef %365)
  %.pre295 = load i32, ptr %0, align 4, !tbaa !5
  br label %367

367:                                              ; preds = %349, %358
  %368 = phi i32 [ %351, %349 ], [ %.pre295, %358 ]
  %369 = add nsw i32 %368, 1
  store i32 %369, ptr %0, align 4, !tbaa !5
  %370 = getelementptr inbounds i8, ptr %9, i64 16
  %371 = load float, ptr %370, align 16, !tbaa !10
  %372 = getelementptr inbounds i8, ptr %7, i64 16
  %373 = load float, ptr %372, align 16, !tbaa !10
  %374 = fsub float %371, %373
  %375 = call float @llvm.fabs.f32(float %374)
  %or.cond41 = fcmp ogt float %375, 0x3F50624DE0000000
  br i1 %or.cond41, label %376, label %385

376:                                              ; preds = %367
  %377 = getelementptr inbounds i8, ptr %0, i64 4
  %378 = load i32, ptr %377, align 4, !tbaa !11
  %379 = add nsw i32 %378, 1
  store i32 %379, ptr %377, align 4, !tbaa !11
  %380 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %381 = load float, ptr %372, align 16, !tbaa !10
  %382 = fpext float %381 to double
  %383 = fpext float %371 to double
  %384 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.54, double noundef %382, double noundef %383)
  %.pre296 = load i32, ptr %0, align 4, !tbaa !5
  br label %385

385:                                              ; preds = %367, %376
  %386 = phi i32 [ %369, %367 ], [ %.pre296, %376 ]
  %387 = add nsw i32 %386, 1
  store i32 %387, ptr %0, align 4, !tbaa !5
  %388 = getelementptr inbounds i8, ptr %9, i64 20
  %389 = load float, ptr %388, align 4, !tbaa !10
  %390 = getelementptr inbounds i8, ptr %7, i64 20
  %391 = load float, ptr %390, align 4, !tbaa !10
  %392 = fsub float %389, %391
  %393 = call float @llvm.fabs.f32(float %392)
  %or.cond43 = fcmp ogt float %393, 0x3F50624DE0000000
  br i1 %or.cond43, label %394, label %403

394:                                              ; preds = %385
  %395 = getelementptr inbounds i8, ptr %0, i64 4
  %396 = load i32, ptr %395, align 4, !tbaa !11
  %397 = add nsw i32 %396, 1
  store i32 %397, ptr %395, align 4, !tbaa !11
  %398 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %399 = load float, ptr %390, align 4, !tbaa !10
  %400 = fpext float %399 to double
  %401 = fpext float %389 to double
  %402 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.55, double noundef %400, double noundef %401)
  %.pre297 = load i32, ptr %0, align 4, !tbaa !5
  br label %403

403:                                              ; preds = %385, %394
  %404 = phi i32 [ %387, %385 ], [ %.pre297, %394 ]
  %405 = add nsw i32 %404, 1
  store i32 %405, ptr %0, align 4, !tbaa !5
  %406 = getelementptr inbounds i8, ptr %9, i64 24
  %407 = load float, ptr %406, align 8, !tbaa !10
  %408 = getelementptr inbounds i8, ptr %7, i64 24
  %409 = load float, ptr %408, align 8, !tbaa !10
  %410 = fsub float %407, %409
  %411 = call float @llvm.fabs.f32(float %410)
  %or.cond45 = fcmp ogt float %411, 0x3F50624DE0000000
  br i1 %or.cond45, label %412, label %421

412:                                              ; preds = %403
  %413 = getelementptr inbounds i8, ptr %0, i64 4
  %414 = load i32, ptr %413, align 4, !tbaa !11
  %415 = add nsw i32 %414, 1
  store i32 %415, ptr %413, align 4, !tbaa !11
  %416 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %417 = load float, ptr %408, align 8, !tbaa !10
  %418 = fpext float %417 to double
  %419 = fpext float %407 to double
  %420 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.56, double noundef %418, double noundef %419)
  %.pre298 = load i32, ptr %0, align 4, !tbaa !5
  br label %421

421:                                              ; preds = %403, %412
  %422 = phi i32 [ %405, %403 ], [ %.pre298, %412 ]
  %423 = add nsw i32 %422, 1
  store i32 %423, ptr %0, align 4, !tbaa !5
  %424 = getelementptr inbounds i8, ptr %9, i64 28
  %425 = load float, ptr %424, align 4, !tbaa !10
  %426 = getelementptr inbounds i8, ptr %7, i64 28
  %427 = load float, ptr %426, align 4, !tbaa !10
  %428 = fsub float %425, %427
  %429 = call float @llvm.fabs.f32(float %428)
  %or.cond47 = fcmp ogt float %429, 0x3F50624DE0000000
  br i1 %or.cond47, label %430, label %439

430:                                              ; preds = %421
  %431 = getelementptr inbounds i8, ptr %0, i64 4
  %432 = load i32, ptr %431, align 4, !tbaa !11
  %433 = add nsw i32 %432, 1
  store i32 %433, ptr %431, align 4, !tbaa !11
  %434 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %435 = load float, ptr %426, align 4, !tbaa !10
  %436 = fpext float %435 to double
  %437 = fpext float %425 to double
  %438 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.57, double noundef %436, double noundef %437)
  %.pre299 = load i32, ptr %0, align 4, !tbaa !5
  br label %439

439:                                              ; preds = %421, %430
  %440 = phi i32 [ %423, %421 ], [ %.pre299, %430 ]
  %441 = add nsw i32 %440, 1
  store i32 %441, ptr %0, align 4, !tbaa !5
  %442 = getelementptr inbounds i8, ptr %9, i64 32
  %443 = load float, ptr %442, align 16, !tbaa !10
  %444 = getelementptr inbounds i8, ptr %7, i64 32
  %445 = load float, ptr %444, align 16, !tbaa !10
  %446 = fsub float %443, %445
  %447 = call float @llvm.fabs.f32(float %446)
  %or.cond49 = fcmp ogt float %447, 0x3F50624DE0000000
  br i1 %or.cond49, label %448, label %457

448:                                              ; preds = %439
  %449 = getelementptr inbounds i8, ptr %0, i64 4
  %450 = load i32, ptr %449, align 4, !tbaa !11
  %451 = add nsw i32 %450, 1
  store i32 %451, ptr %449, align 4, !tbaa !11
  %452 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %453 = load float, ptr %444, align 16, !tbaa !10
  %454 = fpext float %453 to double
  %455 = fpext float %443 to double
  %456 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.58, double noundef %454, double noundef %455)
  %.pre300 = load i32, ptr %0, align 4, !tbaa !5
  br label %457

457:                                              ; preds = %439, %448
  %458 = phi i32 [ %441, %439 ], [ %.pre300, %448 ]
  %459 = add nsw i32 %458, 1
  store i32 %459, ptr %0, align 4, !tbaa !5
  %460 = getelementptr inbounds i8, ptr %9, i64 36
  %461 = load float, ptr %460, align 4, !tbaa !10
  %462 = getelementptr inbounds i8, ptr %7, i64 36
  %463 = load float, ptr %462, align 4, !tbaa !10
  %464 = fsub float %461, %463
  %465 = call float @llvm.fabs.f32(float %464)
  %or.cond51 = fcmp ogt float %465, 0x3F50624DE0000000
  br i1 %or.cond51, label %466, label %475

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

475:                                              ; preds = %457, %466
  %476 = phi i32 [ %459, %457 ], [ %.pre301, %466 ]
  %477 = add nsw i32 %476, 1
  store i32 %477, ptr %0, align 4, !tbaa !5
  %478 = getelementptr inbounds i8, ptr %9, i64 40
  %479 = load float, ptr %478, align 8, !tbaa !10
  %480 = getelementptr inbounds i8, ptr %7, i64 40
  %481 = load float, ptr %480, align 8, !tbaa !10
  %482 = fsub float %479, %481
  %483 = call float @llvm.fabs.f32(float %482)
  %or.cond53 = fcmp ogt float %483, 0x3F50624DE0000000
  br i1 %or.cond53, label %484, label %493

484:                                              ; preds = %475
  %485 = getelementptr inbounds i8, ptr %0, i64 4
  %486 = load i32, ptr %485, align 4, !tbaa !11
  %487 = add nsw i32 %486, 1
  store i32 %487, ptr %485, align 4, !tbaa !11
  %488 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %489 = load float, ptr %480, align 8, !tbaa !10
  %490 = fpext float %489 to double
  %491 = fpext float %479 to double
  %492 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.60, double noundef %490, double noundef %491)
  %.pre302 = load i32, ptr %0, align 4, !tbaa !5
  br label %493

493:                                              ; preds = %475, %484
  %494 = phi i32 [ %477, %475 ], [ %.pre302, %484 ]
  %495 = add nsw i32 %494, 1
  store i32 %495, ptr %0, align 4, !tbaa !5
  %496 = getelementptr inbounds i8, ptr %9, i64 44
  %497 = load float, ptr %496, align 4, !tbaa !10
  %498 = getelementptr inbounds i8, ptr %7, i64 44
  %499 = load float, ptr %498, align 4, !tbaa !10
  %500 = fsub float %497, %499
  %501 = call float @llvm.fabs.f32(float %500)
  %or.cond55 = fcmp ogt float %501, 0x3F50624DE0000000
  br i1 %or.cond55, label %502, label %511

502:                                              ; preds = %493
  %503 = getelementptr inbounds i8, ptr %0, i64 4
  %504 = load i32, ptr %503, align 4, !tbaa !11
  %505 = add nsw i32 %504, 1
  store i32 %505, ptr %503, align 4, !tbaa !11
  %506 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %507 = load float, ptr %498, align 4, !tbaa !10
  %508 = fpext float %507 to double
  %509 = fpext float %497 to double
  %510 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.61, double noundef %508, double noundef %509)
  %.pre303 = load i32, ptr %0, align 4, !tbaa !5
  br label %511

511:                                              ; preds = %493, %502
  %512 = phi i32 [ %495, %493 ], [ %.pre303, %502 ]
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %0, align 4, !tbaa !5
  %514 = getelementptr inbounds i8, ptr %9, i64 48
  %515 = load float, ptr %514, align 16, !tbaa !10
  %516 = getelementptr inbounds i8, ptr %7, i64 48
  %517 = load float, ptr %516, align 16, !tbaa !10
  %518 = fsub float %515, %517
  %519 = call float @llvm.fabs.f32(float %518)
  %or.cond57 = fcmp ogt float %519, 0x3F50624DE0000000
  br i1 %or.cond57, label %520, label %529

520:                                              ; preds = %511
  %521 = getelementptr inbounds i8, ptr %0, i64 4
  %522 = load i32, ptr %521, align 4, !tbaa !11
  %523 = add nsw i32 %522, 1
  store i32 %523, ptr %521, align 4, !tbaa !11
  %524 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %525 = load float, ptr %516, align 16, !tbaa !10
  %526 = fpext float %525 to double
  %527 = fpext float %515 to double
  %528 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.62, double noundef %526, double noundef %527)
  %.pre304 = load i32, ptr %0, align 4, !tbaa !5
  br label %529

529:                                              ; preds = %511, %520
  %530 = phi i32 [ %513, %511 ], [ %.pre304, %520 ]
  %531 = add nsw i32 %530, 1
  store i32 %531, ptr %0, align 4, !tbaa !5
  %532 = getelementptr inbounds i8, ptr %9, i64 52
  %533 = load float, ptr %532, align 4, !tbaa !10
  %534 = getelementptr inbounds i8, ptr %7, i64 52
  %535 = load float, ptr %534, align 4, !tbaa !10
  %536 = fsub float %533, %535
  %537 = call float @llvm.fabs.f32(float %536)
  %or.cond59 = fcmp ogt float %537, 0x3F50624DE0000000
  br i1 %or.cond59, label %538, label %547

538:                                              ; preds = %529
  %539 = getelementptr inbounds i8, ptr %0, i64 4
  %540 = load i32, ptr %539, align 4, !tbaa !11
  %541 = add nsw i32 %540, 1
  store i32 %541, ptr %539, align 4, !tbaa !11
  %542 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %543 = load float, ptr %534, align 4, !tbaa !10
  %544 = fpext float %543 to double
  %545 = fpext float %533 to double
  %546 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.63, double noundef %544, double noundef %545)
  %.pre305 = load i32, ptr %0, align 4, !tbaa !5
  br label %547

547:                                              ; preds = %529, %538
  %548 = phi i32 [ %531, %529 ], [ %.pre305, %538 ]
  %549 = add nsw i32 %548, 1
  store i32 %549, ptr %0, align 4, !tbaa !5
  %550 = getelementptr inbounds i8, ptr %9, i64 56
  %551 = load float, ptr %550, align 8, !tbaa !10
  %552 = getelementptr inbounds i8, ptr %7, i64 56
  %553 = load float, ptr %552, align 8, !tbaa !10
  %554 = fsub float %551, %553
  %555 = call float @llvm.fabs.f32(float %554)
  %or.cond61 = fcmp ogt float %555, 0x3F50624DE0000000
  br i1 %or.cond61, label %556, label %565

556:                                              ; preds = %547
  %557 = getelementptr inbounds i8, ptr %0, i64 4
  %558 = load i32, ptr %557, align 4, !tbaa !11
  %559 = add nsw i32 %558, 1
  store i32 %559, ptr %557, align 4, !tbaa !11
  %560 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %561 = load float, ptr %552, align 8, !tbaa !10
  %562 = fpext float %561 to double
  %563 = fpext float %551 to double
  %564 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.64, double noundef %562, double noundef %563)
  %.pre306 = load i32, ptr %0, align 4, !tbaa !5
  br label %565

565:                                              ; preds = %547, %556
  %566 = phi i32 [ %549, %547 ], [ %.pre306, %556 ]
  %567 = add nsw i32 %566, 1
  store i32 %567, ptr %0, align 4, !tbaa !5
  %568 = getelementptr inbounds i8, ptr %9, i64 60
  %569 = load float, ptr %568, align 4, !tbaa !10
  %570 = getelementptr inbounds i8, ptr %7, i64 60
  %571 = load float, ptr %570, align 4, !tbaa !10
  %572 = fsub float %569, %571
  %573 = call float @llvm.fabs.f32(float %572)
  %or.cond63 = fcmp ogt float %573, 0x3F50624DE0000000
  br i1 %or.cond63, label %574, label %583

574:                                              ; preds = %565
  %575 = getelementptr inbounds i8, ptr %0, i64 4
  %576 = load i32, ptr %575, align 4, !tbaa !11
  %577 = add nsw i32 %576, 1
  store i32 %577, ptr %575, align 4, !tbaa !11
  %578 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 337)
  %579 = load float, ptr %570, align 4, !tbaa !10
  %580 = fpext float %579 to double
  %581 = fpext float %569 to double
  %582 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.65, double noundef %580, double noundef %581)
  br label %583

583:                                              ; preds = %565, %574
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %9) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %8) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %7) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %6) #6
  ret void
}

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

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

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

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { inlinehint mustprogress uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 #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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !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 = !{!8, !8, i64 0}
!11 = !{!6, !7, i64 4}


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