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

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

%union.HMM_Mat2 = type { [2 x [2 x float]] }
%struct.hmt_testresult_struct = type { i32, i32 }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 x i8], align 1

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

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

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z35_hmt_test_Multiplication_Mat2ScalarP21hmt_testresult_struct(ptr noundef %0) #4 {
  %2 = alloca ptr, align 8
  %3 = alloca %union.HMM_Mat2, align 4
  %4 = alloca float, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca %union.HMM_Mat2, align 4
  %10 = alloca %union.HMM_Mat2, align 4
  %11 = alloca float, align 4
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca %union.HMM_Mat2, align 4
  %20 = alloca %union.HMM_Mat2, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca %union.HMM_Mat2, align 4
  %30 = alloca %union.HMM_Mat2, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca float, align 4
  %34 = alloca float, align 4
  %35 = alloca float, align 4
  %36 = alloca float, align 4
  %37 = alloca float, align 4
  %38 = alloca float, align 4
  %39 = alloca %union.HMM_Mat2, align 4
  %40 = alloca %union.HMM_Mat2, align 4
  %41 = alloca float, align 4
  %42 = alloca float, align 4
  %43 = alloca float, align 4
  %44 = alloca float, align 4
  %45 = alloca float, align 4
  %46 = alloca float, align 4
  %47 = alloca float, align 4
  %48 = alloca float, align 4
  %49 = alloca float, align 4
  %50 = alloca float, align 4
  %51 = alloca float, align 4
  %52 = alloca float, align 4
  %53 = alloca float, align 4
  %54 = alloca float, align 4
  %55 = alloca float, align 4
  %56 = alloca float, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %3) #6
  %57 = call { <2 x float>, <2 x float> } @_ZL6HMM_M2v()
  %58 = getelementptr inbounds %union.HMM_Mat2, ptr %3, i32 0, i32 0
  %59 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %58, i32 0, i32 0
  %60 = extractvalue { <2 x float>, <2 x float> } %57, 0
  store <2 x float> %60, ptr %59, align 4
  %61 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %58, i32 0, i32 1
  %62 = extractvalue { <2 x float>, <2 x float> } %57, 1
  store <2 x float> %62, ptr %61, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #6
  store float 1.000000e+01, ptr %4, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #6
  store i32 1, ptr %5, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  store i32 0, ptr %6, align 4, !tbaa !11
  br label %63

63:                                               ; preds = %86, %1
  %64 = load i32, ptr %6, align 4, !tbaa !11
  %65 = icmp slt i32 %64, 2
  br i1 %65, label %67, label %66

66:                                               ; preds = %63
  store i32 2, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  br label %89

67:                                               ; preds = %63
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  store i32 0, ptr %8, align 4, !tbaa !11
  br label %68

68:                                               ; preds = %82, %67
  %69 = load i32, ptr %8, align 4, !tbaa !11
  %70 = icmp slt i32 %69, 2
  br i1 %70, label %72, label %71

71:                                               ; preds = %68
  store i32 5, ptr %7, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  br label %85

72:                                               ; preds = %68
  %73 = load i32, ptr %5, align 4, !tbaa !11
  %74 = add nsw i32 %73, 1
  store i32 %74, ptr %5, align 4, !tbaa !11
  %75 = sitofp i32 %73 to float
  %76 = load i32, ptr %6, align 4, !tbaa !11
  %77 = sext i32 %76 to i64
  %78 = getelementptr inbounds [2 x [2 x float]], ptr %3, i64 0, i64 %77
  %79 = load i32, ptr %8, align 4, !tbaa !11
  %80 = sext i32 %79 to i64
  %81 = getelementptr inbounds [2 x float], ptr %78, i64 0, i64 %80
  store float %75, ptr %81, align 4, !tbaa !13
  br label %82

82:                                               ; preds = %72
  %83 = load i32, ptr %8, align 4, !tbaa !11
  %84 = add nsw i32 %83, 1
  store i32 %84, ptr %8, align 4, !tbaa !11
  br label %68, !llvm.loop !14

85:                                               ; preds = %71
  br label %86

86:                                               ; preds = %85
  %87 = load i32, ptr %6, align 4, !tbaa !11
  %88 = add nsw i32 %87, 1
  store i32 %88, ptr %6, align 4, !tbaa !11
  br label %63, !llvm.loop !16

89:                                               ; preds = %66
  call void @llvm.lifetime.start.p0(i64 16, ptr %9) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %10, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !17
  %90 = load float, ptr %4, align 4, !tbaa !9
  %91 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 0
  %92 = load <2 x float>, ptr %91, align 4
  %93 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 1
  %94 = load <2 x float>, ptr %93, align 4
  %95 = call { <2 x float>, <2 x float> } @_ZL10HMM_MulM2F8HMM_Mat2f(<2 x float> %92, <2 x float> %94, float noundef %90)
  %96 = getelementptr inbounds %union.HMM_Mat2, ptr %9, i32 0, i32 0
  %97 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %96, i32 0, i32 0
  %98 = extractvalue { <2 x float>, <2 x float> } %95, 0
  store <2 x float> %98, ptr %97, align 4
  %99 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %96, i32 0, i32 1
  %100 = extractvalue { <2 x float>, <2 x float> } %95, 1
  store <2 x float> %100, ptr %99, align 4
  %101 = load ptr, ptr %2, align 8, !tbaa !5
  %102 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %101, i32 0, i32 0
  %103 = load i32, ptr %102, align 4, !tbaa !18
  %104 = add nsw i32 %103, 1
  store i32 %104, ptr %102, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  %105 = getelementptr inbounds [2 x [2 x float]], ptr %9, i64 0, i64 0
  %106 = getelementptr inbounds [2 x float], ptr %105, i64 0, i64 0
  %107 = load float, ptr %106, align 4, !tbaa !13
  store float %107, ptr %11, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  %108 = load float, ptr %11, align 4, !tbaa !9
  %109 = fsub float %108, 1.000000e+01
  store float %109, ptr %12, align 4, !tbaa !9
  %110 = load float, ptr %12, align 4, !tbaa !9
  %111 = fcmp olt float %110, 0xBE80000000000000
  br i1 %111, label %115, label %112

112:                                              ; preds = %89
  %113 = load float, ptr %12, align 4, !tbaa !9
  %114 = fcmp olt float 0x3E80000000000000, %113
  br i1 %114, label %115, label %126

115:                                              ; preds = %112, %89
  %116 = load ptr, ptr %2, align 8, !tbaa !5
  %117 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %116, i32 0, i32 1
  %118 = load i32, ptr %117, align 4, !tbaa !20
  %119 = add nsw i32 %118, 1
  store i32 %119, ptr %117, align 4, !tbaa !20
  %120 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 283)
  %121 = load float, ptr %11, align 4, !tbaa !9
  %122 = fpext float %121 to double
  %123 = load float, ptr %12, align 4, !tbaa !9
  %124 = fpext float %123 to double
  %125 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+01, double noundef %122, double noundef %124)
  br label %126

126:                                              ; preds = %115, %112
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  %127 = load ptr, ptr %2, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %127, i32 0, i32 0
  %129 = load i32, ptr %128, align 4, !tbaa !18
  %130 = add nsw i32 %129, 1
  store i32 %130, ptr %128, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %131 = getelementptr inbounds [2 x [2 x float]], ptr %9, i64 0, i64 0
  %132 = getelementptr inbounds [2 x float], ptr %131, i64 0, i64 1
  %133 = load float, ptr %132, align 4, !tbaa !13
  store float %133, ptr %13, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  %134 = load float, ptr %13, align 4, !tbaa !9
  %135 = fsub float %134, 2.000000e+01
  store float %135, ptr %14, align 4, !tbaa !9
  %136 = load float, ptr %14, align 4, !tbaa !9
  %137 = fcmp olt float %136, 0xBE80000000000000
  br i1 %137, label %141, label %138

138:                                              ; preds = %126
  %139 = load float, ptr %14, align 4, !tbaa !9
  %140 = fcmp olt float 0x3E80000000000000, %139
  br i1 %140, label %141, label %152

141:                                              ; preds = %138, %126
  %142 = load ptr, ptr %2, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %142, i32 0, i32 1
  %144 = load i32, ptr %143, align 4, !tbaa !20
  %145 = add nsw i32 %144, 1
  store i32 %145, ptr %143, align 4, !tbaa !20
  %146 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 284)
  %147 = load float, ptr %13, align 4, !tbaa !9
  %148 = fpext float %147 to double
  %149 = load float, ptr %14, align 4, !tbaa !9
  %150 = fpext float %149 to double
  %151 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+01, double noundef %148, double noundef %150)
  br label %152

152:                                              ; preds = %141, %138
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  %153 = load ptr, ptr %2, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %153, i32 0, i32 0
  %155 = load i32, ptr %154, align 4, !tbaa !18
  %156 = add nsw i32 %155, 1
  store i32 %156, ptr %154, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #6
  %157 = getelementptr inbounds [2 x [2 x float]], ptr %9, i64 0, i64 1
  %158 = getelementptr inbounds [2 x float], ptr %157, i64 0, i64 0
  %159 = load float, ptr %158, align 4, !tbaa !13
  store float %159, ptr %15, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  %160 = load float, ptr %15, align 4, !tbaa !9
  %161 = fsub float %160, 3.000000e+01
  store float %161, ptr %16, align 4, !tbaa !9
  %162 = load float, ptr %16, align 4, !tbaa !9
  %163 = fcmp olt float %162, 0xBE80000000000000
  br i1 %163, label %167, label %164

164:                                              ; preds = %152
  %165 = load float, ptr %16, align 4, !tbaa !9
  %166 = fcmp olt float 0x3E80000000000000, %165
  br i1 %166, label %167, label %178

167:                                              ; preds = %164, %152
  %168 = load ptr, ptr %2, align 8, !tbaa !5
  %169 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %168, i32 0, i32 1
  %170 = load i32, ptr %169, align 4, !tbaa !20
  %171 = add nsw i32 %170, 1
  store i32 %171, ptr %169, align 4, !tbaa !20
  %172 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 285)
  %173 = load float, ptr %15, align 4, !tbaa !9
  %174 = fpext float %173 to double
  %175 = load float, ptr %16, align 4, !tbaa !9
  %176 = fpext float %175 to double
  %177 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+01, double noundef %174, double noundef %176)
  br label %178

178:                                              ; preds = %167, %164
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #6
  %179 = load ptr, ptr %2, align 8, !tbaa !5
  %180 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %179, i32 0, i32 0
  %181 = load i32, ptr %180, align 4, !tbaa !18
  %182 = add nsw i32 %181, 1
  store i32 %182, ptr %180, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  %183 = getelementptr inbounds [2 x [2 x float]], ptr %9, i64 0, i64 1
  %184 = getelementptr inbounds [2 x float], ptr %183, i64 0, i64 1
  %185 = load float, ptr %184, align 4, !tbaa !13
  store float %185, ptr %17, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  %186 = load float, ptr %17, align 4, !tbaa !9
  %187 = fsub float %186, 4.000000e+01
  store float %187, ptr %18, align 4, !tbaa !9
  %188 = load float, ptr %18, align 4, !tbaa !9
  %189 = fcmp olt float %188, 0xBE80000000000000
  br i1 %189, label %193, label %190

190:                                              ; preds = %178
  %191 = load float, ptr %18, align 4, !tbaa !9
  %192 = fcmp olt float 0x3E80000000000000, %191
  br i1 %192, label %193, label %204

193:                                              ; preds = %190, %178
  %194 = load ptr, ptr %2, align 8, !tbaa !5
  %195 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %194, i32 0, i32 1
  %196 = load i32, ptr %195, align 4, !tbaa !20
  %197 = add nsw i32 %196, 1
  store i32 %197, ptr %195, align 4, !tbaa !20
  %198 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 286)
  %199 = load float, ptr %17, align 4, !tbaa !9
  %200 = fpext float %199 to double
  %201 = load float, ptr %18, align 4, !tbaa !9
  %202 = fpext float %201 to double
  %203 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+01, double noundef %200, double noundef %202)
  br label %204

204:                                              ; preds = %193, %190
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %19) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %20, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !17
  %205 = load float, ptr %4, align 4, !tbaa !9
  %206 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %20, i32 0, i32 0
  %207 = load <2 x float>, ptr %206, align 4
  %208 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %20, i32 0, i32 1
  %209 = load <2 x float>, ptr %208, align 4
  %210 = call { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2f(<2 x float> %207, <2 x float> %209, float noundef %205)
  %211 = getelementptr inbounds %union.HMM_Mat2, ptr %19, i32 0, i32 0
  %212 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %211, i32 0, i32 0
  %213 = extractvalue { <2 x float>, <2 x float> } %210, 0
  store <2 x float> %213, ptr %212, align 4
  %214 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %211, i32 0, i32 1
  %215 = extractvalue { <2 x float>, <2 x float> } %210, 1
  store <2 x float> %215, ptr %214, align 4
  %216 = load ptr, ptr %2, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %216, i32 0, i32 0
  %218 = load i32, ptr %217, align 4, !tbaa !18
  %219 = add nsw i32 %218, 1
  store i32 %219, ptr %217, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  %220 = getelementptr inbounds [2 x [2 x float]], ptr %19, i64 0, i64 0
  %221 = getelementptr inbounds [2 x float], ptr %220, i64 0, i64 0
  %222 = load float, ptr %221, align 4, !tbaa !13
  store float %222, ptr %21, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  %223 = load float, ptr %21, align 4, !tbaa !9
  %224 = fsub float %223, 1.000000e+01
  store float %224, ptr %22, align 4, !tbaa !9
  %225 = load float, ptr %22, align 4, !tbaa !9
  %226 = fcmp olt float %225, 0xBE80000000000000
  br i1 %226, label %230, label %227

227:                                              ; preds = %204
  %228 = load float, ptr %22, align 4, !tbaa !9
  %229 = fcmp olt float 0x3E80000000000000, %228
  br i1 %229, label %230, label %241

230:                                              ; preds = %227, %204
  %231 = load ptr, ptr %2, align 8, !tbaa !5
  %232 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %231, i32 0, i32 1
  %233 = load i32, ptr %232, align 4, !tbaa !20
  %234 = add nsw i32 %233, 1
  store i32 %234, ptr %232, align 4, !tbaa !20
  %235 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 291)
  %236 = load float, ptr %21, align 4, !tbaa !9
  %237 = fpext float %236 to double
  %238 = load float, ptr %22, align 4, !tbaa !9
  %239 = fpext float %238 to double
  %240 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+01, double noundef %237, double noundef %239)
  br label %241

241:                                              ; preds = %230, %227
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  %242 = load ptr, ptr %2, align 8, !tbaa !5
  %243 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %242, i32 0, i32 0
  %244 = load i32, ptr %243, align 4, !tbaa !18
  %245 = add nsw i32 %244, 1
  store i32 %245, ptr %243, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %246 = getelementptr inbounds [2 x [2 x float]], ptr %19, i64 0, i64 0
  %247 = getelementptr inbounds [2 x float], ptr %246, i64 0, i64 1
  %248 = load float, ptr %247, align 4, !tbaa !13
  store float %248, ptr %23, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  %249 = load float, ptr %23, align 4, !tbaa !9
  %250 = fsub float %249, 2.000000e+01
  store float %250, ptr %24, align 4, !tbaa !9
  %251 = load float, ptr %24, align 4, !tbaa !9
  %252 = fcmp olt float %251, 0xBE80000000000000
  br i1 %252, label %256, label %253

253:                                              ; preds = %241
  %254 = load float, ptr %24, align 4, !tbaa !9
  %255 = fcmp olt float 0x3E80000000000000, %254
  br i1 %255, label %256, label %267

256:                                              ; preds = %253, %241
  %257 = load ptr, ptr %2, align 8, !tbaa !5
  %258 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %257, i32 0, i32 1
  %259 = load i32, ptr %258, align 4, !tbaa !20
  %260 = add nsw i32 %259, 1
  store i32 %260, ptr %258, align 4, !tbaa !20
  %261 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 292)
  %262 = load float, ptr %23, align 4, !tbaa !9
  %263 = fpext float %262 to double
  %264 = load float, ptr %24, align 4, !tbaa !9
  %265 = fpext float %264 to double
  %266 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+01, double noundef %263, double noundef %265)
  br label %267

267:                                              ; preds = %256, %253
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  %268 = load ptr, ptr %2, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %268, i32 0, i32 0
  %270 = load i32, ptr %269, align 4, !tbaa !18
  %271 = add nsw i32 %270, 1
  store i32 %271, ptr %269, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #6
  %272 = getelementptr inbounds [2 x [2 x float]], ptr %19, i64 0, i64 1
  %273 = getelementptr inbounds [2 x float], ptr %272, i64 0, i64 0
  %274 = load float, ptr %273, align 4, !tbaa !13
  store float %274, ptr %25, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %275 = load float, ptr %25, align 4, !tbaa !9
  %276 = fsub float %275, 3.000000e+01
  store float %276, ptr %26, align 4, !tbaa !9
  %277 = load float, ptr %26, align 4, !tbaa !9
  %278 = fcmp olt float %277, 0xBE80000000000000
  br i1 %278, label %282, label %279

279:                                              ; preds = %267
  %280 = load float, ptr %26, align 4, !tbaa !9
  %281 = fcmp olt float 0x3E80000000000000, %280
  br i1 %281, label %282, label %293

282:                                              ; preds = %279, %267
  %283 = load ptr, ptr %2, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %283, i32 0, i32 1
  %285 = load i32, ptr %284, align 4, !tbaa !20
  %286 = add nsw i32 %285, 1
  store i32 %286, ptr %284, align 4, !tbaa !20
  %287 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 293)
  %288 = load float, ptr %25, align 4, !tbaa !9
  %289 = fpext float %288 to double
  %290 = load float, ptr %26, align 4, !tbaa !9
  %291 = fpext float %290 to double
  %292 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+01, double noundef %289, double noundef %291)
  br label %293

293:                                              ; preds = %282, %279
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  %294 = load ptr, ptr %2, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %294, i32 0, i32 0
  %296 = load i32, ptr %295, align 4, !tbaa !18
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %295, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  %298 = getelementptr inbounds [2 x [2 x float]], ptr %19, i64 0, i64 1
  %299 = getelementptr inbounds [2 x float], ptr %298, i64 0, i64 1
  %300 = load float, ptr %299, align 4, !tbaa !13
  store float %300, ptr %27, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %301 = load float, ptr %27, align 4, !tbaa !9
  %302 = fsub float %301, 4.000000e+01
  store float %302, ptr %28, align 4, !tbaa !9
  %303 = load float, ptr %28, align 4, !tbaa !9
  %304 = fcmp olt float %303, 0xBE80000000000000
  br i1 %304, label %308, label %305

305:                                              ; preds = %293
  %306 = load float, ptr %28, align 4, !tbaa !9
  %307 = fcmp olt float 0x3E80000000000000, %306
  br i1 %307, label %308, label %319

308:                                              ; preds = %305, %293
  %309 = load ptr, ptr %2, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %309, i32 0, i32 1
  %311 = load i32, ptr %310, align 4, !tbaa !20
  %312 = add nsw i32 %311, 1
  store i32 %312, ptr %310, align 4, !tbaa !20
  %313 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 294)
  %314 = load float, ptr %27, align 4, !tbaa !9
  %315 = fpext float %314 to double
  %316 = load float, ptr %28, align 4, !tbaa !9
  %317 = fpext float %316 to double
  %318 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+01, double noundef %315, double noundef %317)
  br label %319

319:                                              ; preds = %308, %305
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %19) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %29) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %30, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !17
  %320 = load float, ptr %4, align 4, !tbaa !9
  %321 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %30, i32 0, i32 0
  %322 = load <2 x float>, ptr %321, align 4
  %323 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %30, i32 0, i32 1
  %324 = load <2 x float>, ptr %323, align 4
  %325 = call { <2 x float>, <2 x float> } @_Zml8HMM_Mat2f(<2 x float> %322, <2 x float> %324, float noundef %320)
  %326 = getelementptr inbounds %union.HMM_Mat2, ptr %29, i32 0, i32 0
  %327 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %326, i32 0, i32 0
  %328 = extractvalue { <2 x float>, <2 x float> } %325, 0
  store <2 x float> %328, ptr %327, align 4
  %329 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %326, i32 0, i32 1
  %330 = extractvalue { <2 x float>, <2 x float> } %325, 1
  store <2 x float> %330, ptr %329, align 4
  %331 = load ptr, ptr %2, align 8, !tbaa !5
  %332 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %331, i32 0, i32 0
  %333 = load i32, ptr %332, align 4, !tbaa !18
  %334 = add nsw i32 %333, 1
  store i32 %334, ptr %332, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %335 = getelementptr inbounds [2 x [2 x float]], ptr %29, i64 0, i64 0
  %336 = getelementptr inbounds [2 x float], ptr %335, i64 0, i64 0
  %337 = load float, ptr %336, align 4, !tbaa !13
  store float %337, ptr %31, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  %338 = load float, ptr %31, align 4, !tbaa !9
  %339 = fsub float %338, 1.000000e+01
  store float %339, ptr %32, align 4, !tbaa !9
  %340 = load float, ptr %32, align 4, !tbaa !9
  %341 = fcmp olt float %340, 0xBE80000000000000
  br i1 %341, label %345, label %342

342:                                              ; preds = %319
  %343 = load float, ptr %32, align 4, !tbaa !9
  %344 = fcmp olt float 0x3E80000000000000, %343
  br i1 %344, label %345, label %356

345:                                              ; preds = %342, %319
  %346 = load ptr, ptr %2, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %346, i32 0, i32 1
  %348 = load i32, ptr %347, align 4, !tbaa !20
  %349 = add nsw i32 %348, 1
  store i32 %349, ptr %347, align 4, !tbaa !20
  %350 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 300)
  %351 = load float, ptr %31, align 4, !tbaa !9
  %352 = fpext float %351 to double
  %353 = load float, ptr %32, align 4, !tbaa !9
  %354 = fpext float %353 to double
  %355 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+01, double noundef %352, double noundef %354)
  br label %356

356:                                              ; preds = %345, %342
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  %357 = load ptr, ptr %2, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %357, i32 0, i32 0
  %359 = load i32, ptr %358, align 4, !tbaa !18
  %360 = add nsw i32 %359, 1
  store i32 %360, ptr %358, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  %361 = getelementptr inbounds [2 x [2 x float]], ptr %29, i64 0, i64 0
  %362 = getelementptr inbounds [2 x float], ptr %361, i64 0, i64 1
  %363 = load float, ptr %362, align 4, !tbaa !13
  store float %363, ptr %33, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  %364 = load float, ptr %33, align 4, !tbaa !9
  %365 = fsub float %364, 2.000000e+01
  store float %365, ptr %34, align 4, !tbaa !9
  %366 = load float, ptr %34, align 4, !tbaa !9
  %367 = fcmp olt float %366, 0xBE80000000000000
  br i1 %367, label %371, label %368

368:                                              ; preds = %356
  %369 = load float, ptr %34, align 4, !tbaa !9
  %370 = fcmp olt float 0x3E80000000000000, %369
  br i1 %370, label %371, label %382

371:                                              ; preds = %368, %356
  %372 = load ptr, ptr %2, align 8, !tbaa !5
  %373 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %372, i32 0, i32 1
  %374 = load i32, ptr %373, align 4, !tbaa !20
  %375 = add nsw i32 %374, 1
  store i32 %375, ptr %373, align 4, !tbaa !20
  %376 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 301)
  %377 = load float, ptr %33, align 4, !tbaa !9
  %378 = fpext float %377 to double
  %379 = load float, ptr %34, align 4, !tbaa !9
  %380 = fpext float %379 to double
  %381 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+01, double noundef %378, double noundef %380)
  br label %382

382:                                              ; preds = %371, %368
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  %383 = load ptr, ptr %2, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %383, i32 0, i32 0
  %385 = load i32, ptr %384, align 4, !tbaa !18
  %386 = add nsw i32 %385, 1
  store i32 %386, ptr %384, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  %387 = getelementptr inbounds [2 x [2 x float]], ptr %29, i64 0, i64 1
  %388 = getelementptr inbounds [2 x float], ptr %387, i64 0, i64 0
  %389 = load float, ptr %388, align 4, !tbaa !13
  store float %389, ptr %35, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %390 = load float, ptr %35, align 4, !tbaa !9
  %391 = fsub float %390, 3.000000e+01
  store float %391, ptr %36, align 4, !tbaa !9
  %392 = load float, ptr %36, align 4, !tbaa !9
  %393 = fcmp olt float %392, 0xBE80000000000000
  br i1 %393, label %397, label %394

394:                                              ; preds = %382
  %395 = load float, ptr %36, align 4, !tbaa !9
  %396 = fcmp olt float 0x3E80000000000000, %395
  br i1 %396, label %397, label %408

397:                                              ; preds = %394, %382
  %398 = load ptr, ptr %2, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %398, i32 0, i32 1
  %400 = load i32, ptr %399, align 4, !tbaa !20
  %401 = add nsw i32 %400, 1
  store i32 %401, ptr %399, align 4, !tbaa !20
  %402 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 302)
  %403 = load float, ptr %35, align 4, !tbaa !9
  %404 = fpext float %403 to double
  %405 = load float, ptr %36, align 4, !tbaa !9
  %406 = fpext float %405 to double
  %407 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+01, double noundef %404, double noundef %406)
  br label %408

408:                                              ; preds = %397, %394
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  %409 = load ptr, ptr %2, align 8, !tbaa !5
  %410 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %409, i32 0, i32 0
  %411 = load i32, ptr %410, align 4, !tbaa !18
  %412 = add nsw i32 %411, 1
  store i32 %412, ptr %410, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  %413 = getelementptr inbounds [2 x [2 x float]], ptr %29, i64 0, i64 1
  %414 = getelementptr inbounds [2 x float], ptr %413, i64 0, i64 1
  %415 = load float, ptr %414, align 4, !tbaa !13
  store float %415, ptr %37, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  %416 = load float, ptr %37, align 4, !tbaa !9
  %417 = fsub float %416, 4.000000e+01
  store float %417, ptr %38, align 4, !tbaa !9
  %418 = load float, ptr %38, align 4, !tbaa !9
  %419 = fcmp olt float %418, 0xBE80000000000000
  br i1 %419, label %423, label %420

420:                                              ; preds = %408
  %421 = load float, ptr %38, align 4, !tbaa !9
  %422 = fcmp olt float 0x3E80000000000000, %421
  br i1 %422, label %423, label %434

423:                                              ; preds = %420, %408
  %424 = load ptr, ptr %2, align 8, !tbaa !5
  %425 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %424, i32 0, i32 1
  %426 = load i32, ptr %425, align 4, !tbaa !20
  %427 = add nsw i32 %426, 1
  store i32 %427, ptr %425, align 4, !tbaa !20
  %428 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 303)
  %429 = load float, ptr %37, align 4, !tbaa !9
  %430 = fpext float %429 to double
  %431 = load float, ptr %38, align 4, !tbaa !9
  %432 = fpext float %431 to double
  %433 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+01, double noundef %430, double noundef %432)
  br label %434

434:                                              ; preds = %423, %420
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %39) #6
  %435 = load float, ptr %4, align 4, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %40, ptr align 4 %3, i64 16, i1 false), !tbaa.struct !17
  %436 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %40, i32 0, i32 0
  %437 = load <2 x float>, ptr %436, align 4
  %438 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %40, i32 0, i32 1
  %439 = load <2 x float>, ptr %438, align 4
  %440 = call { <2 x float>, <2 x float> } @_Zmlf8HMM_Mat2(float noundef %435, <2 x float> %437, <2 x float> %439)
  %441 = getelementptr inbounds %union.HMM_Mat2, ptr %39, i32 0, i32 0
  %442 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %441, i32 0, i32 0
  %443 = extractvalue { <2 x float>, <2 x float> } %440, 0
  store <2 x float> %443, ptr %442, align 4
  %444 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %441, i32 0, i32 1
  %445 = extractvalue { <2 x float>, <2 x float> } %440, 1
  store <2 x float> %445, ptr %444, align 4
  %446 = load ptr, ptr %2, align 8, !tbaa !5
  %447 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %446, i32 0, i32 0
  %448 = load i32, ptr %447, align 4, !tbaa !18
  %449 = add nsw i32 %448, 1
  store i32 %449, ptr %447, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  %450 = getelementptr inbounds [2 x [2 x float]], ptr %39, i64 0, i64 0
  %451 = getelementptr inbounds [2 x float], ptr %450, i64 0, i64 0
  %452 = load float, ptr %451, align 4, !tbaa !13
  store float %452, ptr %41, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  %453 = load float, ptr %41, align 4, !tbaa !9
  %454 = fsub float %453, 1.000000e+01
  store float %454, ptr %42, align 4, !tbaa !9
  %455 = load float, ptr %42, align 4, !tbaa !9
  %456 = fcmp olt float %455, 0xBE80000000000000
  br i1 %456, label %460, label %457

457:                                              ; preds = %434
  %458 = load float, ptr %42, align 4, !tbaa !9
  %459 = fcmp olt float 0x3E80000000000000, %458
  br i1 %459, label %460, label %471

460:                                              ; preds = %457, %434
  %461 = load ptr, ptr %2, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %461, i32 0, i32 1
  %463 = load i32, ptr %462, align 4, !tbaa !20
  %464 = add nsw i32 %463, 1
  store i32 %464, ptr %462, align 4, !tbaa !20
  %465 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 307)
  %466 = load float, ptr %41, align 4, !tbaa !9
  %467 = fpext float %466 to double
  %468 = load float, ptr %42, align 4, !tbaa !9
  %469 = fpext float %468 to double
  %470 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+01, double noundef %467, double noundef %469)
  br label %471

471:                                              ; preds = %460, %457
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  %472 = load ptr, ptr %2, align 8, !tbaa !5
  %473 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %472, i32 0, i32 0
  %474 = load i32, ptr %473, align 4, !tbaa !18
  %475 = add nsw i32 %474, 1
  store i32 %475, ptr %473, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %476 = getelementptr inbounds [2 x [2 x float]], ptr %39, i64 0, i64 0
  %477 = getelementptr inbounds [2 x float], ptr %476, i64 0, i64 1
  %478 = load float, ptr %477, align 4, !tbaa !13
  store float %478, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  %479 = load float, ptr %43, align 4, !tbaa !9
  %480 = fsub float %479, 2.000000e+01
  store float %480, ptr %44, align 4, !tbaa !9
  %481 = load float, ptr %44, align 4, !tbaa !9
  %482 = fcmp olt float %481, 0xBE80000000000000
  br i1 %482, label %486, label %483

483:                                              ; preds = %471
  %484 = load float, ptr %44, align 4, !tbaa !9
  %485 = fcmp olt float 0x3E80000000000000, %484
  br i1 %485, label %486, label %497

486:                                              ; preds = %483, %471
  %487 = load ptr, ptr %2, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %487, i32 0, i32 1
  %489 = load i32, ptr %488, align 4, !tbaa !20
  %490 = add nsw i32 %489, 1
  store i32 %490, ptr %488, align 4, !tbaa !20
  %491 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 308)
  %492 = load float, ptr %43, align 4, !tbaa !9
  %493 = fpext float %492 to double
  %494 = load float, ptr %44, align 4, !tbaa !9
  %495 = fpext float %494 to double
  %496 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+01, double noundef %493, double noundef %495)
  br label %497

497:                                              ; preds = %486, %483
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  %498 = load ptr, ptr %2, align 8, !tbaa !5
  %499 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %498, i32 0, i32 0
  %500 = load i32, ptr %499, align 4, !tbaa !18
  %501 = add nsw i32 %500, 1
  store i32 %501, ptr %499, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %502 = getelementptr inbounds [2 x [2 x float]], ptr %39, i64 0, i64 1
  %503 = getelementptr inbounds [2 x float], ptr %502, i64 0, i64 0
  %504 = load float, ptr %503, align 4, !tbaa !13
  store float %504, ptr %45, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %505 = load float, ptr %45, align 4, !tbaa !9
  %506 = fsub float %505, 3.000000e+01
  store float %506, ptr %46, align 4, !tbaa !9
  %507 = load float, ptr %46, align 4, !tbaa !9
  %508 = fcmp olt float %507, 0xBE80000000000000
  br i1 %508, label %512, label %509

509:                                              ; preds = %497
  %510 = load float, ptr %46, align 4, !tbaa !9
  %511 = fcmp olt float 0x3E80000000000000, %510
  br i1 %511, label %512, label %523

512:                                              ; preds = %509, %497
  %513 = load ptr, ptr %2, align 8, !tbaa !5
  %514 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %513, i32 0, i32 1
  %515 = load i32, ptr %514, align 4, !tbaa !20
  %516 = add nsw i32 %515, 1
  store i32 %516, ptr %514, align 4, !tbaa !20
  %517 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 309)
  %518 = load float, ptr %45, align 4, !tbaa !9
  %519 = fpext float %518 to double
  %520 = load float, ptr %46, align 4, !tbaa !9
  %521 = fpext float %520 to double
  %522 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+01, double noundef %519, double noundef %521)
  br label %523

523:                                              ; preds = %512, %509
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  %524 = load ptr, ptr %2, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %524, i32 0, i32 0
  %526 = load i32, ptr %525, align 4, !tbaa !18
  %527 = add nsw i32 %526, 1
  store i32 %527, ptr %525, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #6
  %528 = getelementptr inbounds [2 x [2 x float]], ptr %39, i64 0, i64 1
  %529 = getelementptr inbounds [2 x float], ptr %528, i64 0, i64 1
  %530 = load float, ptr %529, align 4, !tbaa !13
  store float %530, ptr %47, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  %531 = load float, ptr %47, align 4, !tbaa !9
  %532 = fsub float %531, 4.000000e+01
  store float %532, ptr %48, align 4, !tbaa !9
  %533 = load float, ptr %48, align 4, !tbaa !9
  %534 = fcmp olt float %533, 0xBE80000000000000
  br i1 %534, label %538, label %535

535:                                              ; preds = %523
  %536 = load float, ptr %48, align 4, !tbaa !9
  %537 = fcmp olt float 0x3E80000000000000, %536
  br i1 %537, label %538, label %549

538:                                              ; preds = %535, %523
  %539 = load ptr, ptr %2, align 8, !tbaa !5
  %540 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %539, i32 0, i32 1
  %541 = load i32, ptr %540, align 4, !tbaa !20
  %542 = add nsw i32 %541, 1
  store i32 %542, ptr %540, align 4, !tbaa !20
  %543 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 310)
  %544 = load float, ptr %47, align 4, !tbaa !9
  %545 = fpext float %544 to double
  %546 = load float, ptr %48, align 4, !tbaa !9
  %547 = fpext float %546 to double
  %548 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+01, double noundef %545, double noundef %547)
  br label %549

549:                                              ; preds = %538, %535
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #6
  %550 = load float, ptr %4, align 4, !tbaa !9
  %551 = call noundef nonnull align 4 dereferenceable(16) ptr @_ZmLR8HMM_Mat2f(ptr noundef nonnull align 4 dereferenceable(16) %3, float noundef %550)
  %552 = load ptr, ptr %2, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %552, i32 0, i32 0
  %554 = load i32, ptr %553, align 4, !tbaa !18
  %555 = add nsw i32 %554, 1
  store i32 %555, ptr %553, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  %556 = getelementptr inbounds [2 x [2 x float]], ptr %3, i64 0, i64 0
  %557 = getelementptr inbounds [2 x float], ptr %556, i64 0, i64 0
  %558 = load float, ptr %557, align 4, !tbaa !13
  store float %558, ptr %49, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  %559 = load float, ptr %49, align 4, !tbaa !9
  %560 = fsub float %559, 1.000000e+01
  store float %560, ptr %50, align 4, !tbaa !9
  %561 = load float, ptr %50, align 4, !tbaa !9
  %562 = fcmp olt float %561, 0xBE80000000000000
  br i1 %562, label %566, label %563

563:                                              ; preds = %549
  %564 = load float, ptr %50, align 4, !tbaa !9
  %565 = fcmp olt float 0x3E80000000000000, %564
  br i1 %565, label %566, label %577

566:                                              ; preds = %563, %549
  %567 = load ptr, ptr %2, align 8, !tbaa !5
  %568 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %567, i32 0, i32 1
  %569 = load i32, ptr %568, align 4, !tbaa !20
  %570 = add nsw i32 %569, 1
  store i32 %570, ptr %568, align 4, !tbaa !20
  %571 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 313)
  %572 = load float, ptr %49, align 4, !tbaa !9
  %573 = fpext float %572 to double
  %574 = load float, ptr %50, align 4, !tbaa !9
  %575 = fpext float %574 to double
  %576 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 1.000000e+01, double noundef %573, double noundef %575)
  br label %577

577:                                              ; preds = %566, %563
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  %578 = load ptr, ptr %2, align 8, !tbaa !5
  %579 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %578, i32 0, i32 0
  %580 = load i32, ptr %579, align 4, !tbaa !18
  %581 = add nsw i32 %580, 1
  store i32 %581, ptr %579, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #6
  %582 = getelementptr inbounds [2 x [2 x float]], ptr %3, i64 0, i64 0
  %583 = getelementptr inbounds [2 x float], ptr %582, i64 0, i64 1
  %584 = load float, ptr %583, align 4, !tbaa !13
  store float %584, ptr %51, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #6
  %585 = load float, ptr %51, align 4, !tbaa !9
  %586 = fsub float %585, 2.000000e+01
  store float %586, ptr %52, align 4, !tbaa !9
  %587 = load float, ptr %52, align 4, !tbaa !9
  %588 = fcmp olt float %587, 0xBE80000000000000
  br i1 %588, label %592, label %589

589:                                              ; preds = %577
  %590 = load float, ptr %52, align 4, !tbaa !9
  %591 = fcmp olt float 0x3E80000000000000, %590
  br i1 %591, label %592, label %603

592:                                              ; preds = %589, %577
  %593 = load ptr, ptr %2, align 8, !tbaa !5
  %594 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %593, i32 0, i32 1
  %595 = load i32, ptr %594, align 4, !tbaa !20
  %596 = add nsw i32 %595, 1
  store i32 %596, ptr %594, align 4, !tbaa !20
  %597 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 314)
  %598 = load float, ptr %51, align 4, !tbaa !9
  %599 = fpext float %598 to double
  %600 = load float, ptr %52, align 4, !tbaa !9
  %601 = fpext float %600 to double
  %602 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 2.000000e+01, double noundef %599, double noundef %601)
  br label %603

603:                                              ; preds = %592, %589
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #6
  %604 = load ptr, ptr %2, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %604, i32 0, i32 0
  %606 = load i32, ptr %605, align 4, !tbaa !18
  %607 = add nsw i32 %606, 1
  store i32 %607, ptr %605, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #6
  %608 = getelementptr inbounds [2 x [2 x float]], ptr %3, i64 0, i64 1
  %609 = getelementptr inbounds [2 x float], ptr %608, i64 0, i64 0
  %610 = load float, ptr %609, align 4, !tbaa !13
  store float %610, ptr %53, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  %611 = load float, ptr %53, align 4, !tbaa !9
  %612 = fsub float %611, 3.000000e+01
  store float %612, ptr %54, align 4, !tbaa !9
  %613 = load float, ptr %54, align 4, !tbaa !9
  %614 = fcmp olt float %613, 0xBE80000000000000
  br i1 %614, label %618, label %615

615:                                              ; preds = %603
  %616 = load float, ptr %54, align 4, !tbaa !9
  %617 = fcmp olt float 0x3E80000000000000, %616
  br i1 %617, label %618, label %629

618:                                              ; preds = %615, %603
  %619 = load ptr, ptr %2, align 8, !tbaa !5
  %620 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %619, i32 0, i32 1
  %621 = load i32, ptr %620, align 4, !tbaa !20
  %622 = add nsw i32 %621, 1
  store i32 %622, ptr %620, align 4, !tbaa !20
  %623 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 315)
  %624 = load float, ptr %53, align 4, !tbaa !9
  %625 = fpext float %624 to double
  %626 = load float, ptr %54, align 4, !tbaa !9
  %627 = fpext float %626 to double
  %628 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 3.000000e+01, double noundef %625, double noundef %627)
  br label %629

629:                                              ; preds = %618, %615
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  %630 = load ptr, ptr %2, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %630, i32 0, i32 0
  %632 = load i32, ptr %631, align 4, !tbaa !18
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %631, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #6
  %634 = getelementptr inbounds [2 x [2 x float]], ptr %3, i64 0, i64 1
  %635 = getelementptr inbounds [2 x float], ptr %634, i64 0, i64 1
  %636 = load float, ptr %635, align 4, !tbaa !13
  store float %636, ptr %55, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #6
  %637 = load float, ptr %55, align 4, !tbaa !9
  %638 = fsub float %637, 4.000000e+01
  store float %638, ptr %56, align 4, !tbaa !9
  %639 = load float, ptr %56, align 4, !tbaa !9
  %640 = fcmp olt float %639, 0xBE80000000000000
  br i1 %640, label %644, label %641

641:                                              ; preds = %629
  %642 = load float, ptr %56, align 4, !tbaa !9
  %643 = fcmp olt float 0x3E80000000000000, %642
  br i1 %643, label %644, label %655

644:                                              ; preds = %641, %629
  %645 = load ptr, ptr %2, align 8, !tbaa !5
  %646 = getelementptr inbounds %struct.hmt_testresult_struct, ptr %645, i32 0, i32 1
  %647 = load i32, ptr %646, align 4, !tbaa !20
  %648 = add nsw i32 %647, 1
  store i32 %648, ptr %646, align 4, !tbaa !20
  %649 = call i32 (ptr, ...) @printf(ptr noundef @.str.15, i32 noundef 316)
  %650 = load float, ptr %55, align 4, !tbaa !9
  %651 = fpext float %650 to double
  %652 = load float, ptr %56, align 4, !tbaa !9
  %653 = fpext float %652 to double
  %654 = call i32 (ptr, ...) @printf(ptr noundef @.str.18, double noundef 4.000000e+01, double noundef %651, double noundef %653)
  br label %655

655:                                              ; preds = %644, %641
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %3) #6
  ret void
}

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

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef nonnull align 4 dereferenceable(16) ptr @_ZmLR8HMM_Mat2f(ptr noundef nonnull align 4 dereferenceable(16), float noundef) #5

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!7, !7, i64 0}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = !{i64 0, i64 16, !13}
!18 = !{!19, !12, i64 0}
!19 = !{!"_ZTS21hmt_testresult_struct", !12, i64 0, !12, i64 4}
!20 = !{!19, !12, i64 4}


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

%union.HMM_Mat2 = type { [2 x [2 x float]] }

@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [34 x i8], align 1

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

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

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z35_hmt_test_Multiplication_Mat2ScalarP21hmt_testresult_struct(ptr nocapture noundef %0) local_unnamed_addr #3 {
.preheader:
  %1 = alloca %union.HMM_Mat2, align 16
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %1) #6
  %2 = tail call { <2 x float>, <2 x float> } @_ZL6HMM_M2v()
  %3 = getelementptr inbounds i8, ptr %1, i64 8
  %4 = getelementptr inbounds i8, ptr %1, i64 4
  %5 = getelementptr inbounds i8, ptr %1, i64 12
  store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, ptr %1, align 16, !tbaa !5
  %.sroa.2149.0.copyload = load <2 x float>, ptr %3, align 8, !tbaa !5
  %6 = tail call { <2 x float>, <2 x float> } @_ZL10HMM_MulM2F8HMM_Mat2f(<2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> %.sroa.2149.0.copyload, float noundef 1.000000e+01)
  %7 = extractvalue { <2 x float>, <2 x float> } %6, 0
  %8 = extractvalue { <2 x float>, <2 x float> } %6, 1
  %9 = load i32, ptr %0, align 4, !tbaa !8
  %10 = add nsw i32 %9, 1
  store i32 %10, ptr %0, align 4, !tbaa !8
  %.sroa.0150.0.vec.extract = extractelement <2 x float> %7, i64 0
  %11 = fadd float %.sroa.0150.0.vec.extract, -1.000000e+01
  %12 = tail call float @llvm.fabs.f32(float %11)
  %or.cond = fcmp ogt float %12, 0x3E80000000000000
  br i1 %or.cond, label %13, label %21

13:                                               ; preds = %.preheader
  %14 = getelementptr inbounds i8, ptr %0, i64 4
  %15 = load i32, ptr %14, align 4, !tbaa !11
  %16 = add nsw i32 %15, 1
  store i32 %16, ptr %14, align 4, !tbaa !11
  %17 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 283)
  %18 = fpext float %.sroa.0150.0.vec.extract to double
  %19 = fpext float %11 to double
  %20 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+01, double noundef %18, double noundef %19)
  %.pre = load i32, ptr %0, align 4, !tbaa !8
  br label %21

21:                                               ; preds = %.preheader, %13
  %22 = phi i32 [ %10, %.preheader ], [ %.pre, %13 ]
  %23 = add nsw i32 %22, 1
  store i32 %23, ptr %0, align 4, !tbaa !8
  %.sroa.0150.4.vec.extract = extractelement <2 x float> %7, i64 1
  %24 = fadd float %.sroa.0150.4.vec.extract, -2.000000e+01
  %25 = tail call float @llvm.fabs.f32(float %24)
  %or.cond3 = fcmp ogt float %25, 0x3E80000000000000
  br i1 %or.cond3, label %26, label %34

26:                                               ; preds = %21
  %27 = getelementptr inbounds i8, ptr %0, i64 4
  %28 = load i32, ptr %27, align 4, !tbaa !11
  %29 = add nsw i32 %28, 1
  store i32 %29, ptr %27, align 4, !tbaa !11
  %30 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 284)
  %31 = fpext float %.sroa.0150.4.vec.extract to double
  %32 = fpext float %24 to double
  %33 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+01, double noundef %31, double noundef %32)
  %.pre211 = load i32, ptr %0, align 4, !tbaa !8
  br label %34

34:                                               ; preds = %21, %26
  %35 = phi i32 [ %23, %21 ], [ %.pre211, %26 ]
  %36 = add nsw i32 %35, 1
  store i32 %36, ptr %0, align 4, !tbaa !8
  %.sroa.5151.8.vec.extract = extractelement <2 x float> %8, i64 0
  %37 = fadd float %.sroa.5151.8.vec.extract, -3.000000e+01
  %38 = tail call float @llvm.fabs.f32(float %37)
  %or.cond5 = fcmp ogt float %38, 0x3E80000000000000
  br i1 %or.cond5, label %39, label %47

39:                                               ; preds = %34
  %40 = getelementptr inbounds i8, ptr %0, i64 4
  %41 = load i32, ptr %40, align 4, !tbaa !11
  %42 = add nsw i32 %41, 1
  store i32 %42, ptr %40, align 4, !tbaa !11
  %43 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 285)
  %44 = fpext float %.sroa.5151.8.vec.extract to double
  %45 = fpext float %37 to double
  %46 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+01, double noundef %44, double noundef %45)
  %.pre212 = load i32, ptr %0, align 4, !tbaa !8
  br label %47

47:                                               ; preds = %34, %39
  %48 = phi i32 [ %36, %34 ], [ %.pre212, %39 ]
  %49 = add nsw i32 %48, 1
  store i32 %49, ptr %0, align 4, !tbaa !8
  %.sroa.5151.12.vec.extract = extractelement <2 x float> %8, i64 1
  %50 = fadd float %.sroa.5151.12.vec.extract, -4.000000e+01
  %51 = tail call float @llvm.fabs.f32(float %50)
  %or.cond7 = fcmp ogt float %51, 0x3E80000000000000
  br i1 %or.cond7, label %52, label %60

52:                                               ; preds = %47
  %53 = getelementptr inbounds i8, ptr %0, i64 4
  %54 = load i32, ptr %53, align 4, !tbaa !11
  %55 = add nsw i32 %54, 1
  store i32 %55, ptr %53, align 4, !tbaa !11
  %56 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 286)
  %57 = fpext float %.sroa.5151.12.vec.extract to double
  %58 = fpext float %50 to double
  %59 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+01, double noundef %57, double noundef %58)
  br label %60

60:                                               ; preds = %47, %52
  %61 = tail call { <2 x float>, <2 x float> } @_ZL7HMM_Mul8HMM_Mat2f(<2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> %.sroa.2149.0.copyload, float noundef 1.000000e+01)
  %62 = extractvalue { <2 x float>, <2 x float> } %61, 0
  %63 = extractvalue { <2 x float>, <2 x float> } %61, 1
  %64 = load i32, ptr %0, align 4, !tbaa !8
  %65 = add nsw i32 %64, 1
  store i32 %65, ptr %0, align 4, !tbaa !8
  %.sroa.0126.0.vec.extract = extractelement <2 x float> %62, i64 0
  %66 = fadd float %.sroa.0126.0.vec.extract, -1.000000e+01
  %67 = tail call float @llvm.fabs.f32(float %66)
  %or.cond9 = fcmp ogt float %67, 0x3E80000000000000
  br i1 %or.cond9, label %68, label %76

68:                                               ; preds = %60
  %69 = getelementptr inbounds i8, ptr %0, i64 4
  %70 = load i32, ptr %69, align 4, !tbaa !11
  %71 = add nsw i32 %70, 1
  store i32 %71, ptr %69, align 4, !tbaa !11
  %72 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 291)
  %73 = fpext float %.sroa.0126.0.vec.extract to double
  %74 = fpext float %66 to double
  %75 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+01, double noundef %73, double noundef %74)
  %.pre213 = load i32, ptr %0, align 4, !tbaa !8
  br label %76

76:                                               ; preds = %60, %68
  %77 = phi i32 [ %65, %60 ], [ %.pre213, %68 ]
  %78 = add nsw i32 %77, 1
  store i32 %78, ptr %0, align 4, !tbaa !8
  %.sroa.0126.4.vec.extract = extractelement <2 x float> %62, i64 1
  %79 = fadd float %.sroa.0126.4.vec.extract, -2.000000e+01
  %80 = tail call float @llvm.fabs.f32(float %79)
  %or.cond11 = fcmp ogt float %80, 0x3E80000000000000
  br i1 %or.cond11, label %81, label %89

81:                                               ; preds = %76
  %82 = getelementptr inbounds i8, ptr %0, i64 4
  %83 = load i32, ptr %82, align 4, !tbaa !11
  %84 = add nsw i32 %83, 1
  store i32 %84, ptr %82, align 4, !tbaa !11
  %85 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 292)
  %86 = fpext float %.sroa.0126.4.vec.extract to double
  %87 = fpext float %79 to double
  %88 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+01, double noundef %86, double noundef %87)
  %.pre214 = load i32, ptr %0, align 4, !tbaa !8
  br label %89

89:                                               ; preds = %76, %81
  %90 = phi i32 [ %78, %76 ], [ %.pre214, %81 ]
  %91 = add nsw i32 %90, 1
  store i32 %91, ptr %0, align 4, !tbaa !8
  %.sroa.5127.8.vec.extract = extractelement <2 x float> %63, i64 0
  %92 = fadd float %.sroa.5127.8.vec.extract, -3.000000e+01
  %93 = tail call float @llvm.fabs.f32(float %92)
  %or.cond13 = fcmp ogt float %93, 0x3E80000000000000
  br i1 %or.cond13, label %94, label %102

94:                                               ; preds = %89
  %95 = getelementptr inbounds i8, ptr %0, i64 4
  %96 = load i32, ptr %95, align 4, !tbaa !11
  %97 = add nsw i32 %96, 1
  store i32 %97, ptr %95, align 4, !tbaa !11
  %98 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 293)
  %99 = fpext float %.sroa.5127.8.vec.extract to double
  %100 = fpext float %92 to double
  %101 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+01, double noundef %99, double noundef %100)
  %.pre215 = load i32, ptr %0, align 4, !tbaa !8
  br label %102

102:                                              ; preds = %89, %94
  %103 = phi i32 [ %91, %89 ], [ %.pre215, %94 ]
  %104 = add nsw i32 %103, 1
  store i32 %104, ptr %0, align 4, !tbaa !8
  %.sroa.5127.12.vec.extract = extractelement <2 x float> %63, i64 1
  %105 = fadd float %.sroa.5127.12.vec.extract, -4.000000e+01
  %106 = tail call float @llvm.fabs.f32(float %105)
  %or.cond15 = fcmp ogt float %106, 0x3E80000000000000
  br i1 %or.cond15, label %107, label %115

107:                                              ; preds = %102
  %108 = getelementptr inbounds i8, ptr %0, i64 4
  %109 = load i32, ptr %108, align 4, !tbaa !11
  %110 = add nsw i32 %109, 1
  store i32 %110, ptr %108, align 4, !tbaa !11
  %111 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 294)
  %112 = fpext float %.sroa.5127.12.vec.extract to double
  %113 = fpext float %105 to double
  %114 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+01, double noundef %112, double noundef %113)
  br label %115

115:                                              ; preds = %102, %107
  %116 = tail call { <2 x float>, <2 x float> } @_Zml8HMM_Mat2f(<2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> %.sroa.2149.0.copyload, float noundef 1.000000e+01)
  %117 = extractvalue { <2 x float>, <2 x float> } %116, 0
  %118 = extractvalue { <2 x float>, <2 x float> } %116, 1
  %119 = load i32, ptr %0, align 4, !tbaa !8
  %120 = add nsw i32 %119, 1
  store i32 %120, ptr %0, align 4, !tbaa !8
  %.sroa.0102.0.vec.extract = extractelement <2 x float> %117, i64 0
  %121 = fadd float %.sroa.0102.0.vec.extract, -1.000000e+01
  %122 = tail call float @llvm.fabs.f32(float %121)
  %or.cond17 = fcmp ogt float %122, 0x3E80000000000000
  br i1 %or.cond17, label %123, label %131

123:                                              ; preds = %115
  %124 = getelementptr inbounds i8, ptr %0, i64 4
  %125 = load i32, ptr %124, align 4, !tbaa !11
  %126 = add nsw i32 %125, 1
  store i32 %126, ptr %124, align 4, !tbaa !11
  %127 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 300)
  %128 = fpext float %.sroa.0102.0.vec.extract to double
  %129 = fpext float %121 to double
  %130 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+01, double noundef %128, double noundef %129)
  %.pre216 = load i32, ptr %0, align 4, !tbaa !8
  br label %131

131:                                              ; preds = %115, %123
  %132 = phi i32 [ %120, %115 ], [ %.pre216, %123 ]
  %133 = add nsw i32 %132, 1
  store i32 %133, ptr %0, align 4, !tbaa !8
  %.sroa.0102.4.vec.extract = extractelement <2 x float> %117, i64 1
  %134 = fadd float %.sroa.0102.4.vec.extract, -2.000000e+01
  %135 = tail call float @llvm.fabs.f32(float %134)
  %or.cond19 = fcmp ogt float %135, 0x3E80000000000000
  br i1 %or.cond19, label %136, label %144

136:                                              ; preds = %131
  %137 = getelementptr inbounds i8, ptr %0, i64 4
  %138 = load i32, ptr %137, align 4, !tbaa !11
  %139 = add nsw i32 %138, 1
  store i32 %139, ptr %137, align 4, !tbaa !11
  %140 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 301)
  %141 = fpext float %.sroa.0102.4.vec.extract to double
  %142 = fpext float %134 to double
  %143 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+01, double noundef %141, double noundef %142)
  %.pre217 = load i32, ptr %0, align 4, !tbaa !8
  br label %144

144:                                              ; preds = %131, %136
  %145 = phi i32 [ %133, %131 ], [ %.pre217, %136 ]
  %146 = add nsw i32 %145, 1
  store i32 %146, ptr %0, align 4, !tbaa !8
  %.sroa.5103.8.vec.extract = extractelement <2 x float> %118, i64 0
  %147 = fadd float %.sroa.5103.8.vec.extract, -3.000000e+01
  %148 = tail call float @llvm.fabs.f32(float %147)
  %or.cond21 = fcmp ogt float %148, 0x3E80000000000000
  br i1 %or.cond21, label %149, label %157

149:                                              ; preds = %144
  %150 = getelementptr inbounds i8, ptr %0, i64 4
  %151 = load i32, ptr %150, align 4, !tbaa !11
  %152 = add nsw i32 %151, 1
  store i32 %152, ptr %150, align 4, !tbaa !11
  %153 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 302)
  %154 = fpext float %.sroa.5103.8.vec.extract to double
  %155 = fpext float %147 to double
  %156 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+01, double noundef %154, double noundef %155)
  %.pre218 = load i32, ptr %0, align 4, !tbaa !8
  br label %157

157:                                              ; preds = %144, %149
  %158 = phi i32 [ %146, %144 ], [ %.pre218, %149 ]
  %159 = add nsw i32 %158, 1
  store i32 %159, ptr %0, align 4, !tbaa !8
  %.sroa.5103.12.vec.extract = extractelement <2 x float> %118, i64 1
  %160 = fadd float %.sroa.5103.12.vec.extract, -4.000000e+01
  %161 = tail call float @llvm.fabs.f32(float %160)
  %or.cond23 = fcmp ogt float %161, 0x3E80000000000000
  br i1 %or.cond23, label %162, label %170

162:                                              ; preds = %157
  %163 = getelementptr inbounds i8, ptr %0, i64 4
  %164 = load i32, ptr %163, align 4, !tbaa !11
  %165 = add nsw i32 %164, 1
  store i32 %165, ptr %163, align 4, !tbaa !11
  %166 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 303)
  %167 = fpext float %.sroa.5103.12.vec.extract to double
  %168 = fpext float %160 to double
  %169 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+01, double noundef %167, double noundef %168)
  br label %170

170:                                              ; preds = %157, %162
  %171 = tail call { <2 x float>, <2 x float> } @_Zmlf8HMM_Mat2(float noundef 1.000000e+01, <2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> %.sroa.2149.0.copyload)
  %172 = extractvalue { <2 x float>, <2 x float> } %171, 0
  %173 = extractvalue { <2 x float>, <2 x float> } %171, 1
  %174 = load i32, ptr %0, align 4, !tbaa !8
  %175 = add nsw i32 %174, 1
  store i32 %175, ptr %0, align 4, !tbaa !8
  %.sroa.079.0.vec.extract = extractelement <2 x float> %172, i64 0
  %176 = fadd float %.sroa.079.0.vec.extract, -1.000000e+01
  %177 = tail call float @llvm.fabs.f32(float %176)
  %or.cond25 = fcmp ogt float %177, 0x3E80000000000000
  br i1 %or.cond25, label %178, label %186

178:                                              ; preds = %170
  %179 = getelementptr inbounds i8, ptr %0, i64 4
  %180 = load i32, ptr %179, align 4, !tbaa !11
  %181 = add nsw i32 %180, 1
  store i32 %181, ptr %179, align 4, !tbaa !11
  %182 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 307)
  %183 = fpext float %.sroa.079.0.vec.extract to double
  %184 = fpext float %176 to double
  %185 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+01, double noundef %183, double noundef %184)
  %.pre219 = load i32, ptr %0, align 4, !tbaa !8
  br label %186

186:                                              ; preds = %170, %178
  %187 = phi i32 [ %175, %170 ], [ %.pre219, %178 ]
  %188 = add nsw i32 %187, 1
  store i32 %188, ptr %0, align 4, !tbaa !8
  %.sroa.079.4.vec.extract = extractelement <2 x float> %172, i64 1
  %189 = fadd float %.sroa.079.4.vec.extract, -2.000000e+01
  %190 = tail call float @llvm.fabs.f32(float %189)
  %or.cond27 = fcmp ogt float %190, 0x3E80000000000000
  br i1 %or.cond27, label %191, label %199

191:                                              ; preds = %186
  %192 = getelementptr inbounds i8, ptr %0, i64 4
  %193 = load i32, ptr %192, align 4, !tbaa !11
  %194 = add nsw i32 %193, 1
  store i32 %194, ptr %192, align 4, !tbaa !11
  %195 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 308)
  %196 = fpext float %.sroa.079.4.vec.extract to double
  %197 = fpext float %189 to double
  %198 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+01, double noundef %196, double noundef %197)
  %.pre220 = load i32, ptr %0, align 4, !tbaa !8
  br label %199

199:                                              ; preds = %186, %191
  %200 = phi i32 [ %188, %186 ], [ %.pre220, %191 ]
  %201 = add nsw i32 %200, 1
  store i32 %201, ptr %0, align 4, !tbaa !8
  %.sroa.5.8.vec.extract = extractelement <2 x float> %173, i64 0
  %202 = fadd float %.sroa.5.8.vec.extract, -3.000000e+01
  %203 = tail call float @llvm.fabs.f32(float %202)
  %or.cond29 = fcmp ogt float %203, 0x3E80000000000000
  br i1 %or.cond29, label %204, label %212

204:                                              ; preds = %199
  %205 = getelementptr inbounds i8, ptr %0, i64 4
  %206 = load i32, ptr %205, align 4, !tbaa !11
  %207 = add nsw i32 %206, 1
  store i32 %207, ptr %205, align 4, !tbaa !11
  %208 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 309)
  %209 = fpext float %.sroa.5.8.vec.extract to double
  %210 = fpext float %202 to double
  %211 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+01, double noundef %209, double noundef %210)
  %.pre221 = load i32, ptr %0, align 4, !tbaa !8
  br label %212

212:                                              ; preds = %199, %204
  %213 = phi i32 [ %201, %199 ], [ %.pre221, %204 ]
  %214 = add nsw i32 %213, 1
  store i32 %214, ptr %0, align 4, !tbaa !8
  %.sroa.5.12.vec.extract = extractelement <2 x float> %173, i64 1
  %215 = fadd float %.sroa.5.12.vec.extract, -4.000000e+01
  %216 = tail call float @llvm.fabs.f32(float %215)
  %or.cond31 = fcmp ogt float %216, 0x3E80000000000000
  br i1 %or.cond31, label %217, label %225

217:                                              ; preds = %212
  %218 = getelementptr inbounds i8, ptr %0, i64 4
  %219 = load i32, ptr %218, align 4, !tbaa !11
  %220 = add nsw i32 %219, 1
  store i32 %220, ptr %218, align 4, !tbaa !11
  %221 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 310)
  %222 = fpext float %.sroa.5.12.vec.extract to double
  %223 = fpext float %215 to double
  %224 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+01, double noundef %222, double noundef %223)
  br label %225

225:                                              ; preds = %212, %217
  %226 = call noundef nonnull align 4 dereferenceable(16) ptr @_ZmLR8HMM_Mat2f(ptr noundef nonnull align 4 dereferenceable(16) %1, float noundef 1.000000e+01)
  %227 = load i32, ptr %0, align 4, !tbaa !8
  %228 = add nsw i32 %227, 1
  store i32 %228, ptr %0, align 4, !tbaa !8
  %229 = load float, ptr %1, align 16, !tbaa !5
  %230 = fadd float %229, -1.000000e+01
  %231 = call float @llvm.fabs.f32(float %230)
  %or.cond33 = fcmp ogt float %231, 0x3E80000000000000
  br i1 %or.cond33, label %232, label %240

232:                                              ; preds = %225
  %233 = getelementptr inbounds i8, ptr %0, i64 4
  %234 = load i32, ptr %233, align 4, !tbaa !11
  %235 = add nsw i32 %234, 1
  store i32 %235, ptr %233, align 4, !tbaa !11
  %236 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 313)
  %237 = fpext float %229 to double
  %238 = fpext float %230 to double
  %239 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 1.000000e+01, double noundef %237, double noundef %238)
  %.pre222 = load i32, ptr %0, align 4, !tbaa !8
  br label %240

240:                                              ; preds = %225, %232
  %241 = phi i32 [ %228, %225 ], [ %.pre222, %232 ]
  %242 = add nsw i32 %241, 1
  store i32 %242, ptr %0, align 4, !tbaa !8
  %243 = load float, ptr %4, align 4, !tbaa !5
  %244 = fadd float %243, -2.000000e+01
  %245 = call float @llvm.fabs.f32(float %244)
  %or.cond35 = fcmp ogt float %245, 0x3E80000000000000
  br i1 %or.cond35, label %246, label %254

246:                                              ; preds = %240
  %247 = getelementptr inbounds i8, ptr %0, i64 4
  %248 = load i32, ptr %247, align 4, !tbaa !11
  %249 = add nsw i32 %248, 1
  store i32 %249, ptr %247, align 4, !tbaa !11
  %250 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 314)
  %251 = fpext float %243 to double
  %252 = fpext float %244 to double
  %253 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 2.000000e+01, double noundef %251, double noundef %252)
  %.pre223 = load i32, ptr %0, align 4, !tbaa !8
  br label %254

254:                                              ; preds = %240, %246
  %255 = phi i32 [ %242, %240 ], [ %.pre223, %246 ]
  %256 = add nsw i32 %255, 1
  store i32 %256, ptr %0, align 4, !tbaa !8
  %257 = load float, ptr %3, align 8, !tbaa !5
  %258 = fadd float %257, -3.000000e+01
  %259 = call float @llvm.fabs.f32(float %258)
  %or.cond37 = fcmp ogt float %259, 0x3E80000000000000
  br i1 %or.cond37, label %260, label %268

260:                                              ; preds = %254
  %261 = getelementptr inbounds i8, ptr %0, i64 4
  %262 = load i32, ptr %261, align 4, !tbaa !11
  %263 = add nsw i32 %262, 1
  store i32 %263, ptr %261, align 4, !tbaa !11
  %264 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 315)
  %265 = fpext float %257 to double
  %266 = fpext float %258 to double
  %267 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 3.000000e+01, double noundef %265, double noundef %266)
  %.pre224 = load i32, ptr %0, align 4, !tbaa !8
  br label %268

268:                                              ; preds = %254, %260
  %269 = phi i32 [ %256, %254 ], [ %.pre224, %260 ]
  %270 = add nsw i32 %269, 1
  store i32 %270, ptr %0, align 4, !tbaa !8
  %271 = load float, ptr %5, align 4, !tbaa !5
  %272 = fadd float %271, -4.000000e+01
  %273 = call float @llvm.fabs.f32(float %272)
  %or.cond39 = fcmp ogt float %273, 0x3E80000000000000
  br i1 %or.cond39, label %274, label %282

274:                                              ; preds = %268
  %275 = getelementptr inbounds i8, ptr %0, i64 4
  %276 = load i32, ptr %275, align 4, !tbaa !11
  %277 = add nsw i32 %276, 1
  store i32 %277, ptr %275, align 4, !tbaa !11
  %278 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.15, i32 noundef 316)
  %279 = fpext float %271 to double
  %280 = fpext float %272 to double
  %281 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18, double noundef 4.000000e+01, double noundef %279, double noundef %280)
  br label %282

282:                                              ; preds = %268, %274
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %1) #6
  ret void
}

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

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

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

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

; Function Attrs: inlinehint mustprogress uwtable
declare hidden noundef nonnull align 4 dereferenceable(16) ptr @_ZmLR8HMM_Mat2f(ptr noundef nonnull align 4 dereferenceable(16), float noundef) local_unnamed_addr #4

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C++ TBAA"}
!8 = !{!9, !10, i64 0}
!9 = !{!"_ZTS21hmt_testresult_struct", !10, i64 0, !10, i64 4}
!10 = !{!"int", !6, i64 0}
!11 = !{!9, !10, i64 4}


; Effective O3 passes: DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass