; LLVM IR from jgaeddert/liquid-dsp :: src/math/tests (polynomial_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"

@liquid_autotest_verbose = external global i32, align 4
@.str.2 = external hidden unnamed_addr constant [91 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.31 = 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 @printf(ptr noundef, ...) #1

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

; 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

; Function Attrs: nounwind uwtable
define dso_local void @autotest_polycf_expandroots_4() #4 {
  %1 = alloca float, align 4
  %2 = alloca [2 x { float, float }], align 16
  %3 = alloca { float, float }, align 4
  %4 = alloca { float, float }, align 4
  %5 = alloca { float, float }, align 4
  %6 = alloca { float, float }, align 4
  %7 = alloca [3 x { float, float }], align 16
  %8 = alloca [3 x { float, float }], align 16
  %9 = alloca float, align 4
  %10 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %1) #5
  store float 0x3FFB333340000000, ptr %1, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %2) #5
  %11 = load float, ptr %1, align 4, !tbaa !5
  %12 = fmul float 0.000000e+00, %11
  %13 = fmul float 1.000000e+00, %11
  %14 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %15 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %12, ptr %14, align 4
  store float %13, ptr %15, align 4
  %16 = load <2 x float>, ptr %3, align 4
  %17 = call <2 x float> @cexpf(<2 x float> noundef %16) #5
  store <2 x float> %17, ptr %4, align 4
  %18 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %19 = load float, ptr %18, align 4
  %20 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %21 = load float, ptr %20, align 4
  %22 = fneg float %19
  %23 = fneg float %21
  %24 = getelementptr inbounds { float, float }, ptr %2, i32 0, i32 0
  %25 = getelementptr inbounds { float, float }, ptr %2, i32 0, i32 1
  store float %22, ptr %24, align 8
  store float %23, ptr %25, align 4
  %26 = getelementptr inbounds { float, float }, ptr %2, i64 1
  %27 = load float, ptr %1, align 4, !tbaa !5
  %28 = fmul float -0.000000e+00, %27
  %29 = fmul float -1.000000e+00, %27
  %30 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %31 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  store float %28, ptr %30, align 4
  store float %29, ptr %31, align 4
  %32 = load <2 x float>, ptr %5, align 4
  %33 = call <2 x float> @cexpf(<2 x float> noundef %32) #5
  store <2 x float> %33, ptr %6, align 4
  %34 = getelementptr inbounds { float, float }, ptr %6, i32 0, i32 0
  %35 = load float, ptr %34, align 4
  %36 = getelementptr inbounds { float, float }, ptr %6, i32 0, i32 1
  %37 = load float, ptr %36, align 4
  %38 = fneg float %35
  %39 = fneg float %37
  %40 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 0
  %41 = getelementptr inbounds { float, float }, ptr %26, i32 0, i32 1
  store float %38, ptr %40, align 8
  store float %39, ptr %41, align 4
  call void @llvm.lifetime.start.p0(i64 24, ptr %7) #5
  call void @llvm.lifetime.start.p0(i64 24, ptr %8) #5
  %42 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %43 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  store float 1.000000e+00, ptr %42, align 8
  store float 0.000000e+00, ptr %43, align 4
  %44 = getelementptr inbounds { float, float }, ptr %8, i64 1
  %45 = load float, ptr %1, align 4, !tbaa !5
  %46 = call float @cosf(float noundef %45) #5
  %47 = fmul float 2.000000e+00, %46
  %48 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 0
  %49 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 1
  store float %47, ptr %48, align 8
  store float 0.000000e+00, ptr %49, align 4
  %50 = getelementptr inbounds { float, float }, ptr %8, i64 2
  %51 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 0
  %52 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 1
  store float 1.000000e+00, ptr %51, align 8
  store float 0.000000e+00, ptr %52, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  store float 0x3F50624DE0000000, ptr %9, align 4, !tbaa !5
  %53 = getelementptr inbounds [2 x { float, float }], ptr %2, i64 0, i64 0
  %54 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %55 = call i32 @polycf_expandroots(ptr noundef %53, i32 noundef 2, ptr noundef %54)
  %56 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !9
  %57 = icmp ne i32 %56, 0
  br i1 %57, label %58, label %85

58:                                               ; preds = %0
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  store i32 0, ptr %10, align 4, !tbaa !9
  br label %59

59:                                               ; preds = %81, %58
  %60 = load i32, ptr %10, align 4, !tbaa !9
  %61 = icmp ult i32 %60, 3
  br i1 %61, label %62, label %84

62:                                               ; preds = %59
  %63 = load i32, ptr %10, align 4, !tbaa !9
  %64 = load i32, ptr %10, align 4, !tbaa !9
  %65 = zext i32 %64 to i64
  %66 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 %65
  %67 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 0
  %68 = load float, ptr %67, align 8
  %69 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 1
  %70 = load float, ptr %69, align 4
  %71 = fpext float %68 to double
  %72 = load i32, ptr %10, align 4, !tbaa !9
  %73 = zext i32 %72 to i64
  %74 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 %73
  %75 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 0
  %76 = load float, ptr %75, align 8
  %77 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 1
  %78 = load float, ptr %77, align 4
  %79 = fpext float %78 to double
  %80 = call i32 (ptr, ...) @printf(ptr noundef @.str.25, i32 noundef %63, double noundef %71, double noundef %79)
  br label %81

81:                                               ; preds = %62
  %82 = load i32, ptr %10, align 4, !tbaa !9
  %83 = add i32 %82, 1
  store i32 %83, ptr %10, align 4, !tbaa !9
  br label %59, !llvm.loop !11

84:                                               ; preds = %59
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  br label %85

85:                                               ; preds = %84, %0
  %86 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %87 = getelementptr inbounds { float, float }, ptr %86, i32 0, i32 0
  %88 = load float, ptr %87, align 16
  %89 = getelementptr inbounds { float, float }, ptr %86, i32 0, i32 1
  %90 = load float, ptr %89, align 4
  %91 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %92 = getelementptr inbounds { float, float }, ptr %91, i32 0, i32 0
  %93 = load float, ptr %92, align 16
  %94 = getelementptr inbounds { float, float }, ptr %91, i32 0, i32 1
  %95 = load float, ptr %94, align 4
  %96 = fsub float %88, %93
  %97 = fpext float %96 to double
  %98 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %99 = getelementptr inbounds { float, float }, ptr %98, i32 0, i32 0
  %100 = load float, ptr %99, align 16
  %101 = getelementptr inbounds { float, float }, ptr %98, i32 0, i32 1
  %102 = load float, ptr %101, align 4
  %103 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %104 = getelementptr inbounds { float, float }, ptr %103, i32 0, i32 0
  %105 = load float, ptr %104, align 16
  %106 = getelementptr inbounds { float, float }, ptr %103, i32 0, i32 1
  %107 = load float, ptr %106, align 4
  %108 = fsub float %100, %105
  %109 = fpext float %108 to double
  %110 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %111 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 0
  %112 = load float, ptr %111, align 16
  %113 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 1
  %114 = load float, ptr %113, align 4
  %115 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %116 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 0
  %117 = load float, ptr %116, align 16
  %118 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 1
  %119 = load float, ptr %118, align 4
  %120 = fsub float %112, %117
  %121 = fpext float %120 to double
  %122 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %123 = getelementptr inbounds { float, float }, ptr %122, i32 0, i32 0
  %124 = load float, ptr %123, align 16
  %125 = getelementptr inbounds { float, float }, ptr %122, i32 0, i32 1
  %126 = load float, ptr %125, align 4
  %127 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %128 = getelementptr inbounds { float, float }, ptr %127, i32 0, i32 0
  %129 = load float, ptr %128, align 16
  %130 = getelementptr inbounds { float, float }, ptr %127, i32 0, i32 1
  %131 = load float, ptr %130, align 4
  %132 = fsub float %124, %129
  %133 = fpext float %132 to double
  %134 = call double @llvm.fmuladd.f64(double %97, double %109, double 0.000000e+00)
  %135 = call double @sqrt(double noundef %134) #5
  %136 = load float, ptr %9, align 4, !tbaa !5
  %137 = fpext float %136 to double
  %138 = fcmp ogt double %135, %137
  br i1 %138, label %167, label %139

139:                                              ; preds = %85
  %140 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %141 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 0
  %142 = load float, ptr %141, align 16
  %143 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 1
  %144 = load float, ptr %143, align 4
  %145 = call i1 @llvm.is.fpclass.f32(float %142, i32 3)
  br i1 %145, label %167, label %146

146:                                              ; preds = %139
  %147 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %148 = getelementptr inbounds { float, float }, ptr %147, i32 0, i32 0
  %149 = load float, ptr %148, align 16
  %150 = getelementptr inbounds { float, float }, ptr %147, i32 0, i32 1
  %151 = load float, ptr %150, align 4
  %152 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %152, label %167, label %153

153:                                              ; preds = %146
  %154 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %155 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 0
  %156 = load float, ptr %155, align 16
  %157 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 1
  %158 = load float, ptr %157, align 4
  %159 = call i1 @llvm.is.fpclass.f32(float %156, i32 3)
  br i1 %159, label %167, label %160

160:                                              ; preds = %153
  %161 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %162 = getelementptr inbounds { float, float }, ptr %161, i32 0, i32 0
  %163 = load float, ptr %162, align 16
  %164 = getelementptr inbounds { float, float }, ptr %161, i32 0, i32 1
  %165 = load float, ptr %164, align 4
  %166 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %166, label %167, label %220

167:                                              ; preds = %160, %153, %146, %139, %85
  %168 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %169 = getelementptr inbounds { float, float }, ptr %168, i32 0, i32 0
  %170 = load float, ptr %169, align 16
  %171 = getelementptr inbounds { float, float }, ptr %168, i32 0, i32 1
  %172 = load float, ptr %171, align 4
  %173 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %174 = getelementptr inbounds { float, float }, ptr %173, i32 0, i32 0
  %175 = load float, ptr %174, align 16
  %176 = getelementptr inbounds { float, float }, ptr %173, i32 0, i32 1
  %177 = load float, ptr %176, align 4
  %178 = fsub float %170, %175
  %179 = fpext float %178 to double
  %180 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %181 = getelementptr inbounds { float, float }, ptr %180, i32 0, i32 0
  %182 = load float, ptr %181, align 16
  %183 = getelementptr inbounds { float, float }, ptr %180, i32 0, i32 1
  %184 = load float, ptr %183, align 4
  %185 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %186 = getelementptr inbounds { float, float }, ptr %185, i32 0, i32 0
  %187 = load float, ptr %186, align 16
  %188 = getelementptr inbounds { float, float }, ptr %185, i32 0, i32 1
  %189 = load float, ptr %188, align 4
  %190 = fsub float %182, %187
  %191 = fpext float %190 to double
  %192 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %193 = getelementptr inbounds { float, float }, ptr %192, i32 0, i32 0
  %194 = load float, ptr %193, align 16
  %195 = getelementptr inbounds { float, float }, ptr %192, i32 0, i32 1
  %196 = load float, ptr %195, align 4
  %197 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %198 = getelementptr inbounds { float, float }, ptr %197, i32 0, i32 0
  %199 = load float, ptr %198, align 16
  %200 = getelementptr inbounds { float, float }, ptr %197, i32 0, i32 1
  %201 = load float, ptr %200, align 4
  %202 = fsub float %194, %199
  %203 = fpext float %202 to double
  %204 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %205 = getelementptr inbounds { float, float }, ptr %204, i32 0, i32 0
  %206 = load float, ptr %205, align 16
  %207 = getelementptr inbounds { float, float }, ptr %204, i32 0, i32 1
  %208 = load float, ptr %207, align 4
  %209 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %210 = getelementptr inbounds { float, float }, ptr %209, i32 0, i32 0
  %211 = load float, ptr %210, align 16
  %212 = getelementptr inbounds { float, float }, ptr %209, i32 0, i32 1
  %213 = load float, ptr %212, align 4
  %214 = fsub float %206, %211
  %215 = fpext float %214 to double
  %216 = call double @llvm.fmuladd.f64(double %179, double %191, double 0.000000e+00)
  %217 = call double @sqrt(double noundef %216) #5
  %218 = load float, ptr %9, align 4, !tbaa !5
  %219 = fpext float %218 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 228, ptr noundef @.str.26, double noundef %217, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %219)
  br label %221

220:                                              ; preds = %160
  call void (...) @liquid_autotest_passed()
  br label %221

221:                                              ; preds = %220, %167
  %222 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %223 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 0
  %224 = load float, ptr %223, align 16
  %225 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 1
  %226 = load float, ptr %225, align 4
  %227 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %228 = getelementptr inbounds { float, float }, ptr %227, i32 0, i32 0
  %229 = load float, ptr %228, align 16
  %230 = getelementptr inbounds { float, float }, ptr %227, i32 0, i32 1
  %231 = load float, ptr %230, align 4
  %232 = fsub float %226, %231
  %233 = fpext float %232 to double
  %234 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %235 = getelementptr inbounds { float, float }, ptr %234, i32 0, i32 0
  %236 = load float, ptr %235, align 16
  %237 = getelementptr inbounds { float, float }, ptr %234, i32 0, i32 1
  %238 = load float, ptr %237, align 4
  %239 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %240 = getelementptr inbounds { float, float }, ptr %239, i32 0, i32 0
  %241 = load float, ptr %240, align 16
  %242 = getelementptr inbounds { float, float }, ptr %239, i32 0, i32 1
  %243 = load float, ptr %242, align 4
  %244 = fsub float %238, %243
  %245 = fpext float %244 to double
  %246 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %247 = getelementptr inbounds { float, float }, ptr %246, i32 0, i32 0
  %248 = load float, ptr %247, align 16
  %249 = getelementptr inbounds { float, float }, ptr %246, i32 0, i32 1
  %250 = load float, ptr %249, align 4
  %251 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %252 = getelementptr inbounds { float, float }, ptr %251, i32 0, i32 0
  %253 = load float, ptr %252, align 16
  %254 = getelementptr inbounds { float, float }, ptr %251, i32 0, i32 1
  %255 = load float, ptr %254, align 4
  %256 = fsub float %250, %255
  %257 = fpext float %256 to double
  %258 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %259 = getelementptr inbounds { float, float }, ptr %258, i32 0, i32 0
  %260 = load float, ptr %259, align 16
  %261 = getelementptr inbounds { float, float }, ptr %258, i32 0, i32 1
  %262 = load float, ptr %261, align 4
  %263 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %264 = getelementptr inbounds { float, float }, ptr %263, i32 0, i32 0
  %265 = load float, ptr %264, align 16
  %266 = getelementptr inbounds { float, float }, ptr %263, i32 0, i32 1
  %267 = load float, ptr %266, align 4
  %268 = fsub float %262, %267
  %269 = fpext float %268 to double
  %270 = call double @llvm.fmuladd.f64(double %233, double %245, double 0.000000e+00)
  %271 = call double @sqrt(double noundef %270) #5
  %272 = load float, ptr %9, align 4, !tbaa !5
  %273 = fpext float %272 to double
  %274 = fcmp ogt double %271, %273
  br i1 %274, label %303, label %275

275:                                              ; preds = %221
  %276 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %277 = getelementptr inbounds { float, float }, ptr %276, i32 0, i32 0
  %278 = load float, ptr %277, align 16
  %279 = getelementptr inbounds { float, float }, ptr %276, i32 0, i32 1
  %280 = load float, ptr %279, align 4
  %281 = call i1 @llvm.is.fpclass.f32(float %280, i32 3)
  br i1 %281, label %303, label %282

282:                                              ; preds = %275
  %283 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %284 = getelementptr inbounds { float, float }, ptr %283, i32 0, i32 0
  %285 = load float, ptr %284, align 16
  %286 = getelementptr inbounds { float, float }, ptr %283, i32 0, i32 1
  %287 = load float, ptr %286, align 4
  %288 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %288, label %303, label %289

289:                                              ; preds = %282
  %290 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %291 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 0
  %292 = load float, ptr %291, align 16
  %293 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 1
  %294 = load float, ptr %293, align 4
  %295 = call i1 @llvm.is.fpclass.f32(float %294, i32 3)
  br i1 %295, label %303, label %296

296:                                              ; preds = %289
  %297 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %298 = getelementptr inbounds { float, float }, ptr %297, i32 0, i32 0
  %299 = load float, ptr %298, align 16
  %300 = getelementptr inbounds { float, float }, ptr %297, i32 0, i32 1
  %301 = load float, ptr %300, align 4
  %302 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %302, label %303, label %356

303:                                              ; preds = %296, %289, %282, %275, %221
  %304 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %305 = getelementptr inbounds { float, float }, ptr %304, i32 0, i32 0
  %306 = load float, ptr %305, align 16
  %307 = getelementptr inbounds { float, float }, ptr %304, i32 0, i32 1
  %308 = load float, ptr %307, align 4
  %309 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %310 = getelementptr inbounds { float, float }, ptr %309, i32 0, i32 0
  %311 = load float, ptr %310, align 16
  %312 = getelementptr inbounds { float, float }, ptr %309, i32 0, i32 1
  %313 = load float, ptr %312, align 4
  %314 = fsub float %308, %313
  %315 = fpext float %314 to double
  %316 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %317 = getelementptr inbounds { float, float }, ptr %316, i32 0, i32 0
  %318 = load float, ptr %317, align 16
  %319 = getelementptr inbounds { float, float }, ptr %316, i32 0, i32 1
  %320 = load float, ptr %319, align 4
  %321 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %322 = getelementptr inbounds { float, float }, ptr %321, i32 0, i32 0
  %323 = load float, ptr %322, align 16
  %324 = getelementptr inbounds { float, float }, ptr %321, i32 0, i32 1
  %325 = load float, ptr %324, align 4
  %326 = fsub float %320, %325
  %327 = fpext float %326 to double
  %328 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %329 = getelementptr inbounds { float, float }, ptr %328, i32 0, i32 0
  %330 = load float, ptr %329, align 16
  %331 = getelementptr inbounds { float, float }, ptr %328, i32 0, i32 1
  %332 = load float, ptr %331, align 4
  %333 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %334 = getelementptr inbounds { float, float }, ptr %333, i32 0, i32 0
  %335 = load float, ptr %334, align 16
  %336 = getelementptr inbounds { float, float }, ptr %333, i32 0, i32 1
  %337 = load float, ptr %336, align 4
  %338 = fsub float %332, %337
  %339 = fpext float %338 to double
  %340 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 0
  %341 = getelementptr inbounds { float, float }, ptr %340, i32 0, i32 0
  %342 = load float, ptr %341, align 16
  %343 = getelementptr inbounds { float, float }, ptr %340, i32 0, i32 1
  %344 = load float, ptr %343, align 4
  %345 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 0
  %346 = getelementptr inbounds { float, float }, ptr %345, i32 0, i32 0
  %347 = load float, ptr %346, align 16
  %348 = getelementptr inbounds { float, float }, ptr %345, i32 0, i32 1
  %349 = load float, ptr %348, align 4
  %350 = fsub float %344, %349
  %351 = fpext float %350 to double
  %352 = call double @llvm.fmuladd.f64(double %315, double %327, double 0.000000e+00)
  %353 = call double @sqrt(double noundef %352) #5
  %354 = load float, ptr %9, align 4, !tbaa !5
  %355 = fpext float %354 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 229, ptr noundef @.str.27, double noundef %353, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %355)
  br label %357

356:                                              ; preds = %296
  call void (...) @liquid_autotest_passed()
  br label %357

357:                                              ; preds = %356, %303
  %358 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %359 = getelementptr inbounds { float, float }, ptr %358, i32 0, i32 0
  %360 = load float, ptr %359, align 8
  %361 = getelementptr inbounds { float, float }, ptr %358, i32 0, i32 1
  %362 = load float, ptr %361, align 4
  %363 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %364 = getelementptr inbounds { float, float }, ptr %363, i32 0, i32 0
  %365 = load float, ptr %364, align 8
  %366 = getelementptr inbounds { float, float }, ptr %363, i32 0, i32 1
  %367 = load float, ptr %366, align 4
  %368 = fsub float %360, %365
  %369 = fpext float %368 to double
  %370 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %371 = getelementptr inbounds { float, float }, ptr %370, i32 0, i32 0
  %372 = load float, ptr %371, align 8
  %373 = getelementptr inbounds { float, float }, ptr %370, i32 0, i32 1
  %374 = load float, ptr %373, align 4
  %375 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %376 = getelementptr inbounds { float, float }, ptr %375, i32 0, i32 0
  %377 = load float, ptr %376, align 8
  %378 = getelementptr inbounds { float, float }, ptr %375, i32 0, i32 1
  %379 = load float, ptr %378, align 4
  %380 = fsub float %372, %377
  %381 = fpext float %380 to double
  %382 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %383 = getelementptr inbounds { float, float }, ptr %382, i32 0, i32 0
  %384 = load float, ptr %383, align 8
  %385 = getelementptr inbounds { float, float }, ptr %382, i32 0, i32 1
  %386 = load float, ptr %385, align 4
  %387 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %388 = getelementptr inbounds { float, float }, ptr %387, i32 0, i32 0
  %389 = load float, ptr %388, align 8
  %390 = getelementptr inbounds { float, float }, ptr %387, i32 0, i32 1
  %391 = load float, ptr %390, align 4
  %392 = fsub float %384, %389
  %393 = fpext float %392 to double
  %394 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %395 = getelementptr inbounds { float, float }, ptr %394, i32 0, i32 0
  %396 = load float, ptr %395, align 8
  %397 = getelementptr inbounds { float, float }, ptr %394, i32 0, i32 1
  %398 = load float, ptr %397, align 4
  %399 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %400 = getelementptr inbounds { float, float }, ptr %399, i32 0, i32 0
  %401 = load float, ptr %400, align 8
  %402 = getelementptr inbounds { float, float }, ptr %399, i32 0, i32 1
  %403 = load float, ptr %402, align 4
  %404 = fsub float %396, %401
  %405 = fpext float %404 to double
  %406 = call double @llvm.fmuladd.f64(double %369, double %381, double 0.000000e+00)
  %407 = call double @sqrt(double noundef %406) #5
  %408 = load float, ptr %9, align 4, !tbaa !5
  %409 = fpext float %408 to double
  %410 = fcmp ogt double %407, %409
  br i1 %410, label %439, label %411

411:                                              ; preds = %357
  %412 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %413 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 0
  %414 = load float, ptr %413, align 8
  %415 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 1
  %416 = load float, ptr %415, align 4
  %417 = call i1 @llvm.is.fpclass.f32(float %414, i32 3)
  br i1 %417, label %439, label %418

418:                                              ; preds = %411
  %419 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %420 = getelementptr inbounds { float, float }, ptr %419, i32 0, i32 0
  %421 = load float, ptr %420, align 8
  %422 = getelementptr inbounds { float, float }, ptr %419, i32 0, i32 1
  %423 = load float, ptr %422, align 4
  %424 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %424, label %439, label %425

425:                                              ; preds = %418
  %426 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %427 = getelementptr inbounds { float, float }, ptr %426, i32 0, i32 0
  %428 = load float, ptr %427, align 8
  %429 = getelementptr inbounds { float, float }, ptr %426, i32 0, i32 1
  %430 = load float, ptr %429, align 4
  %431 = call i1 @llvm.is.fpclass.f32(float %428, i32 3)
  br i1 %431, label %439, label %432

432:                                              ; preds = %425
  %433 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %434 = getelementptr inbounds { float, float }, ptr %433, i32 0, i32 0
  %435 = load float, ptr %434, align 8
  %436 = getelementptr inbounds { float, float }, ptr %433, i32 0, i32 1
  %437 = load float, ptr %436, align 4
  %438 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %438, label %439, label %492

439:                                              ; preds = %432, %425, %418, %411, %357
  %440 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %441 = getelementptr inbounds { float, float }, ptr %440, i32 0, i32 0
  %442 = load float, ptr %441, align 8
  %443 = getelementptr inbounds { float, float }, ptr %440, i32 0, i32 1
  %444 = load float, ptr %443, align 4
  %445 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %446 = getelementptr inbounds { float, float }, ptr %445, i32 0, i32 0
  %447 = load float, ptr %446, align 8
  %448 = getelementptr inbounds { float, float }, ptr %445, i32 0, i32 1
  %449 = load float, ptr %448, align 4
  %450 = fsub float %442, %447
  %451 = fpext float %450 to double
  %452 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %453 = getelementptr inbounds { float, float }, ptr %452, i32 0, i32 0
  %454 = load float, ptr %453, align 8
  %455 = getelementptr inbounds { float, float }, ptr %452, i32 0, i32 1
  %456 = load float, ptr %455, align 4
  %457 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %458 = getelementptr inbounds { float, float }, ptr %457, i32 0, i32 0
  %459 = load float, ptr %458, align 8
  %460 = getelementptr inbounds { float, float }, ptr %457, i32 0, i32 1
  %461 = load float, ptr %460, align 4
  %462 = fsub float %454, %459
  %463 = fpext float %462 to double
  %464 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %465 = getelementptr inbounds { float, float }, ptr %464, i32 0, i32 0
  %466 = load float, ptr %465, align 8
  %467 = getelementptr inbounds { float, float }, ptr %464, i32 0, i32 1
  %468 = load float, ptr %467, align 4
  %469 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %470 = getelementptr inbounds { float, float }, ptr %469, i32 0, i32 0
  %471 = load float, ptr %470, align 8
  %472 = getelementptr inbounds { float, float }, ptr %469, i32 0, i32 1
  %473 = load float, ptr %472, align 4
  %474 = fsub float %466, %471
  %475 = fpext float %474 to double
  %476 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %477 = getelementptr inbounds { float, float }, ptr %476, i32 0, i32 0
  %478 = load float, ptr %477, align 8
  %479 = getelementptr inbounds { float, float }, ptr %476, i32 0, i32 1
  %480 = load float, ptr %479, align 4
  %481 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %482 = getelementptr inbounds { float, float }, ptr %481, i32 0, i32 0
  %483 = load float, ptr %482, align 8
  %484 = getelementptr inbounds { float, float }, ptr %481, i32 0, i32 1
  %485 = load float, ptr %484, align 4
  %486 = fsub float %478, %483
  %487 = fpext float %486 to double
  %488 = call double @llvm.fmuladd.f64(double %451, double %463, double 0.000000e+00)
  %489 = call double @sqrt(double noundef %488) #5
  %490 = load float, ptr %9, align 4, !tbaa !5
  %491 = fpext float %490 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 231, ptr noundef @.str.28, double noundef %489, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %491)
  br label %493

492:                                              ; preds = %432
  call void (...) @liquid_autotest_passed()
  br label %493

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

547:                                              ; preds = %493
  %548 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %549 = getelementptr inbounds { float, float }, ptr %548, i32 0, i32 0
  %550 = load float, ptr %549, align 8
  %551 = getelementptr inbounds { float, float }, ptr %548, 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 %575, label %554

554:                                              ; preds = %547
  %555 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %556 = getelementptr inbounds { float, float }, ptr %555, i32 0, i32 0
  %557 = load float, ptr %556, align 8
  %558 = getelementptr inbounds { float, float }, ptr %555, i32 0, i32 1
  %559 = load float, ptr %558, align 4
  %560 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %560, label %575, label %561

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

568:                                              ; preds = %561
  %569 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %570 = getelementptr inbounds { float, float }, ptr %569, i32 0, i32 0
  %571 = load float, ptr %570, align 8
  %572 = getelementptr inbounds { float, float }, ptr %569, i32 0, i32 1
  %573 = load float, ptr %572, align 4
  %574 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %574, label %575, label %628

575:                                              ; preds = %568, %561, %554, %547, %493
  %576 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %577 = getelementptr inbounds { float, float }, ptr %576, i32 0, i32 0
  %578 = load float, ptr %577, align 8
  %579 = getelementptr inbounds { float, float }, ptr %576, i32 0, i32 1
  %580 = load float, ptr %579, align 4
  %581 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %582 = getelementptr inbounds { float, float }, ptr %581, i32 0, i32 0
  %583 = load float, ptr %582, align 8
  %584 = getelementptr inbounds { float, float }, ptr %581, i32 0, i32 1
  %585 = load float, ptr %584, align 4
  %586 = fsub float %580, %585
  %587 = fpext float %586 to double
  %588 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %589 = getelementptr inbounds { float, float }, ptr %588, i32 0, i32 0
  %590 = load float, ptr %589, align 8
  %591 = getelementptr inbounds { float, float }, ptr %588, i32 0, i32 1
  %592 = load float, ptr %591, align 4
  %593 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %594 = getelementptr inbounds { float, float }, ptr %593, i32 0, i32 0
  %595 = load float, ptr %594, align 8
  %596 = getelementptr inbounds { float, float }, ptr %593, i32 0, i32 1
  %597 = load float, ptr %596, align 4
  %598 = fsub float %592, %597
  %599 = fpext float %598 to double
  %600 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %601 = getelementptr inbounds { float, float }, ptr %600, i32 0, i32 0
  %602 = load float, ptr %601, align 8
  %603 = getelementptr inbounds { float, float }, ptr %600, i32 0, i32 1
  %604 = load float, ptr %603, align 4
  %605 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %606 = getelementptr inbounds { float, float }, ptr %605, i32 0, i32 0
  %607 = load float, ptr %606, align 8
  %608 = getelementptr inbounds { float, float }, ptr %605, i32 0, i32 1
  %609 = load float, ptr %608, align 4
  %610 = fsub float %604, %609
  %611 = fpext float %610 to double
  %612 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 1
  %613 = getelementptr inbounds { float, float }, ptr %612, i32 0, i32 0
  %614 = load float, ptr %613, align 8
  %615 = getelementptr inbounds { float, float }, ptr %612, i32 0, i32 1
  %616 = load float, ptr %615, align 4
  %617 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 1
  %618 = getelementptr inbounds { float, float }, ptr %617, i32 0, i32 0
  %619 = load float, ptr %618, align 8
  %620 = getelementptr inbounds { float, float }, ptr %617, i32 0, i32 1
  %621 = load float, ptr %620, align 4
  %622 = fsub float %616, %621
  %623 = fpext float %622 to double
  %624 = call double @llvm.fmuladd.f64(double %587, double %599, double 0.000000e+00)
  %625 = call double @sqrt(double noundef %624) #5
  %626 = load float, ptr %9, align 4, !tbaa !5
  %627 = fpext float %626 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 232, ptr noundef @.str.29, double noundef %625, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %627)
  br label %629

628:                                              ; preds = %568
  call void (...) @liquid_autotest_passed()
  br label %629

629:                                              ; preds = %628, %575
  %630 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %631 = getelementptr inbounds { float, float }, ptr %630, i32 0, i32 0
  %632 = load float, ptr %631, align 16
  %633 = getelementptr inbounds { float, float }, ptr %630, i32 0, i32 1
  %634 = load float, ptr %633, align 4
  %635 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %636 = getelementptr inbounds { float, float }, ptr %635, i32 0, i32 0
  %637 = load float, ptr %636, align 16
  %638 = getelementptr inbounds { float, float }, ptr %635, i32 0, i32 1
  %639 = load float, ptr %638, align 4
  %640 = fsub float %632, %637
  %641 = fpext float %640 to double
  %642 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %643 = getelementptr inbounds { float, float }, ptr %642, i32 0, i32 0
  %644 = load float, ptr %643, align 16
  %645 = getelementptr inbounds { float, float }, ptr %642, i32 0, i32 1
  %646 = load float, ptr %645, align 4
  %647 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %648 = getelementptr inbounds { float, float }, ptr %647, i32 0, i32 0
  %649 = load float, ptr %648, align 16
  %650 = getelementptr inbounds { float, float }, ptr %647, i32 0, i32 1
  %651 = load float, ptr %650, align 4
  %652 = fsub float %644, %649
  %653 = fpext float %652 to double
  %654 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %655 = getelementptr inbounds { float, float }, ptr %654, i32 0, i32 0
  %656 = load float, ptr %655, align 16
  %657 = getelementptr inbounds { float, float }, ptr %654, i32 0, i32 1
  %658 = load float, ptr %657, align 4
  %659 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %660 = getelementptr inbounds { float, float }, ptr %659, i32 0, i32 0
  %661 = load float, ptr %660, align 16
  %662 = getelementptr inbounds { float, float }, ptr %659, i32 0, i32 1
  %663 = load float, ptr %662, align 4
  %664 = fsub float %656, %661
  %665 = fpext float %664 to double
  %666 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %667 = getelementptr inbounds { float, float }, ptr %666, i32 0, i32 0
  %668 = load float, ptr %667, align 16
  %669 = getelementptr inbounds { float, float }, ptr %666, i32 0, i32 1
  %670 = load float, ptr %669, align 4
  %671 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %672 = getelementptr inbounds { float, float }, ptr %671, i32 0, i32 0
  %673 = load float, ptr %672, align 16
  %674 = getelementptr inbounds { float, float }, ptr %671, i32 0, i32 1
  %675 = load float, ptr %674, align 4
  %676 = fsub float %668, %673
  %677 = fpext float %676 to double
  %678 = call double @llvm.fmuladd.f64(double %641, double %653, double 0.000000e+00)
  %679 = call double @sqrt(double noundef %678) #5
  %680 = load float, ptr %9, align 4, !tbaa !5
  %681 = fpext float %680 to double
  %682 = fcmp ogt double %679, %681
  br i1 %682, label %711, label %683

683:                                              ; preds = %629
  %684 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %685 = getelementptr inbounds { float, float }, ptr %684, i32 0, i32 0
  %686 = load float, ptr %685, align 16
  %687 = getelementptr inbounds { float, float }, ptr %684, i32 0, i32 1
  %688 = load float, ptr %687, align 4
  %689 = call i1 @llvm.is.fpclass.f32(float %686, i32 3)
  br i1 %689, label %711, label %690

690:                                              ; preds = %683
  %691 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %692 = getelementptr inbounds { float, float }, ptr %691, i32 0, i32 0
  %693 = load float, ptr %692, align 16
  %694 = getelementptr inbounds { float, float }, ptr %691, i32 0, i32 1
  %695 = load float, ptr %694, align 4
  %696 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %696, label %711, label %697

697:                                              ; preds = %690
  %698 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %699 = getelementptr inbounds { float, float }, ptr %698, i32 0, i32 0
  %700 = load float, ptr %699, align 16
  %701 = getelementptr inbounds { float, float }, ptr %698, i32 0, i32 1
  %702 = load float, ptr %701, align 4
  %703 = call i1 @llvm.is.fpclass.f32(float %700, i32 3)
  br i1 %703, label %711, label %704

704:                                              ; preds = %697
  %705 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %706 = getelementptr inbounds { float, float }, ptr %705, i32 0, i32 0
  %707 = load float, ptr %706, align 16
  %708 = getelementptr inbounds { float, float }, ptr %705, i32 0, i32 1
  %709 = load float, ptr %708, align 4
  %710 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %710, label %711, label %764

711:                                              ; preds = %704, %697, %690, %683, %629
  %712 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %713 = getelementptr inbounds { float, float }, ptr %712, i32 0, i32 0
  %714 = load float, ptr %713, align 16
  %715 = getelementptr inbounds { float, float }, ptr %712, i32 0, i32 1
  %716 = load float, ptr %715, align 4
  %717 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %718 = getelementptr inbounds { float, float }, ptr %717, i32 0, i32 0
  %719 = load float, ptr %718, align 16
  %720 = getelementptr inbounds { float, float }, ptr %717, i32 0, i32 1
  %721 = load float, ptr %720, align 4
  %722 = fsub float %714, %719
  %723 = fpext float %722 to double
  %724 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %725 = getelementptr inbounds { float, float }, ptr %724, i32 0, i32 0
  %726 = load float, ptr %725, align 16
  %727 = getelementptr inbounds { float, float }, ptr %724, i32 0, i32 1
  %728 = load float, ptr %727, align 4
  %729 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %730 = getelementptr inbounds { float, float }, ptr %729, i32 0, i32 0
  %731 = load float, ptr %730, align 16
  %732 = getelementptr inbounds { float, float }, ptr %729, i32 0, i32 1
  %733 = load float, ptr %732, align 4
  %734 = fsub float %726, %731
  %735 = fpext float %734 to double
  %736 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %737 = getelementptr inbounds { float, float }, ptr %736, i32 0, i32 0
  %738 = load float, ptr %737, align 16
  %739 = getelementptr inbounds { float, float }, ptr %736, i32 0, i32 1
  %740 = load float, ptr %739, align 4
  %741 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %742 = getelementptr inbounds { float, float }, ptr %741, i32 0, i32 0
  %743 = load float, ptr %742, align 16
  %744 = getelementptr inbounds { float, float }, ptr %741, i32 0, i32 1
  %745 = load float, ptr %744, align 4
  %746 = fsub float %738, %743
  %747 = fpext float %746 to double
  %748 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %749 = getelementptr inbounds { float, float }, ptr %748, i32 0, i32 0
  %750 = load float, ptr %749, align 16
  %751 = getelementptr inbounds { float, float }, ptr %748, i32 0, i32 1
  %752 = load float, ptr %751, align 4
  %753 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %754 = getelementptr inbounds { float, float }, ptr %753, i32 0, i32 0
  %755 = load float, ptr %754, align 16
  %756 = getelementptr inbounds { float, float }, ptr %753, i32 0, i32 1
  %757 = load float, ptr %756, align 4
  %758 = fsub float %750, %755
  %759 = fpext float %758 to double
  %760 = call double @llvm.fmuladd.f64(double %723, double %735, double 0.000000e+00)
  %761 = call double @sqrt(double noundef %760) #5
  %762 = load float, ptr %9, align 4, !tbaa !5
  %763 = fpext float %762 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 234, ptr noundef @.str.30, double noundef %761, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %763)
  br label %765

764:                                              ; preds = %704
  call void (...) @liquid_autotest_passed()
  br label %765

765:                                              ; preds = %764, %711
  %766 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %767 = getelementptr inbounds { float, float }, ptr %766, i32 0, i32 0
  %768 = load float, ptr %767, align 16
  %769 = getelementptr inbounds { float, float }, ptr %766, i32 0, i32 1
  %770 = load float, ptr %769, align 4
  %771 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %772 = getelementptr inbounds { float, float }, ptr %771, i32 0, i32 0
  %773 = load float, ptr %772, align 16
  %774 = getelementptr inbounds { float, float }, ptr %771, i32 0, i32 1
  %775 = load float, ptr %774, align 4
  %776 = fsub float %770, %775
  %777 = fpext float %776 to double
  %778 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %779 = getelementptr inbounds { float, float }, ptr %778, i32 0, i32 0
  %780 = load float, ptr %779, align 16
  %781 = getelementptr inbounds { float, float }, ptr %778, i32 0, i32 1
  %782 = load float, ptr %781, align 4
  %783 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %784 = getelementptr inbounds { float, float }, ptr %783, i32 0, i32 0
  %785 = load float, ptr %784, align 16
  %786 = getelementptr inbounds { float, float }, ptr %783, i32 0, i32 1
  %787 = load float, ptr %786, align 4
  %788 = fsub float %782, %787
  %789 = fpext float %788 to double
  %790 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %791 = getelementptr inbounds { float, float }, ptr %790, i32 0, i32 0
  %792 = load float, ptr %791, align 16
  %793 = getelementptr inbounds { float, float }, ptr %790, i32 0, i32 1
  %794 = load float, ptr %793, align 4
  %795 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %796 = getelementptr inbounds { float, float }, ptr %795, i32 0, i32 0
  %797 = load float, ptr %796, align 16
  %798 = getelementptr inbounds { float, float }, ptr %795, i32 0, i32 1
  %799 = load float, ptr %798, align 4
  %800 = fsub float %794, %799
  %801 = fpext float %800 to double
  %802 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %803 = getelementptr inbounds { float, float }, ptr %802, i32 0, i32 0
  %804 = load float, ptr %803, align 16
  %805 = getelementptr inbounds { float, float }, ptr %802, i32 0, i32 1
  %806 = load float, ptr %805, align 4
  %807 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %808 = getelementptr inbounds { float, float }, ptr %807, i32 0, i32 0
  %809 = load float, ptr %808, align 16
  %810 = getelementptr inbounds { float, float }, ptr %807, i32 0, i32 1
  %811 = load float, ptr %810, align 4
  %812 = fsub float %806, %811
  %813 = fpext float %812 to double
  %814 = call double @llvm.fmuladd.f64(double %777, double %789, double 0.000000e+00)
  %815 = call double @sqrt(double noundef %814) #5
  %816 = load float, ptr %9, align 4, !tbaa !5
  %817 = fpext float %816 to double
  %818 = fcmp ogt double %815, %817
  br i1 %818, label %847, label %819

819:                                              ; preds = %765
  %820 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %821 = getelementptr inbounds { float, float }, ptr %820, i32 0, i32 0
  %822 = load float, ptr %821, align 16
  %823 = getelementptr inbounds { float, float }, ptr %820, i32 0, i32 1
  %824 = load float, ptr %823, align 4
  %825 = call i1 @llvm.is.fpclass.f32(float %824, i32 3)
  br i1 %825, label %847, label %826

826:                                              ; preds = %819
  %827 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %828 = getelementptr inbounds { float, float }, ptr %827, i32 0, i32 0
  %829 = load float, ptr %828, align 16
  %830 = getelementptr inbounds { float, float }, ptr %827, i32 0, i32 1
  %831 = load float, ptr %830, align 4
  %832 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %832, label %847, label %833

833:                                              ; preds = %826
  %834 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %835 = getelementptr inbounds { float, float }, ptr %834, i32 0, i32 0
  %836 = load float, ptr %835, align 16
  %837 = getelementptr inbounds { float, float }, ptr %834, i32 0, i32 1
  %838 = load float, ptr %837, align 4
  %839 = call i1 @llvm.is.fpclass.f32(float %838, i32 3)
  br i1 %839, label %847, label %840

840:                                              ; preds = %833
  %841 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %842 = getelementptr inbounds { float, float }, ptr %841, i32 0, i32 0
  %843 = load float, ptr %842, align 16
  %844 = getelementptr inbounds { float, float }, ptr %841, i32 0, i32 1
  %845 = load float, ptr %844, align 4
  %846 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %846, label %847, label %900

847:                                              ; preds = %840, %833, %826, %819, %765
  %848 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %849 = getelementptr inbounds { float, float }, ptr %848, i32 0, i32 0
  %850 = load float, ptr %849, align 16
  %851 = getelementptr inbounds { float, float }, ptr %848, i32 0, i32 1
  %852 = load float, ptr %851, align 4
  %853 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %854 = getelementptr inbounds { float, float }, ptr %853, i32 0, i32 0
  %855 = load float, ptr %854, align 16
  %856 = getelementptr inbounds { float, float }, ptr %853, i32 0, i32 1
  %857 = load float, ptr %856, align 4
  %858 = fsub float %852, %857
  %859 = fpext float %858 to double
  %860 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %861 = getelementptr inbounds { float, float }, ptr %860, i32 0, i32 0
  %862 = load float, ptr %861, align 16
  %863 = getelementptr inbounds { float, float }, ptr %860, i32 0, i32 1
  %864 = load float, ptr %863, align 4
  %865 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %866 = getelementptr inbounds { float, float }, ptr %865, i32 0, i32 0
  %867 = load float, ptr %866, align 16
  %868 = getelementptr inbounds { float, float }, ptr %865, i32 0, i32 1
  %869 = load float, ptr %868, align 4
  %870 = fsub float %864, %869
  %871 = fpext float %870 to double
  %872 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %873 = getelementptr inbounds { float, float }, ptr %872, i32 0, i32 0
  %874 = load float, ptr %873, align 16
  %875 = getelementptr inbounds { float, float }, ptr %872, i32 0, i32 1
  %876 = load float, ptr %875, align 4
  %877 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %878 = getelementptr inbounds { float, float }, ptr %877, i32 0, i32 0
  %879 = load float, ptr %878, align 16
  %880 = getelementptr inbounds { float, float }, ptr %877, i32 0, i32 1
  %881 = load float, ptr %880, align 4
  %882 = fsub float %876, %881
  %883 = fpext float %882 to double
  %884 = getelementptr inbounds [3 x { float, float }], ptr %7, i64 0, i64 2
  %885 = getelementptr inbounds { float, float }, ptr %884, i32 0, i32 0
  %886 = load float, ptr %885, align 16
  %887 = getelementptr inbounds { float, float }, ptr %884, i32 0, i32 1
  %888 = load float, ptr %887, align 4
  %889 = getelementptr inbounds [3 x { float, float }], ptr %8, i64 0, i64 2
  %890 = getelementptr inbounds { float, float }, ptr %889, i32 0, i32 0
  %891 = load float, ptr %890, align 16
  %892 = getelementptr inbounds { float, float }, ptr %889, i32 0, i32 1
  %893 = load float, ptr %892, align 4
  %894 = fsub float %888, %893
  %895 = fpext float %894 to double
  %896 = call double @llvm.fmuladd.f64(double %859, double %871, double 0.000000e+00)
  %897 = call double @sqrt(double noundef %896) #5
  %898 = load float, ptr %9, align 4, !tbaa !5
  %899 = fpext float %898 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.2, i32 noundef 235, ptr noundef @.str.31, double noundef %897, ptr noundef @.str.4, ptr noundef @.str.5, double noundef %899)
  br label %901

900:                                              ; preds = %840
  call void (...) @liquid_autotest_passed()
  br label %901

901:                                              ; preds = %900, %847
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %8) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %7) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %2) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %1) #5
  ret void
}

; Function Attrs: nounwind
declare <2 x float> @cexpf(<2 x float> noundef) #2

; Function Attrs: nounwind
declare float @cosf(float noundef) #2

declare i32 @polycf_expandroots(ptr noundef, i32 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 = { 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"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { 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 = !{!"int", !7, i64 0}
!11 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}


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

@liquid_autotest_verbose = external local_unnamed_addr global i32, align 4
@.str.2 = external hidden unnamed_addr constant [91 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.31 = 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

; Function Attrs: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) 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: 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 #3

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

; Function Attrs: nounwind uwtable
define dso_local void @autotest_polycf_expandroots_4() local_unnamed_addr #4 {
  %1 = alloca [2 x { float, float }], align 16
  %2 = alloca [3 x { float, float }], align 16
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %1) #7
  %3 = tail call <2 x float> @cexpf(<2 x float> noundef <float 0.000000e+00, float 0x3FFB333340000000>) #7
  %4 = tail call <2 x float> @cexpf(<2 x float> noundef <float -0.000000e+00, float 0xBFFB333340000000>) #7
  %5 = shufflevector <2 x float> %3, <2 x float> %4, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %6 = fneg <4 x float> %5
  store <4 x float> %6, ptr %1, align 16
  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %2) #7
  %7 = call i32 @polycf_expandroots(ptr noundef nonnull %1, i32 noundef 2, ptr noundef nonnull %2) #7
  %8 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !5
  %.not = icmp eq i32 %8, 0
  br i1 %.not, label %.loopexit, label %.preheader.preheader

.preheader.preheader:                             ; preds = %0
  %9 = load float, ptr %2, align 16
  %10 = getelementptr inbounds i8, ptr %2, i64 4
  %11 = fpext float %9 to double
  %12 = load float, ptr %10, align 4
  %13 = fpext float %12 to double
  %14 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25, i32 noundef 0, double noundef %11, double noundef %13)
  %15 = getelementptr inbounds i8, ptr %2, i64 8
  %16 = load float, ptr %15, align 8
  %17 = getelementptr inbounds i8, ptr %2, i64 12
  %18 = fpext float %16 to double
  %19 = load float, ptr %17, align 4
  %20 = fpext float %19 to double
  %21 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25, i32 noundef 1, double noundef %18, double noundef %20)
  %22 = getelementptr inbounds i8, ptr %2, i64 16
  %23 = load float, ptr %22, align 16
  %24 = getelementptr inbounds i8, ptr %2, i64 20
  %25 = fpext float %23 to double
  %26 = load float, ptr %24, align 4
  %27 = fpext float %26 to double
  %28 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25, i32 noundef 2, double noundef %25, double noundef %27)
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader.preheader, %0
  %29 = load float, ptr %2, align 16
  %30 = getelementptr inbounds i8, ptr %2, i64 4
  %31 = fadd float %29, -1.000000e+00
  %32 = fpext float %31 to double
  %33 = call double @llvm.fmuladd.f64(double %32, double %32, double 0.000000e+00)
  %sqrt = call double @llvm.sqrt.f64(double %33)
  %34 = fcmp ogt double %sqrt, 0x3F50624DE0000000
  %35 = fcmp uno float %29, 0.000000e+00
  %or.cond = select i1 %34, i1 true, i1 %35
  br i1 %or.cond, label %36, label %37

36:                                               ; preds = %.loopexit
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 228, ptr noundef nonnull @.str.26, double noundef %sqrt, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %38

37:                                               ; preds = %.loopexit
  call void (...) @liquid_autotest_passed() #7
  br label %38

38:                                               ; preds = %37, %36
  %39 = load float, ptr %30, align 4
  %40 = fpext float %39 to double
  %41 = call double @llvm.fmuladd.f64(double %40, double %40, double 0.000000e+00)
  %sqrt151 = call double @llvm.sqrt.f64(double %41)
  %42 = fcmp ogt double %sqrt151, 0x3F50624DE0000000
  %43 = fcmp uno float %39, 0.000000e+00
  %or.cond141 = select i1 %42, i1 true, i1 %43
  br i1 %or.cond141, label %44, label %45

44:                                               ; preds = %38
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 229, ptr noundef nonnull @.str.27, double noundef %sqrt151, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %46

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

46:                                               ; preds = %45, %44
  %47 = getelementptr inbounds i8, ptr %2, i64 8
  %48 = load float, ptr %47, align 8
  %49 = getelementptr inbounds i8, ptr %2, i64 12
  %50 = fadd float %48, 0x3FD07DFA60000000
  %51 = fpext float %50 to double
  %52 = call double @llvm.fmuladd.f64(double %51, double %51, double 0.000000e+00)
  %sqrt153 = call double @llvm.sqrt.f64(double %52)
  %53 = fcmp ogt double %sqrt153, 0x3F50624DE0000000
  %54 = fcmp uno float %48, 0.000000e+00
  %or.cond143 = select i1 %53, i1 true, i1 %54
  br i1 %or.cond143, label %55, label %56

55:                                               ; preds = %46
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 231, ptr noundef nonnull @.str.28, double noundef %sqrt153, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %57

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

57:                                               ; preds = %56, %55
  %58 = load float, ptr %49, align 4
  %59 = fpext float %58 to double
  %60 = call double @llvm.fmuladd.f64(double %59, double %59, double 0.000000e+00)
  %sqrt155 = call double @llvm.sqrt.f64(double %60)
  %61 = fcmp ogt double %sqrt155, 0x3F50624DE0000000
  %62 = fcmp uno float %58, 0.000000e+00
  %or.cond145 = select i1 %61, i1 true, i1 %62
  br i1 %or.cond145, label %63, label %64

63:                                               ; preds = %57
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 232, ptr noundef nonnull @.str.29, double noundef %sqrt155, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %65

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

65:                                               ; preds = %64, %63
  %66 = getelementptr inbounds i8, ptr %2, i64 16
  %67 = load float, ptr %66, align 16
  %68 = getelementptr inbounds i8, ptr %2, i64 20
  %69 = fadd float %67, -1.000000e+00
  %70 = fpext float %69 to double
  %71 = call double @llvm.fmuladd.f64(double %70, double %70, double 0.000000e+00)
  %sqrt157 = call double @llvm.sqrt.f64(double %71)
  %72 = fcmp ogt double %sqrt157, 0x3F50624DE0000000
  %73 = fcmp uno float %67, 0.000000e+00
  %or.cond147 = select i1 %72, i1 true, i1 %73
  br i1 %or.cond147, label %74, label %75

74:                                               ; preds = %65
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 234, ptr noundef nonnull @.str.30, double noundef %sqrt157, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %76

75:                                               ; preds = %65
  call void (...) @liquid_autotest_passed() #7
  br label %76

76:                                               ; preds = %75, %74
  %77 = load float, ptr %68, align 4
  %78 = fpext float %77 to double
  %79 = call double @llvm.fmuladd.f64(double %78, double %78, double 0.000000e+00)
  %sqrt159 = call double @llvm.sqrt.f64(double %79)
  %80 = fcmp ogt double %sqrt159, 0x3F50624DE0000000
  %81 = fcmp uno float %77, 0.000000e+00
  %or.cond149 = select i1 %80, i1 true, i1 %81
  br i1 %or.cond149, label %82, label %83

82:                                               ; preds = %76
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.2, i32 noundef 235, ptr noundef nonnull @.str.31, double noundef %sqrt159, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, double noundef 0x3F50624DE0000000) #7
  br label %84

83:                                               ; preds = %76
  call void (...) @liquid_autotest_passed() #7
  br label %84

84:                                               ; preds = %83, %82
  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %2) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %1) #7
  ret void
}

; Function Attrs: nounwind
declare <2 x float> @cexpf(<2 x float> noundef) local_unnamed_addr #5

declare i32 @polycf_expandroots(ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #3

; 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 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { "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"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { 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 #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"}


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