; LLVM IR from jgaeddert/liquid-dsp :: src/dotprod/tests (dotprod_rrrf_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_rrrf_basic.h = external hidden unnamed_addr constant [16 x float], align 16
@.str = external hidden unnamed_addr constant [96 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [17 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
@__const.autotest_dotprod_rrrf_basic.x1 = external hidden unnamed_addr constant [16 x float], align 16
@.str.4 = external hidden unnamed_addr constant [17 x i8], align 1
@__const.autotest_dotprod_rrrf_basic.x2 = external hidden unnamed_addr constant [16 x float], align 16
@.str.5 = external hidden unnamed_addr constant [17 x i8], align 1
@__const.autotest_dotprod_rrrf_basic.x3 = external hidden unnamed_addr constant [16 x float], align 16
@.str.6 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [17 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @autotest_dotprod_rrrf_basic() #0 {
  %1 = alloca float, align 4
  %2 = alloca float, align 4
  %3 = alloca [16 x float], align 16
  %4 = alloca [16 x float], align 16
  %5 = alloca float, align 4
  %6 = alloca [16 x float], align 16
  %7 = alloca float, align 4
  %8 = alloca [16 x float], align 16
  %9 = alloca float, align 4
  %10 = alloca [16 x float], align 16
  %11 = alloca float, align 4
  %12 = alloca float, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %1) #7
  store float 0x3EB0C6F7A0000000, ptr %1, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #7
  call void @llvm.lifetime.start.p0(i64 64, ptr %3) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %3, ptr align 16 @__const.autotest_dotprod_rrrf_basic.h, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %4) #7
  call void @llvm.memset.p0.i64(ptr align 16 %4, i8 0, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #7
  store float 0.000000e+00, ptr %5, align 4, !tbaa !5
  %13 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %14 = getelementptr inbounds [16 x float], ptr %4, i64 0, i64 0
  %15 = call i32 @dotprod_rrrf_run(ptr noundef %13, ptr noundef %14, i32 noundef 16, ptr noundef %2)
  %16 = load float, ptr %2, align 4, !tbaa !5
  %17 = load float, ptr %5, align 4, !tbaa !5
  %18 = fsub float %16, %17
  %19 = fpext float %18 to double
  %20 = load float, ptr %2, align 4, !tbaa !5
  %21 = load float, ptr %5, align 4, !tbaa !5
  %22 = fsub float %20, %21
  %23 = fpext float %22 to double
  %24 = load float, ptr %2, align 4, !tbaa !5
  %25 = load float, ptr %5, align 4, !tbaa !5
  %26 = fsub float %24, %25
  %27 = fpext float %26 to double
  %28 = load float, ptr %2, align 4, !tbaa !5
  %29 = load float, ptr %5, align 4, !tbaa !5
  %30 = fsub float %28, %29
  %31 = fpext float %30 to double
  %32 = call double @llvm.fmuladd.f64(double %19, double %23, double 0.000000e+00)
  %33 = call double @sqrt(double noundef %32) #7
  %34 = load float, ptr %1, align 4, !tbaa !5
  %35 = fpext float %34 to double
  %36 = fcmp ogt double %33, %35
  br i1 %36, label %49, label %37

37:                                               ; preds = %0
  %38 = load float, ptr %2, align 4, !tbaa !5
  %39 = call i1 @llvm.is.fpclass.f32(float %38, i32 3)
  br i1 %39, label %49, label %40

40:                                               ; preds = %37
  %41 = load float, ptr %2, align 4, !tbaa !5
  %42 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %42, label %49, label %43

43:                                               ; preds = %40
  %44 = load float, ptr %5, align 4, !tbaa !5
  %45 = call i1 @llvm.is.fpclass.f32(float %44, i32 3)
  br i1 %45, label %49, label %46

46:                                               ; preds = %43
  %47 = load float, ptr %5, align 4, !tbaa !5
  %48 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %48, label %49, label %70

49:                                               ; preds = %46, %43, %40, %37, %0
  %50 = load float, ptr %2, align 4, !tbaa !5
  %51 = load float, ptr %5, align 4, !tbaa !5
  %52 = fsub float %50, %51
  %53 = fpext float %52 to double
  %54 = load float, ptr %2, align 4, !tbaa !5
  %55 = load float, ptr %5, align 4, !tbaa !5
  %56 = fsub float %54, %55
  %57 = fpext float %56 to double
  %58 = load float, ptr %2, align 4, !tbaa !5
  %59 = load float, ptr %5, align 4, !tbaa !5
  %60 = fsub float %58, %59
  %61 = fpext float %60 to double
  %62 = load float, ptr %2, align 4, !tbaa !5
  %63 = load float, ptr %5, align 4, !tbaa !5
  %64 = fsub float %62, %63
  %65 = fpext float %64 to double
  %66 = call double @llvm.fmuladd.f64(double %53, double %57, double 0.000000e+00)
  %67 = call double @sqrt(double noundef %66) #7
  %68 = load float, ptr %1, align 4, !tbaa !5
  %69 = fpext float %68 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 43, ptr noundef @.str.1, double noundef %67, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %69)
  br label %71

70:                                               ; preds = %46
  call void (...) @liquid_autotest_passed()
  br label %71

71:                                               ; preds = %70, %49
  %72 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %73 = getelementptr inbounds [16 x float], ptr %4, i64 0, i64 0
  %74 = call i32 @dotprod_rrrf_run4(ptr noundef %72, ptr noundef %73, i32 noundef 16, ptr noundef %2)
  %75 = load float, ptr %2, align 4, !tbaa !5
  %76 = load float, ptr %5, align 4, !tbaa !5
  %77 = fsub float %75, %76
  %78 = fpext float %77 to double
  %79 = load float, ptr %2, align 4, !tbaa !5
  %80 = load float, ptr %5, align 4, !tbaa !5
  %81 = fsub float %79, %80
  %82 = fpext float %81 to double
  %83 = load float, ptr %2, align 4, !tbaa !5
  %84 = load float, ptr %5, align 4, !tbaa !5
  %85 = fsub float %83, %84
  %86 = fpext float %85 to double
  %87 = load float, ptr %2, align 4, !tbaa !5
  %88 = load float, ptr %5, align 4, !tbaa !5
  %89 = fsub float %87, %88
  %90 = fpext float %89 to double
  %91 = call double @llvm.fmuladd.f64(double %78, double %82, double 0.000000e+00)
  %92 = call double @sqrt(double noundef %91) #7
  %93 = load float, ptr %1, align 4, !tbaa !5
  %94 = fpext float %93 to double
  %95 = fcmp ogt double %92, %94
  br i1 %95, label %108, label %96

96:                                               ; preds = %71
  %97 = load float, ptr %2, align 4, !tbaa !5
  %98 = call i1 @llvm.is.fpclass.f32(float %97, i32 3)
  br i1 %98, label %108, label %99

99:                                               ; preds = %96
  %100 = load float, ptr %2, align 4, !tbaa !5
  %101 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %101, label %108, label %102

102:                                              ; preds = %99
  %103 = load float, ptr %5, align 4, !tbaa !5
  %104 = call i1 @llvm.is.fpclass.f32(float %103, i32 3)
  br i1 %104, label %108, label %105

105:                                              ; preds = %102
  %106 = load float, ptr %5, align 4, !tbaa !5
  %107 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %107, label %108, label %129

108:                                              ; preds = %105, %102, %99, %96, %71
  %109 = load float, ptr %2, align 4, !tbaa !5
  %110 = load float, ptr %5, align 4, !tbaa !5
  %111 = fsub float %109, %110
  %112 = fpext float %111 to double
  %113 = load float, ptr %2, align 4, !tbaa !5
  %114 = load float, ptr %5, align 4, !tbaa !5
  %115 = fsub float %113, %114
  %116 = fpext float %115 to double
  %117 = load float, ptr %2, align 4, !tbaa !5
  %118 = load float, ptr %5, align 4, !tbaa !5
  %119 = fsub float %117, %118
  %120 = fpext float %119 to double
  %121 = load float, ptr %2, align 4, !tbaa !5
  %122 = load float, ptr %5, align 4, !tbaa !5
  %123 = fsub float %121, %122
  %124 = fpext float %123 to double
  %125 = call double @llvm.fmuladd.f64(double %112, double %116, double 0.000000e+00)
  %126 = call double @sqrt(double noundef %125) #7
  %127 = load float, ptr %1, align 4, !tbaa !5
  %128 = fpext float %127 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 45, ptr noundef @.str.1, double noundef %126, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %128)
  br label %130

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

130:                                              ; preds = %129, %108
  call void @llvm.lifetime.start.p0(i64 64, ptr %6) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %6, ptr align 16 @__const.autotest_dotprod_rrrf_basic.x1, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #7
  store float 0.000000e+00, ptr %7, align 4, !tbaa !5
  %131 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %132 = getelementptr inbounds [16 x float], ptr %6, i64 0, i64 0
  %133 = call i32 @dotprod_rrrf_run(ptr noundef %131, ptr noundef %132, i32 noundef 16, ptr noundef %2)
  %134 = load float, ptr %2, align 4, !tbaa !5
  %135 = load float, ptr %7, align 4, !tbaa !5
  %136 = fsub float %134, %135
  %137 = fpext float %136 to double
  %138 = load float, ptr %2, align 4, !tbaa !5
  %139 = load float, ptr %7, align 4, !tbaa !5
  %140 = fsub float %138, %139
  %141 = fpext float %140 to double
  %142 = load float, ptr %2, align 4, !tbaa !5
  %143 = load float, ptr %7, align 4, !tbaa !5
  %144 = fsub float %142, %143
  %145 = fpext float %144 to double
  %146 = load float, ptr %2, align 4, !tbaa !5
  %147 = load float, ptr %7, align 4, !tbaa !5
  %148 = fsub float %146, %147
  %149 = fpext float %148 to double
  %150 = call double @llvm.fmuladd.f64(double %137, double %141, double 0.000000e+00)
  %151 = call double @sqrt(double noundef %150) #7
  %152 = load float, ptr %1, align 4, !tbaa !5
  %153 = fpext float %152 to double
  %154 = fcmp ogt double %151, %153
  br i1 %154, label %167, label %155

155:                                              ; preds = %130
  %156 = load float, ptr %2, align 4, !tbaa !5
  %157 = call i1 @llvm.is.fpclass.f32(float %156, i32 3)
  br i1 %157, label %167, label %158

158:                                              ; preds = %155
  %159 = load float, ptr %2, align 4, !tbaa !5
  %160 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %160, label %167, label %161

161:                                              ; preds = %158
  %162 = load float, ptr %7, align 4, !tbaa !5
  %163 = call i1 @llvm.is.fpclass.f32(float %162, i32 3)
  br i1 %163, label %167, label %164

164:                                              ; preds = %161
  %165 = load float, ptr %7, align 4, !tbaa !5
  %166 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %166, label %167, label %188

167:                                              ; preds = %164, %161, %158, %155, %130
  %168 = load float, ptr %2, align 4, !tbaa !5
  %169 = load float, ptr %7, align 4, !tbaa !5
  %170 = fsub float %168, %169
  %171 = fpext float %170 to double
  %172 = load float, ptr %2, align 4, !tbaa !5
  %173 = load float, ptr %7, align 4, !tbaa !5
  %174 = fsub float %172, %173
  %175 = fpext float %174 to double
  %176 = load float, ptr %2, align 4, !tbaa !5
  %177 = load float, ptr %7, align 4, !tbaa !5
  %178 = fsub float %176, %177
  %179 = fpext float %178 to double
  %180 = load float, ptr %2, align 4, !tbaa !5
  %181 = load float, ptr %7, align 4, !tbaa !5
  %182 = fsub float %180, %181
  %183 = fpext float %182 to double
  %184 = call double @llvm.fmuladd.f64(double %171, double %175, double 0.000000e+00)
  %185 = call double @sqrt(double noundef %184) #7
  %186 = load float, ptr %1, align 4, !tbaa !5
  %187 = fpext float %186 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 50, ptr noundef @.str.4, double noundef %185, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %187)
  br label %189

188:                                              ; preds = %164
  call void (...) @liquid_autotest_passed()
  br label %189

189:                                              ; preds = %188, %167
  %190 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %191 = getelementptr inbounds [16 x float], ptr %6, i64 0, i64 0
  %192 = call i32 @dotprod_rrrf_run4(ptr noundef %190, ptr noundef %191, i32 noundef 16, ptr noundef %2)
  %193 = load float, ptr %2, align 4, !tbaa !5
  %194 = load float, ptr %7, align 4, !tbaa !5
  %195 = fsub float %193, %194
  %196 = fpext float %195 to double
  %197 = load float, ptr %2, align 4, !tbaa !5
  %198 = load float, ptr %7, align 4, !tbaa !5
  %199 = fsub float %197, %198
  %200 = fpext float %199 to double
  %201 = load float, ptr %2, align 4, !tbaa !5
  %202 = load float, ptr %7, align 4, !tbaa !5
  %203 = fsub float %201, %202
  %204 = fpext float %203 to double
  %205 = load float, ptr %2, align 4, !tbaa !5
  %206 = load float, ptr %7, align 4, !tbaa !5
  %207 = fsub float %205, %206
  %208 = fpext float %207 to double
  %209 = call double @llvm.fmuladd.f64(double %196, double %200, double 0.000000e+00)
  %210 = call double @sqrt(double noundef %209) #7
  %211 = load float, ptr %1, align 4, !tbaa !5
  %212 = fpext float %211 to double
  %213 = fcmp ogt double %210, %212
  br i1 %213, label %226, label %214

214:                                              ; preds = %189
  %215 = load float, ptr %2, align 4, !tbaa !5
  %216 = call i1 @llvm.is.fpclass.f32(float %215, i32 3)
  br i1 %216, label %226, label %217

217:                                              ; preds = %214
  %218 = load float, ptr %2, align 4, !tbaa !5
  %219 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %219, label %226, label %220

220:                                              ; preds = %217
  %221 = load float, ptr %7, align 4, !tbaa !5
  %222 = call i1 @llvm.is.fpclass.f32(float %221, i32 3)
  br i1 %222, label %226, label %223

223:                                              ; preds = %220
  %224 = load float, ptr %7, align 4, !tbaa !5
  %225 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %225, label %226, label %247

226:                                              ; preds = %223, %220, %217, %214, %189
  %227 = load float, ptr %2, align 4, !tbaa !5
  %228 = load float, ptr %7, align 4, !tbaa !5
  %229 = fsub float %227, %228
  %230 = fpext float %229 to double
  %231 = load float, ptr %2, align 4, !tbaa !5
  %232 = load float, ptr %7, align 4, !tbaa !5
  %233 = fsub float %231, %232
  %234 = fpext float %233 to double
  %235 = load float, ptr %2, align 4, !tbaa !5
  %236 = load float, ptr %7, align 4, !tbaa !5
  %237 = fsub float %235, %236
  %238 = fpext float %237 to double
  %239 = load float, ptr %2, align 4, !tbaa !5
  %240 = load float, ptr %7, align 4, !tbaa !5
  %241 = fsub float %239, %240
  %242 = fpext float %241 to double
  %243 = call double @llvm.fmuladd.f64(double %230, double %234, double 0.000000e+00)
  %244 = call double @sqrt(double noundef %243) #7
  %245 = load float, ptr %1, align 4, !tbaa !5
  %246 = fpext float %245 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 52, ptr noundef @.str.4, double noundef %244, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %246)
  br label %248

247:                                              ; preds = %223
  call void (...) @liquid_autotest_passed()
  br label %248

248:                                              ; preds = %247, %226
  call void @llvm.lifetime.start.p0(i64 64, ptr %8) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %8, ptr align 16 @__const.autotest_dotprod_rrrf_basic.x2, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #7
  store float -8.000000e+00, ptr %9, align 4, !tbaa !5
  %249 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %250 = getelementptr inbounds [16 x float], ptr %8, i64 0, i64 0
  %251 = call i32 @dotprod_rrrf_run(ptr noundef %249, ptr noundef %250, i32 noundef 16, ptr noundef %2)
  %252 = load float, ptr %2, align 4, !tbaa !5
  %253 = load float, ptr %9, align 4, !tbaa !5
  %254 = fsub float %252, %253
  %255 = fpext float %254 to double
  %256 = load float, ptr %2, align 4, !tbaa !5
  %257 = load float, ptr %9, align 4, !tbaa !5
  %258 = fsub float %256, %257
  %259 = fpext float %258 to double
  %260 = load float, ptr %2, align 4, !tbaa !5
  %261 = load float, ptr %9, align 4, !tbaa !5
  %262 = fsub float %260, %261
  %263 = fpext float %262 to double
  %264 = load float, ptr %2, align 4, !tbaa !5
  %265 = load float, ptr %9, align 4, !tbaa !5
  %266 = fsub float %264, %265
  %267 = fpext float %266 to double
  %268 = call double @llvm.fmuladd.f64(double %255, double %259, double 0.000000e+00)
  %269 = call double @sqrt(double noundef %268) #7
  %270 = load float, ptr %1, align 4, !tbaa !5
  %271 = fpext float %270 to double
  %272 = fcmp ogt double %269, %271
  br i1 %272, label %285, label %273

273:                                              ; preds = %248
  %274 = load float, ptr %2, align 4, !tbaa !5
  %275 = call i1 @llvm.is.fpclass.f32(float %274, i32 3)
  br i1 %275, label %285, label %276

276:                                              ; preds = %273
  %277 = load float, ptr %2, align 4, !tbaa !5
  %278 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %278, label %285, label %279

279:                                              ; preds = %276
  %280 = load float, ptr %9, align 4, !tbaa !5
  %281 = call i1 @llvm.is.fpclass.f32(float %280, i32 3)
  br i1 %281, label %285, label %282

282:                                              ; preds = %279
  %283 = load float, ptr %9, align 4, !tbaa !5
  %284 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %284, label %285, label %306

285:                                              ; preds = %282, %279, %276, %273, %248
  %286 = load float, ptr %2, align 4, !tbaa !5
  %287 = load float, ptr %9, align 4, !tbaa !5
  %288 = fsub float %286, %287
  %289 = fpext float %288 to double
  %290 = load float, ptr %2, align 4, !tbaa !5
  %291 = load float, ptr %9, align 4, !tbaa !5
  %292 = fsub float %290, %291
  %293 = fpext float %292 to double
  %294 = load float, ptr %2, align 4, !tbaa !5
  %295 = load float, ptr %9, align 4, !tbaa !5
  %296 = fsub float %294, %295
  %297 = fpext float %296 to double
  %298 = load float, ptr %2, align 4, !tbaa !5
  %299 = load float, ptr %9, align 4, !tbaa !5
  %300 = fsub float %298, %299
  %301 = fpext float %300 to double
  %302 = call double @llvm.fmuladd.f64(double %289, double %293, double 0.000000e+00)
  %303 = call double @sqrt(double noundef %302) #7
  %304 = load float, ptr %1, align 4, !tbaa !5
  %305 = fpext float %304 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 57, ptr noundef @.str.5, double noundef %303, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %305)
  br label %307

306:                                              ; preds = %282
  call void (...) @liquid_autotest_passed()
  br label %307

307:                                              ; preds = %306, %285
  %308 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %309 = getelementptr inbounds [16 x float], ptr %8, i64 0, i64 0
  %310 = call i32 @dotprod_rrrf_run4(ptr noundef %308, ptr noundef %309, i32 noundef 16, ptr noundef %2)
  %311 = load float, ptr %2, align 4, !tbaa !5
  %312 = load float, ptr %9, align 4, !tbaa !5
  %313 = fsub float %311, %312
  %314 = fpext float %313 to double
  %315 = load float, ptr %2, align 4, !tbaa !5
  %316 = load float, ptr %9, align 4, !tbaa !5
  %317 = fsub float %315, %316
  %318 = fpext float %317 to double
  %319 = load float, ptr %2, align 4, !tbaa !5
  %320 = load float, ptr %9, align 4, !tbaa !5
  %321 = fsub float %319, %320
  %322 = fpext float %321 to double
  %323 = load float, ptr %2, align 4, !tbaa !5
  %324 = load float, ptr %9, align 4, !tbaa !5
  %325 = fsub float %323, %324
  %326 = fpext float %325 to double
  %327 = call double @llvm.fmuladd.f64(double %314, double %318, double 0.000000e+00)
  %328 = call double @sqrt(double noundef %327) #7
  %329 = load float, ptr %1, align 4, !tbaa !5
  %330 = fpext float %329 to double
  %331 = fcmp ogt double %328, %330
  br i1 %331, label %344, label %332

332:                                              ; preds = %307
  %333 = load float, ptr %2, align 4, !tbaa !5
  %334 = call i1 @llvm.is.fpclass.f32(float %333, i32 3)
  br i1 %334, label %344, label %335

335:                                              ; preds = %332
  %336 = load float, ptr %2, align 4, !tbaa !5
  %337 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %337, label %344, label %338

338:                                              ; preds = %335
  %339 = load float, ptr %9, align 4, !tbaa !5
  %340 = call i1 @llvm.is.fpclass.f32(float %339, i32 3)
  br i1 %340, label %344, label %341

341:                                              ; preds = %338
  %342 = load float, ptr %9, align 4, !tbaa !5
  %343 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %343, label %344, label %365

344:                                              ; preds = %341, %338, %335, %332, %307
  %345 = load float, ptr %2, align 4, !tbaa !5
  %346 = load float, ptr %9, align 4, !tbaa !5
  %347 = fsub float %345, %346
  %348 = fpext float %347 to double
  %349 = load float, ptr %2, align 4, !tbaa !5
  %350 = load float, ptr %9, align 4, !tbaa !5
  %351 = fsub float %349, %350
  %352 = fpext float %351 to double
  %353 = load float, ptr %2, align 4, !tbaa !5
  %354 = load float, ptr %9, align 4, !tbaa !5
  %355 = fsub float %353, %354
  %356 = fpext float %355 to double
  %357 = load float, ptr %2, align 4, !tbaa !5
  %358 = load float, ptr %9, align 4, !tbaa !5
  %359 = fsub float %357, %358
  %360 = fpext float %359 to double
  %361 = call double @llvm.fmuladd.f64(double %348, double %352, double 0.000000e+00)
  %362 = call double @sqrt(double noundef %361) #7
  %363 = load float, ptr %1, align 4, !tbaa !5
  %364 = fpext float %363 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 59, ptr noundef @.str.5, double noundef %362, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %364)
  br label %366

365:                                              ; preds = %341
  call void (...) @liquid_autotest_passed()
  br label %366

366:                                              ; preds = %365, %344
  call void @llvm.lifetime.start.p0(i64 64, ptr %10) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %10, ptr align 16 @__const.autotest_dotprod_rrrf_basic.x3, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #7
  store float 8.000000e+00, ptr %11, align 4, !tbaa !5
  %367 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %368 = getelementptr inbounds [16 x float], ptr %10, i64 0, i64 0
  %369 = call i32 @dotprod_rrrf_run(ptr noundef %367, ptr noundef %368, i32 noundef 16, ptr noundef %2)
  %370 = load float, ptr %2, align 4, !tbaa !5
  %371 = load float, ptr %11, align 4, !tbaa !5
  %372 = fsub float %370, %371
  %373 = fpext float %372 to double
  %374 = load float, ptr %2, align 4, !tbaa !5
  %375 = load float, ptr %11, align 4, !tbaa !5
  %376 = fsub float %374, %375
  %377 = fpext float %376 to double
  %378 = load float, ptr %2, align 4, !tbaa !5
  %379 = load float, ptr %11, align 4, !tbaa !5
  %380 = fsub float %378, %379
  %381 = fpext float %380 to double
  %382 = load float, ptr %2, align 4, !tbaa !5
  %383 = load float, ptr %11, align 4, !tbaa !5
  %384 = fsub float %382, %383
  %385 = fpext float %384 to double
  %386 = call double @llvm.fmuladd.f64(double %373, double %377, double 0.000000e+00)
  %387 = call double @sqrt(double noundef %386) #7
  %388 = load float, ptr %1, align 4, !tbaa !5
  %389 = fpext float %388 to double
  %390 = fcmp ogt double %387, %389
  br i1 %390, label %403, label %391

391:                                              ; preds = %366
  %392 = load float, ptr %2, align 4, !tbaa !5
  %393 = call i1 @llvm.is.fpclass.f32(float %392, i32 3)
  br i1 %393, label %403, label %394

394:                                              ; preds = %391
  %395 = load float, ptr %2, align 4, !tbaa !5
  %396 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %396, label %403, label %397

397:                                              ; preds = %394
  %398 = load float, ptr %11, align 4, !tbaa !5
  %399 = call i1 @llvm.is.fpclass.f32(float %398, i32 3)
  br i1 %399, label %403, label %400

400:                                              ; preds = %397
  %401 = load float, ptr %11, align 4, !tbaa !5
  %402 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %402, label %403, label %424

403:                                              ; preds = %400, %397, %394, %391, %366
  %404 = load float, ptr %2, align 4, !tbaa !5
  %405 = load float, ptr %11, align 4, !tbaa !5
  %406 = fsub float %404, %405
  %407 = fpext float %406 to double
  %408 = load float, ptr %2, align 4, !tbaa !5
  %409 = load float, ptr %11, align 4, !tbaa !5
  %410 = fsub float %408, %409
  %411 = fpext float %410 to double
  %412 = load float, ptr %2, align 4, !tbaa !5
  %413 = load float, ptr %11, align 4, !tbaa !5
  %414 = fsub float %412, %413
  %415 = fpext float %414 to double
  %416 = load float, ptr %2, align 4, !tbaa !5
  %417 = load float, ptr %11, align 4, !tbaa !5
  %418 = fsub float %416, %417
  %419 = fpext float %418 to double
  %420 = call double @llvm.fmuladd.f64(double %407, double %411, double 0.000000e+00)
  %421 = call double @sqrt(double noundef %420) #7
  %422 = load float, ptr %1, align 4, !tbaa !5
  %423 = fpext float %422 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 64, ptr noundef @.str.6, double noundef %421, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %423)
  br label %425

424:                                              ; preds = %400
  call void (...) @liquid_autotest_passed()
  br label %425

425:                                              ; preds = %424, %403
  %426 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %427 = getelementptr inbounds [16 x float], ptr %10, i64 0, i64 0
  %428 = call i32 @dotprod_rrrf_run4(ptr noundef %426, ptr noundef %427, i32 noundef 16, ptr noundef %2)
  %429 = load float, ptr %2, align 4, !tbaa !5
  %430 = load float, ptr %11, align 4, !tbaa !5
  %431 = fsub float %429, %430
  %432 = fpext float %431 to double
  %433 = load float, ptr %2, align 4, !tbaa !5
  %434 = load float, ptr %11, align 4, !tbaa !5
  %435 = fsub float %433, %434
  %436 = fpext float %435 to double
  %437 = load float, ptr %2, align 4, !tbaa !5
  %438 = load float, ptr %11, align 4, !tbaa !5
  %439 = fsub float %437, %438
  %440 = fpext float %439 to double
  %441 = load float, ptr %2, align 4, !tbaa !5
  %442 = load float, ptr %11, align 4, !tbaa !5
  %443 = fsub float %441, %442
  %444 = fpext float %443 to double
  %445 = call double @llvm.fmuladd.f64(double %432, double %436, double 0.000000e+00)
  %446 = call double @sqrt(double noundef %445) #7
  %447 = load float, ptr %1, align 4, !tbaa !5
  %448 = fpext float %447 to double
  %449 = fcmp ogt double %446, %448
  br i1 %449, label %462, label %450

450:                                              ; preds = %425
  %451 = load float, ptr %2, align 4, !tbaa !5
  %452 = call i1 @llvm.is.fpclass.f32(float %451, i32 3)
  br i1 %452, label %462, label %453

453:                                              ; preds = %450
  %454 = load float, ptr %2, align 4, !tbaa !5
  %455 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %455, label %462, label %456

456:                                              ; preds = %453
  %457 = load float, ptr %11, align 4, !tbaa !5
  %458 = call i1 @llvm.is.fpclass.f32(float %457, i32 3)
  br i1 %458, label %462, label %459

459:                                              ; preds = %456
  %460 = load float, ptr %11, align 4, !tbaa !5
  %461 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %461, label %462, label %483

462:                                              ; preds = %459, %456, %453, %450, %425
  %463 = load float, ptr %2, align 4, !tbaa !5
  %464 = load float, ptr %11, align 4, !tbaa !5
  %465 = fsub float %463, %464
  %466 = fpext float %465 to double
  %467 = load float, ptr %2, align 4, !tbaa !5
  %468 = load float, ptr %11, align 4, !tbaa !5
  %469 = fsub float %467, %468
  %470 = fpext float %469 to double
  %471 = load float, ptr %2, align 4, !tbaa !5
  %472 = load float, ptr %11, align 4, !tbaa !5
  %473 = fsub float %471, %472
  %474 = fpext float %473 to double
  %475 = load float, ptr %2, align 4, !tbaa !5
  %476 = load float, ptr %11, align 4, !tbaa !5
  %477 = fsub float %475, %476
  %478 = fpext float %477 to double
  %479 = call double @llvm.fmuladd.f64(double %466, double %470, double 0.000000e+00)
  %480 = call double @sqrt(double noundef %479) #7
  %481 = load float, ptr %1, align 4, !tbaa !5
  %482 = fpext float %481 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 66, ptr noundef @.str.6, double noundef %480, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %482)
  br label %484

483:                                              ; preds = %459
  call void (...) @liquid_autotest_passed()
  br label %484

484:                                              ; preds = %483, %462
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  store float 1.600000e+01, ptr %12, align 4, !tbaa !5
  %485 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %486 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %487 = call i32 @dotprod_rrrf_run(ptr noundef %485, ptr noundef %486, i32 noundef 16, ptr noundef %2)
  %488 = load float, ptr %2, align 4, !tbaa !5
  %489 = load float, ptr %12, align 4, !tbaa !5
  %490 = fsub float %488, %489
  %491 = fpext float %490 to double
  %492 = load float, ptr %2, align 4, !tbaa !5
  %493 = load float, ptr %12, align 4, !tbaa !5
  %494 = fsub float %492, %493
  %495 = fpext float %494 to double
  %496 = load float, ptr %2, align 4, !tbaa !5
  %497 = load float, ptr %12, align 4, !tbaa !5
  %498 = fsub float %496, %497
  %499 = fpext float %498 to double
  %500 = load float, ptr %2, align 4, !tbaa !5
  %501 = load float, ptr %12, align 4, !tbaa !5
  %502 = fsub float %500, %501
  %503 = fpext float %502 to double
  %504 = call double @llvm.fmuladd.f64(double %491, double %495, double 0.000000e+00)
  %505 = call double @sqrt(double noundef %504) #7
  %506 = load float, ptr %1, align 4, !tbaa !5
  %507 = fpext float %506 to double
  %508 = fcmp ogt double %505, %507
  br i1 %508, label %521, label %509

509:                                              ; preds = %484
  %510 = load float, ptr %2, align 4, !tbaa !5
  %511 = call i1 @llvm.is.fpclass.f32(float %510, i32 3)
  br i1 %511, label %521, label %512

512:                                              ; preds = %509
  %513 = load float, ptr %2, align 4, !tbaa !5
  %514 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %514, label %521, label %515

515:                                              ; preds = %512
  %516 = load float, ptr %12, align 4, !tbaa !5
  %517 = call i1 @llvm.is.fpclass.f32(float %516, i32 3)
  br i1 %517, label %521, label %518

518:                                              ; preds = %515
  %519 = load float, ptr %12, align 4, !tbaa !5
  %520 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %520, label %521, label %542

521:                                              ; preds = %518, %515, %512, %509, %484
  %522 = load float, ptr %2, align 4, !tbaa !5
  %523 = load float, ptr %12, align 4, !tbaa !5
  %524 = fsub float %522, %523
  %525 = fpext float %524 to double
  %526 = load float, ptr %2, align 4, !tbaa !5
  %527 = load float, ptr %12, align 4, !tbaa !5
  %528 = fsub float %526, %527
  %529 = fpext float %528 to double
  %530 = load float, ptr %2, align 4, !tbaa !5
  %531 = load float, ptr %12, align 4, !tbaa !5
  %532 = fsub float %530, %531
  %533 = fpext float %532 to double
  %534 = load float, ptr %2, align 4, !tbaa !5
  %535 = load float, ptr %12, align 4, !tbaa !5
  %536 = fsub float %534, %535
  %537 = fpext float %536 to double
  %538 = call double @llvm.fmuladd.f64(double %525, double %529, double 0.000000e+00)
  %539 = call double @sqrt(double noundef %538) #7
  %540 = load float, ptr %1, align 4, !tbaa !5
  %541 = fpext float %540 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 70, ptr noundef @.str.7, double noundef %539, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %541)
  br label %543

542:                                              ; preds = %518
  call void (...) @liquid_autotest_passed()
  br label %543

543:                                              ; preds = %542, %521
  %544 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %545 = getelementptr inbounds [16 x float], ptr %3, i64 0, i64 0
  %546 = call i32 @dotprod_rrrf_run4(ptr noundef %544, ptr noundef %545, i32 noundef 16, ptr noundef %2)
  %547 = load float, ptr %2, align 4, !tbaa !5
  %548 = load float, ptr %12, align 4, !tbaa !5
  %549 = fsub float %547, %548
  %550 = fpext float %549 to double
  %551 = load float, ptr %2, align 4, !tbaa !5
  %552 = load float, ptr %12, align 4, !tbaa !5
  %553 = fsub float %551, %552
  %554 = fpext float %553 to double
  %555 = load float, ptr %2, align 4, !tbaa !5
  %556 = load float, ptr %12, align 4, !tbaa !5
  %557 = fsub float %555, %556
  %558 = fpext float %557 to double
  %559 = load float, ptr %2, align 4, !tbaa !5
  %560 = load float, ptr %12, align 4, !tbaa !5
  %561 = fsub float %559, %560
  %562 = fpext float %561 to double
  %563 = call double @llvm.fmuladd.f64(double %550, double %554, double 0.000000e+00)
  %564 = call double @sqrt(double noundef %563) #7
  %565 = load float, ptr %1, align 4, !tbaa !5
  %566 = fpext float %565 to double
  %567 = fcmp ogt double %564, %566
  br i1 %567, label %580, label %568

568:                                              ; preds = %543
  %569 = load float, ptr %2, align 4, !tbaa !5
  %570 = call i1 @llvm.is.fpclass.f32(float %569, i32 3)
  br i1 %570, label %580, label %571

571:                                              ; preds = %568
  %572 = load float, ptr %2, align 4, !tbaa !5
  %573 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %573, label %580, label %574

574:                                              ; preds = %571
  %575 = load float, ptr %12, align 4, !tbaa !5
  %576 = call i1 @llvm.is.fpclass.f32(float %575, i32 3)
  br i1 %576, label %580, label %577

577:                                              ; preds = %574
  %578 = load float, ptr %12, align 4, !tbaa !5
  %579 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %579, label %580, label %601

580:                                              ; preds = %577, %574, %571, %568, %543
  %581 = load float, ptr %2, align 4, !tbaa !5
  %582 = load float, ptr %12, align 4, !tbaa !5
  %583 = fsub float %581, %582
  %584 = fpext float %583 to double
  %585 = load float, ptr %2, align 4, !tbaa !5
  %586 = load float, ptr %12, align 4, !tbaa !5
  %587 = fsub float %585, %586
  %588 = fpext float %587 to double
  %589 = load float, ptr %2, align 4, !tbaa !5
  %590 = load float, ptr %12, align 4, !tbaa !5
  %591 = fsub float %589, %590
  %592 = fpext float %591 to double
  %593 = load float, ptr %2, align 4, !tbaa !5
  %594 = load float, ptr %12, align 4, !tbaa !5
  %595 = fsub float %593, %594
  %596 = fpext float %595 to double
  %597 = call double @llvm.fmuladd.f64(double %584, double %588, double 0.000000e+00)
  %598 = call double @sqrt(double noundef %597) #7
  %599 = load float, ptr %1, align 4, !tbaa !5
  %600 = fpext float %599 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str, i32 noundef 72, ptr noundef @.str.7, double noundef %598, ptr noundef @.str.2, ptr noundef @.str.3, double noundef %600)
  br label %602

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

602:                                              ; preds = %601, %580
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %6) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr %3) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %1) #7
  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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

declare i32 @dotprod_rrrf_run(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #4

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

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

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

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

declare void @liquid_autotest_passed(...) #4

declare i32 @dotprod_rrrf_run4(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #4

; 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 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { "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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}


; 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_rrrf_basic.h = external hidden unnamed_addr constant [16 x float], align 16
@.str = external hidden unnamed_addr constant [96 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [17 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
@__const.autotest_dotprod_rrrf_basic.x1 = external hidden unnamed_addr constant [16 x float], align 16
@.str.4 = external hidden unnamed_addr constant [17 x i8], align 1
@__const.autotest_dotprod_rrrf_basic.x2 = external hidden unnamed_addr constant [16 x float], align 16
@.str.5 = external hidden unnamed_addr constant [17 x i8], align 1
@__const.autotest_dotprod_rrrf_basic.x3 = external hidden unnamed_addr constant [16 x float], align 16
@.str.6 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [17 x i8], align 1

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

13:                                               ; preds = %0
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 43, ptr noundef nonnull @.str.1, double noundef %sqrt, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %15

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

15:                                               ; preds = %14, %13
  %16 = call i32 @dotprod_rrrf_run4(ptr noundef nonnull %2, ptr noundef nonnull %3, i32 noundef 16, ptr noundef nonnull %1) #7
  %17 = load float, ptr %1, align 4
  %18 = fpext float %17 to double
  %19 = call double @llvm.fmuladd.f64(double %18, double %18, double 0.000000e+00)
  %sqrt140 = call double @llvm.sqrt.f64(double %19)
  %20 = fcmp ogt double %sqrt140, 0x3EB0C6F7A0000000
  %21 = fcmp uno float %17, 0.000000e+00
  %or.cond122 = select i1 %20, i1 true, i1 %21
  br i1 %or.cond122, label %22, label %23

22:                                               ; preds = %15
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 45, ptr noundef nonnull @.str.1, double noundef %sqrt140, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %24

23:                                               ; preds = %15
  call void (...) @liquid_autotest_passed() #7
  br label %24

24:                                               ; preds = %23, %22
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #7
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %4, ptr noundef nonnull align 16 dereferenceable(64) @__const.autotest_dotprod_rrrf_basic.x1, i64 64, i1 false)
  %25 = call i32 @dotprod_rrrf_run(ptr noundef nonnull %2, ptr noundef nonnull %4, i32 noundef 16, ptr noundef nonnull %1) #7
  %26 = load float, ptr %1, align 4
  %27 = fpext float %26 to double
  %28 = call double @llvm.fmuladd.f64(double %27, double %27, double 0.000000e+00)
  %sqrt142 = call double @llvm.sqrt.f64(double %28)
  %29 = fcmp ogt double %sqrt142, 0x3EB0C6F7A0000000
  %30 = fcmp uno float %26, 0.000000e+00
  %or.cond124 = select i1 %29, i1 true, i1 %30
  br i1 %or.cond124, label %31, label %32

31:                                               ; preds = %24
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 50, ptr noundef nonnull @.str.4, double noundef %sqrt142, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %33

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

33:                                               ; preds = %32, %31
  %34 = call i32 @dotprod_rrrf_run4(ptr noundef nonnull %2, ptr noundef nonnull %4, i32 noundef 16, ptr noundef nonnull %1) #7
  %35 = load float, ptr %1, align 4
  %36 = fpext float %35 to double
  %37 = call double @llvm.fmuladd.f64(double %36, double %36, double 0.000000e+00)
  %sqrt144 = call double @llvm.sqrt.f64(double %37)
  %38 = fcmp ogt double %sqrt144, 0x3EB0C6F7A0000000
  %39 = fcmp uno float %35, 0.000000e+00
  %or.cond126 = select i1 %38, i1 true, i1 %39
  br i1 %or.cond126, label %40, label %41

40:                                               ; preds = %33
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 52, ptr noundef nonnull @.str.4, double noundef %sqrt144, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %42

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

42:                                               ; preds = %41, %40
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #7
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %5, ptr noundef nonnull align 16 dereferenceable(64) @__const.autotest_dotprod_rrrf_basic.x2, i64 64, i1 false)
  %43 = call i32 @dotprod_rrrf_run(ptr noundef nonnull %2, ptr noundef nonnull %5, i32 noundef 16, ptr noundef nonnull %1) #7
  %44 = load float, ptr %1, align 4
  %45 = fadd float %44, 8.000000e+00
  %46 = fpext float %45 to double
  %47 = call double @llvm.fmuladd.f64(double %46, double %46, double 0.000000e+00)
  %sqrt146 = call double @llvm.sqrt.f64(double %47)
  %48 = fcmp ogt double %sqrt146, 0x3EB0C6F7A0000000
  %49 = fcmp uno float %44, 0.000000e+00
  %or.cond128 = select i1 %48, i1 true, i1 %49
  br i1 %or.cond128, label %50, label %51

50:                                               ; preds = %42
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 57, ptr noundef nonnull @.str.5, double noundef %sqrt146, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %52

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

52:                                               ; preds = %51, %50
  %53 = call i32 @dotprod_rrrf_run4(ptr noundef nonnull %2, ptr noundef nonnull %5, i32 noundef 16, ptr noundef nonnull %1) #7
  %54 = load float, ptr %1, align 4
  %55 = fadd float %54, 8.000000e+00
  %56 = fpext float %55 to double
  %57 = call double @llvm.fmuladd.f64(double %56, double %56, double 0.000000e+00)
  %sqrt148 = call double @llvm.sqrt.f64(double %57)
  %58 = fcmp ogt double %sqrt148, 0x3EB0C6F7A0000000
  %59 = fcmp uno float %54, 0.000000e+00
  %or.cond130 = select i1 %58, i1 true, i1 %59
  br i1 %or.cond130, label %60, label %61

60:                                               ; preds = %52
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 59, ptr noundef nonnull @.str.5, double noundef %sqrt148, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %62

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

62:                                               ; preds = %61, %60
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %6) #7
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %6, ptr noundef nonnull align 16 dereferenceable(64) @__const.autotest_dotprod_rrrf_basic.x3, i64 64, i1 false)
  %63 = call i32 @dotprod_rrrf_run(ptr noundef nonnull %2, ptr noundef nonnull %6, i32 noundef 16, ptr noundef nonnull %1) #7
  %64 = load float, ptr %1, align 4
  %65 = fadd float %64, -8.000000e+00
  %66 = fpext float %65 to double
  %67 = call double @llvm.fmuladd.f64(double %66, double %66, double 0.000000e+00)
  %sqrt150 = call double @llvm.sqrt.f64(double %67)
  %68 = fcmp ogt double %sqrt150, 0x3EB0C6F7A0000000
  %69 = fcmp uno float %64, 0.000000e+00
  %or.cond132 = select i1 %68, i1 true, i1 %69
  br i1 %or.cond132, label %70, label %71

70:                                               ; preds = %62
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 64, ptr noundef nonnull @.str.6, double noundef %sqrt150, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %72

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

72:                                               ; preds = %71, %70
  %73 = call i32 @dotprod_rrrf_run4(ptr noundef nonnull %2, ptr noundef nonnull %6, i32 noundef 16, ptr noundef nonnull %1) #7
  %74 = load float, ptr %1, align 4
  %75 = fadd float %74, -8.000000e+00
  %76 = fpext float %75 to double
  %77 = call double @llvm.fmuladd.f64(double %76, double %76, double 0.000000e+00)
  %sqrt152 = call double @llvm.sqrt.f64(double %77)
  %78 = fcmp ogt double %sqrt152, 0x3EB0C6F7A0000000
  %79 = fcmp uno float %74, 0.000000e+00
  %or.cond134 = select i1 %78, i1 true, i1 %79
  br i1 %or.cond134, label %80, label %81

80:                                               ; preds = %72
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 66, ptr noundef nonnull @.str.6, double noundef %sqrt152, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %82

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

82:                                               ; preds = %81, %80
  %83 = call i32 @dotprod_rrrf_run(ptr noundef nonnull %2, ptr noundef nonnull %2, i32 noundef 16, ptr noundef nonnull %1) #7
  %84 = load float, ptr %1, align 4
  %85 = fadd float %84, -1.600000e+01
  %86 = fpext float %85 to double
  %87 = call double @llvm.fmuladd.f64(double %86, double %86, double 0.000000e+00)
  %sqrt154 = call double @llvm.sqrt.f64(double %87)
  %88 = fcmp ogt double %sqrt154, 0x3EB0C6F7A0000000
  %89 = fcmp uno float %84, 0.000000e+00
  %or.cond136 = select i1 %88, i1 true, i1 %89
  br i1 %or.cond136, label %90, label %91

90:                                               ; preds = %82
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 70, ptr noundef nonnull @.str.7, double noundef %sqrt154, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %92

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

92:                                               ; preds = %91, %90
  %93 = call i32 @dotprod_rrrf_run4(ptr noundef nonnull %2, ptr noundef nonnull %2, i32 noundef 16, ptr noundef nonnull %1) #7
  %94 = load float, ptr %1, align 4
  %95 = fadd float %94, -1.600000e+01
  %96 = fpext float %95 to double
  %97 = call double @llvm.fmuladd.f64(double %96, double %96, double 0.000000e+00)
  %sqrt156 = call double @llvm.sqrt.f64(double %97)
  %98 = fcmp ogt double %sqrt156, 0x3EB0C6F7A0000000
  %99 = fcmp uno float %94, 0.000000e+00
  %or.cond138 = select i1 %98, i1 true, i1 %99
  br i1 %or.cond138, label %100, label %101

100:                                              ; preds = %92
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str, i32 noundef 72, ptr noundef nonnull @.str.7, double noundef %sqrt156, ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.3, double noundef 0x3EB0C6F7A0000000) #7
  br label %102

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

102:                                              ; preds = %101, %100
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %6) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %3) #7
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %2) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %1) #7
  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

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

declare i32 @dotprod_rrrf_run(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #4

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

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

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

declare i32 @dotprod_rrrf_run4(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #4

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

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


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