; LLVM IR from HandmadeMath/HandmadeMath :: test/hmm_test.ll (Z33_hmt_test_Projection_OrthographicP21hmt_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 @_ZL22HMM_Orthographic_RH_NOffffff(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, float noundef, float noundef, float noundef, float noundef, float noundef, float noundef) #4

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL22HMM_Orthographic_LH_ZOffffff(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, float noundef, float noundef, 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 @_Z33_hmt_test_Projection_OrthographicP21hmt_testresult_struct(ptr noundef %0) #5 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Vec4, align 16
  %4 = alloca %union.HMM_Vec4, align 16
  %5 = alloca %union.HMM_Mat4, align 16
  %6 = alloca float, align 4
  %7 = alloca %union.HMM_Vec4, align 16
  %8 = alloca %union.HMM_Mat4, align 16
  %9 = alloca %union.HMM_Vec4, align 16
  %10 = alloca float, align 4
  %11 = alloca %union.HMM_Vec4, align 16
  %12 = alloca %union.HMM_Vec4, align 16
  %13 = alloca float, align 4
  %14 = alloca %union.HMM_Vec4, align 16
  %15 = alloca %union.HMM_Mat4, align 16
  %16 = alloca %union.HMM_Vec4, align 16
  %17 = alloca float, align 4
  %18 = alloca %union.HMM_Vec4, align 16
  %19 = alloca %union.HMM_Vec4, align 16
  %20 = alloca float, align 4
  %21 = alloca %union.HMM_Vec4, align 16
  %22 = alloca %union.HMM_Mat4, align 16
  %23 = alloca %union.HMM_Vec4, align 16
  %24 = alloca float, align 4
  %25 = alloca %union.HMM_Vec4, align 16
  %26 = alloca %union.HMM_Vec4, align 16
  %27 = alloca float, align 4
  %28 = alloca %union.HMM_Vec4, align 16
  %29 = alloca %union.HMM_Mat4, align 16
  %30 = alloca %union.HMM_Vec4, align 16
  %31 = alloca float, align 4
  %32 = alloca %union.HMM_Vec4, align 16
  %33 = alloca %union.HMM_Vec4, align 16
  %34 = alloca float, align 4
  %35 = alloca %union.HMM_Vec4, align 16
  %36 = alloca %union.HMM_Mat4, align 16
  %37 = alloca %union.HMM_Vec4, align 16
  %38 = alloca float, align 4
  %39 = alloca %union.HMM_Vec4, align 16
  %40 = alloca %union.HMM_Vec4, align 16
  %41 = alloca float, align 4
  %42 = alloca %union.HMM_Vec4, align 16
  %43 = alloca %union.HMM_Mat4, align 16
  %44 = alloca %union.HMM_Vec4, align 16
  %45 = alloca float, align 4
  %46 = alloca %union.HMM_Vec4, align 16
  %47 = alloca %union.HMM_Vec4, align 16
  %48 = alloca float, align 4
  %49 = alloca %union.HMM_Vec4, align 16
  %50 = alloca %union.HMM_Mat4, align 16
  %51 = alloca %union.HMM_Vec4, align 16
  %52 = alloca float, align 4
  %53 = alloca %union.HMM_Vec4, align 16
  %54 = alloca %union.HMM_Vec4, align 16
  %55 = alloca float, align 4
  %56 = alloca %union.HMM_Vec4, align 16
  %57 = alloca %union.HMM_Mat4, align 16
  %58 = alloca %union.HMM_Vec4, align 16
  %59 = alloca float, align 4
  %60 = alloca %union.HMM_Vec4, align 16
  %61 = alloca %union.HMM_Vec4, align 16
  %62 = alloca %union.HMM_Mat4, align 16
  %63 = alloca float, align 4
  %64 = alloca %union.HMM_Vec4, align 16
  %65 = alloca %union.HMM_Mat4, align 16
  %66 = alloca %union.HMM_Vec4, align 16
  %67 = alloca float, align 4
  %68 = alloca %union.HMM_Vec4, align 16
  %69 = alloca %union.HMM_Vec4, align 16
  %70 = alloca float, align 4
  %71 = alloca %union.HMM_Vec4, align 16
  %72 = alloca %union.HMM_Mat4, align 16
  %73 = alloca %union.HMM_Vec4, align 16
  %74 = alloca float, align 4
  %75 = alloca %union.HMM_Vec4, align 16
  %76 = alloca %union.HMM_Vec4, align 16
  %77 = alloca float, align 4
  %78 = alloca %union.HMM_Vec4, align 16
  %79 = alloca %union.HMM_Mat4, align 16
  %80 = alloca %union.HMM_Vec4, align 16
  %81 = alloca float, align 4
  %82 = alloca %union.HMM_Vec4, align 16
  %83 = alloca %union.HMM_Vec4, align 16
  %84 = alloca float, align 4
  %85 = alloca %union.HMM_Vec4, align 16
  %86 = alloca %union.HMM_Mat4, align 16
  %87 = alloca %union.HMM_Vec4, align 16
  %88 = alloca float, align 4
  %89 = alloca %union.HMM_Vec4, align 16
  %90 = alloca %union.HMM_Vec4, align 16
  %91 = alloca float, align 4
  %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_Vec4, align 16
  %98 = alloca float, align 4
  %99 = alloca %union.HMM_Vec4, align 16
  %100 = alloca %union.HMM_Mat4, 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_Vec4, align 16
  %105 = alloca float, align 4
  %106 = alloca %union.HMM_Vec4, align 16
  %107 = alloca %union.HMM_Mat4, 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_Vec4, align 16
  %112 = alloca float, align 4
  %113 = alloca %union.HMM_Vec4, align 16
  %114 = alloca %union.HMM_Mat4, 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_Vec4, align 16
  %119 = alloca %union.HMM_Vec4, align 16
  %120 = alloca %union.HMM_Vec4, align 16
  %121 = alloca %union.HMM_Mat4, align 16
  %122 = alloca float, align 4
  %123 = alloca %union.HMM_Vec4, align 16
  %124 = alloca %union.HMM_Mat4, align 16
  %125 = alloca %union.HMM_Vec4, align 16
  %126 = alloca float, align 4
  %127 = alloca %union.HMM_Vec4, align 16
  %128 = alloca %union.HMM_Vec4, align 16
  %129 = alloca float, align 4
  %130 = alloca %union.HMM_Vec4, align 16
  %131 = alloca %union.HMM_Mat4, align 16
  %132 = alloca %union.HMM_Vec4, align 16
  %133 = alloca float, align 4
  %134 = alloca %union.HMM_Vec4, align 16
  %135 = alloca %union.HMM_Vec4, align 16
  %136 = alloca float, align 4
  %137 = alloca %union.HMM_Vec4, align 16
  %138 = alloca %union.HMM_Mat4, align 16
  %139 = alloca %union.HMM_Vec4, align 16
  %140 = alloca float, align 4
  %141 = alloca %union.HMM_Vec4, align 16
  %142 = alloca %union.HMM_Vec4, align 16
  %143 = alloca float, align 4
  %144 = alloca %union.HMM_Vec4, align 16
  %145 = alloca %union.HMM_Mat4, align 16
  %146 = alloca %union.HMM_Vec4, align 16
  %147 = alloca float, align 4
  %148 = alloca %union.HMM_Vec4, align 16
  %149 = alloca %union.HMM_Vec4, align 16
  %150 = alloca float, align 4
  %151 = alloca %union.HMM_Vec4, align 16
  %152 = alloca %union.HMM_Mat4, align 16
  %153 = alloca %union.HMM_Vec4, align 16
  %154 = alloca float, align 4
  %155 = alloca %union.HMM_Vec4, align 16
  %156 = alloca %union.HMM_Vec4, align 16
  %157 = alloca float, align 4
  %158 = alloca %union.HMM_Vec4, align 16
  %159 = alloca %union.HMM_Mat4, align 16
  %160 = alloca %union.HMM_Vec4, align 16
  %161 = alloca float, align 4
  %162 = alloca %union.HMM_Vec4, align 16
  %163 = alloca %union.HMM_Vec4, align 16
  %164 = alloca float, align 4
  %165 = alloca %union.HMM_Vec4, align 16
  %166 = alloca %union.HMM_Mat4, align 16
  %167 = alloca %union.HMM_Vec4, align 16
  %168 = alloca float, align 4
  %169 = alloca %union.HMM_Vec4, align 16
  %170 = alloca %union.HMM_Vec4, align 16
  %171 = alloca float, align 4
  %172 = alloca %union.HMM_Vec4, align 16
  %173 = alloca %union.HMM_Mat4, align 16
  %174 = alloca %union.HMM_Vec4, align 16
  %175 = alloca float, align 4
  %176 = alloca %union.HMM_Vec4, align 16
  %177 = alloca %union.HMM_Vec4, align 16
  %178 = alloca %union.HMM_Mat4, align 16
  %179 = alloca float, align 4
  %180 = alloca %union.HMM_Vec4, align 16
  %181 = alloca %union.HMM_Mat4, align 16
  %182 = alloca %union.HMM_Vec4, align 16
  %183 = alloca float, align 4
  %184 = alloca %union.HMM_Vec4, align 16
  %185 = alloca %union.HMM_Vec4, align 16
  %186 = alloca float, align 4
  %187 = alloca %union.HMM_Vec4, align 16
  %188 = alloca %union.HMM_Mat4, align 16
  %189 = alloca %union.HMM_Vec4, align 16
  %190 = alloca float, align 4
  %191 = alloca %union.HMM_Vec4, align 16
  %192 = alloca %union.HMM_Vec4, align 16
  %193 = alloca float, align 4
  %194 = alloca %union.HMM_Vec4, align 16
  %195 = alloca %union.HMM_Mat4, align 16
  %196 = alloca %union.HMM_Vec4, align 16
  %197 = alloca float, align 4
  %198 = alloca %union.HMM_Vec4, align 16
  %199 = alloca %union.HMM_Vec4, align 16
  %200 = alloca float, align 4
  %201 = alloca %union.HMM_Vec4, align 16
  %202 = alloca %union.HMM_Mat4, align 16
  %203 = alloca %union.HMM_Vec4, align 16
  %204 = alloca float, align 4
  %205 = alloca %union.HMM_Vec4, align 16
  %206 = alloca %union.HMM_Vec4, align 16
  %207 = alloca float, align 4
  %208 = alloca %union.HMM_Vec4, align 16
  %209 = alloca %union.HMM_Mat4, align 16
  %210 = alloca %union.HMM_Vec4, align 16
  %211 = alloca float, align 4
  %212 = alloca %union.HMM_Vec4, align 16
  %213 = alloca %union.HMM_Vec4, align 16
  %214 = alloca float, align 4
  %215 = alloca %union.HMM_Vec4, align 16
  %216 = alloca %union.HMM_Mat4, align 16
  %217 = alloca %union.HMM_Vec4, align 16
  %218 = alloca float, align 4
  %219 = alloca %union.HMM_Vec4, align 16
  %220 = alloca %union.HMM_Vec4, align 16
  %221 = alloca float, align 4
  %222 = alloca %union.HMM_Vec4, align 16
  %223 = alloca %union.HMM_Mat4, align 16
  %224 = alloca %union.HMM_Vec4, align 16
  %225 = alloca float, align 4
  %226 = alloca %union.HMM_Vec4, align 16
  %227 = alloca %union.HMM_Vec4, align 16
  %228 = alloca float, align 4
  %229 = alloca %union.HMM_Vec4, align 16
  %230 = alloca %union.HMM_Mat4, align 16
  %231 = alloca %union.HMM_Vec4, align 16
  %232 = alloca float, align 4
  %233 = alloca %union.HMM_Vec4, align 16
  %234 = alloca %union.HMM_Vec4, align 16
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %3) #6
  %235 = call { double, double } @_ZL6HMM_V4ffff(float noundef -8.000000e+00, float noundef 5.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %236 = getelementptr inbounds %union.HMM_Vec4, ptr %3, i32 0, i32 0
  %237 = getelementptr inbounds { double, double }, ptr %236, i32 0, i32 0
  %238 = extractvalue { double, double } %235, 0
  store double %238, ptr %237, align 16
  %239 = getelementptr inbounds { double, double }, ptr %236, i32 0, i32 1
  %240 = extractvalue { double, double } %235, 1
  store double %240, ptr %239, align 8
  call void @llvm.lifetime.start.p0(i64 16, ptr %4) #6
  %241 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.200000e+01, float noundef 1.000000e+01, float noundef -1.000000e+02, float noundef 1.000000e+00)
  %242 = getelementptr inbounds %union.HMM_Vec4, ptr %4, i32 0, i32 0
  %243 = getelementptr inbounds { double, double }, ptr %242, i32 0, i32 0
  %244 = extractvalue { double, double } %241, 0
  store double %244, ptr %243, align 16
  %245 = getelementptr inbounds { double, double }, ptr %242, i32 0, i32 1
  %246 = extractvalue { double, double } %241, 1
  store double %246, ptr %245, align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr %5) #6
  call void @_ZL22HMM_Orthographic_RH_NOffffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %5, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %247 = load ptr, ptr %2, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %247, i32 0, i32 0
  %249 = load i32, ptr %248, align 4, !tbaa !9
  %250 = add nsw i32 %249, 1
  store i32 %250, ptr %248, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %7) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %8, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %9, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %251 = getelementptr inbounds { double, double }, ptr %9, i32 0, i32 0
  %252 = load double, ptr %251, align 16
  %253 = getelementptr inbounds { double, double }, ptr %9, i32 0, i32 1
  %254 = load double, ptr %253, align 8
  %255 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %8, double %252, double %254)
  %256 = getelementptr inbounds %union.HMM_Vec4, ptr %7, i32 0, i32 0
  %257 = getelementptr inbounds { double, double }, ptr %256, i32 0, i32 0
  %258 = extractvalue { double, double } %255, 0
  store double %258, ptr %257, align 16
  %259 = getelementptr inbounds { double, double }, ptr %256, i32 0, i32 1
  %260 = extractvalue { double, double } %255, 1
  store double %260, ptr %259, align 8
  %261 = getelementptr inbounds %struct.anon.10, ptr %7, i32 0, i32 0
  %262 = getelementptr inbounds %struct.anon.11, ptr %261, i32 0, i32 0
  %263 = load float, ptr %262, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %7) #6
  store float %263, ptr %6, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  %264 = load float, ptr %6, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %11) #6
  %265 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %266 = getelementptr inbounds %union.HMM_Vec4, ptr %11, i32 0, i32 0
  %267 = getelementptr inbounds { double, double }, ptr %266, i32 0, i32 0
  %268 = extractvalue { double, double } %265, 0
  store double %268, ptr %267, align 16
  %269 = getelementptr inbounds { double, double }, ptr %266, i32 0, i32 1
  %270 = extractvalue { double, double } %265, 1
  store double %270, ptr %269, align 8
  %271 = getelementptr inbounds %struct.anon.10, ptr %11, i32 0, i32 0
  %272 = getelementptr inbounds %struct.anon.11, ptr %271, i32 0, i32 0
  %273 = load float, ptr %272, align 16, !tbaa !13
  %274 = fsub float %264, %273
  call void @llvm.lifetime.end.p0(i64 16, ptr %11) #6
  store float %274, ptr %10, align 4, !tbaa !15
  %275 = load float, ptr %10, align 4, !tbaa !15
  %276 = fcmp olt float %275, 0xBE80000000000000
  br i1 %276, label %280, label %277

277:                                              ; preds = %1
  %278 = load float, ptr %10, align 4, !tbaa !15
  %279 = fcmp olt float 0x3E80000000000000, %278
  br i1 %279, label %280, label %301

280:                                              ; preds = %277, %1
  %281 = load ptr, ptr %2, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %281, i32 0, i32 1
  %283 = load i32, ptr %282, align 4, !tbaa !17
  %284 = add nsw i32 %283, 1
  store i32 %284, ptr %282, align 4, !tbaa !17
  %285 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 16)
  call void @llvm.lifetime.start.p0(i64 16, ptr %12) #6
  %286 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %287 = getelementptr inbounds %union.HMM_Vec4, ptr %12, i32 0, i32 0
  %288 = getelementptr inbounds { double, double }, ptr %287, i32 0, i32 0
  %289 = extractvalue { double, double } %286, 0
  store double %289, ptr %288, align 16
  %290 = getelementptr inbounds { double, double }, ptr %287, i32 0, i32 1
  %291 = extractvalue { double, double } %286, 1
  store double %291, ptr %290, align 8
  %292 = getelementptr inbounds %struct.anon.10, ptr %12, i32 0, i32 0
  %293 = getelementptr inbounds %struct.anon.11, ptr %292, i32 0, i32 0
  %294 = load float, ptr %293, align 16, !tbaa !13
  %295 = fpext float %294 to double
  %296 = load float, ptr %6, align 4, !tbaa !15
  %297 = fpext float %296 to double
  %298 = load float, ptr %10, align 4, !tbaa !15
  %299 = fpext float %298 to double
  %300 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %295, double noundef %297, double noundef %299)
  call void @llvm.lifetime.end.p0(i64 16, ptr %12) #6
  br label %301

301:                                              ; preds = %280, %277
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  %302 = load ptr, ptr %2, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %302, i32 0, i32 0
  %304 = load i32, ptr %303, align 4, !tbaa !9
  %305 = add nsw i32 %304, 1
  store i32 %305, ptr %303, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %14) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %15, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %16, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %306 = getelementptr inbounds { double, double }, ptr %16, i32 0, i32 0
  %307 = load double, ptr %306, align 16
  %308 = getelementptr inbounds { double, double }, ptr %16, i32 0, i32 1
  %309 = load double, ptr %308, align 8
  %310 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %15, double %307, double %309)
  %311 = getelementptr inbounds %union.HMM_Vec4, ptr %14, i32 0, i32 0
  %312 = getelementptr inbounds { double, double }, ptr %311, i32 0, i32 0
  %313 = extractvalue { double, double } %310, 0
  store double %313, ptr %312, align 16
  %314 = getelementptr inbounds { double, double }, ptr %311, i32 0, i32 1
  %315 = extractvalue { double, double } %310, 1
  store double %315, ptr %314, align 8
  %316 = getelementptr inbounds %struct.anon.10, ptr %14, i32 0, i32 0
  %317 = getelementptr inbounds %struct.anon.11, ptr %316, i32 0, i32 1
  %318 = load float, ptr %317, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %14) #6
  store float %318, ptr %13, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %319 = load float, ptr %13, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #6
  %320 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %321 = getelementptr inbounds %union.HMM_Vec4, ptr %18, i32 0, i32 0
  %322 = getelementptr inbounds { double, double }, ptr %321, i32 0, i32 0
  %323 = extractvalue { double, double } %320, 0
  store double %323, ptr %322, align 16
  %324 = getelementptr inbounds { double, double }, ptr %321, i32 0, i32 1
  %325 = extractvalue { double, double } %320, 1
  store double %325, ptr %324, align 8
  %326 = getelementptr inbounds %struct.anon.10, ptr %18, i32 0, i32 0
  %327 = getelementptr inbounds %struct.anon.11, ptr %326, i32 0, i32 1
  %328 = load float, ptr %327, align 4, !tbaa !13
  %329 = fsub float %319, %328
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #6
  store float %329, ptr %17, align 4, !tbaa !15
  %330 = load float, ptr %17, align 4, !tbaa !15
  %331 = fcmp olt float %330, 0xBE80000000000000
  br i1 %331, label %335, label %332

332:                                              ; preds = %301
  %333 = load float, ptr %17, align 4, !tbaa !15
  %334 = fcmp olt float 0x3E80000000000000, %333
  br i1 %334, label %335, label %356

335:                                              ; preds = %332, %301
  %336 = load ptr, ptr %2, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %336, i32 0, i32 1
  %338 = load i32, ptr %337, align 4, !tbaa !17
  %339 = add nsw i32 %338, 1
  store i32 %339, ptr %337, align 4, !tbaa !17
  %340 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 16)
  call void @llvm.lifetime.start.p0(i64 16, ptr %19) #6
  %341 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %342 = getelementptr inbounds %union.HMM_Vec4, ptr %19, i32 0, i32 0
  %343 = getelementptr inbounds { double, double }, ptr %342, i32 0, i32 0
  %344 = extractvalue { double, double } %341, 0
  store double %344, ptr %343, align 16
  %345 = getelementptr inbounds { double, double }, ptr %342, i32 0, i32 1
  %346 = extractvalue { double, double } %341, 1
  store double %346, ptr %345, align 8
  %347 = getelementptr inbounds %struct.anon.10, ptr %19, i32 0, i32 0
  %348 = getelementptr inbounds %struct.anon.11, ptr %347, i32 0, i32 1
  %349 = load float, ptr %348, align 4, !tbaa !13
  %350 = fpext float %349 to double
  %351 = load float, ptr %13, align 4, !tbaa !15
  %352 = fpext float %351 to double
  %353 = load float, ptr %17, align 4, !tbaa !15
  %354 = fpext float %353 to double
  %355 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %350, double noundef %352, double noundef %354)
  call void @llvm.lifetime.end.p0(i64 16, ptr %19) #6
  br label %356

356:                                              ; preds = %335, %332
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  %357 = load ptr, ptr %2, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %357, i32 0, i32 0
  %359 = load i32, ptr %358, align 4, !tbaa !9
  %360 = add nsw i32 %359, 1
  store i32 %360, ptr %358, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %21) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %22, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %23, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %361 = getelementptr inbounds { double, double }, ptr %23, i32 0, i32 0
  %362 = load double, ptr %361, align 16
  %363 = getelementptr inbounds { double, double }, ptr %23, i32 0, i32 1
  %364 = load double, ptr %363, align 8
  %365 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %22, double %362, double %364)
  %366 = getelementptr inbounds %union.HMM_Vec4, ptr %21, i32 0, i32 0
  %367 = getelementptr inbounds { double, double }, ptr %366, i32 0, i32 0
  %368 = extractvalue { double, double } %365, 0
  store double %368, ptr %367, align 16
  %369 = getelementptr inbounds { double, double }, ptr %366, i32 0, i32 1
  %370 = extractvalue { double, double } %365, 1
  store double %370, ptr %369, align 8
  %371 = getelementptr inbounds %struct.anon.10, ptr %21, i32 0, i32 0
  %372 = getelementptr inbounds %struct.anon.11, ptr %371, i32 0, i32 2
  %373 = load float, ptr %372, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #6
  store float %373, ptr %20, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %374 = load float, ptr %20, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #6
  %375 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %376 = getelementptr inbounds %union.HMM_Vec4, ptr %25, i32 0, i32 0
  %377 = getelementptr inbounds { double, double }, ptr %376, i32 0, i32 0
  %378 = extractvalue { double, double } %375, 0
  store double %378, ptr %377, align 16
  %379 = getelementptr inbounds { double, double }, ptr %376, i32 0, i32 1
  %380 = extractvalue { double, double } %375, 1
  store double %380, ptr %379, align 8
  %381 = getelementptr inbounds %struct.anon.10, ptr %25, i32 0, i32 0
  %382 = getelementptr inbounds %struct.anon.11, ptr %381, i32 0, i32 2
  %383 = load float, ptr %382, align 8, !tbaa !13
  %384 = fsub float %374, %383
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #6
  store float %384, ptr %24, align 4, !tbaa !15
  %385 = load float, ptr %24, align 4, !tbaa !15
  %386 = fcmp olt float %385, 0xBE80000000000000
  br i1 %386, label %390, label %387

387:                                              ; preds = %356
  %388 = load float, ptr %24, align 4, !tbaa !15
  %389 = fcmp olt float 0x3E80000000000000, %388
  br i1 %389, label %390, label %411

390:                                              ; preds = %387, %356
  %391 = load ptr, ptr %2, align 8, !tbaa !5
  %392 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %391, i32 0, i32 1
  %393 = load i32, ptr %392, align 4, !tbaa !17
  %394 = add nsw i32 %393, 1
  store i32 %394, ptr %392, align 4, !tbaa !17
  %395 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 16)
  call void @llvm.lifetime.start.p0(i64 16, ptr %26) #6
  %396 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %397 = getelementptr inbounds %union.HMM_Vec4, ptr %26, i32 0, i32 0
  %398 = getelementptr inbounds { double, double }, ptr %397, i32 0, i32 0
  %399 = extractvalue { double, double } %396, 0
  store double %399, ptr %398, align 16
  %400 = getelementptr inbounds { double, double }, ptr %397, i32 0, i32 1
  %401 = extractvalue { double, double } %396, 1
  store double %401, ptr %400, align 8
  %402 = getelementptr inbounds %struct.anon.10, ptr %26, i32 0, i32 0
  %403 = getelementptr inbounds %struct.anon.11, ptr %402, i32 0, i32 2
  %404 = load float, ptr %403, align 8, !tbaa !13
  %405 = fpext float %404 to double
  %406 = load float, ptr %20, align 4, !tbaa !15
  %407 = fpext float %406 to double
  %408 = load float, ptr %24, align 4, !tbaa !15
  %409 = fpext float %408 to double
  %410 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %405, double noundef %407, double noundef %409)
  call void @llvm.lifetime.end.p0(i64 16, ptr %26) #6
  br label %411

411:                                              ; preds = %390, %387
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  %412 = load ptr, ptr %2, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %412, i32 0, i32 0
  %414 = load i32, ptr %413, align 4, !tbaa !9
  %415 = add nsw i32 %414, 1
  store i32 %415, ptr %413, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %29, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %30, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %416 = getelementptr inbounds { double, double }, ptr %30, i32 0, i32 0
  %417 = load double, ptr %416, align 16
  %418 = getelementptr inbounds { double, double }, ptr %30, i32 0, i32 1
  %419 = load double, ptr %418, align 8
  %420 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %29, double %417, double %419)
  %421 = getelementptr inbounds %union.HMM_Vec4, ptr %28, i32 0, i32 0
  %422 = getelementptr inbounds { double, double }, ptr %421, i32 0, i32 0
  %423 = extractvalue { double, double } %420, 0
  store double %423, ptr %422, align 16
  %424 = getelementptr inbounds { double, double }, ptr %421, i32 0, i32 1
  %425 = extractvalue { double, double } %420, 1
  store double %425, ptr %424, align 8
  %426 = getelementptr inbounds %struct.anon.10, ptr %28, i32 0, i32 1
  %427 = load float, ptr %426, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #6
  store float %427, ptr %27, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %428 = load float, ptr %27, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %32) #6
  %429 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %430 = getelementptr inbounds %union.HMM_Vec4, ptr %32, i32 0, i32 0
  %431 = getelementptr inbounds { double, double }, ptr %430, i32 0, i32 0
  %432 = extractvalue { double, double } %429, 0
  store double %432, ptr %431, align 16
  %433 = getelementptr inbounds { double, double }, ptr %430, i32 0, i32 1
  %434 = extractvalue { double, double } %429, 1
  store double %434, ptr %433, align 8
  %435 = getelementptr inbounds %struct.anon.10, ptr %32, i32 0, i32 1
  %436 = load float, ptr %435, align 4, !tbaa !13
  %437 = fsub float %428, %436
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #6
  store float %437, ptr %31, align 4, !tbaa !15
  %438 = load float, ptr %31, align 4, !tbaa !15
  %439 = fcmp olt float %438, 0xBE80000000000000
  br i1 %439, label %443, label %440

440:                                              ; preds = %411
  %441 = load float, ptr %31, align 4, !tbaa !15
  %442 = fcmp olt float 0x3E80000000000000, %441
  br i1 %442, label %443, label %463

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

463:                                              ; preds = %443, %440
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  %464 = load ptr, ptr %2, align 8, !tbaa !5
  %465 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %464, i32 0, i32 0
  %466 = load i32, ptr %465, align 4, !tbaa !9
  %467 = add nsw i32 %466, 1
  store i32 %467, ptr %465, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %36, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %37, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %468 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 0
  %469 = load double, ptr %468, align 16
  %470 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 1
  %471 = load double, ptr %470, align 8
  %472 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %36, double %469, double %471)
  %473 = getelementptr inbounds %union.HMM_Vec4, ptr %35, i32 0, i32 0
  %474 = getelementptr inbounds { double, double }, ptr %473, i32 0, i32 0
  %475 = extractvalue { double, double } %472, 0
  store double %475, ptr %474, align 16
  %476 = getelementptr inbounds { double, double }, ptr %473, i32 0, i32 1
  %477 = extractvalue { double, double } %472, 1
  store double %477, ptr %476, align 8
  %478 = getelementptr inbounds %struct.anon.10, ptr %35, i32 0, i32 0
  %479 = getelementptr inbounds %struct.anon.11, ptr %478, i32 0, i32 0
  %480 = load float, ptr %479, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #6
  store float %480, ptr %34, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  %481 = load float, ptr %34, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %39) #6
  %482 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %483 = getelementptr inbounds %union.HMM_Vec4, ptr %39, i32 0, i32 0
  %484 = getelementptr inbounds { double, double }, ptr %483, i32 0, i32 0
  %485 = extractvalue { double, double } %482, 0
  store double %485, ptr %484, align 16
  %486 = getelementptr inbounds { double, double }, ptr %483, i32 0, i32 1
  %487 = extractvalue { double, double } %482, 1
  store double %487, ptr %486, align 8
  %488 = getelementptr inbounds %struct.anon.10, ptr %39, i32 0, i32 0
  %489 = getelementptr inbounds %struct.anon.11, ptr %488, i32 0, i32 0
  %490 = load float, ptr %489, align 16, !tbaa !13
  %491 = fsub float %481, %490
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #6
  store float %491, ptr %38, align 4, !tbaa !15
  %492 = load float, ptr %38, align 4, !tbaa !15
  %493 = fcmp olt float %492, 0xBE80000000000000
  br i1 %493, label %497, label %494

494:                                              ; preds = %463
  %495 = load float, ptr %38, align 4, !tbaa !15
  %496 = fcmp olt float 0x3E80000000000000, %495
  br i1 %496, label %497, label %518

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

518:                                              ; preds = %497, %494
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  %519 = load ptr, ptr %2, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %519, i32 0, i32 0
  %521 = load i32, ptr %520, align 4, !tbaa !9
  %522 = add nsw i32 %521, 1
  store i32 %522, ptr %520, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %42) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %43, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %44, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %523 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 0
  %524 = load double, ptr %523, align 16
  %525 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 1
  %526 = load double, ptr %525, align 8
  %527 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %43, double %524, double %526)
  %528 = getelementptr inbounds %union.HMM_Vec4, ptr %42, i32 0, i32 0
  %529 = getelementptr inbounds { double, double }, ptr %528, i32 0, i32 0
  %530 = extractvalue { double, double } %527, 0
  store double %530, ptr %529, align 16
  %531 = getelementptr inbounds { double, double }, ptr %528, i32 0, i32 1
  %532 = extractvalue { double, double } %527, 1
  store double %532, ptr %531, align 8
  %533 = getelementptr inbounds %struct.anon.10, ptr %42, i32 0, i32 0
  %534 = getelementptr inbounds %struct.anon.11, ptr %533, i32 0, i32 1
  %535 = load float, ptr %534, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %42) #6
  store float %535, ptr %41, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %536 = load float, ptr %41, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %46) #6
  %537 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %538 = getelementptr inbounds %union.HMM_Vec4, ptr %46, i32 0, i32 0
  %539 = getelementptr inbounds { double, double }, ptr %538, i32 0, i32 0
  %540 = extractvalue { double, double } %537, 0
  store double %540, ptr %539, align 16
  %541 = getelementptr inbounds { double, double }, ptr %538, i32 0, i32 1
  %542 = extractvalue { double, double } %537, 1
  store double %542, ptr %541, align 8
  %543 = getelementptr inbounds %struct.anon.10, ptr %46, i32 0, i32 0
  %544 = getelementptr inbounds %struct.anon.11, ptr %543, i32 0, i32 1
  %545 = load float, ptr %544, align 4, !tbaa !13
  %546 = fsub float %536, %545
  call void @llvm.lifetime.end.p0(i64 16, ptr %46) #6
  store float %546, ptr %45, align 4, !tbaa !15
  %547 = load float, ptr %45, align 4, !tbaa !15
  %548 = fcmp olt float %547, 0xBE80000000000000
  br i1 %548, label %552, label %549

549:                                              ; preds = %518
  %550 = load float, ptr %45, align 4, !tbaa !15
  %551 = fcmp olt float 0x3E80000000000000, %550
  br i1 %551, label %552, label %573

552:                                              ; preds = %549, %518
  %553 = load ptr, ptr %2, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %553, i32 0, i32 1
  %555 = load i32, ptr %554, align 4, !tbaa !17
  %556 = add nsw i32 %555, 1
  store i32 %556, ptr %554, align 4, !tbaa !17
  %557 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 17)
  call void @llvm.lifetime.start.p0(i64 16, ptr %47) #6
  %558 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %559 = getelementptr inbounds %union.HMM_Vec4, ptr %47, i32 0, i32 0
  %560 = getelementptr inbounds { double, double }, ptr %559, i32 0, i32 0
  %561 = extractvalue { double, double } %558, 0
  store double %561, ptr %560, align 16
  %562 = getelementptr inbounds { double, double }, ptr %559, i32 0, i32 1
  %563 = extractvalue { double, double } %558, 1
  store double %563, ptr %562, align 8
  %564 = getelementptr inbounds %struct.anon.10, ptr %47, i32 0, i32 0
  %565 = getelementptr inbounds %struct.anon.11, ptr %564, i32 0, i32 1
  %566 = load float, ptr %565, align 4, !tbaa !13
  %567 = fpext float %566 to double
  %568 = load float, ptr %41, align 4, !tbaa !15
  %569 = fpext float %568 to double
  %570 = load float, ptr %45, align 4, !tbaa !15
  %571 = fpext float %570 to double
  %572 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %567, double noundef %569, double noundef %571)
  call void @llvm.lifetime.end.p0(i64 16, ptr %47) #6
  br label %573

573:                                              ; preds = %552, %549
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  %574 = load ptr, ptr %2, align 8, !tbaa !5
  %575 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %574, i32 0, i32 0
  %576 = load i32, ptr %575, align 4, !tbaa !9
  %577 = add nsw i32 %576, 1
  store i32 %577, ptr %575, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %49) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %50, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %51, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %578 = getelementptr inbounds { double, double }, ptr %51, i32 0, i32 0
  %579 = load double, ptr %578, align 16
  %580 = getelementptr inbounds { double, double }, ptr %51, i32 0, i32 1
  %581 = load double, ptr %580, align 8
  %582 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %50, double %579, double %581)
  %583 = getelementptr inbounds %union.HMM_Vec4, ptr %49, i32 0, i32 0
  %584 = getelementptr inbounds { double, double }, ptr %583, i32 0, i32 0
  %585 = extractvalue { double, double } %582, 0
  store double %585, ptr %584, align 16
  %586 = getelementptr inbounds { double, double }, ptr %583, i32 0, i32 1
  %587 = extractvalue { double, double } %582, 1
  store double %587, ptr %586, align 8
  %588 = getelementptr inbounds %struct.anon.10, ptr %49, i32 0, i32 0
  %589 = getelementptr inbounds %struct.anon.11, ptr %588, i32 0, i32 2
  %590 = load float, ptr %589, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %49) #6
  store float %590, ptr %48, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #6
  %591 = load float, ptr %48, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %53) #6
  %592 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %593 = getelementptr inbounds %union.HMM_Vec4, ptr %53, i32 0, i32 0
  %594 = getelementptr inbounds { double, double }, ptr %593, i32 0, i32 0
  %595 = extractvalue { double, double } %592, 0
  store double %595, ptr %594, align 16
  %596 = getelementptr inbounds { double, double }, ptr %593, i32 0, i32 1
  %597 = extractvalue { double, double } %592, 1
  store double %597, ptr %596, align 8
  %598 = getelementptr inbounds %struct.anon.10, ptr %53, i32 0, i32 0
  %599 = getelementptr inbounds %struct.anon.11, ptr %598, i32 0, i32 2
  %600 = load float, ptr %599, align 8, !tbaa !13
  %601 = fsub float %591, %600
  call void @llvm.lifetime.end.p0(i64 16, ptr %53) #6
  store float %601, ptr %52, align 4, !tbaa !15
  %602 = load float, ptr %52, align 4, !tbaa !15
  %603 = fcmp olt float %602, 0xBE80000000000000
  br i1 %603, label %607, label %604

604:                                              ; preds = %573
  %605 = load float, ptr %52, align 4, !tbaa !15
  %606 = fcmp olt float 0x3E80000000000000, %605
  br i1 %606, label %607, label %628

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

628:                                              ; preds = %607, %604
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  %629 = load ptr, ptr %2, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %629, i32 0, i32 0
  %631 = load i32, ptr %630, align 4, !tbaa !9
  %632 = add nsw i32 %631, 1
  store i32 %632, ptr %630, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %56) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %57, ptr align 16 %5, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %58, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %633 = getelementptr inbounds { double, double }, ptr %58, i32 0, i32 0
  %634 = load double, ptr %633, align 16
  %635 = getelementptr inbounds { double, double }, ptr %58, i32 0, i32 1
  %636 = load double, ptr %635, align 8
  %637 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %57, double %634, double %636)
  %638 = getelementptr inbounds %union.HMM_Vec4, ptr %56, i32 0, i32 0
  %639 = getelementptr inbounds { double, double }, ptr %638, i32 0, i32 0
  %640 = extractvalue { double, double } %637, 0
  store double %640, ptr %639, align 16
  %641 = getelementptr inbounds { double, double }, ptr %638, i32 0, i32 1
  %642 = extractvalue { double, double } %637, 1
  store double %642, ptr %641, align 8
  %643 = getelementptr inbounds %struct.anon.10, ptr %56, i32 0, i32 1
  %644 = load float, ptr %643, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %56) #6
  store float %644, ptr %55, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #6
  %645 = load float, ptr %55, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %60) #6
  %646 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %647 = getelementptr inbounds %union.HMM_Vec4, ptr %60, i32 0, i32 0
  %648 = getelementptr inbounds { double, double }, ptr %647, i32 0, i32 0
  %649 = extractvalue { double, double } %646, 0
  store double %649, ptr %648, align 16
  %650 = getelementptr inbounds { double, double }, ptr %647, i32 0, i32 1
  %651 = extractvalue { double, double } %646, 1
  store double %651, ptr %650, align 8
  %652 = getelementptr inbounds %struct.anon.10, ptr %60, i32 0, i32 1
  %653 = load float, ptr %652, align 4, !tbaa !13
  %654 = fsub float %645, %653
  call void @llvm.lifetime.end.p0(i64 16, ptr %60) #6
  store float %654, ptr %59, align 4, !tbaa !15
  %655 = load float, ptr %59, align 4, !tbaa !15
  %656 = fcmp olt float %655, 0xBE80000000000000
  br i1 %656, label %660, label %657

657:                                              ; preds = %628
  %658 = load float, ptr %59, align 4, !tbaa !15
  %659 = fcmp olt float 0x3E80000000000000, %658
  br i1 %659, label %660, label %680

660:                                              ; preds = %657, %628
  %661 = load ptr, ptr %2, align 8, !tbaa !5
  %662 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %661, i32 0, i32 1
  %663 = load i32, ptr %662, align 4, !tbaa !17
  %664 = add nsw i32 %663, 1
  store i32 %664, ptr %662, align 4, !tbaa !17
  %665 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 17)
  call void @llvm.lifetime.start.p0(i64 16, ptr %61) #6
  %666 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %667 = getelementptr inbounds %union.HMM_Vec4, ptr %61, i32 0, i32 0
  %668 = getelementptr inbounds { double, double }, ptr %667, i32 0, i32 0
  %669 = extractvalue { double, double } %666, 0
  store double %669, ptr %668, align 16
  %670 = getelementptr inbounds { double, double }, ptr %667, i32 0, i32 1
  %671 = extractvalue { double, double } %666, 1
  store double %671, ptr %670, align 8
  %672 = getelementptr inbounds %struct.anon.10, ptr %61, i32 0, i32 1
  %673 = load float, ptr %672, align 4, !tbaa !13
  %674 = fpext float %673 to double
  %675 = load float, ptr %55, align 4, !tbaa !15
  %676 = fpext float %675 to double
  %677 = load float, ptr %59, align 4, !tbaa !15
  %678 = fpext float %677 to double
  %679 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %674, double noundef %676, double noundef %678)
  call void @llvm.lifetime.end.p0(i64 16, ptr %61) #6
  br label %680

680:                                              ; preds = %660, %657
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %5) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %62) #6
  call void @_ZL22HMM_Orthographic_RH_ZOffffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %62, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %681 = load ptr, ptr %2, align 8, !tbaa !5
  %682 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %681, i32 0, i32 0
  %683 = load i32, ptr %682, align 4, !tbaa !9
  %684 = add nsw i32 %683, 1
  store i32 %684, ptr %682, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %64) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %65, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %66, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %685 = getelementptr inbounds { double, double }, ptr %66, i32 0, i32 0
  %686 = load double, ptr %685, align 16
  %687 = getelementptr inbounds { double, double }, ptr %66, i32 0, i32 1
  %688 = load double, ptr %687, align 8
  %689 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %65, double %686, double %688)
  %690 = getelementptr inbounds %union.HMM_Vec4, ptr %64, i32 0, i32 0
  %691 = getelementptr inbounds { double, double }, ptr %690, i32 0, i32 0
  %692 = extractvalue { double, double } %689, 0
  store double %692, ptr %691, align 16
  %693 = getelementptr inbounds { double, double }, ptr %690, i32 0, i32 1
  %694 = extractvalue { double, double } %689, 1
  store double %694, ptr %693, align 8
  %695 = getelementptr inbounds %struct.anon.10, ptr %64, i32 0, i32 0
  %696 = getelementptr inbounds %struct.anon.11, ptr %695, i32 0, i32 0
  %697 = load float, ptr %696, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %64) #6
  store float %697, ptr %63, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #6
  %698 = load float, ptr %63, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %68) #6
  %699 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %700 = getelementptr inbounds %union.HMM_Vec4, ptr %68, i32 0, i32 0
  %701 = getelementptr inbounds { double, double }, ptr %700, i32 0, i32 0
  %702 = extractvalue { double, double } %699, 0
  store double %702, ptr %701, align 16
  %703 = getelementptr inbounds { double, double }, ptr %700, i32 0, i32 1
  %704 = extractvalue { double, double } %699, 1
  store double %704, ptr %703, align 8
  %705 = getelementptr inbounds %struct.anon.10, ptr %68, i32 0, i32 0
  %706 = getelementptr inbounds %struct.anon.11, ptr %705, i32 0, i32 0
  %707 = load float, ptr %706, align 16, !tbaa !13
  %708 = fsub float %698, %707
  call void @llvm.lifetime.end.p0(i64 16, ptr %68) #6
  store float %708, ptr %67, align 4, !tbaa !15
  %709 = load float, ptr %67, align 4, !tbaa !15
  %710 = fcmp olt float %709, 0xBE80000000000000
  br i1 %710, label %714, label %711

711:                                              ; preds = %680
  %712 = load float, ptr %67, align 4, !tbaa !15
  %713 = fcmp olt float 0x3E80000000000000, %712
  br i1 %713, label %714, label %735

714:                                              ; preds = %711, %680
  %715 = load ptr, ptr %2, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %715, i32 0, i32 1
  %717 = load i32, ptr %716, align 4, !tbaa !17
  %718 = add nsw i32 %717, 1
  store i32 %718, ptr %716, align 4, !tbaa !17
  %719 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 23)
  call void @llvm.lifetime.start.p0(i64 16, ptr %69) #6
  %720 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %721 = getelementptr inbounds %union.HMM_Vec4, ptr %69, i32 0, i32 0
  %722 = getelementptr inbounds { double, double }, ptr %721, i32 0, i32 0
  %723 = extractvalue { double, double } %720, 0
  store double %723, ptr %722, align 16
  %724 = getelementptr inbounds { double, double }, ptr %721, i32 0, i32 1
  %725 = extractvalue { double, double } %720, 1
  store double %725, ptr %724, align 8
  %726 = getelementptr inbounds %struct.anon.10, ptr %69, i32 0, i32 0
  %727 = getelementptr inbounds %struct.anon.11, ptr %726, i32 0, i32 0
  %728 = load float, ptr %727, align 16, !tbaa !13
  %729 = fpext float %728 to double
  %730 = load float, ptr %63, align 4, !tbaa !15
  %731 = fpext float %730 to double
  %732 = load float, ptr %67, align 4, !tbaa !15
  %733 = fpext float %732 to double
  %734 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %729, double noundef %731, double noundef %733)
  call void @llvm.lifetime.end.p0(i64 16, ptr %69) #6
  br label %735

735:                                              ; preds = %714, %711
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  %736 = load ptr, ptr %2, align 8, !tbaa !5
  %737 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %736, i32 0, i32 0
  %738 = load i32, ptr %737, align 4, !tbaa !9
  %739 = add nsw i32 %738, 1
  store i32 %739, ptr %737, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %71) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %72, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %73, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %740 = getelementptr inbounds { double, double }, ptr %73, i32 0, i32 0
  %741 = load double, ptr %740, align 16
  %742 = getelementptr inbounds { double, double }, ptr %73, i32 0, i32 1
  %743 = load double, ptr %742, align 8
  %744 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %72, double %741, double %743)
  %745 = getelementptr inbounds %union.HMM_Vec4, ptr %71, i32 0, i32 0
  %746 = getelementptr inbounds { double, double }, ptr %745, i32 0, i32 0
  %747 = extractvalue { double, double } %744, 0
  store double %747, ptr %746, align 16
  %748 = getelementptr inbounds { double, double }, ptr %745, i32 0, i32 1
  %749 = extractvalue { double, double } %744, 1
  store double %749, ptr %748, align 8
  %750 = getelementptr inbounds %struct.anon.10, ptr %71, i32 0, i32 0
  %751 = getelementptr inbounds %struct.anon.11, ptr %750, i32 0, i32 1
  %752 = load float, ptr %751, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %71) #6
  store float %752, ptr %70, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #6
  %753 = load float, ptr %70, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %75) #6
  %754 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %755 = getelementptr inbounds %union.HMM_Vec4, ptr %75, i32 0, i32 0
  %756 = getelementptr inbounds { double, double }, ptr %755, i32 0, i32 0
  %757 = extractvalue { double, double } %754, 0
  store double %757, ptr %756, align 16
  %758 = getelementptr inbounds { double, double }, ptr %755, i32 0, i32 1
  %759 = extractvalue { double, double } %754, 1
  store double %759, ptr %758, align 8
  %760 = getelementptr inbounds %struct.anon.10, ptr %75, i32 0, i32 0
  %761 = getelementptr inbounds %struct.anon.11, ptr %760, i32 0, i32 1
  %762 = load float, ptr %761, align 4, !tbaa !13
  %763 = fsub float %753, %762
  call void @llvm.lifetime.end.p0(i64 16, ptr %75) #6
  store float %763, ptr %74, align 4, !tbaa !15
  %764 = load float, ptr %74, align 4, !tbaa !15
  %765 = fcmp olt float %764, 0xBE80000000000000
  br i1 %765, label %769, label %766

766:                                              ; preds = %735
  %767 = load float, ptr %74, align 4, !tbaa !15
  %768 = fcmp olt float 0x3E80000000000000, %767
  br i1 %768, label %769, label %790

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

790:                                              ; preds = %769, %766
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #6
  %791 = load ptr, ptr %2, align 8, !tbaa !5
  %792 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %791, i32 0, i32 0
  %793 = load i32, ptr %792, align 4, !tbaa !9
  %794 = add nsw i32 %793, 1
  store i32 %794, ptr %792, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %78) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %79, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %80, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %795 = getelementptr inbounds { double, double }, ptr %80, i32 0, i32 0
  %796 = load double, ptr %795, align 16
  %797 = getelementptr inbounds { double, double }, ptr %80, i32 0, i32 1
  %798 = load double, ptr %797, align 8
  %799 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %79, double %796, double %798)
  %800 = getelementptr inbounds %union.HMM_Vec4, ptr %78, i32 0, i32 0
  %801 = getelementptr inbounds { double, double }, ptr %800, i32 0, i32 0
  %802 = extractvalue { double, double } %799, 0
  store double %802, ptr %801, align 16
  %803 = getelementptr inbounds { double, double }, ptr %800, i32 0, i32 1
  %804 = extractvalue { double, double } %799, 1
  store double %804, ptr %803, align 8
  %805 = getelementptr inbounds %struct.anon.10, ptr %78, i32 0, i32 0
  %806 = getelementptr inbounds %struct.anon.11, ptr %805, i32 0, i32 2
  %807 = load float, ptr %806, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %78) #6
  store float %807, ptr %77, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %81) #6
  %808 = load float, ptr %77, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %82) #6
  %809 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %810 = getelementptr inbounds %union.HMM_Vec4, ptr %82, i32 0, i32 0
  %811 = getelementptr inbounds { double, double }, ptr %810, i32 0, i32 0
  %812 = extractvalue { double, double } %809, 0
  store double %812, ptr %811, align 16
  %813 = getelementptr inbounds { double, double }, ptr %810, i32 0, i32 1
  %814 = extractvalue { double, double } %809, 1
  store double %814, ptr %813, align 8
  %815 = getelementptr inbounds %struct.anon.10, ptr %82, i32 0, i32 0
  %816 = getelementptr inbounds %struct.anon.11, ptr %815, i32 0, i32 2
  %817 = load float, ptr %816, align 8, !tbaa !13
  %818 = fsub float %808, %817
  call void @llvm.lifetime.end.p0(i64 16, ptr %82) #6
  store float %818, ptr %81, align 4, !tbaa !15
  %819 = load float, ptr %81, align 4, !tbaa !15
  %820 = fcmp olt float %819, 0xBE80000000000000
  br i1 %820, label %824, label %821

821:                                              ; preds = %790
  %822 = load float, ptr %81, align 4, !tbaa !15
  %823 = fcmp olt float 0x3E80000000000000, %822
  br i1 %823, label %824, label %845

824:                                              ; preds = %821, %790
  %825 = load ptr, ptr %2, align 8, !tbaa !5
  %826 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %825, i32 0, i32 1
  %827 = load i32, ptr %826, align 4, !tbaa !17
  %828 = add nsw i32 %827, 1
  store i32 %828, ptr %826, align 4, !tbaa !17
  %829 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 23)
  call void @llvm.lifetime.start.p0(i64 16, ptr %83) #6
  %830 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %831 = getelementptr inbounds %union.HMM_Vec4, ptr %83, i32 0, i32 0
  %832 = getelementptr inbounds { double, double }, ptr %831, i32 0, i32 0
  %833 = extractvalue { double, double } %830, 0
  store double %833, ptr %832, align 16
  %834 = getelementptr inbounds { double, double }, ptr %831, i32 0, i32 1
  %835 = extractvalue { double, double } %830, 1
  store double %835, ptr %834, align 8
  %836 = getelementptr inbounds %struct.anon.10, ptr %83, i32 0, i32 0
  %837 = getelementptr inbounds %struct.anon.11, ptr %836, i32 0, i32 2
  %838 = load float, ptr %837, align 8, !tbaa !13
  %839 = fpext float %838 to double
  %840 = load float, ptr %77, align 4, !tbaa !15
  %841 = fpext float %840 to double
  %842 = load float, ptr %81, align 4, !tbaa !15
  %843 = fpext float %842 to double
  %844 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %839, double noundef %841, double noundef %843)
  call void @llvm.lifetime.end.p0(i64 16, ptr %83) #6
  br label %845

845:                                              ; preds = %824, %821
  call void @llvm.lifetime.end.p0(i64 4, ptr %81) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #6
  %846 = load ptr, ptr %2, align 8, !tbaa !5
  %847 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %846, i32 0, i32 0
  %848 = load i32, ptr %847, align 4, !tbaa !9
  %849 = add nsw i32 %848, 1
  store i32 %849, ptr %847, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %84) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %85) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %86, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %87, ptr align 16 %3, i64 16, i1 false), !tbaa.struct !14
  %850 = getelementptr inbounds { double, double }, ptr %87, i32 0, i32 0
  %851 = load double, ptr %850, align 16
  %852 = getelementptr inbounds { double, double }, ptr %87, i32 0, i32 1
  %853 = load double, ptr %852, align 8
  %854 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %86, double %851, double %853)
  %855 = getelementptr inbounds %union.HMM_Vec4, ptr %85, i32 0, i32 0
  %856 = getelementptr inbounds { double, double }, ptr %855, i32 0, i32 0
  %857 = extractvalue { double, double } %854, 0
  store double %857, ptr %856, align 16
  %858 = getelementptr inbounds { double, double }, ptr %855, i32 0, i32 1
  %859 = extractvalue { double, double } %854, 1
  store double %859, ptr %858, align 8
  %860 = getelementptr inbounds %struct.anon.10, ptr %85, i32 0, i32 1
  %861 = load float, ptr %860, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %85) #6
  store float %861, ptr %84, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #6
  %862 = load float, ptr %84, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %89) #6
  %863 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %864 = getelementptr inbounds %union.HMM_Vec4, ptr %89, i32 0, i32 0
  %865 = getelementptr inbounds { double, double }, ptr %864, i32 0, i32 0
  %866 = extractvalue { double, double } %863, 0
  store double %866, ptr %865, align 16
  %867 = getelementptr inbounds { double, double }, ptr %864, i32 0, i32 1
  %868 = extractvalue { double, double } %863, 1
  store double %868, ptr %867, align 8
  %869 = getelementptr inbounds %struct.anon.10, ptr %89, i32 0, i32 1
  %870 = load float, ptr %869, align 4, !tbaa !13
  %871 = fsub float %862, %870
  call void @llvm.lifetime.end.p0(i64 16, ptr %89) #6
  store float %871, ptr %88, align 4, !tbaa !15
  %872 = load float, ptr %88, align 4, !tbaa !15
  %873 = fcmp olt float %872, 0xBE80000000000000
  br i1 %873, label %877, label %874

874:                                              ; preds = %845
  %875 = load float, ptr %88, align 4, !tbaa !15
  %876 = fcmp olt float 0x3E80000000000000, %875
  br i1 %876, label %877, label %897

877:                                              ; preds = %874, %845
  %878 = load ptr, ptr %2, align 8, !tbaa !5
  %879 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %878, i32 0, i32 1
  %880 = load i32, ptr %879, align 4, !tbaa !17
  %881 = add nsw i32 %880, 1
  store i32 %881, ptr %879, align 4, !tbaa !17
  %882 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 23)
  call void @llvm.lifetime.start.p0(i64 16, ptr %90) #6
  %883 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %884 = getelementptr inbounds %union.HMM_Vec4, ptr %90, i32 0, i32 0
  %885 = getelementptr inbounds { double, double }, ptr %884, i32 0, i32 0
  %886 = extractvalue { double, double } %883, 0
  store double %886, ptr %885, align 16
  %887 = getelementptr inbounds { double, double }, ptr %884, i32 0, i32 1
  %888 = extractvalue { double, double } %883, 1
  store double %888, ptr %887, align 8
  %889 = getelementptr inbounds %struct.anon.10, ptr %90, i32 0, i32 1
  %890 = load float, ptr %889, align 4, !tbaa !13
  %891 = fpext float %890 to double
  %892 = load float, ptr %84, align 4, !tbaa !15
  %893 = fpext float %892 to double
  %894 = load float, ptr %88, align 4, !tbaa !15
  %895 = fpext float %894 to double
  %896 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %891, double noundef %893, double noundef %895)
  call void @llvm.lifetime.end.p0(i64 16, ptr %90) #6
  br label %897

897:                                              ; preds = %877, %874
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %84) #6
  %898 = load ptr, ptr %2, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %898, i32 0, i32 0
  %900 = load i32, ptr %899, align 4, !tbaa !9
  %901 = add nsw i32 %900, 1
  store i32 %901, ptr %899, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %92) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %93, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %94, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %902 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 0
  %903 = load double, ptr %902, align 16
  %904 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 1
  %905 = load double, ptr %904, align 8
  %906 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %93, double %903, double %905)
  %907 = getelementptr inbounds %union.HMM_Vec4, ptr %92, i32 0, i32 0
  %908 = getelementptr inbounds { double, double }, ptr %907, i32 0, i32 0
  %909 = extractvalue { double, double } %906, 0
  store double %909, ptr %908, align 16
  %910 = getelementptr inbounds { double, double }, ptr %907, i32 0, i32 1
  %911 = extractvalue { double, double } %906, 1
  store double %911, ptr %910, align 8
  %912 = getelementptr inbounds %struct.anon.10, ptr %92, i32 0, i32 0
  %913 = getelementptr inbounds %struct.anon.11, ptr %912, i32 0, i32 0
  %914 = load float, ptr %913, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %92) #6
  store float %914, ptr %91, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #6
  %915 = load float, ptr %91, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %96) #6
  %916 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %917 = getelementptr inbounds %union.HMM_Vec4, ptr %96, 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 %96, i32 0, i32 0
  %923 = getelementptr inbounds %struct.anon.11, ptr %922, i32 0, i32 0
  %924 = load float, ptr %923, align 16, !tbaa !13
  %925 = fsub float %915, %924
  call void @llvm.lifetime.end.p0(i64 16, ptr %96) #6
  store float %925, ptr %95, align 4, !tbaa !15
  %926 = load float, ptr %95, align 4, !tbaa !15
  %927 = fcmp olt float %926, 0xBE80000000000000
  br i1 %927, label %931, label %928

928:                                              ; preds = %897
  %929 = load float, ptr %95, align 4, !tbaa !15
  %930 = fcmp olt float 0x3E80000000000000, %929
  br i1 %930, label %931, label %952

931:                                              ; preds = %928, %897
  %932 = load ptr, ptr %2, align 8, !tbaa !5
  %933 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %932, i32 0, i32 1
  %934 = load i32, ptr %933, align 4, !tbaa !17
  %935 = add nsw i32 %934, 1
  store i32 %935, ptr %933, align 4, !tbaa !17
  %936 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 24)
  call void @llvm.lifetime.start.p0(i64 16, ptr %97) #6
  %937 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %938 = getelementptr inbounds %union.HMM_Vec4, ptr %97, i32 0, i32 0
  %939 = getelementptr inbounds { double, double }, ptr %938, i32 0, i32 0
  %940 = extractvalue { double, double } %937, 0
  store double %940, ptr %939, align 16
  %941 = getelementptr inbounds { double, double }, ptr %938, i32 0, i32 1
  %942 = extractvalue { double, double } %937, 1
  store double %942, ptr %941, align 8
  %943 = getelementptr inbounds %struct.anon.10, ptr %97, i32 0, i32 0
  %944 = getelementptr inbounds %struct.anon.11, ptr %943, i32 0, i32 0
  %945 = load float, ptr %944, align 16, !tbaa !13
  %946 = fpext float %945 to double
  %947 = load float, ptr %91, align 4, !tbaa !15
  %948 = fpext float %947 to double
  %949 = load float, ptr %95, align 4, !tbaa !15
  %950 = fpext float %949 to double
  %951 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %946, double noundef %948, double noundef %950)
  call void @llvm.lifetime.end.p0(i64 16, ptr %97) #6
  br label %952

952:                                              ; preds = %931, %928
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #6
  %953 = load ptr, ptr %2, align 8, !tbaa !5
  %954 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %953, i32 0, i32 0
  %955 = load i32, ptr %954, align 4, !tbaa !9
  %956 = add nsw i32 %955, 1
  store i32 %956, ptr %954, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %99) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %100, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %101, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %957 = getelementptr inbounds { double, double }, ptr %101, i32 0, i32 0
  %958 = load double, ptr %957, align 16
  %959 = getelementptr inbounds { double, double }, ptr %101, i32 0, i32 1
  %960 = load double, ptr %959, align 8
  %961 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %100, double %958, double %960)
  %962 = getelementptr inbounds %union.HMM_Vec4, ptr %99, i32 0, i32 0
  %963 = getelementptr inbounds { double, double }, ptr %962, i32 0, i32 0
  %964 = extractvalue { double, double } %961, 0
  store double %964, ptr %963, align 16
  %965 = getelementptr inbounds { double, double }, ptr %962, i32 0, i32 1
  %966 = extractvalue { double, double } %961, 1
  store double %966, ptr %965, align 8
  %967 = getelementptr inbounds %struct.anon.10, ptr %99, i32 0, i32 0
  %968 = getelementptr inbounds %struct.anon.11, ptr %967, i32 0, i32 1
  %969 = load float, ptr %968, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %99) #6
  store float %969, ptr %98, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #6
  %970 = load float, ptr %98, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %103) #6
  %971 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %972 = getelementptr inbounds %union.HMM_Vec4, ptr %103, 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 %103, i32 0, i32 0
  %978 = getelementptr inbounds %struct.anon.11, ptr %977, i32 0, i32 1
  %979 = load float, ptr %978, align 4, !tbaa !13
  %980 = fsub float %970, %979
  call void @llvm.lifetime.end.p0(i64 16, ptr %103) #6
  store float %980, ptr %102, align 4, !tbaa !15
  %981 = load float, ptr %102, align 4, !tbaa !15
  %982 = fcmp olt float %981, 0xBE80000000000000
  br i1 %982, label %986, label %983

983:                                              ; preds = %952
  %984 = load float, ptr %102, align 4, !tbaa !15
  %985 = fcmp olt float 0x3E80000000000000, %984
  br i1 %985, label %986, label %1007

986:                                              ; preds = %983, %952
  %987 = load ptr, ptr %2, align 8, !tbaa !5
  %988 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %987, i32 0, i32 1
  %989 = load i32, ptr %988, align 4, !tbaa !17
  %990 = add nsw i32 %989, 1
  store i32 %990, ptr %988, align 4, !tbaa !17
  %991 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 24)
  call void @llvm.lifetime.start.p0(i64 16, ptr %104) #6
  %992 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %993 = getelementptr inbounds %union.HMM_Vec4, ptr %104, i32 0, i32 0
  %994 = getelementptr inbounds { double, double }, ptr %993, i32 0, i32 0
  %995 = extractvalue { double, double } %992, 0
  store double %995, ptr %994, align 16
  %996 = getelementptr inbounds { double, double }, ptr %993, i32 0, i32 1
  %997 = extractvalue { double, double } %992, 1
  store double %997, ptr %996, align 8
  %998 = getelementptr inbounds %struct.anon.10, ptr %104, i32 0, i32 0
  %999 = getelementptr inbounds %struct.anon.11, ptr %998, i32 0, i32 1
  %1000 = load float, ptr %999, align 4, !tbaa !13
  %1001 = fpext float %1000 to double
  %1002 = load float, ptr %98, align 4, !tbaa !15
  %1003 = fpext float %1002 to double
  %1004 = load float, ptr %102, align 4, !tbaa !15
  %1005 = fpext float %1004 to double
  %1006 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %1001, double noundef %1003, double noundef %1005)
  call void @llvm.lifetime.end.p0(i64 16, ptr %104) #6
  br label %1007

1007:                                             ; preds = %986, %983
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #6
  %1008 = load ptr, ptr %2, align 8, !tbaa !5
  %1009 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1008, i32 0, i32 0
  %1010 = load i32, ptr %1009, align 4, !tbaa !9
  %1011 = add nsw i32 %1010, 1
  store i32 %1011, ptr %1009, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %106) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %107, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %108, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %1012 = getelementptr inbounds { double, double }, ptr %108, i32 0, i32 0
  %1013 = load double, ptr %1012, align 16
  %1014 = getelementptr inbounds { double, double }, ptr %108, i32 0, i32 1
  %1015 = load double, ptr %1014, align 8
  %1016 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %107, double %1013, double %1015)
  %1017 = getelementptr inbounds %union.HMM_Vec4, ptr %106, i32 0, i32 0
  %1018 = getelementptr inbounds { double, double }, ptr %1017, i32 0, i32 0
  %1019 = extractvalue { double, double } %1016, 0
  store double %1019, ptr %1018, align 16
  %1020 = getelementptr inbounds { double, double }, ptr %1017, i32 0, i32 1
  %1021 = extractvalue { double, double } %1016, 1
  store double %1021, ptr %1020, align 8
  %1022 = getelementptr inbounds %struct.anon.10, ptr %106, i32 0, i32 0
  %1023 = getelementptr inbounds %struct.anon.11, ptr %1022, i32 0, i32 2
  %1024 = load float, ptr %1023, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %106) #6
  store float %1024, ptr %105, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #6
  %1025 = load float, ptr %105, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %110) #6
  %1026 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1027 = getelementptr inbounds %union.HMM_Vec4, ptr %110, i32 0, i32 0
  %1028 = getelementptr inbounds { double, double }, ptr %1027, i32 0, i32 0
  %1029 = extractvalue { double, double } %1026, 0
  store double %1029, ptr %1028, align 16
  %1030 = getelementptr inbounds { double, double }, ptr %1027, i32 0, i32 1
  %1031 = extractvalue { double, double } %1026, 1
  store double %1031, ptr %1030, align 8
  %1032 = getelementptr inbounds %struct.anon.10, ptr %110, i32 0, i32 0
  %1033 = getelementptr inbounds %struct.anon.11, ptr %1032, i32 0, i32 2
  %1034 = load float, ptr %1033, align 8, !tbaa !13
  %1035 = fsub float %1025, %1034
  call void @llvm.lifetime.end.p0(i64 16, ptr %110) #6
  store float %1035, ptr %109, align 4, !tbaa !15
  %1036 = load float, ptr %109, align 4, !tbaa !15
  %1037 = fcmp olt float %1036, 0xBE80000000000000
  br i1 %1037, label %1041, label %1038

1038:                                             ; preds = %1007
  %1039 = load float, ptr %109, align 4, !tbaa !15
  %1040 = fcmp olt float 0x3E80000000000000, %1039
  br i1 %1040, label %1041, label %1062

1041:                                             ; preds = %1038, %1007
  %1042 = load ptr, ptr %2, align 8, !tbaa !5
  %1043 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1042, i32 0, i32 1
  %1044 = load i32, ptr %1043, align 4, !tbaa !17
  %1045 = add nsw i32 %1044, 1
  store i32 %1045, ptr %1043, align 4, !tbaa !17
  %1046 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 24)
  call void @llvm.lifetime.start.p0(i64 16, ptr %111) #6
  %1047 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1048 = getelementptr inbounds %union.HMM_Vec4, ptr %111, i32 0, i32 0
  %1049 = getelementptr inbounds { double, double }, ptr %1048, i32 0, i32 0
  %1050 = extractvalue { double, double } %1047, 0
  store double %1050, ptr %1049, align 16
  %1051 = getelementptr inbounds { double, double }, ptr %1048, i32 0, i32 1
  %1052 = extractvalue { double, double } %1047, 1
  store double %1052, ptr %1051, align 8
  %1053 = getelementptr inbounds %struct.anon.10, ptr %111, i32 0, i32 0
  %1054 = getelementptr inbounds %struct.anon.11, ptr %1053, i32 0, i32 2
  %1055 = load float, ptr %1054, align 8, !tbaa !13
  %1056 = fpext float %1055 to double
  %1057 = load float, ptr %105, align 4, !tbaa !15
  %1058 = fpext float %1057 to double
  %1059 = load float, ptr %109, align 4, !tbaa !15
  %1060 = fpext float %1059 to double
  %1061 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %1056, double noundef %1058, double noundef %1060)
  call void @llvm.lifetime.end.p0(i64 16, ptr %111) #6
  br label %1062

1062:                                             ; preds = %1041, %1038
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #6
  %1063 = load ptr, ptr %2, align 8, !tbaa !5
  %1064 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1063, i32 0, i32 0
  %1065 = load i32, ptr %1064, align 4, !tbaa !9
  %1066 = add nsw i32 %1065, 1
  store i32 %1066, ptr %1064, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %113) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %114, ptr align 16 %62, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %115, ptr align 16 %4, i64 16, i1 false), !tbaa.struct !14
  %1067 = getelementptr inbounds { double, double }, ptr %115, i32 0, i32 0
  %1068 = load double, ptr %1067, align 16
  %1069 = getelementptr inbounds { double, double }, ptr %115, i32 0, i32 1
  %1070 = load double, ptr %1069, align 8
  %1071 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %114, double %1068, double %1070)
  %1072 = getelementptr inbounds %union.HMM_Vec4, ptr %113, i32 0, i32 0
  %1073 = getelementptr inbounds { double, double }, ptr %1072, i32 0, i32 0
  %1074 = extractvalue { double, double } %1071, 0
  store double %1074, ptr %1073, align 16
  %1075 = getelementptr inbounds { double, double }, ptr %1072, i32 0, i32 1
  %1076 = extractvalue { double, double } %1071, 1
  store double %1076, ptr %1075, align 8
  %1077 = getelementptr inbounds %struct.anon.10, ptr %113, i32 0, i32 1
  %1078 = load float, ptr %1077, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %113) #6
  store float %1078, ptr %112, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %116) #6
  %1079 = load float, ptr %112, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %117) #6
  %1080 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1081 = getelementptr inbounds %union.HMM_Vec4, ptr %117, i32 0, i32 0
  %1082 = getelementptr inbounds { double, double }, ptr %1081, i32 0, i32 0
  %1083 = extractvalue { double, double } %1080, 0
  store double %1083, ptr %1082, align 16
  %1084 = getelementptr inbounds { double, double }, ptr %1081, i32 0, i32 1
  %1085 = extractvalue { double, double } %1080, 1
  store double %1085, ptr %1084, align 8
  %1086 = getelementptr inbounds %struct.anon.10, ptr %117, i32 0, i32 1
  %1087 = load float, ptr %1086, align 4, !tbaa !13
  %1088 = fsub float %1079, %1087
  call void @llvm.lifetime.end.p0(i64 16, ptr %117) #6
  store float %1088, ptr %116, align 4, !tbaa !15
  %1089 = load float, ptr %116, align 4, !tbaa !15
  %1090 = fcmp olt float %1089, 0xBE80000000000000
  br i1 %1090, label %1094, label %1091

1091:                                             ; preds = %1062
  %1092 = load float, ptr %116, align 4, !tbaa !15
  %1093 = fcmp olt float 0x3E80000000000000, %1092
  br i1 %1093, label %1094, label %1114

1094:                                             ; preds = %1091, %1062
  %1095 = load ptr, ptr %2, align 8, !tbaa !5
  %1096 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1095, i32 0, i32 1
  %1097 = load i32, ptr %1096, align 4, !tbaa !17
  %1098 = add nsw i32 %1097, 1
  store i32 %1098, ptr %1096, align 4, !tbaa !17
  %1099 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 24)
  call void @llvm.lifetime.start.p0(i64 16, ptr %118) #6
  %1100 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1101 = getelementptr inbounds %union.HMM_Vec4, ptr %118, i32 0, i32 0
  %1102 = getelementptr inbounds { double, double }, ptr %1101, i32 0, i32 0
  %1103 = extractvalue { double, double } %1100, 0
  store double %1103, ptr %1102, align 16
  %1104 = getelementptr inbounds { double, double }, ptr %1101, i32 0, i32 1
  %1105 = extractvalue { double, double } %1100, 1
  store double %1105, ptr %1104, align 8
  %1106 = getelementptr inbounds %struct.anon.10, ptr %118, i32 0, i32 1
  %1107 = load float, ptr %1106, align 4, !tbaa !13
  %1108 = fpext float %1107 to double
  %1109 = load float, ptr %112, align 4, !tbaa !15
  %1110 = fpext float %1109 to double
  %1111 = load float, ptr %116, align 4, !tbaa !15
  %1112 = fpext float %1111 to double
  %1113 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1108, double noundef %1110, double noundef %1112)
  call void @llvm.lifetime.end.p0(i64 16, ptr %118) #6
  br label %1114

1114:                                             ; preds = %1094, %1091
  call void @llvm.lifetime.end.p0(i64 4, ptr %116) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %3) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %119) #6
  %1115 = call { double, double } @_ZL6HMM_V4ffff(float noundef -8.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1116 = getelementptr inbounds %union.HMM_Vec4, ptr %119, i32 0, i32 0
  %1117 = getelementptr inbounds { double, double }, ptr %1116, i32 0, i32 0
  %1118 = extractvalue { double, double } %1115, 0
  store double %1118, ptr %1117, align 16
  %1119 = getelementptr inbounds { double, double }, ptr %1116, i32 0, i32 1
  %1120 = extractvalue { double, double } %1115, 1
  store double %1120, ptr %1119, align 8
  call void @llvm.lifetime.start.p0(i64 16, ptr %120) #6
  %1121 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.200000e+01, float noundef 1.000000e+01, float noundef 1.000000e+02, float noundef 1.000000e+00)
  %1122 = getelementptr inbounds %union.HMM_Vec4, ptr %120, i32 0, i32 0
  %1123 = getelementptr inbounds { double, double }, ptr %1122, i32 0, i32 0
  %1124 = extractvalue { double, double } %1121, 0
  store double %1124, ptr %1123, align 16
  %1125 = getelementptr inbounds { double, double }, ptr %1122, i32 0, i32 1
  %1126 = extractvalue { double, double } %1121, 1
  store double %1126, ptr %1125, align 8
  call void @llvm.lifetime.start.p0(i64 64, ptr %121) #6
  call void @_ZL22HMM_Orthographic_LH_NOffffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %121, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %1127 = load ptr, ptr %2, align 8, !tbaa !5
  %1128 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1127, i32 0, i32 0
  %1129 = load i32, ptr %1128, align 4, !tbaa !9
  %1130 = add nsw i32 %1129, 1
  store i32 %1130, ptr %1128, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %122) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %123) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %124, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %125, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1131 = getelementptr inbounds { double, double }, ptr %125, i32 0, i32 0
  %1132 = load double, ptr %1131, align 16
  %1133 = getelementptr inbounds { double, double }, ptr %125, i32 0, i32 1
  %1134 = load double, ptr %1133, align 8
  %1135 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %124, double %1132, double %1134)
  %1136 = getelementptr inbounds %union.HMM_Vec4, ptr %123, i32 0, i32 0
  %1137 = getelementptr inbounds { double, double }, ptr %1136, i32 0, i32 0
  %1138 = extractvalue { double, double } %1135, 0
  store double %1138, ptr %1137, align 16
  %1139 = getelementptr inbounds { double, double }, ptr %1136, i32 0, i32 1
  %1140 = extractvalue { double, double } %1135, 1
  store double %1140, ptr %1139, align 8
  %1141 = getelementptr inbounds %struct.anon.10, ptr %123, i32 0, i32 0
  %1142 = getelementptr inbounds %struct.anon.11, ptr %1141, i32 0, i32 0
  %1143 = load float, ptr %1142, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %123) #6
  store float %1143, ptr %122, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %126) #6
  %1144 = load float, ptr %122, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %127) #6
  %1145 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1146 = getelementptr inbounds %union.HMM_Vec4, ptr %127, i32 0, i32 0
  %1147 = getelementptr inbounds { double, double }, ptr %1146, i32 0, i32 0
  %1148 = extractvalue { double, double } %1145, 0
  store double %1148, ptr %1147, align 16
  %1149 = getelementptr inbounds { double, double }, ptr %1146, i32 0, i32 1
  %1150 = extractvalue { double, double } %1145, 1
  store double %1150, ptr %1149, align 8
  %1151 = getelementptr inbounds %struct.anon.10, ptr %127, i32 0, i32 0
  %1152 = getelementptr inbounds %struct.anon.11, ptr %1151, i32 0, i32 0
  %1153 = load float, ptr %1152, align 16, !tbaa !13
  %1154 = fsub float %1144, %1153
  call void @llvm.lifetime.end.p0(i64 16, ptr %127) #6
  store float %1154, ptr %126, align 4, !tbaa !15
  %1155 = load float, ptr %126, align 4, !tbaa !15
  %1156 = fcmp olt float %1155, 0xBE80000000000000
  br i1 %1156, label %1160, label %1157

1157:                                             ; preds = %1114
  %1158 = load float, ptr %126, align 4, !tbaa !15
  %1159 = fcmp olt float 0x3E80000000000000, %1158
  br i1 %1159, label %1160, label %1181

1160:                                             ; preds = %1157, %1114
  %1161 = load ptr, ptr %2, align 8, !tbaa !5
  %1162 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1161, i32 0, i32 1
  %1163 = load i32, ptr %1162, align 4, !tbaa !17
  %1164 = add nsw i32 %1163, 1
  store i32 %1164, ptr %1162, align 4, !tbaa !17
  %1165 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 37)
  call void @llvm.lifetime.start.p0(i64 16, ptr %128) #6
  %1166 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1167 = getelementptr inbounds %union.HMM_Vec4, ptr %128, i32 0, i32 0
  %1168 = getelementptr inbounds { double, double }, ptr %1167, i32 0, i32 0
  %1169 = extractvalue { double, double } %1166, 0
  store double %1169, ptr %1168, align 16
  %1170 = getelementptr inbounds { double, double }, ptr %1167, i32 0, i32 1
  %1171 = extractvalue { double, double } %1166, 1
  store double %1171, ptr %1170, align 8
  %1172 = getelementptr inbounds %struct.anon.10, ptr %128, i32 0, i32 0
  %1173 = getelementptr inbounds %struct.anon.11, ptr %1172, i32 0, i32 0
  %1174 = load float, ptr %1173, align 16, !tbaa !13
  %1175 = fpext float %1174 to double
  %1176 = load float, ptr %122, align 4, !tbaa !15
  %1177 = fpext float %1176 to double
  %1178 = load float, ptr %126, align 4, !tbaa !15
  %1179 = fpext float %1178 to double
  %1180 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %1175, double noundef %1177, double noundef %1179)
  call void @llvm.lifetime.end.p0(i64 16, ptr %128) #6
  br label %1181

1181:                                             ; preds = %1160, %1157
  call void @llvm.lifetime.end.p0(i64 4, ptr %126) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %122) #6
  %1182 = load ptr, ptr %2, align 8, !tbaa !5
  %1183 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1182, i32 0, i32 0
  %1184 = load i32, ptr %1183, align 4, !tbaa !9
  %1185 = add nsw i32 %1184, 1
  store i32 %1185, ptr %1183, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %129) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %130) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %131, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %132, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1186 = getelementptr inbounds { double, double }, ptr %132, i32 0, i32 0
  %1187 = load double, ptr %1186, align 16
  %1188 = getelementptr inbounds { double, double }, ptr %132, i32 0, i32 1
  %1189 = load double, ptr %1188, align 8
  %1190 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %131, double %1187, double %1189)
  %1191 = getelementptr inbounds %union.HMM_Vec4, ptr %130, i32 0, i32 0
  %1192 = getelementptr inbounds { double, double }, ptr %1191, i32 0, i32 0
  %1193 = extractvalue { double, double } %1190, 0
  store double %1193, ptr %1192, align 16
  %1194 = getelementptr inbounds { double, double }, ptr %1191, i32 0, i32 1
  %1195 = extractvalue { double, double } %1190, 1
  store double %1195, ptr %1194, align 8
  %1196 = getelementptr inbounds %struct.anon.10, ptr %130, i32 0, i32 0
  %1197 = getelementptr inbounds %struct.anon.11, ptr %1196, i32 0, i32 1
  %1198 = load float, ptr %1197, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %130) #6
  store float %1198, ptr %129, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %133) #6
  %1199 = load float, ptr %129, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %134) #6
  %1200 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1201 = getelementptr inbounds %union.HMM_Vec4, ptr %134, i32 0, i32 0
  %1202 = getelementptr inbounds { double, double }, ptr %1201, i32 0, i32 0
  %1203 = extractvalue { double, double } %1200, 0
  store double %1203, ptr %1202, align 16
  %1204 = getelementptr inbounds { double, double }, ptr %1201, i32 0, i32 1
  %1205 = extractvalue { double, double } %1200, 1
  store double %1205, ptr %1204, align 8
  %1206 = getelementptr inbounds %struct.anon.10, ptr %134, i32 0, i32 0
  %1207 = getelementptr inbounds %struct.anon.11, ptr %1206, i32 0, i32 1
  %1208 = load float, ptr %1207, align 4, !tbaa !13
  %1209 = fsub float %1199, %1208
  call void @llvm.lifetime.end.p0(i64 16, ptr %134) #6
  store float %1209, ptr %133, align 4, !tbaa !15
  %1210 = load float, ptr %133, align 4, !tbaa !15
  %1211 = fcmp olt float %1210, 0xBE80000000000000
  br i1 %1211, label %1215, label %1212

1212:                                             ; preds = %1181
  %1213 = load float, ptr %133, align 4, !tbaa !15
  %1214 = fcmp olt float 0x3E80000000000000, %1213
  br i1 %1214, label %1215, label %1236

1215:                                             ; preds = %1212, %1181
  %1216 = load ptr, ptr %2, align 8, !tbaa !5
  %1217 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1216, i32 0, i32 1
  %1218 = load i32, ptr %1217, align 4, !tbaa !17
  %1219 = add nsw i32 %1218, 1
  store i32 %1219, ptr %1217, align 4, !tbaa !17
  %1220 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 37)
  call void @llvm.lifetime.start.p0(i64 16, ptr %135) #6
  %1221 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1222 = getelementptr inbounds %union.HMM_Vec4, ptr %135, i32 0, i32 0
  %1223 = getelementptr inbounds { double, double }, ptr %1222, i32 0, i32 0
  %1224 = extractvalue { double, double } %1221, 0
  store double %1224, ptr %1223, align 16
  %1225 = getelementptr inbounds { double, double }, ptr %1222, i32 0, i32 1
  %1226 = extractvalue { double, double } %1221, 1
  store double %1226, ptr %1225, align 8
  %1227 = getelementptr inbounds %struct.anon.10, ptr %135, i32 0, i32 0
  %1228 = getelementptr inbounds %struct.anon.11, ptr %1227, i32 0, i32 1
  %1229 = load float, ptr %1228, align 4, !tbaa !13
  %1230 = fpext float %1229 to double
  %1231 = load float, ptr %129, align 4, !tbaa !15
  %1232 = fpext float %1231 to double
  %1233 = load float, ptr %133, align 4, !tbaa !15
  %1234 = fpext float %1233 to double
  %1235 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %1230, double noundef %1232, double noundef %1234)
  call void @llvm.lifetime.end.p0(i64 16, ptr %135) #6
  br label %1236

1236:                                             ; preds = %1215, %1212
  call void @llvm.lifetime.end.p0(i64 4, ptr %133) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %129) #6
  %1237 = load ptr, ptr %2, align 8, !tbaa !5
  %1238 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1237, i32 0, i32 0
  %1239 = load i32, ptr %1238, align 4, !tbaa !9
  %1240 = add nsw i32 %1239, 1
  store i32 %1240, ptr %1238, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %136) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %137) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %138, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %139, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1241 = getelementptr inbounds { double, double }, ptr %139, i32 0, i32 0
  %1242 = load double, ptr %1241, align 16
  %1243 = getelementptr inbounds { double, double }, ptr %139, i32 0, i32 1
  %1244 = load double, ptr %1243, align 8
  %1245 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %138, double %1242, double %1244)
  %1246 = getelementptr inbounds %union.HMM_Vec4, ptr %137, i32 0, i32 0
  %1247 = getelementptr inbounds { double, double }, ptr %1246, i32 0, i32 0
  %1248 = extractvalue { double, double } %1245, 0
  store double %1248, ptr %1247, align 16
  %1249 = getelementptr inbounds { double, double }, ptr %1246, i32 0, i32 1
  %1250 = extractvalue { double, double } %1245, 1
  store double %1250, ptr %1249, align 8
  %1251 = getelementptr inbounds %struct.anon.10, ptr %137, i32 0, i32 0
  %1252 = getelementptr inbounds %struct.anon.11, ptr %1251, i32 0, i32 2
  %1253 = load float, ptr %1252, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %137) #6
  store float %1253, ptr %136, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %140) #6
  %1254 = load float, ptr %136, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %141) #6
  %1255 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1256 = getelementptr inbounds %union.HMM_Vec4, ptr %141, i32 0, i32 0
  %1257 = getelementptr inbounds { double, double }, ptr %1256, i32 0, i32 0
  %1258 = extractvalue { double, double } %1255, 0
  store double %1258, ptr %1257, align 16
  %1259 = getelementptr inbounds { double, double }, ptr %1256, i32 0, i32 1
  %1260 = extractvalue { double, double } %1255, 1
  store double %1260, ptr %1259, align 8
  %1261 = getelementptr inbounds %struct.anon.10, ptr %141, i32 0, i32 0
  %1262 = getelementptr inbounds %struct.anon.11, ptr %1261, i32 0, i32 2
  %1263 = load float, ptr %1262, align 8, !tbaa !13
  %1264 = fsub float %1254, %1263
  call void @llvm.lifetime.end.p0(i64 16, ptr %141) #6
  store float %1264, ptr %140, align 4, !tbaa !15
  %1265 = load float, ptr %140, align 4, !tbaa !15
  %1266 = fcmp olt float %1265, 0xBE80000000000000
  br i1 %1266, label %1270, label %1267

1267:                                             ; preds = %1236
  %1268 = load float, ptr %140, align 4, !tbaa !15
  %1269 = fcmp olt float 0x3E80000000000000, %1268
  br i1 %1269, label %1270, label %1291

1270:                                             ; preds = %1267, %1236
  %1271 = load ptr, ptr %2, align 8, !tbaa !5
  %1272 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1271, i32 0, i32 1
  %1273 = load i32, ptr %1272, align 4, !tbaa !17
  %1274 = add nsw i32 %1273, 1
  store i32 %1274, ptr %1272, align 4, !tbaa !17
  %1275 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 37)
  call void @llvm.lifetime.start.p0(i64 16, ptr %142) #6
  %1276 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1277 = getelementptr inbounds %union.HMM_Vec4, ptr %142, i32 0, i32 0
  %1278 = getelementptr inbounds { double, double }, ptr %1277, i32 0, i32 0
  %1279 = extractvalue { double, double } %1276, 0
  store double %1279, ptr %1278, align 16
  %1280 = getelementptr inbounds { double, double }, ptr %1277, i32 0, i32 1
  %1281 = extractvalue { double, double } %1276, 1
  store double %1281, ptr %1280, align 8
  %1282 = getelementptr inbounds %struct.anon.10, ptr %142, i32 0, i32 0
  %1283 = getelementptr inbounds %struct.anon.11, ptr %1282, i32 0, i32 2
  %1284 = load float, ptr %1283, align 8, !tbaa !13
  %1285 = fpext float %1284 to double
  %1286 = load float, ptr %136, align 4, !tbaa !15
  %1287 = fpext float %1286 to double
  %1288 = load float, ptr %140, align 4, !tbaa !15
  %1289 = fpext float %1288 to double
  %1290 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %1285, double noundef %1287, double noundef %1289)
  call void @llvm.lifetime.end.p0(i64 16, ptr %142) #6
  br label %1291

1291:                                             ; preds = %1270, %1267
  call void @llvm.lifetime.end.p0(i64 4, ptr %140) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %136) #6
  %1292 = load ptr, ptr %2, align 8, !tbaa !5
  %1293 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1292, i32 0, i32 0
  %1294 = load i32, ptr %1293, align 4, !tbaa !9
  %1295 = add nsw i32 %1294, 1
  store i32 %1295, ptr %1293, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %143) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %144) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %145, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %146, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1296 = getelementptr inbounds { double, double }, ptr %146, i32 0, i32 0
  %1297 = load double, ptr %1296, align 16
  %1298 = getelementptr inbounds { double, double }, ptr %146, i32 0, i32 1
  %1299 = load double, ptr %1298, align 8
  %1300 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %145, double %1297, double %1299)
  %1301 = getelementptr inbounds %union.HMM_Vec4, ptr %144, i32 0, i32 0
  %1302 = getelementptr inbounds { double, double }, ptr %1301, i32 0, i32 0
  %1303 = extractvalue { double, double } %1300, 0
  store double %1303, ptr %1302, align 16
  %1304 = getelementptr inbounds { double, double }, ptr %1301, i32 0, i32 1
  %1305 = extractvalue { double, double } %1300, 1
  store double %1305, ptr %1304, align 8
  %1306 = getelementptr inbounds %struct.anon.10, ptr %144, i32 0, i32 1
  %1307 = load float, ptr %1306, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %144) #6
  store float %1307, ptr %143, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %147) #6
  %1308 = load float, ptr %143, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %148) #6
  %1309 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1310 = getelementptr inbounds %union.HMM_Vec4, ptr %148, i32 0, i32 0
  %1311 = getelementptr inbounds { double, double }, ptr %1310, i32 0, i32 0
  %1312 = extractvalue { double, double } %1309, 0
  store double %1312, ptr %1311, align 16
  %1313 = getelementptr inbounds { double, double }, ptr %1310, i32 0, i32 1
  %1314 = extractvalue { double, double } %1309, 1
  store double %1314, ptr %1313, align 8
  %1315 = getelementptr inbounds %struct.anon.10, ptr %148, i32 0, i32 1
  %1316 = load float, ptr %1315, align 4, !tbaa !13
  %1317 = fsub float %1308, %1316
  call void @llvm.lifetime.end.p0(i64 16, ptr %148) #6
  store float %1317, ptr %147, align 4, !tbaa !15
  %1318 = load float, ptr %147, align 4, !tbaa !15
  %1319 = fcmp olt float %1318, 0xBE80000000000000
  br i1 %1319, label %1323, label %1320

1320:                                             ; preds = %1291
  %1321 = load float, ptr %147, align 4, !tbaa !15
  %1322 = fcmp olt float 0x3E80000000000000, %1321
  br i1 %1322, label %1323, label %1343

1323:                                             ; preds = %1320, %1291
  %1324 = load ptr, ptr %2, align 8, !tbaa !5
  %1325 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1324, i32 0, i32 1
  %1326 = load i32, ptr %1325, align 4, !tbaa !17
  %1327 = add nsw i32 %1326, 1
  store i32 %1327, ptr %1325, align 4, !tbaa !17
  %1328 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 37)
  call void @llvm.lifetime.start.p0(i64 16, ptr %149) #6
  %1329 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %1330 = getelementptr inbounds %union.HMM_Vec4, ptr %149, i32 0, i32 0
  %1331 = getelementptr inbounds { double, double }, ptr %1330, i32 0, i32 0
  %1332 = extractvalue { double, double } %1329, 0
  store double %1332, ptr %1331, align 16
  %1333 = getelementptr inbounds { double, double }, ptr %1330, i32 0, i32 1
  %1334 = extractvalue { double, double } %1329, 1
  store double %1334, ptr %1333, align 8
  %1335 = getelementptr inbounds %struct.anon.10, ptr %149, i32 0, i32 1
  %1336 = load float, ptr %1335, align 4, !tbaa !13
  %1337 = fpext float %1336 to double
  %1338 = load float, ptr %143, align 4, !tbaa !15
  %1339 = fpext float %1338 to double
  %1340 = load float, ptr %147, align 4, !tbaa !15
  %1341 = fpext float %1340 to double
  %1342 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1337, double noundef %1339, double noundef %1341)
  call void @llvm.lifetime.end.p0(i64 16, ptr %149) #6
  br label %1343

1343:                                             ; preds = %1323, %1320
  call void @llvm.lifetime.end.p0(i64 4, ptr %147) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %143) #6
  %1344 = load ptr, ptr %2, align 8, !tbaa !5
  %1345 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1344, i32 0, i32 0
  %1346 = load i32, ptr %1345, align 4, !tbaa !9
  %1347 = add nsw i32 %1346, 1
  store i32 %1347, ptr %1345, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %150) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %151) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %152, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %153, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1348 = getelementptr inbounds { double, double }, ptr %153, i32 0, i32 0
  %1349 = load double, ptr %1348, align 16
  %1350 = getelementptr inbounds { double, double }, ptr %153, i32 0, i32 1
  %1351 = load double, ptr %1350, align 8
  %1352 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %152, double %1349, double %1351)
  %1353 = getelementptr inbounds %union.HMM_Vec4, ptr %151, i32 0, i32 0
  %1354 = getelementptr inbounds { double, double }, ptr %1353, i32 0, i32 0
  %1355 = extractvalue { double, double } %1352, 0
  store double %1355, ptr %1354, align 16
  %1356 = getelementptr inbounds { double, double }, ptr %1353, i32 0, i32 1
  %1357 = extractvalue { double, double } %1352, 1
  store double %1357, ptr %1356, align 8
  %1358 = getelementptr inbounds %struct.anon.10, ptr %151, i32 0, i32 0
  %1359 = getelementptr inbounds %struct.anon.11, ptr %1358, i32 0, i32 0
  %1360 = load float, ptr %1359, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %151) #6
  store float %1360, ptr %150, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %154) #6
  %1361 = load float, ptr %150, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %155) #6
  %1362 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1363 = getelementptr inbounds %union.HMM_Vec4, ptr %155, i32 0, i32 0
  %1364 = getelementptr inbounds { double, double }, ptr %1363, i32 0, i32 0
  %1365 = extractvalue { double, double } %1362, 0
  store double %1365, ptr %1364, align 16
  %1366 = getelementptr inbounds { double, double }, ptr %1363, i32 0, i32 1
  %1367 = extractvalue { double, double } %1362, 1
  store double %1367, ptr %1366, align 8
  %1368 = getelementptr inbounds %struct.anon.10, ptr %155, i32 0, i32 0
  %1369 = getelementptr inbounds %struct.anon.11, ptr %1368, i32 0, i32 0
  %1370 = load float, ptr %1369, align 16, !tbaa !13
  %1371 = fsub float %1361, %1370
  call void @llvm.lifetime.end.p0(i64 16, ptr %155) #6
  store float %1371, ptr %154, align 4, !tbaa !15
  %1372 = load float, ptr %154, align 4, !tbaa !15
  %1373 = fcmp olt float %1372, 0xBE80000000000000
  br i1 %1373, label %1377, label %1374

1374:                                             ; preds = %1343
  %1375 = load float, ptr %154, align 4, !tbaa !15
  %1376 = fcmp olt float 0x3E80000000000000, %1375
  br i1 %1376, label %1377, label %1398

1377:                                             ; preds = %1374, %1343
  %1378 = load ptr, ptr %2, align 8, !tbaa !5
  %1379 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1378, i32 0, i32 1
  %1380 = load i32, ptr %1379, align 4, !tbaa !17
  %1381 = add nsw i32 %1380, 1
  store i32 %1381, ptr %1379, align 4, !tbaa !17
  %1382 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 38)
  call void @llvm.lifetime.start.p0(i64 16, ptr %156) #6
  %1383 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1384 = getelementptr inbounds %union.HMM_Vec4, ptr %156, i32 0, i32 0
  %1385 = getelementptr inbounds { double, double }, ptr %1384, i32 0, i32 0
  %1386 = extractvalue { double, double } %1383, 0
  store double %1386, ptr %1385, align 16
  %1387 = getelementptr inbounds { double, double }, ptr %1384, i32 0, i32 1
  %1388 = extractvalue { double, double } %1383, 1
  store double %1388, ptr %1387, align 8
  %1389 = getelementptr inbounds %struct.anon.10, ptr %156, i32 0, i32 0
  %1390 = getelementptr inbounds %struct.anon.11, ptr %1389, i32 0, i32 0
  %1391 = load float, ptr %1390, align 16, !tbaa !13
  %1392 = fpext float %1391 to double
  %1393 = load float, ptr %150, align 4, !tbaa !15
  %1394 = fpext float %1393 to double
  %1395 = load float, ptr %154, align 4, !tbaa !15
  %1396 = fpext float %1395 to double
  %1397 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %1392, double noundef %1394, double noundef %1396)
  call void @llvm.lifetime.end.p0(i64 16, ptr %156) #6
  br label %1398

1398:                                             ; preds = %1377, %1374
  call void @llvm.lifetime.end.p0(i64 4, ptr %154) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %150) #6
  %1399 = load ptr, ptr %2, align 8, !tbaa !5
  %1400 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1399, i32 0, i32 0
  %1401 = load i32, ptr %1400, align 4, !tbaa !9
  %1402 = add nsw i32 %1401, 1
  store i32 %1402, ptr %1400, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %157) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %158) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %159, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %160, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1403 = getelementptr inbounds { double, double }, ptr %160, i32 0, i32 0
  %1404 = load double, ptr %1403, align 16
  %1405 = getelementptr inbounds { double, double }, ptr %160, i32 0, i32 1
  %1406 = load double, ptr %1405, align 8
  %1407 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %159, double %1404, double %1406)
  %1408 = getelementptr inbounds %union.HMM_Vec4, ptr %158, i32 0, i32 0
  %1409 = getelementptr inbounds { double, double }, ptr %1408, i32 0, i32 0
  %1410 = extractvalue { double, double } %1407, 0
  store double %1410, ptr %1409, align 16
  %1411 = getelementptr inbounds { double, double }, ptr %1408, i32 0, i32 1
  %1412 = extractvalue { double, double } %1407, 1
  store double %1412, ptr %1411, align 8
  %1413 = getelementptr inbounds %struct.anon.10, ptr %158, i32 0, i32 0
  %1414 = getelementptr inbounds %struct.anon.11, ptr %1413, i32 0, i32 1
  %1415 = load float, ptr %1414, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %158) #6
  store float %1415, ptr %157, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %161) #6
  %1416 = load float, ptr %157, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %162) #6
  %1417 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1418 = getelementptr inbounds %union.HMM_Vec4, ptr %162, i32 0, i32 0
  %1419 = getelementptr inbounds { double, double }, ptr %1418, i32 0, i32 0
  %1420 = extractvalue { double, double } %1417, 0
  store double %1420, ptr %1419, align 16
  %1421 = getelementptr inbounds { double, double }, ptr %1418, i32 0, i32 1
  %1422 = extractvalue { double, double } %1417, 1
  store double %1422, ptr %1421, align 8
  %1423 = getelementptr inbounds %struct.anon.10, ptr %162, i32 0, i32 0
  %1424 = getelementptr inbounds %struct.anon.11, ptr %1423, i32 0, i32 1
  %1425 = load float, ptr %1424, align 4, !tbaa !13
  %1426 = fsub float %1416, %1425
  call void @llvm.lifetime.end.p0(i64 16, ptr %162) #6
  store float %1426, ptr %161, align 4, !tbaa !15
  %1427 = load float, ptr %161, align 4, !tbaa !15
  %1428 = fcmp olt float %1427, 0xBE80000000000000
  br i1 %1428, label %1432, label %1429

1429:                                             ; preds = %1398
  %1430 = load float, ptr %161, align 4, !tbaa !15
  %1431 = fcmp olt float 0x3E80000000000000, %1430
  br i1 %1431, label %1432, label %1453

1432:                                             ; preds = %1429, %1398
  %1433 = load ptr, ptr %2, align 8, !tbaa !5
  %1434 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1433, i32 0, i32 1
  %1435 = load i32, ptr %1434, align 4, !tbaa !17
  %1436 = add nsw i32 %1435, 1
  store i32 %1436, ptr %1434, align 4, !tbaa !17
  %1437 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 38)
  call void @llvm.lifetime.start.p0(i64 16, ptr %163) #6
  %1438 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1439 = getelementptr inbounds %union.HMM_Vec4, ptr %163, i32 0, i32 0
  %1440 = getelementptr inbounds { double, double }, ptr %1439, i32 0, i32 0
  %1441 = extractvalue { double, double } %1438, 0
  store double %1441, ptr %1440, align 16
  %1442 = getelementptr inbounds { double, double }, ptr %1439, i32 0, i32 1
  %1443 = extractvalue { double, double } %1438, 1
  store double %1443, ptr %1442, align 8
  %1444 = getelementptr inbounds %struct.anon.10, ptr %163, i32 0, i32 0
  %1445 = getelementptr inbounds %struct.anon.11, ptr %1444, i32 0, i32 1
  %1446 = load float, ptr %1445, align 4, !tbaa !13
  %1447 = fpext float %1446 to double
  %1448 = load float, ptr %157, align 4, !tbaa !15
  %1449 = fpext float %1448 to double
  %1450 = load float, ptr %161, align 4, !tbaa !15
  %1451 = fpext float %1450 to double
  %1452 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %1447, double noundef %1449, double noundef %1451)
  call void @llvm.lifetime.end.p0(i64 16, ptr %163) #6
  br label %1453

1453:                                             ; preds = %1432, %1429
  call void @llvm.lifetime.end.p0(i64 4, ptr %161) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %157) #6
  %1454 = load ptr, ptr %2, align 8, !tbaa !5
  %1455 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1454, i32 0, i32 0
  %1456 = load i32, ptr %1455, align 4, !tbaa !9
  %1457 = add nsw i32 %1456, 1
  store i32 %1457, ptr %1455, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %164) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %165) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %166, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %167, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1458 = getelementptr inbounds { double, double }, ptr %167, i32 0, i32 0
  %1459 = load double, ptr %1458, align 16
  %1460 = getelementptr inbounds { double, double }, ptr %167, i32 0, i32 1
  %1461 = load double, ptr %1460, align 8
  %1462 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %166, double %1459, double %1461)
  %1463 = getelementptr inbounds %union.HMM_Vec4, ptr %165, i32 0, i32 0
  %1464 = getelementptr inbounds { double, double }, ptr %1463, i32 0, i32 0
  %1465 = extractvalue { double, double } %1462, 0
  store double %1465, ptr %1464, align 16
  %1466 = getelementptr inbounds { double, double }, ptr %1463, i32 0, i32 1
  %1467 = extractvalue { double, double } %1462, 1
  store double %1467, ptr %1466, align 8
  %1468 = getelementptr inbounds %struct.anon.10, ptr %165, i32 0, i32 0
  %1469 = getelementptr inbounds %struct.anon.11, ptr %1468, i32 0, i32 2
  %1470 = load float, ptr %1469, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %165) #6
  store float %1470, ptr %164, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %168) #6
  %1471 = load float, ptr %164, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %169) #6
  %1472 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1473 = getelementptr inbounds %union.HMM_Vec4, ptr %169, i32 0, i32 0
  %1474 = getelementptr inbounds { double, double }, ptr %1473, i32 0, i32 0
  %1475 = extractvalue { double, double } %1472, 0
  store double %1475, ptr %1474, align 16
  %1476 = getelementptr inbounds { double, double }, ptr %1473, i32 0, i32 1
  %1477 = extractvalue { double, double } %1472, 1
  store double %1477, ptr %1476, align 8
  %1478 = getelementptr inbounds %struct.anon.10, ptr %169, i32 0, i32 0
  %1479 = getelementptr inbounds %struct.anon.11, ptr %1478, i32 0, i32 2
  %1480 = load float, ptr %1479, align 8, !tbaa !13
  %1481 = fsub float %1471, %1480
  call void @llvm.lifetime.end.p0(i64 16, ptr %169) #6
  store float %1481, ptr %168, align 4, !tbaa !15
  %1482 = load float, ptr %168, align 4, !tbaa !15
  %1483 = fcmp olt float %1482, 0xBE80000000000000
  br i1 %1483, label %1487, label %1484

1484:                                             ; preds = %1453
  %1485 = load float, ptr %168, align 4, !tbaa !15
  %1486 = fcmp olt float 0x3E80000000000000, %1485
  br i1 %1486, label %1487, label %1508

1487:                                             ; preds = %1484, %1453
  %1488 = load ptr, ptr %2, align 8, !tbaa !5
  %1489 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1488, i32 0, i32 1
  %1490 = load i32, ptr %1489, align 4, !tbaa !17
  %1491 = add nsw i32 %1490, 1
  store i32 %1491, ptr %1489, align 4, !tbaa !17
  %1492 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 38)
  call void @llvm.lifetime.start.p0(i64 16, ptr %170) #6
  %1493 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1494 = getelementptr inbounds %union.HMM_Vec4, ptr %170, i32 0, i32 0
  %1495 = getelementptr inbounds { double, double }, ptr %1494, i32 0, i32 0
  %1496 = extractvalue { double, double } %1493, 0
  store double %1496, ptr %1495, align 16
  %1497 = getelementptr inbounds { double, double }, ptr %1494, i32 0, i32 1
  %1498 = extractvalue { double, double } %1493, 1
  store double %1498, ptr %1497, align 8
  %1499 = getelementptr inbounds %struct.anon.10, ptr %170, i32 0, i32 0
  %1500 = getelementptr inbounds %struct.anon.11, ptr %1499, i32 0, i32 2
  %1501 = load float, ptr %1500, align 8, !tbaa !13
  %1502 = fpext float %1501 to double
  %1503 = load float, ptr %164, align 4, !tbaa !15
  %1504 = fpext float %1503 to double
  %1505 = load float, ptr %168, align 4, !tbaa !15
  %1506 = fpext float %1505 to double
  %1507 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %1502, double noundef %1504, double noundef %1506)
  call void @llvm.lifetime.end.p0(i64 16, ptr %170) #6
  br label %1508

1508:                                             ; preds = %1487, %1484
  call void @llvm.lifetime.end.p0(i64 4, ptr %168) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %164) #6
  %1509 = load ptr, ptr %2, align 8, !tbaa !5
  %1510 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1509, i32 0, i32 0
  %1511 = load i32, ptr %1510, align 4, !tbaa !9
  %1512 = add nsw i32 %1511, 1
  store i32 %1512, ptr %1510, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %171) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %172) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %173, ptr align 16 %121, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %174, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1513 = getelementptr inbounds { double, double }, ptr %174, i32 0, i32 0
  %1514 = load double, ptr %1513, align 16
  %1515 = getelementptr inbounds { double, double }, ptr %174, i32 0, i32 1
  %1516 = load double, ptr %1515, align 8
  %1517 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %173, double %1514, double %1516)
  %1518 = getelementptr inbounds %union.HMM_Vec4, ptr %172, i32 0, i32 0
  %1519 = getelementptr inbounds { double, double }, ptr %1518, i32 0, i32 0
  %1520 = extractvalue { double, double } %1517, 0
  store double %1520, ptr %1519, align 16
  %1521 = getelementptr inbounds { double, double }, ptr %1518, i32 0, i32 1
  %1522 = extractvalue { double, double } %1517, 1
  store double %1522, ptr %1521, align 8
  %1523 = getelementptr inbounds %struct.anon.10, ptr %172, i32 0, i32 1
  %1524 = load float, ptr %1523, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %172) #6
  store float %1524, ptr %171, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %175) #6
  %1525 = load float, ptr %171, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %176) #6
  %1526 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1527 = getelementptr inbounds %union.HMM_Vec4, ptr %176, i32 0, i32 0
  %1528 = getelementptr inbounds { double, double }, ptr %1527, i32 0, i32 0
  %1529 = extractvalue { double, double } %1526, 0
  store double %1529, ptr %1528, align 16
  %1530 = getelementptr inbounds { double, double }, ptr %1527, i32 0, i32 1
  %1531 = extractvalue { double, double } %1526, 1
  store double %1531, ptr %1530, align 8
  %1532 = getelementptr inbounds %struct.anon.10, ptr %176, i32 0, i32 1
  %1533 = load float, ptr %1532, align 4, !tbaa !13
  %1534 = fsub float %1525, %1533
  call void @llvm.lifetime.end.p0(i64 16, ptr %176) #6
  store float %1534, ptr %175, align 4, !tbaa !15
  %1535 = load float, ptr %175, align 4, !tbaa !15
  %1536 = fcmp olt float %1535, 0xBE80000000000000
  br i1 %1536, label %1540, label %1537

1537:                                             ; preds = %1508
  %1538 = load float, ptr %175, align 4, !tbaa !15
  %1539 = fcmp olt float 0x3E80000000000000, %1538
  br i1 %1539, label %1540, label %1560

1540:                                             ; preds = %1537, %1508
  %1541 = load ptr, ptr %2, align 8, !tbaa !5
  %1542 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1541, i32 0, i32 1
  %1543 = load i32, ptr %1542, align 4, !tbaa !17
  %1544 = add nsw i32 %1543, 1
  store i32 %1544, ptr %1542, align 4, !tbaa !17
  %1545 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 38)
  call void @llvm.lifetime.start.p0(i64 16, ptr %177) #6
  %1546 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1547 = getelementptr inbounds %union.HMM_Vec4, ptr %177, i32 0, i32 0
  %1548 = getelementptr inbounds { double, double }, ptr %1547, i32 0, i32 0
  %1549 = extractvalue { double, double } %1546, 0
  store double %1549, ptr %1548, align 16
  %1550 = getelementptr inbounds { double, double }, ptr %1547, i32 0, i32 1
  %1551 = extractvalue { double, double } %1546, 1
  store double %1551, ptr %1550, align 8
  %1552 = getelementptr inbounds %struct.anon.10, ptr %177, i32 0, i32 1
  %1553 = load float, ptr %1552, align 4, !tbaa !13
  %1554 = fpext float %1553 to double
  %1555 = load float, ptr %171, align 4, !tbaa !15
  %1556 = fpext float %1555 to double
  %1557 = load float, ptr %175, align 4, !tbaa !15
  %1558 = fpext float %1557 to double
  %1559 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1554, double noundef %1556, double noundef %1558)
  call void @llvm.lifetime.end.p0(i64 16, ptr %177) #6
  br label %1560

1560:                                             ; preds = %1540, %1537
  call void @llvm.lifetime.end.p0(i64 4, ptr %175) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %171) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %121) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr %178) #6
  call void @_ZL22HMM_Orthographic_LH_ZOffffff(ptr dead_on_unwind writable sret(%union.HMM_Mat4) align 16 %178, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %1561 = load ptr, ptr %2, align 8, !tbaa !5
  %1562 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1561, i32 0, i32 0
  %1563 = load i32, ptr %1562, align 4, !tbaa !9
  %1564 = add nsw i32 %1563, 1
  store i32 %1564, ptr %1562, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %179) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %180) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %181, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %182, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1565 = getelementptr inbounds { double, double }, ptr %182, i32 0, i32 0
  %1566 = load double, ptr %1565, align 16
  %1567 = getelementptr inbounds { double, double }, ptr %182, i32 0, i32 1
  %1568 = load double, ptr %1567, align 8
  %1569 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %181, double %1566, double %1568)
  %1570 = getelementptr inbounds %union.HMM_Vec4, ptr %180, i32 0, i32 0
  %1571 = getelementptr inbounds { double, double }, ptr %1570, i32 0, i32 0
  %1572 = extractvalue { double, double } %1569, 0
  store double %1572, ptr %1571, align 16
  %1573 = getelementptr inbounds { double, double }, ptr %1570, i32 0, i32 1
  %1574 = extractvalue { double, double } %1569, 1
  store double %1574, ptr %1573, align 8
  %1575 = getelementptr inbounds %struct.anon.10, ptr %180, i32 0, i32 0
  %1576 = getelementptr inbounds %struct.anon.11, ptr %1575, i32 0, i32 0
  %1577 = load float, ptr %1576, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %180) #6
  store float %1577, ptr %179, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %183) #6
  %1578 = load float, ptr %179, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %184) #6
  %1579 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1580 = getelementptr inbounds %union.HMM_Vec4, ptr %184, i32 0, i32 0
  %1581 = getelementptr inbounds { double, double }, ptr %1580, i32 0, i32 0
  %1582 = extractvalue { double, double } %1579, 0
  store double %1582, ptr %1581, align 16
  %1583 = getelementptr inbounds { double, double }, ptr %1580, i32 0, i32 1
  %1584 = extractvalue { double, double } %1579, 1
  store double %1584, ptr %1583, align 8
  %1585 = getelementptr inbounds %struct.anon.10, ptr %184, i32 0, i32 0
  %1586 = getelementptr inbounds %struct.anon.11, ptr %1585, i32 0, i32 0
  %1587 = load float, ptr %1586, align 16, !tbaa !13
  %1588 = fsub float %1578, %1587
  call void @llvm.lifetime.end.p0(i64 16, ptr %184) #6
  store float %1588, ptr %183, align 4, !tbaa !15
  %1589 = load float, ptr %183, align 4, !tbaa !15
  %1590 = fcmp olt float %1589, 0xBE80000000000000
  br i1 %1590, label %1594, label %1591

1591:                                             ; preds = %1560
  %1592 = load float, ptr %183, align 4, !tbaa !15
  %1593 = fcmp olt float 0x3E80000000000000, %1592
  br i1 %1593, label %1594, label %1615

1594:                                             ; preds = %1591, %1560
  %1595 = load ptr, ptr %2, align 8, !tbaa !5
  %1596 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1595, i32 0, i32 1
  %1597 = load i32, ptr %1596, align 4, !tbaa !17
  %1598 = add nsw i32 %1597, 1
  store i32 %1598, ptr %1596, align 4, !tbaa !17
  %1599 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 44)
  call void @llvm.lifetime.start.p0(i64 16, ptr %185) #6
  %1600 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1601 = getelementptr inbounds %union.HMM_Vec4, ptr %185, i32 0, i32 0
  %1602 = getelementptr inbounds { double, double }, ptr %1601, i32 0, i32 0
  %1603 = extractvalue { double, double } %1600, 0
  store double %1603, ptr %1602, align 16
  %1604 = getelementptr inbounds { double, double }, ptr %1601, i32 0, i32 1
  %1605 = extractvalue { double, double } %1600, 1
  store double %1605, ptr %1604, align 8
  %1606 = getelementptr inbounds %struct.anon.10, ptr %185, i32 0, i32 0
  %1607 = getelementptr inbounds %struct.anon.11, ptr %1606, i32 0, i32 0
  %1608 = load float, ptr %1607, align 16, !tbaa !13
  %1609 = fpext float %1608 to double
  %1610 = load float, ptr %179, align 4, !tbaa !15
  %1611 = fpext float %1610 to double
  %1612 = load float, ptr %183, align 4, !tbaa !15
  %1613 = fpext float %1612 to double
  %1614 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %1609, double noundef %1611, double noundef %1613)
  call void @llvm.lifetime.end.p0(i64 16, ptr %185) #6
  br label %1615

1615:                                             ; preds = %1594, %1591
  call void @llvm.lifetime.end.p0(i64 4, ptr %183) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %179) #6
  %1616 = load ptr, ptr %2, align 8, !tbaa !5
  %1617 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1616, i32 0, i32 0
  %1618 = load i32, ptr %1617, align 4, !tbaa !9
  %1619 = add nsw i32 %1618, 1
  store i32 %1619, ptr %1617, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %186) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %187) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %188, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %189, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1620 = getelementptr inbounds { double, double }, ptr %189, i32 0, i32 0
  %1621 = load double, ptr %1620, align 16
  %1622 = getelementptr inbounds { double, double }, ptr %189, i32 0, i32 1
  %1623 = load double, ptr %1622, align 8
  %1624 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %188, double %1621, double %1623)
  %1625 = getelementptr inbounds %union.HMM_Vec4, ptr %187, i32 0, i32 0
  %1626 = getelementptr inbounds { double, double }, ptr %1625, i32 0, i32 0
  %1627 = extractvalue { double, double } %1624, 0
  store double %1627, ptr %1626, align 16
  %1628 = getelementptr inbounds { double, double }, ptr %1625, i32 0, i32 1
  %1629 = extractvalue { double, double } %1624, 1
  store double %1629, ptr %1628, align 8
  %1630 = getelementptr inbounds %struct.anon.10, ptr %187, i32 0, i32 0
  %1631 = getelementptr inbounds %struct.anon.11, ptr %1630, i32 0, i32 1
  %1632 = load float, ptr %1631, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %187) #6
  store float %1632, ptr %186, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %190) #6
  %1633 = load float, ptr %186, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %191) #6
  %1634 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1635 = getelementptr inbounds %union.HMM_Vec4, ptr %191, i32 0, i32 0
  %1636 = getelementptr inbounds { double, double }, ptr %1635, i32 0, i32 0
  %1637 = extractvalue { double, double } %1634, 0
  store double %1637, ptr %1636, align 16
  %1638 = getelementptr inbounds { double, double }, ptr %1635, i32 0, i32 1
  %1639 = extractvalue { double, double } %1634, 1
  store double %1639, ptr %1638, align 8
  %1640 = getelementptr inbounds %struct.anon.10, ptr %191, i32 0, i32 0
  %1641 = getelementptr inbounds %struct.anon.11, ptr %1640, i32 0, i32 1
  %1642 = load float, ptr %1641, align 4, !tbaa !13
  %1643 = fsub float %1633, %1642
  call void @llvm.lifetime.end.p0(i64 16, ptr %191) #6
  store float %1643, ptr %190, align 4, !tbaa !15
  %1644 = load float, ptr %190, align 4, !tbaa !15
  %1645 = fcmp olt float %1644, 0xBE80000000000000
  br i1 %1645, label %1649, label %1646

1646:                                             ; preds = %1615
  %1647 = load float, ptr %190, align 4, !tbaa !15
  %1648 = fcmp olt float 0x3E80000000000000, %1647
  br i1 %1648, label %1649, label %1670

1649:                                             ; preds = %1646, %1615
  %1650 = load ptr, ptr %2, align 8, !tbaa !5
  %1651 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1650, i32 0, i32 1
  %1652 = load i32, ptr %1651, align 4, !tbaa !17
  %1653 = add nsw i32 %1652, 1
  store i32 %1653, ptr %1651, align 4, !tbaa !17
  %1654 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 44)
  call void @llvm.lifetime.start.p0(i64 16, ptr %192) #6
  %1655 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1656 = getelementptr inbounds %union.HMM_Vec4, ptr %192, i32 0, i32 0
  %1657 = getelementptr inbounds { double, double }, ptr %1656, i32 0, i32 0
  %1658 = extractvalue { double, double } %1655, 0
  store double %1658, ptr %1657, align 16
  %1659 = getelementptr inbounds { double, double }, ptr %1656, i32 0, i32 1
  %1660 = extractvalue { double, double } %1655, 1
  store double %1660, ptr %1659, align 8
  %1661 = getelementptr inbounds %struct.anon.10, ptr %192, i32 0, i32 0
  %1662 = getelementptr inbounds %struct.anon.11, ptr %1661, i32 0, i32 1
  %1663 = load float, ptr %1662, align 4, !tbaa !13
  %1664 = fpext float %1663 to double
  %1665 = load float, ptr %186, align 4, !tbaa !15
  %1666 = fpext float %1665 to double
  %1667 = load float, ptr %190, align 4, !tbaa !15
  %1668 = fpext float %1667 to double
  %1669 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %1664, double noundef %1666, double noundef %1668)
  call void @llvm.lifetime.end.p0(i64 16, ptr %192) #6
  br label %1670

1670:                                             ; preds = %1649, %1646
  call void @llvm.lifetime.end.p0(i64 4, ptr %190) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %186) #6
  %1671 = load ptr, ptr %2, align 8, !tbaa !5
  %1672 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1671, i32 0, i32 0
  %1673 = load i32, ptr %1672, align 4, !tbaa !9
  %1674 = add nsw i32 %1673, 1
  store i32 %1674, ptr %1672, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %193) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %194) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %195, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %196, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1675 = getelementptr inbounds { double, double }, ptr %196, i32 0, i32 0
  %1676 = load double, ptr %1675, align 16
  %1677 = getelementptr inbounds { double, double }, ptr %196, i32 0, i32 1
  %1678 = load double, ptr %1677, align 8
  %1679 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %195, double %1676, double %1678)
  %1680 = getelementptr inbounds %union.HMM_Vec4, ptr %194, i32 0, i32 0
  %1681 = getelementptr inbounds { double, double }, ptr %1680, i32 0, i32 0
  %1682 = extractvalue { double, double } %1679, 0
  store double %1682, ptr %1681, align 16
  %1683 = getelementptr inbounds { double, double }, ptr %1680, i32 0, i32 1
  %1684 = extractvalue { double, double } %1679, 1
  store double %1684, ptr %1683, align 8
  %1685 = getelementptr inbounds %struct.anon.10, ptr %194, i32 0, i32 0
  %1686 = getelementptr inbounds %struct.anon.11, ptr %1685, i32 0, i32 2
  %1687 = load float, ptr %1686, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %194) #6
  store float %1687, ptr %193, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %197) #6
  %1688 = load float, ptr %193, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %198) #6
  %1689 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1690 = getelementptr inbounds %union.HMM_Vec4, ptr %198, i32 0, i32 0
  %1691 = getelementptr inbounds { double, double }, ptr %1690, i32 0, i32 0
  %1692 = extractvalue { double, double } %1689, 0
  store double %1692, ptr %1691, align 16
  %1693 = getelementptr inbounds { double, double }, ptr %1690, i32 0, i32 1
  %1694 = extractvalue { double, double } %1689, 1
  store double %1694, ptr %1693, align 8
  %1695 = getelementptr inbounds %struct.anon.10, ptr %198, i32 0, i32 0
  %1696 = getelementptr inbounds %struct.anon.11, ptr %1695, i32 0, i32 2
  %1697 = load float, ptr %1696, align 8, !tbaa !13
  %1698 = fsub float %1688, %1697
  call void @llvm.lifetime.end.p0(i64 16, ptr %198) #6
  store float %1698, ptr %197, align 4, !tbaa !15
  %1699 = load float, ptr %197, align 4, !tbaa !15
  %1700 = fcmp olt float %1699, 0xBE80000000000000
  br i1 %1700, label %1704, label %1701

1701:                                             ; preds = %1670
  %1702 = load float, ptr %197, align 4, !tbaa !15
  %1703 = fcmp olt float 0x3E80000000000000, %1702
  br i1 %1703, label %1704, label %1725

1704:                                             ; preds = %1701, %1670
  %1705 = load ptr, ptr %2, align 8, !tbaa !5
  %1706 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1705, i32 0, i32 1
  %1707 = load i32, ptr %1706, align 4, !tbaa !17
  %1708 = add nsw i32 %1707, 1
  store i32 %1708, ptr %1706, align 4, !tbaa !17
  %1709 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 44)
  call void @llvm.lifetime.start.p0(i64 16, ptr %199) #6
  %1710 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1711 = getelementptr inbounds %union.HMM_Vec4, ptr %199, i32 0, i32 0
  %1712 = getelementptr inbounds { double, double }, ptr %1711, i32 0, i32 0
  %1713 = extractvalue { double, double } %1710, 0
  store double %1713, ptr %1712, align 16
  %1714 = getelementptr inbounds { double, double }, ptr %1711, i32 0, i32 1
  %1715 = extractvalue { double, double } %1710, 1
  store double %1715, ptr %1714, align 8
  %1716 = getelementptr inbounds %struct.anon.10, ptr %199, i32 0, i32 0
  %1717 = getelementptr inbounds %struct.anon.11, ptr %1716, i32 0, i32 2
  %1718 = load float, ptr %1717, align 8, !tbaa !13
  %1719 = fpext float %1718 to double
  %1720 = load float, ptr %193, align 4, !tbaa !15
  %1721 = fpext float %1720 to double
  %1722 = load float, ptr %197, align 4, !tbaa !15
  %1723 = fpext float %1722 to double
  %1724 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %1719, double noundef %1721, double noundef %1723)
  call void @llvm.lifetime.end.p0(i64 16, ptr %199) #6
  br label %1725

1725:                                             ; preds = %1704, %1701
  call void @llvm.lifetime.end.p0(i64 4, ptr %197) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %193) #6
  %1726 = load ptr, ptr %2, align 8, !tbaa !5
  %1727 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1726, i32 0, i32 0
  %1728 = load i32, ptr %1727, align 4, !tbaa !9
  %1729 = add nsw i32 %1728, 1
  store i32 %1729, ptr %1727, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %200) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %201) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %202, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %203, ptr align 16 %119, i64 16, i1 false), !tbaa.struct !14
  %1730 = getelementptr inbounds { double, double }, ptr %203, i32 0, i32 0
  %1731 = load double, ptr %1730, align 16
  %1732 = getelementptr inbounds { double, double }, ptr %203, i32 0, i32 1
  %1733 = load double, ptr %1732, align 8
  %1734 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %202, double %1731, double %1733)
  %1735 = getelementptr inbounds %union.HMM_Vec4, ptr %201, i32 0, i32 0
  %1736 = getelementptr inbounds { double, double }, ptr %1735, i32 0, i32 0
  %1737 = extractvalue { double, double } %1734, 0
  store double %1737, ptr %1736, align 16
  %1738 = getelementptr inbounds { double, double }, ptr %1735, i32 0, i32 1
  %1739 = extractvalue { double, double } %1734, 1
  store double %1739, ptr %1738, align 8
  %1740 = getelementptr inbounds %struct.anon.10, ptr %201, i32 0, i32 1
  %1741 = load float, ptr %1740, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %201) #6
  store float %1741, ptr %200, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %204) #6
  %1742 = load float, ptr %200, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %205) #6
  %1743 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1744 = getelementptr inbounds %union.HMM_Vec4, ptr %205, i32 0, i32 0
  %1745 = getelementptr inbounds { double, double }, ptr %1744, i32 0, i32 0
  %1746 = extractvalue { double, double } %1743, 0
  store double %1746, ptr %1745, align 16
  %1747 = getelementptr inbounds { double, double }, ptr %1744, i32 0, i32 1
  %1748 = extractvalue { double, double } %1743, 1
  store double %1748, ptr %1747, align 8
  %1749 = getelementptr inbounds %struct.anon.10, ptr %205, i32 0, i32 1
  %1750 = load float, ptr %1749, align 4, !tbaa !13
  %1751 = fsub float %1742, %1750
  call void @llvm.lifetime.end.p0(i64 16, ptr %205) #6
  store float %1751, ptr %204, align 4, !tbaa !15
  %1752 = load float, ptr %204, align 4, !tbaa !15
  %1753 = fcmp olt float %1752, 0xBE80000000000000
  br i1 %1753, label %1757, label %1754

1754:                                             ; preds = %1725
  %1755 = load float, ptr %204, align 4, !tbaa !15
  %1756 = fcmp olt float 0x3E80000000000000, %1755
  br i1 %1756, label %1757, label %1777

1757:                                             ; preds = %1754, %1725
  %1758 = load ptr, ptr %2, align 8, !tbaa !5
  %1759 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1758, i32 0, i32 1
  %1760 = load i32, ptr %1759, align 4, !tbaa !17
  %1761 = add nsw i32 %1760, 1
  store i32 %1761, ptr %1759, align 4, !tbaa !17
  %1762 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 44)
  call void @llvm.lifetime.start.p0(i64 16, ptr %206) #6
  %1763 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %1764 = getelementptr inbounds %union.HMM_Vec4, ptr %206, i32 0, i32 0
  %1765 = getelementptr inbounds { double, double }, ptr %1764, i32 0, i32 0
  %1766 = extractvalue { double, double } %1763, 0
  store double %1766, ptr %1765, align 16
  %1767 = getelementptr inbounds { double, double }, ptr %1764, i32 0, i32 1
  %1768 = extractvalue { double, double } %1763, 1
  store double %1768, ptr %1767, align 8
  %1769 = getelementptr inbounds %struct.anon.10, ptr %206, i32 0, i32 1
  %1770 = load float, ptr %1769, align 4, !tbaa !13
  %1771 = fpext float %1770 to double
  %1772 = load float, ptr %200, align 4, !tbaa !15
  %1773 = fpext float %1772 to double
  %1774 = load float, ptr %204, align 4, !tbaa !15
  %1775 = fpext float %1774 to double
  %1776 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1771, double noundef %1773, double noundef %1775)
  call void @llvm.lifetime.end.p0(i64 16, ptr %206) #6
  br label %1777

1777:                                             ; preds = %1757, %1754
  call void @llvm.lifetime.end.p0(i64 4, ptr %204) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %200) #6
  %1778 = load ptr, ptr %2, align 8, !tbaa !5
  %1779 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1778, i32 0, i32 0
  %1780 = load i32, ptr %1779, align 4, !tbaa !9
  %1781 = add nsw i32 %1780, 1
  store i32 %1781, ptr %1779, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %207) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %208) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %209, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %210, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1782 = getelementptr inbounds { double, double }, ptr %210, i32 0, i32 0
  %1783 = load double, ptr %1782, align 16
  %1784 = getelementptr inbounds { double, double }, ptr %210, i32 0, i32 1
  %1785 = load double, ptr %1784, align 8
  %1786 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %209, double %1783, double %1785)
  %1787 = getelementptr inbounds %union.HMM_Vec4, ptr %208, i32 0, i32 0
  %1788 = getelementptr inbounds { double, double }, ptr %1787, i32 0, i32 0
  %1789 = extractvalue { double, double } %1786, 0
  store double %1789, ptr %1788, align 16
  %1790 = getelementptr inbounds { double, double }, ptr %1787, i32 0, i32 1
  %1791 = extractvalue { double, double } %1786, 1
  store double %1791, ptr %1790, align 8
  %1792 = getelementptr inbounds %struct.anon.10, ptr %208, i32 0, i32 0
  %1793 = getelementptr inbounds %struct.anon.11, ptr %1792, i32 0, i32 0
  %1794 = load float, ptr %1793, align 16, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %208) #6
  store float %1794, ptr %207, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %211) #6
  %1795 = load float, ptr %207, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %212) #6
  %1796 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1797 = getelementptr inbounds %union.HMM_Vec4, ptr %212, i32 0, i32 0
  %1798 = getelementptr inbounds { double, double }, ptr %1797, i32 0, i32 0
  %1799 = extractvalue { double, double } %1796, 0
  store double %1799, ptr %1798, align 16
  %1800 = getelementptr inbounds { double, double }, ptr %1797, i32 0, i32 1
  %1801 = extractvalue { double, double } %1796, 1
  store double %1801, ptr %1800, align 8
  %1802 = getelementptr inbounds %struct.anon.10, ptr %212, i32 0, i32 0
  %1803 = getelementptr inbounds %struct.anon.11, ptr %1802, i32 0, i32 0
  %1804 = load float, ptr %1803, align 16, !tbaa !13
  %1805 = fsub float %1795, %1804
  call void @llvm.lifetime.end.p0(i64 16, ptr %212) #6
  store float %1805, ptr %211, align 4, !tbaa !15
  %1806 = load float, ptr %211, align 4, !tbaa !15
  %1807 = fcmp olt float %1806, 0xBE80000000000000
  br i1 %1807, label %1811, label %1808

1808:                                             ; preds = %1777
  %1809 = load float, ptr %211, align 4, !tbaa !15
  %1810 = fcmp olt float 0x3E80000000000000, %1809
  br i1 %1810, label %1811, label %1832

1811:                                             ; preds = %1808, %1777
  %1812 = load ptr, ptr %2, align 8, !tbaa !5
  %1813 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1812, i32 0, i32 1
  %1814 = load i32, ptr %1813, align 4, !tbaa !17
  %1815 = add nsw i32 %1814, 1
  store i32 %1815, ptr %1813, align 4, !tbaa !17
  %1816 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 45)
  call void @llvm.lifetime.start.p0(i64 16, ptr %213) #6
  %1817 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1818 = getelementptr inbounds %union.HMM_Vec4, ptr %213, i32 0, i32 0
  %1819 = getelementptr inbounds { double, double }, ptr %1818, i32 0, i32 0
  %1820 = extractvalue { double, double } %1817, 0
  store double %1820, ptr %1819, align 16
  %1821 = getelementptr inbounds { double, double }, ptr %1818, i32 0, i32 1
  %1822 = extractvalue { double, double } %1817, 1
  store double %1822, ptr %1821, align 8
  %1823 = getelementptr inbounds %struct.anon.10, ptr %213, i32 0, i32 0
  %1824 = getelementptr inbounds %struct.anon.11, ptr %1823, i32 0, i32 0
  %1825 = load float, ptr %1824, align 16, !tbaa !13
  %1826 = fpext float %1825 to double
  %1827 = load float, ptr %207, align 4, !tbaa !15
  %1828 = fpext float %1827 to double
  %1829 = load float, ptr %211, align 4, !tbaa !15
  %1830 = fpext float %1829 to double
  %1831 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.135, double noundef %1826, double noundef %1828, double noundef %1830)
  call void @llvm.lifetime.end.p0(i64 16, ptr %213) #6
  br label %1832

1832:                                             ; preds = %1811, %1808
  call void @llvm.lifetime.end.p0(i64 4, ptr %211) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %207) #6
  %1833 = load ptr, ptr %2, align 8, !tbaa !5
  %1834 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1833, i32 0, i32 0
  %1835 = load i32, ptr %1834, align 4, !tbaa !9
  %1836 = add nsw i32 %1835, 1
  store i32 %1836, ptr %1834, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %214) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %215) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %216, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %217, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1837 = getelementptr inbounds { double, double }, ptr %217, i32 0, i32 0
  %1838 = load double, ptr %1837, align 16
  %1839 = getelementptr inbounds { double, double }, ptr %217, i32 0, i32 1
  %1840 = load double, ptr %1839, align 8
  %1841 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %216, double %1838, double %1840)
  %1842 = getelementptr inbounds %union.HMM_Vec4, ptr %215, i32 0, i32 0
  %1843 = getelementptr inbounds { double, double }, ptr %1842, i32 0, i32 0
  %1844 = extractvalue { double, double } %1841, 0
  store double %1844, ptr %1843, align 16
  %1845 = getelementptr inbounds { double, double }, ptr %1842, i32 0, i32 1
  %1846 = extractvalue { double, double } %1841, 1
  store double %1846, ptr %1845, align 8
  %1847 = getelementptr inbounds %struct.anon.10, ptr %215, i32 0, i32 0
  %1848 = getelementptr inbounds %struct.anon.11, ptr %1847, i32 0, i32 1
  %1849 = load float, ptr %1848, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %215) #6
  store float %1849, ptr %214, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %218) #6
  %1850 = load float, ptr %214, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %219) #6
  %1851 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1852 = getelementptr inbounds %union.HMM_Vec4, ptr %219, i32 0, i32 0
  %1853 = getelementptr inbounds { double, double }, ptr %1852, i32 0, i32 0
  %1854 = extractvalue { double, double } %1851, 0
  store double %1854, ptr %1853, align 16
  %1855 = getelementptr inbounds { double, double }, ptr %1852, i32 0, i32 1
  %1856 = extractvalue { double, double } %1851, 1
  store double %1856, ptr %1855, align 8
  %1857 = getelementptr inbounds %struct.anon.10, ptr %219, i32 0, i32 0
  %1858 = getelementptr inbounds %struct.anon.11, ptr %1857, i32 0, i32 1
  %1859 = load float, ptr %1858, align 4, !tbaa !13
  %1860 = fsub float %1850, %1859
  call void @llvm.lifetime.end.p0(i64 16, ptr %219) #6
  store float %1860, ptr %218, align 4, !tbaa !15
  %1861 = load float, ptr %218, align 4, !tbaa !15
  %1862 = fcmp olt float %1861, 0xBE80000000000000
  br i1 %1862, label %1866, label %1863

1863:                                             ; preds = %1832
  %1864 = load float, ptr %218, align 4, !tbaa !15
  %1865 = fcmp olt float 0x3E80000000000000, %1864
  br i1 %1865, label %1866, label %1887

1866:                                             ; preds = %1863, %1832
  %1867 = load ptr, ptr %2, align 8, !tbaa !5
  %1868 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1867, i32 0, i32 1
  %1869 = load i32, ptr %1868, align 4, !tbaa !17
  %1870 = add nsw i32 %1869, 1
  store i32 %1870, ptr %1868, align 4, !tbaa !17
  %1871 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 45)
  call void @llvm.lifetime.start.p0(i64 16, ptr %220) #6
  %1872 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1873 = getelementptr inbounds %union.HMM_Vec4, ptr %220, i32 0, i32 0
  %1874 = getelementptr inbounds { double, double }, ptr %1873, i32 0, i32 0
  %1875 = extractvalue { double, double } %1872, 0
  store double %1875, ptr %1874, align 16
  %1876 = getelementptr inbounds { double, double }, ptr %1873, i32 0, i32 1
  %1877 = extractvalue { double, double } %1872, 1
  store double %1877, ptr %1876, align 8
  %1878 = getelementptr inbounds %struct.anon.10, ptr %220, i32 0, i32 0
  %1879 = getelementptr inbounds %struct.anon.11, ptr %1878, i32 0, i32 1
  %1880 = load float, ptr %1879, align 4, !tbaa !13
  %1881 = fpext float %1880 to double
  %1882 = load float, ptr %214, align 4, !tbaa !15
  %1883 = fpext float %1882 to double
  %1884 = load float, ptr %218, align 4, !tbaa !15
  %1885 = fpext float %1884 to double
  %1886 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.136, double noundef %1881, double noundef %1883, double noundef %1885)
  call void @llvm.lifetime.end.p0(i64 16, ptr %220) #6
  br label %1887

1887:                                             ; preds = %1866, %1863
  call void @llvm.lifetime.end.p0(i64 4, ptr %218) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %214) #6
  %1888 = load ptr, ptr %2, align 8, !tbaa !5
  %1889 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1888, i32 0, i32 0
  %1890 = load i32, ptr %1889, align 4, !tbaa !9
  %1891 = add nsw i32 %1890, 1
  store i32 %1891, ptr %1889, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %221) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %222) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %223, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %224, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1892 = getelementptr inbounds { double, double }, ptr %224, i32 0, i32 0
  %1893 = load double, ptr %1892, align 16
  %1894 = getelementptr inbounds { double, double }, ptr %224, i32 0, i32 1
  %1895 = load double, ptr %1894, align 8
  %1896 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %223, double %1893, double %1895)
  %1897 = getelementptr inbounds %union.HMM_Vec4, ptr %222, i32 0, i32 0
  %1898 = getelementptr inbounds { double, double }, ptr %1897, i32 0, i32 0
  %1899 = extractvalue { double, double } %1896, 0
  store double %1899, ptr %1898, align 16
  %1900 = getelementptr inbounds { double, double }, ptr %1897, i32 0, i32 1
  %1901 = extractvalue { double, double } %1896, 1
  store double %1901, ptr %1900, align 8
  %1902 = getelementptr inbounds %struct.anon.10, ptr %222, i32 0, i32 0
  %1903 = getelementptr inbounds %struct.anon.11, ptr %1902, i32 0, i32 2
  %1904 = load float, ptr %1903, align 8, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %222) #6
  store float %1904, ptr %221, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %225) #6
  %1905 = load float, ptr %221, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %226) #6
  %1906 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1907 = getelementptr inbounds %union.HMM_Vec4, ptr %226, i32 0, i32 0
  %1908 = getelementptr inbounds { double, double }, ptr %1907, i32 0, i32 0
  %1909 = extractvalue { double, double } %1906, 0
  store double %1909, ptr %1908, align 16
  %1910 = getelementptr inbounds { double, double }, ptr %1907, i32 0, i32 1
  %1911 = extractvalue { double, double } %1906, 1
  store double %1911, ptr %1910, align 8
  %1912 = getelementptr inbounds %struct.anon.10, ptr %226, i32 0, i32 0
  %1913 = getelementptr inbounds %struct.anon.11, ptr %1912, i32 0, i32 2
  %1914 = load float, ptr %1913, align 8, !tbaa !13
  %1915 = fsub float %1905, %1914
  call void @llvm.lifetime.end.p0(i64 16, ptr %226) #6
  store float %1915, ptr %225, align 4, !tbaa !15
  %1916 = load float, ptr %225, align 4, !tbaa !15
  %1917 = fcmp olt float %1916, 0xBE80000000000000
  br i1 %1917, label %1921, label %1918

1918:                                             ; preds = %1887
  %1919 = load float, ptr %225, align 4, !tbaa !15
  %1920 = fcmp olt float 0x3E80000000000000, %1919
  br i1 %1920, label %1921, label %1942

1921:                                             ; preds = %1918, %1887
  %1922 = load ptr, ptr %2, align 8, !tbaa !5
  %1923 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1922, i32 0, i32 1
  %1924 = load i32, ptr %1923, align 4, !tbaa !17
  %1925 = add nsw i32 %1924, 1
  store i32 %1925, ptr %1923, align 4, !tbaa !17
  %1926 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 45)
  call void @llvm.lifetime.start.p0(i64 16, ptr %227) #6
  %1927 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1928 = getelementptr inbounds %union.HMM_Vec4, ptr %227, i32 0, i32 0
  %1929 = getelementptr inbounds { double, double }, ptr %1928, i32 0, i32 0
  %1930 = extractvalue { double, double } %1927, 0
  store double %1930, ptr %1929, align 16
  %1931 = getelementptr inbounds { double, double }, ptr %1928, i32 0, i32 1
  %1932 = extractvalue { double, double } %1927, 1
  store double %1932, ptr %1931, align 8
  %1933 = getelementptr inbounds %struct.anon.10, ptr %227, i32 0, i32 0
  %1934 = getelementptr inbounds %struct.anon.11, ptr %1933, i32 0, i32 2
  %1935 = load float, ptr %1934, align 8, !tbaa !13
  %1936 = fpext float %1935 to double
  %1937 = load float, ptr %221, align 4, !tbaa !15
  %1938 = fpext float %1937 to double
  %1939 = load float, ptr %225, align 4, !tbaa !15
  %1940 = fpext float %1939 to double
  %1941 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.137, double noundef %1936, double noundef %1938, double noundef %1940)
  call void @llvm.lifetime.end.p0(i64 16, ptr %227) #6
  br label %1942

1942:                                             ; preds = %1921, %1918
  call void @llvm.lifetime.end.p0(i64 4, ptr %225) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %221) #6
  %1943 = load ptr, ptr %2, align 8, !tbaa !5
  %1944 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1943, i32 0, i32 0
  %1945 = load i32, ptr %1944, align 4, !tbaa !9
  %1946 = add nsw i32 %1945, 1
  store i32 %1946, ptr %1944, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %228) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %229) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %230, ptr align 16 %178, i64 64, i1 false), !tbaa.struct !12
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %231, ptr align 16 %120, i64 16, i1 false), !tbaa.struct !14
  %1947 = getelementptr inbounds { double, double }, ptr %231, i32 0, i32 0
  %1948 = load double, ptr %1947, align 16
  %1949 = getelementptr inbounds { double, double }, ptr %231, i32 0, i32 1
  %1950 = load double, ptr %1949, align 8
  %1951 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef byval(%union.HMM_Mat4) align 16 %230, double %1948, double %1950)
  %1952 = getelementptr inbounds %union.HMM_Vec4, ptr %229, i32 0, i32 0
  %1953 = getelementptr inbounds { double, double }, ptr %1952, i32 0, i32 0
  %1954 = extractvalue { double, double } %1951, 0
  store double %1954, ptr %1953, align 16
  %1955 = getelementptr inbounds { double, double }, ptr %1952, i32 0, i32 1
  %1956 = extractvalue { double, double } %1951, 1
  store double %1956, ptr %1955, align 8
  %1957 = getelementptr inbounds %struct.anon.10, ptr %229, i32 0, i32 1
  %1958 = load float, ptr %1957, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %229) #6
  store float %1958, ptr %228, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %232) #6
  %1959 = load float, ptr %228, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 16, ptr %233) #6
  %1960 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1961 = getelementptr inbounds %union.HMM_Vec4, ptr %233, i32 0, i32 0
  %1962 = getelementptr inbounds { double, double }, ptr %1961, i32 0, i32 0
  %1963 = extractvalue { double, double } %1960, 0
  store double %1963, ptr %1962, align 16
  %1964 = getelementptr inbounds { double, double }, ptr %1961, i32 0, i32 1
  %1965 = extractvalue { double, double } %1960, 1
  store double %1965, ptr %1964, align 8
  %1966 = getelementptr inbounds %struct.anon.10, ptr %233, i32 0, i32 1
  %1967 = load float, ptr %1966, align 4, !tbaa !13
  %1968 = fsub float %1959, %1967
  call void @llvm.lifetime.end.p0(i64 16, ptr %233) #6
  store float %1968, ptr %232, align 4, !tbaa !15
  %1969 = load float, ptr %232, align 4, !tbaa !15
  %1970 = fcmp olt float %1969, 0xBE80000000000000
  br i1 %1970, label %1974, label %1971

1971:                                             ; preds = %1942
  %1972 = load float, ptr %232, align 4, !tbaa !15
  %1973 = fcmp olt float 0x3E80000000000000, %1972
  br i1 %1973, label %1974, label %1994

1974:                                             ; preds = %1971, %1942
  %1975 = load ptr, ptr %2, align 8, !tbaa !5
  %1976 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %1975, i32 0, i32 1
  %1977 = load i32, ptr %1976, align 4, !tbaa !17
  %1978 = add nsw i32 %1977, 1
  store i32 %1978, ptr %1976, align 4, !tbaa !17
  %1979 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 45)
  call void @llvm.lifetime.start.p0(i64 16, ptr %234) #6
  %1980 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1981 = getelementptr inbounds %union.HMM_Vec4, ptr %234, i32 0, i32 0
  %1982 = getelementptr inbounds { double, double }, ptr %1981, i32 0, i32 0
  %1983 = extractvalue { double, double } %1980, 0
  store double %1983, ptr %1982, align 16
  %1984 = getelementptr inbounds { double, double }, ptr %1981, i32 0, i32 1
  %1985 = extractvalue { double, double } %1980, 1
  store double %1985, ptr %1984, align 8
  %1986 = getelementptr inbounds %struct.anon.10, ptr %234, i32 0, i32 1
  %1987 = load float, ptr %1986, align 4, !tbaa !13
  %1988 = fpext float %1987 to double
  %1989 = load float, ptr %228, align 4, !tbaa !15
  %1990 = fpext float %1989 to double
  %1991 = load float, ptr %232, align 4, !tbaa !15
  %1992 = fpext float %1991 to double
  %1993 = call i32 (ptr, ...) @printf(ptr noundef @.str.49, ptr noundef @.str.138, double noundef %1988, double noundef %1990, double noundef %1992)
  call void @llvm.lifetime.end.p0(i64 16, ptr %234) #6
  br label %1994

1994:                                             ; preds = %1974, %1971
  call void @llvm.lifetime.end.p0(i64 4, ptr %232) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %228) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %178) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %120) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %119) #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 @_ZL22HMM_Orthographic_RH_NOffffff(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, float noundef, float noundef, float noundef, float noundef, float noundef, float noundef) local_unnamed_addr #3

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden void @_ZL22HMM_Orthographic_LH_ZOffffff(ptr dead_on_unwind noalias writable sret(%union.HMM_Mat4) align 16, float noundef, float noundef, 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 @_Z33_hmt_test_Projection_OrthographicP21hmt_testresult_struct(ptr noundef %0) local_unnamed_addr #4 {
  %2 = alloca %union.HMM_Mat4, align 16
  %3 = alloca %union.HMM_Mat4, align 16
  %4 = alloca %union.HMM_Mat4, align 16
  %5 = alloca %union.HMM_Mat4, align 16
  %6 = tail call { double, double } @_ZL6HMM_V4ffff(float noundef -8.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 = tail call { double, double } @_ZL6HMM_V4ffff(float noundef 1.200000e+01, float noundef 1.000000e+01, float noundef -1.000000e+02, float noundef 1.000000e+00)
  %10 = extractvalue { double, double } %9, 0
  %11 = extractvalue { double, double } %9, 1
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %2) #6
  call void @_ZL22HMM_Orthographic_RH_NOffffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %2, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %12 = load i32, ptr %0, align 4, !tbaa !5
  %13 = add nsw i32 %12, 1
  store i32 %13, ptr %0, align 4, !tbaa !5
  %14 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %2, double %7, double %8)
  %15 = extractvalue { double, double } %14, 0
  %16 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %17 = extractvalue { double, double } %16, 0
  %18 = insertelement <2 x double> poison, double %15, i64 0
  %19 = insertelement <2 x double> %18, double %17, i64 1
  %20 = bitcast <2 x double> %19 to <2 x i64>
  %21 = trunc <2 x i64> %20 to <2 x i32>
  %22 = bitcast <2 x i32> %21 to <2 x float>
  %shift = shufflevector <2 x float> %22, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %23 = fsub <2 x float> %22, %shift
  %24 = extractelement <2 x float> %23, i64 0
  %25 = call float @llvm.fabs.f32(float %24)
  %or.cond = fcmp ogt float %25, 0x3E80000000000000
  br i1 %or.cond, label %26, label %41

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

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

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

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

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

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

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

135:                                              ; preds = %103, %119
  %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 %2, double %10, double %11)
  %139 = extractvalue { double, double } %138, 0
  %140 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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>
  %shift621 = shufflevector <2 x float> %146, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %147 = fsub <2 x float> %146, %shift621
  %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 = %135
  %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 17)
  %156 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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 = %135, %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 %2, double %10, double %11)
  %169 = extractvalue { double, double } %168, 0
  %170 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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>
  %shift622 = shufflevector <2 x float> %177, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %178 = fsub <2 x float> %177, %shift622
  %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 17)
  %187 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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 %2, double %10, double %11)
  %201 = extractvalue { double, double } %200, 1
  %202 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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>
  %shift623 = shufflevector <2 x float> %208, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %209 = fsub <2 x float> %208, %shift623
  %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 17)
  %218 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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 %2, double %10, double %11)
  %231 = extractvalue { double, double } %230, 1
  %232 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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>
  %shift624 = shufflevector <2 x float> %239, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %240 = fsub <2 x float> %239, %shift624
  %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 17)
  %249 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.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 %2) #6
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %3) #6
  call void @_ZL22HMM_Orthographic_RH_ZOffffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %3, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %260 = load i32, ptr %0, align 4, !tbaa !5
  %261 = add nsw i32 %260, 1
  store i32 %261, ptr %0, align 4, !tbaa !5
  %262 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %7, double %8)
  %263 = extractvalue { double, double } %262, 0
  %264 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %265 = extractvalue { double, double } %264, 0
  %266 = insertelement <2 x double> poison, double %263, i64 0
  %267 = insertelement <2 x double> %266, double %265, i64 1
  %268 = bitcast <2 x double> %267 to <2 x i64>
  %269 = trunc <2 x i64> %268 to <2 x i32>
  %270 = bitcast <2 x i32> %269 to <2 x float>
  %shift625 = shufflevector <2 x float> %270, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %271 = fsub <2 x float> %270, %shift625
  %272 = extractelement <2 x float> %271, i64 0
  %273 = call float @llvm.fabs.f32(float %272)
  %or.cond17 = fcmp ogt float %273, 0x3E80000000000000
  br i1 %or.cond17, label %274, label %289

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

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

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

321:                                              ; preds = %289, %305
  %322 = load i32, ptr %0, align 4, !tbaa !5
  %323 = add nsw i32 %322, 1
  store i32 %323, ptr %0, align 4, !tbaa !5
  %324 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %7, double %8)
  %325 = extractvalue { double, double } %324, 1
  %326 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %327 = extractvalue { double, double } %326, 1
  %328 = insertelement <2 x double> poison, double %325, i64 0
  %329 = insertelement <2 x double> %328, double %327, i64 1
  %330 = bitcast <2 x double> %329 to <2 x i64>
  %331 = trunc <2 x i64> %330 to <2 x i32>
  %332 = bitcast <2 x i32> %331 to <2 x float>
  %shift627 = shufflevector <2 x float> %332, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %333 = fsub <2 x float> %332, %shift627
  %334 = extractelement <2 x float> %333, i64 0
  %335 = call float @llvm.fabs.f32(float %334)
  %or.cond21 = fcmp ogt float %335, 0x3E80000000000000
  br i1 %or.cond21, label %336, label %351

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

351:                                              ; preds = %321, %336
  %352 = load i32, ptr %0, align 4, !tbaa !5
  %353 = add nsw i32 %352, 1
  store i32 %353, ptr %0, align 4, !tbaa !5
  %354 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %7, double %8)
  %355 = extractvalue { double, double } %354, 1
  %356 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %357 = extractvalue { double, double } %356, 1
  %358 = insertelement <2 x double> poison, double %355, i64 0
  %359 = insertelement <2 x double> %358, double %357, i64 1
  %360 = bitcast <2 x double> %359 to <2 x i64>
  %361 = lshr <2 x i64> %360, <i64 32, i64 32>
  %362 = trunc nuw <2 x i64> %361 to <2 x i32>
  %363 = bitcast <2 x i32> %362 to <2 x float>
  %shift628 = shufflevector <2 x float> %363, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %364 = fsub <2 x float> %363, %shift628
  %365 = extractelement <2 x float> %364, i64 0
  %366 = call float @llvm.fabs.f32(float %365)
  %or.cond23 = fcmp ogt float %366, 0x3E80000000000000
  br i1 %or.cond23, label %367, label %383

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

383:                                              ; preds = %351, %367
  %384 = load i32, ptr %0, align 4, !tbaa !5
  %385 = add nsw i32 %384, 1
  store i32 %385, ptr %0, align 4, !tbaa !5
  %386 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %10, double %11)
  %387 = extractvalue { double, double } %386, 0
  %388 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %389 = extractvalue { double, double } %388, 0
  %390 = insertelement <2 x double> poison, double %387, i64 0
  %391 = insertelement <2 x double> %390, double %389, i64 1
  %392 = bitcast <2 x double> %391 to <2 x i64>
  %393 = trunc <2 x i64> %392 to <2 x i32>
  %394 = bitcast <2 x i32> %393 to <2 x float>
  %shift629 = shufflevector <2 x float> %394, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %395 = fsub <2 x float> %394, %shift629
  %396 = extractelement <2 x float> %395, i64 0
  %397 = call float @llvm.fabs.f32(float %396)
  %or.cond25 = fcmp ogt float %397, 0x3E80000000000000
  br i1 %or.cond25, label %398, label %413

398:                                              ; preds = %383
  %399 = extractelement <2 x float> %394, i64 0
  %400 = getelementptr inbounds i8, ptr %0, i64 4
  %401 = load i32, ptr %400, align 4, !tbaa !10
  %402 = add nsw i32 %401, 1
  store i32 %402, ptr %400, align 4, !tbaa !10
  %403 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 24)
  %404 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %405 = extractvalue { double, double } %404, 0
  %406 = bitcast double %405 to i64
  %407 = trunc i64 %406 to i32
  %408 = bitcast i32 %407 to float
  %409 = fpext float %408 to double
  %410 = fpext float %399 to double
  %411 = fpext float %396 to double
  %412 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %409, double noundef %410, double noundef %411)
  br label %413

413:                                              ; preds = %383, %398
  %414 = load i32, ptr %0, align 4, !tbaa !5
  %415 = add nsw i32 %414, 1
  store i32 %415, ptr %0, align 4, !tbaa !5
  %416 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %10, double %11)
  %417 = extractvalue { double, double } %416, 0
  %418 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %419 = extractvalue { double, double } %418, 0
  %420 = insertelement <2 x double> poison, double %417, i64 0
  %421 = insertelement <2 x double> %420, double %419, i64 1
  %422 = bitcast <2 x double> %421 to <2 x i64>
  %423 = lshr <2 x i64> %422, <i64 32, i64 32>
  %424 = trunc nuw <2 x i64> %423 to <2 x i32>
  %425 = bitcast <2 x i32> %424 to <2 x float>
  %shift630 = shufflevector <2 x float> %425, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %426 = fsub <2 x float> %425, %shift630
  %427 = extractelement <2 x float> %426, i64 0
  %428 = call float @llvm.fabs.f32(float %427)
  %or.cond27 = fcmp ogt float %428, 0x3E80000000000000
  br i1 %or.cond27, label %429, label %445

429:                                              ; preds = %413
  %430 = extractelement <2 x float> %425, i64 0
  %431 = getelementptr inbounds i8, ptr %0, i64 4
  %432 = load i32, ptr %431, align 4, !tbaa !10
  %433 = add nsw i32 %432, 1
  store i32 %433, ptr %431, align 4, !tbaa !10
  %434 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 24)
  %435 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %436 = extractvalue { double, double } %435, 0
  %437 = bitcast double %436 to i64
  %438 = lshr i64 %437, 32
  %439 = trunc nuw i64 %438 to i32
  %440 = bitcast i32 %439 to float
  %441 = fpext float %440 to double
  %442 = fpext float %430 to double
  %443 = fpext float %427 to double
  %444 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %441, double noundef %442, double noundef %443)
  br label %445

445:                                              ; preds = %413, %429
  %446 = load i32, ptr %0, align 4, !tbaa !5
  %447 = add nsw i32 %446, 1
  store i32 %447, ptr %0, align 4, !tbaa !5
  %448 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %10, double %11)
  %449 = extractvalue { double, double } %448, 1
  %450 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %451 = extractvalue { double, double } %450, 1
  %452 = insertelement <2 x double> poison, double %449, i64 0
  %453 = insertelement <2 x double> %452, double %451, i64 1
  %454 = bitcast <2 x double> %453 to <2 x i64>
  %455 = trunc <2 x i64> %454 to <2 x i32>
  %456 = bitcast <2 x i32> %455 to <2 x float>
  %shift631 = shufflevector <2 x float> %456, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %457 = fsub <2 x float> %456, %shift631
  %458 = extractelement <2 x float> %457, i64 0
  %459 = call float @llvm.fabs.f32(float %458)
  %or.cond29 = fcmp ogt float %459, 0x3E80000000000000
  br i1 %or.cond29, label %460, label %475

460:                                              ; preds = %445
  %461 = extractelement <2 x float> %456, i64 0
  %462 = getelementptr inbounds i8, ptr %0, i64 4
  %463 = load i32, ptr %462, align 4, !tbaa !10
  %464 = add nsw i32 %463, 1
  store i32 %464, ptr %462, align 4, !tbaa !10
  %465 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 24)
  %466 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %467 = extractvalue { double, double } %466, 1
  %468 = bitcast double %467 to i64
  %469 = trunc i64 %468 to i32
  %470 = bitcast i32 %469 to float
  %471 = fpext float %470 to double
  %472 = fpext float %461 to double
  %473 = fpext float %458 to double
  %474 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %471, double noundef %472, double noundef %473)
  br label %475

475:                                              ; preds = %445, %460
  %476 = load i32, ptr %0, align 4, !tbaa !5
  %477 = add nsw i32 %476, 1
  store i32 %477, ptr %0, align 4, !tbaa !5
  %478 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %3, double %10, double %11)
  %479 = extractvalue { double, double } %478, 1
  %480 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %481 = extractvalue { double, double } %480, 1
  %482 = insertelement <2 x double> poison, double %479, i64 0
  %483 = insertelement <2 x double> %482, double %481, i64 1
  %484 = bitcast <2 x double> %483 to <2 x i64>
  %485 = lshr <2 x i64> %484, <i64 32, i64 32>
  %486 = trunc nuw <2 x i64> %485 to <2 x i32>
  %487 = bitcast <2 x i32> %486 to <2 x float>
  %shift632 = shufflevector <2 x float> %487, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %488 = fsub <2 x float> %487, %shift632
  %489 = extractelement <2 x float> %488, i64 0
  %490 = call float @llvm.fabs.f32(float %489)
  %or.cond31 = fcmp ogt float %490, 0x3E80000000000000
  br i1 %or.cond31, label %491, label %507

491:                                              ; preds = %475
  %492 = extractelement <2 x float> %487, i64 0
  %493 = getelementptr inbounds i8, ptr %0, i64 4
  %494 = load i32, ptr %493, align 4, !tbaa !10
  %495 = add nsw i32 %494, 1
  store i32 %495, ptr %493, align 4, !tbaa !10
  %496 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 24)
  %497 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %498 = extractvalue { double, double } %497, 1
  %499 = bitcast double %498 to i64
  %500 = lshr i64 %499, 32
  %501 = trunc nuw i64 %500 to i32
  %502 = bitcast i32 %501 to float
  %503 = fpext float %502 to double
  %504 = fpext float %492 to double
  %505 = fpext float %489 to double
  %506 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %503, double noundef %504, double noundef %505)
  br label %507

507:                                              ; preds = %475, %491
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #6
  %508 = call { double, double } @_ZL6HMM_V4ffff(float noundef -8.000000e+00, float noundef 5.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %509 = extractvalue { double, double } %508, 0
  %510 = extractvalue { double, double } %508, 1
  %511 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.200000e+01, float noundef 1.000000e+01, float noundef 1.000000e+02, float noundef 1.000000e+00)
  %512 = extractvalue { double, double } %511, 0
  %513 = extractvalue { double, double } %511, 1
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #6
  call void @_ZL22HMM_Orthographic_LH_NOffffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %4, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %514 = load i32, ptr %0, align 4, !tbaa !5
  %515 = add nsw i32 %514, 1
  store i32 %515, ptr %0, align 4, !tbaa !5
  %516 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %509, double %510)
  %517 = extractvalue { double, double } %516, 0
  %518 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %519 = extractvalue { double, double } %518, 0
  %520 = insertelement <2 x double> poison, double %517, i64 0
  %521 = insertelement <2 x double> %520, double %519, i64 1
  %522 = bitcast <2 x double> %521 to <2 x i64>
  %523 = trunc <2 x i64> %522 to <2 x i32>
  %524 = bitcast <2 x i32> %523 to <2 x float>
  %shift633 = shufflevector <2 x float> %524, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %525 = fsub <2 x float> %524, %shift633
  %526 = extractelement <2 x float> %525, i64 0
  %527 = call float @llvm.fabs.f32(float %526)
  %or.cond33 = fcmp ogt float %527, 0x3E80000000000000
  br i1 %or.cond33, label %528, label %543

528:                                              ; preds = %507
  %529 = extractelement <2 x float> %524, i64 0
  %530 = getelementptr inbounds i8, ptr %0, i64 4
  %531 = load i32, ptr %530, align 4, !tbaa !10
  %532 = add nsw i32 %531, 1
  store i32 %532, ptr %530, align 4, !tbaa !10
  %533 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 37)
  %534 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %535 = extractvalue { double, double } %534, 0
  %536 = bitcast double %535 to i64
  %537 = trunc i64 %536 to i32
  %538 = bitcast i32 %537 to float
  %539 = fpext float %538 to double
  %540 = fpext float %529 to double
  %541 = fpext float %526 to double
  %542 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %539, double noundef %540, double noundef %541)
  br label %543

543:                                              ; preds = %507, %528
  %544 = load i32, ptr %0, align 4, !tbaa !5
  %545 = add nsw i32 %544, 1
  store i32 %545, ptr %0, align 4, !tbaa !5
  %546 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %509, double %510)
  %547 = extractvalue { double, double } %546, 0
  %548 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %549 = extractvalue { double, double } %548, 0
  %550 = insertelement <2 x double> poison, double %547, i64 0
  %551 = insertelement <2 x double> %550, double %549, i64 1
  %552 = bitcast <2 x double> %551 to <2 x i64>
  %553 = lshr <2 x i64> %552, <i64 32, i64 32>
  %554 = trunc nuw <2 x i64> %553 to <2 x i32>
  %555 = bitcast <2 x i32> %554 to <2 x float>
  %shift634 = shufflevector <2 x float> %555, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %556 = fsub <2 x float> %555, %shift634
  %557 = extractelement <2 x float> %556, i64 0
  %558 = call float @llvm.fabs.f32(float %557)
  %or.cond35 = fcmp ogt float %558, 0x3E80000000000000
  br i1 %or.cond35, label %559, label %575

559:                                              ; preds = %543
  %560 = extractelement <2 x float> %555, i64 0
  %561 = getelementptr inbounds i8, ptr %0, i64 4
  %562 = load i32, ptr %561, align 4, !tbaa !10
  %563 = add nsw i32 %562, 1
  store i32 %563, ptr %561, align 4, !tbaa !10
  %564 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 37)
  %565 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %566 = extractvalue { double, double } %565, 0
  %567 = bitcast double %566 to i64
  %568 = lshr i64 %567, 32
  %569 = trunc nuw i64 %568 to i32
  %570 = bitcast i32 %569 to float
  %571 = fpext float %570 to double
  %572 = fpext float %560 to double
  %573 = fpext float %557 to double
  %574 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %571, double noundef %572, double noundef %573)
  br label %575

575:                                              ; preds = %543, %559
  %576 = load i32, ptr %0, align 4, !tbaa !5
  %577 = add nsw i32 %576, 1
  store i32 %577, ptr %0, align 4, !tbaa !5
  %578 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %509, double %510)
  %579 = extractvalue { double, double } %578, 1
  %580 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %581 = extractvalue { double, double } %580, 1
  %582 = insertelement <2 x double> poison, double %579, i64 0
  %583 = insertelement <2 x double> %582, double %581, i64 1
  %584 = bitcast <2 x double> %583 to <2 x i64>
  %585 = trunc <2 x i64> %584 to <2 x i32>
  %586 = bitcast <2 x i32> %585 to <2 x float>
  %shift635 = shufflevector <2 x float> %586, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %587 = fsub <2 x float> %586, %shift635
  %588 = extractelement <2 x float> %587, i64 0
  %589 = call float @llvm.fabs.f32(float %588)
  %or.cond37 = fcmp ogt float %589, 0x3E80000000000000
  br i1 %or.cond37, label %590, label %605

590:                                              ; preds = %575
  %591 = extractelement <2 x float> %586, i64 0
  %592 = getelementptr inbounds i8, ptr %0, i64 4
  %593 = load i32, ptr %592, align 4, !tbaa !10
  %594 = add nsw i32 %593, 1
  store i32 %594, ptr %592, align 4, !tbaa !10
  %595 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 37)
  %596 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %597 = extractvalue { double, double } %596, 1
  %598 = bitcast double %597 to i64
  %599 = trunc i64 %598 to i32
  %600 = bitcast i32 %599 to float
  %601 = fpext float %600 to double
  %602 = fpext float %591 to double
  %603 = fpext float %588 to double
  %604 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %601, double noundef %602, double noundef %603)
  br label %605

605:                                              ; preds = %575, %590
  %606 = load i32, ptr %0, align 4, !tbaa !5
  %607 = add nsw i32 %606, 1
  store i32 %607, ptr %0, align 4, !tbaa !5
  %608 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %509, double %510)
  %609 = extractvalue { double, double } %608, 1
  %610 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %611 = extractvalue { double, double } %610, 1
  %612 = insertelement <2 x double> poison, double %609, i64 0
  %613 = insertelement <2 x double> %612, double %611, i64 1
  %614 = bitcast <2 x double> %613 to <2 x i64>
  %615 = lshr <2 x i64> %614, <i64 32, i64 32>
  %616 = trunc nuw <2 x i64> %615 to <2 x i32>
  %617 = bitcast <2 x i32> %616 to <2 x float>
  %shift636 = shufflevector <2 x float> %617, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %618 = fsub <2 x float> %617, %shift636
  %619 = extractelement <2 x float> %618, i64 0
  %620 = call float @llvm.fabs.f32(float %619)
  %or.cond39 = fcmp ogt float %620, 0x3E80000000000000
  br i1 %or.cond39, label %621, label %637

621:                                              ; preds = %605
  %622 = extractelement <2 x float> %617, i64 0
  %623 = getelementptr inbounds i8, ptr %0, i64 4
  %624 = load i32, ptr %623, align 4, !tbaa !10
  %625 = add nsw i32 %624, 1
  store i32 %625, ptr %623, align 4, !tbaa !10
  %626 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 37)
  %627 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 1.000000e+00)
  %628 = extractvalue { double, double } %627, 1
  %629 = bitcast double %628 to i64
  %630 = lshr i64 %629, 32
  %631 = trunc nuw i64 %630 to i32
  %632 = bitcast i32 %631 to float
  %633 = fpext float %632 to double
  %634 = fpext float %622 to double
  %635 = fpext float %619 to double
  %636 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %633, double noundef %634, double noundef %635)
  br label %637

637:                                              ; preds = %605, %621
  %638 = load i32, ptr %0, align 4, !tbaa !5
  %639 = add nsw i32 %638, 1
  store i32 %639, ptr %0, align 4, !tbaa !5
  %640 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %512, double %513)
  %641 = extractvalue { double, double } %640, 0
  %642 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %643 = extractvalue { double, double } %642, 0
  %644 = insertelement <2 x double> poison, double %641, i64 0
  %645 = insertelement <2 x double> %644, double %643, i64 1
  %646 = bitcast <2 x double> %645 to <2 x i64>
  %647 = trunc <2 x i64> %646 to <2 x i32>
  %648 = bitcast <2 x i32> %647 to <2 x float>
  %shift637 = shufflevector <2 x float> %648, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %649 = fsub <2 x float> %648, %shift637
  %650 = extractelement <2 x float> %649, i64 0
  %651 = call float @llvm.fabs.f32(float %650)
  %or.cond41 = fcmp ogt float %651, 0x3E80000000000000
  br i1 %or.cond41, label %652, label %667

652:                                              ; preds = %637
  %653 = extractelement <2 x float> %648, i64 0
  %654 = getelementptr inbounds i8, ptr %0, i64 4
  %655 = load i32, ptr %654, align 4, !tbaa !10
  %656 = add nsw i32 %655, 1
  store i32 %656, ptr %654, align 4, !tbaa !10
  %657 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 38)
  %658 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %659 = extractvalue { double, double } %658, 0
  %660 = bitcast double %659 to i64
  %661 = trunc i64 %660 to i32
  %662 = bitcast i32 %661 to float
  %663 = fpext float %662 to double
  %664 = fpext float %653 to double
  %665 = fpext float %650 to double
  %666 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %663, double noundef %664, double noundef %665)
  br label %667

667:                                              ; preds = %637, %652
  %668 = load i32, ptr %0, align 4, !tbaa !5
  %669 = add nsw i32 %668, 1
  store i32 %669, ptr %0, align 4, !tbaa !5
  %670 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %512, double %513)
  %671 = extractvalue { double, double } %670, 0
  %672 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %673 = extractvalue { double, double } %672, 0
  %674 = insertelement <2 x double> poison, double %671, i64 0
  %675 = insertelement <2 x double> %674, double %673, i64 1
  %676 = bitcast <2 x double> %675 to <2 x i64>
  %677 = lshr <2 x i64> %676, <i64 32, i64 32>
  %678 = trunc nuw <2 x i64> %677 to <2 x i32>
  %679 = bitcast <2 x i32> %678 to <2 x float>
  %shift638 = shufflevector <2 x float> %679, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %680 = fsub <2 x float> %679, %shift638
  %681 = extractelement <2 x float> %680, i64 0
  %682 = call float @llvm.fabs.f32(float %681)
  %or.cond43 = fcmp ogt float %682, 0x3E80000000000000
  br i1 %or.cond43, label %683, label %699

683:                                              ; preds = %667
  %684 = extractelement <2 x float> %679, i64 0
  %685 = getelementptr inbounds i8, ptr %0, i64 4
  %686 = load i32, ptr %685, align 4, !tbaa !10
  %687 = add nsw i32 %686, 1
  store i32 %687, ptr %685, align 4, !tbaa !10
  %688 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 38)
  %689 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %690 = extractvalue { double, double } %689, 0
  %691 = bitcast double %690 to i64
  %692 = lshr i64 %691, 32
  %693 = trunc nuw i64 %692 to i32
  %694 = bitcast i32 %693 to float
  %695 = fpext float %694 to double
  %696 = fpext float %684 to double
  %697 = fpext float %681 to double
  %698 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %695, double noundef %696, double noundef %697)
  br label %699

699:                                              ; preds = %667, %683
  %700 = load i32, ptr %0, align 4, !tbaa !5
  %701 = add nsw i32 %700, 1
  store i32 %701, ptr %0, align 4, !tbaa !5
  %702 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %512, double %513)
  %703 = extractvalue { double, double } %702, 1
  %704 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %705 = extractvalue { double, double } %704, 1
  %706 = insertelement <2 x double> poison, double %703, i64 0
  %707 = insertelement <2 x double> %706, double %705, i64 1
  %708 = bitcast <2 x double> %707 to <2 x i64>
  %709 = trunc <2 x i64> %708 to <2 x i32>
  %710 = bitcast <2 x i32> %709 to <2 x float>
  %shift639 = shufflevector <2 x float> %710, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %711 = fsub <2 x float> %710, %shift639
  %712 = extractelement <2 x float> %711, i64 0
  %713 = call float @llvm.fabs.f32(float %712)
  %or.cond45 = fcmp ogt float %713, 0x3E80000000000000
  br i1 %or.cond45, label %714, label %729

714:                                              ; preds = %699
  %715 = extractelement <2 x float> %710, i64 0
  %716 = getelementptr inbounds i8, ptr %0, i64 4
  %717 = load i32, ptr %716, align 4, !tbaa !10
  %718 = add nsw i32 %717, 1
  store i32 %718, ptr %716, align 4, !tbaa !10
  %719 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 38)
  %720 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %721 = extractvalue { double, double } %720, 1
  %722 = bitcast double %721 to i64
  %723 = trunc i64 %722 to i32
  %724 = bitcast i32 %723 to float
  %725 = fpext float %724 to double
  %726 = fpext float %715 to double
  %727 = fpext float %712 to double
  %728 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %725, double noundef %726, double noundef %727)
  br label %729

729:                                              ; preds = %699, %714
  %730 = load i32, ptr %0, align 4, !tbaa !5
  %731 = add nsw i32 %730, 1
  store i32 %731, ptr %0, align 4, !tbaa !5
  %732 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %4, double %512, double %513)
  %733 = extractvalue { double, double } %732, 1
  %734 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %735 = extractvalue { double, double } %734, 1
  %736 = insertelement <2 x double> poison, double %733, i64 0
  %737 = insertelement <2 x double> %736, double %735, i64 1
  %738 = bitcast <2 x double> %737 to <2 x i64>
  %739 = lshr <2 x i64> %738, <i64 32, i64 32>
  %740 = trunc nuw <2 x i64> %739 to <2 x i32>
  %741 = bitcast <2 x i32> %740 to <2 x float>
  %shift640 = shufflevector <2 x float> %741, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %742 = fsub <2 x float> %741, %shift640
  %743 = extractelement <2 x float> %742, i64 0
  %744 = call float @llvm.fabs.f32(float %743)
  %or.cond47 = fcmp ogt float %744, 0x3E80000000000000
  br i1 %or.cond47, label %745, label %761

745:                                              ; preds = %729
  %746 = extractelement <2 x float> %741, i64 0
  %747 = getelementptr inbounds i8, ptr %0, i64 4
  %748 = load i32, ptr %747, align 4, !tbaa !10
  %749 = add nsw i32 %748, 1
  store i32 %749, ptr %747, align 4, !tbaa !10
  %750 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 38)
  %751 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %752 = extractvalue { double, double } %751, 1
  %753 = bitcast double %752 to i64
  %754 = lshr i64 %753, 32
  %755 = trunc nuw i64 %754 to i32
  %756 = bitcast i32 %755 to float
  %757 = fpext float %756 to double
  %758 = fpext float %746 to double
  %759 = fpext float %743 to double
  %760 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %757, double noundef %758, double noundef %759)
  br label %761

761:                                              ; preds = %729, %745
  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 @_ZL22HMM_Orthographic_LH_ZOffffff(ptr dead_on_unwind nonnull writable sret(%union.HMM_Mat4) align 16 %5, float noundef -8.000000e+00, float noundef 1.200000e+01, float noundef 5.000000e+00, float noundef 1.000000e+01, float noundef 1.000000e+00, float noundef 1.000000e+02)
  %762 = load i32, ptr %0, align 4, !tbaa !5
  %763 = add nsw i32 %762, 1
  store i32 %763, ptr %0, align 4, !tbaa !5
  %764 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %509, double %510)
  %765 = extractvalue { double, double } %764, 0
  %766 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %767 = extractvalue { double, double } %766, 0
  %768 = insertelement <2 x double> poison, double %765, i64 0
  %769 = insertelement <2 x double> %768, double %767, i64 1
  %770 = bitcast <2 x double> %769 to <2 x i64>
  %771 = trunc <2 x i64> %770 to <2 x i32>
  %772 = bitcast <2 x i32> %771 to <2 x float>
  %shift641 = shufflevector <2 x float> %772, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %773 = fsub <2 x float> %772, %shift641
  %774 = extractelement <2 x float> %773, i64 0
  %775 = call float @llvm.fabs.f32(float %774)
  %or.cond49 = fcmp ogt float %775, 0x3E80000000000000
  br i1 %or.cond49, label %776, label %791

776:                                              ; preds = %761
  %777 = extractelement <2 x float> %772, i64 0
  %778 = getelementptr inbounds i8, ptr %0, i64 4
  %779 = load i32, ptr %778, align 4, !tbaa !10
  %780 = add nsw i32 %779, 1
  store i32 %780, ptr %778, align 4, !tbaa !10
  %781 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 44)
  %782 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %783 = extractvalue { double, double } %782, 0
  %784 = bitcast double %783 to i64
  %785 = trunc i64 %784 to i32
  %786 = bitcast i32 %785 to float
  %787 = fpext float %786 to double
  %788 = fpext float %777 to double
  %789 = fpext float %774 to double
  %790 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %787, double noundef %788, double noundef %789)
  br label %791

791:                                              ; preds = %761, %776
  %792 = load i32, ptr %0, align 4, !tbaa !5
  %793 = add nsw i32 %792, 1
  store i32 %793, ptr %0, align 4, !tbaa !5
  %794 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %509, double %510)
  %795 = extractvalue { double, double } %794, 0
  %796 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %797 = extractvalue { double, double } %796, 0
  %798 = insertelement <2 x double> poison, double %795, i64 0
  %799 = insertelement <2 x double> %798, double %797, i64 1
  %800 = bitcast <2 x double> %799 to <2 x i64>
  %801 = lshr <2 x i64> %800, <i64 32, i64 32>
  %802 = trunc nuw <2 x i64> %801 to <2 x i32>
  %803 = bitcast <2 x i32> %802 to <2 x float>
  %shift642 = shufflevector <2 x float> %803, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %804 = fsub <2 x float> %803, %shift642
  %805 = extractelement <2 x float> %804, i64 0
  %806 = call float @llvm.fabs.f32(float %805)
  %or.cond51 = fcmp ogt float %806, 0x3E80000000000000
  br i1 %or.cond51, label %807, label %823

807:                                              ; preds = %791
  %808 = extractelement <2 x float> %803, i64 0
  %809 = getelementptr inbounds i8, ptr %0, i64 4
  %810 = load i32, ptr %809, align 4, !tbaa !10
  %811 = add nsw i32 %810, 1
  store i32 %811, ptr %809, align 4, !tbaa !10
  %812 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 44)
  %813 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %814 = extractvalue { double, double } %813, 0
  %815 = bitcast double %814 to i64
  %816 = lshr i64 %815, 32
  %817 = trunc nuw i64 %816 to i32
  %818 = bitcast i32 %817 to float
  %819 = fpext float %818 to double
  %820 = fpext float %808 to double
  %821 = fpext float %805 to double
  %822 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %819, double noundef %820, double noundef %821)
  br label %823

823:                                              ; preds = %791, %807
  %824 = load i32, ptr %0, align 4, !tbaa !5
  %825 = add nsw i32 %824, 1
  store i32 %825, ptr %0, align 4, !tbaa !5
  %826 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %509, double %510)
  %827 = extractvalue { double, double } %826, 1
  %828 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %829 = extractvalue { double, double } %828, 1
  %830 = insertelement <2 x double> poison, double %827, i64 0
  %831 = insertelement <2 x double> %830, double %829, i64 1
  %832 = bitcast <2 x double> %831 to <2 x i64>
  %833 = trunc <2 x i64> %832 to <2 x i32>
  %834 = bitcast <2 x i32> %833 to <2 x float>
  %shift643 = shufflevector <2 x float> %834, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %835 = fsub <2 x float> %834, %shift643
  %836 = extractelement <2 x float> %835, i64 0
  %837 = call float @llvm.fabs.f32(float %836)
  %or.cond53 = fcmp ogt float %837, 0x3E80000000000000
  br i1 %or.cond53, label %838, label %853

838:                                              ; preds = %823
  %839 = extractelement <2 x float> %834, i64 0
  %840 = getelementptr inbounds i8, ptr %0, i64 4
  %841 = load i32, ptr %840, align 4, !tbaa !10
  %842 = add nsw i32 %841, 1
  store i32 %842, ptr %840, align 4, !tbaa !10
  %843 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 44)
  %844 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %845 = extractvalue { double, double } %844, 1
  %846 = bitcast double %845 to i64
  %847 = trunc i64 %846 to i32
  %848 = bitcast i32 %847 to float
  %849 = fpext float %848 to double
  %850 = fpext float %839 to double
  %851 = fpext float %836 to double
  %852 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %849, double noundef %850, double noundef %851)
  br label %853

853:                                              ; preds = %823, %838
  %854 = load i32, ptr %0, align 4, !tbaa !5
  %855 = add nsw i32 %854, 1
  store i32 %855, ptr %0, align 4, !tbaa !5
  %856 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %509, double %510)
  %857 = extractvalue { double, double } %856, 1
  %858 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %859 = extractvalue { double, double } %858, 1
  %860 = insertelement <2 x double> poison, double %857, i64 0
  %861 = insertelement <2 x double> %860, double %859, i64 1
  %862 = bitcast <2 x double> %861 to <2 x i64>
  %863 = lshr <2 x i64> %862, <i64 32, i64 32>
  %864 = trunc nuw <2 x i64> %863 to <2 x i32>
  %865 = bitcast <2 x i32> %864 to <2 x float>
  %shift644 = shufflevector <2 x float> %865, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %866 = fsub <2 x float> %865, %shift644
  %867 = extractelement <2 x float> %866, i64 0
  %868 = call float @llvm.fabs.f32(float %867)
  %or.cond55 = fcmp ogt float %868, 0x3E80000000000000
  br i1 %or.cond55, label %869, label %885

869:                                              ; preds = %853
  %870 = extractelement <2 x float> %865, i64 0
  %871 = getelementptr inbounds i8, ptr %0, i64 4
  %872 = load i32, ptr %871, align 4, !tbaa !10
  %873 = add nsw i32 %872, 1
  store i32 %873, ptr %871, align 4, !tbaa !10
  %874 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 44)
  %875 = call { double, double } @_ZL6HMM_V4ffff(float noundef -1.000000e+00, float noundef -1.000000e+00, float noundef 0.000000e+00, float noundef 1.000000e+00)
  %876 = extractvalue { double, double } %875, 1
  %877 = bitcast double %876 to i64
  %878 = lshr i64 %877, 32
  %879 = trunc nuw i64 %878 to i32
  %880 = bitcast i32 %879 to float
  %881 = fpext float %880 to double
  %882 = fpext float %870 to double
  %883 = fpext float %867 to double
  %884 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %881, double noundef %882, double noundef %883)
  br label %885

885:                                              ; preds = %853, %869
  %886 = load i32, ptr %0, align 4, !tbaa !5
  %887 = add nsw i32 %886, 1
  store i32 %887, ptr %0, align 4, !tbaa !5
  %888 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %512, double %513)
  %889 = extractvalue { double, double } %888, 0
  %890 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %891 = extractvalue { double, double } %890, 0
  %892 = insertelement <2 x double> poison, double %889, i64 0
  %893 = insertelement <2 x double> %892, double %891, i64 1
  %894 = bitcast <2 x double> %893 to <2 x i64>
  %895 = trunc <2 x i64> %894 to <2 x i32>
  %896 = bitcast <2 x i32> %895 to <2 x float>
  %shift645 = shufflevector <2 x float> %896, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %897 = fsub <2 x float> %896, %shift645
  %898 = extractelement <2 x float> %897, i64 0
  %899 = call float @llvm.fabs.f32(float %898)
  %or.cond57 = fcmp ogt float %899, 0x3E80000000000000
  br i1 %or.cond57, label %900, label %915

900:                                              ; preds = %885
  %901 = extractelement <2 x float> %896, i64 0
  %902 = getelementptr inbounds i8, ptr %0, i64 4
  %903 = load i32, ptr %902, align 4, !tbaa !10
  %904 = add nsw i32 %903, 1
  store i32 %904, ptr %902, align 4, !tbaa !10
  %905 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 45)
  %906 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %907 = extractvalue { double, double } %906, 0
  %908 = bitcast double %907 to i64
  %909 = trunc i64 %908 to i32
  %910 = bitcast i32 %909 to float
  %911 = fpext float %910 to double
  %912 = fpext float %901 to double
  %913 = fpext float %898 to double
  %914 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.135, double noundef %911, double noundef %912, double noundef %913)
  br label %915

915:                                              ; preds = %885, %900
  %916 = load i32, ptr %0, align 4, !tbaa !5
  %917 = add nsw i32 %916, 1
  store i32 %917, ptr %0, align 4, !tbaa !5
  %918 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %512, double %513)
  %919 = extractvalue { double, double } %918, 0
  %920 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %921 = extractvalue { double, double } %920, 0
  %922 = insertelement <2 x double> poison, double %919, i64 0
  %923 = insertelement <2 x double> %922, double %921, i64 1
  %924 = bitcast <2 x double> %923 to <2 x i64>
  %925 = lshr <2 x i64> %924, <i64 32, i64 32>
  %926 = trunc nuw <2 x i64> %925 to <2 x i32>
  %927 = bitcast <2 x i32> %926 to <2 x float>
  %shift646 = shufflevector <2 x float> %927, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %928 = fsub <2 x float> %927, %shift646
  %929 = extractelement <2 x float> %928, i64 0
  %930 = call float @llvm.fabs.f32(float %929)
  %or.cond59 = fcmp ogt float %930, 0x3E80000000000000
  br i1 %or.cond59, label %931, label %947

931:                                              ; preds = %915
  %932 = extractelement <2 x float> %927, i64 0
  %933 = getelementptr inbounds i8, ptr %0, i64 4
  %934 = load i32, ptr %933, align 4, !tbaa !10
  %935 = add nsw i32 %934, 1
  store i32 %935, ptr %933, align 4, !tbaa !10
  %936 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 45)
  %937 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %938 = extractvalue { double, double } %937, 0
  %939 = bitcast double %938 to i64
  %940 = lshr i64 %939, 32
  %941 = trunc nuw i64 %940 to i32
  %942 = bitcast i32 %941 to float
  %943 = fpext float %942 to double
  %944 = fpext float %932 to double
  %945 = fpext float %929 to double
  %946 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.136, double noundef %943, double noundef %944, double noundef %945)
  br label %947

947:                                              ; preds = %915, %931
  %948 = load i32, ptr %0, align 4, !tbaa !5
  %949 = add nsw i32 %948, 1
  store i32 %949, ptr %0, align 4, !tbaa !5
  %950 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %512, double %513)
  %951 = extractvalue { double, double } %950, 1
  %952 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %953 = extractvalue { double, double } %952, 1
  %954 = insertelement <2 x double> poison, double %951, i64 0
  %955 = insertelement <2 x double> %954, double %953, i64 1
  %956 = bitcast <2 x double> %955 to <2 x i64>
  %957 = trunc <2 x i64> %956 to <2 x i32>
  %958 = bitcast <2 x i32> %957 to <2 x float>
  %shift647 = shufflevector <2 x float> %958, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %959 = fsub <2 x float> %958, %shift647
  %960 = extractelement <2 x float> %959, i64 0
  %961 = call float @llvm.fabs.f32(float %960)
  %or.cond61 = fcmp ogt float %961, 0x3E80000000000000
  br i1 %or.cond61, label %962, label %977

962:                                              ; preds = %947
  %963 = extractelement <2 x float> %958, i64 0
  %964 = getelementptr inbounds i8, ptr %0, i64 4
  %965 = load i32, ptr %964, align 4, !tbaa !10
  %966 = add nsw i32 %965, 1
  store i32 %966, ptr %964, align 4, !tbaa !10
  %967 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 45)
  %968 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %969 = extractvalue { double, double } %968, 1
  %970 = bitcast double %969 to i64
  %971 = trunc i64 %970 to i32
  %972 = bitcast i32 %971 to float
  %973 = fpext float %972 to double
  %974 = fpext float %963 to double
  %975 = fpext float %960 to double
  %976 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.137, double noundef %973, double noundef %974, double noundef %975)
  br label %977

977:                                              ; preds = %947, %962
  %978 = load i32, ptr %0, align 4, !tbaa !5
  %979 = add nsw i32 %978, 1
  store i32 %979, ptr %0, align 4, !tbaa !5
  %980 = call { double, double } @_ZL11HMM_MulM4V48HMM_Mat48HMM_Vec4(ptr noundef nonnull byval(%union.HMM_Mat4) align 16 %5, double %512, double %513)
  %981 = extractvalue { double, double } %980, 1
  %982 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %983 = extractvalue { double, double } %982, 1
  %984 = insertelement <2 x double> poison, double %981, i64 0
  %985 = insertelement <2 x double> %984, double %983, i64 1
  %986 = bitcast <2 x double> %985 to <2 x i64>
  %987 = lshr <2 x i64> %986, <i64 32, i64 32>
  %988 = trunc nuw <2 x i64> %987 to <2 x i32>
  %989 = bitcast <2 x i32> %988 to <2 x float>
  %shift648 = shufflevector <2 x float> %989, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %990 = fsub <2 x float> %989, %shift648
  %991 = extractelement <2 x float> %990, i64 0
  %992 = call float @llvm.fabs.f32(float %991)
  %or.cond63 = fcmp ogt float %992, 0x3E80000000000000
  br i1 %or.cond63, label %993, label %1009

993:                                              ; preds = %977
  %994 = extractelement <2 x float> %989, i64 0
  %995 = getelementptr inbounds i8, ptr %0, i64 4
  %996 = load i32, ptr %995, align 4, !tbaa !10
  %997 = add nsw i32 %996, 1
  store i32 %997, ptr %995, align 4, !tbaa !10
  %998 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 45)
  %999 = call { double, double } @_ZL6HMM_V4ffff(float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00, float noundef 1.000000e+00)
  %1000 = extractvalue { double, double } %999, 1
  %1001 = bitcast double %1000 to i64
  %1002 = lshr i64 %1001, 32
  %1003 = trunc nuw i64 %1002 to i32
  %1004 = bitcast i32 %1003 to float
  %1005 = fpext float %1004 to double
  %1006 = fpext float %994 to double
  %1007 = fpext float %991 to double
  %1008 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.49, ptr noundef nonnull @.str.138, double noundef %1005, double noundef %1006, double noundef %1007)
  br label %1009

1009:                                             ; preds = %977, %993
  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,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass