; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z29_hmt_test_InvMatrix_InvLookAtP21hmt_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
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@.str.68 = external hidden unnamed_addr constant [24 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye.69 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center.70 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up.71 = 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 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_InvLookAtP21hmt_testresult_struct(ptr noundef %0) #4 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Vec3, align 4
  %4 = alloca %union.HMM_Vec3, align 4
  %5 = alloca %union.HMM_Vec3, align 4
  %6 = alloca %union.HMM_Mat4, align 16
  %7 = alloca %union.HMM_Vec3, align 4
  %8 = alloca %union.HMM_Vec3, align 4
  %9 = alloca %union.HMM_Vec3, align 4
  %10 = alloca { <2 x float>, float }, align 4
  %11 = alloca { <2 x float>, float }, align 4
  %12 = alloca { <2 x float>, float }, align 4
  %13 = alloca %union.HMM_Mat4, align 16
  %14 = alloca %union.HMM_Mat4, align 16
  %15 = alloca %union.HMM_Mat4, align 16
  %16 = alloca %union.HMM_Mat4, align 16
  %17 = alloca %union.HMM_Mat4, align 16
  %18 = alloca %union.HMM_Mat4, align 16
  %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 float, align 4
  %49 = alloca float, align 4
  %50 = alloca float, align 4
  %51 = alloca %union.HMM_Vec3, align 4
  %52 = alloca %union.HMM_Vec3, align 4
  %53 = alloca %union.HMM_Vec3, align 4
  %54 = alloca %union.HMM_Mat4, align 16
  %55 = alloca %union.HMM_Vec3, align 4
  %56 = alloca %union.HMM_Vec3, align 4
  %57 = alloca %union.HMM_Vec3, align 4
  %58 = alloca { <2 x float>, float }, align 4
  %59 = alloca { <2 x float>, float }, align 4
  %60 = alloca { <2 x float>, float }, align 4
  %61 = alloca %union.HMM_Mat4, align 16
  %62 = alloca %union.HMM_Mat4, align 16
  %63 = alloca %union.HMM_Mat4, align 16
  %64 = alloca %union.HMM_Mat4, align 16
  %65 = alloca %union.HMM_Mat4, align 16
  %66 = alloca %union.HMM_Mat4, align 16
  %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
  %93 = alloca float, align 4
  %94 = alloca float, align 4
  %95 = alloca float, align 4
  %96 = alloca float, align 4
  %97 = alloca float, align 4
  %98 = alloca float, align 4
  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_InvLookAtP21hmt_testresult_struct.Eye, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 12, ptr %4) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %4, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 12, ptr %5) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %6) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %3, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 4 %4, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %9, ptr align 4 %5, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %10, ptr align 4 %7, i64 12, i1 false)
  %99 = getelementptr inbounds { <2 x float>, float }, ptr %10, i32 0, i32 0
  %100 = load <2 x float>, ptr %99, align 4
  %101 = getelementptr inbounds { <2 x float>, float }, ptr %10, i32 0, i32 1
  %102 = load float, ptr %101, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %8, i64 12, i1 false)
  %103 = getelementptr inbounds { <2 x float>, float }, ptr %11, i32 0, i32 0
  %104 = load <2 x float>, ptr %103, align 4
  %105 = getelementptr inbounds { <2 x float>, float }, ptr %11, i32 0, i32 1
  %106 = load float, ptr %105, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %12, ptr align 4 %9, i64 12, i1 false)
  %107 = getelementptr inbounds { <2 x float>, float }, ptr %12, i32 0, i32 0
  %108 = load <2 x float>, ptr %107, align 4
  %109 = getelementptr inbounds { <2 x float>, float }, ptr %12, i32 0, i32 1
  %110 = load float, ptr %109, align 4
  call void @_ZL13HMM_LookAt_RH8HMM_Vec3S_S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %6, <2 x float> %100, float %102, <2 x float> %104, float %106, <2 x float> %108, float %110)
  call void @llvm.lifetime.start.p0(i64 64, ptr %13) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %13, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr %14) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %15, ptr align 16 %6, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL13HMM_InvLookAt8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %14, ptr noundef byval(%union.HMM_Mat4) align 16 %15)
  call void @llvm.lifetime.start.p0(i64 64, ptr %16) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %17, ptr align 16 %6, i64 64, i1 false), !tbaa.struct !11
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %18, ptr align 16 %14, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %16, ptr noundef byval(%union.HMM_Mat4) align 16 %17, ptr noundef byval(%union.HMM_Mat4) align 16 %18)
  %111 = load ptr, ptr %2, align 8, !tbaa !5
  %112 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %111, i32 0, i32 0
  %113 = load i32, ptr %112, align 4, !tbaa !12
  %114 = add nsw i32 %113, 1
  store i32 %114, ptr %112, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  %115 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 0
  %116 = getelementptr inbounds [4 x float], ptr %115, i64 0, i64 0
  %117 = load float, ptr %116, align 16, !tbaa !10
  store float %117, ptr %19, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  %118 = load float, ptr %19, align 4, !tbaa !15
  %119 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %120 = getelementptr inbounds [4 x float], ptr %119, i64 0, i64 0
  %121 = load float, ptr %120, align 16, !tbaa !10
  %122 = fsub float %118, %121
  store float %122, ptr %20, align 4, !tbaa !15
  %123 = load float, ptr %20, align 4, !tbaa !15
  %124 = fcmp olt float %123, 0xBF50624DE0000000
  br i1 %124, label %128, label %125

125:                                              ; preds = %1
  %126 = load float, ptr %20, align 4, !tbaa !15
  %127 = fcmp olt float 0x3F50624DE0000000, %126
  br i1 %127, label %128, label %141

128:                                              ; preds = %125, %1
  %129 = load ptr, ptr %2, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %129, i32 0, i32 1
  %131 = load i32, ptr %130, align 4, !tbaa !17
  %132 = add nsw i32 %131, 1
  store i32 %132, ptr %130, align 4, !tbaa !17
  %133 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %134 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %135 = getelementptr inbounds [4 x float], ptr %134, i64 0, i64 0
  %136 = load float, ptr %135, align 16, !tbaa !10
  %137 = fpext float %136 to double
  %138 = load float, ptr %19, align 4, !tbaa !15
  %139 = fpext float %138 to double
  %140 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.50, double noundef %137, double noundef %139)
  br label %141

141:                                              ; preds = %128, %125
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  %142 = load ptr, ptr %2, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %142, i32 0, i32 0
  %144 = load i32, ptr %143, align 4, !tbaa !12
  %145 = add nsw i32 %144, 1
  store i32 %145, ptr %143, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  %146 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 0
  %147 = getelementptr inbounds [4 x float], ptr %146, i64 0, i64 1
  %148 = load float, ptr %147, align 4, !tbaa !10
  store float %148, ptr %21, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %149 = load float, ptr %21, align 4, !tbaa !15
  %150 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %151 = getelementptr inbounds [4 x float], ptr %150, i64 0, i64 1
  %152 = load float, ptr %151, align 4, !tbaa !10
  %153 = fsub float %149, %152
  store float %153, ptr %22, align 4, !tbaa !15
  %154 = load float, ptr %22, align 4, !tbaa !15
  %155 = fcmp olt float %154, 0xBF50624DE0000000
  br i1 %155, label %159, label %156

156:                                              ; preds = %141
  %157 = load float, ptr %22, align 4, !tbaa !15
  %158 = fcmp olt float 0x3F50624DE0000000, %157
  br i1 %158, label %159, label %172

159:                                              ; preds = %156, %141
  %160 = load ptr, ptr %2, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %160, i32 0, i32 1
  %162 = load i32, ptr %161, align 4, !tbaa !17
  %163 = add nsw i32 %162, 1
  store i32 %163, ptr %161, align 4, !tbaa !17
  %164 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %165 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %166 = getelementptr inbounds [4 x float], ptr %165, i64 0, i64 1
  %167 = load float, ptr %166, align 4, !tbaa !10
  %168 = fpext float %167 to double
  %169 = load float, ptr %21, align 4, !tbaa !15
  %170 = fpext float %169 to double
  %171 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.51, double noundef %168, double noundef %170)
  br label %172

172:                                              ; preds = %159, %156
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  %173 = load ptr, ptr %2, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %173, i32 0, i32 0
  %175 = load i32, ptr %174, align 4, !tbaa !12
  %176 = add nsw i32 %175, 1
  store i32 %176, ptr %174, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %177 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 0
  %178 = getelementptr inbounds [4 x float], ptr %177, i64 0, i64 2
  %179 = load float, ptr %178, align 8, !tbaa !10
  store float %179, ptr %23, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %180 = load float, ptr %23, align 4, !tbaa !15
  %181 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %182 = getelementptr inbounds [4 x float], ptr %181, i64 0, i64 2
  %183 = load float, ptr %182, align 8, !tbaa !10
  %184 = fsub float %180, %183
  store float %184, ptr %24, align 4, !tbaa !15
  %185 = load float, ptr %24, align 4, !tbaa !15
  %186 = fcmp olt float %185, 0xBF50624DE0000000
  br i1 %186, label %190, label %187

187:                                              ; preds = %172
  %188 = load float, ptr %24, align 4, !tbaa !15
  %189 = fcmp olt float 0x3F50624DE0000000, %188
  br i1 %189, label %190, label %203

190:                                              ; preds = %187, %172
  %191 = load ptr, ptr %2, align 8, !tbaa !5
  %192 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %191, i32 0, i32 1
  %193 = load i32, ptr %192, align 4, !tbaa !17
  %194 = add nsw i32 %193, 1
  store i32 %194, ptr %192, align 4, !tbaa !17
  %195 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %196 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %197 = getelementptr inbounds [4 x float], ptr %196, i64 0, i64 2
  %198 = load float, ptr %197, align 8, !tbaa !10
  %199 = fpext float %198 to double
  %200 = load float, ptr %23, align 4, !tbaa !15
  %201 = fpext float %200 to double
  %202 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.52, double noundef %199, double noundef %201)
  br label %203

203:                                              ; preds = %190, %187
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  %204 = load ptr, ptr %2, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %204, i32 0, i32 0
  %206 = load i32, ptr %205, align 4, !tbaa !12
  %207 = add nsw i32 %206, 1
  store i32 %207, ptr %205, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  %208 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 0
  %209 = getelementptr inbounds [4 x float], ptr %208, i64 0, i64 3
  %210 = load float, ptr %209, align 4, !tbaa !10
  store float %210, ptr %25, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %211 = load float, ptr %25, align 4, !tbaa !15
  %212 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %213 = getelementptr inbounds [4 x float], ptr %212, i64 0, i64 3
  %214 = load float, ptr %213, align 4, !tbaa !10
  %215 = fsub float %211, %214
  store float %215, ptr %26, align 4, !tbaa !15
  %216 = load float, ptr %26, align 4, !tbaa !15
  %217 = fcmp olt float %216, 0xBF50624DE0000000
  br i1 %217, label %221, label %218

218:                                              ; preds = %203
  %219 = load float, ptr %26, align 4, !tbaa !15
  %220 = fcmp olt float 0x3F50624DE0000000, %219
  br i1 %220, label %221, label %234

221:                                              ; preds = %218, %203
  %222 = load ptr, ptr %2, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %222, i32 0, i32 1
  %224 = load i32, ptr %223, align 4, !tbaa !17
  %225 = add nsw i32 %224, 1
  store i32 %225, ptr %223, align 4, !tbaa !17
  %226 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %227 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 0
  %228 = getelementptr inbounds [4 x float], ptr %227, i64 0, i64 3
  %229 = load float, ptr %228, align 4, !tbaa !10
  %230 = fpext float %229 to double
  %231 = load float, ptr %25, align 4, !tbaa !15
  %232 = fpext float %231 to double
  %233 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.53, double noundef %230, double noundef %232)
  br label %234

234:                                              ; preds = %221, %218
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  %235 = load ptr, ptr %2, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %235, i32 0, i32 0
  %237 = load i32, ptr %236, align 4, !tbaa !12
  %238 = add nsw i32 %237, 1
  store i32 %238, ptr %236, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  %239 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 1
  %240 = getelementptr inbounds [4 x float], ptr %239, i64 0, i64 0
  %241 = load float, ptr %240, align 16, !tbaa !10
  store float %241, ptr %27, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %242 = load float, ptr %27, align 4, !tbaa !15
  %243 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %244 = getelementptr inbounds [4 x float], ptr %243, i64 0, i64 0
  %245 = load float, ptr %244, align 16, !tbaa !10
  %246 = fsub float %242, %245
  store float %246, ptr %28, align 4, !tbaa !15
  %247 = load float, ptr %28, align 4, !tbaa !15
  %248 = fcmp olt float %247, 0xBF50624DE0000000
  br i1 %248, label %252, label %249

249:                                              ; preds = %234
  %250 = load float, ptr %28, align 4, !tbaa !15
  %251 = fcmp olt float 0x3F50624DE0000000, %250
  br i1 %251, label %252, label %265

252:                                              ; preds = %249, %234
  %253 = load ptr, ptr %2, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %253, i32 0, i32 1
  %255 = load i32, ptr %254, align 4, !tbaa !17
  %256 = add nsw i32 %255, 1
  store i32 %256, ptr %254, align 4, !tbaa !17
  %257 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %258 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %259 = getelementptr inbounds [4 x float], ptr %258, i64 0, i64 0
  %260 = load float, ptr %259, align 16, !tbaa !10
  %261 = fpext float %260 to double
  %262 = load float, ptr %27, align 4, !tbaa !15
  %263 = fpext float %262 to double
  %264 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.54, double noundef %261, double noundef %263)
  br label %265

265:                                              ; preds = %252, %249
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  %266 = load ptr, ptr %2, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %266, i32 0, i32 0
  %268 = load i32, ptr %267, align 4, !tbaa !12
  %269 = add nsw i32 %268, 1
  store i32 %269, ptr %267, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  %270 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 1
  %271 = getelementptr inbounds [4 x float], ptr %270, i64 0, i64 1
  %272 = load float, ptr %271, align 4, !tbaa !10
  store float %272, ptr %29, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %273 = load float, ptr %29, align 4, !tbaa !15
  %274 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %275 = getelementptr inbounds [4 x float], ptr %274, i64 0, i64 1
  %276 = load float, ptr %275, align 4, !tbaa !10
  %277 = fsub float %273, %276
  store float %277, ptr %30, align 4, !tbaa !15
  %278 = load float, ptr %30, align 4, !tbaa !15
  %279 = fcmp olt float %278, 0xBF50624DE0000000
  br i1 %279, label %283, label %280

280:                                              ; preds = %265
  %281 = load float, ptr %30, align 4, !tbaa !15
  %282 = fcmp olt float 0x3F50624DE0000000, %281
  br i1 %282, label %283, label %296

283:                                              ; preds = %280, %265
  %284 = load ptr, ptr %2, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %284, i32 0, i32 1
  %286 = load i32, ptr %285, align 4, !tbaa !17
  %287 = add nsw i32 %286, 1
  store i32 %287, ptr %285, align 4, !tbaa !17
  %288 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %289 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %290 = getelementptr inbounds [4 x float], ptr %289, i64 0, i64 1
  %291 = load float, ptr %290, align 4, !tbaa !10
  %292 = fpext float %291 to double
  %293 = load float, ptr %29, align 4, !tbaa !15
  %294 = fpext float %293 to double
  %295 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.55, double noundef %292, double noundef %294)
  br label %296

296:                                              ; preds = %283, %280
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  %297 = load ptr, ptr %2, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %297, i32 0, i32 0
  %299 = load i32, ptr %298, align 4, !tbaa !12
  %300 = add nsw i32 %299, 1
  store i32 %300, ptr %298, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %301 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 1
  %302 = getelementptr inbounds [4 x float], ptr %301, i64 0, i64 2
  %303 = load float, ptr %302, align 8, !tbaa !10
  store float %303, ptr %31, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  %304 = load float, ptr %31, align 4, !tbaa !15
  %305 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %306 = getelementptr inbounds [4 x float], ptr %305, i64 0, i64 2
  %307 = load float, ptr %306, align 8, !tbaa !10
  %308 = fsub float %304, %307
  store float %308, ptr %32, align 4, !tbaa !15
  %309 = load float, ptr %32, align 4, !tbaa !15
  %310 = fcmp olt float %309, 0xBF50624DE0000000
  br i1 %310, label %314, label %311

311:                                              ; preds = %296
  %312 = load float, ptr %32, align 4, !tbaa !15
  %313 = fcmp olt float 0x3F50624DE0000000, %312
  br i1 %313, label %314, label %327

314:                                              ; preds = %311, %296
  %315 = load ptr, ptr %2, align 8, !tbaa !5
  %316 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %315, i32 0, i32 1
  %317 = load i32, ptr %316, align 4, !tbaa !17
  %318 = add nsw i32 %317, 1
  store i32 %318, ptr %316, align 4, !tbaa !17
  %319 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %320 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %321 = getelementptr inbounds [4 x float], ptr %320, i64 0, i64 2
  %322 = load float, ptr %321, align 8, !tbaa !10
  %323 = fpext float %322 to double
  %324 = load float, ptr %31, align 4, !tbaa !15
  %325 = fpext float %324 to double
  %326 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.56, double noundef %323, double noundef %325)
  br label %327

327:                                              ; preds = %314, %311
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  %328 = load ptr, ptr %2, align 8, !tbaa !5
  %329 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %328, i32 0, i32 0
  %330 = load i32, ptr %329, align 4, !tbaa !12
  %331 = add nsw i32 %330, 1
  store i32 %331, ptr %329, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  %332 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 1
  %333 = getelementptr inbounds [4 x float], ptr %332, i64 0, i64 3
  %334 = load float, ptr %333, align 4, !tbaa !10
  store float %334, ptr %33, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  %335 = load float, ptr %33, align 4, !tbaa !15
  %336 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %337 = getelementptr inbounds [4 x float], ptr %336, i64 0, i64 3
  %338 = load float, ptr %337, align 4, !tbaa !10
  %339 = fsub float %335, %338
  store float %339, ptr %34, align 4, !tbaa !15
  %340 = load float, ptr %34, align 4, !tbaa !15
  %341 = fcmp olt float %340, 0xBF50624DE0000000
  br i1 %341, label %345, label %342

342:                                              ; preds = %327
  %343 = load float, ptr %34, align 4, !tbaa !15
  %344 = fcmp olt float 0x3F50624DE0000000, %343
  br i1 %344, label %345, label %358

345:                                              ; preds = %342, %327
  %346 = load ptr, ptr %2, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %346, i32 0, i32 1
  %348 = load i32, ptr %347, align 4, !tbaa !17
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %347, align 4, !tbaa !17
  %350 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %351 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 1
  %352 = getelementptr inbounds [4 x float], ptr %351, i64 0, i64 3
  %353 = load float, ptr %352, align 4, !tbaa !10
  %354 = fpext float %353 to double
  %355 = load float, ptr %33, align 4, !tbaa !15
  %356 = fpext float %355 to double
  %357 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.57, double noundef %354, double noundef %356)
  br label %358

358:                                              ; preds = %345, %342
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  %359 = load ptr, ptr %2, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %359, i32 0, i32 0
  %361 = load i32, ptr %360, align 4, !tbaa !12
  %362 = add nsw i32 %361, 1
  store i32 %362, ptr %360, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  %363 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 2
  %364 = getelementptr inbounds [4 x float], ptr %363, i64 0, i64 0
  %365 = load float, ptr %364, align 16, !tbaa !10
  store float %365, ptr %35, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %366 = load float, ptr %35, align 4, !tbaa !15
  %367 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %368 = getelementptr inbounds [4 x float], ptr %367, i64 0, i64 0
  %369 = load float, ptr %368, align 16, !tbaa !10
  %370 = fsub float %366, %369
  store float %370, ptr %36, align 4, !tbaa !15
  %371 = load float, ptr %36, align 4, !tbaa !15
  %372 = fcmp olt float %371, 0xBF50624DE0000000
  br i1 %372, label %376, label %373

373:                                              ; preds = %358
  %374 = load float, ptr %36, align 4, !tbaa !15
  %375 = fcmp olt float 0x3F50624DE0000000, %374
  br i1 %375, label %376, label %389

376:                                              ; preds = %373, %358
  %377 = load ptr, ptr %2, align 8, !tbaa !5
  %378 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %377, i32 0, i32 1
  %379 = load i32, ptr %378, align 4, !tbaa !17
  %380 = add nsw i32 %379, 1
  store i32 %380, ptr %378, align 4, !tbaa !17
  %381 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %382 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %383 = getelementptr inbounds [4 x float], ptr %382, i64 0, i64 0
  %384 = load float, ptr %383, align 16, !tbaa !10
  %385 = fpext float %384 to double
  %386 = load float, ptr %35, align 4, !tbaa !15
  %387 = fpext float %386 to double
  %388 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.58, double noundef %385, double noundef %387)
  br label %389

389:                                              ; preds = %376, %373
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  %390 = load ptr, ptr %2, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %390, i32 0, i32 0
  %392 = load i32, ptr %391, align 4, !tbaa !12
  %393 = add nsw i32 %392, 1
  store i32 %393, ptr %391, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  %394 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 2
  %395 = getelementptr inbounds [4 x float], ptr %394, i64 0, i64 1
  %396 = load float, ptr %395, align 4, !tbaa !10
  store float %396, ptr %37, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  %397 = load float, ptr %37, align 4, !tbaa !15
  %398 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %399 = getelementptr inbounds [4 x float], ptr %398, i64 0, i64 1
  %400 = load float, ptr %399, align 4, !tbaa !10
  %401 = fsub float %397, %400
  store float %401, ptr %38, align 4, !tbaa !15
  %402 = load float, ptr %38, align 4, !tbaa !15
  %403 = fcmp olt float %402, 0xBF50624DE0000000
  br i1 %403, label %407, label %404

404:                                              ; preds = %389
  %405 = load float, ptr %38, align 4, !tbaa !15
  %406 = fcmp olt float 0x3F50624DE0000000, %405
  br i1 %406, label %407, label %420

407:                                              ; preds = %404, %389
  %408 = load ptr, ptr %2, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %408, i32 0, i32 1
  %410 = load i32, ptr %409, align 4, !tbaa !17
  %411 = add nsw i32 %410, 1
  store i32 %411, ptr %409, align 4, !tbaa !17
  %412 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %413 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %414 = getelementptr inbounds [4 x float], ptr %413, i64 0, i64 1
  %415 = load float, ptr %414, align 4, !tbaa !10
  %416 = fpext float %415 to double
  %417 = load float, ptr %37, align 4, !tbaa !15
  %418 = fpext float %417 to double
  %419 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.59, double noundef %416, double noundef %418)
  br label %420

420:                                              ; preds = %407, %404
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  %421 = load ptr, ptr %2, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %421, i32 0, i32 0
  %423 = load i32, ptr %422, align 4, !tbaa !12
  %424 = add nsw i32 %423, 1
  store i32 %424, ptr %422, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  %425 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 2
  %426 = getelementptr inbounds [4 x float], ptr %425, i64 0, i64 2
  %427 = load float, ptr %426, align 8, !tbaa !10
  store float %427, ptr %39, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #6
  %428 = load float, ptr %39, align 4, !tbaa !15
  %429 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %430 = getelementptr inbounds [4 x float], ptr %429, i64 0, i64 2
  %431 = load float, ptr %430, align 8, !tbaa !10
  %432 = fsub float %428, %431
  store float %432, ptr %40, align 4, !tbaa !15
  %433 = load float, ptr %40, align 4, !tbaa !15
  %434 = fcmp olt float %433, 0xBF50624DE0000000
  br i1 %434, label %438, label %435

435:                                              ; preds = %420
  %436 = load float, ptr %40, align 4, !tbaa !15
  %437 = fcmp olt float 0x3F50624DE0000000, %436
  br i1 %437, label %438, label %451

438:                                              ; preds = %435, %420
  %439 = load ptr, ptr %2, align 8, !tbaa !5
  %440 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %439, i32 0, i32 1
  %441 = load i32, ptr %440, align 4, !tbaa !17
  %442 = add nsw i32 %441, 1
  store i32 %442, ptr %440, align 4, !tbaa !17
  %443 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %444 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %445 = getelementptr inbounds [4 x float], ptr %444, i64 0, i64 2
  %446 = load float, ptr %445, align 8, !tbaa !10
  %447 = fpext float %446 to double
  %448 = load float, ptr %39, align 4, !tbaa !15
  %449 = fpext float %448 to double
  %450 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.60, double noundef %447, double noundef %449)
  br label %451

451:                                              ; preds = %438, %435
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  %452 = load ptr, ptr %2, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %452, i32 0, i32 0
  %454 = load i32, ptr %453, align 4, !tbaa !12
  %455 = add nsw i32 %454, 1
  store i32 %455, ptr %453, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  %456 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 2
  %457 = getelementptr inbounds [4 x float], ptr %456, i64 0, i64 3
  %458 = load float, ptr %457, align 4, !tbaa !10
  store float %458, ptr %41, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  %459 = load float, ptr %41, align 4, !tbaa !15
  %460 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %461 = getelementptr inbounds [4 x float], ptr %460, i64 0, i64 3
  %462 = load float, ptr %461, align 4, !tbaa !10
  %463 = fsub float %459, %462
  store float %463, ptr %42, align 4, !tbaa !15
  %464 = load float, ptr %42, align 4, !tbaa !15
  %465 = fcmp olt float %464, 0xBF50624DE0000000
  br i1 %465, label %469, label %466

466:                                              ; preds = %451
  %467 = load float, ptr %42, align 4, !tbaa !15
  %468 = fcmp olt float 0x3F50624DE0000000, %467
  br i1 %468, label %469, label %482

469:                                              ; preds = %466, %451
  %470 = load ptr, ptr %2, align 8, !tbaa !5
  %471 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %470, i32 0, i32 1
  %472 = load i32, ptr %471, align 4, !tbaa !17
  %473 = add nsw i32 %472, 1
  store i32 %473, ptr %471, align 4, !tbaa !17
  %474 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %475 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 2
  %476 = getelementptr inbounds [4 x float], ptr %475, i64 0, i64 3
  %477 = load float, ptr %476, align 4, !tbaa !10
  %478 = fpext float %477 to double
  %479 = load float, ptr %41, align 4, !tbaa !15
  %480 = fpext float %479 to double
  %481 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.61, double noundef %478, double noundef %480)
  br label %482

482:                                              ; preds = %469, %466
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  %483 = load ptr, ptr %2, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %483, i32 0, i32 0
  %485 = load i32, ptr %484, align 4, !tbaa !12
  %486 = add nsw i32 %485, 1
  store i32 %486, ptr %484, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %487 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 3
  %488 = getelementptr inbounds [4 x float], ptr %487, i64 0, i64 0
  %489 = load float, ptr %488, align 16, !tbaa !10
  store float %489, ptr %43, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  %490 = load float, ptr %43, align 4, !tbaa !15
  %491 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %492 = getelementptr inbounds [4 x float], ptr %491, i64 0, i64 0
  %493 = load float, ptr %492, align 16, !tbaa !10
  %494 = fsub float %490, %493
  store float %494, ptr %44, align 4, !tbaa !15
  %495 = load float, ptr %44, align 4, !tbaa !15
  %496 = fcmp olt float %495, 0xBF50624DE0000000
  br i1 %496, label %500, label %497

497:                                              ; preds = %482
  %498 = load float, ptr %44, align 4, !tbaa !15
  %499 = fcmp olt float 0x3F50624DE0000000, %498
  br i1 %499, label %500, label %513

500:                                              ; preds = %497, %482
  %501 = load ptr, ptr %2, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %501, i32 0, i32 1
  %503 = load i32, ptr %502, align 4, !tbaa !17
  %504 = add nsw i32 %503, 1
  store i32 %504, ptr %502, align 4, !tbaa !17
  %505 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %506 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %507 = getelementptr inbounds [4 x float], ptr %506, i64 0, i64 0
  %508 = load float, ptr %507, align 16, !tbaa !10
  %509 = fpext float %508 to double
  %510 = load float, ptr %43, align 4, !tbaa !15
  %511 = fpext float %510 to double
  %512 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.62, double noundef %509, double noundef %511)
  br label %513

513:                                              ; preds = %500, %497
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  %514 = load ptr, ptr %2, align 8, !tbaa !5
  %515 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %514, i32 0, i32 0
  %516 = load i32, ptr %515, align 4, !tbaa !12
  %517 = add nsw i32 %516, 1
  store i32 %517, ptr %515, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %518 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 3
  %519 = getelementptr inbounds [4 x float], ptr %518, i64 0, i64 1
  %520 = load float, ptr %519, align 4, !tbaa !10
  store float %520, ptr %45, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %521 = load float, ptr %45, align 4, !tbaa !15
  %522 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %523 = getelementptr inbounds [4 x float], ptr %522, i64 0, i64 1
  %524 = load float, ptr %523, align 4, !tbaa !10
  %525 = fsub float %521, %524
  store float %525, ptr %46, align 4, !tbaa !15
  %526 = load float, ptr %46, align 4, !tbaa !15
  %527 = fcmp olt float %526, 0xBF50624DE0000000
  br i1 %527, label %531, label %528

528:                                              ; preds = %513
  %529 = load float, ptr %46, align 4, !tbaa !15
  %530 = fcmp olt float 0x3F50624DE0000000, %529
  br i1 %530, label %531, label %544

531:                                              ; preds = %528, %513
  %532 = load ptr, ptr %2, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %532, i32 0, i32 1
  %534 = load i32, ptr %533, align 4, !tbaa !17
  %535 = add nsw i32 %534, 1
  store i32 %535, ptr %533, align 4, !tbaa !17
  %536 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %537 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %538 = getelementptr inbounds [4 x float], ptr %537, i64 0, i64 1
  %539 = load float, ptr %538, align 4, !tbaa !10
  %540 = fpext float %539 to double
  %541 = load float, ptr %45, align 4, !tbaa !15
  %542 = fpext float %541 to double
  %543 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.63, double noundef %540, double noundef %542)
  br label %544

544:                                              ; preds = %531, %528
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  %545 = load ptr, ptr %2, align 8, !tbaa !5
  %546 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %545, i32 0, i32 0
  %547 = load i32, ptr %546, align 4, !tbaa !12
  %548 = add nsw i32 %547, 1
  store i32 %548, ptr %546, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #6
  %549 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 3
  %550 = getelementptr inbounds [4 x float], ptr %549, i64 0, i64 2
  %551 = load float, ptr %550, align 8, !tbaa !10
  store float %551, ptr %47, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  %552 = load float, ptr %47, align 4, !tbaa !15
  %553 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %554 = getelementptr inbounds [4 x float], ptr %553, i64 0, i64 2
  %555 = load float, ptr %554, align 8, !tbaa !10
  %556 = fsub float %552, %555
  store float %556, ptr %48, align 4, !tbaa !15
  %557 = load float, ptr %48, align 4, !tbaa !15
  %558 = fcmp olt float %557, 0xBF50624DE0000000
  br i1 %558, label %562, label %559

559:                                              ; preds = %544
  %560 = load float, ptr %48, align 4, !tbaa !15
  %561 = fcmp olt float 0x3F50624DE0000000, %560
  br i1 %561, label %562, label %575

562:                                              ; preds = %559, %544
  %563 = load ptr, ptr %2, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %563, i32 0, i32 1
  %565 = load i32, ptr %564, align 4, !tbaa !17
  %566 = add nsw i32 %565, 1
  store i32 %566, ptr %564, align 4, !tbaa !17
  %567 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %568 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %569 = getelementptr inbounds [4 x float], ptr %568, i64 0, i64 2
  %570 = load float, ptr %569, align 8, !tbaa !10
  %571 = fpext float %570 to double
  %572 = load float, ptr %47, align 4, !tbaa !15
  %573 = fpext float %572 to double
  %574 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.64, double noundef %571, double noundef %573)
  br label %575

575:                                              ; preds = %562, %559
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #6
  %576 = load ptr, ptr %2, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %576, i32 0, i32 0
  %578 = load i32, ptr %577, align 4, !tbaa !12
  %579 = add nsw i32 %578, 1
  store i32 %579, ptr %577, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  %580 = getelementptr inbounds [4 x [4 x float]], ptr %16, i64 0, i64 3
  %581 = getelementptr inbounds [4 x float], ptr %580, i64 0, i64 3
  %582 = load float, ptr %581, align 4, !tbaa !10
  store float %582, ptr %49, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  %583 = load float, ptr %49, align 4, !tbaa !15
  %584 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %585 = getelementptr inbounds [4 x float], ptr %584, i64 0, i64 3
  %586 = load float, ptr %585, align 4, !tbaa !10
  %587 = fsub float %583, %586
  store float %587, ptr %50, align 4, !tbaa !15
  %588 = load float, ptr %50, align 4, !tbaa !15
  %589 = fcmp olt float %588, 0xBF50624DE0000000
  br i1 %589, label %593, label %590

590:                                              ; preds = %575
  %591 = load float, ptr %50, align 4, !tbaa !15
  %592 = fcmp olt float 0x3F50624DE0000000, %591
  br i1 %592, label %593, label %606

593:                                              ; preds = %590, %575
  %594 = load ptr, ptr %2, align 8, !tbaa !5
  %595 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %594, i32 0, i32 1
  %596 = load i32, ptr %595, align 4, !tbaa !17
  %597 = add nsw i32 %596, 1
  store i32 %597, ptr %595, align 4, !tbaa !17
  %598 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %599 = getelementptr inbounds [4 x [4 x float]], ptr %13, i64 0, i64 3
  %600 = getelementptr inbounds [4 x float], ptr %599, i64 0, i64 3
  %601 = load float, ptr %600, align 4, !tbaa !10
  %602 = fpext float %601 to double
  %603 = load float, ptr %49, align 4, !tbaa !15
  %604 = fpext float %603 to double
  %605 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.65, double noundef %602, double noundef %604)
  br label %606

606:                                              ; preds = %593, %590
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %6) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %3) #6
  call void @llvm.lifetime.start.p0(i64 12, ptr %51) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %51, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye.69, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 12, ptr %52) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %52, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center.70, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 12, ptr %53) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %53, ptr align 4 @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up.71, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %54) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %55, ptr align 4 %51, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %56, ptr align 4 %52, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %57, ptr align 4 %53, i64 12, i1 false), !tbaa.struct !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %58, ptr align 4 %55, i64 12, i1 false)
  %607 = getelementptr inbounds { <2 x float>, float }, ptr %58, i32 0, i32 0
  %608 = load <2 x float>, ptr %607, align 4
  %609 = getelementptr inbounds { <2 x float>, float }, ptr %58, i32 0, i32 1
  %610 = load float, ptr %609, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %59, ptr align 4 %56, i64 12, i1 false)
  %611 = getelementptr inbounds { <2 x float>, float }, ptr %59, i32 0, i32 0
  %612 = load <2 x float>, ptr %611, align 4
  %613 = getelementptr inbounds { <2 x float>, float }, ptr %59, i32 0, i32 1
  %614 = load float, ptr %613, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %60, ptr align 4 %57, i64 12, i1 false)
  %615 = getelementptr inbounds { <2 x float>, float }, ptr %60, i32 0, i32 0
  %616 = load <2 x float>, ptr %615, align 4
  %617 = getelementptr inbounds { <2 x float>, float }, ptr %60, i32 0, i32 1
  %618 = load float, ptr %617, align 4
  call void @_ZL13HMM_LookAt_LH8HMM_Vec3S_S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %54, <2 x float> %608, float %610, <2 x float> %612, float %614, <2 x float> %616, float %618)
  call void @llvm.lifetime.start.p0(i64 64, ptr %61) #6
  call void @_ZL7HMM_M4Df(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %61, float noundef 1.000000e+00)
  call void @llvm.lifetime.start.p0(i64 64, ptr %62) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %63, ptr align 16 %54, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL13HMM_InvLookAt8HMM_Mat4(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %62, ptr noundef byval(%union.HMM_Mat4) align 16 %63)
  call void @llvm.lifetime.start.p0(i64 64, ptr %64) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %65, ptr align 16 %54, i64 64, i1 false), !tbaa.struct !11
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %66, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !11
  call void @_ZL9HMM_MulM48HMM_Mat4S_(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %64, ptr noundef byval(%union.HMM_Mat4) align 16 %65, ptr noundef byval(%union.HMM_Mat4) align 16 %66)
  %619 = load ptr, ptr %2, align 8, !tbaa !5
  %620 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %619, i32 0, i32 0
  %621 = load i32, ptr %620, align 4, !tbaa !12
  %622 = add nsw i32 %621, 1
  store i32 %622, ptr %620, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #6
  %623 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 0
  %624 = getelementptr inbounds [4 x float], ptr %623, i64 0, i64 0
  %625 = load float, ptr %624, align 16, !tbaa !10
  store float %625, ptr %67, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #6
  %626 = load float, ptr %67, align 4, !tbaa !15
  %627 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %628 = getelementptr inbounds [4 x float], ptr %627, i64 0, i64 0
  %629 = load float, ptr %628, align 16, !tbaa !10
  %630 = fsub float %626, %629
  store float %630, ptr %68, align 4, !tbaa !15
  %631 = load float, ptr %68, align 4, !tbaa !15
  %632 = fcmp olt float %631, 0xBF50624DE0000000
  br i1 %632, label %636, label %633

633:                                              ; preds = %606
  %634 = load float, ptr %68, align 4, !tbaa !15
  %635 = fcmp olt float 0x3F50624DE0000000, %634
  br i1 %635, label %636, label %649

636:                                              ; preds = %633, %606
  %637 = load ptr, ptr %2, align 8, !tbaa !5
  %638 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %637, i32 0, i32 1
  %639 = load i32, ptr %638, align 4, !tbaa !17
  %640 = add nsw i32 %639, 1
  store i32 %640, ptr %638, align 4, !tbaa !17
  %641 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %642 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %643 = getelementptr inbounds [4 x float], ptr %642, i64 0, i64 0
  %644 = load float, ptr %643, align 16, !tbaa !10
  %645 = fpext float %644 to double
  %646 = load float, ptr %67, align 4, !tbaa !15
  %647 = fpext float %646 to double
  %648 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.50, double noundef %645, double noundef %647)
  br label %649

649:                                              ; preds = %636, %633
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #6
  %650 = load ptr, ptr %2, align 8, !tbaa !5
  %651 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %650, i32 0, i32 0
  %652 = load i32, ptr %651, align 4, !tbaa !12
  %653 = add nsw i32 %652, 1
  store i32 %653, ptr %651, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #6
  %654 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 0
  %655 = getelementptr inbounds [4 x float], ptr %654, i64 0, i64 1
  %656 = load float, ptr %655, align 4, !tbaa !10
  store float %656, ptr %69, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #6
  %657 = load float, ptr %69, align 4, !tbaa !15
  %658 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %659 = getelementptr inbounds [4 x float], ptr %658, i64 0, i64 1
  %660 = load float, ptr %659, align 4, !tbaa !10
  %661 = fsub float %657, %660
  store float %661, ptr %70, align 4, !tbaa !15
  %662 = load float, ptr %70, align 4, !tbaa !15
  %663 = fcmp olt float %662, 0xBF50624DE0000000
  br i1 %663, label %667, label %664

664:                                              ; preds = %649
  %665 = load float, ptr %70, align 4, !tbaa !15
  %666 = fcmp olt float 0x3F50624DE0000000, %665
  br i1 %666, label %667, label %680

667:                                              ; preds = %664, %649
  %668 = load ptr, ptr %2, align 8, !tbaa !5
  %669 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %668, i32 0, i32 1
  %670 = load i32, ptr %669, align 4, !tbaa !17
  %671 = add nsw i32 %670, 1
  store i32 %671, ptr %669, align 4, !tbaa !17
  %672 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %673 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %674 = getelementptr inbounds [4 x float], ptr %673, i64 0, i64 1
  %675 = load float, ptr %674, align 4, !tbaa !10
  %676 = fpext float %675 to double
  %677 = load float, ptr %69, align 4, !tbaa !15
  %678 = fpext float %677 to double
  %679 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.51, double noundef %676, double noundef %678)
  br label %680

680:                                              ; preds = %667, %664
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #6
  %681 = load ptr, ptr %2, align 8, !tbaa !5
  %682 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %681, i32 0, i32 0
  %683 = load i32, ptr %682, align 4, !tbaa !12
  %684 = add nsw i32 %683, 1
  store i32 %684, ptr %682, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #6
  %685 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 0
  %686 = getelementptr inbounds [4 x float], ptr %685, i64 0, i64 2
  %687 = load float, ptr %686, align 8, !tbaa !10
  store float %687, ptr %71, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #6
  %688 = load float, ptr %71, align 4, !tbaa !15
  %689 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %690 = getelementptr inbounds [4 x float], ptr %689, i64 0, i64 2
  %691 = load float, ptr %690, align 8, !tbaa !10
  %692 = fsub float %688, %691
  store float %692, ptr %72, align 4, !tbaa !15
  %693 = load float, ptr %72, align 4, !tbaa !15
  %694 = fcmp olt float %693, 0xBF50624DE0000000
  br i1 %694, label %698, label %695

695:                                              ; preds = %680
  %696 = load float, ptr %72, align 4, !tbaa !15
  %697 = fcmp olt float 0x3F50624DE0000000, %696
  br i1 %697, label %698, label %711

698:                                              ; preds = %695, %680
  %699 = load ptr, ptr %2, align 8, !tbaa !5
  %700 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %699, i32 0, i32 1
  %701 = load i32, ptr %700, align 4, !tbaa !17
  %702 = add nsw i32 %701, 1
  store i32 %702, ptr %700, align 4, !tbaa !17
  %703 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %704 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %705 = getelementptr inbounds [4 x float], ptr %704, i64 0, i64 2
  %706 = load float, ptr %705, align 8, !tbaa !10
  %707 = fpext float %706 to double
  %708 = load float, ptr %71, align 4, !tbaa !15
  %709 = fpext float %708 to double
  %710 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.52, double noundef %707, double noundef %709)
  br label %711

711:                                              ; preds = %698, %695
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #6
  %712 = load ptr, ptr %2, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %712, i32 0, i32 0
  %714 = load i32, ptr %713, align 4, !tbaa !12
  %715 = add nsw i32 %714, 1
  store i32 %715, ptr %713, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #6
  %716 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 0
  %717 = getelementptr inbounds [4 x float], ptr %716, i64 0, i64 3
  %718 = load float, ptr %717, align 4, !tbaa !10
  store float %718, ptr %73, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #6
  %719 = load float, ptr %73, align 4, !tbaa !15
  %720 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %721 = getelementptr inbounds [4 x float], ptr %720, i64 0, i64 3
  %722 = load float, ptr %721, align 4, !tbaa !10
  %723 = fsub float %719, %722
  store float %723, ptr %74, align 4, !tbaa !15
  %724 = load float, ptr %74, align 4, !tbaa !15
  %725 = fcmp olt float %724, 0xBF50624DE0000000
  br i1 %725, label %729, label %726

726:                                              ; preds = %711
  %727 = load float, ptr %74, align 4, !tbaa !15
  %728 = fcmp olt float 0x3F50624DE0000000, %727
  br i1 %728, label %729, label %742

729:                                              ; preds = %726, %711
  %730 = load ptr, ptr %2, align 8, !tbaa !5
  %731 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %730, i32 0, i32 1
  %732 = load i32, ptr %731, align 4, !tbaa !17
  %733 = add nsw i32 %732, 1
  store i32 %733, ptr %731, align 4, !tbaa !17
  %734 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %735 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 0
  %736 = getelementptr inbounds [4 x float], ptr %735, i64 0, i64 3
  %737 = load float, ptr %736, align 4, !tbaa !10
  %738 = fpext float %737 to double
  %739 = load float, ptr %73, align 4, !tbaa !15
  %740 = fpext float %739 to double
  %741 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.53, double noundef %738, double noundef %740)
  br label %742

742:                                              ; preds = %729, %726
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #6
  %743 = load ptr, ptr %2, align 8, !tbaa !5
  %744 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %743, i32 0, i32 0
  %745 = load i32, ptr %744, align 4, !tbaa !12
  %746 = add nsw i32 %745, 1
  store i32 %746, ptr %744, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #6
  %747 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 1
  %748 = getelementptr inbounds [4 x float], ptr %747, i64 0, i64 0
  %749 = load float, ptr %748, align 16, !tbaa !10
  store float %749, ptr %75, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #6
  %750 = load float, ptr %75, align 4, !tbaa !15
  %751 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %752 = getelementptr inbounds [4 x float], ptr %751, i64 0, i64 0
  %753 = load float, ptr %752, align 16, !tbaa !10
  %754 = fsub float %750, %753
  store float %754, ptr %76, align 4, !tbaa !15
  %755 = load float, ptr %76, align 4, !tbaa !15
  %756 = fcmp olt float %755, 0xBF50624DE0000000
  br i1 %756, label %760, label %757

757:                                              ; preds = %742
  %758 = load float, ptr %76, align 4, !tbaa !15
  %759 = fcmp olt float 0x3F50624DE0000000, %758
  br i1 %759, label %760, label %773

760:                                              ; preds = %757, %742
  %761 = load ptr, ptr %2, align 8, !tbaa !5
  %762 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %761, i32 0, i32 1
  %763 = load i32, ptr %762, align 4, !tbaa !17
  %764 = add nsw i32 %763, 1
  store i32 %764, ptr %762, align 4, !tbaa !17
  %765 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %766 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %767 = getelementptr inbounds [4 x float], ptr %766, i64 0, i64 0
  %768 = load float, ptr %767, align 16, !tbaa !10
  %769 = fpext float %768 to double
  %770 = load float, ptr %75, align 4, !tbaa !15
  %771 = fpext float %770 to double
  %772 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.54, double noundef %769, double noundef %771)
  br label %773

773:                                              ; preds = %760, %757
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #6
  %774 = load ptr, ptr %2, align 8, !tbaa !5
  %775 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %774, i32 0, i32 0
  %776 = load i32, ptr %775, align 4, !tbaa !12
  %777 = add nsw i32 %776, 1
  store i32 %777, ptr %775, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #6
  %778 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 1
  %779 = getelementptr inbounds [4 x float], ptr %778, i64 0, i64 1
  %780 = load float, ptr %779, align 4, !tbaa !10
  store float %780, ptr %77, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #6
  %781 = load float, ptr %77, align 4, !tbaa !15
  %782 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %783 = getelementptr inbounds [4 x float], ptr %782, i64 0, i64 1
  %784 = load float, ptr %783, align 4, !tbaa !10
  %785 = fsub float %781, %784
  store float %785, ptr %78, align 4, !tbaa !15
  %786 = load float, ptr %78, align 4, !tbaa !15
  %787 = fcmp olt float %786, 0xBF50624DE0000000
  br i1 %787, label %791, label %788

788:                                              ; preds = %773
  %789 = load float, ptr %78, align 4, !tbaa !15
  %790 = fcmp olt float 0x3F50624DE0000000, %789
  br i1 %790, label %791, label %804

791:                                              ; preds = %788, %773
  %792 = load ptr, ptr %2, align 8, !tbaa !5
  %793 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %792, i32 0, i32 1
  %794 = load i32, ptr %793, align 4, !tbaa !17
  %795 = add nsw i32 %794, 1
  store i32 %795, ptr %793, align 4, !tbaa !17
  %796 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %797 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %798 = getelementptr inbounds [4 x float], ptr %797, i64 0, i64 1
  %799 = load float, ptr %798, align 4, !tbaa !10
  %800 = fpext float %799 to double
  %801 = load float, ptr %77, align 4, !tbaa !15
  %802 = fpext float %801 to double
  %803 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.55, double noundef %800, double noundef %802)
  br label %804

804:                                              ; preds = %791, %788
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #6
  %805 = load ptr, ptr %2, align 8, !tbaa !5
  %806 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %805, i32 0, i32 0
  %807 = load i32, ptr %806, align 4, !tbaa !12
  %808 = add nsw i32 %807, 1
  store i32 %808, ptr %806, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #6
  %809 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 1
  %810 = getelementptr inbounds [4 x float], ptr %809, i64 0, i64 2
  %811 = load float, ptr %810, align 8, !tbaa !10
  store float %811, ptr %79, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %80) #6
  %812 = load float, ptr %79, align 4, !tbaa !15
  %813 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %814 = getelementptr inbounds [4 x float], ptr %813, i64 0, i64 2
  %815 = load float, ptr %814, align 8, !tbaa !10
  %816 = fsub float %812, %815
  store float %816, ptr %80, align 4, !tbaa !15
  %817 = load float, ptr %80, align 4, !tbaa !15
  %818 = fcmp olt float %817, 0xBF50624DE0000000
  br i1 %818, label %822, label %819

819:                                              ; preds = %804
  %820 = load float, ptr %80, align 4, !tbaa !15
  %821 = fcmp olt float 0x3F50624DE0000000, %820
  br i1 %821, label %822, label %835

822:                                              ; preds = %819, %804
  %823 = load ptr, ptr %2, align 8, !tbaa !5
  %824 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %823, i32 0, i32 1
  %825 = load i32, ptr %824, align 4, !tbaa !17
  %826 = add nsw i32 %825, 1
  store i32 %826, ptr %824, align 4, !tbaa !17
  %827 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %828 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %829 = getelementptr inbounds [4 x float], ptr %828, i64 0, i64 2
  %830 = load float, ptr %829, align 8, !tbaa !10
  %831 = fpext float %830 to double
  %832 = load float, ptr %79, align 4, !tbaa !15
  %833 = fpext float %832 to double
  %834 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.56, double noundef %831, double noundef %833)
  br label %835

835:                                              ; preds = %822, %819
  call void @llvm.lifetime.end.p0(i64 4, ptr %80) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #6
  %836 = load ptr, ptr %2, align 8, !tbaa !5
  %837 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %836, i32 0, i32 0
  %838 = load i32, ptr %837, align 4, !tbaa !12
  %839 = add nsw i32 %838, 1
  store i32 %839, ptr %837, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #6
  %840 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 1
  %841 = getelementptr inbounds [4 x float], ptr %840, i64 0, i64 3
  %842 = load float, ptr %841, align 4, !tbaa !10
  store float %842, ptr %81, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #6
  %843 = load float, ptr %81, align 4, !tbaa !15
  %844 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %845 = getelementptr inbounds [4 x float], ptr %844, i64 0, i64 3
  %846 = load float, ptr %845, align 4, !tbaa !10
  %847 = fsub float %843, %846
  store float %847, ptr %82, align 4, !tbaa !15
  %848 = load float, ptr %82, align 4, !tbaa !15
  %849 = fcmp olt float %848, 0xBF50624DE0000000
  br i1 %849, label %853, label %850

850:                                              ; preds = %835
  %851 = load float, ptr %82, align 4, !tbaa !15
  %852 = fcmp olt float 0x3F50624DE0000000, %851
  br i1 %852, label %853, label %866

853:                                              ; preds = %850, %835
  %854 = load ptr, ptr %2, align 8, !tbaa !5
  %855 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %854, i32 0, i32 1
  %856 = load i32, ptr %855, align 4, !tbaa !17
  %857 = add nsw i32 %856, 1
  store i32 %857, ptr %855, align 4, !tbaa !17
  %858 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %859 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 1
  %860 = getelementptr inbounds [4 x float], ptr %859, i64 0, i64 3
  %861 = load float, ptr %860, align 4, !tbaa !10
  %862 = fpext float %861 to double
  %863 = load float, ptr %81, align 4, !tbaa !15
  %864 = fpext float %863 to double
  %865 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.57, double noundef %862, double noundef %864)
  br label %866

866:                                              ; preds = %853, %850
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #6
  %867 = load ptr, ptr %2, align 8, !tbaa !5
  %868 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %867, i32 0, i32 0
  %869 = load i32, ptr %868, align 4, !tbaa !12
  %870 = add nsw i32 %869, 1
  store i32 %870, ptr %868, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #6
  %871 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 2
  %872 = getelementptr inbounds [4 x float], ptr %871, i64 0, i64 0
  %873 = load float, ptr %872, align 16, !tbaa !10
  store float %873, ptr %83, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #6
  %874 = load float, ptr %83, align 4, !tbaa !15
  %875 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %876 = getelementptr inbounds [4 x float], ptr %875, i64 0, i64 0
  %877 = load float, ptr %876, align 16, !tbaa !10
  %878 = fsub float %874, %877
  store float %878, ptr %84, align 4, !tbaa !15
  %879 = load float, ptr %84, align 4, !tbaa !15
  %880 = fcmp olt float %879, 0xBF50624DE0000000
  br i1 %880, label %884, label %881

881:                                              ; preds = %866
  %882 = load float, ptr %84, align 4, !tbaa !15
  %883 = fcmp olt float 0x3F50624DE0000000, %882
  br i1 %883, label %884, label %897

884:                                              ; preds = %881, %866
  %885 = load ptr, ptr %2, align 8, !tbaa !5
  %886 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %885, i32 0, i32 1
  %887 = load i32, ptr %886, align 4, !tbaa !17
  %888 = add nsw i32 %887, 1
  store i32 %888, ptr %886, align 4, !tbaa !17
  %889 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %890 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %891 = getelementptr inbounds [4 x float], ptr %890, i64 0, i64 0
  %892 = load float, ptr %891, align 16, !tbaa !10
  %893 = fpext float %892 to double
  %894 = load float, ptr %83, align 4, !tbaa !15
  %895 = fpext float %894 to double
  %896 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.58, double noundef %893, double noundef %895)
  br label %897

897:                                              ; preds = %884, %881
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  %898 = load ptr, ptr %2, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %898, i32 0, i32 0
  %900 = load i32, ptr %899, align 4, !tbaa !12
  %901 = add nsw i32 %900, 1
  store i32 %901, ptr %899, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #6
  %902 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 2
  %903 = getelementptr inbounds [4 x float], ptr %902, i64 0, i64 1
  %904 = load float, ptr %903, align 4, !tbaa !10
  store float %904, ptr %85, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #6
  %905 = load float, ptr %85, align 4, !tbaa !15
  %906 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %907 = getelementptr inbounds [4 x float], ptr %906, i64 0, i64 1
  %908 = load float, ptr %907, align 4, !tbaa !10
  %909 = fsub float %905, %908
  store float %909, ptr %86, align 4, !tbaa !15
  %910 = load float, ptr %86, align 4, !tbaa !15
  %911 = fcmp olt float %910, 0xBF50624DE0000000
  br i1 %911, label %915, label %912

912:                                              ; preds = %897
  %913 = load float, ptr %86, align 4, !tbaa !15
  %914 = fcmp olt float 0x3F50624DE0000000, %913
  br i1 %914, label %915, label %928

915:                                              ; preds = %912, %897
  %916 = load ptr, ptr %2, align 8, !tbaa !5
  %917 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %916, i32 0, i32 1
  %918 = load i32, ptr %917, align 4, !tbaa !17
  %919 = add nsw i32 %918, 1
  store i32 %919, ptr %917, align 4, !tbaa !17
  %920 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %921 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %922 = getelementptr inbounds [4 x float], ptr %921, i64 0, i64 1
  %923 = load float, ptr %922, align 4, !tbaa !10
  %924 = fpext float %923 to double
  %925 = load float, ptr %85, align 4, !tbaa !15
  %926 = fpext float %925 to double
  %927 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.59, double noundef %924, double noundef %926)
  br label %928

928:                                              ; preds = %915, %912
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #6
  %929 = load ptr, ptr %2, align 8, !tbaa !5
  %930 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %929, i32 0, i32 0
  %931 = load i32, ptr %930, align 4, !tbaa !12
  %932 = add nsw i32 %931, 1
  store i32 %932, ptr %930, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #6
  %933 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 2
  %934 = getelementptr inbounds [4 x float], ptr %933, i64 0, i64 2
  %935 = load float, ptr %934, align 8, !tbaa !10
  store float %935, ptr %87, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #6
  %936 = load float, ptr %87, align 4, !tbaa !15
  %937 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %938 = getelementptr inbounds [4 x float], ptr %937, i64 0, i64 2
  %939 = load float, ptr %938, align 8, !tbaa !10
  %940 = fsub float %936, %939
  store float %940, ptr %88, align 4, !tbaa !15
  %941 = load float, ptr %88, align 4, !tbaa !15
  %942 = fcmp olt float %941, 0xBF50624DE0000000
  br i1 %942, label %946, label %943

943:                                              ; preds = %928
  %944 = load float, ptr %88, align 4, !tbaa !15
  %945 = fcmp olt float 0x3F50624DE0000000, %944
  br i1 %945, label %946, label %959

946:                                              ; preds = %943, %928
  %947 = load ptr, ptr %2, align 8, !tbaa !5
  %948 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %947, i32 0, i32 1
  %949 = load i32, ptr %948, align 4, !tbaa !17
  %950 = add nsw i32 %949, 1
  store i32 %950, ptr %948, align 4, !tbaa !17
  %951 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %952 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %953 = getelementptr inbounds [4 x float], ptr %952, i64 0, i64 2
  %954 = load float, ptr %953, align 8, !tbaa !10
  %955 = fpext float %954 to double
  %956 = load float, ptr %87, align 4, !tbaa !15
  %957 = fpext float %956 to double
  %958 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.60, double noundef %955, double noundef %957)
  br label %959

959:                                              ; preds = %946, %943
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #6
  %960 = load ptr, ptr %2, align 8, !tbaa !5
  %961 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %960, i32 0, i32 0
  %962 = load i32, ptr %961, align 4, !tbaa !12
  %963 = add nsw i32 %962, 1
  store i32 %963, ptr %961, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %89) #6
  %964 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 2
  %965 = getelementptr inbounds [4 x float], ptr %964, i64 0, i64 3
  %966 = load float, ptr %965, align 4, !tbaa !10
  store float %966, ptr %89, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #6
  %967 = load float, ptr %89, align 4, !tbaa !15
  %968 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %969 = getelementptr inbounds [4 x float], ptr %968, i64 0, i64 3
  %970 = load float, ptr %969, align 4, !tbaa !10
  %971 = fsub float %967, %970
  store float %971, ptr %90, align 4, !tbaa !15
  %972 = load float, ptr %90, align 4, !tbaa !15
  %973 = fcmp olt float %972, 0xBF50624DE0000000
  br i1 %973, label %977, label %974

974:                                              ; preds = %959
  %975 = load float, ptr %90, align 4, !tbaa !15
  %976 = fcmp olt float 0x3F50624DE0000000, %975
  br i1 %976, label %977, label %990

977:                                              ; preds = %974, %959
  %978 = load ptr, ptr %2, align 8, !tbaa !5
  %979 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %978, i32 0, i32 1
  %980 = load i32, ptr %979, align 4, !tbaa !17
  %981 = add nsw i32 %980, 1
  store i32 %981, ptr %979, align 4, !tbaa !17
  %982 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %983 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %984 = getelementptr inbounds [4 x float], ptr %983, i64 0, i64 3
  %985 = load float, ptr %984, align 4, !tbaa !10
  %986 = fpext float %985 to double
  %987 = load float, ptr %89, align 4, !tbaa !15
  %988 = fpext float %987 to double
  %989 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.61, double noundef %986, double noundef %988)
  br label %990

990:                                              ; preds = %977, %974
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %89) #6
  %991 = load ptr, ptr %2, align 8, !tbaa !5
  %992 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %991, i32 0, i32 0
  %993 = load i32, ptr %992, align 4, !tbaa !12
  %994 = add nsw i32 %993, 1
  store i32 %994, ptr %992, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #6
  %995 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 3
  %996 = getelementptr inbounds [4 x float], ptr %995, i64 0, i64 0
  %997 = load float, ptr %996, align 16, !tbaa !10
  store float %997, ptr %91, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #6
  %998 = load float, ptr %91, align 4, !tbaa !15
  %999 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1000 = getelementptr inbounds [4 x float], ptr %999, i64 0, i64 0
  %1001 = load float, ptr %1000, align 16, !tbaa !10
  %1002 = fsub float %998, %1001
  store float %1002, ptr %92, align 4, !tbaa !15
  %1003 = load float, ptr %92, align 4, !tbaa !15
  %1004 = fcmp olt float %1003, 0xBF50624DE0000000
  br i1 %1004, label %1008, label %1005

1005:                                             ; preds = %990
  %1006 = load float, ptr %92, align 4, !tbaa !15
  %1007 = fcmp olt float 0x3F50624DE0000000, %1006
  br i1 %1007, label %1008, label %1021

1008:                                             ; preds = %1005, %990
  %1009 = load ptr, ptr %2, align 8, !tbaa !5
  %1010 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1009, i32 0, i32 1
  %1011 = load i32, ptr %1010, align 4, !tbaa !17
  %1012 = add nsw i32 %1011, 1
  store i32 %1012, ptr %1010, align 4, !tbaa !17
  %1013 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %1014 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1015 = getelementptr inbounds [4 x float], ptr %1014, i64 0, i64 0
  %1016 = load float, ptr %1015, align 16, !tbaa !10
  %1017 = fpext float %1016 to double
  %1018 = load float, ptr %91, align 4, !tbaa !15
  %1019 = fpext float %1018 to double
  %1020 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.62, double noundef %1017, double noundef %1019)
  br label %1021

1021:                                             ; preds = %1008, %1005
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #6
  %1022 = load ptr, ptr %2, align 8, !tbaa !5
  %1023 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1022, i32 0, i32 0
  %1024 = load i32, ptr %1023, align 4, !tbaa !12
  %1025 = add nsw i32 %1024, 1
  store i32 %1025, ptr %1023, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #6
  %1026 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 3
  %1027 = getelementptr inbounds [4 x float], ptr %1026, i64 0, i64 1
  %1028 = load float, ptr %1027, align 4, !tbaa !10
  store float %1028, ptr %93, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #6
  %1029 = load float, ptr %93, align 4, !tbaa !15
  %1030 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1031 = getelementptr inbounds [4 x float], ptr %1030, i64 0, i64 1
  %1032 = load float, ptr %1031, align 4, !tbaa !10
  %1033 = fsub float %1029, %1032
  store float %1033, ptr %94, align 4, !tbaa !15
  %1034 = load float, ptr %94, align 4, !tbaa !15
  %1035 = fcmp olt float %1034, 0xBF50624DE0000000
  br i1 %1035, label %1039, label %1036

1036:                                             ; preds = %1021
  %1037 = load float, ptr %94, align 4, !tbaa !15
  %1038 = fcmp olt float 0x3F50624DE0000000, %1037
  br i1 %1038, label %1039, label %1052

1039:                                             ; preds = %1036, %1021
  %1040 = load ptr, ptr %2, align 8, !tbaa !5
  %1041 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1040, i32 0, i32 1
  %1042 = load i32, ptr %1041, align 4, !tbaa !17
  %1043 = add nsw i32 %1042, 1
  store i32 %1043, ptr %1041, align 4, !tbaa !17
  %1044 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %1045 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1046 = getelementptr inbounds [4 x float], ptr %1045, i64 0, i64 1
  %1047 = load float, ptr %1046, align 4, !tbaa !10
  %1048 = fpext float %1047 to double
  %1049 = load float, ptr %93, align 4, !tbaa !15
  %1050 = fpext float %1049 to double
  %1051 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.63, double noundef %1048, double noundef %1050)
  br label %1052

1052:                                             ; preds = %1039, %1036
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #6
  %1053 = load ptr, ptr %2, align 8, !tbaa !5
  %1054 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1053, i32 0, i32 0
  %1055 = load i32, ptr %1054, align 4, !tbaa !12
  %1056 = add nsw i32 %1055, 1
  store i32 %1056, ptr %1054, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #6
  %1057 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 3
  %1058 = getelementptr inbounds [4 x float], ptr %1057, i64 0, i64 2
  %1059 = load float, ptr %1058, align 8, !tbaa !10
  store float %1059, ptr %95, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #6
  %1060 = load float, ptr %95, align 4, !tbaa !15
  %1061 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1062 = getelementptr inbounds [4 x float], ptr %1061, i64 0, i64 2
  %1063 = load float, ptr %1062, align 8, !tbaa !10
  %1064 = fsub float %1060, %1063
  store float %1064, ptr %96, align 4, !tbaa !15
  %1065 = load float, ptr %96, align 4, !tbaa !15
  %1066 = fcmp olt float %1065, 0xBF50624DE0000000
  br i1 %1066, label %1070, label %1067

1067:                                             ; preds = %1052
  %1068 = load float, ptr %96, align 4, !tbaa !15
  %1069 = fcmp olt float 0x3F50624DE0000000, %1068
  br i1 %1069, label %1070, label %1083

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

1083:                                             ; preds = %1070, %1067
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #6
  %1084 = load ptr, ptr %2, align 8, !tbaa !5
  %1085 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1084, i32 0, i32 0
  %1086 = load i32, ptr %1085, align 4, !tbaa !12
  %1087 = add nsw i32 %1086, 1
  store i32 %1087, ptr %1085, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #6
  %1088 = getelementptr inbounds [4 x [4 x float]], ptr %64, i64 0, i64 3
  %1089 = getelementptr inbounds [4 x float], ptr %1088, i64 0, i64 3
  %1090 = load float, ptr %1089, align 4, !tbaa !10
  store float %1090, ptr %97, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #6
  %1091 = load float, ptr %97, align 4, !tbaa !15
  %1092 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1093 = getelementptr inbounds [4 x float], ptr %1092, i64 0, i64 3
  %1094 = load float, ptr %1093, align 4, !tbaa !10
  %1095 = fsub float %1091, %1094
  store float %1095, ptr %98, align 4, !tbaa !15
  %1096 = load float, ptr %98, align 4, !tbaa !15
  %1097 = fcmp olt float %1096, 0xBF50624DE0000000
  br i1 %1097, label %1101, label %1098

1098:                                             ; preds = %1083
  %1099 = load float, ptr %98, align 4, !tbaa !15
  %1100 = fcmp olt float 0x3F50624DE0000000, %1099
  br i1 %1100, label %1101, label %1114

1101:                                             ; preds = %1098, %1083
  %1102 = load ptr, ptr %2, align 8, !tbaa !5
  %1103 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1102, i32 0, i32 1
  %1104 = load i32, ptr %1103, align 4, !tbaa !17
  %1105 = add nsw i32 %1104, 1
  store i32 %1105, ptr %1103, align 4, !tbaa !17
  %1106 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 317)
  %1107 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 3
  %1108 = getelementptr inbounds [4 x float], ptr %1107, i64 0, i64 3
  %1109 = load float, ptr %1108, align 4, !tbaa !10
  %1110 = fpext float %1109 to double
  %1111 = load float, ptr %97, align 4, !tbaa !15
  %1112 = fpext float %1111 to double
  %1113 = call i32 (ptr, ...) @printf(ptr noundef @.str.68, ptr noundef @.str.65, double noundef %1110, double noundef %1112)
  br label %1114

1114:                                             ; preds = %1101, %1098
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %61) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 12, ptr %51) #6
  ret void
}

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

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

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

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { inlinehint mustprogress uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { mustprogress uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { inlinehint mustprogress uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { 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
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@.str.68 = external hidden unnamed_addr constant [24 x i8], align 1
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye.69 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center.70 = external hidden unnamed_addr constant %union.HMM_Vec3, align 4
@__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up.71 = 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 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_InvLookAtP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #3 {
  %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.0222.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye, align 4
  %.sroa.4223.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye, i64 8), align 4
  %.sroa.0220.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center, align 4
  %.sroa.4221.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center, i64 8), align 4
  %.sroa.0218.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up, align 4
  %.sroa.4219.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up, i64 8), align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #6
  call void @_ZL13HMM_LookAt_RH8HMM_Vec3S_S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, <2 x float> %.sroa.0222.0.copyload, float %.sroa.4223.0.copyload, <2 x float> %.sroa.0220.0.copyload, float %.sroa.4221.0.copyload, <2 x float> %.sroa.0218.0.copyload, float %.sroa.4219.0.copyload)
  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_InvLookAt8HMM_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)
  %10 = load i32, ptr %0, align 4, !tbaa !5
  %11 = add nsw i32 %10, 1
  store i32 %11, ptr %0, align 4, !tbaa !5
  %12 = load float, ptr %5, align 16, !tbaa !10
  %13 = load float, ptr %3, align 16, !tbaa !10
  %14 = fsub float %12, %13
  %15 = call float @llvm.fabs.f32(float %14)
  %or.cond = fcmp ogt float %15, 0x3F50624DE0000000
  br i1 %or.cond, label %16, label %25

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

295:                                              ; preds = %277, %286
  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.0140.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye.69, align 4
  %.sroa.4141.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Eye.69, i64 8), align 4
  %.sroa.0138.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center.70, align 4
  %.sroa.4139.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Center.70, i64 8), align 4
  %.sroa.0137.0.copyload = load <2 x float>, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up.71, align 4
  %.sroa.4.0.copyload = load float, ptr getelementptr inbounds (i8, ptr @__const._Z29_hmt_test_InvMatrix_InvLookAtP21hmt_testresult_struct.Up.71, i64 8), align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %6) #6
  call void @_ZL13HMM_LookAt_LH8HMM_Vec3S_S_(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %6, <2 x float> %.sroa.0140.0.copyload, float %.sroa.4141.0.copyload, <2 x float> %.sroa.0138.0.copyload, float %.sroa.4139.0.copyload, <2 x float> %.sroa.0137.0.copyload, float %.sroa.4.0.copyload)
  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_InvLookAt8HMM_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)
  %296 = load i32, ptr %0, align 4, !tbaa !5
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %0, align 4, !tbaa !5
  %298 = load float, ptr %9, align 16, !tbaa !10
  %299 = load float, ptr %7, align 16, !tbaa !10
  %300 = fsub float %298, %299
  %301 = call float @llvm.fabs.f32(float %300)
  %or.cond33 = fcmp ogt float %301, 0x3F50624DE0000000
  br i1 %or.cond33, label %302, label %311

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

311:                                              ; preds = %295, %302
  %312 = phi i32 [ %297, %295 ], [ %.pre302, %302 ]
  %313 = add nsw i32 %312, 1
  store i32 %313, ptr %0, align 4, !tbaa !5
  %314 = getelementptr inbounds i8, ptr %9, i64 4
  %315 = load float, ptr %314, align 4, !tbaa !10
  %316 = getelementptr inbounds i8, ptr %7, i64 4
  %317 = load float, ptr %316, align 4, !tbaa !10
  %318 = fsub float %315, %317
  %319 = call float @llvm.fabs.f32(float %318)
  %or.cond35 = fcmp ogt float %319, 0x3F50624DE0000000
  br i1 %or.cond35, label %320, label %329

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

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

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

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

356:                                              ; preds = %347
  %357 = getelementptr inbounds i8, ptr %0, i64 4
  %358 = load i32, ptr %357, align 4, !tbaa !11
  %359 = add nsw i32 %358, 1
  store i32 %359, ptr %357, align 4, !tbaa !11
  %360 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %361 = load float, ptr %352, align 4, !tbaa !10
  %362 = fpext float %361 to double
  %363 = fpext float %351 to double
  %364 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.53, double noundef %362, double noundef %363)
  %.pre305 = load i32, ptr %0, align 4, !tbaa !5
  br label %365

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

374:                                              ; preds = %365
  %375 = getelementptr inbounds i8, ptr %0, i64 4
  %376 = load i32, ptr %375, align 4, !tbaa !11
  %377 = add nsw i32 %376, 1
  store i32 %377, ptr %375, align 4, !tbaa !11
  %378 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %379 = load float, ptr %370, align 16, !tbaa !10
  %380 = fpext float %379 to double
  %381 = fpext float %369 to double
  %382 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.54, double noundef %380, double noundef %381)
  %.pre306 = load i32, ptr %0, align 4, !tbaa !5
  br label %383

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

392:                                              ; preds = %383
  %393 = getelementptr inbounds i8, ptr %0, i64 4
  %394 = load i32, ptr %393, align 4, !tbaa !11
  %395 = add nsw i32 %394, 1
  store i32 %395, ptr %393, align 4, !tbaa !11
  %396 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %397 = load float, ptr %388, align 4, !tbaa !10
  %398 = fpext float %397 to double
  %399 = fpext float %387 to double
  %400 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.55, double noundef %398, double noundef %399)
  %.pre307 = load i32, ptr %0, align 4, !tbaa !5
  br label %401

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

410:                                              ; preds = %401
  %411 = getelementptr inbounds i8, ptr %0, i64 4
  %412 = load i32, ptr %411, align 4, !tbaa !11
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %411, align 4, !tbaa !11
  %414 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %415 = load float, ptr %406, align 8, !tbaa !10
  %416 = fpext float %415 to double
  %417 = fpext float %405 to double
  %418 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.56, double noundef %416, double noundef %417)
  %.pre308 = load i32, ptr %0, align 4, !tbaa !5
  br label %419

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

428:                                              ; preds = %419
  %429 = getelementptr inbounds i8, ptr %0, i64 4
  %430 = load i32, ptr %429, align 4, !tbaa !11
  %431 = add nsw i32 %430, 1
  store i32 %431, ptr %429, align 4, !tbaa !11
  %432 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %433 = load float, ptr %424, align 4, !tbaa !10
  %434 = fpext float %433 to double
  %435 = fpext float %423 to double
  %436 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.57, double noundef %434, double noundef %435)
  %.pre309 = load i32, ptr %0, align 4, !tbaa !5
  br label %437

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

446:                                              ; preds = %437
  %447 = getelementptr inbounds i8, ptr %0, i64 4
  %448 = load i32, ptr %447, align 4, !tbaa !11
  %449 = add nsw i32 %448, 1
  store i32 %449, ptr %447, align 4, !tbaa !11
  %450 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %451 = load float, ptr %442, align 16, !tbaa !10
  %452 = fpext float %451 to double
  %453 = fpext float %441 to double
  %454 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.58, double noundef %452, double noundef %453)
  %.pre310 = load i32, ptr %0, align 4, !tbaa !5
  br label %455

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

464:                                              ; preds = %455
  %465 = getelementptr inbounds i8, ptr %0, i64 4
  %466 = load i32, ptr %465, align 4, !tbaa !11
  %467 = add nsw i32 %466, 1
  store i32 %467, ptr %465, align 4, !tbaa !11
  %468 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %469 = load float, ptr %460, align 4, !tbaa !10
  %470 = fpext float %469 to double
  %471 = fpext float %459 to double
  %472 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.59, double noundef %470, double noundef %471)
  %.pre311 = load i32, ptr %0, align 4, !tbaa !5
  br label %473

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

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

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

500:                                              ; preds = %491
  %501 = getelementptr inbounds i8, ptr %0, i64 4
  %502 = load i32, ptr %501, align 4, !tbaa !11
  %503 = add nsw i32 %502, 1
  store i32 %503, ptr %501, align 4, !tbaa !11
  %504 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %505 = load float, ptr %496, align 4, !tbaa !10
  %506 = fpext float %505 to double
  %507 = fpext float %495 to double
  %508 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.61, double noundef %506, double noundef %507)
  %.pre313 = load i32, ptr %0, align 4, !tbaa !5
  br label %509

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

518:                                              ; preds = %509
  %519 = getelementptr inbounds i8, ptr %0, i64 4
  %520 = load i32, ptr %519, align 4, !tbaa !11
  %521 = add nsw i32 %520, 1
  store i32 %521, ptr %519, align 4, !tbaa !11
  %522 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %523 = load float, ptr %514, align 16, !tbaa !10
  %524 = fpext float %523 to double
  %525 = fpext float %513 to double
  %526 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.62, double noundef %524, double noundef %525)
  %.pre314 = load i32, ptr %0, align 4, !tbaa !5
  br label %527

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

536:                                              ; preds = %527
  %537 = getelementptr inbounds i8, ptr %0, i64 4
  %538 = load i32, ptr %537, align 4, !tbaa !11
  %539 = add nsw i32 %538, 1
  store i32 %539, ptr %537, align 4, !tbaa !11
  %540 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %541 = load float, ptr %532, align 4, !tbaa !10
  %542 = fpext float %541 to double
  %543 = fpext float %531 to double
  %544 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.63, double noundef %542, double noundef %543)
  %.pre315 = load i32, ptr %0, align 4, !tbaa !5
  br label %545

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

554:                                              ; preds = %545
  %555 = getelementptr inbounds i8, ptr %0, i64 4
  %556 = load i32, ptr %555, align 4, !tbaa !11
  %557 = add nsw i32 %556, 1
  store i32 %557, ptr %555, align 4, !tbaa !11
  %558 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 317)
  %559 = load float, ptr %550, align 8, !tbaa !10
  %560 = fpext float %559 to double
  %561 = fpext float %549 to double
  %562 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.68, ptr noundef nonnull @.str.64, double noundef %560, double noundef %561)
  %.pre316 = load i32, ptr %0, align 4, !tbaa !5
  br label %563

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

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

581:                                              ; preds = %563, %572
  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_LookAt_RH8HMM_Vec3S_S_(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, <2 x float>, float, <2 x float>, float, <2 x float>, float) local_unnamed_addr #4

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

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

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

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