; LLVM IR from hadryansalles/Luz :: deps/imgui/ImGuizmo.ll (ZN8ImGuizmo8matrix_t7InverseERKS0_b)

; 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"

%"struct.ImGuizmo::matrix_t" = type { %union.anon }
%union.anon = type { [4 x [4 x float]] }

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local noundef float @_ZN8ImGuizmo8matrix_t7InverseERKS0_b(ptr noundef nonnull align 4 dereferenceable(64) %0, ptr noundef nonnull align 4 dereferenceable(64) %1, i1 noundef zeroext %2) #2 align 2 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i8, align 1
  %7 = alloca float, align 4
  %8 = alloca float, align 4
  %9 = alloca [16 x float], align 16
  %10 = alloca i32, align 4
  %11 = alloca [12 x float], align 16
  %12 = alloca float, align 4
  %13 = alloca i32, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  %14 = zext i1 %2 to i8
  store i8 %14, ptr %6, align 1, !tbaa !9
  %15 = load ptr, ptr %4, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #4
  store float 0.000000e+00, ptr %7, align 4, !tbaa !11
  %16 = load i8, ptr %6, align 1, !tbaa !9, !range !13, !noundef !14
  %17 = trunc i8 %16 to i1
  br i1 %17, label %18, label %376

18:                                               ; preds = %3
  %19 = call noundef float @_ZNK8ImGuizmo8matrix_t14GetDeterminantEv(ptr noundef nonnull align 4 dereferenceable(64) %15)
  store float %19, ptr %7, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #4
  %20 = load float, ptr %7, align 4, !tbaa !11
  %21 = fdiv float 1.000000e+00, %20
  store float %21, ptr %8, align 4, !tbaa !11
  %22 = load ptr, ptr %5, align 8, !tbaa !5
  %23 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %22, i32 0, i32 0
  %24 = getelementptr inbounds [4 x [4 x float]], ptr %23, i64 0, i64 1
  %25 = getelementptr inbounds [4 x float], ptr %24, i64 0, i64 1
  %26 = load float, ptr %25, align 4, !tbaa !15
  %27 = load ptr, ptr %5, align 8, !tbaa !5
  %28 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %27, i32 0, i32 0
  %29 = getelementptr inbounds [4 x [4 x float]], ptr %28, i64 0, i64 2
  %30 = getelementptr inbounds [4 x float], ptr %29, i64 0, i64 2
  %31 = load float, ptr %30, align 4, !tbaa !15
  %32 = load ptr, ptr %5, align 8, !tbaa !5
  %33 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %32, i32 0, i32 0
  %34 = getelementptr inbounds [4 x [4 x float]], ptr %33, i64 0, i64 1
  %35 = getelementptr inbounds [4 x float], ptr %34, i64 0, i64 2
  %36 = load float, ptr %35, align 4, !tbaa !15
  %37 = load ptr, ptr %5, align 8, !tbaa !5
  %38 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %37, i32 0, i32 0
  %39 = getelementptr inbounds [4 x [4 x float]], ptr %38, i64 0, i64 2
  %40 = getelementptr inbounds [4 x float], ptr %39, i64 0, i64 1
  %41 = load float, ptr %40, align 4, !tbaa !15
  %42 = fmul float %36, %41
  %43 = fneg float %42
  %44 = call float @llvm.fmuladd.f32(float %26, float %31, float %43)
  %45 = load float, ptr %8, align 4, !tbaa !11
  %46 = fmul float %44, %45
  %47 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %48 = getelementptr inbounds [4 x [4 x float]], ptr %47, i64 0, i64 0
  %49 = getelementptr inbounds [4 x float], ptr %48, i64 0, i64 0
  store float %46, ptr %49, align 4, !tbaa !15
  %50 = load ptr, ptr %5, align 8, !tbaa !5
  %51 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %50, i32 0, i32 0
  %52 = getelementptr inbounds [4 x [4 x float]], ptr %51, i64 0, i64 2
  %53 = getelementptr inbounds [4 x float], ptr %52, i64 0, i64 1
  %54 = load float, ptr %53, align 4, !tbaa !15
  %55 = load ptr, ptr %5, align 8, !tbaa !5
  %56 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %55, i32 0, i32 0
  %57 = getelementptr inbounds [4 x [4 x float]], ptr %56, i64 0, i64 0
  %58 = getelementptr inbounds [4 x float], ptr %57, i64 0, i64 2
  %59 = load float, ptr %58, align 4, !tbaa !15
  %60 = load ptr, ptr %5, align 8, !tbaa !5
  %61 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %60, i32 0, i32 0
  %62 = getelementptr inbounds [4 x [4 x float]], ptr %61, i64 0, i64 2
  %63 = getelementptr inbounds [4 x float], ptr %62, i64 0, i64 2
  %64 = load float, ptr %63, align 4, !tbaa !15
  %65 = load ptr, ptr %5, align 8, !tbaa !5
  %66 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %65, i32 0, i32 0
  %67 = getelementptr inbounds [4 x [4 x float]], ptr %66, i64 0, i64 0
  %68 = getelementptr inbounds [4 x float], ptr %67, i64 0, i64 1
  %69 = load float, ptr %68, align 4, !tbaa !15
  %70 = fmul float %64, %69
  %71 = fneg float %70
  %72 = call float @llvm.fmuladd.f32(float %54, float %59, float %71)
  %73 = load float, ptr %8, align 4, !tbaa !11
  %74 = fmul float %72, %73
  %75 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %76 = getelementptr inbounds [4 x [4 x float]], ptr %75, i64 0, i64 0
  %77 = getelementptr inbounds [4 x float], ptr %76, i64 0, i64 1
  store float %74, ptr %77, align 4, !tbaa !15
  %78 = load ptr, ptr %5, align 8, !tbaa !5
  %79 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %78, i32 0, i32 0
  %80 = getelementptr inbounds [4 x [4 x float]], ptr %79, i64 0, i64 0
  %81 = getelementptr inbounds [4 x float], ptr %80, i64 0, i64 1
  %82 = load float, ptr %81, align 4, !tbaa !15
  %83 = load ptr, ptr %5, align 8, !tbaa !5
  %84 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %83, i32 0, i32 0
  %85 = getelementptr inbounds [4 x [4 x float]], ptr %84, i64 0, i64 1
  %86 = getelementptr inbounds [4 x float], ptr %85, i64 0, i64 2
  %87 = load float, ptr %86, align 4, !tbaa !15
  %88 = load ptr, ptr %5, align 8, !tbaa !5
  %89 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %88, i32 0, i32 0
  %90 = getelementptr inbounds [4 x [4 x float]], ptr %89, i64 0, i64 0
  %91 = getelementptr inbounds [4 x float], ptr %90, i64 0, i64 2
  %92 = load float, ptr %91, align 4, !tbaa !15
  %93 = load ptr, ptr %5, align 8, !tbaa !5
  %94 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %93, i32 0, i32 0
  %95 = getelementptr inbounds [4 x [4 x float]], ptr %94, i64 0, i64 1
  %96 = getelementptr inbounds [4 x float], ptr %95, i64 0, i64 1
  %97 = load float, ptr %96, align 4, !tbaa !15
  %98 = fmul float %92, %97
  %99 = fneg float %98
  %100 = call float @llvm.fmuladd.f32(float %82, float %87, float %99)
  %101 = load float, ptr %8, align 4, !tbaa !11
  %102 = fmul float %100, %101
  %103 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %104 = getelementptr inbounds [4 x [4 x float]], ptr %103, i64 0, i64 0
  %105 = getelementptr inbounds [4 x float], ptr %104, i64 0, i64 2
  store float %102, ptr %105, align 4, !tbaa !15
  %106 = load ptr, ptr %5, align 8, !tbaa !5
  %107 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %106, i32 0, i32 0
  %108 = getelementptr inbounds [4 x [4 x float]], ptr %107, i64 0, i64 1
  %109 = getelementptr inbounds [4 x float], ptr %108, i64 0, i64 2
  %110 = load float, ptr %109, align 4, !tbaa !15
  %111 = load ptr, ptr %5, align 8, !tbaa !5
  %112 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %111, i32 0, i32 0
  %113 = getelementptr inbounds [4 x [4 x float]], ptr %112, i64 0, i64 2
  %114 = getelementptr inbounds [4 x float], ptr %113, i64 0, i64 0
  %115 = load float, ptr %114, align 4, !tbaa !15
  %116 = load ptr, ptr %5, align 8, !tbaa !5
  %117 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %116, i32 0, i32 0
  %118 = getelementptr inbounds [4 x [4 x float]], ptr %117, i64 0, i64 1
  %119 = getelementptr inbounds [4 x float], ptr %118, i64 0, i64 0
  %120 = load float, ptr %119, align 4, !tbaa !15
  %121 = load ptr, ptr %5, align 8, !tbaa !5
  %122 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %121, i32 0, i32 0
  %123 = getelementptr inbounds [4 x [4 x float]], ptr %122, i64 0, i64 2
  %124 = getelementptr inbounds [4 x float], ptr %123, i64 0, i64 2
  %125 = load float, ptr %124, align 4, !tbaa !15
  %126 = fmul float %120, %125
  %127 = fneg float %126
  %128 = call float @llvm.fmuladd.f32(float %110, float %115, float %127)
  %129 = load float, ptr %8, align 4, !tbaa !11
  %130 = fmul float %128, %129
  %131 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %132 = getelementptr inbounds [4 x [4 x float]], ptr %131, i64 0, i64 1
  %133 = getelementptr inbounds [4 x float], ptr %132, i64 0, i64 0
  store float %130, ptr %133, align 4, !tbaa !15
  %134 = load ptr, ptr %5, align 8, !tbaa !5
  %135 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %134, i32 0, i32 0
  %136 = getelementptr inbounds [4 x [4 x float]], ptr %135, i64 0, i64 2
  %137 = getelementptr inbounds [4 x float], ptr %136, i64 0, i64 2
  %138 = load float, ptr %137, align 4, !tbaa !15
  %139 = load ptr, ptr %5, align 8, !tbaa !5
  %140 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %139, i32 0, i32 0
  %141 = getelementptr inbounds [4 x [4 x float]], ptr %140, i64 0, i64 0
  %142 = getelementptr inbounds [4 x float], ptr %141, i64 0, i64 0
  %143 = load float, ptr %142, align 4, !tbaa !15
  %144 = load ptr, ptr %5, align 8, !tbaa !5
  %145 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %144, i32 0, i32 0
  %146 = getelementptr inbounds [4 x [4 x float]], ptr %145, i64 0, i64 2
  %147 = getelementptr inbounds [4 x float], ptr %146, i64 0, i64 0
  %148 = load float, ptr %147, align 4, !tbaa !15
  %149 = load ptr, ptr %5, align 8, !tbaa !5
  %150 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %149, i32 0, i32 0
  %151 = getelementptr inbounds [4 x [4 x float]], ptr %150, i64 0, i64 0
  %152 = getelementptr inbounds [4 x float], ptr %151, i64 0, i64 2
  %153 = load float, ptr %152, align 4, !tbaa !15
  %154 = fmul float %148, %153
  %155 = fneg float %154
  %156 = call float @llvm.fmuladd.f32(float %138, float %143, float %155)
  %157 = load float, ptr %8, align 4, !tbaa !11
  %158 = fmul float %156, %157
  %159 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %160 = getelementptr inbounds [4 x [4 x float]], ptr %159, i64 0, i64 1
  %161 = getelementptr inbounds [4 x float], ptr %160, i64 0, i64 1
  store float %158, ptr %161, align 4, !tbaa !15
  %162 = load ptr, ptr %5, align 8, !tbaa !5
  %163 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %162, i32 0, i32 0
  %164 = getelementptr inbounds [4 x [4 x float]], ptr %163, i64 0, i64 0
  %165 = getelementptr inbounds [4 x float], ptr %164, i64 0, i64 2
  %166 = load float, ptr %165, align 4, !tbaa !15
  %167 = load ptr, ptr %5, align 8, !tbaa !5
  %168 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %167, i32 0, i32 0
  %169 = getelementptr inbounds [4 x [4 x float]], ptr %168, i64 0, i64 1
  %170 = getelementptr inbounds [4 x float], ptr %169, i64 0, i64 0
  %171 = load float, ptr %170, align 4, !tbaa !15
  %172 = load ptr, ptr %5, align 8, !tbaa !5
  %173 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %172, i32 0, i32 0
  %174 = getelementptr inbounds [4 x [4 x float]], ptr %173, i64 0, i64 0
  %175 = getelementptr inbounds [4 x float], ptr %174, i64 0, i64 0
  %176 = load float, ptr %175, align 4, !tbaa !15
  %177 = load ptr, ptr %5, align 8, !tbaa !5
  %178 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %177, i32 0, i32 0
  %179 = getelementptr inbounds [4 x [4 x float]], ptr %178, i64 0, i64 1
  %180 = getelementptr inbounds [4 x float], ptr %179, i64 0, i64 2
  %181 = load float, ptr %180, align 4, !tbaa !15
  %182 = fmul float %176, %181
  %183 = fneg float %182
  %184 = call float @llvm.fmuladd.f32(float %166, float %171, float %183)
  %185 = load float, ptr %8, align 4, !tbaa !11
  %186 = fmul float %184, %185
  %187 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %188 = getelementptr inbounds [4 x [4 x float]], ptr %187, i64 0, i64 1
  %189 = getelementptr inbounds [4 x float], ptr %188, i64 0, i64 2
  store float %186, ptr %189, align 4, !tbaa !15
  %190 = load ptr, ptr %5, align 8, !tbaa !5
  %191 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %190, i32 0, i32 0
  %192 = getelementptr inbounds [4 x [4 x float]], ptr %191, i64 0, i64 1
  %193 = getelementptr inbounds [4 x float], ptr %192, i64 0, i64 0
  %194 = load float, ptr %193, align 4, !tbaa !15
  %195 = load ptr, ptr %5, align 8, !tbaa !5
  %196 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %195, i32 0, i32 0
  %197 = getelementptr inbounds [4 x [4 x float]], ptr %196, i64 0, i64 2
  %198 = getelementptr inbounds [4 x float], ptr %197, i64 0, i64 1
  %199 = load float, ptr %198, align 4, !tbaa !15
  %200 = load ptr, ptr %5, align 8, !tbaa !5
  %201 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %200, i32 0, i32 0
  %202 = getelementptr inbounds [4 x [4 x float]], ptr %201, i64 0, i64 1
  %203 = getelementptr inbounds [4 x float], ptr %202, i64 0, i64 1
  %204 = load float, ptr %203, align 4, !tbaa !15
  %205 = load ptr, ptr %5, align 8, !tbaa !5
  %206 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %205, i32 0, i32 0
  %207 = getelementptr inbounds [4 x [4 x float]], ptr %206, i64 0, i64 2
  %208 = getelementptr inbounds [4 x float], ptr %207, i64 0, i64 0
  %209 = load float, ptr %208, align 4, !tbaa !15
  %210 = fmul float %204, %209
  %211 = fneg float %210
  %212 = call float @llvm.fmuladd.f32(float %194, float %199, float %211)
  %213 = load float, ptr %8, align 4, !tbaa !11
  %214 = fmul float %212, %213
  %215 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %216 = getelementptr inbounds [4 x [4 x float]], ptr %215, i64 0, i64 2
  %217 = getelementptr inbounds [4 x float], ptr %216, i64 0, i64 0
  store float %214, ptr %217, align 4, !tbaa !15
  %218 = load ptr, ptr %5, align 8, !tbaa !5
  %219 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %218, i32 0, i32 0
  %220 = getelementptr inbounds [4 x [4 x float]], ptr %219, i64 0, i64 2
  %221 = getelementptr inbounds [4 x float], ptr %220, i64 0, i64 0
  %222 = load float, ptr %221, align 4, !tbaa !15
  %223 = load ptr, ptr %5, align 8, !tbaa !5
  %224 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %223, i32 0, i32 0
  %225 = getelementptr inbounds [4 x [4 x float]], ptr %224, i64 0, i64 0
  %226 = getelementptr inbounds [4 x float], ptr %225, i64 0, i64 1
  %227 = load float, ptr %226, align 4, !tbaa !15
  %228 = load ptr, ptr %5, align 8, !tbaa !5
  %229 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %228, i32 0, i32 0
  %230 = getelementptr inbounds [4 x [4 x float]], ptr %229, i64 0, i64 2
  %231 = getelementptr inbounds [4 x float], ptr %230, i64 0, i64 1
  %232 = load float, ptr %231, align 4, !tbaa !15
  %233 = load ptr, ptr %5, align 8, !tbaa !5
  %234 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %233, i32 0, i32 0
  %235 = getelementptr inbounds [4 x [4 x float]], ptr %234, i64 0, i64 0
  %236 = getelementptr inbounds [4 x float], ptr %235, i64 0, i64 0
  %237 = load float, ptr %236, align 4, !tbaa !15
  %238 = fmul float %232, %237
  %239 = fneg float %238
  %240 = call float @llvm.fmuladd.f32(float %222, float %227, float %239)
  %241 = load float, ptr %8, align 4, !tbaa !11
  %242 = fmul float %240, %241
  %243 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %244 = getelementptr inbounds [4 x [4 x float]], ptr %243, i64 0, i64 2
  %245 = getelementptr inbounds [4 x float], ptr %244, i64 0, i64 1
  store float %242, ptr %245, align 4, !tbaa !15
  %246 = load ptr, ptr %5, align 8, !tbaa !5
  %247 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %246, i32 0, i32 0
  %248 = getelementptr inbounds [4 x [4 x float]], ptr %247, i64 0, i64 0
  %249 = getelementptr inbounds [4 x float], ptr %248, i64 0, i64 0
  %250 = load float, ptr %249, align 4, !tbaa !15
  %251 = load ptr, ptr %5, align 8, !tbaa !5
  %252 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %251, i32 0, i32 0
  %253 = getelementptr inbounds [4 x [4 x float]], ptr %252, i64 0, i64 1
  %254 = getelementptr inbounds [4 x float], ptr %253, i64 0, i64 1
  %255 = load float, ptr %254, align 4, !tbaa !15
  %256 = load ptr, ptr %5, align 8, !tbaa !5
  %257 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %256, i32 0, i32 0
  %258 = getelementptr inbounds [4 x [4 x float]], ptr %257, i64 0, i64 0
  %259 = getelementptr inbounds [4 x float], ptr %258, i64 0, i64 1
  %260 = load float, ptr %259, align 4, !tbaa !15
  %261 = load ptr, ptr %5, align 8, !tbaa !5
  %262 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %261, i32 0, i32 0
  %263 = getelementptr inbounds [4 x [4 x float]], ptr %262, i64 0, i64 1
  %264 = getelementptr inbounds [4 x float], ptr %263, i64 0, i64 0
  %265 = load float, ptr %264, align 4, !tbaa !15
  %266 = fmul float %260, %265
  %267 = fneg float %266
  %268 = call float @llvm.fmuladd.f32(float %250, float %255, float %267)
  %269 = load float, ptr %8, align 4, !tbaa !11
  %270 = fmul float %268, %269
  %271 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %272 = getelementptr inbounds [4 x [4 x float]], ptr %271, i64 0, i64 2
  %273 = getelementptr inbounds [4 x float], ptr %272, i64 0, i64 2
  store float %270, ptr %273, align 4, !tbaa !15
  %274 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %275 = getelementptr inbounds [4 x [4 x float]], ptr %274, i64 0, i64 0
  %276 = getelementptr inbounds [4 x float], ptr %275, i64 0, i64 0
  %277 = load float, ptr %276, align 4, !tbaa !15
  %278 = load ptr, ptr %5, align 8, !tbaa !5
  %279 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %278, i32 0, i32 0
  %280 = getelementptr inbounds [4 x [4 x float]], ptr %279, i64 0, i64 3
  %281 = getelementptr inbounds [4 x float], ptr %280, i64 0, i64 0
  %282 = load float, ptr %281, align 4, !tbaa !15
  %283 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %284 = getelementptr inbounds [4 x [4 x float]], ptr %283, i64 0, i64 1
  %285 = getelementptr inbounds [4 x float], ptr %284, i64 0, i64 0
  %286 = load float, ptr %285, align 4, !tbaa !15
  %287 = load ptr, ptr %5, align 8, !tbaa !5
  %288 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %287, i32 0, i32 0
  %289 = getelementptr inbounds [4 x [4 x float]], ptr %288, i64 0, i64 3
  %290 = getelementptr inbounds [4 x float], ptr %289, i64 0, i64 1
  %291 = load float, ptr %290, align 4, !tbaa !15
  %292 = fmul float %286, %291
  %293 = call float @llvm.fmuladd.f32(float %277, float %282, float %292)
  %294 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %295 = getelementptr inbounds [4 x [4 x float]], ptr %294, i64 0, i64 2
  %296 = getelementptr inbounds [4 x float], ptr %295, i64 0, i64 0
  %297 = load float, ptr %296, align 4, !tbaa !15
  %298 = load ptr, ptr %5, align 8, !tbaa !5
  %299 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %298, i32 0, i32 0
  %300 = getelementptr inbounds [4 x [4 x float]], ptr %299, i64 0, i64 3
  %301 = getelementptr inbounds [4 x float], ptr %300, i64 0, i64 2
  %302 = load float, ptr %301, align 4, !tbaa !15
  %303 = call float @llvm.fmuladd.f32(float %297, float %302, float %293)
  %304 = fneg float %303
  %305 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %306 = getelementptr inbounds [4 x [4 x float]], ptr %305, i64 0, i64 3
  %307 = getelementptr inbounds [4 x float], ptr %306, i64 0, i64 0
  store float %304, ptr %307, align 4, !tbaa !15
  %308 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %309 = getelementptr inbounds [4 x [4 x float]], ptr %308, i64 0, i64 0
  %310 = getelementptr inbounds [4 x float], ptr %309, i64 0, i64 1
  %311 = load float, ptr %310, align 4, !tbaa !15
  %312 = load ptr, ptr %5, align 8, !tbaa !5
  %313 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %312, i32 0, i32 0
  %314 = getelementptr inbounds [4 x [4 x float]], ptr %313, i64 0, i64 3
  %315 = getelementptr inbounds [4 x float], ptr %314, i64 0, i64 0
  %316 = load float, ptr %315, align 4, !tbaa !15
  %317 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %318 = getelementptr inbounds [4 x [4 x float]], ptr %317, i64 0, i64 1
  %319 = getelementptr inbounds [4 x float], ptr %318, i64 0, i64 1
  %320 = load float, ptr %319, align 4, !tbaa !15
  %321 = load ptr, ptr %5, align 8, !tbaa !5
  %322 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %321, i32 0, i32 0
  %323 = getelementptr inbounds [4 x [4 x float]], ptr %322, i64 0, i64 3
  %324 = getelementptr inbounds [4 x float], ptr %323, i64 0, i64 1
  %325 = load float, ptr %324, align 4, !tbaa !15
  %326 = fmul float %320, %325
  %327 = call float @llvm.fmuladd.f32(float %311, float %316, float %326)
  %328 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %329 = getelementptr inbounds [4 x [4 x float]], ptr %328, i64 0, i64 2
  %330 = getelementptr inbounds [4 x float], ptr %329, i64 0, i64 1
  %331 = load float, ptr %330, align 4, !tbaa !15
  %332 = load ptr, ptr %5, align 8, !tbaa !5
  %333 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %332, i32 0, i32 0
  %334 = getelementptr inbounds [4 x [4 x float]], ptr %333, i64 0, i64 3
  %335 = getelementptr inbounds [4 x float], ptr %334, i64 0, i64 2
  %336 = load float, ptr %335, align 4, !tbaa !15
  %337 = call float @llvm.fmuladd.f32(float %331, float %336, float %327)
  %338 = fneg float %337
  %339 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %340 = getelementptr inbounds [4 x [4 x float]], ptr %339, i64 0, i64 3
  %341 = getelementptr inbounds [4 x float], ptr %340, i64 0, i64 1
  store float %338, ptr %341, align 4, !tbaa !15
  %342 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %343 = getelementptr inbounds [4 x [4 x float]], ptr %342, i64 0, i64 0
  %344 = getelementptr inbounds [4 x float], ptr %343, i64 0, i64 2
  %345 = load float, ptr %344, align 4, !tbaa !15
  %346 = load ptr, ptr %5, align 8, !tbaa !5
  %347 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %346, i32 0, i32 0
  %348 = getelementptr inbounds [4 x [4 x float]], ptr %347, i64 0, i64 3
  %349 = getelementptr inbounds [4 x float], ptr %348, i64 0, i64 0
  %350 = load float, ptr %349, align 4, !tbaa !15
  %351 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %352 = getelementptr inbounds [4 x [4 x float]], ptr %351, i64 0, i64 1
  %353 = getelementptr inbounds [4 x float], ptr %352, i64 0, i64 2
  %354 = load float, ptr %353, align 4, !tbaa !15
  %355 = load ptr, ptr %5, align 8, !tbaa !5
  %356 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %355, i32 0, i32 0
  %357 = getelementptr inbounds [4 x [4 x float]], ptr %356, i64 0, i64 3
  %358 = getelementptr inbounds [4 x float], ptr %357, i64 0, i64 1
  %359 = load float, ptr %358, align 4, !tbaa !15
  %360 = fmul float %354, %359
  %361 = call float @llvm.fmuladd.f32(float %345, float %350, float %360)
  %362 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %363 = getelementptr inbounds [4 x [4 x float]], ptr %362, i64 0, i64 2
  %364 = getelementptr inbounds [4 x float], ptr %363, i64 0, i64 2
  %365 = load float, ptr %364, align 4, !tbaa !15
  %366 = load ptr, ptr %5, align 8, !tbaa !5
  %367 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %366, i32 0, i32 0
  %368 = getelementptr inbounds [4 x [4 x float]], ptr %367, i64 0, i64 3
  %369 = getelementptr inbounds [4 x float], ptr %368, i64 0, i64 2
  %370 = load float, ptr %369, align 4, !tbaa !15
  %371 = call float @llvm.fmuladd.f32(float %365, float %370, float %361)
  %372 = fneg float %371
  %373 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %374 = getelementptr inbounds [4 x [4 x float]], ptr %373, i64 0, i64 3
  %375 = getelementptr inbounds [4 x float], ptr %374, i64 0, i64 2
  store float %372, ptr %375, align 4, !tbaa !15
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  br label %1146

376:                                              ; preds = %3
  call void @llvm.lifetime.start.p0(i64 64, ptr %9) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #4
  store i32 0, ptr %10, align 4, !tbaa !16
  br label %377

377:                                              ; preds = %428, %376
  %378 = load i32, ptr %10, align 4, !tbaa !16
  %379 = icmp slt i32 %378, 4
  br i1 %379, label %381, label %380

380:                                              ; preds = %377
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  br label %431

381:                                              ; preds = %377
  %382 = load ptr, ptr %5, align 8, !tbaa !5
  %383 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %382, i32 0, i32 0
  %384 = load i32, ptr %10, align 4, !tbaa !16
  %385 = mul nsw i32 %384, 4
  %386 = sext i32 %385 to i64
  %387 = getelementptr inbounds [16 x float], ptr %383, i64 0, i64 %386
  %388 = load float, ptr %387, align 4, !tbaa !15
  %389 = load i32, ptr %10, align 4, !tbaa !16
  %390 = sext i32 %389 to i64
  %391 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 %390
  store float %388, ptr %391, align 4, !tbaa !11
  %392 = load ptr, ptr %5, align 8, !tbaa !5
  %393 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %392, i32 0, i32 0
  %394 = load i32, ptr %10, align 4, !tbaa !16
  %395 = mul nsw i32 %394, 4
  %396 = add nsw i32 %395, 1
  %397 = sext i32 %396 to i64
  %398 = getelementptr inbounds [16 x float], ptr %393, i64 0, i64 %397
  %399 = load float, ptr %398, align 4, !tbaa !15
  %400 = load i32, ptr %10, align 4, !tbaa !16
  %401 = add nsw i32 %400, 4
  %402 = sext i32 %401 to i64
  %403 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 %402
  store float %399, ptr %403, align 4, !tbaa !11
  %404 = load ptr, ptr %5, align 8, !tbaa !5
  %405 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %404, i32 0, i32 0
  %406 = load i32, ptr %10, align 4, !tbaa !16
  %407 = mul nsw i32 %406, 4
  %408 = add nsw i32 %407, 2
  %409 = sext i32 %408 to i64
  %410 = getelementptr inbounds [16 x float], ptr %405, i64 0, i64 %409
  %411 = load float, ptr %410, align 4, !tbaa !15
  %412 = load i32, ptr %10, align 4, !tbaa !16
  %413 = add nsw i32 %412, 8
  %414 = sext i32 %413 to i64
  %415 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 %414
  store float %411, ptr %415, align 4, !tbaa !11
  %416 = load ptr, ptr %5, align 8, !tbaa !5
  %417 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %416, i32 0, i32 0
  %418 = load i32, ptr %10, align 4, !tbaa !16
  %419 = mul nsw i32 %418, 4
  %420 = add nsw i32 %419, 3
  %421 = sext i32 %420 to i64
  %422 = getelementptr inbounds [16 x float], ptr %417, i64 0, i64 %421
  %423 = load float, ptr %422, align 4, !tbaa !15
  %424 = load i32, ptr %10, align 4, !tbaa !16
  %425 = add nsw i32 %424, 12
  %426 = sext i32 %425 to i64
  %427 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 %426
  store float %423, ptr %427, align 4, !tbaa !11
  br label %428

428:                                              ; preds = %381
  %429 = load i32, ptr %10, align 4, !tbaa !16
  %430 = add nsw i32 %429, 1
  store i32 %430, ptr %10, align 4, !tbaa !16
  br label %377, !llvm.loop !18

431:                                              ; preds = %380
  call void @llvm.lifetime.start.p0(i64 48, ptr %11) #4
  %432 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %433 = load float, ptr %432, align 8, !tbaa !11
  %434 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %435 = load float, ptr %434, align 4, !tbaa !11
  %436 = fmul float %433, %435
  %437 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  store float %436, ptr %437, align 16, !tbaa !11
  %438 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %439 = load float, ptr %438, align 4, !tbaa !11
  %440 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %441 = load float, ptr %440, align 8, !tbaa !11
  %442 = fmul float %439, %441
  %443 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  store float %442, ptr %443, align 4, !tbaa !11
  %444 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %445 = load float, ptr %444, align 4, !tbaa !11
  %446 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %447 = load float, ptr %446, align 4, !tbaa !11
  %448 = fmul float %445, %447
  %449 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  store float %448, ptr %449, align 8, !tbaa !11
  %450 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %451 = load float, ptr %450, align 4, !tbaa !11
  %452 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %453 = load float, ptr %452, align 4, !tbaa !11
  %454 = fmul float %451, %453
  %455 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  store float %454, ptr %455, align 4, !tbaa !11
  %456 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %457 = load float, ptr %456, align 4, !tbaa !11
  %458 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %459 = load float, ptr %458, align 8, !tbaa !11
  %460 = fmul float %457, %459
  %461 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  store float %460, ptr %461, align 16, !tbaa !11
  %462 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %463 = load float, ptr %462, align 8, !tbaa !11
  %464 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %465 = load float, ptr %464, align 4, !tbaa !11
  %466 = fmul float %463, %465
  %467 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  store float %466, ptr %467, align 4, !tbaa !11
  %468 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %469 = load float, ptr %468, align 16, !tbaa !11
  %470 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %471 = load float, ptr %470, align 4, !tbaa !11
  %472 = fmul float %469, %471
  %473 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  store float %472, ptr %473, align 8, !tbaa !11
  %474 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %475 = load float, ptr %474, align 4, !tbaa !11
  %476 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %477 = load float, ptr %476, align 16, !tbaa !11
  %478 = fmul float %475, %477
  %479 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  store float %478, ptr %479, align 4, !tbaa !11
  %480 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %481 = load float, ptr %480, align 16, !tbaa !11
  %482 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %483 = load float, ptr %482, align 8, !tbaa !11
  %484 = fmul float %481, %483
  %485 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  store float %484, ptr %485, align 16, !tbaa !11
  %486 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %487 = load float, ptr %486, align 8, !tbaa !11
  %488 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %489 = load float, ptr %488, align 16, !tbaa !11
  %490 = fmul float %487, %489
  %491 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  store float %490, ptr %491, align 4, !tbaa !11
  %492 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %493 = load float, ptr %492, align 16, !tbaa !11
  %494 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %495 = load float, ptr %494, align 4, !tbaa !11
  %496 = fmul float %493, %495
  %497 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  store float %496, ptr %497, align 8, !tbaa !11
  %498 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %499 = load float, ptr %498, align 4, !tbaa !11
  %500 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %501 = load float, ptr %500, align 16, !tbaa !11
  %502 = fmul float %499, %501
  %503 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  store float %502, ptr %503, align 4, !tbaa !11
  %504 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %505 = load float, ptr %504, align 16, !tbaa !11
  %506 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %507 = load float, ptr %506, align 4, !tbaa !11
  %508 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %509 = load float, ptr %508, align 4, !tbaa !11
  %510 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %511 = load float, ptr %510, align 8, !tbaa !11
  %512 = fmul float %509, %511
  %513 = call float @llvm.fmuladd.f32(float %505, float %507, float %512)
  %514 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %515 = load float, ptr %514, align 16, !tbaa !11
  %516 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %517 = load float, ptr %516, align 4, !tbaa !11
  %518 = call float @llvm.fmuladd.f32(float %515, float %517, float %513)
  %519 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %520 = load float, ptr %519, align 4, !tbaa !11
  %521 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %522 = load float, ptr %521, align 4, !tbaa !11
  %523 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %524 = load float, ptr %523, align 8, !tbaa !11
  %525 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %526 = load float, ptr %525, align 8, !tbaa !11
  %527 = fmul float %524, %526
  %528 = call float @llvm.fmuladd.f32(float %520, float %522, float %527)
  %529 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %530 = load float, ptr %529, align 4, !tbaa !11
  %531 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %532 = load float, ptr %531, align 4, !tbaa !11
  %533 = call float @llvm.fmuladd.f32(float %530, float %532, float %528)
  %534 = fsub float %518, %533
  %535 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %536 = getelementptr inbounds [16 x float], ptr %535, i64 0, i64 0
  store float %534, ptr %536, align 4, !tbaa !15
  %537 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %538 = load float, ptr %537, align 4, !tbaa !11
  %539 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %540 = load float, ptr %539, align 16, !tbaa !11
  %541 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %542 = load float, ptr %541, align 8, !tbaa !11
  %543 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %544 = load float, ptr %543, align 8, !tbaa !11
  %545 = fmul float %542, %544
  %546 = call float @llvm.fmuladd.f32(float %538, float %540, float %545)
  %547 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %548 = load float, ptr %547, align 4, !tbaa !11
  %549 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %550 = load float, ptr %549, align 4, !tbaa !11
  %551 = call float @llvm.fmuladd.f32(float %548, float %550, float %546)
  %552 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %553 = load float, ptr %552, align 16, !tbaa !11
  %554 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %555 = load float, ptr %554, align 16, !tbaa !11
  %556 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %557 = load float, ptr %556, align 4, !tbaa !11
  %558 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %559 = load float, ptr %558, align 8, !tbaa !11
  %560 = fmul float %557, %559
  %561 = call float @llvm.fmuladd.f32(float %553, float %555, float %560)
  %562 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %563 = load float, ptr %562, align 16, !tbaa !11
  %564 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %565 = load float, ptr %564, align 4, !tbaa !11
  %566 = call float @llvm.fmuladd.f32(float %563, float %565, float %561)
  %567 = fsub float %551, %566
  %568 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %569 = getelementptr inbounds [16 x float], ptr %568, i64 0, i64 1
  store float %567, ptr %569, align 4, !tbaa !15
  %570 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %571 = load float, ptr %570, align 8, !tbaa !11
  %572 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %573 = load float, ptr %572, align 16, !tbaa !11
  %574 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %575 = load float, ptr %574, align 4, !tbaa !11
  %576 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %577 = load float, ptr %576, align 4, !tbaa !11
  %578 = fmul float %575, %577
  %579 = call float @llvm.fmuladd.f32(float %571, float %573, float %578)
  %580 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %581 = load float, ptr %580, align 8, !tbaa !11
  %582 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %583 = load float, ptr %582, align 4, !tbaa !11
  %584 = call float @llvm.fmuladd.f32(float %581, float %583, float %579)
  %585 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %586 = load float, ptr %585, align 4, !tbaa !11
  %587 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %588 = load float, ptr %587, align 16, !tbaa !11
  %589 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %590 = load float, ptr %589, align 8, !tbaa !11
  %591 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %592 = load float, ptr %591, align 4, !tbaa !11
  %593 = fmul float %590, %592
  %594 = call float @llvm.fmuladd.f32(float %586, float %588, float %593)
  %595 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %596 = load float, ptr %595, align 4, !tbaa !11
  %597 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %598 = load float, ptr %597, align 4, !tbaa !11
  %599 = call float @llvm.fmuladd.f32(float %596, float %598, float %594)
  %600 = fsub float %584, %599
  %601 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %602 = getelementptr inbounds [16 x float], ptr %601, i64 0, i64 2
  store float %600, ptr %602, align 4, !tbaa !15
  %603 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %604 = load float, ptr %603, align 4, !tbaa !11
  %605 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %606 = load float, ptr %605, align 16, !tbaa !11
  %607 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %608 = load float, ptr %607, align 16, !tbaa !11
  %609 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %610 = load float, ptr %609, align 4, !tbaa !11
  %611 = fmul float %608, %610
  %612 = call float @llvm.fmuladd.f32(float %604, float %606, float %611)
  %613 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %614 = load float, ptr %613, align 4, !tbaa !11
  %615 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %616 = load float, ptr %615, align 8, !tbaa !11
  %617 = call float @llvm.fmuladd.f32(float %614, float %616, float %612)
  %618 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %619 = load float, ptr %618, align 16, !tbaa !11
  %620 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %621 = load float, ptr %620, align 16, !tbaa !11
  %622 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %623 = load float, ptr %622, align 4, !tbaa !11
  %624 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %625 = load float, ptr %624, align 4, !tbaa !11
  %626 = fmul float %623, %625
  %627 = call float @llvm.fmuladd.f32(float %619, float %621, float %626)
  %628 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %629 = load float, ptr %628, align 8, !tbaa !11
  %630 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %631 = load float, ptr %630, align 8, !tbaa !11
  %632 = call float @llvm.fmuladd.f32(float %629, float %631, float %627)
  %633 = fsub float %617, %632
  %634 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %635 = getelementptr inbounds [16 x float], ptr %634, i64 0, i64 3
  store float %633, ptr %635, align 4, !tbaa !15
  %636 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %637 = load float, ptr %636, align 4, !tbaa !11
  %638 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %639 = load float, ptr %638, align 4, !tbaa !11
  %640 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %641 = load float, ptr %640, align 8, !tbaa !11
  %642 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %643 = load float, ptr %642, align 8, !tbaa !11
  %644 = fmul float %641, %643
  %645 = call float @llvm.fmuladd.f32(float %637, float %639, float %644)
  %646 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %647 = load float, ptr %646, align 4, !tbaa !11
  %648 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %649 = load float, ptr %648, align 4, !tbaa !11
  %650 = call float @llvm.fmuladd.f32(float %647, float %649, float %645)
  %651 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %652 = load float, ptr %651, align 16, !tbaa !11
  %653 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %654 = load float, ptr %653, align 4, !tbaa !11
  %655 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %656 = load float, ptr %655, align 4, !tbaa !11
  %657 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %658 = load float, ptr %657, align 8, !tbaa !11
  %659 = fmul float %656, %658
  %660 = call float @llvm.fmuladd.f32(float %652, float %654, float %659)
  %661 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %662 = load float, ptr %661, align 16, !tbaa !11
  %663 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %664 = load float, ptr %663, align 4, !tbaa !11
  %665 = call float @llvm.fmuladd.f32(float %662, float %664, float %660)
  %666 = fsub float %650, %665
  %667 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %668 = getelementptr inbounds [16 x float], ptr %667, i64 0, i64 4
  store float %666, ptr %668, align 4, !tbaa !15
  %669 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %670 = load float, ptr %669, align 16, !tbaa !11
  %671 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %672 = load float, ptr %671, align 16, !tbaa !11
  %673 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %674 = load float, ptr %673, align 4, !tbaa !11
  %675 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %676 = load float, ptr %675, align 8, !tbaa !11
  %677 = fmul float %674, %676
  %678 = call float @llvm.fmuladd.f32(float %670, float %672, float %677)
  %679 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %680 = load float, ptr %679, align 16, !tbaa !11
  %681 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %682 = load float, ptr %681, align 4, !tbaa !11
  %683 = call float @llvm.fmuladd.f32(float %680, float %682, float %678)
  %684 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %685 = load float, ptr %684, align 4, !tbaa !11
  %686 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %687 = load float, ptr %686, align 16, !tbaa !11
  %688 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %689 = load float, ptr %688, align 8, !tbaa !11
  %690 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %691 = load float, ptr %690, align 8, !tbaa !11
  %692 = fmul float %689, %691
  %693 = call float @llvm.fmuladd.f32(float %685, float %687, float %692)
  %694 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %695 = load float, ptr %694, align 4, !tbaa !11
  %696 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %697 = load float, ptr %696, align 4, !tbaa !11
  %698 = call float @llvm.fmuladd.f32(float %695, float %697, float %693)
  %699 = fsub float %683, %698
  %700 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %701 = getelementptr inbounds [16 x float], ptr %700, i64 0, i64 5
  store float %699, ptr %701, align 4, !tbaa !15
  %702 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %703 = load float, ptr %702, align 4, !tbaa !11
  %704 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %705 = load float, ptr %704, align 16, !tbaa !11
  %706 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %707 = load float, ptr %706, align 8, !tbaa !11
  %708 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %709 = load float, ptr %708, align 4, !tbaa !11
  %710 = fmul float %707, %709
  %711 = call float @llvm.fmuladd.f32(float %703, float %705, float %710)
  %712 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %713 = load float, ptr %712, align 4, !tbaa !11
  %714 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %715 = load float, ptr %714, align 4, !tbaa !11
  %716 = call float @llvm.fmuladd.f32(float %713, float %715, float %711)
  %717 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %718 = load float, ptr %717, align 8, !tbaa !11
  %719 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %720 = load float, ptr %719, align 16, !tbaa !11
  %721 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %722 = load float, ptr %721, align 4, !tbaa !11
  %723 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %724 = load float, ptr %723, align 4, !tbaa !11
  %725 = fmul float %722, %724
  %726 = call float @llvm.fmuladd.f32(float %718, float %720, float %725)
  %727 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %728 = load float, ptr %727, align 8, !tbaa !11
  %729 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %730 = load float, ptr %729, align 4, !tbaa !11
  %731 = call float @llvm.fmuladd.f32(float %728, float %730, float %726)
  %732 = fsub float %716, %731
  %733 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %734 = getelementptr inbounds [16 x float], ptr %733, i64 0, i64 6
  store float %732, ptr %734, align 4, !tbaa !15
  %735 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %736 = load float, ptr %735, align 16, !tbaa !11
  %737 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %738 = load float, ptr %737, align 16, !tbaa !11
  %739 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %740 = load float, ptr %739, align 4, !tbaa !11
  %741 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %742 = load float, ptr %741, align 4, !tbaa !11
  %743 = fmul float %740, %742
  %744 = call float @llvm.fmuladd.f32(float %736, float %738, float %743)
  %745 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %746 = load float, ptr %745, align 8, !tbaa !11
  %747 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %748 = load float, ptr %747, align 8, !tbaa !11
  %749 = call float @llvm.fmuladd.f32(float %746, float %748, float %744)
  %750 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %751 = load float, ptr %750, align 4, !tbaa !11
  %752 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %753 = load float, ptr %752, align 16, !tbaa !11
  %754 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %755 = load float, ptr %754, align 16, !tbaa !11
  %756 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %757 = load float, ptr %756, align 4, !tbaa !11
  %758 = fmul float %755, %757
  %759 = call float @llvm.fmuladd.f32(float %751, float %753, float %758)
  %760 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %761 = load float, ptr %760, align 4, !tbaa !11
  %762 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %763 = load float, ptr %762, align 8, !tbaa !11
  %764 = call float @llvm.fmuladd.f32(float %761, float %763, float %759)
  %765 = fsub float %749, %764
  %766 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %767 = getelementptr inbounds [16 x float], ptr %766, i64 0, i64 7
  store float %765, ptr %767, align 4, !tbaa !15
  %768 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %769 = load float, ptr %768, align 8, !tbaa !11
  %770 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %771 = load float, ptr %770, align 4, !tbaa !11
  %772 = fmul float %769, %771
  %773 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  store float %772, ptr %773, align 16, !tbaa !11
  %774 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %775 = load float, ptr %774, align 4, !tbaa !11
  %776 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %777 = load float, ptr %776, align 8, !tbaa !11
  %778 = fmul float %775, %777
  %779 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  store float %778, ptr %779, align 4, !tbaa !11
  %780 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %781 = load float, ptr %780, align 4, !tbaa !11
  %782 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %783 = load float, ptr %782, align 4, !tbaa !11
  %784 = fmul float %781, %783
  %785 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  store float %784, ptr %785, align 8, !tbaa !11
  %786 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %787 = load float, ptr %786, align 4, !tbaa !11
  %788 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %789 = load float, ptr %788, align 4, !tbaa !11
  %790 = fmul float %787, %789
  %791 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  store float %790, ptr %791, align 4, !tbaa !11
  %792 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %793 = load float, ptr %792, align 4, !tbaa !11
  %794 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %795 = load float, ptr %794, align 8, !tbaa !11
  %796 = fmul float %793, %795
  %797 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  store float %796, ptr %797, align 16, !tbaa !11
  %798 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %799 = load float, ptr %798, align 8, !tbaa !11
  %800 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %801 = load float, ptr %800, align 4, !tbaa !11
  %802 = fmul float %799, %801
  %803 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  store float %802, ptr %803, align 4, !tbaa !11
  %804 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %805 = load float, ptr %804, align 16, !tbaa !11
  %806 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 7
  %807 = load float, ptr %806, align 4, !tbaa !11
  %808 = fmul float %805, %807
  %809 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  store float %808, ptr %809, align 8, !tbaa !11
  %810 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %811 = load float, ptr %810, align 4, !tbaa !11
  %812 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %813 = load float, ptr %812, align 16, !tbaa !11
  %814 = fmul float %811, %813
  %815 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  store float %814, ptr %815, align 4, !tbaa !11
  %816 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %817 = load float, ptr %816, align 16, !tbaa !11
  %818 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 6
  %819 = load float, ptr %818, align 8, !tbaa !11
  %820 = fmul float %817, %819
  %821 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  store float %820, ptr %821, align 16, !tbaa !11
  %822 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %823 = load float, ptr %822, align 8, !tbaa !11
  %824 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %825 = load float, ptr %824, align 16, !tbaa !11
  %826 = fmul float %823, %825
  %827 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  store float %826, ptr %827, align 4, !tbaa !11
  %828 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %829 = load float, ptr %828, align 16, !tbaa !11
  %830 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 5
  %831 = load float, ptr %830, align 4, !tbaa !11
  %832 = fmul float %829, %831
  %833 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  store float %832, ptr %833, align 8, !tbaa !11
  %834 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %835 = load float, ptr %834, align 4, !tbaa !11
  %836 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 4
  %837 = load float, ptr %836, align 16, !tbaa !11
  %838 = fmul float %835, %837
  %839 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  store float %838, ptr %839, align 4, !tbaa !11
  %840 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %841 = load float, ptr %840, align 16, !tbaa !11
  %842 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %843 = load float, ptr %842, align 4, !tbaa !11
  %844 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %845 = load float, ptr %844, align 4, !tbaa !11
  %846 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %847 = load float, ptr %846, align 8, !tbaa !11
  %848 = fmul float %845, %847
  %849 = call float @llvm.fmuladd.f32(float %841, float %843, float %848)
  %850 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %851 = load float, ptr %850, align 16, !tbaa !11
  %852 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %853 = load float, ptr %852, align 4, !tbaa !11
  %854 = call float @llvm.fmuladd.f32(float %851, float %853, float %849)
  %855 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %856 = load float, ptr %855, align 4, !tbaa !11
  %857 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %858 = load float, ptr %857, align 4, !tbaa !11
  %859 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %860 = load float, ptr %859, align 8, !tbaa !11
  %861 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %862 = load float, ptr %861, align 8, !tbaa !11
  %863 = fmul float %860, %862
  %864 = call float @llvm.fmuladd.f32(float %856, float %858, float %863)
  %865 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %866 = load float, ptr %865, align 4, !tbaa !11
  %867 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %868 = load float, ptr %867, align 4, !tbaa !11
  %869 = call float @llvm.fmuladd.f32(float %866, float %868, float %864)
  %870 = fsub float %854, %869
  %871 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %872 = getelementptr inbounds [16 x float], ptr %871, i64 0, i64 8
  store float %870, ptr %872, align 4, !tbaa !15
  %873 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %874 = load float, ptr %873, align 4, !tbaa !11
  %875 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %876 = load float, ptr %875, align 16, !tbaa !11
  %877 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %878 = load float, ptr %877, align 8, !tbaa !11
  %879 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %880 = load float, ptr %879, align 8, !tbaa !11
  %881 = fmul float %878, %880
  %882 = call float @llvm.fmuladd.f32(float %874, float %876, float %881)
  %883 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %884 = load float, ptr %883, align 4, !tbaa !11
  %885 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %886 = load float, ptr %885, align 4, !tbaa !11
  %887 = call float @llvm.fmuladd.f32(float %884, float %886, float %882)
  %888 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %889 = load float, ptr %888, align 16, !tbaa !11
  %890 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %891 = load float, ptr %890, align 16, !tbaa !11
  %892 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %893 = load float, ptr %892, align 4, !tbaa !11
  %894 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %895 = load float, ptr %894, align 8, !tbaa !11
  %896 = fmul float %893, %895
  %897 = call float @llvm.fmuladd.f32(float %889, float %891, float %896)
  %898 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %899 = load float, ptr %898, align 16, !tbaa !11
  %900 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %901 = load float, ptr %900, align 4, !tbaa !11
  %902 = call float @llvm.fmuladd.f32(float %899, float %901, float %897)
  %903 = fsub float %887, %902
  %904 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %905 = getelementptr inbounds [16 x float], ptr %904, i64 0, i64 9
  store float %903, ptr %905, align 4, !tbaa !15
  %906 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %907 = load float, ptr %906, align 8, !tbaa !11
  %908 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %909 = load float, ptr %908, align 16, !tbaa !11
  %910 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %911 = load float, ptr %910, align 4, !tbaa !11
  %912 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %913 = load float, ptr %912, align 4, !tbaa !11
  %914 = fmul float %911, %913
  %915 = call float @llvm.fmuladd.f32(float %907, float %909, float %914)
  %916 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %917 = load float, ptr %916, align 8, !tbaa !11
  %918 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %919 = load float, ptr %918, align 4, !tbaa !11
  %920 = call float @llvm.fmuladd.f32(float %917, float %919, float %915)
  %921 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %922 = load float, ptr %921, align 4, !tbaa !11
  %923 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %924 = load float, ptr %923, align 16, !tbaa !11
  %925 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %926 = load float, ptr %925, align 8, !tbaa !11
  %927 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %928 = load float, ptr %927, align 4, !tbaa !11
  %929 = fmul float %926, %928
  %930 = call float @llvm.fmuladd.f32(float %922, float %924, float %929)
  %931 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %932 = load float, ptr %931, align 4, !tbaa !11
  %933 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 15
  %934 = load float, ptr %933, align 4, !tbaa !11
  %935 = call float @llvm.fmuladd.f32(float %932, float %934, float %930)
  %936 = fsub float %920, %935
  %937 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %938 = getelementptr inbounds [16 x float], ptr %937, i64 0, i64 10
  store float %936, ptr %938, align 4, !tbaa !15
  %939 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %940 = load float, ptr %939, align 4, !tbaa !11
  %941 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %942 = load float, ptr %941, align 16, !tbaa !11
  %943 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %944 = load float, ptr %943, align 16, !tbaa !11
  %945 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %946 = load float, ptr %945, align 4, !tbaa !11
  %947 = fmul float %944, %946
  %948 = call float @llvm.fmuladd.f32(float %940, float %942, float %947)
  %949 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %950 = load float, ptr %949, align 4, !tbaa !11
  %951 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %952 = load float, ptr %951, align 8, !tbaa !11
  %953 = call float @llvm.fmuladd.f32(float %950, float %952, float %948)
  %954 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %955 = load float, ptr %954, align 16, !tbaa !11
  %956 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 12
  %957 = load float, ptr %956, align 16, !tbaa !11
  %958 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %959 = load float, ptr %958, align 4, !tbaa !11
  %960 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 13
  %961 = load float, ptr %960, align 4, !tbaa !11
  %962 = fmul float %959, %961
  %963 = call float @llvm.fmuladd.f32(float %955, float %957, float %962)
  %964 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %965 = load float, ptr %964, align 8, !tbaa !11
  %966 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 14
  %967 = load float, ptr %966, align 8, !tbaa !11
  %968 = call float @llvm.fmuladd.f32(float %965, float %967, float %963)
  %969 = fsub float %953, %968
  %970 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %971 = getelementptr inbounds [16 x float], ptr %970, i64 0, i64 11
  store float %969, ptr %971, align 4, !tbaa !15
  %972 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %973 = load float, ptr %972, align 8, !tbaa !11
  %974 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %975 = load float, ptr %974, align 8, !tbaa !11
  %976 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %977 = load float, ptr %976, align 4, !tbaa !11
  %978 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %979 = load float, ptr %978, align 4, !tbaa !11
  %980 = fmul float %977, %979
  %981 = call float @llvm.fmuladd.f32(float %973, float %975, float %980)
  %982 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %983 = load float, ptr %982, align 4, !tbaa !11
  %984 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %985 = load float, ptr %984, align 4, !tbaa !11
  %986 = call float @llvm.fmuladd.f32(float %983, float %985, float %981)
  %987 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %988 = load float, ptr %987, align 16, !tbaa !11
  %989 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %990 = load float, ptr %989, align 4, !tbaa !11
  %991 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %992 = load float, ptr %991, align 16, !tbaa !11
  %993 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %994 = load float, ptr %993, align 4, !tbaa !11
  %995 = fmul float %992, %994
  %996 = call float @llvm.fmuladd.f32(float %988, float %990, float %995)
  %997 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %998 = load float, ptr %997, align 4, !tbaa !11
  %999 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %1000 = load float, ptr %999, align 8, !tbaa !11
  %1001 = call float @llvm.fmuladd.f32(float %998, float %1000, float %996)
  %1002 = fsub float %986, %1001
  %1003 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1004 = getelementptr inbounds [16 x float], ptr %1003, i64 0, i64 12
  store float %1002, ptr %1004, align 4, !tbaa !15
  %1005 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %1006 = load float, ptr %1005, align 16, !tbaa !11
  %1007 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %1008 = load float, ptr %1007, align 4, !tbaa !11
  %1009 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 0
  %1010 = load float, ptr %1009, align 16, !tbaa !11
  %1011 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1012 = load float, ptr %1011, align 16, !tbaa !11
  %1013 = fmul float %1010, %1012
  %1014 = call float @llvm.fmuladd.f32(float %1006, float %1008, float %1013)
  %1015 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %1016 = load float, ptr %1015, align 4, !tbaa !11
  %1017 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %1018 = load float, ptr %1017, align 8, !tbaa !11
  %1019 = call float @llvm.fmuladd.f32(float %1016, float %1018, float %1014)
  %1020 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %1021 = load float, ptr %1020, align 8, !tbaa !11
  %1022 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %1023 = load float, ptr %1022, align 8, !tbaa !11
  %1024 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %1025 = load float, ptr %1024, align 4, !tbaa !11
  %1026 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %1027 = load float, ptr %1026, align 4, !tbaa !11
  %1028 = fmul float %1025, %1027
  %1029 = call float @llvm.fmuladd.f32(float %1021, float %1023, float %1028)
  %1030 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 1
  %1031 = load float, ptr %1030, align 4, !tbaa !11
  %1032 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1033 = load float, ptr %1032, align 16, !tbaa !11
  %1034 = call float @llvm.fmuladd.f32(float %1031, float %1033, float %1029)
  %1035 = fsub float %1019, %1034
  %1036 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1037 = getelementptr inbounds [16 x float], ptr %1036, i64 0, i64 13
  store float %1035, ptr %1037, align 4, !tbaa !15
  %1038 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 6
  %1039 = load float, ptr %1038, align 8, !tbaa !11
  %1040 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %1041 = load float, ptr %1040, align 4, !tbaa !11
  %1042 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %1043 = load float, ptr %1042, align 4, !tbaa !11
  %1044 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %1045 = load float, ptr %1044, align 4, !tbaa !11
  %1046 = fmul float %1043, %1045
  %1047 = call float @llvm.fmuladd.f32(float %1039, float %1041, float %1046)
  %1048 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 3
  %1049 = load float, ptr %1048, align 4, !tbaa !11
  %1050 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1051 = load float, ptr %1050, align 16, !tbaa !11
  %1052 = call float @llvm.fmuladd.f32(float %1049, float %1051, float %1047)
  %1053 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %1054 = load float, ptr %1053, align 8, !tbaa !11
  %1055 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 11
  %1056 = load float, ptr %1055, align 4, !tbaa !11
  %1057 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 2
  %1058 = load float, ptr %1057, align 8, !tbaa !11
  %1059 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1060 = load float, ptr %1059, align 16, !tbaa !11
  %1061 = fmul float %1058, %1060
  %1062 = call float @llvm.fmuladd.f32(float %1054, float %1056, float %1061)
  %1063 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 7
  %1064 = load float, ptr %1063, align 4, !tbaa !11
  %1065 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %1066 = load float, ptr %1065, align 4, !tbaa !11
  %1067 = call float @llvm.fmuladd.f32(float %1064, float %1066, float %1062)
  %1068 = fsub float %1052, %1067
  %1069 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1070 = getelementptr inbounds [16 x float], ptr %1069, i64 0, i64 14
  store float %1068, ptr %1070, align 4, !tbaa !15
  %1071 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 10
  %1072 = load float, ptr %1071, align 8, !tbaa !11
  %1073 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %1074 = load float, ptr %1073, align 8, !tbaa !11
  %1075 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 4
  %1076 = load float, ptr %1075, align 16, !tbaa !11
  %1077 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1078 = load float, ptr %1077, align 16, !tbaa !11
  %1079 = fmul float %1076, %1078
  %1080 = call float @llvm.fmuladd.f32(float %1072, float %1074, float %1079)
  %1081 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 9
  %1082 = load float, ptr %1081, align 4, !tbaa !11
  %1083 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %1084 = load float, ptr %1083, align 4, !tbaa !11
  %1085 = call float @llvm.fmuladd.f32(float %1082, float %1084, float %1080)
  %1086 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 8
  %1087 = load float, ptr %1086, align 16, !tbaa !11
  %1088 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 9
  %1089 = load float, ptr %1088, align 4, !tbaa !11
  %1090 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 11
  %1091 = load float, ptr %1090, align 4, !tbaa !11
  %1092 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 10
  %1093 = load float, ptr %1092, align 8, !tbaa !11
  %1094 = fmul float %1091, %1093
  %1095 = call float @llvm.fmuladd.f32(float %1087, float %1089, float %1094)
  %1096 = getelementptr inbounds [12 x float], ptr %11, i64 0, i64 5
  %1097 = load float, ptr %1096, align 4, !tbaa !11
  %1098 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 8
  %1099 = load float, ptr %1098, align 16, !tbaa !11
  %1100 = call float @llvm.fmuladd.f32(float %1097, float %1099, float %1095)
  %1101 = fsub float %1085, %1100
  %1102 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1103 = getelementptr inbounds [16 x float], ptr %1102, i64 0, i64 15
  store float %1101, ptr %1103, align 4, !tbaa !15
  %1104 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 0
  %1105 = load float, ptr %1104, align 16, !tbaa !11
  %1106 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1107 = getelementptr inbounds [16 x float], ptr %1106, i64 0, i64 0
  %1108 = load float, ptr %1107, align 4, !tbaa !15
  %1109 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 1
  %1110 = load float, ptr %1109, align 4, !tbaa !11
  %1111 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1112 = getelementptr inbounds [16 x float], ptr %1111, i64 0, i64 1
  %1113 = load float, ptr %1112, align 4, !tbaa !15
  %1114 = fmul float %1110, %1113
  %1115 = call float @llvm.fmuladd.f32(float %1105, float %1108, float %1114)
  %1116 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 2
  %1117 = load float, ptr %1116, align 8, !tbaa !11
  %1118 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1119 = getelementptr inbounds [16 x float], ptr %1118, i64 0, i64 2
  %1120 = load float, ptr %1119, align 4, !tbaa !15
  %1121 = call float @llvm.fmuladd.f32(float %1117, float %1120, float %1115)
  %1122 = getelementptr inbounds [16 x float], ptr %9, i64 0, i64 3
  %1123 = load float, ptr %1122, align 4, !tbaa !11
  %1124 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1125 = getelementptr inbounds [16 x float], ptr %1124, i64 0, i64 3
  %1126 = load float, ptr %1125, align 4, !tbaa !15
  %1127 = call float @llvm.fmuladd.f32(float %1123, float %1126, float %1121)
  store float %1127, ptr %7, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #4
  %1128 = load float, ptr %7, align 4, !tbaa !11
  %1129 = fdiv float 1.000000e+00, %1128
  store float %1129, ptr %12, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #4
  store i32 0, ptr %13, align 4, !tbaa !16
  br label %1130

1130:                                             ; preds = %1142, %431
  %1131 = load i32, ptr %13, align 4, !tbaa !16
  %1132 = icmp slt i32 %1131, 16
  br i1 %1132, label %1134, label %1133

1133:                                             ; preds = %1130
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  br label %1145

1134:                                             ; preds = %1130
  %1135 = load float, ptr %12, align 4, !tbaa !11
  %1136 = getelementptr inbounds %"struct.ImGuizmo::matrix_t", ptr %15, i32 0, i32 0
  %1137 = load i32, ptr %13, align 4, !tbaa !16
  %1138 = sext i32 %1137 to i64
  %1139 = getelementptr inbounds [16 x float], ptr %1136, i64 0, i64 %1138
  %1140 = load float, ptr %1139, align 4, !tbaa !15
  %1141 = fmul float %1140, %1135
  store float %1141, ptr %1139, align 4, !tbaa !15
  br label %1142

1142:                                             ; preds = %1134
  %1143 = load i32, ptr %13, align 4, !tbaa !16
  %1144 = add nsw i32 %1143, 1
  store i32 %1144, ptr %13, align 4, !tbaa !16
  br label %1130, !llvm.loop !20

1145:                                             ; preds = %1133
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 48, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 64, ptr %9) #4
  br label %1146

1146:                                             ; preds = %1145, %18
  %1147 = load float, ptr %7, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #4
  ret float %1147
}

; Function Attrs: mustprogress nounwind uwtable
declare dso_local noundef float @_ZNK8ImGuizmo8matrix_t14GetDeterminantEv(ptr noundef nonnull align 4 dereferenceable(64)) #3 align 2

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


; 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"

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #0

; Function Attrs: mustprogress nounwind uwtable
define dso_local noundef float @_ZN8ImGuizmo8matrix_t7InverseERKS0_b(ptr noundef nonnull align 4 dereferenceable(64) %0, ptr nocapture noundef nonnull readonly align 4 dereferenceable(64) %1, i1 noundef zeroext %2) local_unnamed_addr #1 align 2 {
  br i1 %2, label %4, label %122

4:                                                ; preds = %3
  %5 = tail call noundef float @_ZNK8ImGuizmo8matrix_t14GetDeterminantEv(ptr noundef nonnull align 4 dereferenceable(64) %0)
  %6 = fdiv float 1.000000e+00, %5
  %7 = getelementptr inbounds i8, ptr %1, i64 16
  %8 = getelementptr inbounds i8, ptr %1, i64 20
  %9 = load float, ptr %8, align 4, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %1, i64 32
  %11 = getelementptr inbounds i8, ptr %1, i64 40
  %12 = load float, ptr %11, align 4, !tbaa !5
  %13 = getelementptr inbounds i8, ptr %1, i64 24
  %14 = load float, ptr %13, align 4, !tbaa !5
  %15 = getelementptr inbounds i8, ptr %1, i64 36
  %16 = load float, ptr %15, align 4, !tbaa !5
  %17 = fneg float %14
  %18 = fmul float %16, %17
  %19 = tail call float @llvm.fmuladd.f32(float %9, float %12, float %18)
  %20 = fmul float %6, %19
  store float %20, ptr %0, align 4, !tbaa !5
  %21 = load float, ptr %15, align 4, !tbaa !5
  %22 = getelementptr inbounds i8, ptr %1, i64 8
  %23 = load float, ptr %22, align 4, !tbaa !5
  %24 = load float, ptr %11, align 4, !tbaa !5
  %25 = getelementptr inbounds i8, ptr %1, i64 4
  %26 = load float, ptr %25, align 4, !tbaa !5
  %27 = fneg float %24
  %28 = fmul float %26, %27
  %29 = tail call float @llvm.fmuladd.f32(float %21, float %23, float %28)
  %30 = fmul float %6, %29
  %31 = getelementptr inbounds i8, ptr %0, i64 4
  store float %30, ptr %31, align 4, !tbaa !5
  %32 = load float, ptr %25, align 4, !tbaa !5
  %33 = load float, ptr %13, align 4, !tbaa !5
  %34 = load float, ptr %22, align 4, !tbaa !5
  %35 = load float, ptr %8, align 4, !tbaa !5
  %36 = fneg float %34
  %37 = fmul float %35, %36
  %38 = tail call float @llvm.fmuladd.f32(float %32, float %33, float %37)
  %39 = fmul float %6, %38
  %40 = getelementptr inbounds i8, ptr %0, i64 8
  store float %39, ptr %40, align 4, !tbaa !5
  %41 = load float, ptr %13, align 4, !tbaa !5
  %42 = load float, ptr %10, align 4, !tbaa !5
  %43 = load float, ptr %7, align 4, !tbaa !5
  %44 = load float, ptr %11, align 4, !tbaa !5
  %45 = fneg float %43
  %46 = fmul float %44, %45
  %47 = tail call float @llvm.fmuladd.f32(float %41, float %42, float %46)
  %48 = fmul float %6, %47
  %49 = getelementptr inbounds i8, ptr %0, i64 16
  store float %48, ptr %49, align 4, !tbaa !5
  %50 = load float, ptr %11, align 4, !tbaa !5
  %51 = load float, ptr %1, align 4, !tbaa !5
  %52 = load float, ptr %10, align 4, !tbaa !5
  %53 = load float, ptr %22, align 4, !tbaa !5
  %54 = fneg float %52
  %55 = fmul float %53, %54
  %56 = tail call float @llvm.fmuladd.f32(float %50, float %51, float %55)
  %57 = fmul float %6, %56
  %58 = getelementptr inbounds i8, ptr %0, i64 20
  store float %57, ptr %58, align 4, !tbaa !5
  %59 = load float, ptr %22, align 4, !tbaa !5
  %60 = load float, ptr %7, align 4, !tbaa !5
  %61 = load float, ptr %1, align 4, !tbaa !5
  %62 = load float, ptr %13, align 4, !tbaa !5
  %63 = fneg float %61
  %64 = fmul float %62, %63
  %65 = tail call float @llvm.fmuladd.f32(float %59, float %60, float %64)
  %66 = fmul float %6, %65
  %67 = getelementptr inbounds i8, ptr %0, i64 24
  store float %66, ptr %67, align 4, !tbaa !5
  %68 = load float, ptr %7, align 4, !tbaa !5
  %69 = load float, ptr %15, align 4, !tbaa !5
  %70 = load float, ptr %8, align 4, !tbaa !5
  %71 = load float, ptr %10, align 4, !tbaa !5
  %72 = fneg float %70
  %73 = fmul float %71, %72
  %74 = tail call float @llvm.fmuladd.f32(float %68, float %69, float %73)
  %75 = fmul float %6, %74
  %76 = getelementptr inbounds i8, ptr %0, i64 32
  store float %75, ptr %76, align 4, !tbaa !5
  %77 = load float, ptr %10, align 4, !tbaa !5
  %78 = load float, ptr %25, align 4, !tbaa !5
  %79 = load float, ptr %15, align 4, !tbaa !5
  %80 = load float, ptr %1, align 4, !tbaa !5
  %81 = fneg float %79
  %82 = fmul float %80, %81
  %83 = tail call float @llvm.fmuladd.f32(float %77, float %78, float %82)
  %84 = fmul float %6, %83
  %85 = getelementptr inbounds i8, ptr %0, i64 36
  store float %84, ptr %85, align 4, !tbaa !5
  %86 = load float, ptr %1, align 4, !tbaa !5
  %87 = load float, ptr %8, align 4, !tbaa !5
  %88 = load float, ptr %25, align 4, !tbaa !5
  %89 = load float, ptr %7, align 4, !tbaa !5
  %90 = fneg float %88
  %91 = fmul float %89, %90
  %92 = tail call float @llvm.fmuladd.f32(float %86, float %87, float %91)
  %93 = fmul float %6, %92
  %94 = getelementptr inbounds i8, ptr %0, i64 40
  store float %93, ptr %94, align 4, !tbaa !5
  %95 = getelementptr inbounds i8, ptr %1, i64 48
  %96 = load float, ptr %95, align 4, !tbaa !5
  %97 = getelementptr inbounds i8, ptr %1, i64 52
  %98 = load float, ptr %97, align 4, !tbaa !5
  %99 = fmul float %48, %98
  %100 = tail call float @llvm.fmuladd.f32(float %20, float %96, float %99)
  %101 = getelementptr inbounds i8, ptr %1, i64 56
  %102 = load float, ptr %101, align 4, !tbaa !5
  %103 = tail call float @llvm.fmuladd.f32(float %75, float %102, float %100)
  %104 = fneg float %103
  %105 = getelementptr inbounds i8, ptr %0, i64 48
  store float %104, ptr %105, align 4, !tbaa !5
  %106 = load float, ptr %95, align 4, !tbaa !5
  %107 = load float, ptr %97, align 4, !tbaa !5
  %108 = fmul float %57, %107
  %109 = tail call float @llvm.fmuladd.f32(float %30, float %106, float %108)
  %110 = load float, ptr %101, align 4, !tbaa !5
  %111 = tail call float @llvm.fmuladd.f32(float %84, float %110, float %109)
  %112 = fneg float %111
  %113 = getelementptr inbounds i8, ptr %0, i64 52
  store float %112, ptr %113, align 4, !tbaa !5
  %114 = load float, ptr %95, align 4, !tbaa !5
  %115 = load float, ptr %97, align 4, !tbaa !5
  %116 = fmul float %66, %115
  %117 = tail call float @llvm.fmuladd.f32(float %39, float %114, float %116)
  %118 = load float, ptr %101, align 4, !tbaa !5
  %119 = tail call float @llvm.fmuladd.f32(float %93, float %118, float %117)
  %120 = fneg float %119
  %121 = getelementptr inbounds i8, ptr %0, i64 56
  store float %120, ptr %121, align 4, !tbaa !5
  br label %304

122:                                              ; preds = %3
  %123 = load <2 x float>, ptr %1, align 4, !tbaa !5
  %124 = getelementptr inbounds i8, ptr %1, i64 8
  %125 = getelementptr inbounds i8, ptr %1, i64 16
  %126 = load float, ptr %125, align 4, !tbaa !5
  %127 = getelementptr inbounds i8, ptr %1, i64 20
  %128 = load float, ptr %127, align 4, !tbaa !5
  %129 = getelementptr inbounds i8, ptr %1, i64 24
  %130 = getelementptr inbounds i8, ptr %1, i64 32
  %131 = load float, ptr %130, align 4, !tbaa !5
  %132 = getelementptr inbounds i8, ptr %1, i64 36
  %133 = load float, ptr %132, align 4, !tbaa !5
  %134 = getelementptr inbounds i8, ptr %1, i64 40
  %135 = getelementptr inbounds i8, ptr %1, i64 48
  %136 = load <2 x float>, ptr %135, align 4, !tbaa !5
  %137 = getelementptr inbounds i8, ptr %1, i64 56
  %138 = getelementptr inbounds i8, ptr %0, i64 4
  %139 = getelementptr inbounds i8, ptr %0, i64 8
  %140 = load <2 x float>, ptr %124, align 4, !tbaa !5
  %141 = shufflevector <2 x float> %140, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %142 = shufflevector <2 x float> %140, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %143 = load <2 x float>, ptr %129, align 4, !tbaa !5
  %144 = shufflevector <2 x float> %143, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %145 = shufflevector <2 x float> %143, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %146 = shufflevector <2 x float> %143, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %147 = load <2 x float>, ptr %134, align 4, !tbaa !5
  %148 = shufflevector <2 x float> %143, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %149 = fmul <2 x float> %147, %148
  %150 = shufflevector <2 x float> %149, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %151 = shufflevector <2 x float> %149, <2 x float> poison, <4 x i32> <i32 poison, i32 1, i32 poison, i32 poison>
  %152 = shufflevector <2 x float> %147, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %153 = fmul <2 x float> %152, %140
  %154 = shufflevector <2 x float> %153, <2 x float> poison, <4 x i32> <i32 poison, i32 1, i32 poison, i32 poison>
  %155 = shufflevector <2 x float> %153, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %156 = shufflevector <2 x float> %153, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %157 = shufflevector <2 x float> %153, <2 x float> poison, <4 x i32> <i32 poison, i32 1, i32 poison, i32 poison>
  %158 = fmul <2 x float> %143, %142
  %159 = shufflevector <2 x float> %149, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %160 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %161 = load <2 x float>, ptr %137, align 4, !tbaa !5
  %162 = shufflevector <2 x float> %161, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %163 = fmul <2 x float> %162, %143
  %164 = fmul <2 x float> %161, %142
  %165 = fmul <2 x float> %162, %147
  %166 = insertelement <2 x float> poison, float %133, i64 0
  %167 = shufflevector <2 x float> %166, <2 x float> poison, <2 x i32> zeroinitializer
  %168 = fmul <2 x float> %163, %167
  %169 = shufflevector <2 x float> %168, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %170 = insertelement <2 x float> poison, float %128, i64 0
  %171 = shufflevector <2 x float> %170, <2 x float> poison, <2 x i32> zeroinitializer
  %172 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %165, <2 x float> %171, <2 x float> %169)
  %173 = shufflevector <2 x float> %136, <2 x float> poison, <2 x i32> <i32 1, i32 1>
  %174 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %159, <2 x float> %173, <2 x float> %172)
  %shift = shufflevector <2 x float> %174, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %175 = fsub <2 x float> %174, %shift
  %176 = extractelement <2 x float> %175, i64 0
  store float %176, ptr %0, align 4, !tbaa !5
  %177 = fmul <2 x float> %164, %167
  %178 = shufflevector <2 x float> %123, <2 x float> poison, <2 x i32> <i32 1, i32 1>
  %179 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %165, <2 x float> %178, <2 x float> %177)
  %180 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %153, <2 x float> %173, <2 x float> %179)
  %shift166 = shufflevector <2 x float> %180, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %181 = fsub <2 x float> %shift166, %180
  %182 = extractelement <2 x float> %181, i64 0
  store float %182, ptr %138, align 4, !tbaa !5
  %183 = fmul <2 x float> %164, %171
  %184 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %163, <2 x float> %178, <2 x float> %183)
  %185 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %160, <2 x float> %173, <2 x float> %184)
  %shift167 = shufflevector <2 x float> %185, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %186 = fsub <2 x float> %185, %shift167
  %187 = extractelement <2 x float> %186, i64 0
  store float %187, ptr %139, align 4, !tbaa !5
  %188 = fmul <2 x float> %153, %171
  %189 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %149, <2 x float> %178, <2 x float> %188)
  %190 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %158, <2 x float> %167, <2 x float> %189)
  %shift168 = shufflevector <2 x float> %190, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %191 = fsub <2 x float> %190, %shift168
  %192 = extractelement <2 x float> %191, i64 0
  %193 = getelementptr inbounds i8, ptr %0, i64 12
  store float %192, ptr %193, align 4, !tbaa !5
  %194 = getelementptr inbounds i8, ptr %0, i64 16
  %195 = shufflevector <2 x float> %163, <2 x float> %164, <4 x i32> <i32 0, i32 2, i32 3, i32 poison>
  %196 = shufflevector <4 x float> %195, <4 x float> %157, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
  %197 = insertelement <4 x float> poison, float %131, i64 0
  %198 = insertelement <4 x float> %197, float %126, i64 1
  %199 = shufflevector <4 x float> %198, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
  %200 = fmul <4 x float> %196, %199
  %201 = shufflevector <2 x float> %165, <2 x float> %163, <4 x i32> <i32 1, i32 0, i32 3, i32 poison>
  %202 = shufflevector <4 x float> %201, <4 x float> %151, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
  %203 = insertelement <4 x float> poison, float %126, i64 0
  %204 = shufflevector <2 x float> %123, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %205 = shufflevector <4 x float> %203, <4 x float> %204, <4 x i32> <i32 0, i32 4, i32 poison, i32 poison>
  %206 = shufflevector <4 x float> %205, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
  %207 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %202, <4 x float> %206, <4 x float> %200)
  %208 = shufflevector <2 x float> %149, <2 x float> %158, <4 x i32> <i32 0, i32 poison, i32 2, i32 3>
  %209 = shufflevector <4 x float> %208, <4 x float> %156, <4 x i32> <i32 0, i32 4, i32 2, i32 3>
  %210 = shufflevector <2 x float> %136, <2 x float> poison, <4 x i32> <i32 0, i32 poison, i32 1, i32 poison>
  %211 = insertelement <4 x float> %210, float %131, i64 1
  %212 = shufflevector <4 x float> %211, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 0, i32 1>
  %213 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %209, <4 x float> %212, <4 x float> %207)
  %214 = shufflevector <2 x float> %163, <2 x float> %164, <4 x i32> <i32 1, i32 3, i32 2, i32 poison>
  %215 = shufflevector <4 x float> %214, <4 x float> %155, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
  %216 = fmul <4 x float> %215, %199
  %217 = shufflevector <2 x float> %165, <2 x float> %163, <4 x i32> <i32 0, i32 1, i32 2, i32 poison>
  %218 = shufflevector <4 x float> %217, <4 x float> %150, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
  %219 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %218, <4 x float> %206, <4 x float> %216)
  %220 = shufflevector <2 x float> %149, <2 x float> %158, <4 x i32> <i32 1, i32 poison, i32 3, i32 2>
  %221 = shufflevector <4 x float> %220, <4 x float> %154, <4 x i32> <i32 0, i32 5, i32 2, i32 3>
  %222 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %221, <4 x float> %212, <4 x float> %219)
  %223 = fsub <4 x float> %213, %222
  store <4 x float> %223, ptr %194, align 4, !tbaa !5
  %224 = getelementptr inbounds i8, ptr %0, i64 32
  %225 = getelementptr inbounds i8, ptr %0, i64 48
  %226 = fmul float %182, %126
  %227 = extractelement <2 x float> %123, i64 0
  %228 = tail call float @llvm.fmuladd.f32(float %227, float %176, float %226)
  %229 = tail call float @llvm.fmuladd.f32(float %131, float %187, float %228)
  %230 = extractelement <2 x float> %136, i64 0
  %231 = tail call float @llvm.fmuladd.f32(float %230, float %192, float %229)
  %232 = fdiv float 1.000000e+00, %231
  %233 = load <4 x float>, ptr %0, align 4, !tbaa !5
  %234 = insertelement <4 x float> poison, float %232, i64 0
  %235 = shufflevector <4 x float> %234, <4 x float> poison, <4 x i32> zeroinitializer
  %236 = fmul <4 x float> %235, %233
  store <4 x float> %236, ptr %0, align 4, !tbaa !5
  %237 = load <4 x float>, ptr %194, align 4, !tbaa !5
  %238 = fmul <4 x float> %235, %237
  store <4 x float> %238, ptr %194, align 4, !tbaa !5
  %239 = insertelement <4 x float> %198, float %133, i64 2
  %240 = insertelement <4 x float> %239, float %128, i64 3
  %241 = shufflevector <2 x float> %136, <2 x float> poison, <4 x i32> <i32 1, i32 poison, i32 0, i32 poison>
  %242 = insertelement <4 x float> %241, float %131, i64 3
  %243 = shufflevector <4 x float> %242, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 2, i32 3>
  %244 = fmul <4 x float> %240, %243
  %245 = insertelement <4 x float> poison, float %128, i64 0
  %246 = shufflevector <4 x float> %245, <4 x float> %204, <4 x i32> <i32 0, i32 5, i32 4, i32 poison>
  %247 = insertelement <4 x float> %246, float %133, i64 3
  %248 = shufflevector <4 x float> %210, <4 x float> %204, <4 x i32> <i32 0, i32 poison, i32 2, i32 4>
  %249 = shufflevector <4 x float> %248, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 2, i32 3>
  %250 = fmul <4 x float> %247, %249
  %251 = shufflevector <2 x float> %123, <2 x float> poison, <4 x i32> <i32 1, i32 poison, i32 0, i32 poison>
  %252 = insertelement <4 x float> %251, float %133, i64 3
  %253 = shufflevector <4 x float> %252, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 2, i32 3>
  %254 = insertelement <4 x float> %203, float %131, i64 1
  %255 = insertelement <4 x float> %254, float %128, i64 2
  %256 = shufflevector <4 x float> %255, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 0>
  %257 = fmul <4 x float> %253, %256
  %258 = shufflevector <4 x float> %257, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
  %259 = shufflevector <2 x float> %147, <2 x float> %143, <4 x i32> <i32 1, i32 3, i32 1, i32 3>
  %260 = fmul <4 x float> %259, %250
  %261 = shufflevector <2 x float> %143, <2 x float> %140, <4 x i32> <i32 1, i32 3, i32 3, i32 3>
  %262 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %244, <4 x float> %261, <4 x float> %260)
  %263 = shufflevector <2 x float> %161, <2 x float> %147, <4 x i32> <i32 1, i32 1, i32 1, i32 3>
  %264 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %258, <4 x float> %263, <4 x float> %262)
  %265 = shufflevector <4 x float> %244, <4 x float> %250, <4 x i32> <i32 1, i32 6, i32 5, i32 poison>
  %266 = shufflevector <4 x float> %265, <4 x float> %257, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
  %267 = fmul <4 x float> %259, %266
  %268 = shufflevector <4 x float> %244, <4 x float> %250, <4 x i32> <i32 2, i32 4, i32 0, i32 poison>
  %269 = shufflevector <4 x float> %268, <4 x float> %257, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
  %270 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %269, <4 x float> %261, <4 x float> %267)
  %271 = shufflevector <4 x float> %244, <4 x float> %257, <4 x i32> <i32 3, i32 4, i32 poison, i32 6>
  %272 = shufflevector <4 x float> %271, <4 x float> %250, <4 x i32> <i32 0, i32 1, i32 7, i32 3>
  %273 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %272, <4 x float> %263, <4 x float> %270)
  %274 = fsub <4 x float> %264, %273
  %275 = fmul <4 x float> %235, %274
  %276 = shufflevector <4 x float> %275, <4 x float> poison, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x float> %276, ptr %224, align 4, !tbaa !5
  %277 = shufflevector <2 x float> %161, <2 x float> %142, <4 x i32> <i32 0, i32 3, i32 0, i32 3>
  %278 = shufflevector <4 x float> %244, <4 x float> %257, <4 x i32> <i32 3, i32 0, i32 4, i32 7>
  %279 = fmul <4 x float> %277, %278
  %280 = shufflevector <4 x float> %244, <4 x float> %250, <4 x i32> <i32 1, i32 7, i32 6, i32 poison>
  %281 = shufflevector <4 x float> %280, <4 x float> %257, <4 x i32> <i32 0, i32 1, i32 2, i32 6>
  %282 = shufflevector <2 x float> %147, <2 x float> %162, <4 x i32> <i32 0, i32 3, i32 poison, i32 0>
  %283 = shufflevector <4 x float> %282, <4 x float> %146, <4 x i32> <i32 0, i32 1, i32 4, i32 3>
  %284 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %281, <4 x float> %283, <4 x float> %279)
  %285 = shufflevector <4 x float> %244, <4 x float> %250, <4 x i32> <i32 2, i32 5, i32 4, i32 poison>
  %286 = shufflevector <4 x float> %285, <4 x float> %257, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
  %287 = shufflevector <2 x float> %143, <2 x float> %147, <4 x i32> <i32 0, i32 2, i32 poison, i32 0>
  %288 = shufflevector <4 x float> %287, <4 x float> %141, <4 x i32> <i32 0, i32 1, i32 4, i32 3>
  %289 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %286, <4 x float> %288, <4 x float> %284)
  %290 = shufflevector <2 x float> %143, <2 x float> %162, <4 x i32> <i32 0, i32 3, i32 poison, i32 poison>
  %291 = shufflevector <4 x float> %290, <4 x float> %288, <4 x i32> <i32 0, i32 1, i32 6, i32 5>
  %292 = shufflevector <4 x float> %244, <4 x float> %257, <4 x i32> <i32 0, i32 5, i32 1, i32 4>
  %293 = fmul <4 x float> %291, %292
  %294 = shufflevector <4 x float> %257, <4 x float> %250, <4 x i32> <i32 3, i32 6, i32 2, i32 7>
  %295 = shufflevector <2 x float> %161, <2 x float> %147, <4 x i32> <i32 0, i32 2, i32 0, i32 poison>
  %296 = shufflevector <4 x float> %295, <4 x float> %145, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
  %297 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %294, <4 x float> %296, <4 x float> %293)
  %298 = shufflevector <4 x float> %250, <4 x float> %244, <4 x i32> <i32 0, i32 6, i32 1, i32 7>
  %299 = shufflevector <2 x float> %147, <2 x float> %142, <4 x i32> <i32 0, i32 3, i32 poison, i32 3>
  %300 = shufflevector <4 x float> %299, <4 x float> %144, <4 x i32> <i32 0, i32 1, i32 4, i32 3>
  %301 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %298, <4 x float> %300, <4 x float> %297)
  %302 = fsub <4 x float> %289, %301
  %303 = fmul <4 x float> %235, %302
  store <4 x float> %303, ptr %225, align 4, !tbaa !5
  br label %304

304:                                              ; preds = %122, %4
  %.0160 = phi float [ %5, %4 ], [ %231, %122 ]
  ret float %.0160
}

; Function Attrs: mustprogress nounwind uwtable
declare dso_local noundef float @_ZNK8ImGuizmo8matrix_t14GetDeterminantEv(ptr noundef nonnull align 4 dereferenceable(64)) local_unnamed_addr #1 align 2

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x float> @llvm.fmuladd.v2f32(<2 x float>, <2 x float>, <2 x float>) #2

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #2

attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #1 = { mustprogress nounwind 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 #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }

!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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C++ TBAA"}


; Effective O3 passes: DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,LoopRotatePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass