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

@__const.autotest_dotprod_cccf_rand16.h = external hidden unnamed_addr constant [16 x { float, float }], align 16
@__const.autotest_dotprod_cccf_rand16.x = external hidden unnamed_addr constant [16 x { float, float }], align 16
@.str = external hidden unnamed_addr constant [96 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [32 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
@.str.4 = external hidden unnamed_addr constant [32 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [36 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @autotest_dotprod_cccf_rand16() #0 {
  %1 = alloca [16 x { float, float }], align 16
  %2 = alloca [16 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, align 4
  %7 = alloca ptr, align 8
  call void @llvm.lifetime.start.p0(i64 128, ptr %1) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %1, ptr align 16 @__const.autotest_dotprod_cccf_rand16.h, i64 128, i1 false)
  call void @llvm.lifetime.start.p0(i64 128, ptr %2) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %2, ptr align 16 @__const.autotest_dotprod_cccf_rand16.x, i64 128, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #6
  %8 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %9 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  store float 0xBFE3564DA0000000, ptr %8, align 4
  store float 0xC028C82760000000, ptr %9, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #6
  %10 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %11 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  store float 0x400B4C8680000000, ptr %10, align 4
  store float 0x4018C10E80000000, ptr %11, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #6
  store float 0x3F50624DE0000000, ptr %6, align 4, !tbaa !5
  %12 = getelementptr inbounds [16 x { float, float }], ptr %1, i64 0, i64 0
  %13 = getelementptr inbounds [16 x { float, float }], ptr %2, i64 0, i64 0
  %14 = call i32 @dotprod_cccf_run(ptr noundef %12, ptr noundef %13, i32 noundef 16, ptr noundef %3)
  %15 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %16 = load float, ptr %15, align 4
  %17 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %18 = load float, ptr %17, align 4
  %19 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %20 = load float, ptr %19, align 4
  %21 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %22 = load float, ptr %21, align 4
  %23 = fsub float %16, %20
  %24 = fpext float %23 to double
  %25 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %26 = load float, ptr %25, align 4
  %27 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %28 = load float, ptr %27, align 4
  %29 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %30 = load float, ptr %29, align 4
  %31 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %32 = load float, ptr %31, align 4
  %33 = fsub float %26, %30
  %34 = fpext float %33 to double
  %35 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %36 = load float, ptr %35, align 4
  %37 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %38 = load float, ptr %37, align 4
  %39 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %40 = load float, ptr %39, align 4
  %41 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %42 = load float, ptr %41, align 4
  %43 = fsub float %36, %40
  %44 = fpext float %43 to double
  %45 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %46 = load float, ptr %45, align 4
  %47 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %48 = load float, ptr %47, align 4
  %49 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %50 = load float, ptr %49, align 4
  %51 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %52 = load float, ptr %51, align 4
  %53 = fsub float %46, %50
  %54 = fpext float %53 to double
  %55 = call double @llvm.fmuladd.f64(double %24, double %34, double 0.000000e+00)
  %56 = call double @sqrt(double noundef %55) #6
  %57 = load float, ptr %6, align 4, !tbaa !5
  %58 = fpext float %57 to double
  %59 = fcmp ogt double %56, %58
  br i1 %59, label %84, label %60

60:                                               ; preds = %0
  %61 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %62 = load float, ptr %61, align 4
  %63 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %64 = load float, ptr %63, align 4
  %65 = call i1 @llvm.is.fpclass.f32(float %62, i32 3)
  br i1 %65, label %84, label %66

66:                                               ; preds = %60
  %67 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %68 = load float, ptr %67, align 4
  %69 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %70 = load float, ptr %69, align 4
  %71 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %71, label %84, label %72

72:                                               ; preds = %66
  %73 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %74 = load float, ptr %73, align 4
  %75 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %76 = load float, ptr %75, align 4
  %77 = call i1 @llvm.is.fpclass.f32(float %74, i32 3)
  br i1 %77, label %84, label %78

78:                                               ; preds = %72
  %79 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %80 = load float, ptr %79, align 4
  %81 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %82 = load float, ptr %81, align 4
  %83 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %83, label %84, label %129

84:                                               ; preds = %78, %72, %66, %60, %0
  %85 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %86 = load float, ptr %85, align 4
  %87 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %88 = load float, ptr %87, align 4
  %89 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %90 = load float, ptr %89, align 4
  %91 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %92 = load float, ptr %91, align 4
  %93 = fsub float %86, %90
  %94 = fpext float %93 to double
  %95 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %96 = load float, ptr %95, align 4
  %97 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %98 = load float, ptr %97, align 4
  %99 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %100 = load float, ptr %99, align 4
  %101 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %102 = load float, ptr %101, align 4
  %103 = fsub float %96, %100
  %104 = fpext float %103 to double
  %105 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %106 = load float, ptr %105, align 4
  %107 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %108 = load float, ptr %107, align 4
  %109 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %110 = load float, ptr %109, align 4
  %111 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %112 = load float, ptr %111, align 4
  %113 = fsub float %106, %110
  %114 = fpext float %113 to double
  %115 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %116 = load float, ptr %115, align 4
  %117 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %118 = load float, ptr %117, align 4
  %119 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %120 = load float, ptr %119, align 4
  %121 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %122 = load float, ptr %121, align 4
  %123 = fsub float %116, %120
  %124 = fpext float %123 to double
  %125 = call double @llvm.fmuladd.f64(double %94, double %104, double 0.000000e+00)
  %126 = call double @sqrt(double noundef %125) #6
  %127 = load float, ptr %6, align 4, !tbaa !5
  %128 = fpext float %127 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 64, ptr noundef @.str.1, double noundef %126, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %128)
  br label %130

129:                                              ; preds = %78
  call void (...) @liquid_autotest_passed()
  br label %130

130:                                              ; preds = %129, %84
  %131 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %132 = load float, ptr %131, align 4
  %133 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %134 = load float, ptr %133, align 4
  %135 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %136 = load float, ptr %135, align 4
  %137 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %138 = load float, ptr %137, align 4
  %139 = fsub float %134, %138
  %140 = fpext float %139 to double
  %141 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %142 = load float, ptr %141, align 4
  %143 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %144 = load float, ptr %143, align 4
  %145 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %146 = load float, ptr %145, align 4
  %147 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %148 = load float, ptr %147, align 4
  %149 = fsub float %144, %148
  %150 = fpext float %149 to double
  %151 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %152 = load float, ptr %151, align 4
  %153 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %154 = load float, ptr %153, align 4
  %155 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %156 = load float, ptr %155, align 4
  %157 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %158 = load float, ptr %157, align 4
  %159 = fsub float %154, %158
  %160 = fpext float %159 to double
  %161 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %162 = load float, ptr %161, align 4
  %163 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %164 = load float, ptr %163, align 4
  %165 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %166 = load float, ptr %165, align 4
  %167 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %168 = load float, ptr %167, align 4
  %169 = fsub float %164, %168
  %170 = fpext float %169 to double
  %171 = call double @llvm.fmuladd.f64(double %140, double %150, double 0.000000e+00)
  %172 = call double @sqrt(double noundef %171) #6
  %173 = load float, ptr %6, align 4, !tbaa !5
  %174 = fpext float %173 to double
  %175 = fcmp ogt double %172, %174
  br i1 %175, label %200, label %176

176:                                              ; preds = %130
  %177 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %178 = load float, ptr %177, align 4
  %179 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %180 = load float, ptr %179, align 4
  %181 = call i1 @llvm.is.fpclass.f32(float %180, i32 3)
  br i1 %181, label %200, label %182

182:                                              ; preds = %176
  %183 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %184 = load float, ptr %183, align 4
  %185 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %186 = load float, ptr %185, align 4
  %187 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %187, label %200, label %188

188:                                              ; preds = %182
  %189 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %190 = load float, ptr %189, align 4
  %191 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %192 = load float, ptr %191, align 4
  %193 = call i1 @llvm.is.fpclass.f32(float %192, i32 3)
  br i1 %193, label %200, label %194

194:                                              ; preds = %188
  %195 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %196 = load float, ptr %195, align 4
  %197 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %198 = load float, ptr %197, align 4
  %199 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %199, label %200, label %245

200:                                              ; preds = %194, %188, %182, %176, %130
  %201 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %202 = load float, ptr %201, align 4
  %203 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %204 = load float, ptr %203, align 4
  %205 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %206 = load float, ptr %205, align 4
  %207 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %208 = load float, ptr %207, align 4
  %209 = fsub float %204, %208
  %210 = fpext float %209 to double
  %211 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %212 = load float, ptr %211, align 4
  %213 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %214 = load float, ptr %213, align 4
  %215 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %216 = load float, ptr %215, align 4
  %217 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %218 = load float, ptr %217, align 4
  %219 = fsub float %214, %218
  %220 = fpext float %219 to double
  %221 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %222 = load float, ptr %221, align 4
  %223 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %224 = load float, ptr %223, align 4
  %225 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %226 = load float, ptr %225, align 4
  %227 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %228 = load float, ptr %227, align 4
  %229 = fsub float %224, %228
  %230 = fpext float %229 to double
  %231 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %232 = load float, ptr %231, align 4
  %233 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %234 = load float, ptr %233, align 4
  %235 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %236 = load float, ptr %235, align 4
  %237 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %238 = load float, ptr %237, align 4
  %239 = fsub float %234, %238
  %240 = fpext float %239 to double
  %241 = call double @llvm.fmuladd.f64(double %210, double %220, double 0.000000e+00)
  %242 = call double @sqrt(double noundef %241) #6
  %243 = load float, ptr %6, align 4, !tbaa !5
  %244 = fpext float %243 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 65, ptr noundef @.str.4, double noundef %242, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %244)
  br label %246

245:                                              ; preds = %194
  call void (...) @liquid_autotest_passed()
  br label %246

246:                                              ; preds = %245, %200
  %247 = getelementptr inbounds [16 x { float, float }], ptr %1, i64 0, i64 0
  %248 = getelementptr inbounds [16 x { float, float }], ptr %2, i64 0, i64 0
  %249 = call i32 @dotprod_cccf_run4(ptr noundef %247, ptr noundef %248, i32 noundef 16, ptr noundef %3)
  %250 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %251 = load float, ptr %250, align 4
  %252 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %253 = load float, ptr %252, align 4
  %254 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %255 = load float, ptr %254, align 4
  %256 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %257 = load float, ptr %256, align 4
  %258 = fsub float %251, %255
  %259 = fpext float %258 to double
  %260 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %261 = load float, ptr %260, align 4
  %262 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %263 = load float, ptr %262, align 4
  %264 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %265 = load float, ptr %264, align 4
  %266 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %267 = load float, ptr %266, align 4
  %268 = fsub float %261, %265
  %269 = fpext float %268 to double
  %270 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %271 = load float, ptr %270, align 4
  %272 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %273 = load float, ptr %272, align 4
  %274 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %275 = load float, ptr %274, align 4
  %276 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %277 = load float, ptr %276, align 4
  %278 = fsub float %271, %275
  %279 = fpext float %278 to double
  %280 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %281 = load float, ptr %280, align 4
  %282 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %283 = load float, ptr %282, align 4
  %284 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %285 = load float, ptr %284, align 4
  %286 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %287 = load float, ptr %286, align 4
  %288 = fsub float %281, %285
  %289 = fpext float %288 to double
  %290 = call double @llvm.fmuladd.f64(double %259, double %269, double 0.000000e+00)
  %291 = call double @sqrt(double noundef %290) #6
  %292 = load float, ptr %6, align 4, !tbaa !5
  %293 = fpext float %292 to double
  %294 = fcmp ogt double %291, %293
  br i1 %294, label %319, label %295

295:                                              ; preds = %246
  %296 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %297 = load float, ptr %296, align 4
  %298 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %299 = load float, ptr %298, align 4
  %300 = call i1 @llvm.is.fpclass.f32(float %297, i32 3)
  br i1 %300, label %319, label %301

301:                                              ; preds = %295
  %302 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %303 = load float, ptr %302, align 4
  %304 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %305 = load float, ptr %304, align 4
  %306 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %306, label %319, label %307

307:                                              ; preds = %301
  %308 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %309 = load float, ptr %308, align 4
  %310 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %311 = load float, ptr %310, align 4
  %312 = call i1 @llvm.is.fpclass.f32(float %309, i32 3)
  br i1 %312, label %319, label %313

313:                                              ; preds = %307
  %314 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %315 = load float, ptr %314, align 4
  %316 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %317 = load float, ptr %316, align 4
  %318 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %318, label %319, label %364

319:                                              ; preds = %313, %307, %301, %295, %246
  %320 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %321 = load float, ptr %320, align 4
  %322 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %323 = load float, ptr %322, align 4
  %324 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %325 = load float, ptr %324, align 4
  %326 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %327 = load float, ptr %326, align 4
  %328 = fsub float %321, %325
  %329 = fpext float %328 to double
  %330 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %331 = load float, ptr %330, align 4
  %332 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %333 = load float, ptr %332, align 4
  %334 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %335 = load float, ptr %334, align 4
  %336 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %337 = load float, ptr %336, align 4
  %338 = fsub float %331, %335
  %339 = fpext float %338 to double
  %340 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %341 = load float, ptr %340, align 4
  %342 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %343 = load float, ptr %342, align 4
  %344 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %345 = load float, ptr %344, align 4
  %346 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %347 = load float, ptr %346, align 4
  %348 = fsub float %341, %345
  %349 = fpext float %348 to double
  %350 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %351 = load float, ptr %350, align 4
  %352 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %353 = load float, ptr %352, align 4
  %354 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %355 = load float, ptr %354, align 4
  %356 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %357 = load float, ptr %356, align 4
  %358 = fsub float %351, %355
  %359 = fpext float %358 to double
  %360 = call double @llvm.fmuladd.f64(double %329, double %339, double 0.000000e+00)
  %361 = call double @sqrt(double noundef %360) #6
  %362 = load float, ptr %6, align 4, !tbaa !5
  %363 = fpext float %362 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 68, ptr noundef @.str.1, double noundef %361, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %363)
  br label %365

364:                                              ; preds = %313
  call void (...) @liquid_autotest_passed()
  br label %365

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

411:                                              ; preds = %365
  %412 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %413 = load float, ptr %412, align 4
  %414 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %415 = load float, ptr %414, align 4
  %416 = call i1 @llvm.is.fpclass.f32(float %415, i32 3)
  br i1 %416, label %435, label %417

417:                                              ; preds = %411
  %418 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %419 = load float, ptr %418, align 4
  %420 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %421 = load float, ptr %420, align 4
  %422 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %422, label %435, label %423

423:                                              ; preds = %417
  %424 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %425 = load float, ptr %424, align 4
  %426 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %427 = load float, ptr %426, align 4
  %428 = call i1 @llvm.is.fpclass.f32(float %427, i32 3)
  br i1 %428, label %435, label %429

429:                                              ; preds = %423
  %430 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %431 = load float, ptr %430, align 4
  %432 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %433 = load float, ptr %432, align 4
  %434 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %434, label %435, label %480

435:                                              ; preds = %429, %423, %417, %411, %365
  %436 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %437 = load float, ptr %436, align 4
  %438 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %439 = load float, ptr %438, align 4
  %440 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %441 = load float, ptr %440, align 4
  %442 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %443 = load float, ptr %442, align 4
  %444 = fsub float %439, %443
  %445 = fpext float %444 to double
  %446 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %447 = load float, ptr %446, align 4
  %448 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %449 = load float, ptr %448, align 4
  %450 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %451 = load float, ptr %450, align 4
  %452 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %453 = load float, ptr %452, align 4
  %454 = fsub float %449, %453
  %455 = fpext float %454 to double
  %456 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %457 = load float, ptr %456, align 4
  %458 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %459 = load float, ptr %458, align 4
  %460 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %461 = load float, ptr %460, align 4
  %462 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %463 = load float, ptr %462, align 4
  %464 = fsub float %459, %463
  %465 = fpext float %464 to double
  %466 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %467 = load float, ptr %466, align 4
  %468 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %469 = load float, ptr %468, align 4
  %470 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %471 = load float, ptr %470, align 4
  %472 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %473 = load float, ptr %472, align 4
  %474 = fsub float %469, %473
  %475 = fpext float %474 to double
  %476 = call double @llvm.fmuladd.f64(double %445, double %455, double 0.000000e+00)
  %477 = call double @sqrt(double noundef %476) #6
  %478 = load float, ptr %6, align 4, !tbaa !5
  %479 = fpext float %478 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 69, ptr noundef @.str.4, double noundef %477, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %479)
  br label %481

480:                                              ; preds = %429
  call void (...) @liquid_autotest_passed()
  br label %481

481:                                              ; preds = %480, %435
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %482 = getelementptr inbounds [16 x { float, float }], ptr %1, i64 0, i64 0
  %483 = call ptr @dotprod_cccf_create(ptr noundef %482, i32 noundef 16)
  store ptr %483, ptr %7, align 8, !tbaa !9
  %484 = load ptr, ptr %7, align 8, !tbaa !9
  %485 = getelementptr inbounds [16 x { float, float }], ptr %2, i64 0, i64 0
  %486 = call i32 @dotprod_cccf_execute(ptr noundef %484, ptr noundef %485, ptr noundef %3)
  %487 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %488 = load float, ptr %487, align 4
  %489 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %490 = load float, ptr %489, align 4
  %491 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %492 = load float, ptr %491, align 4
  %493 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %494 = load float, ptr %493, align 4
  %495 = fsub float %488, %492
  %496 = fpext float %495 to double
  %497 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %498 = load float, ptr %497, align 4
  %499 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %500 = load float, ptr %499, align 4
  %501 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %502 = load float, ptr %501, align 4
  %503 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %504 = load float, ptr %503, align 4
  %505 = fsub float %498, %502
  %506 = fpext float %505 to double
  %507 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %508 = load float, ptr %507, align 4
  %509 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %510 = load float, ptr %509, align 4
  %511 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %512 = load float, ptr %511, align 4
  %513 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %514 = load float, ptr %513, align 4
  %515 = fsub float %508, %512
  %516 = fpext float %515 to double
  %517 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %518 = load float, ptr %517, align 4
  %519 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %520 = load float, ptr %519, align 4
  %521 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %522 = load float, ptr %521, align 4
  %523 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %524 = load float, ptr %523, align 4
  %525 = fsub float %518, %522
  %526 = fpext float %525 to double
  %527 = call double @llvm.fmuladd.f64(double %496, double %506, double 0.000000e+00)
  %528 = call double @sqrt(double noundef %527) #6
  %529 = load float, ptr %6, align 4, !tbaa !5
  %530 = fpext float %529 to double
  %531 = fcmp ogt double %528, %530
  br i1 %531, label %556, label %532

532:                                              ; preds = %481
  %533 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %534 = load float, ptr %533, align 4
  %535 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %536 = load float, ptr %535, align 4
  %537 = call i1 @llvm.is.fpclass.f32(float %534, i32 3)
  br i1 %537, label %556, label %538

538:                                              ; preds = %532
  %539 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %540 = load float, ptr %539, align 4
  %541 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %542 = load float, ptr %541, align 4
  %543 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %543, label %556, label %544

544:                                              ; preds = %538
  %545 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %546 = load float, ptr %545, align 4
  %547 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %548 = load float, ptr %547, align 4
  %549 = call i1 @llvm.is.fpclass.f32(float %546, i32 3)
  br i1 %549, label %556, label %550

550:                                              ; preds = %544
  %551 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %552 = load float, ptr %551, align 4
  %553 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %554 = load float, ptr %553, align 4
  %555 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %555, label %556, label %601

556:                                              ; preds = %550, %544, %538, %532, %481
  %557 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %558 = load float, ptr %557, align 4
  %559 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %560 = load float, ptr %559, align 4
  %561 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %562 = load float, ptr %561, align 4
  %563 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %564 = load float, ptr %563, align 4
  %565 = fsub float %558, %562
  %566 = fpext float %565 to double
  %567 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %568 = load float, ptr %567, align 4
  %569 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %570 = load float, ptr %569, align 4
  %571 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %572 = load float, ptr %571, align 4
  %573 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %574 = load float, ptr %573, align 4
  %575 = fsub float %568, %572
  %576 = fpext float %575 to double
  %577 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %578 = load float, ptr %577, align 4
  %579 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %580 = load float, ptr %579, align 4
  %581 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %582 = load float, ptr %581, align 4
  %583 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %584 = load float, ptr %583, align 4
  %585 = fsub float %578, %582
  %586 = fpext float %585 to double
  %587 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %588 = load float, ptr %587, align 4
  %589 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %590 = load float, ptr %589, align 4
  %591 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %592 = load float, ptr %591, align 4
  %593 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %594 = load float, ptr %593, align 4
  %595 = fsub float %588, %592
  %596 = fpext float %595 to double
  %597 = call double @llvm.fmuladd.f64(double %566, double %576, double 0.000000e+00)
  %598 = call double @sqrt(double noundef %597) #6
  %599 = load float, ptr %6, align 4, !tbaa !5
  %600 = fpext float %599 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 74, ptr noundef @.str.1, double noundef %598, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %600)
  br label %602

601:                                              ; preds = %550
  call void (...) @liquid_autotest_passed()
  br label %602

602:                                              ; preds = %601, %556
  %603 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %604 = load float, ptr %603, align 4
  %605 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %606 = load float, ptr %605, align 4
  %607 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %608 = load float, ptr %607, align 4
  %609 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %610 = load float, ptr %609, align 4
  %611 = fsub float %606, %610
  %612 = fpext float %611 to double
  %613 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %614 = load float, ptr %613, align 4
  %615 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %616 = load float, ptr %615, align 4
  %617 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %618 = load float, ptr %617, align 4
  %619 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %620 = load float, ptr %619, align 4
  %621 = fsub float %616, %620
  %622 = fpext float %621 to double
  %623 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %624 = load float, ptr %623, align 4
  %625 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %626 = load float, ptr %625, align 4
  %627 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %628 = load float, ptr %627, align 4
  %629 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %630 = load float, ptr %629, align 4
  %631 = fsub float %626, %630
  %632 = fpext float %631 to double
  %633 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %634 = load float, ptr %633, align 4
  %635 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %636 = load float, ptr %635, align 4
  %637 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %638 = load float, ptr %637, align 4
  %639 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %640 = load float, ptr %639, align 4
  %641 = fsub float %636, %640
  %642 = fpext float %641 to double
  %643 = call double @llvm.fmuladd.f64(double %612, double %622, double 0.000000e+00)
  %644 = call double @sqrt(double noundef %643) #6
  %645 = load float, ptr %6, align 4, !tbaa !5
  %646 = fpext float %645 to double
  %647 = fcmp ogt double %644, %646
  br i1 %647, label %672, label %648

648:                                              ; preds = %602
  %649 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %650 = load float, ptr %649, align 4
  %651 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %652 = load float, ptr %651, align 4
  %653 = call i1 @llvm.is.fpclass.f32(float %652, i32 3)
  br i1 %653, label %672, label %654

654:                                              ; preds = %648
  %655 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %656 = load float, ptr %655, align 4
  %657 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %658 = load float, ptr %657, align 4
  %659 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %659, label %672, label %660

660:                                              ; preds = %654
  %661 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %662 = load float, ptr %661, align 4
  %663 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %664 = load float, ptr %663, align 4
  %665 = call i1 @llvm.is.fpclass.f32(float %664, i32 3)
  br i1 %665, label %672, label %666

666:                                              ; preds = %660
  %667 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %668 = load float, ptr %667, align 4
  %669 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %670 = load float, ptr %669, align 4
  %671 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %671, label %672, label %717

672:                                              ; preds = %666, %660, %654, %648, %602
  %673 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %674 = load float, ptr %673, align 4
  %675 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %676 = load float, ptr %675, align 4
  %677 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %678 = load float, ptr %677, align 4
  %679 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %680 = load float, ptr %679, align 4
  %681 = fsub float %676, %680
  %682 = fpext float %681 to double
  %683 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %684 = load float, ptr %683, align 4
  %685 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %686 = load float, ptr %685, align 4
  %687 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %688 = load float, ptr %687, align 4
  %689 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %690 = load float, ptr %689, align 4
  %691 = fsub float %686, %690
  %692 = fpext float %691 to double
  %693 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %694 = load float, ptr %693, align 4
  %695 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %696 = load float, ptr %695, align 4
  %697 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %698 = load float, ptr %697, align 4
  %699 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %700 = load float, ptr %699, align 4
  %701 = fsub float %696, %700
  %702 = fpext float %701 to double
  %703 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %704 = load float, ptr %703, align 4
  %705 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %706 = load float, ptr %705, align 4
  %707 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %708 = load float, ptr %707, align 4
  %709 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %710 = load float, ptr %709, align 4
  %711 = fsub float %706, %710
  %712 = fpext float %711 to double
  %713 = call double @llvm.fmuladd.f64(double %682, double %692, double 0.000000e+00)
  %714 = call double @sqrt(double noundef %713) #6
  %715 = load float, ptr %6, align 4, !tbaa !5
  %716 = fpext float %715 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 75, ptr noundef @.str.4, double noundef %714, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %716)
  br label %718

717:                                              ; preds = %666
  call void (...) @liquid_autotest_passed()
  br label %718

718:                                              ; preds = %717, %672
  %719 = load ptr, ptr %7, align 8, !tbaa !9
  %720 = getelementptr inbounds [16 x { float, float }], ptr %1, i64 0, i64 0
  %721 = call ptr @dotprod_cccf_recreate_rev(ptr noundef %719, ptr noundef %720, i32 noundef 16)
  store ptr %721, ptr %7, align 8, !tbaa !9
  %722 = load ptr, ptr %7, align 8, !tbaa !9
  %723 = getelementptr inbounds [16 x { float, float }], ptr %2, i64 0, i64 0
  %724 = call i32 @dotprod_cccf_execute(ptr noundef %722, ptr noundef %723, ptr noundef %3)
  %725 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %726 = load float, ptr %725, align 4
  %727 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %728 = load float, ptr %727, align 4
  %729 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %730 = load float, ptr %729, align 4
  %731 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %732 = load float, ptr %731, align 4
  %733 = fsub float %726, %730
  %734 = fpext float %733 to double
  %735 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %736 = load float, ptr %735, align 4
  %737 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %738 = load float, ptr %737, align 4
  %739 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %740 = load float, ptr %739, align 4
  %741 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %742 = load float, ptr %741, align 4
  %743 = fsub float %736, %740
  %744 = fpext float %743 to double
  %745 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %746 = load float, ptr %745, align 4
  %747 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %748 = load float, ptr %747, align 4
  %749 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %750 = load float, ptr %749, align 4
  %751 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %752 = load float, ptr %751, align 4
  %753 = fsub float %746, %750
  %754 = fpext float %753 to double
  %755 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %756 = load float, ptr %755, align 4
  %757 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %758 = load float, ptr %757, align 4
  %759 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %760 = load float, ptr %759, align 4
  %761 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %762 = load float, ptr %761, align 4
  %763 = fsub float %756, %760
  %764 = fpext float %763 to double
  %765 = call double @llvm.fmuladd.f64(double %734, double %744, double 0.000000e+00)
  %766 = call double @sqrt(double noundef %765) #6
  %767 = load float, ptr %6, align 4, !tbaa !5
  %768 = fpext float %767 to double
  %769 = fcmp ogt double %766, %768
  br i1 %769, label %794, label %770

770:                                              ; preds = %718
  %771 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %772 = load float, ptr %771, align 4
  %773 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %774 = load float, ptr %773, align 4
  %775 = call i1 @llvm.is.fpclass.f32(float %772, i32 3)
  br i1 %775, label %794, label %776

776:                                              ; preds = %770
  %777 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %778 = load float, ptr %777, align 4
  %779 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %780 = load float, ptr %779, align 4
  %781 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %781, label %794, label %782

782:                                              ; preds = %776
  %783 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %784 = load float, ptr %783, align 4
  %785 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %786 = load float, ptr %785, align 4
  %787 = call i1 @llvm.is.fpclass.f32(float %784, i32 3)
  br i1 %787, label %794, label %788

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

794:                                              ; preds = %788, %782, %776, %770, %718
  %795 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %796 = load float, ptr %795, align 4
  %797 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %798 = load float, ptr %797, align 4
  %799 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %800 = load float, ptr %799, align 4
  %801 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %802 = load float, ptr %801, align 4
  %803 = fsub float %796, %800
  %804 = fpext float %803 to double
  %805 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %806 = load float, ptr %805, align 4
  %807 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %808 = load float, ptr %807, align 4
  %809 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %810 = load float, ptr %809, align 4
  %811 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %812 = load float, ptr %811, align 4
  %813 = fsub float %806, %810
  %814 = fpext float %813 to double
  %815 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %816 = load float, ptr %815, align 4
  %817 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %818 = load float, ptr %817, align 4
  %819 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %820 = load float, ptr %819, align 4
  %821 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %822 = load float, ptr %821, align 4
  %823 = fsub float %816, %820
  %824 = fpext float %823 to double
  %825 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %826 = load float, ptr %825, align 4
  %827 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %828 = load float, ptr %827, align 4
  %829 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %830 = load float, ptr %829, align 4
  %831 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %832 = load float, ptr %831, align 4
  %833 = fsub float %826, %830
  %834 = fpext float %833 to double
  %835 = call double @llvm.fmuladd.f64(double %804, double %814, double 0.000000e+00)
  %836 = call double @sqrt(double noundef %835) #6
  %837 = load float, ptr %6, align 4, !tbaa !5
  %838 = fpext float %837 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 80, ptr noundef @.str.5, double noundef %836, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %838)
  br label %840

839:                                              ; preds = %788
  call void (...) @liquid_autotest_passed()
  br label %840

840:                                              ; preds = %839, %794
  %841 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %842 = load float, ptr %841, align 4
  %843 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %844 = load float, ptr %843, align 4
  %845 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %846 = load float, ptr %845, align 4
  %847 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %848 = load float, ptr %847, align 4
  %849 = fsub float %844, %848
  %850 = fpext float %849 to double
  %851 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %852 = load float, ptr %851, align 4
  %853 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %854 = load float, ptr %853, align 4
  %855 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %856 = load float, ptr %855, align 4
  %857 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %858 = load float, ptr %857, align 4
  %859 = fsub float %854, %858
  %860 = fpext float %859 to double
  %861 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %862 = load float, ptr %861, align 4
  %863 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %864 = load float, ptr %863, align 4
  %865 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %866 = load float, ptr %865, align 4
  %867 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %868 = load float, ptr %867, align 4
  %869 = fsub float %864, %868
  %870 = fpext float %869 to double
  %871 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %872 = load float, ptr %871, align 4
  %873 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %874 = load float, ptr %873, align 4
  %875 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %876 = load float, ptr %875, align 4
  %877 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %878 = load float, ptr %877, align 4
  %879 = fsub float %874, %878
  %880 = fpext float %879 to double
  %881 = call double @llvm.fmuladd.f64(double %850, double %860, double 0.000000e+00)
  %882 = call double @sqrt(double noundef %881) #6
  %883 = load float, ptr %6, align 4, !tbaa !5
  %884 = fpext float %883 to double
  %885 = fcmp ogt double %882, %884
  br i1 %885, label %910, label %886

886:                                              ; preds = %840
  %887 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %888 = load float, ptr %887, align 4
  %889 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %890 = load float, ptr %889, align 4
  %891 = call i1 @llvm.is.fpclass.f32(float %890, i32 3)
  br i1 %891, label %910, label %892

892:                                              ; preds = %886
  %893 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %894 = load float, ptr %893, align 4
  %895 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %896 = load float, ptr %895, align 4
  %897 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %897, label %910, label %898

898:                                              ; preds = %892
  %899 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %900 = load float, ptr %899, align 4
  %901 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %902 = load float, ptr %901, align 4
  %903 = call i1 @llvm.is.fpclass.f32(float %902, i32 3)
  br i1 %903, label %910, label %904

904:                                              ; preds = %898
  %905 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %906 = load float, ptr %905, align 4
  %907 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %908 = load float, ptr %907, align 4
  %909 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %909, label %910, label %955

910:                                              ; preds = %904, %898, %892, %886, %840
  %911 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %912 = load float, ptr %911, align 4
  %913 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %914 = load float, ptr %913, align 4
  %915 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %916 = load float, ptr %915, align 4
  %917 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %918 = load float, ptr %917, align 4
  %919 = fsub float %914, %918
  %920 = fpext float %919 to double
  %921 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %922 = load float, ptr %921, align 4
  %923 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %924 = load float, ptr %923, align 4
  %925 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %926 = load float, ptr %925, align 4
  %927 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %928 = load float, ptr %927, align 4
  %929 = fsub float %924, %928
  %930 = fpext float %929 to double
  %931 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %932 = load float, ptr %931, align 4
  %933 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %934 = load float, ptr %933, align 4
  %935 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %936 = load float, ptr %935, align 4
  %937 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %938 = load float, ptr %937, align 4
  %939 = fsub float %934, %938
  %940 = fpext float %939 to double
  %941 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %942 = load float, ptr %941, align 4
  %943 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %944 = load float, ptr %943, align 4
  %945 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 0
  %946 = load float, ptr %945, align 4
  %947 = getelementptr inbounds { float, float }, ptr %5, i32 0, i32 1
  %948 = load float, ptr %947, align 4
  %949 = fsub float %944, %948
  %950 = fpext float %949 to double
  %951 = call double @llvm.fmuladd.f64(double %920, double %930, double 0.000000e+00)
  %952 = call double @sqrt(double noundef %951) #6
  %953 = load float, ptr %6, align 4, !tbaa !5
  %954 = fpext float %953 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 81, ptr noundef @.str.6, double noundef %952, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %954)
  br label %956

955:                                              ; preds = %904
  call void (...) @liquid_autotest_passed()
  br label %956

956:                                              ; preds = %955, %910
  %957 = load ptr, ptr %7, align 8, !tbaa !9
  %958 = getelementptr inbounds [16 x { float, float }], ptr %1, i64 0, i64 0
  %959 = call ptr @dotprod_cccf_recreate(ptr noundef %957, ptr noundef %958, i32 noundef 16)
  store ptr %959, ptr %7, align 8, !tbaa !9
  %960 = load ptr, ptr %7, align 8, !tbaa !9
  %961 = getelementptr inbounds [16 x { float, float }], ptr %2, i64 0, i64 0
  %962 = call i32 @dotprod_cccf_execute(ptr noundef %960, ptr noundef %961, ptr noundef %3)
  %963 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %964 = load float, ptr %963, align 4
  %965 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %966 = load float, ptr %965, align 4
  %967 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %968 = load float, ptr %967, align 4
  %969 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %970 = load float, ptr %969, align 4
  %971 = fsub float %964, %968
  %972 = fpext float %971 to double
  %973 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %974 = load float, ptr %973, align 4
  %975 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %976 = load float, ptr %975, align 4
  %977 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %978 = load float, ptr %977, align 4
  %979 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %980 = load float, ptr %979, align 4
  %981 = fsub float %974, %978
  %982 = fpext float %981 to double
  %983 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %984 = load float, ptr %983, align 4
  %985 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %986 = load float, ptr %985, align 4
  %987 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %988 = load float, ptr %987, align 4
  %989 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %990 = load float, ptr %989, align 4
  %991 = fsub float %984, %988
  %992 = fpext float %991 to double
  %993 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %994 = load float, ptr %993, align 4
  %995 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %996 = load float, ptr %995, align 4
  %997 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %998 = load float, ptr %997, align 4
  %999 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1000 = load float, ptr %999, align 4
  %1001 = fsub float %994, %998
  %1002 = fpext float %1001 to double
  %1003 = call double @llvm.fmuladd.f64(double %972, double %982, double 0.000000e+00)
  %1004 = call double @sqrt(double noundef %1003) #6
  %1005 = load float, ptr %6, align 4, !tbaa !5
  %1006 = fpext float %1005 to double
  %1007 = fcmp ogt double %1004, %1006
  br i1 %1007, label %1032, label %1008

1008:                                             ; preds = %956
  %1009 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1010 = load float, ptr %1009, align 4
  %1011 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1012 = load float, ptr %1011, align 4
  %1013 = call i1 @llvm.is.fpclass.f32(float %1010, i32 3)
  br i1 %1013, label %1032, label %1014

1014:                                             ; preds = %1008
  %1015 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1016 = load float, ptr %1015, align 4
  %1017 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1018 = load float, ptr %1017, align 4
  %1019 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %1019, label %1032, label %1020

1020:                                             ; preds = %1014
  %1021 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1022 = load float, ptr %1021, align 4
  %1023 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1024 = load float, ptr %1023, align 4
  %1025 = call i1 @llvm.is.fpclass.f32(float %1022, i32 3)
  br i1 %1025, label %1032, label %1026

1026:                                             ; preds = %1020
  %1027 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1028 = load float, ptr %1027, align 4
  %1029 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1030 = load float, ptr %1029, align 4
  %1031 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %1031, label %1032, label %1077

1032:                                             ; preds = %1026, %1020, %1014, %1008, %956
  %1033 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1034 = load float, ptr %1033, align 4
  %1035 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1036 = load float, ptr %1035, align 4
  %1037 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1038 = load float, ptr %1037, align 4
  %1039 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1040 = load float, ptr %1039, align 4
  %1041 = fsub float %1034, %1038
  %1042 = fpext float %1041 to double
  %1043 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1044 = load float, ptr %1043, align 4
  %1045 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1046 = load float, ptr %1045, align 4
  %1047 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1048 = load float, ptr %1047, align 4
  %1049 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1050 = load float, ptr %1049, align 4
  %1051 = fsub float %1044, %1048
  %1052 = fpext float %1051 to double
  %1053 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1054 = load float, ptr %1053, align 4
  %1055 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1056 = load float, ptr %1055, align 4
  %1057 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1058 = load float, ptr %1057, align 4
  %1059 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1060 = load float, ptr %1059, align 4
  %1061 = fsub float %1054, %1058
  %1062 = fpext float %1061 to double
  %1063 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1064 = load float, ptr %1063, align 4
  %1065 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1066 = load float, ptr %1065, align 4
  %1067 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1068 = load float, ptr %1067, align 4
  %1069 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1070 = load float, ptr %1069, align 4
  %1071 = fsub float %1064, %1068
  %1072 = fpext float %1071 to double
  %1073 = call double @llvm.fmuladd.f64(double %1042, double %1052, double 0.000000e+00)
  %1074 = call double @sqrt(double noundef %1073) #6
  %1075 = load float, ptr %6, align 4, !tbaa !5
  %1076 = fpext float %1075 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 86, ptr noundef @.str.1, double noundef %1074, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %1076)
  br label %1078

1077:                                             ; preds = %1026
  call void (...) @liquid_autotest_passed()
  br label %1078

1078:                                             ; preds = %1077, %1032
  %1079 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1080 = load float, ptr %1079, align 4
  %1081 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1082 = load float, ptr %1081, align 4
  %1083 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1084 = load float, ptr %1083, align 4
  %1085 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1086 = load float, ptr %1085, align 4
  %1087 = fsub float %1082, %1086
  %1088 = fpext float %1087 to double
  %1089 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1090 = load float, ptr %1089, align 4
  %1091 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1092 = load float, ptr %1091, align 4
  %1093 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1094 = load float, ptr %1093, align 4
  %1095 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1096 = load float, ptr %1095, align 4
  %1097 = fsub float %1092, %1096
  %1098 = fpext float %1097 to double
  %1099 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1100 = load float, ptr %1099, align 4
  %1101 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1102 = load float, ptr %1101, align 4
  %1103 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1104 = load float, ptr %1103, align 4
  %1105 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1106 = load float, ptr %1105, align 4
  %1107 = fsub float %1102, %1106
  %1108 = fpext float %1107 to double
  %1109 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1110 = load float, ptr %1109, align 4
  %1111 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1112 = load float, ptr %1111, align 4
  %1113 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1114 = load float, ptr %1113, align 4
  %1115 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1116 = load float, ptr %1115, align 4
  %1117 = fsub float %1112, %1116
  %1118 = fpext float %1117 to double
  %1119 = call double @llvm.fmuladd.f64(double %1088, double %1098, double 0.000000e+00)
  %1120 = call double @sqrt(double noundef %1119) #6
  %1121 = load float, ptr %6, align 4, !tbaa !5
  %1122 = fpext float %1121 to double
  %1123 = fcmp ogt double %1120, %1122
  br i1 %1123, label %1148, label %1124

1124:                                             ; preds = %1078
  %1125 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1126 = load float, ptr %1125, align 4
  %1127 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1128 = load float, ptr %1127, align 4
  %1129 = call i1 @llvm.is.fpclass.f32(float %1128, i32 3)
  br i1 %1129, label %1148, label %1130

1130:                                             ; preds = %1124
  %1131 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1132 = load float, ptr %1131, align 4
  %1133 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1134 = load float, ptr %1133, align 4
  %1135 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %1135, label %1148, label %1136

1136:                                             ; preds = %1130
  %1137 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1138 = load float, ptr %1137, align 4
  %1139 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1140 = load float, ptr %1139, align 4
  %1141 = call i1 @llvm.is.fpclass.f32(float %1140, i32 3)
  br i1 %1141, label %1148, label %1142

1142:                                             ; preds = %1136
  %1143 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1144 = load float, ptr %1143, align 4
  %1145 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1146 = load float, ptr %1145, align 4
  %1147 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %1147, label %1148, label %1193

1148:                                             ; preds = %1142, %1136, %1130, %1124, %1078
  %1149 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1150 = load float, ptr %1149, align 4
  %1151 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1152 = load float, ptr %1151, align 4
  %1153 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1154 = load float, ptr %1153, align 4
  %1155 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1156 = load float, ptr %1155, align 4
  %1157 = fsub float %1152, %1156
  %1158 = fpext float %1157 to double
  %1159 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1160 = load float, ptr %1159, align 4
  %1161 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1162 = load float, ptr %1161, align 4
  %1163 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1164 = load float, ptr %1163, align 4
  %1165 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1166 = load float, ptr %1165, align 4
  %1167 = fsub float %1162, %1166
  %1168 = fpext float %1167 to double
  %1169 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1170 = load float, ptr %1169, align 4
  %1171 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1172 = load float, ptr %1171, align 4
  %1173 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1174 = load float, ptr %1173, align 4
  %1175 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1176 = load float, ptr %1175, align 4
  %1177 = fsub float %1172, %1176
  %1178 = fpext float %1177 to double
  %1179 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1180 = load float, ptr %1179, align 4
  %1181 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1182 = load float, ptr %1181, align 4
  %1183 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 0
  %1184 = load float, ptr %1183, align 4
  %1185 = getelementptr inbounds { float, float }, ptr %4, i32 0, i32 1
  %1186 = load float, ptr %1185, align 4
  %1187 = fsub float %1182, %1186
  %1188 = fpext float %1187 to double
  %1189 = call double @llvm.fmuladd.f64(double %1158, double %1168, double 0.000000e+00)
  %1190 = call double @sqrt(double noundef %1189) #6
  %1191 = load float, ptr %6, align 4, !tbaa !5
  %1192 = fpext float %1191 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 87, ptr noundef @.str.4, double noundef %1190, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %1192)
  br label %1194

1193:                                             ; preds = %1142
  call void (...) @liquid_autotest_passed()
  br label %1194

1194:                                             ; preds = %1193, %1148
  %1195 = load ptr, ptr %7, align 8, !tbaa !9
  %1196 = call i32 @dotprod_cccf_destroy(ptr noundef %1195)
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr %2) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr %1) #6
  ret void
}

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

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

declare i32 @dotprod_cccf_run(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #3

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

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

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

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

declare void @liquid_autotest_passed(...) #3

declare i32 @dotprod_cccf_run4(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #3

declare ptr @dotprod_cccf_create(ptr noundef, i32 noundef) #3

declare i32 @dotprod_cccf_execute(ptr noundef, ptr noundef, ptr noundef) #3

declare ptr @dotprod_cccf_recreate_rev(ptr noundef, ptr noundef, i32 noundef) #3

declare ptr @dotprod_cccf_recreate(ptr noundef, ptr noundef, i32 noundef) #3

declare i32 @dotprod_cccf_destroy(ptr noundef) #3

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

attributes #0 = { 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 #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
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 "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 = !{!10, !10, i64 0}
!10 = !{!"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"

@__const.autotest_dotprod_cccf_rand16.h = external hidden unnamed_addr constant [16 x { float, float }], align 16
@__const.autotest_dotprod_cccf_rand16.x = external hidden unnamed_addr constant [16 x { float, float }], align 16
@.str = external hidden unnamed_addr constant [96 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [32 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
@.str.4 = external hidden unnamed_addr constant [32 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [36 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @autotest_dotprod_cccf_rand16() local_unnamed_addr #0 {
  %1 = alloca [16 x { float, float }], align 16
  %2 = alloca [16 x { float, float }], align 16
  %3 = alloca { float, float }, align 4
  call void @llvm.lifetime.start.p0(i64 128, ptr nonnull %1) #6
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(128) %1, ptr noundef nonnull align 16 dereferenceable(128) @__const.autotest_dotprod_cccf_rand16.h, i64 128, i1 false)
  call void @llvm.lifetime.start.p0(i64 128, ptr nonnull %2) #6
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(128) %2, ptr noundef nonnull align 16 dereferenceable(128) @__const.autotest_dotprod_cccf_rand16.x, i64 128, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %3) #6
  %4 = call i32 @dotprod_cccf_run(ptr noundef nonnull %1, ptr noundef nonnull %2, i32 noundef 16, ptr noundef nonnull %3) #6
  %5 = load float, ptr %3, align 4
  %6 = getelementptr inbounds i8, ptr %3, i64 4
  %7 = fadd float %5, 0x3FE3564DA0000000
  %8 = fpext float %7 to double
  %9 = call double @llvm.fmuladd.f64(double %8, double %8, double 0.000000e+00)
  %sqrt = call double @llvm.sqrt.f64(double %9)
  %10 = fcmp ogt double %sqrt, 0x3F50624DE0000000
  %11 = fcmp uno float %5, 0.000000e+00
  %or.cond = select i1 %10, i1 true, i1 %11
  br i1 %or.cond, label %12, label %13

12:                                               ; preds = %0
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 64, ptr noundef nonnull @.str.1, double noundef %sqrt, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %14

13:                                               ; preds = %0
  call void (...) @liquid_autotest_passed() #6
  br label %14

14:                                               ; preds = %13, %12
  %15 = load float, ptr %6, align 4
  %16 = fadd float %15, 0x4028C82760000000
  %17 = fpext float %16 to double
  %18 = call double @llvm.fmuladd.f64(double %17, double %17, double 0.000000e+00)
  %sqrt243 = call double @llvm.sqrt.f64(double %18)
  %19 = fcmp ogt double %sqrt243, 0x3F50624DE0000000
  %20 = fcmp uno float %15, 0.000000e+00
  %or.cond225 = select i1 %19, i1 true, i1 %20
  br i1 %or.cond225, label %21, label %22

21:                                               ; preds = %14
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 65, ptr noundef nonnull @.str.4, double noundef %sqrt243, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %23

22:                                               ; preds = %14
  call void (...) @liquid_autotest_passed() #6
  br label %23

23:                                               ; preds = %22, %21
  %24 = call i32 @dotprod_cccf_run4(ptr noundef nonnull %1, ptr noundef nonnull %2, i32 noundef 16, ptr noundef nonnull %3) #6
  %25 = load float, ptr %3, align 4
  %26 = fadd float %25, 0x3FE3564DA0000000
  %27 = fpext float %26 to double
  %28 = call double @llvm.fmuladd.f64(double %27, double %27, double 0.000000e+00)
  %sqrt245 = call double @llvm.sqrt.f64(double %28)
  %29 = fcmp ogt double %sqrt245, 0x3F50624DE0000000
  %30 = fcmp uno float %25, 0.000000e+00
  %or.cond227 = select i1 %29, i1 true, i1 %30
  br i1 %or.cond227, label %31, label %32

31:                                               ; preds = %23
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 68, ptr noundef nonnull @.str.1, double noundef %sqrt245, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %33

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

33:                                               ; preds = %32, %31
  %34 = load float, ptr %6, align 4
  %35 = fadd float %34, 0x4028C82760000000
  %36 = fpext float %35 to double
  %37 = call double @llvm.fmuladd.f64(double %36, double %36, double 0.000000e+00)
  %sqrt247 = call double @llvm.sqrt.f64(double %37)
  %38 = fcmp ogt double %sqrt247, 0x3F50624DE0000000
  %39 = fcmp uno float %34, 0.000000e+00
  %or.cond229 = select i1 %38, i1 true, i1 %39
  br i1 %or.cond229, label %40, label %41

40:                                               ; preds = %33
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 69, ptr noundef nonnull @.str.4, double noundef %sqrt247, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %42

41:                                               ; preds = %33
  call void (...) @liquid_autotest_passed() #6
  br label %42

42:                                               ; preds = %41, %40
  %43 = call ptr @dotprod_cccf_create(ptr noundef nonnull %1, i32 noundef 16) #6
  %44 = call i32 @dotprod_cccf_execute(ptr noundef %43, ptr noundef nonnull %2, ptr noundef nonnull %3) #6
  %45 = load float, ptr %3, align 4
  %46 = fadd float %45, 0x3FE3564DA0000000
  %47 = fpext float %46 to double
  %48 = call double @llvm.fmuladd.f64(double %47, double %47, double 0.000000e+00)
  %sqrt249 = call double @llvm.sqrt.f64(double %48)
  %49 = fcmp ogt double %sqrt249, 0x3F50624DE0000000
  %50 = fcmp uno float %45, 0.000000e+00
  %or.cond231 = select i1 %49, i1 true, i1 %50
  br i1 %or.cond231, label %51, label %52

51:                                               ; preds = %42
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 74, ptr noundef nonnull @.str.1, double noundef %sqrt249, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %53

52:                                               ; preds = %42
  call void (...) @liquid_autotest_passed() #6
  br label %53

53:                                               ; preds = %52, %51
  %54 = load float, ptr %6, align 4
  %55 = fadd float %54, 0x4028C82760000000
  %56 = fpext float %55 to double
  %57 = call double @llvm.fmuladd.f64(double %56, double %56, double 0.000000e+00)
  %sqrt251 = call double @llvm.sqrt.f64(double %57)
  %58 = fcmp ogt double %sqrt251, 0x3F50624DE0000000
  %59 = fcmp uno float %54, 0.000000e+00
  %or.cond233 = select i1 %58, i1 true, i1 %59
  br i1 %or.cond233, label %60, label %61

60:                                               ; preds = %53
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 75, ptr noundef nonnull @.str.4, double noundef %sqrt251, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %62

61:                                               ; preds = %53
  call void (...) @liquid_autotest_passed() #6
  br label %62

62:                                               ; preds = %61, %60
  %63 = call ptr @dotprod_cccf_recreate_rev(ptr noundef %43, ptr noundef nonnull %1, i32 noundef 16) #6
  %64 = call i32 @dotprod_cccf_execute(ptr noundef %63, ptr noundef nonnull %2, ptr noundef nonnull %3) #6
  %65 = load float, ptr %3, align 4
  %66 = fadd float %65, 0xC00B4C8680000000
  %67 = fpext float %66 to double
  %68 = call double @llvm.fmuladd.f64(double %67, double %67, double 0.000000e+00)
  %sqrt253 = call double @llvm.sqrt.f64(double %68)
  %69 = fcmp ogt double %sqrt253, 0x3F50624DE0000000
  %70 = fcmp uno float %65, 0.000000e+00
  %or.cond235 = select i1 %69, i1 true, i1 %70
  br i1 %or.cond235, label %71, label %72

71:                                               ; preds = %62
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 80, ptr noundef nonnull @.str.5, double noundef %sqrt253, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %73

72:                                               ; preds = %62
  call void (...) @liquid_autotest_passed() #6
  br label %73

73:                                               ; preds = %72, %71
  %74 = load float, ptr %6, align 4
  %75 = fadd float %74, 0xC018C10E80000000
  %76 = fpext float %75 to double
  %77 = call double @llvm.fmuladd.f64(double %76, double %76, double 0.000000e+00)
  %sqrt255 = call double @llvm.sqrt.f64(double %77)
  %78 = fcmp ogt double %sqrt255, 0x3F50624DE0000000
  %79 = fcmp uno float %74, 0.000000e+00
  %or.cond237 = select i1 %78, i1 true, i1 %79
  br i1 %or.cond237, label %80, label %81

80:                                               ; preds = %73
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 81, ptr noundef nonnull @.str.6, double noundef %sqrt255, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %82

81:                                               ; preds = %73
  call void (...) @liquid_autotest_passed() #6
  br label %82

82:                                               ; preds = %81, %80
  %83 = call ptr @dotprod_cccf_recreate(ptr noundef %63, ptr noundef nonnull %1, i32 noundef 16) #6
  %84 = call i32 @dotprod_cccf_execute(ptr noundef %83, ptr noundef nonnull %2, ptr noundef nonnull %3) #6
  %85 = load float, ptr %3, align 4
  %86 = fadd float %85, 0x3FE3564DA0000000
  %87 = fpext float %86 to double
  %88 = call double @llvm.fmuladd.f64(double %87, double %87, double 0.000000e+00)
  %sqrt257 = call double @llvm.sqrt.f64(double %88)
  %89 = fcmp ogt double %sqrt257, 0x3F50624DE0000000
  %90 = fcmp uno float %85, 0.000000e+00
  %or.cond239 = select i1 %89, i1 true, i1 %90
  br i1 %or.cond239, label %91, label %92

91:                                               ; preds = %82
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 86, ptr noundef nonnull @.str.1, double noundef %sqrt257, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %93

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

93:                                               ; preds = %92, %91
  %94 = load float, ptr %6, align 4
  %95 = fadd float %94, 0x4028C82760000000
  %96 = fpext float %95 to double
  %97 = call double @llvm.fmuladd.f64(double %96, double %96, double 0.000000e+00)
  %sqrt259 = call double @llvm.sqrt.f64(double %97)
  %98 = fcmp ogt double %sqrt259, 0x3F50624DE0000000
  %99 = fcmp uno float %94, 0.000000e+00
  %or.cond241 = select i1 %98, i1 true, i1 %99
  br i1 %or.cond241, label %100, label %101

100:                                              ; preds = %93
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 87, ptr noundef nonnull @.str.4, double noundef %sqrt259, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3F50624DE0000000) #6
  br label %102

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

102:                                              ; preds = %101, %100
  %103 = call i32 @dotprod_cccf_destroy(ptr noundef %83) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %3) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr nonnull %2) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr nonnull %1) #6
  ret void
}

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

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

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

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

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

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

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

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

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

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

declare i32 @dotprod_cccf_destroy(ptr noundef) local_unnamed_addr #3

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

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

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


; Effective O3 passes: AggressiveInstCombinePass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,SROAPass,SimplifyCFGPass