; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z32_hmt_test_Projection_PerspectiveP21hmt_testresult_struct)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%union.HMM_Mat4 = type { [4 x %union.HMM_Vec4] }
%union.HMM_Vec4 = type { <4 x float> }
%struct.hmt_testresult_struct = type { i32, i32 }
%struct.anon.10 = type { %union.anon, float }
%union.anon = type { %union.HMM_Vec3 }
%union.HMM_Vec3 = type { %struct.anon.3 }
%struct.anon.3 = type { float, float, float }
%struct.anon.11 = type { float, float, float }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [38 x i8], align 1
@.str.135 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.136 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.137 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.138 = external hidden unnamed_addr constant [12 x i8], align 1

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

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { double, double } @_ZL6HMM_V4ffff(float noundef, float noundef, float noundef, float noundef) #3

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

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16, double, double) #4

; Function Attrs: mustprogress uwtable
define dso_local void @_Z32_hmt_test_Projection_PerspectiveP21hmt_testresult_struct(ptr noundef %0) #5 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Vec4, align 16
  %5 = alloca float, align 4
  %6 = alloca %union.HMM_Vec4, align 16
  %7 = alloca %union.HMM_Mat4, align 16
  %8 = alloca %union.HMM_Vec4, align 16
  %9 = alloca float, align 4
  %10 = alloca %union.HMM_Vec4, align 16
  %11 = alloca %union.HMM_Vec4, align 16
  %12 = alloca float, align 4
  %13 = alloca %union.HMM_Vec4, align 16
  %14 = alloca %union.HMM_Mat4, align 16
  %15 = alloca %union.HMM_Vec4, align 16
  %16 = alloca float, align 4
  %17 = alloca %union.HMM_Vec4, align 16
  %18 = alloca %union.HMM_Vec4, align 16
  %19 = alloca float, align 4
  %20 = alloca %union.HMM_Vec4, align 16
  %21 = alloca %union.HMM_Mat4, align 16
  %22 = alloca %union.HMM_Vec4, align 16
  %23 = alloca float, align 4
  %24 = alloca %union.HMM_Vec4, align 16
  %25 = alloca %union.HMM_Vec4, align 16
  %26 = alloca float, align 4
  %27 = alloca %union.HMM_Vec4, align 16
  %28 = alloca %union.HMM_Mat4, align 16
  %29 = alloca %union.HMM_Vec4, align 16
  %30 = alloca float, align 4
  %31 = alloca %union.HMM_Vec4, align 16
  %32 = alloca %union.HMM_Vec4, align 16
  %33 = alloca %union.HMM_Mat4, align 16
  %34 = alloca %union.HMM_Vec4, align 16
  %35 = alloca float, align 4
  %36 = alloca %union.HMM_Vec4, align 16
  %37 = alloca %union.HMM_Mat4, align 16
  %38 = alloca %union.HMM_Vec4, align 16
  %39 = alloca float, align 4
  %40 = alloca %union.HMM_Vec4, align 16
  %41 = alloca %union.HMM_Vec4, align 16
  %42 = alloca float, align 4
  %43 = alloca %union.HMM_Vec4, align 16
  %44 = alloca %union.HMM_Mat4, align 16
  %45 = alloca %union.HMM_Vec4, align 16
  %46 = alloca float, align 4
  %47 = alloca %union.HMM_Vec4, align 16
  %48 = alloca %union.HMM_Vec4, align 16
  %49 = alloca float, align 4
  %50 = alloca %union.HMM_Vec4, align 16
  %51 = alloca %union.HMM_Mat4, align 16
  %52 = alloca %union.HMM_Vec4, align 16
  %53 = alloca float, align 4
  %54 = alloca %union.HMM_Vec4, align 16
  %55 = alloca %union.HMM_Vec4, align 16
  %56 = alloca float, align 4
  %57 = alloca %union.HMM_Vec4, align 16
  %58 = alloca %union.HMM_Mat4, align 16
  %59 = alloca %union.HMM_Vec4, align 16
  %60 = alloca float, align 4
  %61 = alloca %union.HMM_Vec4, align 16
  %62 = alloca %union.HMM_Vec4, align 16
  %63 = alloca %union.HMM_Mat4, align 16
  %64 = alloca %union.HMM_Vec4, align 16
  %65 = alloca float, align 4
  %66 = alloca %union.HMM_Vec4, align 16
  %67 = alloca %union.HMM_Mat4, align 16
  %68 = alloca %union.HMM_Vec4, align 16
  %69 = alloca float, align 4
  %70 = alloca %union.HMM_Vec4, align 16
  %71 = alloca %union.HMM_Vec4, align 16
  %72 = alloca float, align 4
  %73 = alloca %union.HMM_Vec4, align 16
  %74 = alloca %union.HMM_Mat4, align 16
  %75 = alloca %union.HMM_Vec4, align 16
  %76 = alloca float, align 4
  %77 = alloca %union.HMM_Vec4, align 16
  %78 = alloca %union.HMM_Vec4, align 16
  %79 = alloca float, align 4
  %80 = alloca %union.HMM_Vec4, align 16
  %81 = alloca %union.HMM_Mat4, align 16
  %82 = alloca %union.HMM_Vec4, align 16
  %83 = alloca float, align 4
  %84 = alloca %union.HMM_Vec4, align 16
  %85 = alloca %union.HMM_Vec4, align 16
  %86 = alloca float, align 4
  %87 = alloca %union.HMM_Vec4, align 16
  %88 = alloca %union.HMM_Mat4, align 16
  %89 = alloca %union.HMM_Vec4, align 16
  %90 = alloca float, align 4
  %91 = alloca %union.HMM_Vec4, align 16
  %92 = alloca %union.HMM_Vec4, align 16
  %93 = alloca %union.HMM_Mat4, align 16
  %94 = alloca %union.HMM_Vec4, align 16
  %95 = alloca float, align 4
  %96 = alloca %union.HMM_Vec4, align 16
  %97 = alloca %union.HMM_Mat4, align 16
  %98 = alloca %union.HMM_Vec4, align 16
  %99 = alloca float, align 4
  %100 = alloca %union.HMM_Vec4, align 16
  %101 = alloca %union.HMM_Vec4, align 16
  %102 = alloca float, align 4
  %103 = alloca %union.HMM_Vec4, align 16
  %104 = alloca %union.HMM_Mat4, align 16
  %105 = alloca %union.HMM_Vec4, align 16
  %106 = alloca float, align 4
  %107 = alloca %union.HMM_Vec4, align 16
  %108 = alloca %union.HMM_Vec4, align 16
  %109 = alloca float, align 4
  %110 = alloca %union.HMM_Vec4, align 16
  %111 = alloca %union.HMM_Mat4, align 16
  %112 = alloca %union.HMM_Vec4, align 16
  %113 = alloca float, align 4
  %114 = alloca %union.HMM_Vec4, align 16
  %115 = alloca %union.HMM_Vec4, align 16
  %116 = alloca float, align 4
  %117 = alloca %union.HMM_Vec4, align 16
  %118 = alloca %union.HMM_Mat4, align 16
  %119 = alloca %union.HMM_Vec4, align 16
  %120 = alloca float, align 4
  %121 = alloca %union.HMM_Vec4, align 16
  %122 = alloca %union.HMM_Vec4, align 16
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %3) #6
  call void @_ZL21HMM_Perspective_RH_NOffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %3, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  call void @llvm.lifetime.start.p0(i64 16, ptr %4) #6
  %123 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %124 = getelementptr inbounds %union.HMM_Vec4, ptr %4, i32 0, i32 0
  %125 = getelementptr inbounds { double, double }, ptr %124, i32 0, i32 0
  %126 = extractvalue { double, double } %123, 0
  store double %126, ptr %125, align 16
  %127 = getelementptr inbounds { double, double }, ptr %124, i32 0, i32 1
  %128 = extractvalue { double, double } %123, 1
  store double %128, ptr %127, align 8
  %129 = load ptr, ptr %2, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %129, i32 0, i32 0
  %131 = load i32, ptr %130, align 4, !tbaa !9
  %132 = add nsw i32 %131, 1
  store i32 %132, ptr %130, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %6) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %7, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %8, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %133 = getelementptr inbounds { double, double }, ptr %8, i32 0, i32 0
  %134 = load double, ptr %133, align 16
  %135 = getelementptr inbounds { double, double }, ptr %8, i32 0, i32 1
  %136 = load double, ptr %135, align 8
  %137 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %7, double %134, double %136)
  %138 = getelementptr inbounds %union.HMM_Vec4, ptr %6, i32 0, i32 0
  %139 = getelementptr inbounds { double, double }, ptr %138, i32 0, i32 0
  %140 = extractvalue { double, double } %137, 0
  store double %140, ptr %139, align 16
  %141 = getelementptr inbounds { double, double }, ptr %138, i32 0, i32 1
  %142 = extractvalue { double, double } %137, 1
  store double %142, ptr %141, align 8
  %143 = getelementptr inbounds %struct.anon.10, ptr %6, i32 0, i32 0
  %144 = getelementptr inbounds %struct.anon.11, ptr %143, i32 0, i32 0
  %145 = load float, ptr %144, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %6) #6
  store float %145, ptr %5, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #6
  %146 = load float, ptr %5, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %10) #6
  %147 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %148 = getelementptr inbounds %union.HMM_Vec4, ptr %10, i32 0, i32 0
  %149 = getelementptr inbounds { double, double }, ptr %148, i32 0, i32 0
  %150 = extractvalue { double, double } %147, 0
  store double %150, ptr %149, align 16
  %151 = getelementptr inbounds { double, double }, ptr %148, i32 0, i32 1
  %152 = extractvalue { double, double } %147, 1
  store double %152, ptr %151, align 8
  %153 = getelementptr inbounds %struct.anon.10, ptr %10, i32 0, i32 0
  %154 = getelementptr inbounds %struct.anon.11, ptr %153, i32 0, i32 0
  %155 = load float, ptr %154, align 16, !tbaa !13
  %156 = fsub float %146, %155
  call void @llvm.lifetime.end.p0(i64 16, ptr %10) #6
  store float %156, ptr %9, align 4, !tbaa !15
  %157 = load float, ptr %9, align 4, !tbaa !15
  %158 = fcmp olt float %157, 0xBE80000000000000
  br i1 %158, label %162, label %159

159:                                              ; preds = %1
  %160 = load float, ptr %9, align 4, !tbaa !15
  %161 = fcmp olt float 0x3E80000000000000, %160
  br i1 %161, label %162, label %183

162:                                              ; preds = %159, %1
  %163 = load ptr, ptr %2, align 8, !tbaa !5
  %164 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %163, i32 0, i32 1
  %165 = load i32, ptr %164, align 4, !tbaa !17
  %166 = add nsw i32 %165, 1
  store i32 %166, ptr %164, align 4, !tbaa !17
  %167 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 58)
  call void @llvm.lifetime.start.p0(i64 16, ptr %11) #6
  %168 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %169 = getelementptr inbounds %union.HMM_Vec4, ptr %11, i32 0, i32 0
  %170 = getelementptr inbounds { double, double }, ptr %169, i32 0, i32 0
  %171 = extractvalue { double, double } %168, 0
  store double %171, ptr %170, align 16
  %172 = getelementptr inbounds { double, double }, ptr %169, i32 0, i32 1
  %173 = extractvalue { double, double } %168, 1
  store double %173, ptr %172, align 8
  %174 = getelementptr inbounds %struct.anon.10, ptr %11, i32 0, i32 0
  %175 = getelementptr inbounds %struct.anon.11, ptr %174, i32 0, i32 0
  %176 = load float, ptr %175, align 16, !tbaa !13
  %177 = fpext float %176 to double
  %178 = load float, ptr %5, align 4, !tbaa !15
  %179 = fpext float %178 to double
  %180 = load float, ptr %9, align 4, !tbaa !15
  %181 = fpext float %180 to double
  %182 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %177, double noundef %179, double noundef %181)
  call void @llvm.lifetime.end.p0(i64 16, ptr %11) #6
  br label %183

183:                                              ; preds = %162, %159
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #6
  %184 = load ptr, ptr %2, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %184, i32 0, i32 0
  %186 = load i32, ptr %185, align 4, !tbaa !9
  %187 = add nsw i32 %186, 1
  store i32 %187, ptr %185, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %13) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %14, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %15, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %188 = getelementptr inbounds { double, double }, ptr %15, i32 0, i32 0
  %189 = load double, ptr %188, align 16
  %190 = getelementptr inbounds { double, double }, ptr %15, i32 0, i32 1
  %191 = load double, ptr %190, align 8
  %192 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %14, double %189, double %191)
  %193 = getelementptr inbounds %union.HMM_Vec4, ptr %13, i32 0, i32 0
  %194 = getelementptr inbounds { double, double }, ptr %193, i32 0, i32 0
  %195 = extractvalue { double, double } %192, 0
  store double %195, ptr %194, align 16
  %196 = getelementptr inbounds { double, double }, ptr %193, i32 0, i32 1
  %197 = extractvalue { double, double } %192, 1
  store double %197, ptr %196, align 8
  %198 = getelementptr inbounds %struct.anon.10, ptr %13, i32 0, i32 0
  %199 = getelementptr inbounds %struct.anon.11, ptr %198, i32 0, i32 1
  %200 = load float, ptr %199, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %13) #6
  store float %200, ptr %12, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %201 = load float, ptr %12, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %17) #6
  %202 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %203 = getelementptr inbounds %union.HMM_Vec4, ptr %17, i32 0, i32 0
  %204 = getelementptr inbounds { double, double }, ptr %203, i32 0, i32 0
  %205 = extractvalue { double, double } %202, 0
  store double %205, ptr %204, align 16
  %206 = getelementptr inbounds { double, double }, ptr %203, i32 0, i32 1
  %207 = extractvalue { double, double } %202, 1
  store double %207, ptr %206, align 8
  %208 = getelementptr inbounds %struct.anon.10, ptr %17, i32 0, i32 0
  %209 = getelementptr inbounds %struct.anon.11, ptr %208, i32 0, i32 1
  %210 = load float, ptr %209, align 4, !tbaa !13
  %211 = fsub float %201, %210
  call void @llvm.lifetime.end.p0(i64 16, ptr %17) #6
  store float %211, ptr %16, align 4, !tbaa !15
  %212 = load float, ptr %16, align 4, !tbaa !15
  %213 = fcmp olt float %212, 0xBE80000000000000
  br i1 %213, label %217, label %214

214:                                              ; preds = %183
  %215 = load float, ptr %16, align 4, !tbaa !15
  %216 = fcmp olt float 0x3E80000000000000, %215
  br i1 %216, label %217, label %238

217:                                              ; preds = %214, %183
  %218 = load ptr, ptr %2, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %218, i32 0, i32 1
  %220 = load i32, ptr %219, align 4, !tbaa !17
  %221 = add nsw i32 %220, 1
  store i32 %221, ptr %219, align 4, !tbaa !17
  %222 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 58)
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #6
  %223 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %224 = getelementptr inbounds %union.HMM_Vec4, ptr %18, i32 0, i32 0
  %225 = getelementptr inbounds { double, double }, ptr %224, i32 0, i32 0
  %226 = extractvalue { double, double } %223, 0
  store double %226, ptr %225, align 16
  %227 = getelementptr inbounds { double, double }, ptr %224, i32 0, i32 1
  %228 = extractvalue { double, double } %223, 1
  store double %228, ptr %227, align 8
  %229 = getelementptr inbounds %struct.anon.10, ptr %18, i32 0, i32 0
  %230 = getelementptr inbounds %struct.anon.11, ptr %229, i32 0, i32 1
  %231 = load float, ptr %230, align 4, !tbaa !13
  %232 = fpext float %231 to double
  %233 = load float, ptr %12, align 4, !tbaa !15
  %234 = fpext float %233 to double
  %235 = load float, ptr %16, align 4, !tbaa !15
  %236 = fpext float %235 to double
  %237 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %232, double noundef %234, double noundef %236)
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #6
  br label %238

238:                                              ; preds = %217, %214
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  %239 = load ptr, ptr %2, align 8, !tbaa !5
  %240 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %239, i32 0, i32 0
  %241 = load i32, ptr %240, align 4, !tbaa !9
  %242 = add nsw i32 %241, 1
  store i32 %242, ptr %240, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %20) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %21, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %22, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %243 = getelementptr inbounds { double, double }, ptr %22, i32 0, i32 0
  %244 = load double, ptr %243, align 16
  %245 = getelementptr inbounds { double, double }, ptr %22, i32 0, i32 1
  %246 = load double, ptr %245, align 8
  %247 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %21, double %244, double %246)
  %248 = getelementptr inbounds %union.HMM_Vec4, ptr %20, i32 0, i32 0
  %249 = getelementptr inbounds { double, double }, ptr %248, i32 0, i32 0
  %250 = extractvalue { double, double } %247, 0
  store double %250, ptr %249, align 16
  %251 = getelementptr inbounds { double, double }, ptr %248, i32 0, i32 1
  %252 = extractvalue { double, double } %247, 1
  store double %252, ptr %251, align 8
  %253 = getelementptr inbounds %struct.anon.10, ptr %20, i32 0, i32 0
  %254 = getelementptr inbounds %struct.anon.11, ptr %253, i32 0, i32 2
  %255 = load float, ptr %254, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #6
  store float %255, ptr %19, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %256 = load float, ptr %19, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %24) #6
  %257 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %258 = getelementptr inbounds %union.HMM_Vec4, ptr %24, i32 0, i32 0
  %259 = getelementptr inbounds { double, double }, ptr %258, i32 0, i32 0
  %260 = extractvalue { double, double } %257, 0
  store double %260, ptr %259, align 16
  %261 = getelementptr inbounds { double, double }, ptr %258, i32 0, i32 1
  %262 = extractvalue { double, double } %257, 1
  store double %262, ptr %261, align 8
  %263 = getelementptr inbounds %struct.anon.10, ptr %24, i32 0, i32 0
  %264 = getelementptr inbounds %struct.anon.11, ptr %263, i32 0, i32 2
  %265 = load float, ptr %264, align 8, !tbaa !13
  %266 = fsub float %256, %265
  call void @llvm.lifetime.end.p0(i64 16, ptr %24) #6
  store float %266, ptr %23, align 4, !tbaa !15
  %267 = load float, ptr %23, align 4, !tbaa !15
  %268 = fcmp olt float %267, 0xBE80000000000000
  br i1 %268, label %272, label %269

269:                                              ; preds = %238
  %270 = load float, ptr %23, align 4, !tbaa !15
  %271 = fcmp olt float 0x3E80000000000000, %270
  br i1 %271, label %272, label %293

272:                                              ; preds = %269, %238
  %273 = load ptr, ptr %2, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %273, i32 0, i32 1
  %275 = load i32, ptr %274, align 4, !tbaa !17
  %276 = add nsw i32 %275, 1
  store i32 %276, ptr %274, align 4, !tbaa !17
  %277 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 58)
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #6
  %278 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %279 = getelementptr inbounds %union.HMM_Vec4, ptr %25, i32 0, i32 0
  %280 = getelementptr inbounds { double, double }, ptr %279, i32 0, i32 0
  %281 = extractvalue { double, double } %278, 0
  store double %281, ptr %280, align 16
  %282 = getelementptr inbounds { double, double }, ptr %279, i32 0, i32 1
  %283 = extractvalue { double, double } %278, 1
  store double %283, ptr %282, align 8
  %284 = getelementptr inbounds %struct.anon.10, ptr %25, i32 0, i32 0
  %285 = getelementptr inbounds %struct.anon.11, ptr %284, i32 0, i32 2
  %286 = load float, ptr %285, align 8, !tbaa !13
  %287 = fpext float %286 to double
  %288 = load float, ptr %19, align 4, !tbaa !15
  %289 = fpext float %288 to double
  %290 = load float, ptr %23, align 4, !tbaa !15
  %291 = fpext float %290 to double
  %292 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %287, double noundef %289, double noundef %291)
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #6
  br label %293

293:                                              ; preds = %272, %269
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  %294 = load ptr, ptr %2, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %294, i32 0, i32 0
  %296 = load i32, ptr %295, align 4, !tbaa !9
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %295, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %27) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %28, ptr align 16 %3, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %29, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %298 = getelementptr inbounds { double, double }, ptr %29, i32 0, i32 0
  %299 = load double, ptr %298, align 16
  %300 = getelementptr inbounds { double, double }, ptr %29, i32 0, i32 1
  %301 = load double, ptr %300, align 8
  %302 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %28, double %299, double %301)
  %303 = getelementptr inbounds %union.HMM_Vec4, ptr %27, i32 0, i32 0
  %304 = getelementptr inbounds { double, double }, ptr %303, i32 0, i32 0
  %305 = extractvalue { double, double } %302, 0
  store double %305, ptr %304, align 16
  %306 = getelementptr inbounds { double, double }, ptr %303, i32 0, i32 1
  %307 = extractvalue { double, double } %302, 1
  store double %307, ptr %306, align 8
  %308 = getelementptr inbounds %struct.anon.10, ptr %27, i32 0, i32 1
  %309 = load float, ptr %308, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #6
  store float %309, ptr %26, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %310 = load float, ptr %26, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %31) #6
  %311 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %312 = getelementptr inbounds %union.HMM_Vec4, ptr %31, i32 0, i32 0
  %313 = getelementptr inbounds { double, double }, ptr %312, i32 0, i32 0
  %314 = extractvalue { double, double } %311, 0
  store double %314, ptr %313, align 16
  %315 = getelementptr inbounds { double, double }, ptr %312, i32 0, i32 1
  %316 = extractvalue { double, double } %311, 1
  store double %316, ptr %315, align 8
  %317 = getelementptr inbounds %struct.anon.10, ptr %31, i32 0, i32 1
  %318 = load float, ptr %317, align 4, !tbaa !13
  %319 = fsub float %310, %318
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #6
  store float %319, ptr %30, align 4, !tbaa !15
  %320 = load float, ptr %30, align 4, !tbaa !15
  %321 = fcmp olt float %320, 0xBE80000000000000
  br i1 %321, label %325, label %322

322:                                              ; preds = %293
  %323 = load float, ptr %30, align 4, !tbaa !15
  %324 = fcmp olt float 0x3E80000000000000, %323
  br i1 %324, label %325, label %345

325:                                              ; preds = %322, %293
  %326 = load ptr, ptr %2, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %326, i32 0, i32 1
  %328 = load i32, ptr %327, align 4, !tbaa !17
  %329 = add nsw i32 %328, 1
  store i32 %329, ptr %327, align 4, !tbaa !17
  %330 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 58)
  call void @llvm.lifetime.start.p0(i64 16, ptr %32) #6
  %331 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %332 = getelementptr inbounds %union.HMM_Vec4, ptr %32, i32 0, i32 0
  %333 = getelementptr inbounds { double, double }, ptr %332, i32 0, i32 0
  %334 = extractvalue { double, double } %331, 0
  store double %334, ptr %333, align 16
  %335 = getelementptr inbounds { double, double }, ptr %332, i32 0, i32 1
  %336 = extractvalue { double, double } %331, 1
  store double %336, ptr %335, align 8
  %337 = getelementptr inbounds %struct.anon.10, ptr %32, i32 0, i32 1
  %338 = load float, ptr %337, align 4, !tbaa !13
  %339 = fpext float %338 to double
  %340 = load float, ptr %26, align 4, !tbaa !15
  %341 = fpext float %340 to double
  %342 = load float, ptr %30, align 4, !tbaa !15
  %343 = fpext float %342 to double
  %344 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %339, double noundef %341, double noundef %343)
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #6
  br label %345

345:                                              ; preds = %325, %322
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %3) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %33) #6
  call void @_ZL21HMM_Perspective_RH_ZOffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %33, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  call void @llvm.lifetime.start.p0(i64 16, ptr %34) #6
  %346 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %347 = getelementptr inbounds %union.HMM_Vec4, ptr %34, i32 0, i32 0
  %348 = getelementptr inbounds { double, double }, ptr %347, i32 0, i32 0
  %349 = extractvalue { double, double } %346, 0
  store double %349, ptr %348, align 16
  %350 = getelementptr inbounds { double, double }, ptr %347, i32 0, i32 1
  %351 = extractvalue { double, double } %346, 1
  store double %351, ptr %350, align 8
  %352 = load ptr, ptr %2, align 8, !tbaa !5
  %353 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %352, i32 0, i32 0
  %354 = load i32, ptr %353, align 4, !tbaa !9
  %355 = add nsw i32 %354, 1
  store i32 %355, ptr %353, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %36) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %37, ptr align 16 %33, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %38, ptr align 16 %34, i64 16, i1 false), !tbaa.struct !14
  %356 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 0
  %357 = load double, ptr %356, align 16
  %358 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 1
  %359 = load double, ptr %358, align 8
  %360 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %37, double %357, double %359)
  %361 = getelementptr inbounds %union.HMM_Vec4, ptr %36, i32 0, i32 0
  %362 = getelementptr inbounds { double, double }, ptr %361, i32 0, i32 0
  %363 = extractvalue { double, double } %360, 0
  store double %363, ptr %362, align 16
  %364 = getelementptr inbounds { double, double }, ptr %361, i32 0, i32 1
  %365 = extractvalue { double, double } %360, 1
  store double %365, ptr %364, align 8
  %366 = getelementptr inbounds %struct.anon.10, ptr %36, i32 0, i32 0
  %367 = getelementptr inbounds %struct.anon.11, ptr %366, i32 0, i32 0
  %368 = load float, ptr %367, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %36) #6
  store float %368, ptr %35, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  %369 = load float, ptr %35, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %40) #6
  %370 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %371 = getelementptr inbounds %union.HMM_Vec4, ptr %40, i32 0, i32 0
  %372 = getelementptr inbounds { double, double }, ptr %371, i32 0, i32 0
  %373 = extractvalue { double, double } %370, 0
  store double %373, ptr %372, align 16
  %374 = getelementptr inbounds { double, double }, ptr %371, i32 0, i32 1
  %375 = extractvalue { double, double } %370, 1
  store double %375, ptr %374, align 8
  %376 = getelementptr inbounds %struct.anon.10, ptr %40, i32 0, i32 0
  %377 = getelementptr inbounds %struct.anon.11, ptr %376, i32 0, i32 0
  %378 = load float, ptr %377, align 16, !tbaa !13
  %379 = fsub float %369, %378
  call void @llvm.lifetime.end.p0(i64 16, ptr %40) #6
  store float %379, ptr %39, align 4, !tbaa !15
  %380 = load float, ptr %39, align 4, !tbaa !15
  %381 = fcmp olt float %380, 0xBE80000000000000
  br i1 %381, label %385, label %382

382:                                              ; preds = %345
  %383 = load float, ptr %39, align 4, !tbaa !15
  %384 = fcmp olt float 0x3E80000000000000, %383
  br i1 %384, label %385, label %406

385:                                              ; preds = %382, %345
  %386 = load ptr, ptr %2, align 8, !tbaa !5
  %387 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %386, i32 0, i32 1
  %388 = load i32, ptr %387, align 4, !tbaa !17
  %389 = add nsw i32 %388, 1
  store i32 %389, ptr %387, align 4, !tbaa !17
  %390 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 65)
  call void @llvm.lifetime.start.p0(i64 16, ptr %41) #6
  %391 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %392 = getelementptr inbounds %union.HMM_Vec4, ptr %41, i32 0, i32 0
  %393 = getelementptr inbounds { double, double }, ptr %392, i32 0, i32 0
  %394 = extractvalue { double, double } %391, 0
  store double %394, ptr %393, align 16
  %395 = getelementptr inbounds { double, double }, ptr %392, i32 0, i32 1
  %396 = extractvalue { double, double } %391, 1
  store double %396, ptr %395, align 8
  %397 = getelementptr inbounds %struct.anon.10, ptr %41, i32 0, i32 0
  %398 = getelementptr inbounds %struct.anon.11, ptr %397, i32 0, i32 0
  %399 = load float, ptr %398, align 16, !tbaa !13
  %400 = fpext float %399 to double
  %401 = load float, ptr %35, align 4, !tbaa !15
  %402 = fpext float %401 to double
  %403 = load float, ptr %39, align 4, !tbaa !15
  %404 = fpext float %403 to double
  %405 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %400, double noundef %402, double noundef %404)
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #6
  br label %406

406:                                              ; preds = %385, %382
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  %407 = load ptr, ptr %2, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %407, i32 0, i32 0
  %409 = load i32, ptr %408, align 4, !tbaa !9
  %410 = add nsw i32 %409, 1
  store i32 %410, ptr %408, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %43) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %44, ptr align 16 %33, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %45, ptr align 16 %34, i64 16, i1 false), !tbaa.struct !14
  %411 = getelementptr inbounds { double, double }, ptr %45, i32 0, i32 0
  %412 = load double, ptr %411, align 16
  %413 = getelementptr inbounds { double, double }, ptr %45, i32 0, i32 1
  %414 = load double, ptr %413, align 8
  %415 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %44, double %412, double %414)
  %416 = getelementptr inbounds %union.HMM_Vec4, ptr %43, i32 0, i32 0
  %417 = getelementptr inbounds { double, double }, ptr %416, i32 0, i32 0
  %418 = extractvalue { double, double } %415, 0
  store double %418, ptr %417, align 16
  %419 = getelementptr inbounds { double, double }, ptr %416, i32 0, i32 1
  %420 = extractvalue { double, double } %415, 1
  store double %420, ptr %419, align 8
  %421 = getelementptr inbounds %struct.anon.10, ptr %43, i32 0, i32 0
  %422 = getelementptr inbounds %struct.anon.11, ptr %421, i32 0, i32 1
  %423 = load float, ptr %422, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %43) #6
  store float %423, ptr %42, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %424 = load float, ptr %42, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %47) #6
  %425 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %426 = getelementptr inbounds %union.HMM_Vec4, ptr %47, i32 0, i32 0
  %427 = getelementptr inbounds { double, double }, ptr %426, i32 0, i32 0
  %428 = extractvalue { double, double } %425, 0
  store double %428, ptr %427, align 16
  %429 = getelementptr inbounds { double, double }, ptr %426, i32 0, i32 1
  %430 = extractvalue { double, double } %425, 1
  store double %430, ptr %429, align 8
  %431 = getelementptr inbounds %struct.anon.10, ptr %47, i32 0, i32 0
  %432 = getelementptr inbounds %struct.anon.11, ptr %431, i32 0, i32 1
  %433 = load float, ptr %432, align 4, !tbaa !13
  %434 = fsub float %424, %433
  call void @llvm.lifetime.end.p0(i64 16, ptr %47) #6
  store float %434, ptr %46, align 4, !tbaa !15
  %435 = load float, ptr %46, align 4, !tbaa !15
  %436 = fcmp olt float %435, 0xBE80000000000000
  br i1 %436, label %440, label %437

437:                                              ; preds = %406
  %438 = load float, ptr %46, align 4, !tbaa !15
  %439 = fcmp olt float 0x3E80000000000000, %438
  br i1 %439, label %440, label %461

440:                                              ; preds = %437, %406
  %441 = load ptr, ptr %2, align 8, !tbaa !5
  %442 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %441, i32 0, i32 1
  %443 = load i32, ptr %442, align 4, !tbaa !17
  %444 = add nsw i32 %443, 1
  store i32 %444, ptr %442, align 4, !tbaa !17
  %445 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 65)
  call void @llvm.lifetime.start.p0(i64 16, ptr %48) #6
  %446 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %447 = getelementptr inbounds %union.HMM_Vec4, ptr %48, i32 0, i32 0
  %448 = getelementptr inbounds { double, double }, ptr %447, i32 0, i32 0
  %449 = extractvalue { double, double } %446, 0
  store double %449, ptr %448, align 16
  %450 = getelementptr inbounds { double, double }, ptr %447, i32 0, i32 1
  %451 = extractvalue { double, double } %446, 1
  store double %451, ptr %450, align 8
  %452 = getelementptr inbounds %struct.anon.10, ptr %48, i32 0, i32 0
  %453 = getelementptr inbounds %struct.anon.11, ptr %452, i32 0, i32 1
  %454 = load float, ptr %453, align 4, !tbaa !13
  %455 = fpext float %454 to double
  %456 = load float, ptr %42, align 4, !tbaa !15
  %457 = fpext float %456 to double
  %458 = load float, ptr %46, align 4, !tbaa !15
  %459 = fpext float %458 to double
  %460 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %455, double noundef %457, double noundef %459)
  call void @llvm.lifetime.end.p0(i64 16, ptr %48) #6
  br label %461

461:                                              ; preds = %440, %437
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  %462 = load ptr, ptr %2, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %462, i32 0, i32 0
  %464 = load i32, ptr %463, align 4, !tbaa !9
  %465 = add nsw i32 %464, 1
  store i32 %465, ptr %463, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %50) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %51, ptr align 16 %33, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %52, ptr align 16 %34, i64 16, i1 false), !tbaa.struct !14
  %466 = getelementptr inbounds { double, double }, ptr %52, i32 0, i32 0
  %467 = load double, ptr %466, align 16
  %468 = getelementptr inbounds { double, double }, ptr %52, i32 0, i32 1
  %469 = load double, ptr %468, align 8
  %470 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %51, double %467, double %469)
  %471 = getelementptr inbounds %union.HMM_Vec4, ptr %50, i32 0, i32 0
  %472 = getelementptr inbounds { double, double }, ptr %471, i32 0, i32 0
  %473 = extractvalue { double, double } %470, 0
  store double %473, ptr %472, align 16
  %474 = getelementptr inbounds { double, double }, ptr %471, i32 0, i32 1
  %475 = extractvalue { double, double } %470, 1
  store double %475, ptr %474, align 8
  %476 = getelementptr inbounds %struct.anon.10, ptr %50, i32 0, i32 0
  %477 = getelementptr inbounds %struct.anon.11, ptr %476, i32 0, i32 2
  %478 = load float, ptr %477, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %50) #6
  store float %478, ptr %49, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #6
  %479 = load float, ptr %49, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %54) #6
  %480 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %481 = getelementptr inbounds %union.HMM_Vec4, ptr %54, i32 0, i32 0
  %482 = getelementptr inbounds { double, double }, ptr %481, i32 0, i32 0
  %483 = extractvalue { double, double } %480, 0
  store double %483, ptr %482, align 16
  %484 = getelementptr inbounds { double, double }, ptr %481, i32 0, i32 1
  %485 = extractvalue { double, double } %480, 1
  store double %485, ptr %484, align 8
  %486 = getelementptr inbounds %struct.anon.10, ptr %54, i32 0, i32 0
  %487 = getelementptr inbounds %struct.anon.11, ptr %486, i32 0, i32 2
  %488 = load float, ptr %487, align 8, !tbaa !13
  %489 = fsub float %479, %488
  call void @llvm.lifetime.end.p0(i64 16, ptr %54) #6
  store float %489, ptr %53, align 4, !tbaa !15
  %490 = load float, ptr %53, align 4, !tbaa !15
  %491 = fcmp olt float %490, 0xBE80000000000000
  br i1 %491, label %495, label %492

492:                                              ; preds = %461
  %493 = load float, ptr %53, align 4, !tbaa !15
  %494 = fcmp olt float 0x3E80000000000000, %493
  br i1 %494, label %495, label %516

495:                                              ; preds = %492, %461
  %496 = load ptr, ptr %2, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %496, i32 0, i32 1
  %498 = load i32, ptr %497, align 4, !tbaa !17
  %499 = add nsw i32 %498, 1
  store i32 %499, ptr %497, align 4, !tbaa !17
  %500 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 65)
  call void @llvm.lifetime.start.p0(i64 16, ptr %55) #6
  %501 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %502 = getelementptr inbounds %union.HMM_Vec4, ptr %55, i32 0, i32 0
  %503 = getelementptr inbounds { double, double }, ptr %502, i32 0, i32 0
  %504 = extractvalue { double, double } %501, 0
  store double %504, ptr %503, align 16
  %505 = getelementptr inbounds { double, double }, ptr %502, i32 0, i32 1
  %506 = extractvalue { double, double } %501, 1
  store double %506, ptr %505, align 8
  %507 = getelementptr inbounds %struct.anon.10, ptr %55, i32 0, i32 0
  %508 = getelementptr inbounds %struct.anon.11, ptr %507, i32 0, i32 2
  %509 = load float, ptr %508, align 8, !tbaa !13
  %510 = fpext float %509 to double
  %511 = load float, ptr %49, align 4, !tbaa !15
  %512 = fpext float %511 to double
  %513 = load float, ptr %53, align 4, !tbaa !15
  %514 = fpext float %513 to double
  %515 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %510, double noundef %512, double noundef %514)
  call void @llvm.lifetime.end.p0(i64 16, ptr %55) #6
  br label %516

516:                                              ; preds = %495, %492
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  %517 = load ptr, ptr %2, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %517, i32 0, i32 0
  %519 = load i32, ptr %518, align 4, !tbaa !9
  %520 = add nsw i32 %519, 1
  store i32 %520, ptr %518, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %57) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %58, ptr align 16 %33, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %59, ptr align 16 %34, i64 16, i1 false), !tbaa.struct !14
  %521 = getelementptr inbounds { double, double }, ptr %59, i32 0, i32 0
  %522 = load double, ptr %521, align 16
  %523 = getelementptr inbounds { double, double }, ptr %59, i32 0, i32 1
  %524 = load double, ptr %523, align 8
  %525 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %58, double %522, double %524)
  %526 = getelementptr inbounds %union.HMM_Vec4, ptr %57, i32 0, i32 0
  %527 = getelementptr inbounds { double, double }, ptr %526, i32 0, i32 0
  %528 = extractvalue { double, double } %525, 0
  store double %528, ptr %527, align 16
  %529 = getelementptr inbounds { double, double }, ptr %526, i32 0, i32 1
  %530 = extractvalue { double, double } %525, 1
  store double %530, ptr %529, align 8
  %531 = getelementptr inbounds %struct.anon.10, ptr %57, i32 0, i32 1
  %532 = load float, ptr %531, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %57) #6
  store float %532, ptr %56, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #6
  %533 = load float, ptr %56, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %61) #6
  %534 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %535 = getelementptr inbounds %union.HMM_Vec4, ptr %61, i32 0, i32 0
  %536 = getelementptr inbounds { double, double }, ptr %535, i32 0, i32 0
  %537 = extractvalue { double, double } %534, 0
  store double %537, ptr %536, align 16
  %538 = getelementptr inbounds { double, double }, ptr %535, i32 0, i32 1
  %539 = extractvalue { double, double } %534, 1
  store double %539, ptr %538, align 8
  %540 = getelementptr inbounds %struct.anon.10, ptr %61, i32 0, i32 1
  %541 = load float, ptr %540, align 4, !tbaa !13
  %542 = fsub float %533, %541
  call void @llvm.lifetime.end.p0(i64 16, ptr %61) #6
  store float %542, ptr %60, align 4, !tbaa !15
  %543 = load float, ptr %60, align 4, !tbaa !15
  %544 = fcmp olt float %543, 0xBE80000000000000
  br i1 %544, label %548, label %545

545:                                              ; preds = %516
  %546 = load float, ptr %60, align 4, !tbaa !15
  %547 = fcmp olt float 0x3E80000000000000, %546
  br i1 %547, label %548, label %568

548:                                              ; preds = %545, %516
  %549 = load ptr, ptr %2, align 8, !tbaa !5
  %550 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %549, i32 0, i32 1
  %551 = load i32, ptr %550, align 4, !tbaa !17
  %552 = add nsw i32 %551, 1
  store i32 %552, ptr %550, align 4, !tbaa !17
  %553 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 65)
  call void @llvm.lifetime.start.p0(i64 16, ptr %62) #6
  %554 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %555 = getelementptr inbounds %union.HMM_Vec4, ptr %62, i32 0, i32 0
  %556 = getelementptr inbounds { double, double }, ptr %555, i32 0, i32 0
  %557 = extractvalue { double, double } %554, 0
  store double %557, ptr %556, align 16
  %558 = getelementptr inbounds { double, double }, ptr %555, i32 0, i32 1
  %559 = extractvalue { double, double } %554, 1
  store double %559, ptr %558, align 8
  %560 = getelementptr inbounds %struct.anon.10, ptr %62, i32 0, i32 1
  %561 = load float, ptr %560, align 4, !tbaa !13
  %562 = fpext float %561 to double
  %563 = load float, ptr %56, align 4, !tbaa !15
  %564 = fpext float %563 to double
  %565 = load float, ptr %60, align 4, !tbaa !15
  %566 = fpext float %565 to double
  %567 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %562, double noundef %564, double noundef %566)
  call void @llvm.lifetime.end.p0(i64 16, ptr %62) #6
  br label %568

568:                                              ; preds = %548, %545
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %33) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %63) #6
  call void @_ZL21HMM_Perspective_LH_NOffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %63, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  call void @llvm.lifetime.start.p0(i64 16, ptr %64) #6
  %569 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %570 = getelementptr inbounds %union.HMM_Vec4, ptr %64, i32 0, i32 0
  %571 = getelementptr inbounds { double, double }, ptr %570, i32 0, i32 0
  %572 = extractvalue { double, double } %569, 0
  store double %572, ptr %571, align 16
  %573 = getelementptr inbounds { double, double }, ptr %570, i32 0, i32 1
  %574 = extractvalue { double, double } %569, 1
  store double %574, ptr %573, align 8
  %575 = load ptr, ptr %2, align 8, !tbaa !5
  %576 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %575, i32 0, i32 0
  %577 = load i32, ptr %576, align 4, !tbaa !9
  %578 = add nsw i32 %577, 1
  store i32 %578, ptr %576, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %66) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %67, ptr align 16 %63, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %68, ptr align 16 %64, i64 16, i1 false), !tbaa.struct !14
  %579 = getelementptr inbounds { double, double }, ptr %68, i32 0, i32 0
  %580 = load double, ptr %579, align 16
  %581 = getelementptr inbounds { double, double }, ptr %68, i32 0, i32 1
  %582 = load double, ptr %581, align 8
  %583 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %67, double %580, double %582)
  %584 = getelementptr inbounds %union.HMM_Vec4, ptr %66, i32 0, i32 0
  %585 = getelementptr inbounds { double, double }, ptr %584, i32 0, i32 0
  %586 = extractvalue { double, double } %583, 0
  store double %586, ptr %585, align 16
  %587 = getelementptr inbounds { double, double }, ptr %584, i32 0, i32 1
  %588 = extractvalue { double, double } %583, 1
  store double %588, ptr %587, align 8
  %589 = getelementptr inbounds %struct.anon.10, ptr %66, i32 0, i32 0
  %590 = getelementptr inbounds %struct.anon.11, ptr %589, i32 0, i32 0
  %591 = load float, ptr %590, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %66) #6
  store float %591, ptr %65, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #6
  %592 = load float, ptr %65, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %70) #6
  %593 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %594 = getelementptr inbounds %union.HMM_Vec4, ptr %70, i32 0, i32 0
  %595 = getelementptr inbounds { double, double }, ptr %594, i32 0, i32 0
  %596 = extractvalue { double, double } %593, 0
  store double %596, ptr %595, align 16
  %597 = getelementptr inbounds { double, double }, ptr %594, i32 0, i32 1
  %598 = extractvalue { double, double } %593, 1
  store double %598, ptr %597, align 8
  %599 = getelementptr inbounds %struct.anon.10, ptr %70, i32 0, i32 0
  %600 = getelementptr inbounds %struct.anon.11, ptr %599, i32 0, i32 0
  %601 = load float, ptr %600, align 16, !tbaa !13
  %602 = fsub float %592, %601
  call void @llvm.lifetime.end.p0(i64 16, ptr %70) #6
  store float %602, ptr %69, align 4, !tbaa !15
  %603 = load float, ptr %69, align 4, !tbaa !15
  %604 = fcmp olt float %603, 0xBE80000000000000
  br i1 %604, label %608, label %605

605:                                              ; preds = %568
  %606 = load float, ptr %69, align 4, !tbaa !15
  %607 = fcmp olt float 0x3E80000000000000, %606
  br i1 %607, label %608, label %629

608:                                              ; preds = %605, %568
  %609 = load ptr, ptr %2, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %609, i32 0, i32 1
  %611 = load i32, ptr %610, align 4, !tbaa !17
  %612 = add nsw i32 %611, 1
  store i32 %612, ptr %610, align 4, !tbaa !17
  %613 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 75)
  call void @llvm.lifetime.start.p0(i64 16, ptr %71) #6
  %614 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %615 = getelementptr inbounds %union.HMM_Vec4, ptr %71, i32 0, i32 0
  %616 = getelementptr inbounds { double, double }, ptr %615, i32 0, i32 0
  %617 = extractvalue { double, double } %614, 0
  store double %617, ptr %616, align 16
  %618 = getelementptr inbounds { double, double }, ptr %615, i32 0, i32 1
  %619 = extractvalue { double, double } %614, 1
  store double %619, ptr %618, align 8
  %620 = getelementptr inbounds %struct.anon.10, ptr %71, i32 0, i32 0
  %621 = getelementptr inbounds %struct.anon.11, ptr %620, i32 0, i32 0
  %622 = load float, ptr %621, align 16, !tbaa !13
  %623 = fpext float %622 to double
  %624 = load float, ptr %65, align 4, !tbaa !15
  %625 = fpext float %624 to double
  %626 = load float, ptr %69, align 4, !tbaa !15
  %627 = fpext float %626 to double
  %628 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %623, double noundef %625, double noundef %627)
  call void @llvm.lifetime.end.p0(i64 16, ptr %71) #6
  br label %629

629:                                              ; preds = %608, %605
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #6
  %630 = load ptr, ptr %2, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %630, i32 0, i32 0
  %632 = load i32, ptr %631, align 4, !tbaa !9
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %631, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %73) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %74, ptr align 16 %63, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %75, ptr align 16 %64, i64 16, i1 false), !tbaa.struct !14
  %634 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 0
  %635 = load double, ptr %634, align 16
  %636 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 1
  %637 = load double, ptr %636, align 8
  %638 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %74, double %635, double %637)
  %639 = getelementptr inbounds %union.HMM_Vec4, ptr %73, i32 0, i32 0
  %640 = getelementptr inbounds { double, double }, ptr %639, i32 0, i32 0
  %641 = extractvalue { double, double } %638, 0
  store double %641, ptr %640, align 16
  %642 = getelementptr inbounds { double, double }, ptr %639, i32 0, i32 1
  %643 = extractvalue { double, double } %638, 1
  store double %643, ptr %642, align 8
  %644 = getelementptr inbounds %struct.anon.10, ptr %73, i32 0, i32 0
  %645 = getelementptr inbounds %struct.anon.11, ptr %644, i32 0, i32 1
  %646 = load float, ptr %645, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %73) #6
  store float %646, ptr %72, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #6
  %647 = load float, ptr %72, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %77) #6
  %648 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %649 = getelementptr inbounds %union.HMM_Vec4, ptr %77, i32 0, i32 0
  %650 = getelementptr inbounds { double, double }, ptr %649, i32 0, i32 0
  %651 = extractvalue { double, double } %648, 0
  store double %651, ptr %650, align 16
  %652 = getelementptr inbounds { double, double }, ptr %649, i32 0, i32 1
  %653 = extractvalue { double, double } %648, 1
  store double %653, ptr %652, align 8
  %654 = getelementptr inbounds %struct.anon.10, ptr %77, i32 0, i32 0
  %655 = getelementptr inbounds %struct.anon.11, ptr %654, i32 0, i32 1
  %656 = load float, ptr %655, align 4, !tbaa !13
  %657 = fsub float %647, %656
  call void @llvm.lifetime.end.p0(i64 16, ptr %77) #6
  store float %657, ptr %76, align 4, !tbaa !15
  %658 = load float, ptr %76, align 4, !tbaa !15
  %659 = fcmp olt float %658, 0xBE80000000000000
  br i1 %659, label %663, label %660

660:                                              ; preds = %629
  %661 = load float, ptr %76, align 4, !tbaa !15
  %662 = fcmp olt float 0x3E80000000000000, %661
  br i1 %662, label %663, label %684

663:                                              ; preds = %660, %629
  %664 = load ptr, ptr %2, align 8, !tbaa !5
  %665 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %664, i32 0, i32 1
  %666 = load i32, ptr %665, align 4, !tbaa !17
  %667 = add nsw i32 %666, 1
  store i32 %667, ptr %665, align 4, !tbaa !17
  %668 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 75)
  call void @llvm.lifetime.start.p0(i64 16, ptr %78) #6
  %669 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %670 = getelementptr inbounds %union.HMM_Vec4, ptr %78, i32 0, i32 0
  %671 = getelementptr inbounds { double, double }, ptr %670, i32 0, i32 0
  %672 = extractvalue { double, double } %669, 0
  store double %672, ptr %671, align 16
  %673 = getelementptr inbounds { double, double }, ptr %670, i32 0, i32 1
  %674 = extractvalue { double, double } %669, 1
  store double %674, ptr %673, align 8
  %675 = getelementptr inbounds %struct.anon.10, ptr %78, i32 0, i32 0
  %676 = getelementptr inbounds %struct.anon.11, ptr %675, i32 0, i32 1
  %677 = load float, ptr %676, align 4, !tbaa !13
  %678 = fpext float %677 to double
  %679 = load float, ptr %72, align 4, !tbaa !15
  %680 = fpext float %679 to double
  %681 = load float, ptr %76, align 4, !tbaa !15
  %682 = fpext float %681 to double
  %683 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %678, double noundef %680, double noundef %682)
  call void @llvm.lifetime.end.p0(i64 16, ptr %78) #6
  br label %684

684:                                              ; preds = %663, %660
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #6
  %685 = load ptr, ptr %2, align 8, !tbaa !5
  %686 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %685, i32 0, i32 0
  %687 = load i32, ptr %686, align 4, !tbaa !9
  %688 = add nsw i32 %687, 1
  store i32 %688, ptr %686, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %80) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %81, ptr align 16 %63, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %82, ptr align 16 %64, i64 16, i1 false), !tbaa.struct !14
  %689 = getelementptr inbounds { double, double }, ptr %82, i32 0, i32 0
  %690 = load double, ptr %689, align 16
  %691 = getelementptr inbounds { double, double }, ptr %82, i32 0, i32 1
  %692 = load double, ptr %691, align 8
  %693 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %81, double %690, double %692)
  %694 = getelementptr inbounds %union.HMM_Vec4, ptr %80, i32 0, i32 0
  %695 = getelementptr inbounds { double, double }, ptr %694, i32 0, i32 0
  %696 = extractvalue { double, double } %693, 0
  store double %696, ptr %695, align 16
  %697 = getelementptr inbounds { double, double }, ptr %694, i32 0, i32 1
  %698 = extractvalue { double, double } %693, 1
  store double %698, ptr %697, align 8
  %699 = getelementptr inbounds %struct.anon.10, ptr %80, i32 0, i32 0
  %700 = getelementptr inbounds %struct.anon.11, ptr %699, i32 0, i32 2
  %701 = load float, ptr %700, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %80) #6
  store float %701, ptr %79, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #6
  %702 = load float, ptr %79, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %84) #6
  %703 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %704 = getelementptr inbounds %union.HMM_Vec4, ptr %84, i32 0, i32 0
  %705 = getelementptr inbounds { double, double }, ptr %704, i32 0, i32 0
  %706 = extractvalue { double, double } %703, 0
  store double %706, ptr %705, align 16
  %707 = getelementptr inbounds { double, double }, ptr %704, i32 0, i32 1
  %708 = extractvalue { double, double } %703, 1
  store double %708, ptr %707, align 8
  %709 = getelementptr inbounds %struct.anon.10, ptr %84, i32 0, i32 0
  %710 = getelementptr inbounds %struct.anon.11, ptr %709, i32 0, i32 2
  %711 = load float, ptr %710, align 8, !tbaa !13
  %712 = fsub float %702, %711
  call void @llvm.lifetime.end.p0(i64 16, ptr %84) #6
  store float %712, ptr %83, align 4, !tbaa !15
  %713 = load float, ptr %83, align 4, !tbaa !15
  %714 = fcmp olt float %713, 0xBE80000000000000
  br i1 %714, label %718, label %715

715:                                              ; preds = %684
  %716 = load float, ptr %83, align 4, !tbaa !15
  %717 = fcmp olt float 0x3E80000000000000, %716
  br i1 %717, label %718, label %739

718:                                              ; preds = %715, %684
  %719 = load ptr, ptr %2, align 8, !tbaa !5
  %720 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %719, i32 0, i32 1
  %721 = load i32, ptr %720, align 4, !tbaa !17
  %722 = add nsw i32 %721, 1
  store i32 %722, ptr %720, align 4, !tbaa !17
  %723 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 75)
  call void @llvm.lifetime.start.p0(i64 16, ptr %85) #6
  %724 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %725 = getelementptr inbounds %union.HMM_Vec4, ptr %85, i32 0, i32 0
  %726 = getelementptr inbounds { double, double }, ptr %725, i32 0, i32 0
  %727 = extractvalue { double, double } %724, 0
  store double %727, ptr %726, align 16
  %728 = getelementptr inbounds { double, double }, ptr %725, i32 0, i32 1
  %729 = extractvalue { double, double } %724, 1
  store double %729, ptr %728, align 8
  %730 = getelementptr inbounds %struct.anon.10, ptr %85, i32 0, i32 0
  %731 = getelementptr inbounds %struct.anon.11, ptr %730, i32 0, i32 2
  %732 = load float, ptr %731, align 8, !tbaa !13
  %733 = fpext float %732 to double
  %734 = load float, ptr %79, align 4, !tbaa !15
  %735 = fpext float %734 to double
  %736 = load float, ptr %83, align 4, !tbaa !15
  %737 = fpext float %736 to double
  %738 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %733, double noundef %735, double noundef %737)
  call void @llvm.lifetime.end.p0(i64 16, ptr %85) #6
  br label %739

739:                                              ; preds = %718, %715
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #6
  %740 = load ptr, ptr %2, align 8, !tbaa !5
  %741 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %740, i32 0, i32 0
  %742 = load i32, ptr %741, align 4, !tbaa !9
  %743 = add nsw i32 %742, 1
  store i32 %743, ptr %741, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %87) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %88, ptr align 16 %63, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %89, ptr align 16 %64, i64 16, i1 false), !tbaa.struct !14
  %744 = getelementptr inbounds { double, double }, ptr %89, i32 0, i32 0
  %745 = load double, ptr %744, align 16
  %746 = getelementptr inbounds { double, double }, ptr %89, i32 0, i32 1
  %747 = load double, ptr %746, align 8
  %748 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %88, double %745, double %747)
  %749 = getelementptr inbounds %union.HMM_Vec4, ptr %87, i32 0, i32 0
  %750 = getelementptr inbounds { double, double }, ptr %749, i32 0, i32 0
  %751 = extractvalue { double, double } %748, 0
  store double %751, ptr %750, align 16
  %752 = getelementptr inbounds { double, double }, ptr %749, i32 0, i32 1
  %753 = extractvalue { double, double } %748, 1
  store double %753, ptr %752, align 8
  %754 = getelementptr inbounds %struct.anon.10, ptr %87, i32 0, i32 1
  %755 = load float, ptr %754, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %87) #6
  store float %755, ptr %86, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #6
  %756 = load float, ptr %86, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %91) #6
  %757 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %758 = getelementptr inbounds %union.HMM_Vec4, ptr %91, i32 0, i32 0
  %759 = getelementptr inbounds { double, double }, ptr %758, i32 0, i32 0
  %760 = extractvalue { double, double } %757, 0
  store double %760, ptr %759, align 16
  %761 = getelementptr inbounds { double, double }, ptr %758, i32 0, i32 1
  %762 = extractvalue { double, double } %757, 1
  store double %762, ptr %761, align 8
  %763 = getelementptr inbounds %struct.anon.10, ptr %91, i32 0, i32 1
  %764 = load float, ptr %763, align 4, !tbaa !13
  %765 = fsub float %756, %764
  call void @llvm.lifetime.end.p0(i64 16, ptr %91) #6
  store float %765, ptr %90, align 4, !tbaa !15
  %766 = load float, ptr %90, align 4, !tbaa !15
  %767 = fcmp olt float %766, 0xBE80000000000000
  br i1 %767, label %771, label %768

768:                                              ; preds = %739
  %769 = load float, ptr %90, align 4, !tbaa !15
  %770 = fcmp olt float 0x3E80000000000000, %769
  br i1 %770, label %771, label %791

771:                                              ; preds = %768, %739
  %772 = load ptr, ptr %2, align 8, !tbaa !5
  %773 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %772, i32 0, i32 1
  %774 = load i32, ptr %773, align 4, !tbaa !17
  %775 = add nsw i32 %774, 1
  store i32 %775, ptr %773, align 4, !tbaa !17
  %776 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 75)
  call void @llvm.lifetime.start.p0(i64 16, ptr %92) #6
  %777 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %778 = getelementptr inbounds %union.HMM_Vec4, ptr %92, i32 0, i32 0
  %779 = getelementptr inbounds { double, double }, ptr %778, i32 0, i32 0
  %780 = extractvalue { double, double } %777, 0
  store double %780, ptr %779, align 16
  %781 = getelementptr inbounds { double, double }, ptr %778, i32 0, i32 1
  %782 = extractvalue { double, double } %777, 1
  store double %782, ptr %781, align 8
  %783 = getelementptr inbounds %struct.anon.10, ptr %92, i32 0, i32 1
  %784 = load float, ptr %783, align 4, !tbaa !13
  %785 = fpext float %784 to double
  %786 = load float, ptr %86, align 4, !tbaa !15
  %787 = fpext float %786 to double
  %788 = load float, ptr %90, align 4, !tbaa !15
  %789 = fpext float %788 to double
  %790 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %785, double noundef %787, double noundef %789)
  call void @llvm.lifetime.end.p0(i64 16, ptr %92) #6
  br label %791

791:                                              ; preds = %771, %768
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %63) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %93) #6
  call void @_ZL21HMM_Perspective_LH_ZOffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %93, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  call void @llvm.lifetime.start.p0(i64 16, ptr %94) #6
  %792 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %793 = getelementptr inbounds %union.HMM_Vec4, ptr %94, i32 0, i32 0
  %794 = getelementptr inbounds { double, double }, ptr %793, i32 0, i32 0
  %795 = extractvalue { double, double } %792, 0
  store double %795, ptr %794, align 16
  %796 = getelementptr inbounds { double, double }, ptr %793, i32 0, i32 1
  %797 = extractvalue { double, double } %792, 1
  store double %797, ptr %796, align 8
  %798 = load ptr, ptr %2, align 8, !tbaa !5
  %799 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %798, i32 0, i32 0
  %800 = load i32, ptr %799, align 4, !tbaa !9
  %801 = add nsw i32 %800, 1
  store i32 %801, ptr %799, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %96) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %97, ptr align 16 %93, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %98, ptr align 16 %94, i64 16, i1 false), !tbaa.struct !14
  %802 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 0
  %803 = load double, ptr %802, align 16
  %804 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 1
  %805 = load double, ptr %804, align 8
  %806 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %97, double %803, double %805)
  %807 = getelementptr inbounds %union.HMM_Vec4, ptr %96, i32 0, i32 0
  %808 = getelementptr inbounds { double, double }, ptr %807, i32 0, i32 0
  %809 = extractvalue { double, double } %806, 0
  store double %809, ptr %808, align 16
  %810 = getelementptr inbounds { double, double }, ptr %807, i32 0, i32 1
  %811 = extractvalue { double, double } %806, 1
  store double %811, ptr %810, align 8
  %812 = getelementptr inbounds %struct.anon.10, ptr %96, i32 0, i32 0
  %813 = getelementptr inbounds %struct.anon.11, ptr %812, i32 0, i32 0
  %814 = load float, ptr %813, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %96) #6
  store float %814, ptr %95, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #6
  %815 = load float, ptr %95, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %100) #6
  %816 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %817 = getelementptr inbounds %union.HMM_Vec4, ptr %100, i32 0, i32 0
  %818 = getelementptr inbounds { double, double }, ptr %817, i32 0, i32 0
  %819 = extractvalue { double, double } %816, 0
  store double %819, ptr %818, align 16
  %820 = getelementptr inbounds { double, double }, ptr %817, i32 0, i32 1
  %821 = extractvalue { double, double } %816, 1
  store double %821, ptr %820, align 8
  %822 = getelementptr inbounds %struct.anon.10, ptr %100, i32 0, i32 0
  %823 = getelementptr inbounds %struct.anon.11, ptr %822, i32 0, i32 0
  %824 = load float, ptr %823, align 16, !tbaa !13
  %825 = fsub float %815, %824
  call void @llvm.lifetime.end.p0(i64 16, ptr %100) #6
  store float %825, ptr %99, align 4, !tbaa !15
  %826 = load float, ptr %99, align 4, !tbaa !15
  %827 = fcmp olt float %826, 0xBE80000000000000
  br i1 %827, label %831, label %828

828:                                              ; preds = %791
  %829 = load float, ptr %99, align 4, !tbaa !15
  %830 = fcmp olt float 0x3E80000000000000, %829
  br i1 %830, label %831, label %852

831:                                              ; preds = %828, %791
  %832 = load ptr, ptr %2, align 8, !tbaa !5
  %833 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %832, i32 0, i32 1
  %834 = load i32, ptr %833, align 4, !tbaa !17
  %835 = add nsw i32 %834, 1
  store i32 %835, ptr %833, align 4, !tbaa !17
  %836 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 82)
  call void @llvm.lifetime.start.p0(i64 16, ptr %101) #6
  %837 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %838 = getelementptr inbounds %union.HMM_Vec4, ptr %101, i32 0, i32 0
  %839 = getelementptr inbounds { double, double }, ptr %838, i32 0, i32 0
  %840 = extractvalue { double, double } %837, 0
  store double %840, ptr %839, align 16
  %841 = getelementptr inbounds { double, double }, ptr %838, i32 0, i32 1
  %842 = extractvalue { double, double } %837, 1
  store double %842, ptr %841, align 8
  %843 = getelementptr inbounds %struct.anon.10, ptr %101, i32 0, i32 0
  %844 = getelementptr inbounds %struct.anon.11, ptr %843, i32 0, i32 0
  %845 = load float, ptr %844, align 16, !tbaa !13
  %846 = fpext float %845 to double
  %847 = load float, ptr %95, align 4, !tbaa !15
  %848 = fpext float %847 to double
  %849 = load float, ptr %99, align 4, !tbaa !15
  %850 = fpext float %849 to double
  %851 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %846, double noundef %848, double noundef %850)
  call void @llvm.lifetime.end.p0(i64 16, ptr %101) #6
  br label %852

852:                                              ; preds = %831, %828
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #6
  %853 = load ptr, ptr %2, align 8, !tbaa !5
  %854 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %853, i32 0, i32 0
  %855 = load i32, ptr %854, align 4, !tbaa !9
  %856 = add nsw i32 %855, 1
  store i32 %856, ptr %854, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %103) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %104, ptr align 16 %93, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %105, ptr align 16 %94, i64 16, i1 false), !tbaa.struct !14
  %857 = getelementptr inbounds { double, double }, ptr %105, i32 0, i32 0
  %858 = load double, ptr %857, align 16
  %859 = getelementptr inbounds { double, double }, ptr %105, i32 0, i32 1
  %860 = load double, ptr %859, align 8
  %861 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %104, double %858, double %860)
  %862 = getelementptr inbounds %union.HMM_Vec4, ptr %103, i32 0, i32 0
  %863 = getelementptr inbounds { double, double }, ptr %862, i32 0, i32 0
  %864 = extractvalue { double, double } %861, 0
  store double %864, ptr %863, align 16
  %865 = getelementptr inbounds { double, double }, ptr %862, i32 0, i32 1
  %866 = extractvalue { double, double } %861, 1
  store double %866, ptr %865, align 8
  %867 = getelementptr inbounds %struct.anon.10, ptr %103, i32 0, i32 0
  %868 = getelementptr inbounds %struct.anon.11, ptr %867, i32 0, i32 1
  %869 = load float, ptr %868, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %103) #6
  store float %869, ptr %102, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #6
  %870 = load float, ptr %102, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %107) #6
  %871 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %872 = getelementptr inbounds %union.HMM_Vec4, ptr %107, i32 0, i32 0
  %873 = getelementptr inbounds { double, double }, ptr %872, i32 0, i32 0
  %874 = extractvalue { double, double } %871, 0
  store double %874, ptr %873, align 16
  %875 = getelementptr inbounds { double, double }, ptr %872, i32 0, i32 1
  %876 = extractvalue { double, double } %871, 1
  store double %876, ptr %875, align 8
  %877 = getelementptr inbounds %struct.anon.10, ptr %107, i32 0, i32 0
  %878 = getelementptr inbounds %struct.anon.11, ptr %877, i32 0, i32 1
  %879 = load float, ptr %878, align 4, !tbaa !13
  %880 = fsub float %870, %879
  call void @llvm.lifetime.end.p0(i64 16, ptr %107) #6
  store float %880, ptr %106, align 4, !tbaa !15
  %881 = load float, ptr %106, align 4, !tbaa !15
  %882 = fcmp olt float %881, 0xBE80000000000000
  br i1 %882, label %886, label %883

883:                                              ; preds = %852
  %884 = load float, ptr %106, align 4, !tbaa !15
  %885 = fcmp olt float 0x3E80000000000000, %884
  br i1 %885, label %886, label %907

886:                                              ; preds = %883, %852
  %887 = load ptr, ptr %2, align 8, !tbaa !5
  %888 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %887, i32 0, i32 1
  %889 = load i32, ptr %888, align 4, !tbaa !17
  %890 = add nsw i32 %889, 1
  store i32 %890, ptr %888, align 4, !tbaa !17
  %891 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 82)
  call void @llvm.lifetime.start.p0(i64 16, ptr %108) #6
  %892 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %893 = getelementptr inbounds %union.HMM_Vec4, ptr %108, i32 0, i32 0
  %894 = getelementptr inbounds { double, double }, ptr %893, i32 0, i32 0
  %895 = extractvalue { double, double } %892, 0
  store double %895, ptr %894, align 16
  %896 = getelementptr inbounds { double, double }, ptr %893, i32 0, i32 1
  %897 = extractvalue { double, double } %892, 1
  store double %897, ptr %896, align 8
  %898 = getelementptr inbounds %struct.anon.10, ptr %108, i32 0, i32 0
  %899 = getelementptr inbounds %struct.anon.11, ptr %898, i32 0, i32 1
  %900 = load float, ptr %899, align 4, !tbaa !13
  %901 = fpext float %900 to double
  %902 = load float, ptr %102, align 4, !tbaa !15
  %903 = fpext float %902 to double
  %904 = load float, ptr %106, align 4, !tbaa !15
  %905 = fpext float %904 to double
  %906 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %901, double noundef %903, double noundef %905)
  call void @llvm.lifetime.end.p0(i64 16, ptr %108) #6
  br label %907

907:                                              ; preds = %886, %883
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #6
  %908 = load ptr, ptr %2, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %908, i32 0, i32 0
  %910 = load i32, ptr %909, align 4, !tbaa !9
  %911 = add nsw i32 %910, 1
  store i32 %911, ptr %909, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %110) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %111, ptr align 16 %93, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %112, ptr align 16 %94, i64 16, i1 false), !tbaa.struct !14
  %912 = getelementptr inbounds { double, double }, ptr %112, i32 0, i32 0
  %913 = load double, ptr %912, align 16
  %914 = getelementptr inbounds { double, double }, ptr %112, i32 0, i32 1
  %915 = load double, ptr %914, align 8
  %916 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %111, double %913, double %915)
  %917 = getelementptr inbounds %union.HMM_Vec4, ptr %110, i32 0, i32 0
  %918 = getelementptr inbounds { double, double }, ptr %917, i32 0, i32 0
  %919 = extractvalue { double, double } %916, 0
  store double %919, ptr %918, align 16
  %920 = getelementptr inbounds { double, double }, ptr %917, i32 0, i32 1
  %921 = extractvalue { double, double } %916, 1
  store double %921, ptr %920, align 8
  %922 = getelementptr inbounds %struct.anon.10, ptr %110, i32 0, i32 0
  %923 = getelementptr inbounds %struct.anon.11, ptr %922, i32 0, i32 2
  %924 = load float, ptr %923, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %110) #6
  store float %924, ptr %109, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %113) #6
  %925 = load float, ptr %109, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %114) #6
  %926 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %927 = getelementptr inbounds %union.HMM_Vec4, ptr %114, i32 0, i32 0
  %928 = getelementptr inbounds { double, double }, ptr %927, i32 0, i32 0
  %929 = extractvalue { double, double } %926, 0
  store double %929, ptr %928, align 16
  %930 = getelementptr inbounds { double, double }, ptr %927, i32 0, i32 1
  %931 = extractvalue { double, double } %926, 1
  store double %931, ptr %930, align 8
  %932 = getelementptr inbounds %struct.anon.10, ptr %114, i32 0, i32 0
  %933 = getelementptr inbounds %struct.anon.11, ptr %932, i32 0, i32 2
  %934 = load float, ptr %933, align 8, !tbaa !13
  %935 = fsub float %925, %934
  call void @llvm.lifetime.end.p0(i64 16, ptr %114) #6
  store float %935, ptr %113, align 4, !tbaa !15
  %936 = load float, ptr %113, align 4, !tbaa !15
  %937 = fcmp olt float %936, 0xBE80000000000000
  br i1 %937, label %941, label %938

938:                                              ; preds = %907
  %939 = load float, ptr %113, align 4, !tbaa !15
  %940 = fcmp olt float 0x3E80000000000000, %939
  br i1 %940, label %941, label %962

941:                                              ; preds = %938, %907
  %942 = load ptr, ptr %2, align 8, !tbaa !5
  %943 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %942, i32 0, i32 1
  %944 = load i32, ptr %943, align 4, !tbaa !17
  %945 = add nsw i32 %944, 1
  store i32 %945, ptr %943, align 4, !tbaa !17
  %946 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 82)
  call void @llvm.lifetime.start.p0(i64 16, ptr %115) #6
  %947 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %948 = getelementptr inbounds %union.HMM_Vec4, ptr %115, i32 0, i32 0
  %949 = getelementptr inbounds { double, double }, ptr %948, i32 0, i32 0
  %950 = extractvalue { double, double } %947, 0
  store double %950, ptr %949, align 16
  %951 = getelementptr inbounds { double, double }, ptr %948, i32 0, i32 1
  %952 = extractvalue { double, double } %947, 1
  store double %952, ptr %951, align 8
  %953 = getelementptr inbounds %struct.anon.10, ptr %115, i32 0, i32 0
  %954 = getelementptr inbounds %struct.anon.11, ptr %953, i32 0, i32 2
  %955 = load float, ptr %954, align 8, !tbaa !13
  %956 = fpext float %955 to double
  %957 = load float, ptr %109, align 4, !tbaa !15
  %958 = fpext float %957 to double
  %959 = load float, ptr %113, align 4, !tbaa !15
  %960 = fpext float %959 to double
  %961 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %956, double noundef %958, double noundef %960)
  call void @llvm.lifetime.end.p0(i64 16, ptr %115) #6
  br label %962

962:                                              ; preds = %941, %938
  call void @llvm.lifetime.end.p0(i64 4, ptr %113) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #6
  %963 = load ptr, ptr %2, align 8, !tbaa !5
  %964 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %963, i32 0, i32 0
  %965 = load i32, ptr %964, align 4, !tbaa !9
  %966 = add nsw i32 %965, 1
  store i32 %966, ptr %964, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %116) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %117) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %118, ptr align 16 %93, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %119, ptr align 16 %94, i64 16, i1 false), !tbaa.struct !14
  %967 = getelementptr inbounds { double, double }, ptr %119, i32 0, i32 0
  %968 = load double, ptr %967, align 16
  %969 = getelementptr inbounds { double, double }, ptr %119, i32 0, i32 1
  %970 = load double, ptr %969, align 8
  %971 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %118, double %968, double %970)
  %972 = getelementptr inbounds %union.HMM_Vec4, ptr %117, i32 0, i32 0
  %973 = getelementptr inbounds { double, double }, ptr %972, i32 0, i32 0
  %974 = extractvalue { double, double } %971, 0
  store double %974, ptr %973, align 16
  %975 = getelementptr inbounds { double, double }, ptr %972, i32 0, i32 1
  %976 = extractvalue { double, double } %971, 1
  store double %976, ptr %975, align 8
  %977 = getelementptr inbounds %struct.anon.10, ptr %117, i32 0, i32 1
  %978 = load float, ptr %977, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %117) #6
  store float %978, ptr %116, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %120) #6
  %979 = load float, ptr %116, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %121) #6
  %980 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %981 = getelementptr inbounds %union.HMM_Vec4, ptr %121, i32 0, i32 0
  %982 = getelementptr inbounds { double, double }, ptr %981, i32 0, i32 0
  %983 = extractvalue { double, double } %980, 0
  store double %983, ptr %982, align 16
  %984 = getelementptr inbounds { double, double }, ptr %981, i32 0, i32 1
  %985 = extractvalue { double, double } %980, 1
  store double %985, ptr %984, align 8
  %986 = getelementptr inbounds %struct.anon.10, ptr %121, i32 0, i32 1
  %987 = load float, ptr %986, align 4, !tbaa !13
  %988 = fsub float %979, %987
  call void @llvm.lifetime.end.p0(i64 16, ptr %121) #6
  store float %988, ptr %120, align 4, !tbaa !15
  %989 = load float, ptr %120, align 4, !tbaa !15
  %990 = fcmp olt float %989, 0xBE80000000000000
  br i1 %990, label %994, label %991

991:                                              ; preds = %962
  %992 = load float, ptr %120, align 4, !tbaa !15
  %993 = fcmp olt float 0x3E80000000000000, %992
  br i1 %993, label %994, label %1014

994:                                              ; preds = %991, %962
  %995 = load ptr, ptr %2, align 8, !tbaa !5
  %996 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %995, i32 0, i32 1
  %997 = load i32, ptr %996, align 4, !tbaa !17
  %998 = add nsw i32 %997, 1
  store i32 %998, ptr %996, align 4, !tbaa !17
  %999 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 82)
  call void @llvm.lifetime.start.p0(i64 16, ptr %122) #6
  %1000 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1001 = getelementptr inbounds %union.HMM_Vec4, ptr %122, i32 0, i32 0
  %1002 = getelementptr inbounds { double, double }, ptr %1001, i32 0, i32 0
  %1003 = extractvalue { double, double } %1000, 0
  store double %1003, ptr %1002, align 16
  %1004 = getelementptr inbounds { double, double }, ptr %1001, i32 0, i32 1
  %1005 = extractvalue { double, double } %1000, 1
  store double %1005, ptr %1004, align 8
  %1006 = getelementptr inbounds %struct.anon.10, ptr %122, i32 0, i32 1
  %1007 = load float, ptr %1006, align 4, !tbaa !13
  %1008 = fpext float %1007 to double
  %1009 = load float, ptr %116, align 4, !tbaa !15
  %1010 = fpext float %1009 to double
  %1011 = load float, ptr %120, align 4, !tbaa !15
  %1012 = fpext float %1011 to double
  %1013 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1008, double noundef %1010, double noundef %1012)
  call void @llvm.lifetime.end.p0(i64 16, ptr %122) #6
  br label %1014

1014:                                             ; preds = %994, %991
  call void @llvm.lifetime.end.p0(i64 4, ptr %120) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %116) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %94) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %93) #6
  ret void
}

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


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

%union.HMM_Mat4 = type { [4 x %union.HMM_Vec4] }
%union.HMM_Vec4 = type { <4 x float> }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [38 x i8], align 1
@.str.135 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.136 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.137 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.138 = external hidden unnamed_addr constant [12 x i8], align 1

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { double, double } @_ZL6HMM_V4ffff(float noundef, float noundef, float noundef, float noundef) local_unnamed_addr #2

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

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16, double, double) local_unnamed_addr #3

; Function Attrs: mustprogress uwtable
define dso_local void @_Z32_hmt_test_Projection_PerspectiveP21hmt_testresult_struct(ptr nocapture noundef %0) local_unnamed_addr #4 {
  %2 = alloca %union.HMM_Mat4, align 16
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca %union.HMM_Mat4, align 16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #6
  call void @_ZL21HMM_Perspective_RH_NOffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  %6 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %7 = extractvalue { double, double } %6, 0
  %8 = extractvalue { double, double } %6, 1
  %9 = load i32, ptr %0, align 4, !tbaa !5
  %10 = add nsw i32 %9, 1
  store i32 %10, ptr %0, align 4, !tbaa !5
  %11 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, double %7, double %8)
  %12 = extractvalue { double, double } %11, 0
  %13 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %14 = extractvalue { double, double } %13, 0
  %15 = insertelement <2 x double> poison, double %12, i64 0
  %16 = insertelement <2 x double> %15, double %14, i64 1
  %17 = bitcast <2 x double> %16 to <2 x i64>
  %18 = trunc <2 x i64> %17 to <2 x i32>
  %19 = bitcast <2 x i32> %18 to <2 x float>
  %shift = shufflevector <2 x float> %19, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %20 = fsub <2 x float> %19, %shift
  %21 = extractelement <2 x float> %20, i64 0
  %22 = call float @llvm.fabs.f32(float %21)
  %or.cond = fcmp ogt float %22, 0x3E80000000000000
  br i1 %or.cond, label %23, label %38

23:                                               ; preds = %1
  %24 = extractelement <2 x float> %19, i64 0
  %25 = getelementptr inbounds i8, ptr %0, i64 4
  %26 = load i32, ptr %25, align 4, !tbaa !10
  %27 = add nsw i32 %26, 1
  store i32 %27, ptr %25, align 4, !tbaa !10
  %28 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 58)
  %29 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %30 = extractvalue { double, double } %29, 0
  %31 = bitcast double %30 to i64
  %32 = trunc i64 %31 to i32
  %33 = bitcast i32 %32 to float
  %34 = fpext float %33 to double
  %35 = fpext float %24 to double
  %36 = fpext float %21 to double
  %37 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %34, double noundef %35, double noundef %36)
  br label %38

38:                                               ; preds = %1, %23
  %39 = load i32, ptr %0, align 4, !tbaa !5
  %40 = add nsw i32 %39, 1
  store i32 %40, ptr %0, align 4, !tbaa !5
  %41 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, double %7, double %8)
  %42 = extractvalue { double, double } %41, 0
  %43 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %44 = extractvalue { double, double } %43, 0
  %45 = insertelement <2 x double> poison, double %42, i64 0
  %46 = insertelement <2 x double> %45, double %44, i64 1
  %47 = bitcast <2 x double> %46 to <2 x i64>
  %48 = lshr <2 x i64> %47, <i64 32, i64 32>
  %49 = trunc nuw <2 x i64> %48 to <2 x i32>
  %50 = bitcast <2 x i32> %49 to <2 x float>
  %shift310 = shufflevector <2 x float> %50, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %51 = fsub <2 x float> %50, %shift310
  %52 = extractelement <2 x float> %51, i64 0
  %53 = call float @llvm.fabs.f32(float %52)
  %or.cond3 = fcmp ogt float %53, 0x3E80000000000000
  br i1 %or.cond3, label %54, label %70

54:                                               ; preds = %38
  %55 = extractelement <2 x float> %50, i64 0
  %56 = getelementptr inbounds i8, ptr %0, i64 4
  %57 = load i32, ptr %56, align 4, !tbaa !10
  %58 = add nsw i32 %57, 1
  store i32 %58, ptr %56, align 4, !tbaa !10
  %59 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 58)
  %60 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %61 = extractvalue { double, double } %60, 0
  %62 = bitcast double %61 to i64
  %63 = lshr i64 %62, 32
  %64 = trunc nuw i64 %63 to i32
  %65 = bitcast i32 %64 to float
  %66 = fpext float %65 to double
  %67 = fpext float %55 to double
  %68 = fpext float %52 to double
  %69 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %66, double noundef %67, double noundef %68)
  br label %70

70:                                               ; preds = %38, %54
  %71 = load i32, ptr %0, align 4, !tbaa !5
  %72 = add nsw i32 %71, 1
  store i32 %72, ptr %0, align 4, !tbaa !5
  %73 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, double %7, double %8)
  %74 = extractvalue { double, double } %73, 1
  %75 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %76 = extractvalue { double, double } %75, 1
  %77 = insertelement <2 x double> poison, double %74, i64 0
  %78 = insertelement <2 x double> %77, double %76, i64 1
  %79 = bitcast <2 x double> %78 to <2 x i64>
  %80 = trunc <2 x i64> %79 to <2 x i32>
  %81 = bitcast <2 x i32> %80 to <2 x float>
  %shift311 = shufflevector <2 x float> %81, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %82 = fsub <2 x float> %81, %shift311
  %83 = extractelement <2 x float> %82, i64 0
  %84 = call float @llvm.fabs.f32(float %83)
  %or.cond5 = fcmp ogt float %84, 0x3E80000000000000
  br i1 %or.cond5, label %85, label %100

85:                                               ; preds = %70
  %86 = extractelement <2 x float> %81, i64 0
  %87 = getelementptr inbounds i8, ptr %0, i64 4
  %88 = load i32, ptr %87, align 4, !tbaa !10
  %89 = add nsw i32 %88, 1
  store i32 %89, ptr %87, align 4, !tbaa !10
  %90 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 58)
  %91 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %92 = extractvalue { double, double } %91, 1
  %93 = bitcast double %92 to i64
  %94 = trunc i64 %93 to i32
  %95 = bitcast i32 %94 to float
  %96 = fpext float %95 to double
  %97 = fpext float %86 to double
  %98 = fpext float %83 to double
  %99 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %96, double noundef %97, double noundef %98)
  br label %100

100:                                              ; preds = %70, %85
  %101 = load i32, ptr %0, align 4, !tbaa !5
  %102 = add nsw i32 %101, 1
  store i32 %102, ptr %0, align 4, !tbaa !5
  %103 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, double %7, double %8)
  %104 = extractvalue { double, double } %103, 1
  %105 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %106 = extractvalue { double, double } %105, 1
  %107 = insertelement <2 x double> poison, double %104, i64 0
  %108 = insertelement <2 x double> %107, double %106, i64 1
  %109 = bitcast <2 x double> %108 to <2 x i64>
  %110 = lshr <2 x i64> %109, <i64 32, i64 32>
  %111 = trunc nuw <2 x i64> %110 to <2 x i32>
  %112 = bitcast <2 x i32> %111 to <2 x float>
  %shift312 = shufflevector <2 x float> %112, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %113 = fsub <2 x float> %112, %shift312
  %114 = extractelement <2 x float> %113, i64 0
  %115 = call float @llvm.fabs.f32(float %114)
  %or.cond7 = fcmp ogt float %115, 0x3E80000000000000
  br i1 %or.cond7, label %116, label %132

116:                                              ; preds = %100
  %117 = extractelement <2 x float> %112, i64 0
  %118 = getelementptr inbounds i8, ptr %0, i64 4
  %119 = load i32, ptr %118, align 4, !tbaa !10
  %120 = add nsw i32 %119, 1
  store i32 %120, ptr %118, align 4, !tbaa !10
  %121 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 58)
  %122 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %123 = extractvalue { double, double } %122, 1
  %124 = bitcast double %123 to i64
  %125 = lshr i64 %124, 32
  %126 = trunc nuw i64 %125 to i32
  %127 = bitcast i32 %126 to float
  %128 = fpext float %127 to double
  %129 = fpext float %117 to double
  %130 = fpext float %114 to double
  %131 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %128, double noundef %129, double noundef %130)
  br label %132

132:                                              ; preds = %100, %116
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #6
  call void @_ZL21HMM_Perspective_RH_ZOffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  %133 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %134 = extractvalue { double, double } %133, 0
  %135 = extractvalue { double, double } %133, 1
  %136 = load i32, ptr %0, align 4, !tbaa !5
  %137 = add nsw i32 %136, 1
  store i32 %137, ptr %0, align 4, !tbaa !5
  %138 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %134, double %135)
  %139 = extractvalue { double, double } %138, 0
  %140 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %141 = extractvalue { double, double } %140, 0
  %142 = insertelement <2 x double> poison, double %139, i64 0
  %143 = insertelement <2 x double> %142, double %141, i64 1
  %144 = bitcast <2 x double> %143 to <2 x i64>
  %145 = trunc <2 x i64> %144 to <2 x i32>
  %146 = bitcast <2 x i32> %145 to <2 x float>
  %shift313 = shufflevector <2 x float> %146, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %147 = fsub <2 x float> %146, %shift313
  %148 = extractelement <2 x float> %147, i64 0
  %149 = call float @llvm.fabs.f32(float %148)
  %or.cond9 = fcmp ogt float %149, 0x3E80000000000000
  br i1 %or.cond9, label %150, label %165

150:                                              ; preds = %132
  %151 = extractelement <2 x float> %146, i64 0
  %152 = getelementptr inbounds i8, ptr %0, i64 4
  %153 = load i32, ptr %152, align 4, !tbaa !10
  %154 = add nsw i32 %153, 1
  store i32 %154, ptr %152, align 4, !tbaa !10
  %155 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 65)
  %156 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %157 = extractvalue { double, double } %156, 0
  %158 = bitcast double %157 to i64
  %159 = trunc i64 %158 to i32
  %160 = bitcast i32 %159 to float
  %161 = fpext float %160 to double
  %162 = fpext float %151 to double
  %163 = fpext float %148 to double
  %164 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %161, double noundef %162, double noundef %163)
  br label %165

165:                                              ; preds = %132, %150
  %166 = load i32, ptr %0, align 4, !tbaa !5
  %167 = add nsw i32 %166, 1
  store i32 %167, ptr %0, align 4, !tbaa !5
  %168 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %134, double %135)
  %169 = extractvalue { double, double } %168, 0
  %170 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %171 = extractvalue { double, double } %170, 0
  %172 = insertelement <2 x double> poison, double %169, i64 0
  %173 = insertelement <2 x double> %172, double %171, i64 1
  %174 = bitcast <2 x double> %173 to <2 x i64>
  %175 = lshr <2 x i64> %174, <i64 32, i64 32>
  %176 = trunc nuw <2 x i64> %175 to <2 x i32>
  %177 = bitcast <2 x i32> %176 to <2 x float>
  %shift314 = shufflevector <2 x float> %177, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %178 = fsub <2 x float> %177, %shift314
  %179 = extractelement <2 x float> %178, i64 0
  %180 = call float @llvm.fabs.f32(float %179)
  %or.cond11 = fcmp ogt float %180, 0x3E80000000000000
  br i1 %or.cond11, label %181, label %197

181:                                              ; preds = %165
  %182 = extractelement <2 x float> %177, i64 0
  %183 = getelementptr inbounds i8, ptr %0, i64 4
  %184 = load i32, ptr %183, align 4, !tbaa !10
  %185 = add nsw i32 %184, 1
  store i32 %185, ptr %183, align 4, !tbaa !10
  %186 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 65)
  %187 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %188 = extractvalue { double, double } %187, 0
  %189 = bitcast double %188 to i64
  %190 = lshr i64 %189, 32
  %191 = trunc nuw i64 %190 to i32
  %192 = bitcast i32 %191 to float
  %193 = fpext float %192 to double
  %194 = fpext float %182 to double
  %195 = fpext float %179 to double
  %196 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %193, double noundef %194, double noundef %195)
  br label %197

197:                                              ; preds = %165, %181
  %198 = load i32, ptr %0, align 4, !tbaa !5
  %199 = add nsw i32 %198, 1
  store i32 %199, ptr %0, align 4, !tbaa !5
  %200 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %134, double %135)
  %201 = extractvalue { double, double } %200, 1
  %202 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %203 = extractvalue { double, double } %202, 1
  %204 = insertelement <2 x double> poison, double %201, i64 0
  %205 = insertelement <2 x double> %204, double %203, i64 1
  %206 = bitcast <2 x double> %205 to <2 x i64>
  %207 = trunc <2 x i64> %206 to <2 x i32>
  %208 = bitcast <2 x i32> %207 to <2 x float>
  %shift315 = shufflevector <2 x float> %208, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %209 = fsub <2 x float> %208, %shift315
  %210 = extractelement <2 x float> %209, i64 0
  %211 = call float @llvm.fabs.f32(float %210)
  %or.cond13 = fcmp ogt float %211, 0x3E80000000000000
  br i1 %or.cond13, label %212, label %227

212:                                              ; preds = %197
  %213 = extractelement <2 x float> %208, i64 0
  %214 = getelementptr inbounds i8, ptr %0, i64 4
  %215 = load i32, ptr %214, align 4, !tbaa !10
  %216 = add nsw i32 %215, 1
  store i32 %216, ptr %214, align 4, !tbaa !10
  %217 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 65)
  %218 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %219 = extractvalue { double, double } %218, 1
  %220 = bitcast double %219 to i64
  %221 = trunc i64 %220 to i32
  %222 = bitcast i32 %221 to float
  %223 = fpext float %222 to double
  %224 = fpext float %213 to double
  %225 = fpext float %210 to double
  %226 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %223, double noundef %224, double noundef %225)
  br label %227

227:                                              ; preds = %197, %212
  %228 = load i32, ptr %0, align 4, !tbaa !5
  %229 = add nsw i32 %228, 1
  store i32 %229, ptr %0, align 4, !tbaa !5
  %230 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %134, double %135)
  %231 = extractvalue { double, double } %230, 1
  %232 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %233 = extractvalue { double, double } %232, 1
  %234 = insertelement <2 x double> poison, double %231, i64 0
  %235 = insertelement <2 x double> %234, double %233, i64 1
  %236 = bitcast <2 x double> %235 to <2 x i64>
  %237 = lshr <2 x i64> %236, <i64 32, i64 32>
  %238 = trunc nuw <2 x i64> %237 to <2 x i32>
  %239 = bitcast <2 x i32> %238 to <2 x float>
  %shift316 = shufflevector <2 x float> %239, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %240 = fsub <2 x float> %239, %shift316
  %241 = extractelement <2 x float> %240, i64 0
  %242 = call float @llvm.fabs.f32(float %241)
  %or.cond15 = fcmp ogt float %242, 0x3E80000000000000
  br i1 %or.cond15, label %243, label %259

243:                                              ; preds = %227
  %244 = extractelement <2 x float> %239, i64 0
  %245 = getelementptr inbounds i8, ptr %0, i64 4
  %246 = load i32, ptr %245, align 4, !tbaa !10
  %247 = add nsw i32 %246, 1
  store i32 %247, ptr %245, align 4, !tbaa !10
  %248 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 65)
  %249 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %250 = extractvalue { double, double } %249, 1
  %251 = bitcast double %250 to i64
  %252 = lshr i64 %251, 32
  %253 = trunc nuw i64 %252 to i32
  %254 = bitcast i32 %253 to float
  %255 = fpext float %254 to double
  %256 = fpext float %244 to double
  %257 = fpext float %241 to double
  %258 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %255, double noundef %256, double noundef %257)
  br label %259

259:                                              ; preds = %227, %243
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #6
  call void @_ZL21HMM_Perspective_LH_NOffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  %260 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %261 = extractvalue { double, double } %260, 0
  %262 = extractvalue { double, double } %260, 1
  %263 = load i32, ptr %0, align 4, !tbaa !5
  %264 = add nsw i32 %263, 1
  store i32 %264, ptr %0, align 4, !tbaa !5
  %265 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %261, double %262)
  %266 = extractvalue { double, double } %265, 0
  %267 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %268 = extractvalue { double, double } %267, 0
  %269 = insertelement <2 x double> poison, double %266, i64 0
  %270 = insertelement <2 x double> %269, double %268, i64 1
  %271 = bitcast <2 x double> %270 to <2 x i64>
  %272 = trunc <2 x i64> %271 to <2 x i32>
  %273 = bitcast <2 x i32> %272 to <2 x float>
  %shift317 = shufflevector <2 x float> %273, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %274 = fsub <2 x float> %273, %shift317
  %275 = extractelement <2 x float> %274, i64 0
  %276 = call float @llvm.fabs.f32(float %275)
  %or.cond17 = fcmp ogt float %276, 0x3E80000000000000
  br i1 %or.cond17, label %277, label %292

277:                                              ; preds = %259
  %278 = extractelement <2 x float> %273, i64 0
  %279 = getelementptr inbounds i8, ptr %0, i64 4
  %280 = load i32, ptr %279, align 4, !tbaa !10
  %281 = add nsw i32 %280, 1
  store i32 %281, ptr %279, align 4, !tbaa !10
  %282 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 75)
  %283 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %284 = extractvalue { double, double } %283, 0
  %285 = bitcast double %284 to i64
  %286 = trunc i64 %285 to i32
  %287 = bitcast i32 %286 to float
  %288 = fpext float %287 to double
  %289 = fpext float %278 to double
  %290 = fpext float %275 to double
  %291 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %288, double noundef %289, double noundef %290)
  br label %292

292:                                              ; preds = %259, %277
  %293 = load i32, ptr %0, align 4, !tbaa !5
  %294 = add nsw i32 %293, 1
  store i32 %294, ptr %0, align 4, !tbaa !5
  %295 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %261, double %262)
  %296 = extractvalue { double, double } %295, 0
  %297 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %298 = extractvalue { double, double } %297, 0
  %299 = insertelement <2 x double> poison, double %296, i64 0
  %300 = insertelement <2 x double> %299, double %298, i64 1
  %301 = bitcast <2 x double> %300 to <2 x i64>
  %302 = lshr <2 x i64> %301, <i64 32, i64 32>
  %303 = trunc nuw <2 x i64> %302 to <2 x i32>
  %304 = bitcast <2 x i32> %303 to <2 x float>
  %shift318 = shufflevector <2 x float> %304, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %305 = fsub <2 x float> %304, %shift318
  %306 = extractelement <2 x float> %305, i64 0
  %307 = call float @llvm.fabs.f32(float %306)
  %or.cond19 = fcmp ogt float %307, 0x3E80000000000000
  br i1 %or.cond19, label %308, label %324

308:                                              ; preds = %292
  %309 = extractelement <2 x float> %304, i64 0
  %310 = getelementptr inbounds i8, ptr %0, i64 4
  %311 = load i32, ptr %310, align 4, !tbaa !10
  %312 = add nsw i32 %311, 1
  store i32 %312, ptr %310, align 4, !tbaa !10
  %313 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 75)
  %314 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %315 = extractvalue { double, double } %314, 0
  %316 = bitcast double %315 to i64
  %317 = lshr i64 %316, 32
  %318 = trunc nuw i64 %317 to i32
  %319 = bitcast i32 %318 to float
  %320 = fpext float %319 to double
  %321 = fpext float %309 to double
  %322 = fpext float %306 to double
  %323 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %320, double noundef %321, double noundef %322)
  br label %324

324:                                              ; preds = %292, %308
  %325 = load i32, ptr %0, align 4, !tbaa !5
  %326 = add nsw i32 %325, 1
  store i32 %326, ptr %0, align 4, !tbaa !5
  %327 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %261, double %262)
  %328 = extractvalue { double, double } %327, 1
  %329 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %330 = extractvalue { double, double } %329, 1
  %331 = insertelement <2 x double> poison, double %328, i64 0
  %332 = insertelement <2 x double> %331, double %330, i64 1
  %333 = bitcast <2 x double> %332 to <2 x i64>
  %334 = trunc <2 x i64> %333 to <2 x i32>
  %335 = bitcast <2 x i32> %334 to <2 x float>
  %shift319 = shufflevector <2 x float> %335, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %336 = fsub <2 x float> %335, %shift319
  %337 = extractelement <2 x float> %336, i64 0
  %338 = call float @llvm.fabs.f32(float %337)
  %or.cond21 = fcmp ogt float %338, 0x3E80000000000000
  br i1 %or.cond21, label %339, label %354

339:                                              ; preds = %324
  %340 = extractelement <2 x float> %335, i64 0
  %341 = getelementptr inbounds i8, ptr %0, i64 4
  %342 = load i32, ptr %341, align 4, !tbaa !10
  %343 = add nsw i32 %342, 1
  store i32 %343, ptr %341, align 4, !tbaa !10
  %344 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 75)
  %345 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %346 = extractvalue { double, double } %345, 1
  %347 = bitcast double %346 to i64
  %348 = trunc i64 %347 to i32
  %349 = bitcast i32 %348 to float
  %350 = fpext float %349 to double
  %351 = fpext float %340 to double
  %352 = fpext float %337 to double
  %353 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %350, double noundef %351, double noundef %352)
  br label %354

354:                                              ; preds = %324, %339
  %355 = load i32, ptr %0, align 4, !tbaa !5
  %356 = add nsw i32 %355, 1
  store i32 %356, ptr %0, align 4, !tbaa !5
  %357 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %261, double %262)
  %358 = extractvalue { double, double } %357, 1
  %359 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %360 = extractvalue { double, double } %359, 1
  %361 = insertelement <2 x double> poison, double %358, i64 0
  %362 = insertelement <2 x double> %361, double %360, i64 1
  %363 = bitcast <2 x double> %362 to <2 x i64>
  %364 = lshr <2 x i64> %363, <i64 32, i64 32>
  %365 = trunc nuw <2 x i64> %364 to <2 x i32>
  %366 = bitcast <2 x i32> %365 to <2 x float>
  %shift320 = shufflevector <2 x float> %366, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %367 = fsub <2 x float> %366, %shift320
  %368 = extractelement <2 x float> %367, i64 0
  %369 = call float @llvm.fabs.f32(float %368)
  %or.cond23 = fcmp ogt float %369, 0x3E80000000000000
  br i1 %or.cond23, label %370, label %386

370:                                              ; preds = %354
  %371 = extractelement <2 x float> %366, i64 0
  %372 = getelementptr inbounds i8, ptr %0, i64 4
  %373 = load i32, ptr %372, align 4, !tbaa !10
  %374 = add nsw i32 %373, 1
  store i32 %374, ptr %372, align 4, !tbaa !10
  %375 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 75)
  %376 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %377 = extractvalue { double, double } %376, 1
  %378 = bitcast double %377 to i64
  %379 = lshr i64 %378, 32
  %380 = trunc nuw i64 %379 to i32
  %381 = bitcast i32 %380 to float
  %382 = fpext float %381 to double
  %383 = fpext float %371 to double
  %384 = fpext float %368 to double
  %385 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %382, double noundef %383, double noundef %384)
  br label %386

386:                                              ; preds = %354, %370
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #6
  call void @_ZL21HMM_Perspective_LH_ZOffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %5, float noundef 0x3FF921FB60000000, float noundef 2.000000e+00, float noundef 1.000000e+00, float noundef 1.500000e+01)
  %387 = call { double, double } @_ZL6HMM_V4ffff(float noundef 5.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %388 = extractvalue { double, double } %387, 0
  %389 = extractvalue { double, double } %387, 1
  %390 = load i32, ptr %0, align 4, !tbaa !5
  %391 = add nsw i32 %390, 1
  store i32 %391, ptr %0, align 4, !tbaa !5
  %392 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %388, double %389)
  %393 = extractvalue { double, double } %392, 0
  %394 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %395 = extractvalue { double, double } %394, 0
  %396 = insertelement <2 x double> poison, double %393, i64 0
  %397 = insertelement <2 x double> %396, double %395, i64 1
  %398 = bitcast <2 x double> %397 to <2 x i64>
  %399 = trunc <2 x i64> %398 to <2 x i32>
  %400 = bitcast <2 x i32> %399 to <2 x float>
  %shift321 = shufflevector <2 x float> %400, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %401 = fsub <2 x float> %400, %shift321
  %402 = extractelement <2 x float> %401, i64 0
  %403 = call float @llvm.fabs.f32(float %402)
  %or.cond25 = fcmp ogt float %403, 0x3E80000000000000
  br i1 %or.cond25, label %404, label %419

404:                                              ; preds = %386
  %405 = extractelement <2 x float> %400, i64 0
  %406 = getelementptr inbounds i8, ptr %0, i64 4
  %407 = load i32, ptr %406, align 4, !tbaa !10
  %408 = add nsw i32 %407, 1
  store i32 %408, ptr %406, align 4, !tbaa !10
  %409 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 82)
  %410 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %411 = extractvalue { double, double } %410, 0
  %412 = bitcast double %411 to i64
  %413 = trunc i64 %412 to i32
  %414 = bitcast i32 %413 to float
  %415 = fpext float %414 to double
  %416 = fpext float %405 to double
  %417 = fpext float %402 to double
  %418 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %415, double noundef %416, double noundef %417)
  br label %419

419:                                              ; preds = %386, %404
  %420 = load i32, ptr %0, align 4, !tbaa !5
  %421 = add nsw i32 %420, 1
  store i32 %421, ptr %0, align 4, !tbaa !5
  %422 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %388, double %389)
  %423 = extractvalue { double, double } %422, 0
  %424 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %425 = extractvalue { double, double } %424, 0
  %426 = insertelement <2 x double> poison, double %423, i64 0
  %427 = insertelement <2 x double> %426, double %425, i64 1
  %428 = bitcast <2 x double> %427 to <2 x i64>
  %429 = lshr <2 x i64> %428, <i64 32, i64 32>
  %430 = trunc nuw <2 x i64> %429 to <2 x i32>
  %431 = bitcast <2 x i32> %430 to <2 x float>
  %shift322 = shufflevector <2 x float> %431, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %432 = fsub <2 x float> %431, %shift322
  %433 = extractelement <2 x float> %432, i64 0
  %434 = call float @llvm.fabs.f32(float %433)
  %or.cond27 = fcmp ogt float %434, 0x3E80000000000000
  br i1 %or.cond27, label %435, label %451

435:                                              ; preds = %419
  %436 = extractelement <2 x float> %431, i64 0
  %437 = getelementptr inbounds i8, ptr %0, i64 4
  %438 = load i32, ptr %437, align 4, !tbaa !10
  %439 = add nsw i32 %438, 1
  store i32 %439, ptr %437, align 4, !tbaa !10
  %440 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 82)
  %441 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %442 = extractvalue { double, double } %441, 0
  %443 = bitcast double %442 to i64
  %444 = lshr i64 %443, 32
  %445 = trunc nuw i64 %444 to i32
  %446 = bitcast i32 %445 to float
  %447 = fpext float %446 to double
  %448 = fpext float %436 to double
  %449 = fpext float %433 to double
  %450 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %447, double noundef %448, double noundef %449)
  br label %451

451:                                              ; preds = %419, %435
  %452 = load i32, ptr %0, align 4, !tbaa !5
  %453 = add nsw i32 %452, 1
  store i32 %453, ptr %0, align 4, !tbaa !5
  %454 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %388, double %389)
  %455 = extractvalue { double, double } %454, 1
  %456 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %457 = extractvalue { double, double } %456, 1
  %458 = insertelement <2 x double> poison, double %455, i64 0
  %459 = insertelement <2 x double> %458, double %457, i64 1
  %460 = bitcast <2 x double> %459 to <2 x i64>
  %461 = trunc <2 x i64> %460 to <2 x i32>
  %462 = bitcast <2 x i32> %461 to <2 x float>
  %shift323 = shufflevector <2 x float> %462, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %463 = fsub <2 x float> %462, %shift323
  %464 = extractelement <2 x float> %463, i64 0
  %465 = call float @llvm.fabs.f32(float %464)
  %or.cond29 = fcmp ogt float %465, 0x3E80000000000000
  br i1 %or.cond29, label %466, label %481

466:                                              ; preds = %451
  %467 = extractelement <2 x float> %462, i64 0
  %468 = getelementptr inbounds i8, ptr %0, i64 4
  %469 = load i32, ptr %468, align 4, !tbaa !10
  %470 = add nsw i32 %469, 1
  store i32 %470, ptr %468, align 4, !tbaa !10
  %471 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 82)
  %472 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %473 = extractvalue { double, double } %472, 1
  %474 = bitcast double %473 to i64
  %475 = trunc i64 %474 to i32
  %476 = bitcast i32 %475 to float
  %477 = fpext float %476 to double
  %478 = fpext float %467 to double
  %479 = fpext float %464 to double
  %480 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %477, double noundef %478, double noundef %479)
  br label %481

481:                                              ; preds = %451, %466
  %482 = load i32, ptr %0, align 4, !tbaa !5
  %483 = add nsw i32 %482, 1
  store i32 %483, ptr %0, align 4, !tbaa !5
  %484 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %388, double %389)
  %485 = extractvalue { double, double } %484, 1
  %486 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %487 = extractvalue { double, double } %486, 1
  %488 = insertelement <2 x double> poison, double %485, i64 0
  %489 = insertelement <2 x double> %488, double %487, i64 1
  %490 = bitcast <2 x double> %489 to <2 x i64>
  %491 = lshr <2 x i64> %490, <i64 32, i64 32>
  %492 = trunc nuw <2 x i64> %491 to <2 x i32>
  %493 = bitcast <2 x i32> %492 to <2 x float>
  %shift324 = shufflevector <2 x float> %493, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %494 = fsub <2 x float> %493, %shift324
  %495 = extractelement <2 x float> %494, i64 0
  %496 = call float @llvm.fabs.f32(float %495)
  %or.cond31 = fcmp ogt float %496, 0x3E80000000000000
  br i1 %or.cond31, label %497, label %513

497:                                              ; preds = %481
  %498 = extractelement <2 x float> %493, i64 0
  %499 = getelementptr inbounds i8, ptr %0, i64 4
  %500 = load i32, ptr %499, align 4, !tbaa !10
  %501 = add nsw i32 %500, 1
  store i32 %501, ptr %499, align 4, !tbaa !10
  %502 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 82)
  %503 = call { double, double } @_ZL6HMM_V4ffff(float noundef 2.500000e+00, float noundef 5.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %504 = extractvalue { double, double } %503, 1
  %505 = bitcast double %504 to i64
  %506 = lshr i64 %505, 32
  %507 = trunc nuw i64 %506 to i32
  %508 = bitcast i32 %507 to float
  %509 = fpext float %508 to double
  %510 = fpext float %498 to double
  %511 = fpext float %495 to double
  %512 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %509, double noundef %510, double noundef %511)
  br label %513

513:                                              ; preds = %481, %497
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #6
  ret void
}

; 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"="128" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { inlinehint mustprogress uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { mustprogress uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { 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 = !{!6, !7, i64 4}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,InferFunctionAttrsPass,InstCombinePass,MemCpyOptPass,PostOrderFunctionAttrsPass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass