; LLVM IR from jgaeddert/liquid-dsp :: src/dotprod/tests (dotprod_crcf_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 [96 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [4 x i8], align 1
@liquid_autotest_verbose = external global i32, align 4
@.str.8 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [40 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 i32 @dotprod_crcf_run(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #1

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

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

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

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 @dotprod_crcf_run4(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #1

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

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

declare i32 @dotprod_crcf_destroy(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 @printf(ptr noundef, ...) #1

; Function Attrs: nounwind uwtable
define dso_local void @runtest_dotprod_crcf(i32 noundef %0) #4 {
  %2 = alloca i32, align 4
  %3 = alloca float, align 4
  %4 = alloca ptr, align 8
  %5 = alloca i64, align 8
  %6 = alloca i64, align 8
  %7 = alloca i32, align 4
  %8 = alloca { float, float }, align 4
  %9 = alloca { float, float }, align 4
  %10 = alloca ptr, align 8
  %11 = alloca { float, float }, align 4
  %12 = alloca { float, float }, align 4
  store i32 %0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #6
  store float 0x3F1A36E2E0000000, ptr %3, align 4, !tbaa !9
  %13 = load i32, ptr %2, align 4, !tbaa !5
  %14 = zext i32 %13 to i64
  %15 = call ptr @llvm.stacksave.p0()
  store ptr %15, ptr %4, align 8
  %16 = alloca float, i64 %14, align 16
  store i64 %14, ptr %5, align 8
  %17 = load i32, ptr %2, align 4, !tbaa !5
  %18 = zext i32 %17 to i64
  %19 = alloca { float, float }, i64 %18, align 16
  store i64 %18, ptr %6, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #6
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %20

20:                                               ; preds = %39, %1
  %21 = load i32, ptr %7, align 4, !tbaa !5
  %22 = load i32, ptr %2, align 4, !tbaa !5
  %23 = icmp ult i32 %21, %22
  br i1 %23, label %24, label %42

24:                                               ; preds = %20
  %25 = call float (...) @randnf()
  %26 = load i32, ptr %7, align 4, !tbaa !5
  %27 = zext i32 %26 to i64
  %28 = getelementptr inbounds float, ptr %16, i64 %27
  store float %25, ptr %28, align 4, !tbaa !9
  %29 = call float (...) @randnf()
  %30 = call float (...) @randnf()
  %31 = fmul float %30, 0.000000e+00
  %32 = fmul float %30, 1.000000e+00
  %33 = fadd float %29, %31
  %34 = load i32, ptr %7, align 4, !tbaa !5
  %35 = zext i32 %34 to i64
  %36 = getelementptr inbounds { float, float }, ptr %19, i64 %35
  %37 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %38 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  store float %33, ptr %37, align 8
  store float %32, ptr %38, align 4
  br label %39

39:                                               ; preds = %24
  %40 = load i32, ptr %7, align 4, !tbaa !5
  %41 = add i32 %40, 1
  store i32 %41, ptr %7, align 4, !tbaa !5
  br label %20, !llvm.loop !11

42:                                               ; preds = %20
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #6
  %43 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %44 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float 0.000000e+00, ptr %43, align 4
  store float 0.000000e+00, ptr %44, align 4
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %45

45:                                               ; preds = %71, %42
  %46 = load i32, ptr %7, align 4, !tbaa !5
  %47 = load i32, ptr %2, align 4, !tbaa !5
  %48 = icmp ult i32 %46, %47
  br i1 %48, label %49, label %74

49:                                               ; preds = %45
  %50 = load i32, ptr %7, align 4, !tbaa !5
  %51 = zext i32 %50 to i64
  %52 = getelementptr inbounds float, ptr %16, i64 %51
  %53 = load float, ptr %52, align 4, !tbaa !9
  %54 = load i32, ptr %7, align 4, !tbaa !5
  %55 = zext i32 %54 to i64
  %56 = getelementptr inbounds { float, float }, ptr %19, i64 %55
  %57 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 0
  %58 = load float, ptr %57, align 8
  %59 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 1
  %60 = load float, ptr %59, align 4
  %61 = fmul float %53, %58
  %62 = fmul float %53, %60
  %63 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %64 = load float, ptr %63, align 4
  %65 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %66 = load float, ptr %65, align 4
  %67 = fadd float %64, %61
  %68 = fadd float %66, %62
  %69 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %70 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float %67, ptr %69, align 4
  store float %68, ptr %70, align 4
  br label %71

71:                                               ; preds = %49
  %72 = load i32, ptr %7, align 4, !tbaa !5
  %73 = add i32 %72, 1
  store i32 %73, ptr %7, align 4, !tbaa !5
  br label %45, !llvm.loop !13

74:                                               ; preds = %45
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #6
  %75 = load i32, ptr %2, align 4, !tbaa !5
  %76 = call ptr @dotprod_crcf_create(ptr noundef %16, i32 noundef %75)
  store ptr %76, ptr %10, align 8, !tbaa !14
  %77 = load ptr, ptr %10, align 8, !tbaa !14
  %78 = call i32 @dotprod_crcf_execute(ptr noundef %77, ptr noundef %19, ptr noundef %9)
  %79 = load ptr, ptr %10, align 8, !tbaa !14
  %80 = call i32 @dotprod_crcf_destroy(ptr noundef %79)
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %81 = load i32, ptr %2, align 4, !tbaa !5
  %82 = call i32 @dotprod_crcf_run(ptr noundef %16, ptr noundef %19, i32 noundef %81, ptr noundef %11)
  %83 = load i32, ptr %2, align 4, !tbaa !5
  %84 = call i32 @dotprod_crcf_run4(ptr noundef %16, ptr noundef %19, i32 noundef %83, ptr noundef %12)
  %85 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !5
  %86 = icmp ne i32 %85, 0
  br i1 %86, label %87, label %154

87:                                               ; preds = %74
  %88 = load i32, ptr %2, align 4, !tbaa !5
  %89 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %90 = load float, ptr %89, align 4
  %91 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %92 = load float, ptr %91, align 4
  %93 = fpext float %90 to double
  %94 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %95 = load float, ptr %94, align 4
  %96 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %97 = load float, ptr %96, align 4
  %98 = fpext float %97 to double
  %99 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %100 = load float, ptr %99, align 4
  %101 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %102 = load float, ptr %101, align 4
  %103 = fpext float %100 to double
  %104 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %105 = load float, ptr %104, align 4
  %106 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %107 = load float, ptr %106, align 4
  %108 = fpext float %107 to double
  %109 = call i32 (ptr, ...) @printf(ptr noundef @.str.8, i32 noundef %88, double noundef %93, double noundef %98, double noundef %103, double noundef %108)
  %110 = load i32, ptr %2, align 4, !tbaa !5
  %111 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %112 = load float, ptr %111, align 4
  %113 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %114 = load float, ptr %113, align 4
  %115 = fpext float %112 to double
  %116 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %117 = load float, ptr %116, align 4
  %118 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %119 = load float, ptr %118, align 4
  %120 = fpext float %119 to double
  %121 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %122 = load float, ptr %121, align 4
  %123 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %124 = load float, ptr %123, align 4
  %125 = fpext float %122 to double
  %126 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %127 = load float, ptr %126, align 4
  %128 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %129 = load float, ptr %128, align 4
  %130 = fpext float %129 to double
  %131 = call i32 (ptr, ...) @printf(ptr noundef @.str.9, i32 noundef %110, double noundef %115, double noundef %120, double noundef %125, double noundef %130)
  %132 = load i32, ptr %2, align 4, !tbaa !5
  %133 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %134 = load float, ptr %133, align 4
  %135 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %136 = load float, ptr %135, align 4
  %137 = fpext float %134 to double
  %138 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %139 = load float, ptr %138, align 4
  %140 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %141 = load float, ptr %140, align 4
  %142 = fpext float %141 to double
  %143 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %144 = load float, ptr %143, align 4
  %145 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %146 = load float, ptr %145, align 4
  %147 = fpext float %144 to double
  %148 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %149 = load float, ptr %148, align 4
  %150 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %151 = load float, ptr %150, align 4
  %152 = fpext float %151 to double
  %153 = call i32 (ptr, ...) @printf(ptr noundef @.str.10, i32 noundef %132, double noundef %137, double noundef %142, double noundef %147, double noundef %152)
  br label %154

154:                                              ; preds = %87, %74
  %155 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %156 = load float, ptr %155, align 4
  %157 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %158 = load float, ptr %157, align 4
  %159 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %160 = load float, ptr %159, align 4
  %161 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %162 = load float, ptr %161, align 4
  %163 = fsub float %156, %160
  %164 = fpext float %163 to double
  %165 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %166 = load float, ptr %165, align 4
  %167 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %168 = load float, ptr %167, align 4
  %169 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %170 = load float, ptr %169, align 4
  %171 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %172 = load float, ptr %171, align 4
  %173 = fsub float %166, %170
  %174 = fpext float %173 to double
  %175 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %176 = load float, ptr %175, align 4
  %177 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %178 = load float, ptr %177, align 4
  %179 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %180 = load float, ptr %179, align 4
  %181 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %182 = load float, ptr %181, align 4
  %183 = fsub float %176, %180
  %184 = fpext float %183 to double
  %185 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %186 = load float, ptr %185, align 4
  %187 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %188 = load float, ptr %187, align 4
  %189 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %190 = load float, ptr %189, align 4
  %191 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %192 = load float, ptr %191, align 4
  %193 = fsub float %186, %190
  %194 = fpext float %193 to double
  %195 = call double @llvm.fmuladd.f64(double %164, double %174, double 0.000000e+00)
  %196 = call double @sqrt(double noundef %195) #6
  %197 = load float, ptr %3, align 4, !tbaa !9
  %198 = fpext float %197 to double
  %199 = fcmp ogt double %196, %198
  br i1 %199, label %224, label %200

200:                                              ; preds = %154
  %201 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %202 = load float, ptr %201, align 4
  %203 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %204 = load float, ptr %203, align 4
  %205 = call i1 @llvm.is.fpclass.f32(float %202, i32 3)
  br i1 %205, label %224, label %206

206:                                              ; preds = %200
  %207 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %208 = load float, ptr %207, align 4
  %209 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %210 = load float, ptr %209, align 4
  %211 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %211, label %224, label %212

212:                                              ; preds = %206
  %213 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %214 = load float, ptr %213, align 4
  %215 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %216 = load float, ptr %215, align 4
  %217 = call i1 @llvm.is.fpclass.f32(float %214, i32 3)
  br i1 %217, label %224, label %218

218:                                              ; preds = %212
  %219 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %220 = load float, ptr %219, align 4
  %221 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %222 = load float, ptr %221, align 4
  %223 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %223, label %224, label %269

224:                                              ; preds = %218, %212, %206, %200, %154
  %225 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %226 = load float, ptr %225, align 4
  %227 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %228 = load float, ptr %227, align 4
  %229 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %230 = load float, ptr %229, align 4
  %231 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %232 = load float, ptr %231, align 4
  %233 = fsub float %226, %230
  %234 = fpext float %233 to double
  %235 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %236 = load float, ptr %235, align 4
  %237 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %238 = load float, ptr %237, align 4
  %239 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %240 = load float, ptr %239, align 4
  %241 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %242 = load float, ptr %241, align 4
  %243 = fsub float %236, %240
  %244 = fpext float %243 to double
  %245 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %246 = load float, ptr %245, align 4
  %247 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %248 = load float, ptr %247, align 4
  %249 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %250 = load float, ptr %249, align 4
  %251 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %252 = load float, ptr %251, align 4
  %253 = fsub float %246, %250
  %254 = fpext float %253 to double
  %255 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %256 = load float, ptr %255, align 4
  %257 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %258 = load float, ptr %257, align 4
  %259 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %260 = load float, ptr %259, align 4
  %261 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %262 = load float, ptr %261, align 4
  %263 = fsub float %256, %260
  %264 = fpext float %263 to double
  %265 = call double @llvm.fmuladd.f64(double %234, double %244, double 0.000000e+00)
  %266 = call double @sqrt(double noundef %265) #6
  %267 = load float, ptr %3, align 4, !tbaa !9
  %268 = fpext float %267 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 177, ptr noundef @.str.11, double noundef %266, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %268)
  br label %270

269:                                              ; preds = %218
  call void (...) @liquid_autotest_passed()
  br label %270

270:                                              ; preds = %269, %224
  %271 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %272 = load float, ptr %271, align 4
  %273 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %274 = load float, ptr %273, align 4
  %275 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %276 = load float, ptr %275, align 4
  %277 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %278 = load float, ptr %277, align 4
  %279 = fsub float %274, %278
  %280 = fpext float %279 to double
  %281 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %282 = load float, ptr %281, align 4
  %283 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %284 = load float, ptr %283, align 4
  %285 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %286 = load float, ptr %285, align 4
  %287 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %288 = load float, ptr %287, align 4
  %289 = fsub float %284, %288
  %290 = fpext float %289 to double
  %291 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %292 = load float, ptr %291, align 4
  %293 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %294 = load float, ptr %293, align 4
  %295 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %296 = load float, ptr %295, align 4
  %297 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %298 = load float, ptr %297, align 4
  %299 = fsub float %294, %298
  %300 = fpext float %299 to double
  %301 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %302 = load float, ptr %301, align 4
  %303 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %304 = load float, ptr %303, align 4
  %305 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %306 = load float, ptr %305, align 4
  %307 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %308 = load float, ptr %307, align 4
  %309 = fsub float %304, %308
  %310 = fpext float %309 to double
  %311 = call double @llvm.fmuladd.f64(double %280, double %290, double 0.000000e+00)
  %312 = call double @sqrt(double noundef %311) #6
  %313 = load float, ptr %3, align 4, !tbaa !9
  %314 = fpext float %313 to double
  %315 = fcmp ogt double %312, %314
  br i1 %315, label %340, label %316

316:                                              ; preds = %270
  %317 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %318 = load float, ptr %317, align 4
  %319 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %320 = load float, ptr %319, align 4
  %321 = call i1 @llvm.is.fpclass.f32(float %320, i32 3)
  br i1 %321, label %340, label %322

322:                                              ; preds = %316
  %323 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %324 = load float, ptr %323, align 4
  %325 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %326 = load float, ptr %325, align 4
  %327 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %327, label %340, label %328

328:                                              ; preds = %322
  %329 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %330 = load float, ptr %329, align 4
  %331 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %332 = load float, ptr %331, align 4
  %333 = call i1 @llvm.is.fpclass.f32(float %332, i32 3)
  br i1 %333, label %340, label %334

334:                                              ; preds = %328
  %335 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %336 = load float, ptr %335, align 4
  %337 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %338 = load float, ptr %337, align 4
  %339 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %339, label %340, label %385

340:                                              ; preds = %334, %328, %322, %316, %270
  %341 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %342 = load float, ptr %341, align 4
  %343 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %344 = load float, ptr %343, align 4
  %345 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %346 = load float, ptr %345, align 4
  %347 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %348 = load float, ptr %347, align 4
  %349 = fsub float %344, %348
  %350 = fpext float %349 to double
  %351 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %352 = load float, ptr %351, align 4
  %353 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %354 = load float, ptr %353, align 4
  %355 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %356 = load float, ptr %355, align 4
  %357 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %358 = load float, ptr %357, align 4
  %359 = fsub float %354, %358
  %360 = fpext float %359 to double
  %361 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %362 = load float, ptr %361, align 4
  %363 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %364 = load float, ptr %363, align 4
  %365 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %366 = load float, ptr %365, align 4
  %367 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %368 = load float, ptr %367, align 4
  %369 = fsub float %364, %368
  %370 = fpext float %369 to double
  %371 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %372 = load float, ptr %371, align 4
  %373 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %374 = load float, ptr %373, align 4
  %375 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %376 = load float, ptr %375, align 4
  %377 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %378 = load float, ptr %377, align 4
  %379 = fsub float %374, %378
  %380 = fpext float %379 to double
  %381 = call double @llvm.fmuladd.f64(double %350, double %360, double 0.000000e+00)
  %382 = call double @sqrt(double noundef %381) #6
  %383 = load float, ptr %3, align 4, !tbaa !9
  %384 = fpext float %383 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 178, ptr noundef @.str.12, double noundef %382, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %384)
  br label %386

385:                                              ; preds = %334
  call void (...) @liquid_autotest_passed()
  br label %386

386:                                              ; preds = %385, %340
  %387 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %388 = load float, ptr %387, align 4
  %389 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %390 = load float, ptr %389, align 4
  %391 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %392 = load float, ptr %391, align 4
  %393 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %394 = load float, ptr %393, align 4
  %395 = fsub float %388, %392
  %396 = fpext float %395 to double
  %397 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %398 = load float, ptr %397, align 4
  %399 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %400 = load float, ptr %399, align 4
  %401 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %402 = load float, ptr %401, align 4
  %403 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %404 = load float, ptr %403, align 4
  %405 = fsub float %398, %402
  %406 = fpext float %405 to double
  %407 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %408 = load float, ptr %407, align 4
  %409 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %410 = load float, ptr %409, align 4
  %411 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %412 = load float, ptr %411, align 4
  %413 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %414 = load float, ptr %413, align 4
  %415 = fsub float %408, %412
  %416 = fpext float %415 to double
  %417 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %418 = load float, ptr %417, align 4
  %419 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %420 = load float, ptr %419, align 4
  %421 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %422 = load float, ptr %421, align 4
  %423 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %424 = load float, ptr %423, align 4
  %425 = fsub float %418, %422
  %426 = fpext float %425 to double
  %427 = call double @llvm.fmuladd.f64(double %396, double %406, double 0.000000e+00)
  %428 = call double @sqrt(double noundef %427) #6
  %429 = load float, ptr %3, align 4, !tbaa !9
  %430 = fpext float %429 to double
  %431 = fcmp ogt double %428, %430
  br i1 %431, label %456, label %432

432:                                              ; preds = %386
  %433 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %434 = load float, ptr %433, align 4
  %435 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %436 = load float, ptr %435, align 4
  %437 = call i1 @llvm.is.fpclass.f32(float %434, i32 3)
  br i1 %437, label %456, label %438

438:                                              ; preds = %432
  %439 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %440 = load float, ptr %439, align 4
  %441 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %442 = load float, ptr %441, align 4
  %443 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %443, label %456, label %444

444:                                              ; preds = %438
  %445 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %446 = load float, ptr %445, align 4
  %447 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %448 = load float, ptr %447, align 4
  %449 = call i1 @llvm.is.fpclass.f32(float %446, i32 3)
  br i1 %449, label %456, label %450

450:                                              ; preds = %444
  %451 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %452 = load float, ptr %451, align 4
  %453 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %454 = load float, ptr %453, align 4
  %455 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %455, label %456, label %501

456:                                              ; preds = %450, %444, %438, %432, %386
  %457 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %458 = load float, ptr %457, align 4
  %459 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %460 = load float, ptr %459, align 4
  %461 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %462 = load float, ptr %461, align 4
  %463 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %464 = load float, ptr %463, align 4
  %465 = fsub float %458, %462
  %466 = fpext float %465 to double
  %467 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %468 = load float, ptr %467, align 4
  %469 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %470 = load float, ptr %469, align 4
  %471 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %472 = load float, ptr %471, align 4
  %473 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %474 = load float, ptr %473, align 4
  %475 = fsub float %468, %472
  %476 = fpext float %475 to double
  %477 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %478 = load float, ptr %477, align 4
  %479 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %480 = load float, ptr %479, align 4
  %481 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %482 = load float, ptr %481, align 4
  %483 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %484 = load float, ptr %483, align 4
  %485 = fsub float %478, %482
  %486 = fpext float %485 to double
  %487 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %488 = load float, ptr %487, align 4
  %489 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %490 = load float, ptr %489, align 4
  %491 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %492 = load float, ptr %491, align 4
  %493 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %494 = load float, ptr %493, align 4
  %495 = fsub float %488, %492
  %496 = fpext float %495 to double
  %497 = call double @llvm.fmuladd.f64(double %466, double %476, double 0.000000e+00)
  %498 = call double @sqrt(double noundef %497) #6
  %499 = load float, ptr %3, align 4, !tbaa !9
  %500 = fpext float %499 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 181, ptr noundef @.str.13, double noundef %498, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %500)
  br label %502

501:                                              ; preds = %450
  call void (...) @liquid_autotest_passed()
  br label %502

502:                                              ; preds = %501, %456
  %503 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %504 = load float, ptr %503, align 4
  %505 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %506 = load float, ptr %505, align 4
  %507 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %508 = load float, ptr %507, align 4
  %509 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %510 = load float, ptr %509, align 4
  %511 = fsub float %506, %510
  %512 = fpext float %511 to double
  %513 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %514 = load float, ptr %513, align 4
  %515 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %516 = load float, ptr %515, align 4
  %517 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %518 = load float, ptr %517, align 4
  %519 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %520 = load float, ptr %519, align 4
  %521 = fsub float %516, %520
  %522 = fpext float %521 to double
  %523 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %524 = load float, ptr %523, align 4
  %525 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %526 = load float, ptr %525, align 4
  %527 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %528 = load float, ptr %527, align 4
  %529 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %530 = load float, ptr %529, align 4
  %531 = fsub float %526, %530
  %532 = fpext float %531 to double
  %533 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %534 = load float, ptr %533, align 4
  %535 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %536 = load float, ptr %535, align 4
  %537 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %538 = load float, ptr %537, align 4
  %539 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %540 = load float, ptr %539, align 4
  %541 = fsub float %536, %540
  %542 = fpext float %541 to double
  %543 = call double @llvm.fmuladd.f64(double %512, double %522, double 0.000000e+00)
  %544 = call double @sqrt(double noundef %543) #6
  %545 = load float, ptr %3, align 4, !tbaa !9
  %546 = fpext float %545 to double
  %547 = fcmp ogt double %544, %546
  br i1 %547, label %572, label %548

548:                                              ; preds = %502
  %549 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %550 = load float, ptr %549, align 4
  %551 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %552 = load float, ptr %551, align 4
  %553 = call i1 @llvm.is.fpclass.f32(float %552, i32 3)
  br i1 %553, label %572, label %554

554:                                              ; preds = %548
  %555 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %556 = load float, ptr %555, align 4
  %557 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %558 = load float, ptr %557, align 4
  %559 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %559, label %572, label %560

560:                                              ; preds = %554
  %561 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %562 = load float, ptr %561, align 4
  %563 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %564 = load float, ptr %563, align 4
  %565 = call i1 @llvm.is.fpclass.f32(float %564, i32 3)
  br i1 %565, label %572, label %566

566:                                              ; preds = %560
  %567 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %568 = load float, ptr %567, align 4
  %569 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %570 = load float, ptr %569, align 4
  %571 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %571, label %572, label %617

572:                                              ; preds = %566, %560, %554, %548, %502
  %573 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %574 = load float, ptr %573, align 4
  %575 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %576 = load float, ptr %575, align 4
  %577 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %578 = load float, ptr %577, align 4
  %579 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %580 = load float, ptr %579, align 4
  %581 = fsub float %576, %580
  %582 = fpext float %581 to double
  %583 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %584 = load float, ptr %583, align 4
  %585 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %586 = load float, ptr %585, align 4
  %587 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %588 = load float, ptr %587, align 4
  %589 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %590 = load float, ptr %589, align 4
  %591 = fsub float %586, %590
  %592 = fpext float %591 to double
  %593 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %594 = load float, ptr %593, align 4
  %595 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %596 = load float, ptr %595, align 4
  %597 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %598 = load float, ptr %597, align 4
  %599 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %600 = load float, ptr %599, align 4
  %601 = fsub float %596, %600
  %602 = fpext float %601 to double
  %603 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %604 = load float, ptr %603, align 4
  %605 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %606 = load float, ptr %605, align 4
  %607 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %608 = load float, ptr %607, align 4
  %609 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %610 = load float, ptr %609, align 4
  %611 = fsub float %606, %610
  %612 = fpext float %611 to double
  %613 = call double @llvm.fmuladd.f64(double %582, double %592, double 0.000000e+00)
  %614 = call double @sqrt(double noundef %613) #6
  %615 = load float, ptr %3, align 4, !tbaa !9
  %616 = fpext float %615 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 182, ptr noundef @.str.14, double noundef %614, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %616)
  br label %618

617:                                              ; preds = %566
  call void (...) @liquid_autotest_passed()
  br label %618

618:                                              ; preds = %617, %572
  %619 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %620 = load float, ptr %619, align 4
  %621 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %622 = load float, ptr %621, align 4
  %623 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %624 = load float, ptr %623, align 4
  %625 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %626 = load float, ptr %625, align 4
  %627 = fsub float %620, %624
  %628 = fpext float %627 to double
  %629 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %630 = load float, ptr %629, align 4
  %631 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %632 = load float, ptr %631, align 4
  %633 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %634 = load float, ptr %633, align 4
  %635 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %636 = load float, ptr %635, align 4
  %637 = fsub float %630, %634
  %638 = fpext float %637 to double
  %639 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %640 = load float, ptr %639, align 4
  %641 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %642 = load float, ptr %641, align 4
  %643 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %644 = load float, ptr %643, align 4
  %645 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %646 = load float, ptr %645, align 4
  %647 = fsub float %640, %644
  %648 = fpext float %647 to double
  %649 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %650 = load float, ptr %649, align 4
  %651 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %652 = load float, ptr %651, align 4
  %653 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %654 = load float, ptr %653, align 4
  %655 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %656 = load float, ptr %655, align 4
  %657 = fsub float %650, %654
  %658 = fpext float %657 to double
  %659 = call double @llvm.fmuladd.f64(double %628, double %638, double 0.000000e+00)
  %660 = call double @sqrt(double noundef %659) #6
  %661 = load float, ptr %3, align 4, !tbaa !9
  %662 = fpext float %661 to double
  %663 = fcmp ogt double %660, %662
  br i1 %663, label %688, label %664

664:                                              ; preds = %618
  %665 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %666 = load float, ptr %665, align 4
  %667 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %668 = load float, ptr %667, align 4
  %669 = call i1 @llvm.is.fpclass.f32(float %666, i32 3)
  br i1 %669, label %688, label %670

670:                                              ; preds = %664
  %671 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %672 = load float, ptr %671, align 4
  %673 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %674 = load float, ptr %673, align 4
  %675 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %675, label %688, label %676

676:                                              ; preds = %670
  %677 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %678 = load float, ptr %677, align 4
  %679 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %680 = load float, ptr %679, align 4
  %681 = call i1 @llvm.is.fpclass.f32(float %678, i32 3)
  br i1 %681, label %688, label %682

682:                                              ; preds = %676
  %683 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %684 = load float, ptr %683, align 4
  %685 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %686 = load float, ptr %685, align 4
  %687 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %687, label %688, label %733

688:                                              ; preds = %682, %676, %670, %664, %618
  %689 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %690 = load float, ptr %689, align 4
  %691 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %692 = load float, ptr %691, align 4
  %693 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %694 = load float, ptr %693, align 4
  %695 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %696 = load float, ptr %695, align 4
  %697 = fsub float %690, %694
  %698 = fpext float %697 to double
  %699 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %700 = load float, ptr %699, align 4
  %701 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %702 = load float, ptr %701, align 4
  %703 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %704 = load float, ptr %703, align 4
  %705 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %706 = load float, ptr %705, align 4
  %707 = fsub float %700, %704
  %708 = fpext float %707 to double
  %709 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %710 = load float, ptr %709, align 4
  %711 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %712 = load float, ptr %711, align 4
  %713 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %714 = load float, ptr %713, align 4
  %715 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %716 = load float, ptr %715, align 4
  %717 = fsub float %710, %714
  %718 = fpext float %717 to double
  %719 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %720 = load float, ptr %719, align 4
  %721 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %722 = load float, ptr %721, align 4
  %723 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %724 = load float, ptr %723, align 4
  %725 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %726 = load float, ptr %725, align 4
  %727 = fsub float %720, %724
  %728 = fpext float %727 to double
  %729 = call double @llvm.fmuladd.f64(double %698, double %708, double 0.000000e+00)
  %730 = call double @sqrt(double noundef %729) #6
  %731 = load float, ptr %3, align 4, !tbaa !9
  %732 = fpext float %731 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 185, ptr noundef @.str.15, double noundef %730, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %732)
  br label %734

733:                                              ; preds = %682
  call void (...) @liquid_autotest_passed()
  br label %734

734:                                              ; preds = %733, %688
  %735 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %736 = load float, ptr %735, align 4
  %737 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %738 = load float, ptr %737, align 4
  %739 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %740 = load float, ptr %739, align 4
  %741 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %742 = load float, ptr %741, align 4
  %743 = fsub float %738, %742
  %744 = fpext float %743 to double
  %745 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %746 = load float, ptr %745, align 4
  %747 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %748 = load float, ptr %747, align 4
  %749 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %750 = load float, ptr %749, align 4
  %751 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %752 = load float, ptr %751, align 4
  %753 = fsub float %748, %752
  %754 = fpext float %753 to double
  %755 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %756 = load float, ptr %755, align 4
  %757 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %758 = load float, ptr %757, align 4
  %759 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %760 = load float, ptr %759, align 4
  %761 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %762 = load float, ptr %761, align 4
  %763 = fsub float %758, %762
  %764 = fpext float %763 to double
  %765 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %766 = load float, ptr %765, align 4
  %767 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %768 = load float, ptr %767, align 4
  %769 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %770 = load float, ptr %769, align 4
  %771 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %772 = load float, ptr %771, align 4
  %773 = fsub float %768, %772
  %774 = fpext float %773 to double
  %775 = call double @llvm.fmuladd.f64(double %744, double %754, double 0.000000e+00)
  %776 = call double @sqrt(double noundef %775) #6
  %777 = load float, ptr %3, align 4, !tbaa !9
  %778 = fpext float %777 to double
  %779 = fcmp ogt double %776, %778
  br i1 %779, label %804, label %780

780:                                              ; preds = %734
  %781 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %782 = load float, ptr %781, align 4
  %783 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %784 = load float, ptr %783, align 4
  %785 = call i1 @llvm.is.fpclass.f32(float %784, i32 3)
  br i1 %785, label %804, label %786

786:                                              ; preds = %780
  %787 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %788 = load float, ptr %787, align 4
  %789 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %790 = load float, ptr %789, align 4
  %791 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %791, label %804, label %792

792:                                              ; preds = %786
  %793 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %794 = load float, ptr %793, align 4
  %795 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %796 = load float, ptr %795, align 4
  %797 = call i1 @llvm.is.fpclass.f32(float %796, i32 3)
  br i1 %797, label %804, label %798

798:                                              ; preds = %792
  %799 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %800 = load float, ptr %799, align 4
  %801 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %802 = load float, ptr %801, align 4
  %803 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %803, label %804, label %849

804:                                              ; preds = %798, %792, %786, %780, %734
  %805 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %806 = load float, ptr %805, align 4
  %807 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %808 = load float, ptr %807, align 4
  %809 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %810 = load float, ptr %809, align 4
  %811 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %812 = load float, ptr %811, align 4
  %813 = fsub float %808, %812
  %814 = fpext float %813 to double
  %815 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %816 = load float, ptr %815, align 4
  %817 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %818 = load float, ptr %817, align 4
  %819 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %820 = load float, ptr %819, align 4
  %821 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %822 = load float, ptr %821, align 4
  %823 = fsub float %818, %822
  %824 = fpext float %823 to double
  %825 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %826 = load float, ptr %825, align 4
  %827 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %828 = load float, ptr %827, align 4
  %829 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %830 = load float, ptr %829, align 4
  %831 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %832 = load float, ptr %831, align 4
  %833 = fsub float %828, %832
  %834 = fpext float %833 to double
  %835 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %836 = load float, ptr %835, align 4
  %837 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %838 = load float, ptr %837, align 4
  %839 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %840 = load float, ptr %839, align 4
  %841 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %842 = load float, ptr %841, align 4
  %843 = fsub float %838, %842
  %844 = fpext float %843 to double
  %845 = call double @llvm.fmuladd.f64(double %814, double %824, double 0.000000e+00)
  %846 = call double @sqrt(double noundef %845) #6
  %847 = load float, ptr %3, align 4, !tbaa !9
  %848 = fpext float %847 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 186, ptr noundef @.str.16, double noundef %846, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %848)
  br label %850

849:                                              ; preds = %798
  call void (...) @liquid_autotest_passed()
  br label %850

850:                                              ; preds = %849, %804
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #6
  %851 = load ptr, ptr %4, align 8
  call void @llvm.stackrestore.p0(ptr %851)
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #6
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #5

declare float @randnf(...) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #5

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 = { 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 #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 #5 = { nocallback nofree nosync nounwind willreturn }
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 = !{!"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}
!11 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}
!13 = distinct !{!13, !12}
!14 = !{!15, !15, i64 0}
!15 = !{!"any pointer", !7, i64 0}


; 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 [96 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [4 x i8], align 1
@liquid_autotest_verbose = external local_unnamed_addr global i32, align 4
@.str.8 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [76 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [40 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 i32 @dotprod_crcf_run(ptr noundef, ptr noundef, i32 noundef, 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) #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

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

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

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

declare i32 @dotprod_crcf_destroy(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

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

; Function Attrs: nounwind uwtable
define dso_local void @runtest_dotprod_crcf(i32 noundef %0) local_unnamed_addr #4 {
  %2 = alloca { float, float }, align 4
  %3 = alloca { float, float }, align 4
  %4 = alloca { float, float }, align 4
  %5 = zext i32 %0 to i64
  %6 = alloca float, i64 %5, align 16
  %7 = alloca { float, float }, i64 %5, align 16
  %.not199 = icmp eq i32 %0, 0
  br i1 %.not199, label %._crit_edge, label %.lr.ph

.preheader:                                       ; preds = %.lr.ph
  br i1 %.not199, label %._crit_edge, label %.lr.ph197.preheader

.lr.ph197.preheader:                              ; preds = %.preheader
  %xtraiter = and i64 %5, 3
  %8 = icmp ult i32 %0, 4
  br i1 %8, label %._crit_edge.loopexit.unr-lcssa, label %.lr.ph197.preheader.new

.lr.ph197.preheader.new:                          ; preds = %.lr.ph197.preheader
  %unroll_iter = and i64 %5, 4294967292
  br label %.lr.ph197

.lr.ph:                                           ; preds = %1, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ 0, %1 ]
  %9 = tail call float (...) @randnf() #6
  %10 = getelementptr inbounds float, ptr %6, i64 %indvars.iv
  store float %9, ptr %10, align 4, !tbaa !5
  %11 = tail call float (...) @randnf() #6
  %12 = tail call float (...) @randnf() #6
  %13 = fmul float %12, 0.000000e+00
  %14 = fadd float %11, %13
  %15 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv
  %16 = getelementptr inbounds i8, ptr %15, i64 4
  store float %14, ptr %15, align 8
  store float %12, ptr %16, align 4
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %5
  br i1 %exitcond.not, label %.preheader, label %.lr.ph, !llvm.loop !9

.lr.ph197:                                        ; preds = %.lr.ph197, %.lr.ph197.preheader.new
  %indvars.iv203 = phi i64 [ 0, %.lr.ph197.preheader.new ], [ %indvars.iv.next204.3, %.lr.ph197 ]
  %17 = phi <2 x float> [ zeroinitializer, %.lr.ph197.preheader.new ], [ %49, %.lr.ph197 ]
  %niter = phi i64 [ 0, %.lr.ph197.preheader.new ], [ %niter.next.3, %.lr.ph197 ]
  %18 = getelementptr inbounds float, ptr %6, i64 %indvars.iv203
  %19 = load float, ptr %18, align 16, !tbaa !5
  %20 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv203
  %21 = load <2 x float>, ptr %20, align 16
  %22 = insertelement <2 x float> poison, float %19, i64 0
  %23 = shufflevector <2 x float> %22, <2 x float> poison, <2 x i32> zeroinitializer
  %24 = fmul <2 x float> %23, %21
  %25 = fadd <2 x float> %17, %24
  %indvars.iv.next204 = or disjoint i64 %indvars.iv203, 1
  %26 = getelementptr inbounds float, ptr %6, i64 %indvars.iv.next204
  %27 = load float, ptr %26, align 4, !tbaa !5
  %28 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next204
  %29 = load <2 x float>, ptr %28, align 8
  %30 = insertelement <2 x float> poison, float %27, i64 0
  %31 = shufflevector <2 x float> %30, <2 x float> poison, <2 x i32> zeroinitializer
  %32 = fmul <2 x float> %31, %29
  %33 = fadd <2 x float> %25, %32
  %indvars.iv.next204.1 = or disjoint i64 %indvars.iv203, 2
  %34 = getelementptr inbounds float, ptr %6, i64 %indvars.iv.next204.1
  %35 = load float, ptr %34, align 8, !tbaa !5
  %36 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next204.1
  %37 = load <2 x float>, ptr %36, align 16
  %38 = insertelement <2 x float> poison, float %35, i64 0
  %39 = shufflevector <2 x float> %38, <2 x float> poison, <2 x i32> zeroinitializer
  %40 = fmul <2 x float> %39, %37
  %41 = fadd <2 x float> %33, %40
  %indvars.iv.next204.2 = or disjoint i64 %indvars.iv203, 3
  %42 = getelementptr inbounds float, ptr %6, i64 %indvars.iv.next204.2
  %43 = load float, ptr %42, align 4, !tbaa !5
  %44 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv.next204.2
  %45 = load <2 x float>, ptr %44, align 8
  %46 = insertelement <2 x float> poison, float %43, i64 0
  %47 = shufflevector <2 x float> %46, <2 x float> poison, <2 x i32> zeroinitializer
  %48 = fmul <2 x float> %47, %45
  %49 = fadd <2 x float> %41, %48
  %indvars.iv.next204.3 = add nuw nsw i64 %indvars.iv203, 4
  %niter.next.3 = add i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %._crit_edge.loopexit.unr-lcssa, label %.lr.ph197, !llvm.loop !11

._crit_edge.loopexit.unr-lcssa:                   ; preds = %.lr.ph197, %.lr.ph197.preheader
  %.lcssa.ph = phi <2 x float> [ poison, %.lr.ph197.preheader ], [ %49, %.lr.ph197 ]
  %indvars.iv203.unr = phi i64 [ 0, %.lr.ph197.preheader ], [ %indvars.iv.next204.3, %.lr.ph197 ]
  %.unr = phi <2 x float> [ zeroinitializer, %.lr.ph197.preheader ], [ %49, %.lr.ph197 ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %._crit_edge, label %.lr.ph197.epil

.lr.ph197.epil:                                   ; preds = %._crit_edge.loopexit.unr-lcssa, %.lr.ph197.epil
  %indvars.iv203.epil = phi i64 [ %indvars.iv.next204.epil, %.lr.ph197.epil ], [ %indvars.iv203.unr, %._crit_edge.loopexit.unr-lcssa ]
  %50 = phi <2 x float> [ %58, %.lr.ph197.epil ], [ %.unr, %._crit_edge.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.lr.ph197.epil ], [ 0, %._crit_edge.loopexit.unr-lcssa ]
  %51 = getelementptr inbounds float, ptr %6, i64 %indvars.iv203.epil
  %52 = load float, ptr %51, align 4, !tbaa !5
  %53 = getelementptr inbounds { float, float }, ptr %7, i64 %indvars.iv203.epil
  %54 = load <2 x float>, ptr %53, align 8
  %55 = insertelement <2 x float> poison, float %52, i64 0
  %56 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> zeroinitializer
  %57 = fmul <2 x float> %56, %54
  %58 = fadd <2 x float> %50, %57
  %indvars.iv.next204.epil = add nuw nsw i64 %indvars.iv203.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %._crit_edge, label %.lr.ph197.epil, !llvm.loop !12

._crit_edge:                                      ; preds = %._crit_edge.loopexit.unr-lcssa, %.lr.ph197.epil, %1, %.preheader
  %59 = phi <2 x float> [ zeroinitializer, %.preheader ], [ zeroinitializer, %1 ], [ %.lcssa.ph, %._crit_edge.loopexit.unr-lcssa ], [ %58, %.lr.ph197.epil ]
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %2) #6
  %60 = call ptr @dotprod_crcf_create(ptr noundef nonnull %6, i32 noundef %0) #6
  %61 = call i32 @dotprod_crcf_execute(ptr noundef %60, ptr noundef nonnull %7, ptr noundef nonnull %2) #6
  %62 = call i32 @dotprod_crcf_destroy(ptr noundef %60) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %3) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %4) #6
  %63 = call i32 @dotprod_crcf_run(ptr noundef nonnull %6, ptr noundef nonnull %7, i32 noundef %0, ptr noundef nonnull %3) #6
  %64 = call i32 @dotprod_crcf_run4(ptr noundef nonnull %6, ptr noundef nonnull %7, i32 noundef %0, ptr noundef nonnull %4) #6
  %65 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !14
  %.not = icmp eq i32 %65, 0
  br i1 %.not, label %89, label %66

66:                                               ; preds = %._crit_edge
  %67 = load float, ptr %2, align 4
  %68 = getelementptr inbounds i8, ptr %2, i64 4
  %69 = fpext float %67 to double
  %70 = load float, ptr %68, align 4
  %71 = fpext float %70 to double
  %72 = extractelement <2 x float> %59, i64 0
  %73 = fpext float %72 to double
  %74 = extractelement <2 x float> %59, i64 1
  %75 = fpext float %74 to double
  %76 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.8, i32 noundef %0, double noundef %69, double noundef %71, double noundef %73, double noundef %75)
  %77 = load float, ptr %3, align 4
  %78 = getelementptr inbounds i8, ptr %3, i64 4
  %79 = fpext float %77 to double
  %80 = load float, ptr %78, align 4
  %81 = fpext float %80 to double
  %82 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.9, i32 noundef %0, double noundef %79, double noundef %81, double noundef %73, double noundef %75)
  %83 = load float, ptr %4, align 4
  %84 = getelementptr inbounds i8, ptr %4, i64 4
  %85 = fpext float %83 to double
  %86 = load float, ptr %84, align 4
  %87 = fpext float %86 to double
  %88 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.10, i32 noundef %0, double noundef %85, double noundef %87, double noundef %73, double noundef %75)
  br label %89

89:                                               ; preds = %66, %._crit_edge
  %90 = load float, ptr %2, align 4
  %91 = getelementptr inbounds i8, ptr %2, i64 4
  %92 = extractelement <2 x float> %59, i64 0
  %93 = fsub float %90, %92
  %94 = fpext float %93 to double
  %95 = call double @llvm.fmuladd.f64(double %94, double %94, double 0.000000e+00)
  %sqrt = call double @llvm.sqrt.f64(double %95)
  %96 = fcmp ogt double %sqrt, 0x3F1A36E2E0000000
  %97 = fcmp uno float %90, 0.000000e+00
  %or.cond = select i1 %96, i1 true, i1 %97
  %98 = fcmp uno float %92, 0.000000e+00
  %or.cond166 = select i1 %or.cond, i1 true, i1 %98
  br i1 %or.cond166, label %99, label %100

99:                                               ; preds = %89
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 177, ptr noundef nonnull @.str.11, double noundef %sqrt, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %101

100:                                              ; preds = %89
  call void (...) @liquid_autotest_passed() #6
  br label %101

101:                                              ; preds = %100, %99
  %102 = load float, ptr %91, align 4
  %103 = extractelement <2 x float> %59, i64 1
  %104 = fsub float %102, %103
  %105 = fpext float %104 to double
  %106 = call double @llvm.fmuladd.f64(double %105, double %105, double 0.000000e+00)
  %sqrt183 = call double @llvm.sqrt.f64(double %106)
  %107 = fcmp ogt double %sqrt183, 0x3F1A36E2E0000000
  %108 = fcmp uno float %102, 0.000000e+00
  %or.cond168 = select i1 %107, i1 true, i1 %108
  %109 = fcmp uno float %103, 0.000000e+00
  %or.cond169 = select i1 %or.cond168, i1 true, i1 %109
  br i1 %or.cond169, label %110, label %111

110:                                              ; preds = %101
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 178, ptr noundef nonnull @.str.12, double noundef %sqrt183, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %112

111:                                              ; preds = %101
  call void (...) @liquid_autotest_passed() #6
  br label %112

112:                                              ; preds = %111, %110
  %113 = load float, ptr %3, align 4
  %114 = getelementptr inbounds i8, ptr %3, i64 4
  %115 = fsub float %113, %92
  %116 = fpext float %115 to double
  %117 = call double @llvm.fmuladd.f64(double %116, double %116, double 0.000000e+00)
  %sqrt185 = call double @llvm.sqrt.f64(double %117)
  %118 = fcmp ogt double %sqrt185, 0x3F1A36E2E0000000
  %119 = fcmp uno float %113, 0.000000e+00
  %or.cond171 = select i1 %118, i1 true, i1 %119
  %or.cond172 = select i1 %or.cond171, i1 true, i1 %98
  br i1 %or.cond172, label %120, label %121

120:                                              ; preds = %112
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 181, ptr noundef nonnull @.str.13, double noundef %sqrt185, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %122

121:                                              ; preds = %112
  call void (...) @liquid_autotest_passed() #6
  br label %122

122:                                              ; preds = %121, %120
  %123 = load float, ptr %114, align 4
  %124 = fsub float %123, %103
  %125 = fpext float %124 to double
  %126 = call double @llvm.fmuladd.f64(double %125, double %125, double 0.000000e+00)
  %sqrt187 = call double @llvm.sqrt.f64(double %126)
  %127 = fcmp ogt double %sqrt187, 0x3F1A36E2E0000000
  %128 = fcmp uno float %123, 0.000000e+00
  %or.cond174 = select i1 %127, i1 true, i1 %128
  %or.cond175 = select i1 %or.cond174, i1 true, i1 %109
  br i1 %or.cond175, label %129, label %130

129:                                              ; preds = %122
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 182, ptr noundef nonnull @.str.14, double noundef %sqrt187, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %131

130:                                              ; preds = %122
  call void (...) @liquid_autotest_passed() #6
  br label %131

131:                                              ; preds = %130, %129
  %132 = load float, ptr %4, align 4
  %133 = getelementptr inbounds i8, ptr %4, i64 4
  %134 = fsub float %132, %92
  %135 = fpext float %134 to double
  %136 = call double @llvm.fmuladd.f64(double %135, double %135, double 0.000000e+00)
  %sqrt189 = call double @llvm.sqrt.f64(double %136)
  %137 = fcmp ogt double %sqrt189, 0x3F1A36E2E0000000
  %138 = fcmp uno float %132, 0.000000e+00
  %or.cond177 = select i1 %137, i1 true, i1 %138
  %or.cond178 = select i1 %or.cond177, i1 true, i1 %98
  br i1 %or.cond178, label %139, label %140

139:                                              ; preds = %131
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 185, ptr noundef nonnull @.str.15, double noundef %sqrt189, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %141

140:                                              ; preds = %131
  call void (...) @liquid_autotest_passed() #6
  br label %141

141:                                              ; preds = %140, %139
  %142 = load float, ptr %133, align 4
  %143 = fsub float %142, %103
  %144 = fpext float %143 to double
  %145 = call double @llvm.fmuladd.f64(double %144, double %144, double 0.000000e+00)
  %sqrt191 = call double @llvm.sqrt.f64(double %145)
  %146 = fcmp ogt double %sqrt191, 0x3F1A36E2E0000000
  %147 = fcmp uno float %142, 0.000000e+00
  %or.cond180 = select i1 %146, i1 true, i1 %147
  %or.cond181 = select i1 %or.cond180, i1 true, i1 %109
  br i1 %or.cond181, label %148, label %149

148:                                              ; preds = %141
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 186, ptr noundef nonnull @.str.16, double noundef %sqrt191, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F1A36E2E0000000) #6
  br label %150

149:                                              ; preds = %141
  call void (...) @liquid_autotest_passed() #6
  br label %150

150:                                              ; preds = %149, %148
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %3) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %2) #6
  ret void
}

declare float @randnf(...) local_unnamed_addr #1

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

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 nosync nounwind speculatable willreturn memory(none) }
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 = { 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 #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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = distinct !{!11, !10}
!12 = distinct !{!12, !13}
!13 = !{!"llvm.loop.unroll.disable"}
!14 = !{!15, !15, i64 0}
!15 = !{!"int", !7, i64 0}


; Effective O3 passes: AggressiveInstCombinePass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass