; LLVM IR from jgaeddert/liquid-dsp :: src/multichannel/tests (firpfbch_crcf_synthesizer_autotest)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@.str = external hidden unnamed_addr constant [14 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [114 x i8], align 1
@__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis = external hidden unnamed_addr constant [40 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [15 x i8], align 1
@liquid_autotest_verbose = external global i32, align 4
@.str.3 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [37 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @autotest_firpfbch_crcf_synthesis() #0 {
  %1 = alloca float, align 4
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca i64, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i64, align 8
  %15 = alloca i64, align 8
  %16 = alloca i64, align 8
  %17 = alloca i64, align 8
  %18 = alloca i32, align 4
  %19 = alloca float, align 4
  %20 = alloca { float, float }, align 4
  %21 = alloca { float, float }, align 4
  %22 = alloca { float, float }, align 4
  %23 = alloca { float, float }, align 4
  %24 = alloca { float, float }, align 4
  %25 = alloca { float, float }, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %1) #7
  store float 0x3F1A36E2E0000000, ptr %1, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #7
  store i32 4, ptr %2, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #7
  store i32 5, ptr %3, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #7
  store i32 40, ptr %4, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #7
  %26 = load i32, ptr %2, align 4, !tbaa !9
  %27 = load i32, ptr %4, align 4, !tbaa !9
  %28 = mul i32 %26, %27
  store i32 %28, ptr %5, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #7
  %29 = load i32, ptr %3, align 4, !tbaa !9
  %30 = load i32, ptr %2, align 4, !tbaa !9
  %31 = mul i32 %29, %30
  store i32 %31, ptr %8, align 4, !tbaa !9
  %32 = load i32, ptr %8, align 4, !tbaa !9
  %33 = zext i32 %32 to i64
  %34 = call ptr @llvm.stacksave.p0()
  store ptr %34, ptr %9, align 8
  %35 = alloca float, i64 %33, align 16
  store i64 %33, ptr %10, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #7
  %36 = call ptr @msequence_create_default(i32 noundef 6)
  store ptr %36, ptr %11, align 8, !tbaa !11
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %37

37:                                               ; preds = %49, %0
  %38 = load i32, ptr %6, align 4, !tbaa !9
  %39 = load i32, ptr %8, align 4, !tbaa !9
  %40 = icmp ult i32 %38, %39
  br i1 %40, label %41, label %52

41:                                               ; preds = %37
  %42 = load ptr, ptr %11, align 8, !tbaa !11
  %43 = call i32 @msequence_generate_symbol(ptr noundef %42, i32 noundef 2)
  %44 = uitofp i32 %43 to float
  %45 = fsub float %44, 1.500000e+00
  %46 = load i32, ptr %6, align 4, !tbaa !9
  %47 = zext i32 %46 to i64
  %48 = getelementptr inbounds float, ptr %35, i64 %47
  store float %45, ptr %48, align 4, !tbaa !5
  br label %49

49:                                               ; preds = %41
  %50 = load i32, ptr %6, align 4, !tbaa !9
  %51 = add i32 %50, 1
  store i32 %51, ptr %6, align 4, !tbaa !9
  br label %37, !llvm.loop !13

52:                                               ; preds = %37
  %53 = load ptr, ptr %11, align 8, !tbaa !11
  %54 = call i32 @msequence_destroy(ptr noundef %53)
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #7
  %55 = load i32, ptr %8, align 4, !tbaa !9
  %56 = call ptr @firfilt_crcf_create(ptr noundef %35, i32 noundef %55)
  store ptr %56, ptr %12, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #7
  %57 = load i32, ptr %2, align 4, !tbaa !9
  %58 = load i32, ptr %3, align 4, !tbaa !9
  %59 = call ptr @firpfbch_crcf_create(i32 noundef 1, i32 noundef %57, i32 noundef %58, ptr noundef %35)
  store ptr %59, ptr %13, align 8, !tbaa !11
  %60 = load i32, ptr %4, align 4, !tbaa !9
  %61 = zext i32 %60 to i64
  %62 = load i32, ptr %2, align 4, !tbaa !9
  %63 = zext i32 %62 to i64
  %64 = mul nuw i64 %61, %63
  %65 = alloca { float, float }, i64 %64, align 16
  store i64 %61, ptr %14, align 8
  store i64 %63, ptr %15, align 8
  %66 = load i32, ptr %5, align 4, !tbaa !9
  %67 = zext i32 %66 to i64
  %68 = alloca { float, float }, i64 %67, align 16
  store i64 %67, ptr %16, align 8
  %69 = load i32, ptr %5, align 4, !tbaa !9
  %70 = zext i32 %69 to i64
  %71 = alloca { float, float }, i64 %70, align 16
  store i64 %70, ptr %17, align 8
  %72 = call ptr @msequence_create_default(i32 noundef 7)
  store ptr %72, ptr %11, align 8, !tbaa !11
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %73

73:                                               ; preds = %113, %52
  %74 = load i32, ptr %6, align 4, !tbaa !9
  %75 = load i32, ptr %4, align 4, !tbaa !9
  %76 = icmp ult i32 %74, %75
  br i1 %76, label %77, label %116

77:                                               ; preds = %73
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %78

78:                                               ; preds = %109, %77
  %79 = load i32, ptr %7, align 4, !tbaa !9
  %80 = load i32, ptr %2, align 4, !tbaa !9
  %81 = icmp ult i32 %79, %80
  br i1 %81, label %82, label %112

82:                                               ; preds = %78
  %83 = load ptr, ptr %11, align 8, !tbaa !11
  %84 = call i32 @msequence_generate_symbol(ptr noundef %83, i32 noundef 2)
  %85 = uitofp i32 %84 to float
  %86 = fsub float %85, 1.500000e+00
  %87 = fpext float %86 to double
  %88 = fmul double 0x3FB21A185685E91F, %87
  %89 = load ptr, ptr %11, align 8, !tbaa !11
  %90 = call i32 @msequence_generate_symbol(ptr noundef %89, i32 noundef 2)
  %91 = uitofp i32 %90 to float
  %92 = fsub float %91, 1.500000e+00
  %93 = fpext float %92 to double
  %94 = fmul double 0x3FB21A185685E91F, %93
  %95 = fmul double %94, 0.000000e+00
  %96 = fmul double %94, 1.000000e+00
  %97 = fadd double %88, %95
  %98 = fptrunc double %97 to float
  %99 = fptrunc double %96 to float
  %100 = load i32, ptr %6, align 4, !tbaa !9
  %101 = zext i32 %100 to i64
  %102 = mul nsw i64 %101, %63
  %103 = getelementptr inbounds { float, float }, ptr %65, i64 %102
  %104 = load i32, ptr %7, align 4, !tbaa !9
  %105 = zext i32 %104 to i64
  %106 = getelementptr inbounds { float, float }, ptr %103, i64 %105
  %107 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 0
  %108 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 1
  store float %98, ptr %107, align 8
  store float %99, ptr %108, align 4
  br label %109

109:                                              ; preds = %82
  %110 = load i32, ptr %7, align 4, !tbaa !9
  %111 = add i32 %110, 1
  store i32 %111, ptr %7, align 4, !tbaa !9
  br label %78, !llvm.loop !15

112:                                              ; preds = %78
  br label %113

113:                                              ; preds = %112
  %114 = load i32, ptr %6, align 4, !tbaa !9
  %115 = add i32 %114, 1
  store i32 %115, ptr %6, align 4, !tbaa !9
  br label %73, !llvm.loop !16

116:                                              ; preds = %73
  %117 = load ptr, ptr %11, align 8, !tbaa !11
  %118 = call i32 @msequence_destroy(ptr noundef %117)
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %119

119:                                              ; preds = %136, %116
  %120 = load i32, ptr %6, align 4, !tbaa !9
  %121 = load i32, ptr %4, align 4, !tbaa !9
  %122 = icmp ult i32 %120, %121
  br i1 %122, label %123, label %139

123:                                              ; preds = %119
  %124 = load ptr, ptr %13, align 8, !tbaa !11
  %125 = load i32, ptr %6, align 4, !tbaa !9
  %126 = zext i32 %125 to i64
  %127 = mul nsw i64 %126, %63
  %128 = getelementptr inbounds { float, float }, ptr %65, i64 %127
  %129 = getelementptr inbounds { float, float }, ptr %128, i64 0
  %130 = load i32, ptr %6, align 4, !tbaa !9
  %131 = load i32, ptr %2, align 4, !tbaa !9
  %132 = mul i32 %130, %131
  %133 = zext i32 %132 to i64
  %134 = getelementptr inbounds { float, float }, ptr %68, i64 %133
  %135 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %124, ptr noundef %129, ptr noundef %134)
  br label %136

136:                                              ; preds = %123
  %137 = load i32, ptr %6, align 4, !tbaa !9
  %138 = add i32 %137, 1
  store i32 %138, ptr %6, align 4, !tbaa !9
  br label %119, !llvm.loop !17

139:                                              ; preds = %119
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %140

140:                                              ; preds = %150, %139
  %141 = load i32, ptr %6, align 4, !tbaa !9
  %142 = load i32, ptr %5, align 4, !tbaa !9
  %143 = icmp ult i32 %141, %142
  br i1 %143, label %144, label %153

144:                                              ; preds = %140
  %145 = load i32, ptr %6, align 4, !tbaa !9
  %146 = zext i32 %145 to i64
  %147 = getelementptr inbounds { float, float }, ptr %71, i64 %146
  %148 = getelementptr inbounds { float, float }, ptr %147, i32 0, i32 0
  %149 = getelementptr inbounds { float, float }, ptr %147, i32 0, i32 1
  store float 0.000000e+00, ptr %148, align 8
  store float 0.000000e+00, ptr %149, align 4
  br label %150

150:                                              ; preds = %144
  %151 = load i32, ptr %6, align 4, !tbaa !9
  %152 = add i32 %151, 1
  store i32 %152, ptr %6, align 4, !tbaa !9
  br label %140, !llvm.loop !18

153:                                              ; preds = %140
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #7
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %154

154:                                              ; preds = %271, %153
  %155 = load i32, ptr %6, align 4, !tbaa !9
  %156 = load i32, ptr %2, align 4, !tbaa !9
  %157 = icmp ult i32 %155, %156
  br i1 %157, label %158, label %274

158:                                              ; preds = %154
  %159 = load ptr, ptr %12, align 8, !tbaa !11
  %160 = call i32 @firfilt_crcf_reset(ptr noundef %159)
  %161 = load i32, ptr %6, align 4, !tbaa !9
  %162 = uitofp i32 %161 to float
  %163 = fpext float %162 to double
  %164 = fmul double 0x401921FB54442D18, %163
  %165 = load i32, ptr %2, align 4, !tbaa !9
  %166 = uitofp i32 %165 to float
  %167 = fpext float %166 to double
  %168 = fdiv double %164, %167
  %169 = fptrunc double %168 to float
  store float %169, ptr %19, align 4, !tbaa !5
  store i32 0, ptr %18, align 4, !tbaa !9
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %170

170:                                              ; preds = %261, %158
  %171 = load i32, ptr %7, align 4, !tbaa !9
  %172 = load i32, ptr %5, align 4, !tbaa !9
  %173 = icmp ult i32 %171, %172
  br i1 %173, label %174, label %264

174:                                              ; preds = %170
  %175 = load i32, ptr %7, align 4, !tbaa !9
  %176 = load i32, ptr %2, align 4, !tbaa !9
  %177 = urem i32 %175, %176
  %178 = icmp eq i32 %177, 0
  br i1 %178, label %179, label %204

179:                                              ; preds = %174
  %180 = load i32, ptr %18, align 4, !tbaa !9
  %181 = load i32, ptr %4, align 4, !tbaa !9
  %182 = icmp ult i32 %180, %181
  br i1 %182, label %183, label %184

183:                                              ; preds = %179
  br label %185

184:                                              ; preds = %179
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 108, ptr noundef @__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis) #8
  unreachable

185:                                              ; preds = %183
  %186 = load ptr, ptr %12, align 8, !tbaa !11
  %187 = load i32, ptr %18, align 4, !tbaa !9
  %188 = zext i32 %187 to i64
  %189 = mul nsw i64 %188, %63
  %190 = getelementptr inbounds { float, float }, ptr %65, i64 %189
  %191 = load i32, ptr %6, align 4, !tbaa !9
  %192 = zext i32 %191 to i64
  %193 = getelementptr inbounds { float, float }, ptr %190, i64 %192
  %194 = getelementptr inbounds { float, float }, ptr %193, i32 0, i32 0
  %195 = load float, ptr %194, align 8
  %196 = getelementptr inbounds { float, float }, ptr %193, i32 0, i32 1
  %197 = load float, ptr %196, align 4
  %198 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 0
  %199 = getelementptr inbounds { float, float }, ptr %21, i32 0, i32 1
  store float %195, ptr %198, align 4
  store float %197, ptr %199, align 4
  %200 = load <2 x float>, ptr %21, align 4
  %201 = call i32 @firfilt_crcf_push(ptr noundef %186, <2 x float> noundef %200)
  %202 = load i32, ptr %18, align 4, !tbaa !9
  %203 = add i32 %202, 1
  store i32 %203, ptr %18, align 4, !tbaa !9
  br label %210

204:                                              ; preds = %174
  %205 = load ptr, ptr %12, align 8, !tbaa !11
  %206 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 0
  %207 = getelementptr inbounds { float, float }, ptr %22, i32 0, i32 1
  store float 0.000000e+00, ptr %206, align 4
  store float 0.000000e+00, ptr %207, align 4
  %208 = load <2 x float>, ptr %22, align 4
  %209 = call i32 @firfilt_crcf_push(ptr noundef %205, <2 x float> noundef %208)
  br label %210

210:                                              ; preds = %204, %185
  %211 = load ptr, ptr %12, align 8, !tbaa !11
  %212 = call i32 @firfilt_crcf_execute(ptr noundef %211, ptr noundef %20)
  %213 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 0
  %214 = load float, ptr %213, align 4
  %215 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 1
  %216 = load float, ptr %215, align 4
  %217 = load i32, ptr %7, align 4, !tbaa !9
  %218 = uitofp i32 %217 to float
  %219 = fmul float 0.000000e+00, %218
  %220 = fmul float 1.000000e+00, %218
  %221 = load float, ptr %19, align 4, !tbaa !5
  %222 = fmul float %219, %221
  %223 = fmul float %220, %221
  %224 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 0
  %225 = getelementptr inbounds { float, float }, ptr %23, i32 0, i32 1
  store float %222, ptr %224, align 4
  store float %223, ptr %225, align 4
  %226 = load <2 x float>, ptr %23, align 4
  %227 = call <2 x float> @cexpf(<2 x float> noundef %226) #7
  store <2 x float> %227, ptr %24, align 4
  %228 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 0
  %229 = load float, ptr %228, align 4
  %230 = getelementptr inbounds { float, float }, ptr %24, i32 0, i32 1
  %231 = load float, ptr %230, align 4
  %232 = fmul float %214, %229
  %233 = fmul float %216, %231
  %234 = fmul float %214, %231
  %235 = fmul float %216, %229
  %236 = fsub float %232, %233
  %237 = fadd float %234, %235
  %238 = fcmp uno float %236, %236
  br i1 %238, label %239, label %247, !prof !19

239:                                              ; preds = %210
  %240 = fcmp uno float %237, %237
  br i1 %240, label %241, label %247, !prof !19

241:                                              ; preds = %239
  %242 = call <2 x float> @__mulsc3(float noundef %214, float noundef %216, float noundef %229, float noundef %231) #7
  store <2 x float> %242, ptr %25, align 4
  %243 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 0
  %244 = load float, ptr %243, align 4
  %245 = getelementptr inbounds { float, float }, ptr %25, i32 0, i32 1
  %246 = load float, ptr %245, align 4
  br label %247

247:                                              ; preds = %241, %239, %210
  %248 = phi float [ %236, %210 ], [ %236, %239 ], [ %244, %241 ]
  %249 = phi float [ %237, %210 ], [ %237, %239 ], [ %246, %241 ]
  %250 = load i32, ptr %7, align 4, !tbaa !9
  %251 = zext i32 %250 to i64
  %252 = getelementptr inbounds { float, float }, ptr %71, i64 %251
  %253 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 0
  %254 = load float, ptr %253, align 8
  %255 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 1
  %256 = load float, ptr %255, align 4
  %257 = fadd float %254, %248
  %258 = fadd float %256, %249
  %259 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 0
  %260 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 1
  store float %257, ptr %259, align 8
  store float %258, ptr %260, align 4
  br label %261

261:                                              ; preds = %247
  %262 = load i32, ptr %7, align 4, !tbaa !9
  %263 = add i32 %262, 1
  store i32 %263, ptr %7, align 4, !tbaa !9
  br label %170, !llvm.loop !20

264:                                              ; preds = %170
  %265 = load i32, ptr %18, align 4, !tbaa !9
  %266 = load i32, ptr %4, align 4, !tbaa !9
  %267 = icmp eq i32 %265, %266
  br i1 %267, label %268, label %269

268:                                              ; preds = %264
  br label %270

269:                                              ; preds = %264
  call void @__assert_fail(ptr noundef @.str.2, ptr noundef @.str.1, i32 noundef 119, ptr noundef @__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis) #8
  unreachable

270:                                              ; preds = %268
  br label %271

271:                                              ; preds = %270
  %272 = load i32, ptr %6, align 4, !tbaa !9
  %273 = add i32 %272, 1
  store i32 %273, ptr %6, align 4, !tbaa !9
  br label %154, !llvm.loop !21

274:                                              ; preds = %154
  %275 = load ptr, ptr %12, align 8, !tbaa !11
  %276 = call i32 @firfilt_crcf_destroy(ptr noundef %275)
  %277 = load ptr, ptr %13, align 8, !tbaa !11
  %278 = call i32 @firpfbch_crcf_destroy(ptr noundef %277)
  store i32 0, ptr %6, align 4, !tbaa !9
  br label %279

279:                                              ; preds = %708, %274
  %280 = load i32, ptr %6, align 4, !tbaa !9
  %281 = load i32, ptr %5, align 4, !tbaa !9
  %282 = icmp ult i32 %280, %281
  br i1 %282, label %283, label %711

283:                                              ; preds = %279
  %284 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !9
  %285 = icmp ne i32 %284, 0
  br i1 %285, label %286, label %355

286:                                              ; preds = %283
  %287 = load i32, ptr %6, align 4, !tbaa !9
  %288 = load i32, ptr %6, align 4, !tbaa !9
  %289 = zext i32 %288 to i64
  %290 = getelementptr inbounds { float, float }, ptr %68, i64 %289
  %291 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 0
  %292 = load float, ptr %291, align 8
  %293 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 1
  %294 = load float, ptr %293, align 4
  %295 = fpext float %292 to double
  %296 = load i32, ptr %6, align 4, !tbaa !9
  %297 = zext i32 %296 to i64
  %298 = getelementptr inbounds { float, float }, ptr %68, i64 %297
  %299 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 0
  %300 = load float, ptr %299, align 8
  %301 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 1
  %302 = load float, ptr %301, align 4
  %303 = fpext float %302 to double
  %304 = load i32, ptr %6, align 4, !tbaa !9
  %305 = zext i32 %304 to i64
  %306 = getelementptr inbounds { float, float }, ptr %71, i64 %305
  %307 = getelementptr inbounds { float, float }, ptr %306, i32 0, i32 0
  %308 = load float, ptr %307, align 8
  %309 = getelementptr inbounds { float, float }, ptr %306, i32 0, i32 1
  %310 = load float, ptr %309, align 4
  %311 = fpext float %308 to double
  %312 = load i32, ptr %6, align 4, !tbaa !9
  %313 = zext i32 %312 to i64
  %314 = getelementptr inbounds { float, float }, ptr %71, i64 %313
  %315 = getelementptr inbounds { float, float }, ptr %314, i32 0, i32 0
  %316 = load float, ptr %315, align 8
  %317 = getelementptr inbounds { float, float }, ptr %314, i32 0, i32 1
  %318 = load float, ptr %317, align 4
  %319 = fpext float %318 to double
  %320 = load i32, ptr %6, align 4, !tbaa !9
  %321 = zext i32 %320 to i64
  %322 = getelementptr inbounds { float, float }, ptr %71, i64 %321
  %323 = getelementptr inbounds { float, float }, ptr %322, i32 0, i32 0
  %324 = load float, ptr %323, align 8
  %325 = getelementptr inbounds { float, float }, ptr %322, i32 0, i32 1
  %326 = load float, ptr %325, align 4
  %327 = load i32, ptr %6, align 4, !tbaa !9
  %328 = zext i32 %327 to i64
  %329 = getelementptr inbounds { float, float }, ptr %68, i64 %328
  %330 = getelementptr inbounds { float, float }, ptr %329, i32 0, i32 0
  %331 = load float, ptr %330, align 8
  %332 = getelementptr inbounds { float, float }, ptr %329, i32 0, i32 1
  %333 = load float, ptr %332, align 4
  %334 = fsub float %324, %331
  %335 = fsub float %326, %333
  %336 = fpext float %334 to double
  %337 = load i32, ptr %6, align 4, !tbaa !9
  %338 = zext i32 %337 to i64
  %339 = getelementptr inbounds { float, float }, ptr %71, i64 %338
  %340 = getelementptr inbounds { float, float }, ptr %339, i32 0, i32 0
  %341 = load float, ptr %340, align 8
  %342 = getelementptr inbounds { float, float }, ptr %339, i32 0, i32 1
  %343 = load float, ptr %342, align 4
  %344 = load i32, ptr %6, align 4, !tbaa !9
  %345 = zext i32 %344 to i64
  %346 = getelementptr inbounds { float, float }, ptr %68, i64 %345
  %347 = getelementptr inbounds { float, float }, ptr %346, i32 0, i32 0
  %348 = load float, ptr %347, align 8
  %349 = getelementptr inbounds { float, float }, ptr %346, i32 0, i32 1
  %350 = load float, ptr %349, align 4
  %351 = fsub float %341, %348
  %352 = fsub float %343, %350
  %353 = fpext float %352 to double
  %354 = call i32 (ptr, ...) @printf(ptr noundef @.str.3, i32 noundef %287, double noundef %295, double noundef %303, double noundef %311, double noundef %319, double noundef %336, double noundef %353)
  br label %355

355:                                              ; preds = %286, %283
  %356 = load i32, ptr %6, align 4, !tbaa !9
  %357 = zext i32 %356 to i64
  %358 = getelementptr inbounds { float, float }, ptr %68, i64 %357
  %359 = getelementptr inbounds { float, float }, ptr %358, i32 0, i32 0
  %360 = load float, ptr %359, align 8
  %361 = getelementptr inbounds { float, float }, ptr %358, i32 0, i32 1
  %362 = load float, ptr %361, align 4
  %363 = load i32, ptr %6, align 4, !tbaa !9
  %364 = zext i32 %363 to i64
  %365 = getelementptr inbounds { float, float }, ptr %71, i64 %364
  %366 = getelementptr inbounds { float, float }, ptr %365, i32 0, i32 0
  %367 = load float, ptr %366, align 8
  %368 = getelementptr inbounds { float, float }, ptr %365, i32 0, i32 1
  %369 = load float, ptr %368, align 4
  %370 = fsub float %360, %367
  %371 = fpext float %370 to double
  %372 = load i32, ptr %6, align 4, !tbaa !9
  %373 = zext i32 %372 to i64
  %374 = getelementptr inbounds { float, float }, ptr %68, i64 %373
  %375 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 0
  %376 = load float, ptr %375, align 8
  %377 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 1
  %378 = load float, ptr %377, align 4
  %379 = load i32, ptr %6, align 4, !tbaa !9
  %380 = zext i32 %379 to i64
  %381 = getelementptr inbounds { float, float }, ptr %71, i64 %380
  %382 = getelementptr inbounds { float, float }, ptr %381, i32 0, i32 0
  %383 = load float, ptr %382, align 8
  %384 = getelementptr inbounds { float, float }, ptr %381, i32 0, i32 1
  %385 = load float, ptr %384, align 4
  %386 = fsub float %376, %383
  %387 = fpext float %386 to double
  %388 = load i32, ptr %6, align 4, !tbaa !9
  %389 = zext i32 %388 to i64
  %390 = getelementptr inbounds { float, float }, ptr %68, i64 %389
  %391 = getelementptr inbounds { float, float }, ptr %390, i32 0, i32 0
  %392 = load float, ptr %391, align 8
  %393 = getelementptr inbounds { float, float }, ptr %390, i32 0, i32 1
  %394 = load float, ptr %393, align 4
  %395 = load i32, ptr %6, align 4, !tbaa !9
  %396 = zext i32 %395 to i64
  %397 = getelementptr inbounds { float, float }, ptr %71, i64 %396
  %398 = getelementptr inbounds { float, float }, ptr %397, i32 0, i32 0
  %399 = load float, ptr %398, align 8
  %400 = getelementptr inbounds { float, float }, ptr %397, i32 0, i32 1
  %401 = load float, ptr %400, align 4
  %402 = fsub float %392, %399
  %403 = fpext float %402 to double
  %404 = load i32, ptr %6, align 4, !tbaa !9
  %405 = zext i32 %404 to i64
  %406 = getelementptr inbounds { float, float }, ptr %68, i64 %405
  %407 = getelementptr inbounds { float, float }, ptr %406, i32 0, i32 0
  %408 = load float, ptr %407, align 8
  %409 = getelementptr inbounds { float, float }, ptr %406, i32 0, i32 1
  %410 = load float, ptr %409, align 4
  %411 = load i32, ptr %6, align 4, !tbaa !9
  %412 = zext i32 %411 to i64
  %413 = getelementptr inbounds { float, float }, ptr %71, i64 %412
  %414 = getelementptr inbounds { float, float }, ptr %413, i32 0, i32 0
  %415 = load float, ptr %414, align 8
  %416 = getelementptr inbounds { float, float }, ptr %413, i32 0, i32 1
  %417 = load float, ptr %416, align 4
  %418 = fsub float %408, %415
  %419 = fpext float %418 to double
  %420 = call double @llvm.fmuladd.f64(double %371, double %387, 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
  %424 = fcmp ogt double %421, %423
  br i1 %424, label %461, label %425

425:                                              ; preds = %355
  %426 = load i32, ptr %6, align 4, !tbaa !9
  %427 = zext i32 %426 to i64
  %428 = getelementptr inbounds { float, float }, ptr %68, i64 %427
  %429 = getelementptr inbounds { float, float }, ptr %428, i32 0, i32 0
  %430 = load float, ptr %429, align 8
  %431 = getelementptr inbounds { float, float }, ptr %428, i32 0, i32 1
  %432 = load float, ptr %431, align 4
  %433 = call i1 @llvm.is.fpclass.f32(float %430, i32 3)
  br i1 %433, label %461, label %434

434:                                              ; preds = %425
  %435 = load i32, ptr %6, align 4, !tbaa !9
  %436 = zext i32 %435 to i64
  %437 = getelementptr inbounds { float, float }, ptr %68, i64 %436
  %438 = getelementptr inbounds { float, float }, ptr %437, i32 0, i32 0
  %439 = load float, ptr %438, align 8
  %440 = getelementptr inbounds { float, float }, ptr %437, i32 0, i32 1
  %441 = load float, ptr %440, align 4
  %442 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %442, label %461, label %443

443:                                              ; preds = %434
  %444 = load i32, ptr %6, align 4, !tbaa !9
  %445 = zext i32 %444 to i64
  %446 = getelementptr inbounds { float, float }, ptr %71, i64 %445
  %447 = getelementptr inbounds { float, float }, ptr %446, i32 0, i32 0
  %448 = load float, ptr %447, align 8
  %449 = getelementptr inbounds { float, float }, ptr %446, i32 0, i32 1
  %450 = load float, ptr %449, align 4
  %451 = call i1 @llvm.is.fpclass.f32(float %448, i32 3)
  br i1 %451, label %461, label %452

452:                                              ; preds = %443
  %453 = load i32, ptr %6, align 4, !tbaa !9
  %454 = zext i32 %453 to i64
  %455 = getelementptr inbounds { float, float }, ptr %71, i64 %454
  %456 = getelementptr inbounds { float, float }, ptr %455, i32 0, i32 0
  %457 = load float, ptr %456, align 8
  %458 = getelementptr inbounds { float, float }, ptr %455, i32 0, i32 1
  %459 = load float, ptr %458, align 4
  %460 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %460, label %461, label %530

461:                                              ; preds = %452, %443, %434, %425, %355
  %462 = load i32, ptr %6, align 4, !tbaa !9
  %463 = zext i32 %462 to i64
  %464 = getelementptr inbounds { float, float }, ptr %68, i64 %463
  %465 = getelementptr inbounds { float, float }, ptr %464, i32 0, i32 0
  %466 = load float, ptr %465, align 8
  %467 = getelementptr inbounds { float, float }, ptr %464, i32 0, i32 1
  %468 = load float, ptr %467, align 4
  %469 = load i32, ptr %6, align 4, !tbaa !9
  %470 = zext i32 %469 to i64
  %471 = getelementptr inbounds { float, float }, ptr %71, i64 %470
  %472 = getelementptr inbounds { float, float }, ptr %471, i32 0, i32 0
  %473 = load float, ptr %472, align 8
  %474 = getelementptr inbounds { float, float }, ptr %471, i32 0, i32 1
  %475 = load float, ptr %474, align 4
  %476 = fsub float %466, %473
  %477 = fpext float %476 to double
  %478 = load i32, ptr %6, align 4, !tbaa !9
  %479 = zext i32 %478 to i64
  %480 = getelementptr inbounds { float, float }, ptr %68, i64 %479
  %481 = getelementptr inbounds { float, float }, ptr %480, i32 0, i32 0
  %482 = load float, ptr %481, align 8
  %483 = getelementptr inbounds { float, float }, ptr %480, i32 0, i32 1
  %484 = load float, ptr %483, align 4
  %485 = load i32, ptr %6, align 4, !tbaa !9
  %486 = zext i32 %485 to i64
  %487 = getelementptr inbounds { float, float }, ptr %71, i64 %486
  %488 = getelementptr inbounds { float, float }, ptr %487, i32 0, i32 0
  %489 = load float, ptr %488, align 8
  %490 = getelementptr inbounds { float, float }, ptr %487, i32 0, i32 1
  %491 = load float, ptr %490, align 4
  %492 = fsub float %482, %489
  %493 = fpext float %492 to double
  %494 = load i32, ptr %6, align 4, !tbaa !9
  %495 = zext i32 %494 to i64
  %496 = getelementptr inbounds { float, float }, ptr %68, i64 %495
  %497 = getelementptr inbounds { float, float }, ptr %496, i32 0, i32 0
  %498 = load float, ptr %497, align 8
  %499 = getelementptr inbounds { float, float }, ptr %496, i32 0, i32 1
  %500 = load float, ptr %499, align 4
  %501 = load i32, ptr %6, align 4, !tbaa !9
  %502 = zext i32 %501 to i64
  %503 = getelementptr inbounds { float, float }, ptr %71, i64 %502
  %504 = getelementptr inbounds { float, float }, ptr %503, i32 0, i32 0
  %505 = load float, ptr %504, align 8
  %506 = getelementptr inbounds { float, float }, ptr %503, i32 0, i32 1
  %507 = load float, ptr %506, align 4
  %508 = fsub float %498, %505
  %509 = fpext float %508 to double
  %510 = load i32, ptr %6, align 4, !tbaa !9
  %511 = zext i32 %510 to i64
  %512 = getelementptr inbounds { float, float }, ptr %68, i64 %511
  %513 = getelementptr inbounds { float, float }, ptr %512, i32 0, i32 0
  %514 = load float, ptr %513, align 8
  %515 = getelementptr inbounds { float, float }, ptr %512, i32 0, i32 1
  %516 = load float, ptr %515, align 4
  %517 = load i32, ptr %6, align 4, !tbaa !9
  %518 = zext i32 %517 to i64
  %519 = getelementptr inbounds { float, float }, ptr %71, i64 %518
  %520 = getelementptr inbounds { float, float }, ptr %519, i32 0, i32 0
  %521 = load float, ptr %520, align 8
  %522 = getelementptr inbounds { float, float }, ptr %519, i32 0, i32 1
  %523 = load float, ptr %522, align 4
  %524 = fsub float %514, %521
  %525 = fpext float %524 to double
  %526 = call double @llvm.fmuladd.f64(double %477, double %493, double 0.000000e+00)
  %527 = call double @sqrt(double noundef %526) #7
  %528 = load float, ptr %1, align 4, !tbaa !5
  %529 = fpext float %528 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.1, i32 noundef 141, ptr noundef @.str.4, double noundef %527, ptr noundef @.str.5, ptr noundef @.str.6, double noundef %529)
  br label %531

530:                                              ; preds = %452
  call void (...) @liquid_autotest_passed()
  br label %531

531:                                              ; preds = %530, %461
  %532 = load i32, ptr %6, align 4, !tbaa !9
  %533 = zext i32 %532 to i64
  %534 = getelementptr inbounds { float, float }, ptr %68, i64 %533
  %535 = getelementptr inbounds { float, float }, ptr %534, i32 0, i32 0
  %536 = load float, ptr %535, align 8
  %537 = getelementptr inbounds { float, float }, ptr %534, i32 0, i32 1
  %538 = load float, ptr %537, align 4
  %539 = load i32, ptr %6, align 4, !tbaa !9
  %540 = zext i32 %539 to i64
  %541 = getelementptr inbounds { float, float }, ptr %71, i64 %540
  %542 = getelementptr inbounds { float, float }, ptr %541, i32 0, i32 0
  %543 = load float, ptr %542, align 8
  %544 = getelementptr inbounds { float, float }, ptr %541, i32 0, i32 1
  %545 = load float, ptr %544, align 4
  %546 = fsub float %538, %545
  %547 = fpext float %546 to double
  %548 = load i32, ptr %6, align 4, !tbaa !9
  %549 = zext i32 %548 to i64
  %550 = getelementptr inbounds { float, float }, ptr %68, i64 %549
  %551 = getelementptr inbounds { float, float }, ptr %550, i32 0, i32 0
  %552 = load float, ptr %551, align 8
  %553 = getelementptr inbounds { float, float }, ptr %550, i32 0, i32 1
  %554 = load float, ptr %553, align 4
  %555 = load i32, ptr %6, align 4, !tbaa !9
  %556 = zext i32 %555 to i64
  %557 = getelementptr inbounds { float, float }, ptr %71, i64 %556
  %558 = getelementptr inbounds { float, float }, ptr %557, i32 0, i32 0
  %559 = load float, ptr %558, align 8
  %560 = getelementptr inbounds { float, float }, ptr %557, i32 0, i32 1
  %561 = load float, ptr %560, align 4
  %562 = fsub float %554, %561
  %563 = fpext float %562 to double
  %564 = load i32, ptr %6, align 4, !tbaa !9
  %565 = zext i32 %564 to i64
  %566 = getelementptr inbounds { float, float }, ptr %68, i64 %565
  %567 = getelementptr inbounds { float, float }, ptr %566, i32 0, i32 0
  %568 = load float, ptr %567, align 8
  %569 = getelementptr inbounds { float, float }, ptr %566, i32 0, i32 1
  %570 = load float, ptr %569, align 4
  %571 = load i32, ptr %6, align 4, !tbaa !9
  %572 = zext i32 %571 to i64
  %573 = getelementptr inbounds { float, float }, ptr %71, i64 %572
  %574 = getelementptr inbounds { float, float }, ptr %573, i32 0, i32 0
  %575 = load float, ptr %574, align 8
  %576 = getelementptr inbounds { float, float }, ptr %573, i32 0, i32 1
  %577 = load float, ptr %576, align 4
  %578 = fsub float %570, %577
  %579 = fpext float %578 to double
  %580 = load i32, ptr %6, align 4, !tbaa !9
  %581 = zext i32 %580 to i64
  %582 = getelementptr inbounds { float, float }, ptr %68, i64 %581
  %583 = getelementptr inbounds { float, float }, ptr %582, i32 0, i32 0
  %584 = load float, ptr %583, align 8
  %585 = getelementptr inbounds { float, float }, ptr %582, i32 0, i32 1
  %586 = load float, ptr %585, align 4
  %587 = load i32, ptr %6, align 4, !tbaa !9
  %588 = zext i32 %587 to i64
  %589 = getelementptr inbounds { float, float }, ptr %71, i64 %588
  %590 = getelementptr inbounds { float, float }, ptr %589, i32 0, i32 0
  %591 = load float, ptr %590, align 8
  %592 = getelementptr inbounds { float, float }, ptr %589, i32 0, i32 1
  %593 = load float, ptr %592, align 4
  %594 = fsub float %586, %593
  %595 = fpext float %594 to double
  %596 = call double @llvm.fmuladd.f64(double %547, double %563, double 0.000000e+00)
  %597 = call double @sqrt(double noundef %596) #7
  %598 = load float, ptr %1, align 4, !tbaa !5
  %599 = fpext float %598 to double
  %600 = fcmp ogt double %597, %599
  br i1 %600, label %637, label %601

601:                                              ; preds = %531
  %602 = load i32, ptr %6, align 4, !tbaa !9
  %603 = zext i32 %602 to i64
  %604 = getelementptr inbounds { float, float }, ptr %68, i64 %603
  %605 = getelementptr inbounds { float, float }, ptr %604, i32 0, i32 0
  %606 = load float, ptr %605, align 8
  %607 = getelementptr inbounds { float, float }, ptr %604, i32 0, i32 1
  %608 = load float, ptr %607, align 4
  %609 = call i1 @llvm.is.fpclass.f32(float %608, i32 3)
  br i1 %609, label %637, label %610

610:                                              ; preds = %601
  %611 = load i32, ptr %6, align 4, !tbaa !9
  %612 = zext i32 %611 to i64
  %613 = getelementptr inbounds { float, float }, ptr %68, i64 %612
  %614 = getelementptr inbounds { float, float }, ptr %613, i32 0, i32 0
  %615 = load float, ptr %614, align 8
  %616 = getelementptr inbounds { float, float }, ptr %613, i32 0, i32 1
  %617 = load float, ptr %616, align 4
  %618 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %618, label %637, label %619

619:                                              ; preds = %610
  %620 = load i32, ptr %6, align 4, !tbaa !9
  %621 = zext i32 %620 to i64
  %622 = getelementptr inbounds { float, float }, ptr %71, i64 %621
  %623 = getelementptr inbounds { float, float }, ptr %622, i32 0, i32 0
  %624 = load float, ptr %623, align 8
  %625 = getelementptr inbounds { float, float }, ptr %622, i32 0, i32 1
  %626 = load float, ptr %625, align 4
  %627 = call i1 @llvm.is.fpclass.f32(float %626, i32 3)
  br i1 %627, label %637, label %628

628:                                              ; preds = %619
  %629 = load i32, ptr %6, align 4, !tbaa !9
  %630 = zext i32 %629 to i64
  %631 = getelementptr inbounds { float, float }, ptr %71, i64 %630
  %632 = getelementptr inbounds { float, float }, ptr %631, i32 0, i32 0
  %633 = load float, ptr %632, align 8
  %634 = getelementptr inbounds { float, float }, ptr %631, i32 0, i32 1
  %635 = load float, ptr %634, align 4
  %636 = call i1 @llvm.is.fpclass.f32(float 0.000000e+00, i32 3)
  br i1 %636, label %637, label %706

637:                                              ; preds = %628, %619, %610, %601, %531
  %638 = load i32, ptr %6, align 4, !tbaa !9
  %639 = zext i32 %638 to i64
  %640 = getelementptr inbounds { float, float }, ptr %68, i64 %639
  %641 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 0
  %642 = load float, ptr %641, align 8
  %643 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 1
  %644 = load float, ptr %643, align 4
  %645 = load i32, ptr %6, align 4, !tbaa !9
  %646 = zext i32 %645 to i64
  %647 = getelementptr inbounds { float, float }, ptr %71, i64 %646
  %648 = getelementptr inbounds { float, float }, ptr %647, i32 0, i32 0
  %649 = load float, ptr %648, align 8
  %650 = getelementptr inbounds { float, float }, ptr %647, i32 0, i32 1
  %651 = load float, ptr %650, align 4
  %652 = fsub float %644, %651
  %653 = fpext float %652 to double
  %654 = load i32, ptr %6, align 4, !tbaa !9
  %655 = zext i32 %654 to i64
  %656 = getelementptr inbounds { float, float }, ptr %68, i64 %655
  %657 = getelementptr inbounds { float, float }, ptr %656, i32 0, i32 0
  %658 = load float, ptr %657, align 8
  %659 = getelementptr inbounds { float, float }, ptr %656, i32 0, i32 1
  %660 = load float, ptr %659, align 4
  %661 = load i32, ptr %6, align 4, !tbaa !9
  %662 = zext i32 %661 to i64
  %663 = getelementptr inbounds { float, float }, ptr %71, i64 %662
  %664 = getelementptr inbounds { float, float }, ptr %663, i32 0, i32 0
  %665 = load float, ptr %664, align 8
  %666 = getelementptr inbounds { float, float }, ptr %663, i32 0, i32 1
  %667 = load float, ptr %666, align 4
  %668 = fsub float %660, %667
  %669 = fpext float %668 to double
  %670 = load i32, ptr %6, align 4, !tbaa !9
  %671 = zext i32 %670 to i64
  %672 = getelementptr inbounds { float, float }, ptr %68, i64 %671
  %673 = getelementptr inbounds { float, float }, ptr %672, i32 0, i32 0
  %674 = load float, ptr %673, align 8
  %675 = getelementptr inbounds { float, float }, ptr %672, i32 0, i32 1
  %676 = load float, ptr %675, align 4
  %677 = load i32, ptr %6, align 4, !tbaa !9
  %678 = zext i32 %677 to i64
  %679 = getelementptr inbounds { float, float }, ptr %71, i64 %678
  %680 = getelementptr inbounds { float, float }, ptr %679, i32 0, i32 0
  %681 = load float, ptr %680, align 8
  %682 = getelementptr inbounds { float, float }, ptr %679, i32 0, i32 1
  %683 = load float, ptr %682, align 4
  %684 = fsub float %676, %683
  %685 = fpext float %684 to double
  %686 = load i32, ptr %6, align 4, !tbaa !9
  %687 = zext i32 %686 to i64
  %688 = getelementptr inbounds { float, float }, ptr %68, i64 %687
  %689 = getelementptr inbounds { float, float }, ptr %688, i32 0, i32 0
  %690 = load float, ptr %689, align 8
  %691 = getelementptr inbounds { float, float }, ptr %688, i32 0, i32 1
  %692 = load float, ptr %691, align 4
  %693 = load i32, ptr %6, align 4, !tbaa !9
  %694 = zext i32 %693 to i64
  %695 = getelementptr inbounds { float, float }, ptr %71, i64 %694
  %696 = getelementptr inbounds { float, float }, ptr %695, i32 0, i32 0
  %697 = load float, ptr %696, align 8
  %698 = getelementptr inbounds { float, float }, ptr %695, i32 0, i32 1
  %699 = load float, ptr %698, align 4
  %700 = fsub float %692, %699
  %701 = fpext float %700 to double
  %702 = call double @llvm.fmuladd.f64(double %653, double %669, double 0.000000e+00)
  %703 = call double @sqrt(double noundef %702) #7
  %704 = load float, ptr %1, align 4, !tbaa !5
  %705 = fpext float %704 to double
  call void @liquid_autotest_failed_expr(ptr noundef @.str.1, i32 noundef 142, ptr noundef @.str.7, double noundef %703, ptr noundef @.str.5, ptr noundef @.str.6, double noundef %705)
  br label %707

706:                                              ; preds = %628
  call void (...) @liquid_autotest_passed()
  br label %707

707:                                              ; preds = %706, %637
  br label %708

708:                                              ; preds = %707
  %709 = load i32, ptr %6, align 4, !tbaa !9
  %710 = add i32 %709, 1
  store i32 %710, ptr %6, align 4, !tbaa !9
  br label %279, !llvm.loop !22

711:                                              ; preds = %279
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #7
  %712 = load ptr, ptr %9, align 8
  call void @llvm.stackrestore.p0(ptr %712)
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 4, 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 nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #2

declare ptr @msequence_create_default(i32 noundef) #3

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

declare i32 @msequence_destroy(ptr noundef) #3

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

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

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

declare i32 @firfilt_crcf_reset(ptr noundef) #3

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #4

declare i32 @firfilt_crcf_push(ptr noundef, <2 x float> noundef) #3

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

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

declare <2 x float> @__mulsc3(float, float, float, float)

declare i32 @firfilt_crcf_destroy(ptr noundef) #3

declare i32 @firpfbch_crcf_destroy(ptr noundef) #3

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

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

declare void @liquid_autotest_passed(...) #3

; Function Attrs: 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 willreturn
declare void @llvm.stackrestore.p0(ptr) #2

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nosync nounwind willreturn }
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 = { noreturn 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 = { 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 }
attributes #8 = { noreturn nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}
!17 = distinct !{!17, !14}
!18 = distinct !{!18, !14}
!19 = !{!"branch_weights", i32 1, i32 1048575}
!20 = distinct !{!20, !14}
!21 = distinct !{!21, !14}
!22 = distinct !{!22, !14}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@.str = external hidden unnamed_addr constant [14 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [114 x i8], align 1
@__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis = external hidden unnamed_addr constant [40 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [15 x i8], align 1
@liquid_autotest_verbose = external local_unnamed_addr global i32, align 4
@.str.3 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [37 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @autotest_firpfbch_crcf_synthesis() local_unnamed_addr #0 {
  %1 = alloca { float, float }, align 4
  %2 = alloca [20 x float], align 16
  %3 = tail call ptr @msequence_create_default(i32 noundef 6) #9
  %4 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %5 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %6 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %7 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %8 = insertelement <4 x i32> poison, i32 %4, i64 0
  %9 = insertelement <4 x i32> %8, i32 %5, i64 1
  %10 = insertelement <4 x i32> %9, i32 %6, i64 2
  %11 = insertelement <4 x i32> %10, i32 %7, i64 3
  %12 = uitofp <4 x i32> %11 to <4 x float>
  %13 = fadd <4 x float> %12, <float -1.500000e+00, float -1.500000e+00, float -1.500000e+00, float -1.500000e+00>
  store <4 x float> %13, ptr %2, align 16, !tbaa !5
  %14 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %15 = getelementptr inbounds i8, ptr %2, i64 16
  %16 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %17 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %18 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %19 = insertelement <4 x i32> poison, i32 %14, i64 0
  %20 = insertelement <4 x i32> %19, i32 %16, i64 1
  %21 = insertelement <4 x i32> %20, i32 %17, i64 2
  %22 = insertelement <4 x i32> %21, i32 %18, i64 3
  %23 = uitofp <4 x i32> %22 to <4 x float>
  %24 = fadd <4 x float> %23, <float -1.500000e+00, float -1.500000e+00, float -1.500000e+00, float -1.500000e+00>
  store <4 x float> %24, ptr %15, align 16, !tbaa !5
  %25 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %26 = getelementptr inbounds i8, ptr %2, i64 32
  %27 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %28 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %29 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %30 = insertelement <4 x i32> poison, i32 %25, i64 0
  %31 = insertelement <4 x i32> %30, i32 %27, i64 1
  %32 = insertelement <4 x i32> %31, i32 %28, i64 2
  %33 = insertelement <4 x i32> %32, i32 %29, i64 3
  %34 = uitofp <4 x i32> %33 to <4 x float>
  %35 = fadd <4 x float> %34, <float -1.500000e+00, float -1.500000e+00, float -1.500000e+00, float -1.500000e+00>
  store <4 x float> %35, ptr %26, align 16, !tbaa !5
  %36 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %37 = getelementptr inbounds i8, ptr %2, i64 48
  %38 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %39 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %40 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %41 = insertelement <4 x i32> poison, i32 %36, i64 0
  %42 = insertelement <4 x i32> %41, i32 %38, i64 1
  %43 = insertelement <4 x i32> %42, i32 %39, i64 2
  %44 = insertelement <4 x i32> %43, i32 %40, i64 3
  %45 = uitofp <4 x i32> %44 to <4 x float>
  %46 = fadd <4 x float> %45, <float -1.500000e+00, float -1.500000e+00, float -1.500000e+00, float -1.500000e+00>
  store <4 x float> %46, ptr %37, align 16, !tbaa !5
  %47 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %48 = getelementptr inbounds i8, ptr %2, i64 64
  %49 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %50 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %51 = tail call i32 @msequence_generate_symbol(ptr noundef %3, i32 noundef 2) #9
  %52 = insertelement <4 x i32> poison, i32 %47, i64 0
  %53 = insertelement <4 x i32> %52, i32 %49, i64 1
  %54 = insertelement <4 x i32> %53, i32 %50, i64 2
  %55 = insertelement <4 x i32> %54, i32 %51, i64 3
  %56 = uitofp <4 x i32> %55 to <4 x float>
  %57 = fadd <4 x float> %56, <float -1.500000e+00, float -1.500000e+00, float -1.500000e+00, float -1.500000e+00>
  store <4 x float> %57, ptr %48, align 16, !tbaa !5
  %58 = tail call i32 @msequence_destroy(ptr noundef %3) #9
  %59 = call ptr @firfilt_crcf_create(ptr noundef nonnull %2, i32 noundef 20) #9
  %60 = call ptr @firpfbch_crcf_create(i32 noundef 1, i32 noundef 4, i32 noundef 5, ptr noundef nonnull %2) #9
  %61 = alloca [160 x { float, float }], align 16
  %62 = alloca [160 x { float, float }], align 16
  %63 = alloca [160 x { float, float }], align 16
  %64 = call ptr @msequence_create_default(i32 noundef 7) #9
  br label %.preheader137

.preheader137:                                    ; preds = %0, %.preheader137
  %indvars.iv = phi i64 [ 0, %0 ], [ %indvars.iv.next, %.preheader137 ]
  %.idx = shl nsw i64 %indvars.iv, 5
  %65 = getelementptr inbounds i8, ptr %61, i64 %.idx
  %66 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %67 = uitofp i32 %66 to float
  %68 = fadd float %67, -1.500000e+00
  %69 = fpext float %68 to double
  %70 = fmul double %69, 0x3FB21A185685E91F
  %71 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %72 = uitofp i32 %71 to float
  %73 = fadd float %72, -1.500000e+00
  %74 = fpext float %73 to double
  %75 = fmul double %74, 0x3FB21A185685E91F
  %76 = fmul double %75, 0.000000e+00
  %77 = fadd double %70, %76
  %78 = insertelement <2 x double> poison, double %77, i64 0
  %79 = insertelement <2 x double> %78, double %75, i64 1
  %80 = fptrunc <2 x double> %79 to <2 x float>
  store <2 x float> %80, ptr %65, align 16
  %81 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %82 = uitofp i32 %81 to float
  %83 = fadd float %82, -1.500000e+00
  %84 = fpext float %83 to double
  %85 = fmul double %84, 0x3FB21A185685E91F
  %86 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %87 = uitofp i32 %86 to float
  %88 = fadd float %87, -1.500000e+00
  %89 = fpext float %88 to double
  %90 = fmul double %89, 0x3FB21A185685E91F
  %91 = fmul double %90, 0.000000e+00
  %92 = fadd double %85, %91
  %93 = getelementptr inbounds i8, ptr %65, i64 8
  %94 = insertelement <2 x double> poison, double %92, i64 0
  %95 = insertelement <2 x double> %94, double %90, i64 1
  %96 = fptrunc <2 x double> %95 to <2 x float>
  store <2 x float> %96, ptr %93, align 8
  %97 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %98 = uitofp i32 %97 to float
  %99 = fadd float %98, -1.500000e+00
  %100 = fpext float %99 to double
  %101 = fmul double %100, 0x3FB21A185685E91F
  %102 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %103 = uitofp i32 %102 to float
  %104 = fadd float %103, -1.500000e+00
  %105 = fpext float %104 to double
  %106 = fmul double %105, 0x3FB21A185685E91F
  %107 = fmul double %106, 0.000000e+00
  %108 = fadd double %101, %107
  %109 = getelementptr inbounds i8, ptr %65, i64 16
  %110 = insertelement <2 x double> poison, double %108, i64 0
  %111 = insertelement <2 x double> %110, double %106, i64 1
  %112 = fptrunc <2 x double> %111 to <2 x float>
  store <2 x float> %112, ptr %109, align 16
  %113 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %114 = uitofp i32 %113 to float
  %115 = fadd float %114, -1.500000e+00
  %116 = fpext float %115 to double
  %117 = fmul double %116, 0x3FB21A185685E91F
  %118 = call i32 @msequence_generate_symbol(ptr noundef %64, i32 noundef 2) #9
  %119 = uitofp i32 %118 to float
  %120 = fadd float %119, -1.500000e+00
  %121 = fpext float %120 to double
  %122 = fmul double %121, 0x3FB21A185685E91F
  %123 = fmul double %122, 0.000000e+00
  %124 = fadd double %117, %123
  %125 = getelementptr inbounds i8, ptr %65, i64 24
  %126 = insertelement <2 x double> poison, double %124, i64 0
  %127 = insertelement <2 x double> %126, double %122, i64 1
  %128 = fptrunc <2 x double> %127 to <2 x float>
  store <2 x float> %128, ptr %125, align 8
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, 40
  br i1 %exitcond.not, label %.preheader.preheader, label %.preheader137, !llvm.loop !9

.preheader.preheader:                             ; preds = %.preheader137
  %129 = call i32 @msequence_destroy(ptr noundef %64) #9
  %130 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %61, ptr noundef nonnull %62) #9
  %131 = getelementptr inbounds i8, ptr %61, i64 32
  %132 = getelementptr inbounds i8, ptr %62, i64 32
  %133 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %131, ptr noundef nonnull %132) #9
  %134 = getelementptr inbounds i8, ptr %61, i64 64
  %135 = getelementptr inbounds i8, ptr %62, i64 64
  %136 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %134, ptr noundef nonnull %135) #9
  %137 = getelementptr inbounds i8, ptr %61, i64 96
  %138 = getelementptr inbounds i8, ptr %62, i64 96
  %139 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %137, ptr noundef nonnull %138) #9
  %140 = getelementptr inbounds i8, ptr %61, i64 128
  %141 = getelementptr inbounds i8, ptr %62, i64 128
  %142 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %140, ptr noundef nonnull %141) #9
  %143 = getelementptr inbounds i8, ptr %61, i64 160
  %144 = getelementptr inbounds i8, ptr %62, i64 160
  %145 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %143, ptr noundef nonnull %144) #9
  %146 = getelementptr inbounds i8, ptr %61, i64 192
  %147 = getelementptr inbounds i8, ptr %62, i64 192
  %148 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %146, ptr noundef nonnull %147) #9
  %149 = getelementptr inbounds i8, ptr %61, i64 224
  %150 = getelementptr inbounds i8, ptr %62, i64 224
  %151 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %149, ptr noundef nonnull %150) #9
  %152 = getelementptr inbounds i8, ptr %61, i64 256
  %153 = getelementptr inbounds i8, ptr %62, i64 256
  %154 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %152, ptr noundef nonnull %153) #9
  %155 = getelementptr inbounds i8, ptr %61, i64 288
  %156 = getelementptr inbounds i8, ptr %62, i64 288
  %157 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %155, ptr noundef nonnull %156) #9
  %158 = getelementptr inbounds i8, ptr %61, i64 320
  %159 = getelementptr inbounds i8, ptr %62, i64 320
  %160 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %158, ptr noundef nonnull %159) #9
  %161 = getelementptr inbounds i8, ptr %61, i64 352
  %162 = getelementptr inbounds i8, ptr %62, i64 352
  %163 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %161, ptr noundef nonnull %162) #9
  %164 = getelementptr inbounds i8, ptr %61, i64 384
  %165 = getelementptr inbounds i8, ptr %62, i64 384
  %166 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %164, ptr noundef nonnull %165) #9
  %167 = getelementptr inbounds i8, ptr %61, i64 416
  %168 = getelementptr inbounds i8, ptr %62, i64 416
  %169 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %167, ptr noundef nonnull %168) #9
  %170 = getelementptr inbounds i8, ptr %61, i64 448
  %171 = getelementptr inbounds i8, ptr %62, i64 448
  %172 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %170, ptr noundef nonnull %171) #9
  %173 = getelementptr inbounds i8, ptr %61, i64 480
  %174 = getelementptr inbounds i8, ptr %62, i64 480
  %175 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %173, ptr noundef nonnull %174) #9
  %176 = getelementptr inbounds i8, ptr %61, i64 512
  %177 = getelementptr inbounds i8, ptr %62, i64 512
  %178 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %176, ptr noundef nonnull %177) #9
  %179 = getelementptr inbounds i8, ptr %61, i64 544
  %180 = getelementptr inbounds i8, ptr %62, i64 544
  %181 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %179, ptr noundef nonnull %180) #9
  %182 = getelementptr inbounds i8, ptr %61, i64 576
  %183 = getelementptr inbounds i8, ptr %62, i64 576
  %184 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %182, ptr noundef nonnull %183) #9
  %185 = getelementptr inbounds i8, ptr %61, i64 608
  %186 = getelementptr inbounds i8, ptr %62, i64 608
  %187 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %185, ptr noundef nonnull %186) #9
  %188 = getelementptr inbounds i8, ptr %61, i64 640
  %189 = getelementptr inbounds i8, ptr %62, i64 640
  %190 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %188, ptr noundef nonnull %189) #9
  %191 = getelementptr inbounds i8, ptr %61, i64 672
  %192 = getelementptr inbounds i8, ptr %62, i64 672
  %193 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %191, ptr noundef nonnull %192) #9
  %194 = getelementptr inbounds i8, ptr %61, i64 704
  %195 = getelementptr inbounds i8, ptr %62, i64 704
  %196 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %194, ptr noundef nonnull %195) #9
  %197 = getelementptr inbounds i8, ptr %61, i64 736
  %198 = getelementptr inbounds i8, ptr %62, i64 736
  %199 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %197, ptr noundef nonnull %198) #9
  %200 = getelementptr inbounds i8, ptr %61, i64 768
  %201 = getelementptr inbounds i8, ptr %62, i64 768
  %202 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %200, ptr noundef nonnull %201) #9
  %203 = getelementptr inbounds i8, ptr %61, i64 800
  %204 = getelementptr inbounds i8, ptr %62, i64 800
  %205 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %203, ptr noundef nonnull %204) #9
  %206 = getelementptr inbounds i8, ptr %61, i64 832
  %207 = getelementptr inbounds i8, ptr %62, i64 832
  %208 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %206, ptr noundef nonnull %207) #9
  %209 = getelementptr inbounds i8, ptr %61, i64 864
  %210 = getelementptr inbounds i8, ptr %62, i64 864
  %211 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %209, ptr noundef nonnull %210) #9
  %212 = getelementptr inbounds i8, ptr %61, i64 896
  %213 = getelementptr inbounds i8, ptr %62, i64 896
  %214 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %212, ptr noundef nonnull %213) #9
  %215 = getelementptr inbounds i8, ptr %61, i64 928
  %216 = getelementptr inbounds i8, ptr %62, i64 928
  %217 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %215, ptr noundef nonnull %216) #9
  %218 = getelementptr inbounds i8, ptr %61, i64 960
  %219 = getelementptr inbounds i8, ptr %62, i64 960
  %220 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %218, ptr noundef nonnull %219) #9
  %221 = getelementptr inbounds i8, ptr %61, i64 992
  %222 = getelementptr inbounds i8, ptr %62, i64 992
  %223 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %221, ptr noundef nonnull %222) #9
  %224 = getelementptr inbounds i8, ptr %61, i64 1024
  %225 = getelementptr inbounds i8, ptr %62, i64 1024
  %226 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %224, ptr noundef nonnull %225) #9
  %227 = getelementptr inbounds i8, ptr %61, i64 1056
  %228 = getelementptr inbounds i8, ptr %62, i64 1056
  %229 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %227, ptr noundef nonnull %228) #9
  %230 = getelementptr inbounds i8, ptr %61, i64 1088
  %231 = getelementptr inbounds i8, ptr %62, i64 1088
  %232 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %230, ptr noundef nonnull %231) #9
  %233 = getelementptr inbounds i8, ptr %61, i64 1120
  %234 = getelementptr inbounds i8, ptr %62, i64 1120
  %235 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %233, ptr noundef nonnull %234) #9
  %236 = getelementptr inbounds i8, ptr %61, i64 1152
  %237 = getelementptr inbounds i8, ptr %62, i64 1152
  %238 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %236, ptr noundef nonnull %237) #9
  %239 = getelementptr inbounds i8, ptr %61, i64 1184
  %240 = getelementptr inbounds i8, ptr %62, i64 1184
  %241 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %239, ptr noundef nonnull %240) #9
  %242 = getelementptr inbounds i8, ptr %61, i64 1216
  %243 = getelementptr inbounds i8, ptr %62, i64 1216
  %244 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %242, ptr noundef nonnull %243) #9
  %245 = getelementptr inbounds i8, ptr %61, i64 1248
  %246 = getelementptr inbounds i8, ptr %62, i64 1248
  %247 = call i32 @firpfbch_crcf_synthesizer_execute(ptr noundef %60, ptr noundef nonnull %245, ptr noundef nonnull %246) #9
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(1280) %63, i8 0, i64 1280, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %1) #9
  %248 = getelementptr inbounds i8, ptr %1, i64 4
  %249 = call i32 @firfilt_crcf_reset(ptr noundef %59) #9
  br label %400

250:                                              ; preds = %442
  %251 = call i32 @firfilt_crcf_reset(ptr noundef %59) #9
  %invariant.gep.1 = getelementptr inbounds i8, ptr %61, i64 8
  br label %252

252:                                              ; preds = %292, %250
  %indvars.iv164.1 = phi i64 [ 0, %250 ], [ %indvars.iv.next165.1, %292 ]
  %.0131146.1 = phi i32 [ 0, %250 ], [ %.1132.1, %292 ]
  %253 = trunc nuw nsw i64 %indvars.iv164.1 to i32
  %254 = and i32 %253, 3
  %255 = icmp eq i32 %254, 0
  br i1 %255, label %258, label %256

256:                                              ; preds = %252
  %257 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef zeroinitializer) #9
  br label %266

258:                                              ; preds = %252
  %259 = icmp ult i32 %.0131146.1, 40
  br i1 %259, label %260, label %.loopexit

260:                                              ; preds = %258
  %261 = shl nuw nsw i32 %.0131146.1, 2
  %262 = zext nneg i32 %261 to i64
  %gep.1 = getelementptr inbounds { float, float }, ptr %invariant.gep.1, i64 %262
  %263 = load <2 x float>, ptr %gep.1, align 8
  %264 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef %263) #9
  %265 = add nuw nsw i32 %.0131146.1, 1
  br label %266

266:                                              ; preds = %260, %256
  %.1132.1 = phi i32 [ %265, %260 ], [ %.0131146.1, %256 ]
  %267 = call i32 @firfilt_crcf_execute(ptr noundef %59, ptr noundef nonnull %1) #9
  %268 = load float, ptr %1, align 4
  %269 = load float, ptr %248, align 4
  %270 = uitofp nneg i32 %253 to float
  %271 = fmul float %270, 0x3FF921FB60000000
  %.sroa.02.4.vec.insert.1 = insertelement <2 x float> <float 0.000000e+00, float poison>, float %271, i64 1
  %272 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.02.4.vec.insert.1) #9
  %273 = insertelement <2 x float> poison, float %268, i64 0
  %274 = shufflevector <2 x float> %273, <2 x float> poison, <2 x i32> zeroinitializer
  %275 = fmul <2 x float> %274, %272
  %276 = insertelement <2 x float> poison, float %269, i64 0
  %277 = shufflevector <2 x float> %276, <2 x float> poison, <2 x i32> zeroinitializer
  %278 = fmul <2 x float> %277, %272
  %279 = shufflevector <2 x float> %278, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %280 = fsub <2 x float> %275, %279
  %281 = fadd <2 x float> %275, %279
  %282 = shufflevector <2 x float> %280, <2 x float> %281, <2 x i32> <i32 0, i32 3>
  %283 = extractelement <2 x float> %280, i64 0
  %284 = fcmp uno float %283, 0.000000e+00
  br i1 %284, label %285, label %292, !prof !11

285:                                              ; preds = %266
  %286 = extractelement <2 x float> %281, i64 1
  %287 = fcmp uno float %286, 0.000000e+00
  br i1 %287, label %288, label %292, !prof !11

288:                                              ; preds = %285
  %289 = extractelement <2 x float> %272, i64 0
  %290 = extractelement <2 x float> %272, i64 1
  %291 = call <2 x float> @__mulsc3(float noundef %268, float noundef %269, float noundef %289, float noundef %290) #9
  br label %292

292:                                              ; preds = %288, %285, %266
  %293 = phi <2 x float> [ %282, %266 ], [ %282, %285 ], [ %291, %288 ]
  %294 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv164.1
  %295 = load <2 x float>, ptr %294, align 8
  %296 = fadd <2 x float> %293, %295
  store <2 x float> %296, ptr %294, align 8
  %indvars.iv.next165.1 = add nuw nsw i64 %indvars.iv164.1, 1
  %exitcond167.1.not = icmp eq i64 %indvars.iv.next165.1, 160
  br i1 %exitcond167.1.not, label %297, label %252, !llvm.loop !12

297:                                              ; preds = %292
  %298 = icmp eq i32 %.1132.1, 40
  br i1 %298, label %299, label %444

299:                                              ; preds = %297
  %300 = call i32 @firfilt_crcf_reset(ptr noundef %59) #9
  %invariant.gep.2 = getelementptr inbounds i8, ptr %61, i64 16
  br label %301

301:                                              ; preds = %341, %299
  %indvars.iv164.2 = phi i64 [ 0, %299 ], [ %indvars.iv.next165.2, %341 ]
  %.0131146.2 = phi i32 [ 0, %299 ], [ %.1132.2, %341 ]
  %302 = trunc nuw nsw i64 %indvars.iv164.2 to i32
  %303 = and i32 %302, 3
  %304 = icmp eq i32 %303, 0
  br i1 %304, label %307, label %305

305:                                              ; preds = %301
  %306 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef zeroinitializer) #9
  br label %315

307:                                              ; preds = %301
  %308 = icmp ult i32 %.0131146.2, 40
  br i1 %308, label %309, label %.loopexit

309:                                              ; preds = %307
  %310 = shl nuw nsw i32 %.0131146.2, 2
  %311 = zext nneg i32 %310 to i64
  %gep.2 = getelementptr inbounds { float, float }, ptr %invariant.gep.2, i64 %311
  %312 = load <2 x float>, ptr %gep.2, align 16
  %313 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef %312) #9
  %314 = add nuw nsw i32 %.0131146.2, 1
  br label %315

315:                                              ; preds = %309, %305
  %.1132.2 = phi i32 [ %314, %309 ], [ %.0131146.2, %305 ]
  %316 = call i32 @firfilt_crcf_execute(ptr noundef %59, ptr noundef nonnull %1) #9
  %317 = load float, ptr %1, align 4
  %318 = load float, ptr %248, align 4
  %319 = uitofp nneg i32 %302 to float
  %320 = fmul float %319, 0x400921FB60000000
  %.sroa.02.4.vec.insert.2 = insertelement <2 x float> <float 0.000000e+00, float poison>, float %320, i64 1
  %321 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.02.4.vec.insert.2) #9
  %322 = insertelement <2 x float> poison, float %317, i64 0
  %323 = shufflevector <2 x float> %322, <2 x float> poison, <2 x i32> zeroinitializer
  %324 = fmul <2 x float> %323, %321
  %325 = insertelement <2 x float> poison, float %318, i64 0
  %326 = shufflevector <2 x float> %325, <2 x float> poison, <2 x i32> zeroinitializer
  %327 = fmul <2 x float> %326, %321
  %328 = shufflevector <2 x float> %327, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %329 = fsub <2 x float> %324, %328
  %330 = fadd <2 x float> %324, %328
  %331 = shufflevector <2 x float> %329, <2 x float> %330, <2 x i32> <i32 0, i32 3>
  %332 = extractelement <2 x float> %329, i64 0
  %333 = fcmp uno float %332, 0.000000e+00
  br i1 %333, label %334, label %341, !prof !11

334:                                              ; preds = %315
  %335 = extractelement <2 x float> %330, i64 1
  %336 = fcmp uno float %335, 0.000000e+00
  br i1 %336, label %337, label %341, !prof !11

337:                                              ; preds = %334
  %338 = extractelement <2 x float> %321, i64 0
  %339 = extractelement <2 x float> %321, i64 1
  %340 = call <2 x float> @__mulsc3(float noundef %317, float noundef %318, float noundef %338, float noundef %339) #9
  br label %341

341:                                              ; preds = %337, %334, %315
  %342 = phi <2 x float> [ %331, %315 ], [ %331, %334 ], [ %340, %337 ]
  %343 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv164.2
  %344 = load <2 x float>, ptr %343, align 8
  %345 = fadd <2 x float> %342, %344
  store <2 x float> %345, ptr %343, align 8
  %indvars.iv.next165.2 = add nuw nsw i64 %indvars.iv164.2, 1
  %exitcond167.2.not = icmp eq i64 %indvars.iv.next165.2, 160
  br i1 %exitcond167.2.not, label %346, label %301, !llvm.loop !12

346:                                              ; preds = %341
  %347 = icmp eq i32 %.1132.2, 40
  br i1 %347, label %348, label %444

348:                                              ; preds = %346
  %349 = call i32 @firfilt_crcf_reset(ptr noundef %59) #9
  %invariant.gep.3 = getelementptr inbounds i8, ptr %61, i64 24
  br label %350

350:                                              ; preds = %390, %348
  %indvars.iv164.3 = phi i64 [ 0, %348 ], [ %indvars.iv.next165.3, %390 ]
  %.0131146.3 = phi i32 [ 0, %348 ], [ %.1132.3, %390 ]
  %351 = trunc nuw nsw i64 %indvars.iv164.3 to i32
  %352 = and i32 %351, 3
  %353 = icmp eq i32 %352, 0
  br i1 %353, label %356, label %354

354:                                              ; preds = %350
  %355 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef zeroinitializer) #9
  br label %364

356:                                              ; preds = %350
  %357 = icmp ult i32 %.0131146.3, 40
  br i1 %357, label %358, label %.loopexit

358:                                              ; preds = %356
  %359 = shl nuw nsw i32 %.0131146.3, 2
  %360 = zext nneg i32 %359 to i64
  %gep.3 = getelementptr inbounds { float, float }, ptr %invariant.gep.3, i64 %360
  %361 = load <2 x float>, ptr %gep.3, align 8
  %362 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef %361) #9
  %363 = add nuw nsw i32 %.0131146.3, 1
  br label %364

364:                                              ; preds = %358, %354
  %.1132.3 = phi i32 [ %363, %358 ], [ %.0131146.3, %354 ]
  %365 = call i32 @firfilt_crcf_execute(ptr noundef %59, ptr noundef nonnull %1) #9
  %366 = load float, ptr %1, align 4
  %367 = load float, ptr %248, align 4
  %368 = uitofp nneg i32 %351 to float
  %369 = fmul float %368, 0x4012D97C80000000
  %.sroa.02.4.vec.insert.3 = insertelement <2 x float> <float 0.000000e+00, float poison>, float %369, i64 1
  %370 = call <2 x float> @cexpf(<2 x float> noundef %.sroa.02.4.vec.insert.3) #9
  %371 = insertelement <2 x float> poison, float %366, i64 0
  %372 = shufflevector <2 x float> %371, <2 x float> poison, <2 x i32> zeroinitializer
  %373 = fmul <2 x float> %372, %370
  %374 = insertelement <2 x float> poison, float %367, i64 0
  %375 = shufflevector <2 x float> %374, <2 x float> poison, <2 x i32> zeroinitializer
  %376 = fmul <2 x float> %375, %370
  %377 = shufflevector <2 x float> %376, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %378 = fsub <2 x float> %373, %377
  %379 = fadd <2 x float> %373, %377
  %380 = shufflevector <2 x float> %378, <2 x float> %379, <2 x i32> <i32 0, i32 3>
  %381 = extractelement <2 x float> %378, i64 0
  %382 = fcmp uno float %381, 0.000000e+00
  br i1 %382, label %383, label %390, !prof !11

383:                                              ; preds = %364
  %384 = extractelement <2 x float> %379, i64 1
  %385 = fcmp uno float %384, 0.000000e+00
  br i1 %385, label %386, label %390, !prof !11

386:                                              ; preds = %383
  %387 = extractelement <2 x float> %370, i64 0
  %388 = extractelement <2 x float> %370, i64 1
  %389 = call <2 x float> @__mulsc3(float noundef %366, float noundef %367, float noundef %387, float noundef %388) #9
  br label %390

390:                                              ; preds = %386, %383, %364
  %391 = phi <2 x float> [ %380, %364 ], [ %380, %383 ], [ %389, %386 ]
  %392 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv164.3
  %393 = load <2 x float>, ptr %392, align 8
  %394 = fadd <2 x float> %391, %393
  store <2 x float> %394, ptr %392, align 8
  %indvars.iv.next165.3 = add nuw nsw i64 %indvars.iv164.3, 1
  %exitcond167.3.not = icmp eq i64 %indvars.iv.next165.3, 160
  br i1 %exitcond167.3.not, label %395, label %350, !llvm.loop !12

395:                                              ; preds = %390
  %396 = icmp eq i32 %.1132.3, 40
  br i1 %396, label %397, label %444

397:                                              ; preds = %395
  %398 = call i32 @firfilt_crcf_destroy(ptr noundef %59) #9
  %399 = call i32 @firpfbch_crcf_destroy(ptr noundef %60) #9
  br label %445

400:                                              ; preds = %.preheader.preheader, %437
  %indvars.iv164 = phi i64 [ 0, %.preheader.preheader ], [ %indvars.iv.next165, %437 ]
  %.0131146 = phi i32 [ 0, %.preheader.preheader ], [ %.1132, %437 ]
  %401 = and i64 %indvars.iv164, 3
  %402 = icmp eq i64 %401, 0
  br i1 %402, label %403, label %411

403:                                              ; preds = %400
  %404 = icmp ult i32 %.0131146, 40
  br i1 %404, label %405, label %.loopexit

.loopexit:                                        ; preds = %403, %258, %307, %356
  call void @__assert_fail(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 108, ptr noundef nonnull @__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis) #10
  unreachable

405:                                              ; preds = %403
  %406 = shl nuw nsw i32 %.0131146, 2
  %407 = zext nneg i32 %406 to i64
  %gep = getelementptr inbounds { float, float }, ptr %61, i64 %407
  %408 = load <2 x float>, ptr %gep, align 16
  %409 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef %408) #9
  %410 = add nuw nsw i32 %.0131146, 1
  br label %413

411:                                              ; preds = %400
  %412 = call i32 @firfilt_crcf_push(ptr noundef %59, <2 x float> noundef zeroinitializer) #9
  br label %413

413:                                              ; preds = %411, %405
  %.1132 = phi i32 [ %410, %405 ], [ %.0131146, %411 ]
  %414 = call i32 @firfilt_crcf_execute(ptr noundef %59, ptr noundef nonnull %1) #9
  %415 = load float, ptr %1, align 4
  %416 = load float, ptr %248, align 4
  %417 = call <2 x float> @cexpf(<2 x float> noundef zeroinitializer) #9
  %418 = insertelement <2 x float> poison, float %415, i64 0
  %419 = shufflevector <2 x float> %418, <2 x float> poison, <2 x i32> zeroinitializer
  %420 = fmul <2 x float> %419, %417
  %421 = insertelement <2 x float> poison, float %416, i64 0
  %422 = shufflevector <2 x float> %421, <2 x float> poison, <2 x i32> zeroinitializer
  %423 = fmul <2 x float> %422, %417
  %424 = shufflevector <2 x float> %423, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %425 = fsub <2 x float> %420, %424
  %426 = fadd <2 x float> %420, %424
  %427 = shufflevector <2 x float> %425, <2 x float> %426, <2 x i32> <i32 0, i32 3>
  %428 = extractelement <2 x float> %425, i64 0
  %429 = fcmp uno float %428, 0.000000e+00
  br i1 %429, label %430, label %437, !prof !11

430:                                              ; preds = %413
  %431 = extractelement <2 x float> %426, i64 1
  %432 = fcmp uno float %431, 0.000000e+00
  br i1 %432, label %433, label %437, !prof !11

433:                                              ; preds = %430
  %434 = extractelement <2 x float> %417, i64 0
  %435 = extractelement <2 x float> %417, i64 1
  %436 = call <2 x float> @__mulsc3(float noundef %415, float noundef %416, float noundef %434, float noundef %435) #9
  br label %437

437:                                              ; preds = %433, %430, %413
  %438 = phi <2 x float> [ %427, %413 ], [ %427, %430 ], [ %436, %433 ]
  %439 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv164
  %440 = load <2 x float>, ptr %439, align 8
  %441 = fadd <2 x float> %438, %440
  store <2 x float> %441, ptr %439, align 8
  %indvars.iv.next165 = add nuw nsw i64 %indvars.iv164, 1
  %exitcond167.not = icmp eq i64 %indvars.iv.next165, 160
  br i1 %exitcond167.not, label %442, label %400, !llvm.loop !12

442:                                              ; preds = %437
  %443 = icmp eq i32 %.1132, 40
  br i1 %443, label %250, label %444

444:                                              ; preds = %395, %346, %297, %442
  call void @__assert_fail(ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.1, i32 noundef 119, ptr noundef nonnull @__PRETTY_FUNCTION__.autotest_firpfbch_crcf_synthesis) #10
  unreachable

445:                                              ; preds = %397, %493
  %indvars.iv175 = phi i64 [ 0, %397 ], [ %indvars.iv.next176, %493 ]
  %446 = load i32, ptr @liquid_autotest_verbose, align 4, !tbaa !13
  %.not = icmp eq i32 %446, 0
  br i1 %.not, label %._crit_edge, label %447

._crit_edge:                                      ; preds = %445
  %.phi.trans.insert = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv175
  %.pre = load float, ptr %.phi.trans.insert, align 8
  br label %466

447:                                              ; preds = %445
  %448 = getelementptr inbounds { float, float }, ptr %62, i64 %indvars.iv175
  %449 = load float, ptr %448, align 8
  %450 = getelementptr inbounds i8, ptr %448, i64 4
  %451 = fpext float %449 to double
  %452 = load float, ptr %450, align 4
  %453 = fpext float %452 to double
  %454 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv175
  %455 = load float, ptr %454, align 8
  %456 = getelementptr inbounds i8, ptr %454, i64 4
  %457 = fpext float %455 to double
  %458 = load float, ptr %456, align 4
  %459 = fpext float %458 to double
  %460 = fsub float %455, %449
  %461 = fpext float %460 to double
  %462 = fsub float %458, %452
  %463 = fpext float %462 to double
  %464 = trunc nuw nsw i64 %indvars.iv175 to i32
  %465 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.3, i32 noundef %464, double noundef %451, double noundef %453, double noundef %457, double noundef %459, double noundef %461, double noundef %463)
  br label %466

466:                                              ; preds = %._crit_edge, %447
  %467 = phi float [ %.pre, %._crit_edge ], [ %455, %447 ]
  %468 = getelementptr inbounds { float, float }, ptr %62, i64 %indvars.iv175
  %469 = load float, ptr %468, align 8
  %470 = getelementptr inbounds i8, ptr %468, i64 4
  %471 = getelementptr inbounds { float, float }, ptr %63, i64 %indvars.iv175, i32 1
  %472 = fsub float %469, %467
  %473 = fpext float %472 to double
  %474 = call double @llvm.fmuladd.f64(double %473, double %473, double 0.000000e+00)
  %sqrt = call double @llvm.sqrt.f64(double %474)
  %475 = fcmp ogt double %sqrt, 0x3F1A36E2E0000000
  br i1 %475, label %479, label %476

476:                                              ; preds = %466
  %477 = fcmp uno float %469, 0.000000e+00
  %478 = fcmp uno float %467, 0.000000e+00
  %or.cond = select i1 %477, i1 true, i1 %478
  br i1 %or.cond, label %479, label %480

479:                                              ; preds = %476, %466
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.1, i32 noundef 141, ptr noundef nonnull @.str.4, double noundef %sqrt, ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.6, double noundef 0x3F1A36E2E0000000) #9
  br label %481

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

481:                                              ; preds = %480, %479
  %482 = load float, ptr %470, align 4
  %483 = load float, ptr %471, align 4
  %484 = fsub float %482, %483
  %485 = fpext float %484 to double
  %486 = call double @llvm.fmuladd.f64(double %485, double %485, double 0.000000e+00)
  %sqrt135 = call double @llvm.sqrt.f64(double %486)
  %487 = fcmp ogt double %sqrt135, 0x3F1A36E2E0000000
  br i1 %487, label %491, label %488

488:                                              ; preds = %481
  %489 = fcmp uno float %482, 0.000000e+00
  %490 = fcmp uno float %483, 0.000000e+00
  %or.cond133 = select i1 %489, i1 true, i1 %490
  br i1 %or.cond133, label %491, label %492

491:                                              ; preds = %488, %481
  call void @liquid_autotest_failed_expr(ptr noundef nonnull @.str.1, i32 noundef 142, ptr noundef nonnull @.str.7, double noundef %sqrt135, ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.6, double noundef 0x3F1A36E2E0000000) #9
  br label %493

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

493:                                              ; preds = %491, %492
  %indvars.iv.next176 = add nuw nsw i64 %indvars.iv175, 1
  %exitcond178.not = icmp eq i64 %indvars.iv.next176, 160
  br i1 %exitcond178.not, label %494, label %445, !llvm.loop !15

494:                                              ; preds = %493
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %1) #9
  ret void
}

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

declare ptr @msequence_create_default(i32 noundef) local_unnamed_addr #2

declare i32 @msequence_generate_symbol(ptr noundef, i32 noundef) local_unnamed_addr #2

declare i32 @msequence_destroy(ptr noundef) local_unnamed_addr #2

declare ptr @firfilt_crcf_create(ptr noundef, i32 noundef) local_unnamed_addr #2

declare ptr @firpfbch_crcf_create(i32 noundef, i32 noundef, i32 noundef, ptr noundef) local_unnamed_addr #2

declare i32 @firpfbch_crcf_synthesizer_execute(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @firfilt_crcf_reset(ptr noundef) local_unnamed_addr #2

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #3

declare i32 @firfilt_crcf_push(ptr noundef, <2 x float> noundef) local_unnamed_addr #2

declare i32 @firfilt_crcf_execute(ptr noundef, ptr noundef) local_unnamed_addr #2

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

declare <2 x float> @__mulsc3(float, float, float, float) local_unnamed_addr

declare i32 @firfilt_crcf_destroy(ptr noundef) local_unnamed_addr #2

declare i32 @firpfbch_crcf_destroy(ptr noundef) local_unnamed_addr #2

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

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

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

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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind "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 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #9 = { nounwind }
attributes #10 = { noreturn nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = !{!"branch_weights", i32 1, i32 1048575}
!12 = distinct !{!12, !10}
!13 = !{!14, !14, i64 0}
!14 = !{!"int", !7, i64 0}
!15 = distinct !{!15, !10}


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