; LLVM IR from jgaeddert/liquid-dsp :: src/matrix/tests (smatrixb_autotest)

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

@.str = external hidden unnamed_addr constant [91 x i8], align 1
@liquid_autotest_verbose = external global i32, align 4
@.str.18 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [4 x i8], align 1
@__const.autotest_smatrixb_vmulf.x = external hidden unnamed_addr constant [12 x float], align 16
@__const.autotest_smatrixb_vmulf.y_test = external hidden unnamed_addr constant [8 x float], align 16
@.str.40 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [6 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

declare ptr @smatrixb_create(i32 noundef, i32 noundef) #1

declare i32 @smatrixb_set(ptr noundef, i32 noundef, i32 noundef, i8 noundef zeroext) #1

; 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) #2

declare void @liquid_autotest_failed_expr(ptr noundef, i32 noundef, ptr noundef, double noundef, ptr noundef, ptr noundef, double noundef) #1

declare void @liquid_autotest_passed(...) #1

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

declare i32 @smatrixb_print(ptr noundef) #1

declare i32 @smatrixb_print_expanded(ptr noundef) #1

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

declare i32 @smatrixb_destroy(ptr noundef) #1

; Function Attrs: nounwind
declare double @sqrt(double noundef) #3

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #4

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i1 @llvm.is.fpclass.f32(float, i32 immarg) #4

; Function Attrs: nounwind uwtable
define dso_local void @autotest_smatrixb_vmulf() #5 {
  %1 = alloca float, align 4
  %2 = alloca ptr, align 8
  %3 = alloca [12 x float], align 16
  %4 = alloca [8 x float], align 16
  %5 = alloca [8 x float], align 16
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %1) #6
  store float 0x3EB0C6F7A0000000, ptr %1, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %2) #6
  %8 = call ptr @smatrixb_create(i32 noundef 8, i32 noundef 12)
  store ptr %8, ptr %2, align 8, !tbaa !9
  %9 = load ptr, ptr %2, align 8, !tbaa !9
  %10 = call i32 @smatrixb_set(ptr noundef %9, i32 noundef 0, i32 noundef 0, i8 noundef zeroext 1)
  %11 = load ptr, ptr %2, align 8, !tbaa !9
  %12 = call i32 @smatrixb_set(ptr noundef %11, i32 noundef 2, i32 noundef 0, i8 noundef zeroext 1)
  %13 = load ptr, ptr %2, align 8, !tbaa !9
  %14 = call i32 @smatrixb_set(ptr noundef %13, i32 noundef 6, i32 noundef 0, i8 noundef zeroext 1)
  %15 = load ptr, ptr %2, align 8, !tbaa !9
  %16 = call i32 @smatrixb_set(ptr noundef %15, i32 noundef 3, i32 noundef 2, i8 noundef zeroext 1)
  %17 = load ptr, ptr %2, align 8, !tbaa !9
  %18 = call i32 @smatrixb_set(ptr noundef %17, i32 noundef 6, i32 noundef 2, i8 noundef zeroext 1)
  %19 = load ptr, ptr %2, align 8, !tbaa !9
  %20 = call i32 @smatrixb_set(ptr noundef %19, i32 noundef 7, i32 noundef 2, i8 noundef zeroext 1)
  %21 = load ptr, ptr %2, align 8, !tbaa !9
  %22 = call i32 @smatrixb_set(ptr noundef %21, i32 noundef 1, i32 noundef 3, i8 noundef zeroext 1)
  %23 = load ptr, ptr %2, align 8, !tbaa !9
  %24 = call i32 @smatrixb_set(ptr noundef %23, i32 noundef 7, i32 noundef 5, i8 noundef zeroext 1)
  %25 = load ptr, ptr %2, align 8, !tbaa !9
  %26 = call i32 @smatrixb_set(ptr noundef %25, i32 noundef 3, i32 noundef 6, i8 noundef zeroext 1)
  %27 = load ptr, ptr %2, align 8, !tbaa !9
  %28 = call i32 @smatrixb_set(ptr noundef %27, i32 noundef 5, i32 noundef 6, i8 noundef zeroext 1)
  %29 = load ptr, ptr %2, align 8, !tbaa !9
  %30 = call i32 @smatrixb_set(ptr noundef %29, i32 noundef 7, i32 noundef 6, i8 noundef zeroext 1)
  %31 = load ptr, ptr %2, align 8, !tbaa !9
  %32 = call i32 @smatrixb_set(ptr noundef %31, i32 noundef 3, i32 noundef 7, i8 noundef zeroext 1)
  %33 = load ptr, ptr %2, align 8, !tbaa !9
  %34 = call i32 @smatrixb_set(ptr noundef %33, i32 noundef 2, i32 noundef 8, i8 noundef zeroext 1)
  %35 = load ptr, ptr %2, align 8, !tbaa !9
  %36 = call i32 @smatrixb_set(ptr noundef %35, i32 noundef 5, i32 noundef 8, i8 noundef zeroext 1)
  %37 = load ptr, ptr %2, align 8, !tbaa !9
  %38 = call i32 @smatrixb_set(ptr noundef %37, i32 noundef 2, i32 noundef 9, i8 noundef zeroext 1)
  %39 = load ptr, ptr %2, align 8, !tbaa !9
  %40 = call i32 @smatrixb_set(ptr noundef %39, i32 noundef 5, i32 noundef 10, i8 noundef zeroext 1)
  %41 = load ptr, ptr %2, align 8, !tbaa !9
  %42 = call i32 @smatrixb_set(ptr noundef %41, i32 noundef 6, i32 noundef 10, i8 noundef zeroext 1)
  %43 = load ptr, ptr %2, align 8, !tbaa !9
  %44 = call i32 @smatrixb_set(ptr noundef %43, i32 noundef 6, i32 noundef 11, i8 noundef zeroext 1)
  call void @llvm.lifetime.start.p0(i64 48, ptr %3) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %3, ptr align 16 @__const.autotest_smatrixb_vmulf.x, i64 48, i1 false)
  call void @llvm.lifetime.start.p0(i64 32, ptr %4) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %4, ptr align 16 @__const.autotest_smatrixb_vmulf.y_test, i64 32, i1 false)
  call void @llvm.lifetime.start.p0(i64 32, ptr %5) #6
  %45 = load ptr, ptr %2, align 8, !tbaa !9
  %46 = getelementptr inbounds [12 x float], ptr %3, i64 0, i64 0
  %47 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %48 = call i32 @smatrixb_vmulf(ptr noundef %45, ptr noundef %46, ptr noundef %47)
  %49 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %50 = load float, ptr %49, align 16, !tbaa !5
  %51 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %52 = load float, ptr %51, align 16, !tbaa !5
  %53 = fsub float %50, %52
  %54 = fpext float %53 to double
  %55 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %56 = load float, ptr %55, align 16, !tbaa !5
  %57 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %58 = load float, ptr %57, align 16, !tbaa !5
  %59 = fsub float %56, %58
  %60 = fpext float %59 to double
  %61 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %62 = load float, ptr %61, align 16, !tbaa !5
  %63 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %64 = load float, ptr %63, align 16, !tbaa !5
  %65 = fsub float %62, %64
  %66 = fpext float %65 to double
  %67 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %68 = load float, ptr %67, align 16, !tbaa !5
  %69 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %70 = load float, ptr %69, align 16, !tbaa !5
  %71 = fsub float %68, %70
  %72 = fpext float %71 to double
  %73 = call double @llvm.fmuladd.f64(double %54, double %60, double 0.000000e+00)
  %74 = call double @sqrt(double noundef %73) #6
  %75 = load float, ptr %1, align 4, !tbaa !5
  %76 = fpext float %75 to double
  %77 = fcmp ogt double %74, %76
  br i1 %77, label %94, label %78

78:                                               ; preds = %0
  %79 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %80 = load float, ptr %79, align 16, !tbaa !5
  %81 = call i1 @llvm.is.fpclass.f32(float %80, i32 3)
  br i1 %81, label %94, label %82

82:                                               ; preds = %78
  %83 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %84 = load float, ptr %83, align 16, !tbaa !5
  %85 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %85, label %94, label %86

86:                                               ; preds = %82
  %87 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %88 = load float, ptr %87, align 16, !tbaa !5
  %89 = call i1 @llvm.is.fpclass.f32(float %88, i32 3)
  br i1 %89, label %94, label %90

90:                                               ; preds = %86
  %91 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %92 = load float, ptr %91, align 16, !tbaa !5
  %93 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %93, label %94, label %123

94:                                               ; preds = %90, %86, %82, %78, %0
  %95 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %96 = load float, ptr %95, align 16, !tbaa !5
  %97 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %98 = load float, ptr %97, align 16, !tbaa !5
  %99 = fsub float %96, %98
  %100 = fpext float %99 to double
  %101 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %102 = load float, ptr %101, align 16, !tbaa !5
  %103 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %104 = load float, ptr %103, align 16, !tbaa !5
  %105 = fsub float %102, %104
  %106 = fpext float %105 to double
  %107 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %108 = load float, ptr %107, align 16, !tbaa !5
  %109 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %110 = load float, ptr %109, align 16, !tbaa !5
  %111 = fsub float %108, %110
  %112 = fpext float %111 to double
  %113 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 0
  %114 = load float, ptr %113, align 16, !tbaa !5
  %115 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 0
  %116 = load float, ptr %115, align 16, !tbaa !5
  %117 = fsub float %114, %116
  %118 = fpext float %117 to double
  %119 = call double @llvm.fmuladd.f64(double %100, double %106, double 0.000000e+00)
  %120 = call double @sqrt(double noundef %119) #6
  %121 = load float, ptr %1, align 4, !tbaa !5
  %122 = fpext float %121 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 331, ptr noundef @.str.40, double noundef %120, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %122)
  br label %124

123:                                              ; preds = %90
  call void (...) @liquid_autotest_passed()
  br label %124

124:                                              ; preds = %123, %94
  %125 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %126 = load float, ptr %125, align 4, !tbaa !5
  %127 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %128 = load float, ptr %127, align 4, !tbaa !5
  %129 = fsub float %126, %128
  %130 = fpext float %129 to double
  %131 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %132 = load float, ptr %131, align 4, !tbaa !5
  %133 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %134 = load float, ptr %133, align 4, !tbaa !5
  %135 = fsub float %132, %134
  %136 = fpext float %135 to double
  %137 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %138 = load float, ptr %137, align 4, !tbaa !5
  %139 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %140 = load float, ptr %139, align 4, !tbaa !5
  %141 = fsub float %138, %140
  %142 = fpext float %141 to double
  %143 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %144 = load float, ptr %143, align 4, !tbaa !5
  %145 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %146 = load float, ptr %145, align 4, !tbaa !5
  %147 = fsub float %144, %146
  %148 = fpext float %147 to double
  %149 = call double @llvm.fmuladd.f64(double %130, double %136, double 0.000000e+00)
  %150 = call double @sqrt(double noundef %149) #6
  %151 = load float, ptr %1, align 4, !tbaa !5
  %152 = fpext float %151 to double
  %153 = fcmp ogt double %150, %152
  br i1 %153, label %170, label %154

154:                                              ; preds = %124
  %155 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %156 = load float, ptr %155, align 4, !tbaa !5
  %157 = call i1 @llvm.is.fpclass.f32(float %156, i32 3)
  br i1 %157, label %170, label %158

158:                                              ; preds = %154
  %159 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %160 = load float, ptr %159, align 4, !tbaa !5
  %161 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %161, label %170, label %162

162:                                              ; preds = %158
  %163 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %164 = load float, ptr %163, align 4, !tbaa !5
  %165 = call i1 @llvm.is.fpclass.f32(float %164, i32 3)
  br i1 %165, label %170, label %166

166:                                              ; preds = %162
  %167 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %168 = load float, ptr %167, align 4, !tbaa !5
  %169 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %169, label %170, label %199

170:                                              ; preds = %166, %162, %158, %154, %124
  %171 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %172 = load float, ptr %171, align 4, !tbaa !5
  %173 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %174 = load float, ptr %173, align 4, !tbaa !5
  %175 = fsub float %172, %174
  %176 = fpext float %175 to double
  %177 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %178 = load float, ptr %177, align 4, !tbaa !5
  %179 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %180 = load float, ptr %179, align 4, !tbaa !5
  %181 = fsub float %178, %180
  %182 = fpext float %181 to double
  %183 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %184 = load float, ptr %183, align 4, !tbaa !5
  %185 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %186 = load float, ptr %185, align 4, !tbaa !5
  %187 = fsub float %184, %186
  %188 = fpext float %187 to double
  %189 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 1
  %190 = load float, ptr %189, align 4, !tbaa !5
  %191 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 1
  %192 = load float, ptr %191, align 4, !tbaa !5
  %193 = fsub float %190, %192
  %194 = fpext float %193 to double
  %195 = call double @llvm.fmuladd.f64(double %176, double %182, double 0.000000e+00)
  %196 = call double @sqrt(double noundef %195) #6
  %197 = load float, ptr %1, align 4, !tbaa !5
  %198 = fpext float %197 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 332, ptr noundef @.str.41, double noundef %196, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %198)
  br label %200

199:                                              ; preds = %166
  call void (...) @liquid_autotest_passed()
  br label %200

200:                                              ; preds = %199, %170
  %201 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %202 = load float, ptr %201, align 8, !tbaa !5
  %203 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %204 = load float, ptr %203, align 8, !tbaa !5
  %205 = fsub float %202, %204
  %206 = fpext float %205 to double
  %207 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %208 = load float, ptr %207, align 8, !tbaa !5
  %209 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %210 = load float, ptr %209, align 8, !tbaa !5
  %211 = fsub float %208, %210
  %212 = fpext float %211 to double
  %213 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %214 = load float, ptr %213, align 8, !tbaa !5
  %215 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %216 = load float, ptr %215, align 8, !tbaa !5
  %217 = fsub float %214, %216
  %218 = fpext float %217 to double
  %219 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %220 = load float, ptr %219, align 8, !tbaa !5
  %221 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %222 = load float, ptr %221, align 8, !tbaa !5
  %223 = fsub float %220, %222
  %224 = fpext float %223 to double
  %225 = call double @llvm.fmuladd.f64(double %206, double %212, double 0.000000e+00)
  %226 = call double @sqrt(double noundef %225) #6
  %227 = load float, ptr %1, align 4, !tbaa !5
  %228 = fpext float %227 to double
  %229 = fcmp ogt double %226, %228
  br i1 %229, label %246, label %230

230:                                              ; preds = %200
  %231 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %232 = load float, ptr %231, align 8, !tbaa !5
  %233 = call i1 @llvm.is.fpclass.f32(float %232, i32 3)
  br i1 %233, label %246, label %234

234:                                              ; preds = %230
  %235 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %236 = load float, ptr %235, align 8, !tbaa !5
  %237 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %237, label %246, label %238

238:                                              ; preds = %234
  %239 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %240 = load float, ptr %239, align 8, !tbaa !5
  %241 = call i1 @llvm.is.fpclass.f32(float %240, i32 3)
  br i1 %241, label %246, label %242

242:                                              ; preds = %238
  %243 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %244 = load float, ptr %243, align 8, !tbaa !5
  %245 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %245, label %246, label %275

246:                                              ; preds = %242, %238, %234, %230, %200
  %247 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %248 = load float, ptr %247, align 8, !tbaa !5
  %249 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %250 = load float, ptr %249, align 8, !tbaa !5
  %251 = fsub float %248, %250
  %252 = fpext float %251 to double
  %253 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %254 = load float, ptr %253, align 8, !tbaa !5
  %255 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %256 = load float, ptr %255, align 8, !tbaa !5
  %257 = fsub float %254, %256
  %258 = fpext float %257 to double
  %259 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %260 = load float, ptr %259, align 8, !tbaa !5
  %261 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %262 = load float, ptr %261, align 8, !tbaa !5
  %263 = fsub float %260, %262
  %264 = fpext float %263 to double
  %265 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 2
  %266 = load float, ptr %265, align 8, !tbaa !5
  %267 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 2
  %268 = load float, ptr %267, align 8, !tbaa !5
  %269 = fsub float %266, %268
  %270 = fpext float %269 to double
  %271 = call double @llvm.fmuladd.f64(double %252, double %258, double 0.000000e+00)
  %272 = call double @sqrt(double noundef %271) #6
  %273 = load float, ptr %1, align 4, !tbaa !5
  %274 = fpext float %273 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 333, ptr noundef @.str.42, double noundef %272, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %274)
  br label %276

275:                                              ; preds = %242
  call void (...) @liquid_autotest_passed()
  br label %276

276:                                              ; preds = %275, %246
  %277 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %278 = load float, ptr %277, align 4, !tbaa !5
  %279 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %280 = load float, ptr %279, align 4, !tbaa !5
  %281 = fsub float %278, %280
  %282 = fpext float %281 to double
  %283 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %284 = load float, ptr %283, align 4, !tbaa !5
  %285 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %286 = load float, ptr %285, align 4, !tbaa !5
  %287 = fsub float %284, %286
  %288 = fpext float %287 to double
  %289 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %290 = load float, ptr %289, align 4, !tbaa !5
  %291 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %292 = load float, ptr %291, align 4, !tbaa !5
  %293 = fsub float %290, %292
  %294 = fpext float %293 to double
  %295 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %296 = load float, ptr %295, align 4, !tbaa !5
  %297 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %298 = load float, ptr %297, align 4, !tbaa !5
  %299 = fsub float %296, %298
  %300 = fpext float %299 to double
  %301 = call double @llvm.fmuladd.f64(double %282, double %288, double 0.000000e+00)
  %302 = call double @sqrt(double noundef %301) #6
  %303 = load float, ptr %1, align 4, !tbaa !5
  %304 = fpext float %303 to double
  %305 = fcmp ogt double %302, %304
  br i1 %305, label %322, label %306

306:                                              ; preds = %276
  %307 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %308 = load float, ptr %307, align 4, !tbaa !5
  %309 = call i1 @llvm.is.fpclass.f32(float %308, i32 3)
  br i1 %309, label %322, label %310

310:                                              ; preds = %306
  %311 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %312 = load float, ptr %311, align 4, !tbaa !5
  %313 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %313, label %322, label %314

314:                                              ; preds = %310
  %315 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %316 = load float, ptr %315, align 4, !tbaa !5
  %317 = call i1 @llvm.is.fpclass.f32(float %316, i32 3)
  br i1 %317, label %322, label %318

318:                                              ; preds = %314
  %319 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %320 = load float, ptr %319, align 4, !tbaa !5
  %321 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %321, label %322, label %351

322:                                              ; preds = %318, %314, %310, %306, %276
  %323 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %324 = load float, ptr %323, align 4, !tbaa !5
  %325 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %326 = load float, ptr %325, align 4, !tbaa !5
  %327 = fsub float %324, %326
  %328 = fpext float %327 to double
  %329 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %330 = load float, ptr %329, align 4, !tbaa !5
  %331 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %332 = load float, ptr %331, align 4, !tbaa !5
  %333 = fsub float %330, %332
  %334 = fpext float %333 to double
  %335 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %336 = load float, ptr %335, align 4, !tbaa !5
  %337 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %338 = load float, ptr %337, align 4, !tbaa !5
  %339 = fsub float %336, %338
  %340 = fpext float %339 to double
  %341 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 3
  %342 = load float, ptr %341, align 4, !tbaa !5
  %343 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 3
  %344 = load float, ptr %343, align 4, !tbaa !5
  %345 = fsub float %342, %344
  %346 = fpext float %345 to double
  %347 = call double @llvm.fmuladd.f64(double %328, double %334, double 0.000000e+00)
  %348 = call double @sqrt(double noundef %347) #6
  %349 = load float, ptr %1, align 4, !tbaa !5
  %350 = fpext float %349 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 334, ptr noundef @.str.43, double noundef %348, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %350)
  br label %352

351:                                              ; preds = %318
  call void (...) @liquid_autotest_passed()
  br label %352

352:                                              ; preds = %351, %322
  %353 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %354 = load float, ptr %353, align 16, !tbaa !5
  %355 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %356 = load float, ptr %355, align 16, !tbaa !5
  %357 = fsub float %354, %356
  %358 = fpext float %357 to double
  %359 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %360 = load float, ptr %359, align 16, !tbaa !5
  %361 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %362 = load float, ptr %361, align 16, !tbaa !5
  %363 = fsub float %360, %362
  %364 = fpext float %363 to double
  %365 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %366 = load float, ptr %365, align 16, !tbaa !5
  %367 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %368 = load float, ptr %367, align 16, !tbaa !5
  %369 = fsub float %366, %368
  %370 = fpext float %369 to double
  %371 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %372 = load float, ptr %371, align 16, !tbaa !5
  %373 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %374 = load float, ptr %373, align 16, !tbaa !5
  %375 = fsub float %372, %374
  %376 = fpext float %375 to double
  %377 = call double @llvm.fmuladd.f64(double %358, double %364, double 0.000000e+00)
  %378 = call double @sqrt(double noundef %377) #6
  %379 = load float, ptr %1, align 4, !tbaa !5
  %380 = fpext float %379 to double
  %381 = fcmp ogt double %378, %380
  br i1 %381, label %398, label %382

382:                                              ; preds = %352
  %383 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %384 = load float, ptr %383, align 16, !tbaa !5
  %385 = call i1 @llvm.is.fpclass.f32(float %384, i32 3)
  br i1 %385, label %398, label %386

386:                                              ; preds = %382
  %387 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %388 = load float, ptr %387, align 16, !tbaa !5
  %389 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %389, label %398, label %390

390:                                              ; preds = %386
  %391 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %392 = load float, ptr %391, align 16, !tbaa !5
  %393 = call i1 @llvm.is.fpclass.f32(float %392, i32 3)
  br i1 %393, label %398, label %394

394:                                              ; preds = %390
  %395 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %396 = load float, ptr %395, align 16, !tbaa !5
  %397 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %397, label %398, label %427

398:                                              ; preds = %394, %390, %386, %382, %352
  %399 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %400 = load float, ptr %399, align 16, !tbaa !5
  %401 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %402 = load float, ptr %401, align 16, !tbaa !5
  %403 = fsub float %400, %402
  %404 = fpext float %403 to double
  %405 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %406 = load float, ptr %405, align 16, !tbaa !5
  %407 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %408 = load float, ptr %407, align 16, !tbaa !5
  %409 = fsub float %406, %408
  %410 = fpext float %409 to double
  %411 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %412 = load float, ptr %411, align 16, !tbaa !5
  %413 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %414 = load float, ptr %413, align 16, !tbaa !5
  %415 = fsub float %412, %414
  %416 = fpext float %415 to double
  %417 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 4
  %418 = load float, ptr %417, align 16, !tbaa !5
  %419 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 4
  %420 = load float, ptr %419, align 16, !tbaa !5
  %421 = fsub float %418, %420
  %422 = fpext float %421 to double
  %423 = call double @llvm.fmuladd.f64(double %404, double %410, double 0.000000e+00)
  %424 = call double @sqrt(double noundef %423) #6
  %425 = load float, ptr %1, align 4, !tbaa !5
  %426 = fpext float %425 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 335, ptr noundef @.str.44, double noundef %424, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %426)
  br label %428

427:                                              ; preds = %394
  call void (...) @liquid_autotest_passed()
  br label %428

428:                                              ; preds = %427, %398
  %429 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %430 = load float, ptr %429, align 4, !tbaa !5
  %431 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %432 = load float, ptr %431, align 4, !tbaa !5
  %433 = fsub float %430, %432
  %434 = fpext float %433 to double
  %435 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %436 = load float, ptr %435, align 4, !tbaa !5
  %437 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %438 = load float, ptr %437, align 4, !tbaa !5
  %439 = fsub float %436, %438
  %440 = fpext float %439 to double
  %441 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %442 = load float, ptr %441, align 4, !tbaa !5
  %443 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %444 = load float, ptr %443, align 4, !tbaa !5
  %445 = fsub float %442, %444
  %446 = fpext float %445 to double
  %447 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %448 = load float, ptr %447, align 4, !tbaa !5
  %449 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %450 = load float, ptr %449, align 4, !tbaa !5
  %451 = fsub float %448, %450
  %452 = fpext float %451 to double
  %453 = call double @llvm.fmuladd.f64(double %434, double %440, double 0.000000e+00)
  %454 = call double @sqrt(double noundef %453) #6
  %455 = load float, ptr %1, align 4, !tbaa !5
  %456 = fpext float %455 to double
  %457 = fcmp ogt double %454, %456
  br i1 %457, label %474, label %458

458:                                              ; preds = %428
  %459 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %460 = load float, ptr %459, align 4, !tbaa !5
  %461 = call i1 @llvm.is.fpclass.f32(float %460, i32 3)
  br i1 %461, label %474, label %462

462:                                              ; preds = %458
  %463 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %464 = load float, ptr %463, align 4, !tbaa !5
  %465 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %465, label %474, label %466

466:                                              ; preds = %462
  %467 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %468 = load float, ptr %467, align 4, !tbaa !5
  %469 = call i1 @llvm.is.fpclass.f32(float %468, i32 3)
  br i1 %469, label %474, label %470

470:                                              ; preds = %466
  %471 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %472 = load float, ptr %471, align 4, !tbaa !5
  %473 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %473, label %474, label %503

474:                                              ; preds = %470, %466, %462, %458, %428
  %475 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %476 = load float, ptr %475, align 4, !tbaa !5
  %477 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %478 = load float, ptr %477, align 4, !tbaa !5
  %479 = fsub float %476, %478
  %480 = fpext float %479 to double
  %481 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %482 = load float, ptr %481, align 4, !tbaa !5
  %483 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %484 = load float, ptr %483, align 4, !tbaa !5
  %485 = fsub float %482, %484
  %486 = fpext float %485 to double
  %487 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %488 = load float, ptr %487, align 4, !tbaa !5
  %489 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %490 = load float, ptr %489, align 4, !tbaa !5
  %491 = fsub float %488, %490
  %492 = fpext float %491 to double
  %493 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 5
  %494 = load float, ptr %493, align 4, !tbaa !5
  %495 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 5
  %496 = load float, ptr %495, align 4, !tbaa !5
  %497 = fsub float %494, %496
  %498 = fpext float %497 to double
  %499 = call double @llvm.fmuladd.f64(double %480, double %486, double 0.000000e+00)
  %500 = call double @sqrt(double noundef %499) #6
  %501 = load float, ptr %1, align 4, !tbaa !5
  %502 = fpext float %501 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 336, ptr noundef @.str.45, double noundef %500, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %502)
  br label %504

503:                                              ; preds = %470
  call void (...) @liquid_autotest_passed()
  br label %504

504:                                              ; preds = %503, %474
  %505 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %506 = load float, ptr %505, align 8, !tbaa !5
  %507 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %508 = load float, ptr %507, align 8, !tbaa !5
  %509 = fsub float %506, %508
  %510 = fpext float %509 to double
  %511 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %512 = load float, ptr %511, align 8, !tbaa !5
  %513 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %514 = load float, ptr %513, align 8, !tbaa !5
  %515 = fsub float %512, %514
  %516 = fpext float %515 to double
  %517 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %518 = load float, ptr %517, align 8, !tbaa !5
  %519 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %520 = load float, ptr %519, align 8, !tbaa !5
  %521 = fsub float %518, %520
  %522 = fpext float %521 to double
  %523 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %524 = load float, ptr %523, align 8, !tbaa !5
  %525 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %526 = load float, ptr %525, align 8, !tbaa !5
  %527 = fsub float %524, %526
  %528 = fpext float %527 to double
  %529 = call double @llvm.fmuladd.f64(double %510, double %516, double 0.000000e+00)
  %530 = call double @sqrt(double noundef %529) #6
  %531 = load float, ptr %1, align 4, !tbaa !5
  %532 = fpext float %531 to double
  %533 = fcmp ogt double %530, %532
  br i1 %533, label %550, label %534

534:                                              ; preds = %504
  %535 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %536 = load float, ptr %535, align 8, !tbaa !5
  %537 = call i1 @llvm.is.fpclass.f32(float %536, i32 3)
  br i1 %537, label %550, label %538

538:                                              ; preds = %534
  %539 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %540 = load float, ptr %539, align 8, !tbaa !5
  %541 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %541, label %550, label %542

542:                                              ; preds = %538
  %543 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %544 = load float, ptr %543, align 8, !tbaa !5
  %545 = call i1 @llvm.is.fpclass.f32(float %544, i32 3)
  br i1 %545, label %550, label %546

546:                                              ; preds = %542
  %547 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %548 = load float, ptr %547, align 8, !tbaa !5
  %549 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %549, label %550, label %579

550:                                              ; preds = %546, %542, %538, %534, %504
  %551 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %552 = load float, ptr %551, align 8, !tbaa !5
  %553 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %554 = load float, ptr %553, align 8, !tbaa !5
  %555 = fsub float %552, %554
  %556 = fpext float %555 to double
  %557 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %558 = load float, ptr %557, align 8, !tbaa !5
  %559 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %560 = load float, ptr %559, align 8, !tbaa !5
  %561 = fsub float %558, %560
  %562 = fpext float %561 to double
  %563 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %564 = load float, ptr %563, align 8, !tbaa !5
  %565 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %566 = load float, ptr %565, align 8, !tbaa !5
  %567 = fsub float %564, %566
  %568 = fpext float %567 to double
  %569 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 6
  %570 = load float, ptr %569, align 8, !tbaa !5
  %571 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 6
  %572 = load float, ptr %571, align 8, !tbaa !5
  %573 = fsub float %570, %572
  %574 = fpext float %573 to double
  %575 = call double @llvm.fmuladd.f64(double %556, double %562, double 0.000000e+00)
  %576 = call double @sqrt(double noundef %575) #6
  %577 = load float, ptr %1, align 4, !tbaa !5
  %578 = fpext float %577 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 337, ptr noundef @.str.46, double noundef %576, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %578)
  br label %580

579:                                              ; preds = %546
  call void (...) @liquid_autotest_passed()
  br label %580

580:                                              ; preds = %579, %550
  %581 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %582 = load float, ptr %581, align 4, !tbaa !5
  %583 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %584 = load float, ptr %583, align 4, !tbaa !5
  %585 = fsub float %582, %584
  %586 = fpext float %585 to double
  %587 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %588 = load float, ptr %587, align 4, !tbaa !5
  %589 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %590 = load float, ptr %589, align 4, !tbaa !5
  %591 = fsub float %588, %590
  %592 = fpext float %591 to double
  %593 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %594 = load float, ptr %593, align 4, !tbaa !5
  %595 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %596 = load float, ptr %595, align 4, !tbaa !5
  %597 = fsub float %594, %596
  %598 = fpext float %597 to double
  %599 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %600 = load float, ptr %599, align 4, !tbaa !5
  %601 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %602 = load float, ptr %601, align 4, !tbaa !5
  %603 = fsub float %600, %602
  %604 = fpext float %603 to double
  %605 = call double @llvm.fmuladd.f64(double %586, double %592, double 0.000000e+00)
  %606 = call double @sqrt(double noundef %605) #6
  %607 = load float, ptr %1, align 4, !tbaa !5
  %608 = fpext float %607 to double
  %609 = fcmp ogt double %606, %608
  br i1 %609, label %626, label %610

610:                                              ; preds = %580
  %611 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %612 = load float, ptr %611, align 4, !tbaa !5
  %613 = call i1 @llvm.is.fpclass.f32(float %612, i32 3)
  br i1 %613, label %626, label %614

614:                                              ; preds = %610
  %615 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %616 = load float, ptr %615, align 4, !tbaa !5
  %617 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %617, label %626, label %618

618:                                              ; preds = %614
  %619 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %620 = load float, ptr %619, align 4, !tbaa !5
  %621 = call i1 @llvm.is.fpclass.f32(float %620, i32 3)
  br i1 %621, label %626, label %622

622:                                              ; preds = %618
  %623 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %624 = load float, ptr %623, align 4, !tbaa !5
  %625 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %625, label %626, label %655

626:                                              ; preds = %622, %618, %614, %610, %580
  %627 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %628 = load float, ptr %627, align 4, !tbaa !5
  %629 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %630 = load float, ptr %629, align 4, !tbaa !5
  %631 = fsub float %628, %630
  %632 = fpext float %631 to double
  %633 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %634 = load float, ptr %633, align 4, !tbaa !5
  %635 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %636 = load float, ptr %635, align 4, !tbaa !5
  %637 = fsub float %634, %636
  %638 = fpext float %637 to double
  %639 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %640 = load float, ptr %639, align 4, !tbaa !5
  %641 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %642 = load float, ptr %641, align 4, !tbaa !5
  %643 = fsub float %640, %642
  %644 = fpext float %643 to double
  %645 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 7
  %646 = load float, ptr %645, align 4, !tbaa !5
  %647 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 7
  %648 = load float, ptr %647, align 4, !tbaa !5
  %649 = fsub float %646, %648
  %650 = fpext float %649 to double
  %651 = call double @llvm.fmuladd.f64(double %632, double %638, double 0.000000e+00)
  %652 = call double @sqrt(double noundef %651) #6
  %653 = load float, ptr %1, align 4, !tbaa !5
  %654 = fpext float %653 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 338, ptr noundef @.str.47, double noundef %652, ptr noundef @.str.31, ptr noundef @.str.32, double noundef %654)
  br label %656

655:                                              ; preds = %622
  call void (...) @liquid_autotest_passed()
  br label %656

656:                                              ; preds = %655, %626
  %657 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !11
  %658 = icmp ne i32 %657, 0
  br i1 %658, label %659, label %714

659:                                              ; preds = %656
  %660 = call i32 (ptr, ...) @printf(ptr noundef @.str.18)
  %661 = load ptr, ptr %2, align 8, !tbaa !9
  %662 = call i32 @smatrixb_print(ptr noundef %661)
  %663 = call i32 (ptr, ...) @printf(ptr noundef @.str.19)
  %664 = load ptr, ptr %2, align 8, !tbaa !9
  %665 = call i32 @smatrixb_print_expanded(ptr noundef %664)
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #6
  %666 = call i32 (ptr, ...) @printf(ptr noundef @.str.20)
  store i32 0, ptr %7, align 4, !tbaa !11
  br label %667

667:                                              ; preds = %677, %659
  %668 = load i32, ptr %7, align 4, !tbaa !11
  %669 = icmp ult i32 %668, 12
  br i1 %669, label %670, label %680

670:                                              ; preds = %667
  %671 = load i32, ptr %7, align 4, !tbaa !11
  %672 = zext i32 %671 to i64
  %673 = getelementptr inbounds [12 x float], ptr %3, i64 0, i64 %672
  %674 = load float, ptr %673, align 4, !tbaa !5
  %675 = fpext float %674 to double
  %676 = call i32 (ptr, ...) @printf(ptr noundef @.str.48, double noundef %675)
  br label %677

677:                                              ; preds = %670
  %678 = load i32, ptr %7, align 4, !tbaa !11
  %679 = add i32 %678, 1
  store i32 %679, ptr %7, align 4, !tbaa !11
  br label %667, !llvm.loop !13

680:                                              ; preds = %667
  %681 = call i32 (ptr, ...) @printf(ptr noundef @.str.22)
  %682 = call i32 (ptr, ...) @printf(ptr noundef @.str.23)
  store i32 0, ptr %6, align 4, !tbaa !11
  br label %683

683:                                              ; preds = %693, %680
  %684 = load i32, ptr %6, align 4, !tbaa !11
  %685 = icmp ult i32 %684, 8
  br i1 %685, label %686, label %696

686:                                              ; preds = %683
  %687 = load i32, ptr %6, align 4, !tbaa !11
  %688 = zext i32 %687 to i64
  %689 = getelementptr inbounds [8 x float], ptr %5, i64 0, i64 %688
  %690 = load float, ptr %689, align 4, !tbaa !5
  %691 = fpext float %690 to double
  %692 = call i32 (ptr, ...) @printf(ptr noundef @.str.48, double noundef %691)
  br label %693

693:                                              ; preds = %686
  %694 = load i32, ptr %6, align 4, !tbaa !11
  %695 = add i32 %694, 1
  store i32 %695, ptr %6, align 4, !tbaa !11
  br label %683, !llvm.loop !15

696:                                              ; preds = %683
  %697 = call i32 (ptr, ...) @printf(ptr noundef @.str.22)
  %698 = call i32 (ptr, ...) @printf(ptr noundef @.str.24)
  store i32 0, ptr %6, align 4, !tbaa !11
  br label %699

699:                                              ; preds = %709, %696
  %700 = load i32, ptr %6, align 4, !tbaa !11
  %701 = icmp ult i32 %700, 8
  br i1 %701, label %702, label %712

702:                                              ; preds = %699
  %703 = load i32, ptr %6, align 4, !tbaa !11
  %704 = zext i32 %703 to i64
  %705 = getelementptr inbounds [8 x float], ptr %4, i64 0, i64 %704
  %706 = load float, ptr %705, align 4, !tbaa !5
  %707 = fpext float %706 to double
  %708 = call i32 (ptr, ...) @printf(ptr noundef @.str.48, double noundef %707)
  br label %709

709:                                              ; preds = %702
  %710 = load i32, ptr %6, align 4, !tbaa !11
  %711 = add i32 %710, 1
  store i32 %711, ptr %6, align 4, !tbaa !11
  br label %699, !llvm.loop !16

712:                                              ; preds = %699
  %713 = call i32 (ptr, ...) @printf(ptr noundef @.str.22)
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  br label %714

714:                                              ; preds = %712, %656
  %715 = load ptr, ptr %2, align 8, !tbaa !9
  %716 = call i32 @smatrixb_destroy(ptr noundef %715)
  call void @llvm.lifetime.end.p0(i64 32, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 48, ptr %3) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %2) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %1) #6
  ret void
}

declare i32 @smatrixb_vmulf(ptr noundef, ptr noundef, ptr noundef) #1

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { 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 #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}


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

@.str = external hidden unnamed_addr constant [91 x i8], align 1
@liquid_autotest_verbose = external local_unnamed_addr global i32, align 4
@.str.18 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [4 x i8], align 1
@__const.autotest_smatrixb_vmulf.x = external hidden unnamed_addr constant [12 x float], align 16
@__const.autotest_smatrixb_vmulf.y_test = external hidden unnamed_addr constant [8 x float], align 16
@.str.40 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [6 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

declare ptr @smatrixb_create(i32 noundef, i32 noundef) local_unnamed_addr #1

declare i32 @smatrixb_set(ptr noundef, i32 noundef, i32 noundef, i8 noundef zeroext) local_unnamed_addr #1

; Function Attrs: mustprogress 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) #2

declare void @liquid_autotest_failed_expr(ptr noundef, i32 noundef, ptr noundef, double noundef, ptr noundef, ptr noundef, double noundef) local_unnamed_addr #1

declare void @liquid_autotest_passed(...) local_unnamed_addr #1

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

declare i32 @smatrixb_print(ptr noundef) local_unnamed_addr #1

declare i32 @smatrixb_print_expanded(ptr noundef) local_unnamed_addr #1

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

declare i32 @smatrixb_destroy(ptr noundef) local_unnamed_addr #1

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #4

; Function Attrs: nounwind uwtable
define dso_local void @autotest_smatrixb_vmulf() local_unnamed_addr #5 {
  %1 = alloca [12 x float], align 16
  %2 = alloca [8 x float], align 16
  %3 = tail call ptr @smatrixb_create(i32 noundef 8, i32 noundef 12) #7
  %4 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 0, i32 noundef 0, i8 noundef zeroext 1) #7
  %5 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 2, i32 noundef 0, i8 noundef zeroext 1) #7
  %6 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 6, i32 noundef 0, i8 noundef zeroext 1) #7
  %7 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 3, i32 noundef 2, i8 noundef zeroext 1) #7
  %8 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 6, i32 noundef 2, i8 noundef zeroext 1) #7
  %9 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 7, i32 noundef 2, i8 noundef zeroext 1) #7
  %10 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 1, i32 noundef 3, i8 noundef zeroext 1) #7
  %11 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 7, i32 noundef 5, i8 noundef zeroext 1) #7
  %12 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 3, i32 noundef 6, i8 noundef zeroext 1) #7
  %13 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 5, i32 noundef 6, i8 noundef zeroext 1) #7
  %14 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 7, i32 noundef 6, i8 noundef zeroext 1) #7
  %15 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 3, i32 noundef 7, i8 noundef zeroext 1) #7
  %16 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 2, i32 noundef 8, i8 noundef zeroext 1) #7
  %17 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 5, i32 noundef 8, i8 noundef zeroext 1) #7
  %18 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 2, i32 noundef 9, i8 noundef zeroext 1) #7
  %19 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 5, i32 noundef 10, i8 noundef zeroext 1) #7
  %20 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 6, i32 noundef 10, i8 noundef zeroext 1) #7
  %21 = tail call i32 @smatrixb_set(ptr noundef %3, i32 noundef 6, i32 noundef 11, i8 noundef zeroext 1) #7
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %1) #7
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(48) %1, ptr noundef nonnull align 16 dereferenceable(48) @__const.autotest_smatrixb_vmulf.x, i64 48, i1 false)
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %2) #7
  %22 = call i32 @smatrixb_vmulf(ptr noundef %3, ptr noundef nonnull %1, ptr noundef nonnull %2) #7
  %23 = load float, ptr %2, align 16
  %24 = load float, ptr @__const.autotest_smatrixb_vmulf.y_test, align 16
  %25 = fsub float %23, %24
  %26 = fpext float %25 to double
  %27 = call double @llvm.fmuladd.f64(double %26, double %26, double 0.000000e+00)
  %sqrt = call double @llvm.sqrt.f64(double %27)
  %28 = fcmp ogt double %sqrt, 0x3EB0C6F7A0000000
  %29 = fcmp uno float %23, 0.000000e+00
  %or.cond = select i1 %28, i1 true, i1 %29
  %30 = fcmp uno float %24, 0.000000e+00
  %or.cond49 = select i1 %or.cond, i1 true, i1 %30
  br i1 %or.cond49, label %31, label %32

31:                                               ; preds = %0
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 331, ptr noundef nonnull @.str.40, double noundef %sqrt, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %33

32:                                               ; preds = %0
  call void (...) @liquid_autotest_passed() #7
  br label %33

33:                                               ; preds = %32, %31
  %34 = getelementptr inbounds i8, ptr %2, i64 4
  %35 = load float, ptr %34, align 4
  %36 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 4), align 4
  %37 = fsub float %35, %36
  %38 = fpext float %37 to double
  %39 = call double @llvm.fmuladd.f64(double %38, double %38, double 0.000000e+00)
  %sqrt79 = call double @llvm.sqrt.f64(double %39)
  %40 = fcmp ogt double %sqrt79, 0x3EB0C6F7A0000000
  %41 = fcmp uno float %35, 0.000000e+00
  %or.cond51 = select i1 %40, i1 true, i1 %41
  %42 = fcmp uno float %36, 0.000000e+00
  %or.cond53 = select i1 %or.cond51, i1 true, i1 %42
  br i1 %or.cond53, label %43, label %44

43:                                               ; preds = %33
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 332, ptr noundef nonnull @.str.41, double noundef %sqrt79, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %45

44:                                               ; preds = %33
  call void (...) @liquid_autotest_passed() #7
  br label %45

45:                                               ; preds = %44, %43
  %46 = getelementptr inbounds i8, ptr %2, i64 8
  %47 = load float, ptr %46, align 8
  %48 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 8), align 8
  %49 = fsub float %47, %48
  %50 = fpext float %49 to double
  %51 = call double @llvm.fmuladd.f64(double %50, double %50, double 0.000000e+00)
  %sqrt81 = call double @llvm.sqrt.f64(double %51)
  %52 = fcmp ogt double %sqrt81, 0x3EB0C6F7A0000000
  %53 = fcmp uno float %47, 0.000000e+00
  %or.cond55 = select i1 %52, i1 true, i1 %53
  %54 = fcmp uno float %48, 0.000000e+00
  %or.cond57 = select i1 %or.cond55, i1 true, i1 %54
  br i1 %or.cond57, label %55, label %56

55:                                               ; preds = %45
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 333, ptr noundef nonnull @.str.42, double noundef %sqrt81, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %57

56:                                               ; preds = %45
  call void (...) @liquid_autotest_passed() #7
  br label %57

57:                                               ; preds = %56, %55
  %58 = getelementptr inbounds i8, ptr %2, i64 12
  %59 = load float, ptr %58, align 4
  %60 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 12), align 4
  %61 = fsub float %59, %60
  %62 = fpext float %61 to double
  %63 = call double @llvm.fmuladd.f64(double %62, double %62, double 0.000000e+00)
  %sqrt83 = call double @llvm.sqrt.f64(double %63)
  %64 = fcmp ogt double %sqrt83, 0x3EB0C6F7A0000000
  %65 = fcmp uno float %59, 0.000000e+00
  %or.cond59 = select i1 %64, i1 true, i1 %65
  %66 = fcmp uno float %60, 0.000000e+00
  %or.cond61 = select i1 %or.cond59, i1 true, i1 %66
  br i1 %or.cond61, label %67, label %68

67:                                               ; preds = %57
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 334, ptr noundef nonnull @.str.43, double noundef %sqrt83, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %69

68:                                               ; preds = %57
  call void (...) @liquid_autotest_passed() #7
  br label %69

69:                                               ; preds = %68, %67
  %70 = getelementptr inbounds i8, ptr %2, i64 16
  %71 = load float, ptr %70, align 16
  %72 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 16), align 16
  %73 = fsub float %71, %72
  %74 = fpext float %73 to double
  %75 = call double @llvm.fmuladd.f64(double %74, double %74, double 0.000000e+00)
  %sqrt85 = call double @llvm.sqrt.f64(double %75)
  %76 = fcmp ogt double %sqrt85, 0x3EB0C6F7A0000000
  %77 = fcmp uno float %71, 0.000000e+00
  %or.cond63 = select i1 %76, i1 true, i1 %77
  %78 = fcmp uno float %72, 0.000000e+00
  %or.cond65 = select i1 %or.cond63, i1 true, i1 %78
  br i1 %or.cond65, label %79, label %80

79:                                               ; preds = %69
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 335, ptr noundef nonnull @.str.44, double noundef %sqrt85, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %81

80:                                               ; preds = %69
  call void (...) @liquid_autotest_passed() #7
  br label %81

81:                                               ; preds = %80, %79
  %82 = getelementptr inbounds i8, ptr %2, i64 20
  %83 = load float, ptr %82, align 4
  %84 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 20), align 4
  %85 = fsub float %83, %84
  %86 = fpext float %85 to double
  %87 = call double @llvm.fmuladd.f64(double %86, double %86, double 0.000000e+00)
  %sqrt87 = call double @llvm.sqrt.f64(double %87)
  %88 = fcmp ogt double %sqrt87, 0x3EB0C6F7A0000000
  %89 = fcmp uno float %83, 0.000000e+00
  %or.cond67 = select i1 %88, i1 true, i1 %89
  %90 = fcmp uno float %84, 0.000000e+00
  %or.cond69 = select i1 %or.cond67, i1 true, i1 %90
  br i1 %or.cond69, label %91, label %92

91:                                               ; preds = %81
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 336, ptr noundef nonnull @.str.45, double noundef %sqrt87, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %93

92:                                               ; preds = %81
  call void (...) @liquid_autotest_passed() #7
  br label %93

93:                                               ; preds = %92, %91
  %94 = getelementptr inbounds i8, ptr %2, i64 24
  %95 = load float, ptr %94, align 8
  %96 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 24), align 8
  %97 = fsub float %95, %96
  %98 = fpext float %97 to double
  %99 = call double @llvm.fmuladd.f64(double %98, double %98, double 0.000000e+00)
  %sqrt89 = call double @llvm.sqrt.f64(double %99)
  %100 = fcmp ogt double %sqrt89, 0x3EB0C6F7A0000000
  %101 = fcmp uno float %95, 0.000000e+00
  %or.cond71 = select i1 %100, i1 true, i1 %101
  %102 = fcmp uno float %96, 0.000000e+00
  %or.cond73 = select i1 %or.cond71, i1 true, i1 %102
  br i1 %or.cond73, label %103, label %104

103:                                              ; preds = %93
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 337, ptr noundef nonnull @.str.46, double noundef %sqrt89, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %105

104:                                              ; preds = %93
  call void (...) @liquid_autotest_passed() #7
  br label %105

105:                                              ; preds = %104, %103
  %106 = getelementptr inbounds i8, ptr %2, i64 28
  %107 = load float, ptr %106, align 4
  %108 = load float, ptr getelementptr inbounds (i8, ptr @__const.autotest_smatrixb_vmulf.y_test, i64 28), align 4
  %109 = fsub float %107, %108
  %110 = fpext float %109 to double
  %111 = call double @llvm.fmuladd.f64(double %110, double %110, double 0.000000e+00)
  %sqrt91 = call double @llvm.sqrt.f64(double %111)
  %112 = fcmp ogt double %sqrt91, 0x3EB0C6F7A0000000
  %113 = fcmp uno float %107, 0.000000e+00
  %or.cond75 = select i1 %112, i1 true, i1 %113
  %114 = fcmp uno float %108, 0.000000e+00
  %or.cond77 = select i1 %or.cond75, i1 true, i1 %114
  br i1 %or.cond77, label %115, label %116

115:                                              ; preds = %105
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 338, ptr noundef nonnull @.str.47, double noundef %sqrt91, ptr noundef nonnull @.str.31, ptr noundef nonnull @.str.32, double noundef 0x3EB0C6F7A0000000) #7
  br label %117

116:                                              ; preds = %105
  call void (...) @liquid_autotest_passed() #7
  br label %117

117:                                              ; preds = %116, %115
  %118 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !5
  %.not = icmp eq i32 %118, 0
  br i1 %.not, label %217, label %119

119:                                              ; preds = %117
  %120 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.18)
  %121 = call i32 @smatrixb_print(ptr noundef %3) #7
  %122 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.19)
  %123 = call i32 @smatrixb_print_expanded(ptr noundef %3) #7
  %124 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.20)
  %125 = load float, ptr %1, align 16, !tbaa !9
  %126 = fpext float %125 to double
  %127 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %126)
  %128 = getelementptr inbounds i8, ptr %1, i64 4
  %129 = load float, ptr %128, align 4, !tbaa !9
  %130 = fpext float %129 to double
  %131 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %130)
  %132 = getelementptr inbounds i8, ptr %1, i64 8
  %133 = load float, ptr %132, align 8, !tbaa !9
  %134 = fpext float %133 to double
  %135 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %134)
  %136 = getelementptr inbounds i8, ptr %1, i64 12
  %137 = load float, ptr %136, align 4, !tbaa !9
  %138 = fpext float %137 to double
  %139 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %138)
  %140 = getelementptr inbounds i8, ptr %1, i64 16
  %141 = load float, ptr %140, align 16, !tbaa !9
  %142 = fpext float %141 to double
  %143 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %142)
  %144 = getelementptr inbounds i8, ptr %1, i64 20
  %145 = load float, ptr %144, align 4, !tbaa !9
  %146 = fpext float %145 to double
  %147 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %146)
  %148 = getelementptr inbounds i8, ptr %1, i64 24
  %149 = load float, ptr %148, align 8, !tbaa !9
  %150 = fpext float %149 to double
  %151 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %150)
  %152 = getelementptr inbounds i8, ptr %1, i64 28
  %153 = load float, ptr %152, align 4, !tbaa !9
  %154 = fpext float %153 to double
  %155 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %154)
  %156 = getelementptr inbounds i8, ptr %1, i64 32
  %157 = load float, ptr %156, align 16, !tbaa !9
  %158 = fpext float %157 to double
  %159 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %158)
  %160 = getelementptr inbounds i8, ptr %1, i64 36
  %161 = load float, ptr %160, align 4, !tbaa !9
  %162 = fpext float %161 to double
  %163 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %162)
  %164 = getelementptr inbounds i8, ptr %1, i64 40
  %165 = load float, ptr %164, align 8, !tbaa !9
  %166 = fpext float %165 to double
  %167 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %166)
  %168 = getelementptr inbounds i8, ptr %1, i64 44
  %169 = load float, ptr %168, align 4, !tbaa !9
  %170 = fpext float %169 to double
  %171 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %170)
  %172 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.22)
  %173 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.23)
  %174 = load float, ptr %2, align 16, !tbaa !9
  %175 = fpext float %174 to double
  %176 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %175)
  %177 = load float, ptr %34, align 4, !tbaa !9
  %178 = fpext float %177 to double
  %179 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %178)
  %180 = load float, ptr %46, align 8, !tbaa !9
  %181 = fpext float %180 to double
  %182 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %181)
  %183 = load float, ptr %58, align 4, !tbaa !9
  %184 = fpext float %183 to double
  %185 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %184)
  %186 = load float, ptr %70, align 16, !tbaa !9
  %187 = fpext float %186 to double
  %188 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %187)
  %189 = load float, ptr %82, align 4, !tbaa !9
  %190 = fpext float %189 to double
  %191 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %190)
  %192 = load float, ptr %94, align 8, !tbaa !9
  %193 = fpext float %192 to double
  %194 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %193)
  %195 = load float, ptr %106, align 4, !tbaa !9
  %196 = fpext float %195 to double
  %197 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %196)
  %198 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.22)
  %199 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.24)
  %200 = fpext float %24 to double
  %201 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %200)
  %202 = fpext float %36 to double
  %203 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %202)
  %204 = fpext float %48 to double
  %205 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %204)
  %206 = fpext float %60 to double
  %207 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %206)
  %208 = fpext float %72 to double
  %209 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %208)
  %210 = fpext float %84 to double
  %211 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %210)
  %212 = fpext float %96 to double
  %213 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %212)
  %214 = fpext float %108 to double
  %215 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.48, double noundef %214)
  %216 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.22)
  br label %217

217:                                              ; preds = %119, %117
  %218 = call i32 @smatrixb_destroy(ptr noundef %3) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %2) #7
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %1) #7
  ret void
}

declare i32 @smatrixb_vmulf(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.sqrt.f64(double) #6

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { 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 #4 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}


; Effective O3 passes: AggressiveInstCombinePass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LoopRotatePass,SROAPass,SimplifyCFGPass,TailCallElimPass