; LLVM IR from suxiaojack/sapDecoder :: src/equalizer.ll (ZN9Equalizer9EqzFilterEPfS0_ii)

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

%class.Equalizer = type { ptr }
%struct.eq_param_t = type { i32, ptr, ptr, ptr, ptr, float, [32 x [2 x float]], [32 x [128 x [2 x float]]], [32 x [2 x float]], [32 x [128 x [2 x float]]], i32 }

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

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

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

20:                                               ; preds = %363, %5
  %21 = load i32, ptr %11, align 4, !tbaa !9
  %22 = load i32, ptr %9, align 4, !tbaa !9
  %23 = icmp slt i32 %21, %22
  br i1 %23, label %24, label %366

24:                                               ; preds = %20
  store i32 0, ptr %12, align 4, !tbaa !9
  br label %25

25:                                               ; preds = %351, %24
  %26 = load i32, ptr %12, align 4, !tbaa !9
  %27 = load i32, ptr %10, align 4, !tbaa !9
  %28 = icmp slt i32 %26, %27
  br i1 %28, label %29, label %354

29:                                               ; preds = %25
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #3
  %30 = load ptr, ptr %8, align 8, !tbaa !5
  %31 = load i32, ptr %12, align 4, !tbaa !9
  %32 = sext i32 %31 to i64
  %33 = getelementptr inbounds float, ptr %30, i64 %32
  %34 = load float, ptr %33, align 4, !tbaa !11
  store float %34, ptr %14, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #3
  store float 0.000000e+00, ptr %15, align 4, !tbaa !11
  store i32 0, ptr %13, align 4, !tbaa !9
  br label %35

35:                                               ; preds = %146, %29
  %36 = load i32, ptr %13, align 4, !tbaa !9
  %37 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %38 = load ptr, ptr %37, align 8, !tbaa !13
  %39 = getelementptr inbounds %struct.eq_param_t, ptr %38, i32 0, i32 0
  %40 = load i32, ptr %39, align 8, !tbaa !15
  %41 = icmp slt i32 %36, %40
  br i1 %41, label %42, label %149

42:                                               ; preds = %35
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #3
  %43 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %44 = load ptr, ptr %43, align 8, !tbaa !13
  %45 = getelementptr inbounds %struct.eq_param_t, ptr %44, i32 0, i32 1
  %46 = load ptr, ptr %45, align 8, !tbaa !17
  %47 = load i32, ptr %13, align 4, !tbaa !9
  %48 = sext i32 %47 to i64
  %49 = getelementptr inbounds float, ptr %46, i64 %48
  %50 = load float, ptr %49, align 4, !tbaa !11
  %51 = load float, ptr %14, align 4, !tbaa !11
  %52 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %53 = load ptr, ptr %52, align 8, !tbaa !13
  %54 = getelementptr inbounds %struct.eq_param_t, ptr %53, i32 0, i32 6
  %55 = load i32, ptr %12, align 4, !tbaa !9
  %56 = sext i32 %55 to i64
  %57 = getelementptr inbounds [32 x [2 x float]], ptr %54, i64 0, i64 %56
  %58 = getelementptr inbounds [2 x float], ptr %57, i64 0, i64 1
  %59 = load float, ptr %58, align 4, !tbaa !11
  %60 = fsub float %51, %59
  %61 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %62 = load ptr, ptr %61, align 8, !tbaa !13
  %63 = getelementptr inbounds %struct.eq_param_t, ptr %62, i32 0, i32 3
  %64 = load ptr, ptr %63, align 8, !tbaa !18
  %65 = load i32, ptr %13, align 4, !tbaa !9
  %66 = sext i32 %65 to i64
  %67 = getelementptr inbounds float, ptr %64, i64 %66
  %68 = load float, ptr %67, align 4, !tbaa !11
  %69 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %70 = load ptr, ptr %69, align 8, !tbaa !13
  %71 = getelementptr inbounds %struct.eq_param_t, ptr %70, i32 0, i32 7
  %72 = load i32, ptr %12, align 4, !tbaa !9
  %73 = sext i32 %72 to i64
  %74 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %71, i64 0, i64 %73
  %75 = load i32, ptr %13, align 4, !tbaa !9
  %76 = sext i32 %75 to i64
  %77 = getelementptr inbounds [128 x [2 x float]], ptr %74, i64 0, i64 %76
  %78 = getelementptr inbounds [2 x float], ptr %77, i64 0, i64 0
  %79 = load float, ptr %78, align 4, !tbaa !11
  %80 = fmul float %68, %79
  %81 = call float @llvm.fmuladd.f32(float %50, float %60, float %80)
  %82 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %83 = load ptr, ptr %82, align 8, !tbaa !13
  %84 = getelementptr inbounds %struct.eq_param_t, ptr %83, i32 0, i32 2
  %85 = load ptr, ptr %84, align 8, !tbaa !19
  %86 = load i32, ptr %13, align 4, !tbaa !9
  %87 = sext i32 %86 to i64
  %88 = getelementptr inbounds float, ptr %85, i64 %87
  %89 = load float, ptr %88, align 4, !tbaa !11
  %90 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %91 = load ptr, ptr %90, align 8, !tbaa !13
  %92 = getelementptr inbounds %struct.eq_param_t, ptr %91, i32 0, i32 7
  %93 = load i32, ptr %12, align 4, !tbaa !9
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %92, i64 0, i64 %94
  %96 = load i32, ptr %13, align 4, !tbaa !9
  %97 = sext i32 %96 to i64
  %98 = getelementptr inbounds [128 x [2 x float]], ptr %95, i64 0, i64 %97
  %99 = getelementptr inbounds [2 x float], ptr %98, i64 0, i64 1
  %100 = load float, ptr %99, align 4, !tbaa !11
  %101 = fneg float %89
  %102 = call float @llvm.fmuladd.f32(float %101, float %100, float %81)
  store float %102, ptr %16, align 4, !tbaa !11
  %103 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %104 = load ptr, ptr %103, align 8, !tbaa !13
  %105 = getelementptr inbounds %struct.eq_param_t, ptr %104, i32 0, i32 7
  %106 = load i32, ptr %12, align 4, !tbaa !9
  %107 = sext i32 %106 to i64
  %108 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %105, i64 0, i64 %107
  %109 = load i32, ptr %13, align 4, !tbaa !9
  %110 = sext i32 %109 to i64
  %111 = getelementptr inbounds [128 x [2 x float]], ptr %108, i64 0, i64 %110
  %112 = getelementptr inbounds [2 x float], ptr %111, i64 0, i64 0
  %113 = load float, ptr %112, align 4, !tbaa !11
  %114 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %115 = load ptr, ptr %114, align 8, !tbaa !13
  %116 = getelementptr inbounds %struct.eq_param_t, ptr %115, i32 0, i32 7
  %117 = load i32, ptr %12, align 4, !tbaa !9
  %118 = sext i32 %117 to i64
  %119 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %116, i64 0, i64 %118
  %120 = load i32, ptr %13, align 4, !tbaa !9
  %121 = sext i32 %120 to i64
  %122 = getelementptr inbounds [128 x [2 x float]], ptr %119, i64 0, i64 %121
  %123 = getelementptr inbounds [2 x float], ptr %122, i64 0, i64 1
  store float %113, ptr %123, align 4, !tbaa !11
  %124 = load float, ptr %16, align 4, !tbaa !11
  %125 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %126 = load ptr, ptr %125, align 8, !tbaa !13
  %127 = getelementptr inbounds %struct.eq_param_t, ptr %126, i32 0, i32 7
  %128 = load i32, ptr %12, align 4, !tbaa !9
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %127, i64 0, i64 %129
  %131 = load i32, ptr %13, align 4, !tbaa !9
  %132 = sext i32 %131 to i64
  %133 = getelementptr inbounds [128 x [2 x float]], ptr %130, i64 0, i64 %132
  %134 = getelementptr inbounds [2 x float], ptr %133, i64 0, i64 0
  store float %124, ptr %134, align 4, !tbaa !11
  %135 = load float, ptr %16, align 4, !tbaa !11
  %136 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %137 = load ptr, ptr %136, align 8, !tbaa !13
  %138 = getelementptr inbounds %struct.eq_param_t, ptr %137, i32 0, i32 4
  %139 = load ptr, ptr %138, align 8, !tbaa !20
  %140 = load i32, ptr %13, align 4, !tbaa !9
  %141 = sext i32 %140 to i64
  %142 = getelementptr inbounds float, ptr %139, i64 %141
  %143 = load float, ptr %142, align 4, !tbaa !11
  %144 = load float, ptr %15, align 4, !tbaa !11
  %145 = call float @llvm.fmuladd.f32(float %135, float %143, float %144)
  store float %145, ptr %15, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #3
  br label %146

146:                                              ; preds = %42
  %147 = load i32, ptr %13, align 4, !tbaa !9
  %148 = add nsw i32 %147, 1
  store i32 %148, ptr %13, align 4, !tbaa !9
  br label %35, !llvm.loop !21

149:                                              ; preds = %35
  %150 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %151 = load ptr, ptr %150, align 8, !tbaa !13
  %152 = getelementptr inbounds %struct.eq_param_t, ptr %151, i32 0, i32 6
  %153 = load i32, ptr %12, align 4, !tbaa !9
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds [32 x [2 x float]], ptr %152, i64 0, i64 %154
  %156 = getelementptr inbounds [2 x float], ptr %155, i64 0, i64 0
  %157 = load float, ptr %156, align 4, !tbaa !11
  %158 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %159 = load ptr, ptr %158, align 8, !tbaa !13
  %160 = getelementptr inbounds %struct.eq_param_t, ptr %159, i32 0, i32 6
  %161 = load i32, ptr %12, align 4, !tbaa !9
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds [32 x [2 x float]], ptr %160, i64 0, i64 %162
  %164 = getelementptr inbounds [2 x float], ptr %163, i64 0, i64 1
  store float %157, ptr %164, align 4, !tbaa !11
  %165 = load float, ptr %14, align 4, !tbaa !11
  %166 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %167 = load ptr, ptr %166, align 8, !tbaa !13
  %168 = getelementptr inbounds %struct.eq_param_t, ptr %167, i32 0, i32 6
  %169 = load i32, ptr %12, align 4, !tbaa !9
  %170 = sext i32 %169 to i64
  %171 = getelementptr inbounds [32 x [2 x float]], ptr %168, i64 0, i64 %170
  %172 = getelementptr inbounds [2 x float], ptr %171, i64 0, i64 0
  store float %165, ptr %172, align 4, !tbaa !11
  %173 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %174 = load ptr, ptr %173, align 8, !tbaa !13
  %175 = getelementptr inbounds %struct.eq_param_t, ptr %174, i32 0, i32 10
  %176 = load i32, ptr %175, align 4, !tbaa !23
  %177 = icmp ne i32 %176, 0
  br i1 %177, label %178, label %337

178:                                              ; preds = %149
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #3
  %179 = load float, ptr %14, align 4, !tbaa !11
  %180 = load float, ptr %15, align 4, !tbaa !11
  %181 = call float @llvm.fmuladd.f32(float 2.500000e-01, float %179, float %180)
  store float %181, ptr %17, align 4, !tbaa !11
  store float 0.000000e+00, ptr %15, align 4, !tbaa !11
  store i32 0, ptr %13, align 4, !tbaa !9
  br label %182

182:                                              ; preds = %293, %178
  %183 = load i32, ptr %13, align 4, !tbaa !9
  %184 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %185 = load ptr, ptr %184, align 8, !tbaa !13
  %186 = getelementptr inbounds %struct.eq_param_t, ptr %185, i32 0, i32 0
  %187 = load i32, ptr %186, align 8, !tbaa !15
  %188 = icmp slt i32 %183, %187
  br i1 %188, label %189, label %296

189:                                              ; preds = %182
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #3
  %190 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %191 = load ptr, ptr %190, align 8, !tbaa !13
  %192 = getelementptr inbounds %struct.eq_param_t, ptr %191, i32 0, i32 1
  %193 = load ptr, ptr %192, align 8, !tbaa !17
  %194 = load i32, ptr %13, align 4, !tbaa !9
  %195 = sext i32 %194 to i64
  %196 = getelementptr inbounds float, ptr %193, i64 %195
  %197 = load float, ptr %196, align 4, !tbaa !11
  %198 = load float, ptr %17, align 4, !tbaa !11
  %199 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %200 = load ptr, ptr %199, align 8, !tbaa !13
  %201 = getelementptr inbounds %struct.eq_param_t, ptr %200, i32 0, i32 8
  %202 = load i32, ptr %12, align 4, !tbaa !9
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds [32 x [2 x float]], ptr %201, i64 0, i64 %203
  %205 = getelementptr inbounds [2 x float], ptr %204, i64 0, i64 1
  %206 = load float, ptr %205, align 4, !tbaa !11
  %207 = fsub float %198, %206
  %208 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %209 = load ptr, ptr %208, align 8, !tbaa !13
  %210 = getelementptr inbounds %struct.eq_param_t, ptr %209, i32 0, i32 3
  %211 = load ptr, ptr %210, align 8, !tbaa !18
  %212 = load i32, ptr %13, align 4, !tbaa !9
  %213 = sext i32 %212 to i64
  %214 = getelementptr inbounds float, ptr %211, i64 %213
  %215 = load float, ptr %214, align 4, !tbaa !11
  %216 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %217 = load ptr, ptr %216, align 8, !tbaa !13
  %218 = getelementptr inbounds %struct.eq_param_t, ptr %217, i32 0, i32 9
  %219 = load i32, ptr %12, align 4, !tbaa !9
  %220 = sext i32 %219 to i64
  %221 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %218, i64 0, i64 %220
  %222 = load i32, ptr %13, align 4, !tbaa !9
  %223 = sext i32 %222 to i64
  %224 = getelementptr inbounds [128 x [2 x float]], ptr %221, i64 0, i64 %223
  %225 = getelementptr inbounds [2 x float], ptr %224, i64 0, i64 0
  %226 = load float, ptr %225, align 4, !tbaa !11
  %227 = fmul float %215, %226
  %228 = call float @llvm.fmuladd.f32(float %197, float %207, float %227)
  %229 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %230 = load ptr, ptr %229, align 8, !tbaa !13
  %231 = getelementptr inbounds %struct.eq_param_t, ptr %230, i32 0, i32 2
  %232 = load ptr, ptr %231, align 8, !tbaa !19
  %233 = load i32, ptr %13, align 4, !tbaa !9
  %234 = sext i32 %233 to i64
  %235 = getelementptr inbounds float, ptr %232, i64 %234
  %236 = load float, ptr %235, align 4, !tbaa !11
  %237 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %238 = load ptr, ptr %237, align 8, !tbaa !13
  %239 = getelementptr inbounds %struct.eq_param_t, ptr %238, i32 0, i32 9
  %240 = load i32, ptr %12, align 4, !tbaa !9
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %239, i64 0, i64 %241
  %243 = load i32, ptr %13, align 4, !tbaa !9
  %244 = sext i32 %243 to i64
  %245 = getelementptr inbounds [128 x [2 x float]], ptr %242, i64 0, i64 %244
  %246 = getelementptr inbounds [2 x float], ptr %245, i64 0, i64 1
  %247 = load float, ptr %246, align 4, !tbaa !11
  %248 = fneg float %236
  %249 = call float @llvm.fmuladd.f32(float %248, float %247, float %228)
  store float %249, ptr %18, align 4, !tbaa !11
  %250 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %251 = load ptr, ptr %250, align 8, !tbaa !13
  %252 = getelementptr inbounds %struct.eq_param_t, ptr %251, i32 0, i32 9
  %253 = load i32, ptr %12, align 4, !tbaa !9
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %252, i64 0, i64 %254
  %256 = load i32, ptr %13, align 4, !tbaa !9
  %257 = sext i32 %256 to i64
  %258 = getelementptr inbounds [128 x [2 x float]], ptr %255, i64 0, i64 %257
  %259 = getelementptr inbounds [2 x float], ptr %258, i64 0, i64 0
  %260 = load float, ptr %259, align 4, !tbaa !11
  %261 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %262 = load ptr, ptr %261, align 8, !tbaa !13
  %263 = getelementptr inbounds %struct.eq_param_t, ptr %262, i32 0, i32 9
  %264 = load i32, ptr %12, align 4, !tbaa !9
  %265 = sext i32 %264 to i64
  %266 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %263, i64 0, i64 %265
  %267 = load i32, ptr %13, align 4, !tbaa !9
  %268 = sext i32 %267 to i64
  %269 = getelementptr inbounds [128 x [2 x float]], ptr %266, i64 0, i64 %268
  %270 = getelementptr inbounds [2 x float], ptr %269, i64 0, i64 1
  store float %260, ptr %270, align 4, !tbaa !11
  %271 = load float, ptr %18, align 4, !tbaa !11
  %272 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %273 = load ptr, ptr %272, align 8, !tbaa !13
  %274 = getelementptr inbounds %struct.eq_param_t, ptr %273, i32 0, i32 9
  %275 = load i32, ptr %12, align 4, !tbaa !9
  %276 = sext i32 %275 to i64
  %277 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %274, i64 0, i64 %276
  %278 = load i32, ptr %13, align 4, !tbaa !9
  %279 = sext i32 %278 to i64
  %280 = getelementptr inbounds [128 x [2 x float]], ptr %277, i64 0, i64 %279
  %281 = getelementptr inbounds [2 x float], ptr %280, i64 0, i64 0
  store float %271, ptr %281, align 4, !tbaa !11
  %282 = load float, ptr %18, align 4, !tbaa !11
  %283 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %284 = load ptr, ptr %283, align 8, !tbaa !13
  %285 = getelementptr inbounds %struct.eq_param_t, ptr %284, i32 0, i32 4
  %286 = load ptr, ptr %285, align 8, !tbaa !20
  %287 = load i32, ptr %13, align 4, !tbaa !9
  %288 = sext i32 %287 to i64
  %289 = getelementptr inbounds float, ptr %286, i64 %288
  %290 = load float, ptr %289, align 4, !tbaa !11
  %291 = load float, ptr %15, align 4, !tbaa !11
  %292 = call float @llvm.fmuladd.f32(float %282, float %290, float %291)
  store float %292, ptr %15, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #3
  br label %293

293:                                              ; preds = %189
  %294 = load i32, ptr %13, align 4, !tbaa !9
  %295 = add nsw i32 %294, 1
  store i32 %295, ptr %13, align 4, !tbaa !9
  br label %182, !llvm.loop !24

296:                                              ; preds = %182
  %297 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %298 = load ptr, ptr %297, align 8, !tbaa !13
  %299 = getelementptr inbounds %struct.eq_param_t, ptr %298, i32 0, i32 8
  %300 = load i32, ptr %12, align 4, !tbaa !9
  %301 = sext i32 %300 to i64
  %302 = getelementptr inbounds [32 x [2 x float]], ptr %299, i64 0, i64 %301
  %303 = getelementptr inbounds [2 x float], ptr %302, i64 0, i64 0
  %304 = load float, ptr %303, align 4, !tbaa !11
  %305 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %306 = load ptr, ptr %305, align 8, !tbaa !13
  %307 = getelementptr inbounds %struct.eq_param_t, ptr %306, i32 0, i32 8
  %308 = load i32, ptr %12, align 4, !tbaa !9
  %309 = sext i32 %308 to i64
  %310 = getelementptr inbounds [32 x [2 x float]], ptr %307, i64 0, i64 %309
  %311 = getelementptr inbounds [2 x float], ptr %310, i64 0, i64 1
  store float %304, ptr %311, align 4, !tbaa !11
  %312 = load float, ptr %17, align 4, !tbaa !11
  %313 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %314 = load ptr, ptr %313, align 8, !tbaa !13
  %315 = getelementptr inbounds %struct.eq_param_t, ptr %314, i32 0, i32 8
  %316 = load i32, ptr %12, align 4, !tbaa !9
  %317 = sext i32 %316 to i64
  %318 = getelementptr inbounds [32 x [2 x float]], ptr %315, i64 0, i64 %317
  %319 = getelementptr inbounds [2 x float], ptr %318, i64 0, i64 0
  store float %312, ptr %319, align 4, !tbaa !11
  %320 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %321 = load ptr, ptr %320, align 8, !tbaa !13
  %322 = getelementptr inbounds %struct.eq_param_t, ptr %321, i32 0, i32 5
  %323 = load float, ptr %322, align 8, !tbaa !25
  %324 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %325 = load ptr, ptr %324, align 8, !tbaa !13
  %326 = getelementptr inbounds %struct.eq_param_t, ptr %325, i32 0, i32 5
  %327 = load float, ptr %326, align 8, !tbaa !25
  %328 = fmul float %323, %327
  %329 = load float, ptr %17, align 4, !tbaa !11
  %330 = load float, ptr %15, align 4, !tbaa !11
  %331 = call float @llvm.fmuladd.f32(float 2.500000e-01, float %329, float %330)
  %332 = fmul float %328, %331
  %333 = load ptr, ptr %7, align 8, !tbaa !5
  %334 = load i32, ptr %12, align 4, !tbaa !9
  %335 = sext i32 %334 to i64
  %336 = getelementptr inbounds float, ptr %333, i64 %335
  store float %332, ptr %336, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #3
  br label %350

337:                                              ; preds = %149
  %338 = getelementptr inbounds %class.Equalizer, ptr %19, i32 0, i32 0
  %339 = load ptr, ptr %338, align 8, !tbaa !13
  %340 = getelementptr inbounds %struct.eq_param_t, ptr %339, i32 0, i32 5
  %341 = load float, ptr %340, align 8, !tbaa !25
  %342 = load float, ptr %14, align 4, !tbaa !11
  %343 = load float, ptr %15, align 4, !tbaa !11
  %344 = call float @llvm.fmuladd.f32(float 2.500000e-01, float %342, float %343)
  %345 = fmul float %341, %344
  %346 = load ptr, ptr %7, align 8, !tbaa !5
  %347 = load i32, ptr %12, align 4, !tbaa !9
  %348 = sext i32 %347 to i64
  %349 = getelementptr inbounds float, ptr %346, i64 %348
  store float %345, ptr %349, align 4, !tbaa !11
  br label %350

350:                                              ; preds = %337, %296
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  br label %351

351:                                              ; preds = %350
  %352 = load i32, ptr %12, align 4, !tbaa !9
  %353 = add nsw i32 %352, 1
  store i32 %353, ptr %12, align 4, !tbaa !9
  br label %25, !llvm.loop !26

354:                                              ; preds = %25
  %355 = load i32, ptr %10, align 4, !tbaa !9
  %356 = load ptr, ptr %8, align 8, !tbaa !5
  %357 = sext i32 %355 to i64
  %358 = getelementptr inbounds float, ptr %356, i64 %357
  store ptr %358, ptr %8, align 8, !tbaa !5
  %359 = load i32, ptr %10, align 4, !tbaa !9
  %360 = load ptr, ptr %7, align 8, !tbaa !5
  %361 = sext i32 %359 to i64
  %362 = getelementptr inbounds float, ptr %360, i64 %361
  store ptr %362, ptr %7, align 8, !tbaa !5
  br label %363

363:                                              ; preds = %354
  %364 = load i32, ptr %11, align 4, !tbaa !9
  %365 = add nsw i32 %364, 1
  store i32 %365, ptr %11, align 4, !tbaa !9
  br label %20, !llvm.loop !27

366:                                              ; preds = %20
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #3
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #2

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { mustprogress 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 #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!14, !6, i64 0}
!14 = !{!"_ZTS9Equalizer", !6, i64 0}
!15 = !{!16, !10, i64 0}
!16 = !{!"_ZTS10eq_param_t", !10, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !12, i64 40, !7, i64 44, !7, i64 300, !7, i64 33068, !7, i64 33324, !10, i64 66092}
!17 = !{!16, !6, i64 8}
!18 = !{!16, !6, i64 24}
!19 = !{!16, !6, i64 16}
!20 = !{!16, !6, i64 32}
!21 = distinct !{!21, !22}
!22 = !{!"llvm.loop.mustprogress"}
!23 = !{!16, !10, i64 66092}
!24 = distinct !{!24, !22}
!25 = !{!16, !12, i64 40}
!26 = distinct !{!26, !22}
!27 = distinct !{!27, !22}


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

; Function Attrs: mustprogress nofree norecurse nosync nounwind memory(readwrite, inaccessiblemem: none) uwtable
define dso_local void @_ZN9Equalizer9EqzFilterEPfS0_ii(ptr nocapture noundef nonnull readonly align 8 dereferenceable(8) %0, ptr nocapture noundef writeonly %1, ptr nocapture noundef readonly %2, i32 noundef %3, i32 noundef %4) local_unnamed_addr #0 align 2 {
  %6 = icmp sgt i32 %3, 0
  br i1 %6, label %.preheader.lr.ph, label %._crit_edge100

.preheader.lr.ph:                                 ; preds = %5
  %7 = icmp sgt i32 %4, 0
  %8 = load ptr, ptr %0, align 8
  %9 = getelementptr inbounds i8, ptr %8, i64 8
  %10 = getelementptr inbounds i8, ptr %8, i64 44
  %11 = getelementptr inbounds i8, ptr %8, i64 24
  %12 = getelementptr inbounds i8, ptr %8, i64 300
  %13 = getelementptr inbounds i8, ptr %8, i64 16
  %14 = getelementptr inbounds i8, ptr %8, i64 32
  %15 = getelementptr inbounds i8, ptr %8, i64 33068
  %16 = getelementptr inbounds i8, ptr %8, i64 33324
  %17 = getelementptr inbounds i8, ptr %8, i64 40
  %18 = sext i32 %4 to i64
  br i1 %7, label %.preheader.lr.ph.split.us, label %._crit_edge100

.preheader.lr.ph.split.us:                        ; preds = %.preheader.lr.ph
  %19 = getelementptr inbounds i8, ptr %8, i64 66092
  %20 = load i32, ptr %8, align 8, !tbaa !5
  %21 = icmp sgt i32 %20, 0
  %22 = load i32, ptr %19, align 4, !tbaa !12
  %.not.us = icmp eq i32 %22, 0
  br i1 %.not.us, label %.preheader.lr.ph.split.us.split.us, label %.preheader.us.preheader

.preheader.us.preheader:                          ; preds = %.preheader.lr.ph.split.us
  %wide.trip.count121 = zext nneg i32 %4 to i64
  %wide.trip.count = zext nneg i32 %20 to i64
  %wide.trip.count116 = zext nneg i32 %20 to i64
  br label %.preheader.us

.preheader.lr.ph.split.us.split.us:               ; preds = %.preheader.lr.ph.split.us
  br i1 %21, label %.preheader.lr.ph.split.us.split.us.split.us, label %.preheader.us.us.preheader

.preheader.us.us.preheader:                       ; preds = %.preheader.lr.ph.split.us.split.us
  %wide.trip.count127 = zext nneg i32 %4 to i64
  %xtraiter = and i64 %wide.trip.count127, 1
  %23 = icmp eq i32 %4, 1
  %unroll_iter = and i64 %wide.trip.count127, 2147483646
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br label %.preheader.us.us

.preheader.lr.ph.split.us.split.us.split.us:      ; preds = %.preheader.lr.ph.split.us.split.us
  %24 = load ptr, ptr %9, align 8, !tbaa !13
  %25 = load ptr, ptr %11, align 8, !tbaa !14
  %26 = load ptr, ptr %13, align 8, !tbaa !15
  %27 = load ptr, ptr %14, align 8, !tbaa !16
  %wide.trip.count138 = zext nneg i32 %4 to i64
  %wide.trip.count133 = zext nneg i32 %20 to i64
  br label %.preheader.us.us.us

.preheader.us.us.us:                              ; preds = %._crit_edge92.split.us.split.us.us.us.us, %.preheader.lr.ph.split.us.split.us.split.us
  %.097.us.us.us = phi ptr [ %1, %.preheader.lr.ph.split.us.split.us.split.us ], [ %59, %._crit_edge92.split.us.split.us.us.us.us ]
  %.07294.us.us.us = phi ptr [ %2, %.preheader.lr.ph.split.us.split.us.split.us ], [ %58, %._crit_edge92.split.us.split.us.us.us.us ]
  %.07393.us.us.us = phi i32 [ 0, %.preheader.lr.ph.split.us.split.us.split.us ], [ %60, %._crit_edge92.split.us.split.us.us.us.us ]
  br label %.lr.ph.us.us.us.us.us

.lr.ph.us.us.us.us.us:                            ; preds = %._crit_edge.us.us.us.us.us, %.preheader.us.us.us
  %indvars.iv135 = phi i64 [ %indvars.iv.next136, %._crit_edge.us.us.us.us.us ], [ 0, %.preheader.us.us.us ]
  %28 = getelementptr inbounds float, ptr %.07294.us.us.us, i64 %indvars.iv135
  %29 = load float, ptr %28, align 4, !tbaa !17
  %30 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv135, i64 1
  br label %31

31:                                               ; preds = %31, %.lr.ph.us.us.us.us.us
  %indvars.iv130 = phi i64 [ %indvars.iv.next131, %31 ], [ 0, %.lr.ph.us.us.us.us.us ]
  %.07481.us.us.us.us.us = phi float [ %50, %31 ], [ 0.000000e+00, %.lr.ph.us.us.us.us.us ]
  %32 = getelementptr inbounds float, ptr %24, i64 %indvars.iv130
  %33 = load float, ptr %32, align 4, !tbaa !17
  %34 = load float, ptr %30, align 4, !tbaa !17
  %35 = fsub float %29, %34
  %36 = getelementptr inbounds float, ptr %25, i64 %indvars.iv130
  %37 = load float, ptr %36, align 4, !tbaa !17
  %38 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %12, i64 0, i64 %indvars.iv135, i64 %indvars.iv130
  %39 = load float, ptr %38, align 4, !tbaa !17
  %40 = fmul float %37, %39
  %41 = tail call float @llvm.fmuladd.f32(float %33, float %35, float %40)
  %42 = getelementptr inbounds float, ptr %26, i64 %indvars.iv130
  %43 = load float, ptr %42, align 4, !tbaa !17
  %44 = getelementptr inbounds i8, ptr %38, i64 4
  %45 = load float, ptr %44, align 4, !tbaa !17
  %46 = fneg float %43
  %47 = tail call float @llvm.fmuladd.f32(float %46, float %45, float %41)
  store float %39, ptr %44, align 4, !tbaa !17
  store float %47, ptr %38, align 4, !tbaa !17
  %48 = getelementptr inbounds float, ptr %27, i64 %indvars.iv130
  %49 = load float, ptr %48, align 4, !tbaa !17
  %50 = tail call float @llvm.fmuladd.f32(float %47, float %49, float %.07481.us.us.us.us.us)
  %indvars.iv.next131 = add nuw nsw i64 %indvars.iv130, 1
  %exitcond134.not = icmp eq i64 %indvars.iv.next131, %wide.trip.count133
  br i1 %exitcond134.not, label %._crit_edge.us.us.us.us.us, label %31, !llvm.loop !18

._crit_edge.us.us.us.us.us:                       ; preds = %31
  %51 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv135
  %52 = load float, ptr %51, align 4, !tbaa !17
  %53 = getelementptr inbounds i8, ptr %51, i64 4
  store float %52, ptr %53, align 4, !tbaa !17
  store float %29, ptr %51, align 4, !tbaa !17
  %54 = load float, ptr %17, align 8, !tbaa !20
  %55 = tail call float @llvm.fmuladd.f32(float %29, float 2.500000e-01, float %50)
  %56 = fmul float %55, %54
  %57 = getelementptr inbounds float, ptr %.097.us.us.us, i64 %indvars.iv135
  store float %56, ptr %57, align 4, !tbaa !17
  %indvars.iv.next136 = add nuw nsw i64 %indvars.iv135, 1
  %exitcond139.not = icmp eq i64 %indvars.iv.next136, %wide.trip.count138
  br i1 %exitcond139.not, label %._crit_edge92.split.us.split.us.us.us.us, label %.lr.ph.us.us.us.us.us, !llvm.loop !21

._crit_edge92.split.us.split.us.us.us.us:         ; preds = %._crit_edge.us.us.us.us.us
  %58 = getelementptr inbounds float, ptr %.07294.us.us.us, i64 %18
  %59 = getelementptr inbounds float, ptr %.097.us.us.us, i64 %18
  %60 = add nuw nsw i32 %.07393.us.us.us, 1
  %exitcond140.not = icmp eq i32 %60, %3
  br i1 %exitcond140.not, label %._crit_edge100, label %.preheader.us.us.us, !llvm.loop !22

.preheader.us.us:                                 ; preds = %.preheader.us.us.preheader, %._crit_edge92.split.us.split.us105.us
  %.097.us.us = phi ptr [ %89, %._crit_edge92.split.us.split.us105.us ], [ %1, %.preheader.us.us.preheader ]
  %.07294.us.us = phi ptr [ %88, %._crit_edge92.split.us.split.us105.us ], [ %2, %.preheader.us.us.preheader ]
  %.07393.us.us = phi i32 [ %90, %._crit_edge92.split.us.split.us105.us ], [ 0, %.preheader.us.us.preheader ]
  br i1 %23, label %._crit_edge92.split.us.split.us105.us.unr-lcssa, label %.preheader.us.us.new

.preheader.us.us.new:                             ; preds = %.preheader.us.us, %.preheader.us.us.new
  %indvars.iv124 = phi i64 [ %indvars.iv.next125.1, %.preheader.us.us.new ], [ 0, %.preheader.us.us ]
  %niter = phi i64 [ %niter.next.1, %.preheader.us.us.new ], [ 0, %.preheader.us.us ]
  %61 = getelementptr inbounds float, ptr %.07294.us.us, i64 %indvars.iv124
  %62 = load float, ptr %61, align 4, !tbaa !17
  %63 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv124
  %64 = load float, ptr %63, align 4, !tbaa !17
  %65 = getelementptr inbounds i8, ptr %63, i64 4
  store float %64, ptr %65, align 4, !tbaa !17
  store float %62, ptr %63, align 4, !tbaa !17
  %66 = load float, ptr %17, align 8, !tbaa !20
  %67 = tail call float @llvm.fmuladd.f32(float %62, float 2.500000e-01, float 0.000000e+00)
  %68 = fmul float %67, %66
  %69 = getelementptr inbounds float, ptr %.097.us.us, i64 %indvars.iv124
  store float %68, ptr %69, align 4, !tbaa !17
  %indvars.iv.next125 = or disjoint i64 %indvars.iv124, 1
  %70 = getelementptr inbounds float, ptr %.07294.us.us, i64 %indvars.iv.next125
  %71 = load float, ptr %70, align 4, !tbaa !17
  %72 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv.next125
  %73 = load float, ptr %72, align 4, !tbaa !17
  %74 = getelementptr inbounds i8, ptr %72, i64 4
  store float %73, ptr %74, align 4, !tbaa !17
  store float %71, ptr %72, align 4, !tbaa !17
  %75 = load float, ptr %17, align 8, !tbaa !20
  %76 = tail call float @llvm.fmuladd.f32(float %71, float 2.500000e-01, float 0.000000e+00)
  %77 = fmul float %76, %75
  %78 = getelementptr inbounds float, ptr %.097.us.us, i64 %indvars.iv.next125
  store float %77, ptr %78, align 4, !tbaa !17
  %indvars.iv.next125.1 = add nuw nsw i64 %indvars.iv124, 2
  %niter.next.1 = add i64 %niter, 2
  %niter.ncmp.1 = icmp eq i64 %niter.next.1, %unroll_iter
  br i1 %niter.ncmp.1, label %._crit_edge92.split.us.split.us105.us.unr-lcssa, label %.preheader.us.us.new, !llvm.loop !21

._crit_edge92.split.us.split.us105.us.unr-lcssa:  ; preds = %.preheader.us.us.new, %.preheader.us.us
  %indvars.iv124.unr = phi i64 [ 0, %.preheader.us.us ], [ %indvars.iv.next125.1, %.preheader.us.us.new ]
  br i1 %lcmp.mod.not, label %._crit_edge92.split.us.split.us105.us, label %._crit_edge92.split.us.split.us105.us.epilog-lcssa

._crit_edge92.split.us.split.us105.us.epilog-lcssa: ; preds = %._crit_edge92.split.us.split.us105.us.unr-lcssa
  %79 = getelementptr inbounds float, ptr %.07294.us.us, i64 %indvars.iv124.unr
  %80 = load float, ptr %79, align 4, !tbaa !17
  %81 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv124.unr
  %82 = load float, ptr %81, align 4, !tbaa !17
  %83 = getelementptr inbounds i8, ptr %81, i64 4
  store float %82, ptr %83, align 4, !tbaa !17
  store float %80, ptr %81, align 4, !tbaa !17
  %84 = load float, ptr %17, align 8, !tbaa !20
  %85 = tail call float @llvm.fmuladd.f32(float %80, float 2.500000e-01, float 0.000000e+00)
  %86 = fmul float %85, %84
  %87 = getelementptr inbounds float, ptr %.097.us.us, i64 %indvars.iv124.unr
  store float %86, ptr %87, align 4, !tbaa !17
  br label %._crit_edge92.split.us.split.us105.us

._crit_edge92.split.us.split.us105.us:            ; preds = %._crit_edge92.split.us.split.us105.us.unr-lcssa, %._crit_edge92.split.us.split.us105.us.epilog-lcssa
  %88 = getelementptr inbounds float, ptr %.07294.us.us, i64 %18
  %89 = getelementptr inbounds float, ptr %.097.us.us, i64 %18
  %90 = add nuw nsw i32 %.07393.us.us, 1
  %exitcond129.not = icmp eq i32 %90, %3
  br i1 %exitcond129.not, label %._crit_edge100, label %.preheader.us.us, !llvm.loop !22

.preheader.us:                                    ; preds = %.preheader.us.preheader, %._crit_edge92.split.us102
  %.097.us = phi ptr [ %162, %._crit_edge92.split.us102 ], [ %1, %.preheader.us.preheader ]
  %.07294.us = phi ptr [ %161, %._crit_edge92.split.us102 ], [ %2, %.preheader.us.preheader ]
  %.07393.us = phi i32 [ %163, %._crit_edge92.split.us102 ], [ 0, %.preheader.us.preheader ]
  br label %91

91:                                               ; preds = %.preheader.us, %._crit_edge88.us
  %indvars.iv118 = phi i64 [ 0, %.preheader.us ], [ %indvars.iv.next119, %._crit_edge88.us ]
  %92 = getelementptr inbounds float, ptr %.07294.us, i64 %indvars.iv118
  %93 = load float, ptr %92, align 4, !tbaa !17
  br i1 %21, label %.lr.ph.us, label %._crit_edge.us.thread

._crit_edge.us.thread:                            ; preds = %91
  %94 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv118
  %95 = load float, ptr %94, align 4, !tbaa !17
  %96 = getelementptr inbounds i8, ptr %94, i64 4
  store float %95, ptr %96, align 4, !tbaa !17
  store float %93, ptr %94, align 4, !tbaa !17
  %97 = tail call float @llvm.fmuladd.f32(float %93, float 2.500000e-01, float 0.000000e+00)
  br label %._crit_edge88.us

._crit_edge.us:                                   ; preds = %131
  %98 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv118
  %99 = load float, ptr %98, align 4, !tbaa !17
  %100 = getelementptr inbounds i8, ptr %98, i64 4
  store float %99, ptr %100, align 4, !tbaa !17
  store float %93, ptr %98, align 4, !tbaa !17
  %101 = tail call float @llvm.fmuladd.f32(float %93, float 2.500000e-01, float %150)
  br i1 %21, label %.lr.ph87.us, label %._crit_edge88.us

._crit_edge88.us:                                 ; preds = %111, %._crit_edge.us.thread, %._crit_edge.us
  %102 = phi float [ %101, %._crit_edge.us ], [ %97, %._crit_edge.us.thread ], [ %101, %111 ]
  %.1.lcssa.us = phi float [ 0.000000e+00, %._crit_edge.us ], [ 0.000000e+00, %._crit_edge.us.thread ], [ %130, %111 ]
  %103 = getelementptr inbounds [32 x [2 x float]], ptr %15, i64 0, i64 %indvars.iv118
  %104 = load float, ptr %103, align 4, !tbaa !17
  %105 = getelementptr inbounds i8, ptr %103, i64 4
  store float %104, ptr %105, align 4, !tbaa !17
  store float %102, ptr %103, align 4, !tbaa !17
  %106 = load float, ptr %17, align 8, !tbaa !20
  %107 = fmul float %106, %106
  %108 = tail call float @llvm.fmuladd.f32(float %102, float 2.500000e-01, float %.1.lcssa.us)
  %109 = fmul float %108, %107
  %110 = getelementptr inbounds float, ptr %.097.us, i64 %indvars.iv118
  store float %109, ptr %110, align 4, !tbaa !17
  %indvars.iv.next119 = add nuw nsw i64 %indvars.iv118, 1
  %exitcond122.not = icmp eq i64 %indvars.iv.next119, %wide.trip.count121
  br i1 %exitcond122.not, label %._crit_edge92.split.us102, label %91, !llvm.loop !21

111:                                              ; preds = %.lr.ph87.us, %111
  %indvars.iv113 = phi i64 [ 0, %.lr.ph87.us ], [ %indvars.iv.next114, %111 ]
  %.185.us = phi float [ 0.000000e+00, %.lr.ph87.us ], [ %130, %111 ]
  %112 = getelementptr inbounds float, ptr %156, i64 %indvars.iv113
  %113 = load float, ptr %112, align 4, !tbaa !17
  %114 = load float, ptr %157, align 4, !tbaa !17
  %115 = fsub float %101, %114
  %116 = getelementptr inbounds float, ptr %158, i64 %indvars.iv113
  %117 = load float, ptr %116, align 4, !tbaa !17
  %118 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %16, i64 0, i64 %indvars.iv118, i64 %indvars.iv113
  %119 = load float, ptr %118, align 4, !tbaa !17
  %120 = fmul float %117, %119
  %121 = tail call float @llvm.fmuladd.f32(float %113, float %115, float %120)
  %122 = getelementptr inbounds float, ptr %159, i64 %indvars.iv113
  %123 = load float, ptr %122, align 4, !tbaa !17
  %124 = getelementptr inbounds i8, ptr %118, i64 4
  %125 = load float, ptr %124, align 4, !tbaa !17
  %126 = fneg float %123
  %127 = tail call float @llvm.fmuladd.f32(float %126, float %125, float %121)
  store float %119, ptr %124, align 4, !tbaa !17
  store float %127, ptr %118, align 4, !tbaa !17
  %128 = getelementptr inbounds float, ptr %160, i64 %indvars.iv113
  %129 = load float, ptr %128, align 4, !tbaa !17
  %130 = tail call float @llvm.fmuladd.f32(float %127, float %129, float %.185.us)
  %indvars.iv.next114 = add nuw nsw i64 %indvars.iv113, 1
  %exitcond117.not = icmp eq i64 %indvars.iv.next114, %wide.trip.count116
  br i1 %exitcond117.not, label %._crit_edge88.us, label %111, !llvm.loop !23

131:                                              ; preds = %.lr.ph.us, %131
  %indvars.iv = phi i64 [ 0, %.lr.ph.us ], [ %indvars.iv.next, %131 ]
  %.07481.us = phi float [ 0.000000e+00, %.lr.ph.us ], [ %150, %131 ]
  %132 = getelementptr inbounds float, ptr %151, i64 %indvars.iv
  %133 = load float, ptr %132, align 4, !tbaa !17
  %134 = load float, ptr %152, align 4, !tbaa !17
  %135 = fsub float %93, %134
  %136 = getelementptr inbounds float, ptr %153, i64 %indvars.iv
  %137 = load float, ptr %136, align 4, !tbaa !17
  %138 = getelementptr inbounds [32 x [128 x [2 x float]]], ptr %12, i64 0, i64 %indvars.iv118, i64 %indvars.iv
  %139 = load float, ptr %138, align 4, !tbaa !17
  %140 = fmul float %137, %139
  %141 = tail call float @llvm.fmuladd.f32(float %133, float %135, float %140)
  %142 = getelementptr inbounds float, ptr %154, i64 %indvars.iv
  %143 = load float, ptr %142, align 4, !tbaa !17
  %144 = getelementptr inbounds i8, ptr %138, i64 4
  %145 = load float, ptr %144, align 4, !tbaa !17
  %146 = fneg float %143
  %147 = tail call float @llvm.fmuladd.f32(float %146, float %145, float %141)
  store float %139, ptr %144, align 4, !tbaa !17
  store float %147, ptr %138, align 4, !tbaa !17
  %148 = getelementptr inbounds float, ptr %155, i64 %indvars.iv
  %149 = load float, ptr %148, align 4, !tbaa !17
  %150 = tail call float @llvm.fmuladd.f32(float %147, float %149, float %.07481.us)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge.us, label %131, !llvm.loop !18

.lr.ph.us:                                        ; preds = %91
  %151 = load ptr, ptr %9, align 8, !tbaa !13
  %152 = getelementptr inbounds [32 x [2 x float]], ptr %10, i64 0, i64 %indvars.iv118, i64 1
  %153 = load ptr, ptr %11, align 8, !tbaa !14
  %154 = load ptr, ptr %13, align 8, !tbaa !15
  %155 = load ptr, ptr %14, align 8, !tbaa !16
  br label %131

.lr.ph87.us:                                      ; preds = %._crit_edge.us
  %156 = load ptr, ptr %9, align 8, !tbaa !13
  %157 = getelementptr inbounds [32 x [2 x float]], ptr %15, i64 0, i64 %indvars.iv118, i64 1
  %158 = load ptr, ptr %11, align 8, !tbaa !14
  %159 = load ptr, ptr %13, align 8, !tbaa !15
  %160 = load ptr, ptr %14, align 8, !tbaa !16
  br label %111

._crit_edge92.split.us102:                        ; preds = %._crit_edge88.us
  %161 = getelementptr inbounds float, ptr %.07294.us, i64 %18
  %162 = getelementptr inbounds float, ptr %.097.us, i64 %18
  %163 = add nuw nsw i32 %.07393.us, 1
  %exitcond123.not = icmp eq i32 %163, %3
  br i1 %exitcond123.not, label %._crit_edge100, label %.preheader.us, !llvm.loop !22

._crit_edge100:                                   ; preds = %._crit_edge92.split.us102, %._crit_edge92.split.us.split.us105.us, %._crit_edge92.split.us.split.us.us.us.us, %.preheader.lr.ph, %5
  ret void
}

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #1

attributes #0 = { mustprogress nofree norecurse nosync nounwind memory(readwrite, inaccessiblemem: none) 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 speculatable willreturn memory(none) }

!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, !7, i64 0}
!6 = !{!"_ZTS10eq_param_t", !7, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !11, i64 40, !8, i64 44, !8, i64 300, !8, i64 33068, !8, i64 33324, !7, i64 66092}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!"float", !8, i64 0}
!12 = !{!6, !7, i64 66092}
!13 = !{!6, !10, i64 8}
!14 = !{!6, !10, i64 24}
!15 = !{!6, !10, i64 16}
!16 = !{!6, !10, i64 32}
!17 = !{!11, !11, i64 0}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!6, !11, i64 40}
!21 = distinct !{!21, !19}
!22 = distinct !{!22, !19}
!23 = distinct !{!23, !19}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass