; LLVM IR from glaretechnologies/substrata :: opus/opus-1.3.1/silk/float (noise_shape_analysis_FLP)

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

%struct.silk_encoder_state_FLP = type { %struct.silk_encoder_state, %struct.silk_shape_state_FLP, [720 x float], float }
%struct.silk_encoder_state = type { [2 x i32], i32, i32, %struct.silk_LP_state, %struct.silk_VAD_state, %struct.silk_nsq_state, [16 x i16], i32, i32, i8, i8, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ptr, ptr, ptr, [4 x i32], i32, i32, [3 x i8], i8, [3 x i32], %struct.SideInfoIndices, [320 x i8], i32, [322 x i16], i32, i32, i32, i32, i32, i32, i32, i32, i16, %struct._silk_resampler_state_struct, i32, i32, i32, i32, i32, i32, [3 x %struct.SideInfoIndices], [3 x [320 x i8]] }
%struct.silk_LP_state = type { [2 x i32], i32, i32, i32 }
%struct.silk_VAD_state = type { [2 x i32], [2 x i32], [2 x i32], [4 x i32], [4 x i32], i16, [4 x i32], [4 x i32], [4 x i32], i32 }
%struct.silk_nsq_state = type { [640 x i16], [640 x i32], [96 x i32], [24 x i32], i32, i32, i32, i32, i32, i32, i32, i32 }
%struct.SideInfoIndices = type { [4 x i8], [4 x i8], [17 x i8], i16, i8, i8, i8, i8, i8, i8, i8 }
%struct._silk_resampler_state_struct = type { [6 x i32], %union.anon, [48 x i16], i32, i32, i32, i32, i32, i32, i32, i32, ptr }
%union.anon = type { [36 x i32] }
%struct.silk_shape_state_FLP = type { i8, float, float }
%struct.silk_encoder_control_FLP = type { [4 x float], [2 x [16 x float]], [20 x float], float, [4 x i32], [96 x float], [4 x float], [4 x float], [4 x float], [4 x float], float, float, float, float, float, [4 x float], [4 x i32], i8 }

; Function Attrs: nounwind uwtable
define dso_local void @silk_noise_shape_analysis_FLP(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3) #0 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca float, 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
  %19 = alloca float, align 4
  %20 = alloca float, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca [240 x float], align 16
  %27 = alloca [25 x float], align 16
  %28 = alloca [25 x float], align 16
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store ptr %2, ptr %7, align 8, !tbaa !5
  store ptr %3, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #7
  %34 = load ptr, ptr %5, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %34, i32 0, i32 1
  store ptr %35, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #7
  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 4, ptr %20) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #7
  call void @llvm.lifetime.start.p0(i64 960, ptr %26) #7
  call void @llvm.lifetime.start.p0(i64 100, ptr %27) #7
  call void @llvm.lifetime.start.p0(i64 100, ptr %28) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #7
  %36 = load ptr, ptr %8, align 8, !tbaa !5
  %37 = load ptr, ptr %5, align 8, !tbaa !5
  %38 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %37, i32 0, i32 0
  %39 = getelementptr inbounds %struct.silk_encoder_state, ptr %38, i32 0, i32 25
  %40 = load i32, ptr %39, align 8, !tbaa !9
  %41 = sext i32 %40 to i64
  %42 = sub i64 0, %41
  %43 = getelementptr inbounds float, ptr %36, i64 %42
  store ptr %43, ptr %29, align 8, !tbaa !5
  %44 = load ptr, ptr %5, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %44, i32 0, i32 0
  %46 = getelementptr inbounds %struct.silk_encoder_state, ptr %45, i32 0, i32 51
  %47 = load i32, ptr %46, align 4, !tbaa !21
  %48 = sitofp i32 %47 to float
  %49 = fmul float %48, 7.812500e-03
  store float %49, ptr %13, align 4, !tbaa !22
  %50 = load ptr, ptr %5, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %50, i32 0, i32 0
  %52 = getelementptr inbounds %struct.silk_encoder_state, ptr %51, i32 0, i32 49
  %53 = getelementptr inbounds [4 x i32], ptr %52, i64 0, i64 0
  %54 = load i32, ptr %53, align 8, !tbaa !23
  %55 = load ptr, ptr %5, align 8, !tbaa !5
  %56 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %55, i32 0, i32 0
  %57 = getelementptr inbounds %struct.silk_encoder_state, ptr %56, i32 0, i32 49
  %58 = getelementptr inbounds [4 x i32], ptr %57, i64 0, i64 1
  %59 = load i32, ptr %58, align 4, !tbaa !23
  %60 = add nsw i32 %54, %59
  %61 = sitofp i32 %60 to float
  %62 = fmul float 5.000000e-01, %61
  %63 = fmul float %62, 0x3F00000000000000
  %64 = load ptr, ptr %6, align 8, !tbaa !5
  %65 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %64, i32 0, i32 11
  store float %63, ptr %65, align 4, !tbaa !24
  %66 = load float, ptr %13, align 4, !tbaa !22
  %67 = fsub float %66, 2.000000e+01
  %68 = fmul float 2.500000e-01, %67
  %69 = call float @silk_sigmoid(float noundef %68)
  %70 = load ptr, ptr %6, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %70, i32 0, i32 12
  store float %69, ptr %71, align 4, !tbaa !26
  %72 = load ptr, ptr %5, align 8, !tbaa !5
  %73 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %72, i32 0, i32 0
  %74 = getelementptr inbounds %struct.silk_encoder_state, ptr %73, i32 0, i32 44
  %75 = load i32, ptr %74, align 4, !tbaa !27
  %76 = icmp eq i32 %75, 0
  br i1 %76, label %77, label %100

77:                                               ; preds = %4
  %78 = load ptr, ptr %5, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %78, i32 0, i32 0
  %80 = getelementptr inbounds %struct.silk_encoder_state, ptr %79, i32 0, i32 7
  %81 = load i32, ptr %80, align 4, !tbaa !28
  %82 = sitofp i32 %81 to float
  %83 = fneg float %82
  %84 = call float @llvm.fmuladd.f32(float %83, float 3.906250e-03, float 1.000000e+00)
  store float %84, ptr %24, align 4, !tbaa !22
  %85 = load ptr, ptr %6, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %85, i32 0, i32 12
  %87 = load float, ptr %86, align 4, !tbaa !26
  %88 = fmul float 2.000000e+00, %87
  %89 = load ptr, ptr %6, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %89, i32 0, i32 11
  %91 = load float, ptr %90, align 4, !tbaa !24
  %92 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %91, float 5.000000e-01)
  %93 = fmul float %88, %92
  %94 = load float, ptr %24, align 4, !tbaa !22
  %95 = fmul float %93, %94
  %96 = load float, ptr %24, align 4, !tbaa !22
  %97 = load float, ptr %13, align 4, !tbaa !22
  %98 = fneg float %95
  %99 = call float @llvm.fmuladd.f32(float %98, float %96, float %97)
  store float %99, ptr %13, align 4, !tbaa !22
  br label %100

100:                                              ; preds = %77, %4
  %101 = load ptr, ptr %5, align 8, !tbaa !5
  %102 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %101, i32 0, i32 0
  %103 = getelementptr inbounds %struct.silk_encoder_state, ptr %102, i32 0, i32 55
  %104 = getelementptr inbounds %struct.SideInfoIndices, ptr %103, i32 0, i32 5
  %105 = load i8, ptr %104, align 1, !tbaa !29
  %106 = sext i8 %105 to i32
  %107 = icmp eq i32 %106, 2
  br i1 %107, label %108, label %114

108:                                              ; preds = %100
  %109 = load ptr, ptr %5, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %109, i32 0, i32 3
  %111 = load float, ptr %110, align 4, !tbaa !30
  %112 = load float, ptr %13, align 4, !tbaa !22
  %113 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %111, float %112)
  store float %113, ptr %13, align 4, !tbaa !22
  br label %128

114:                                              ; preds = %100
  %115 = load ptr, ptr %5, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %115, i32 0, i32 0
  %117 = getelementptr inbounds %struct.silk_encoder_state, ptr %116, i32 0, i32 51
  %118 = load i32, ptr %117, align 4, !tbaa !21
  %119 = sitofp i32 %118 to float
  %120 = fmul float 0xBFD99999A0000000, %119
  %121 = call float @llvm.fmuladd.f32(float %120, float 7.812500e-03, float 6.000000e+00)
  %122 = load ptr, ptr %6, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %122, i32 0, i32 11
  %124 = load float, ptr %123, align 4, !tbaa !24
  %125 = fsub float 1.000000e+00, %124
  %126 = load float, ptr %13, align 4, !tbaa !22
  %127 = call float @llvm.fmuladd.f32(float %121, float %125, float %126)
  store float %127, ptr %13, align 4, !tbaa !22
  br label %128

128:                                              ; preds = %114, %108
  %129 = load ptr, ptr %5, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %129, i32 0, i32 0
  %131 = getelementptr inbounds %struct.silk_encoder_state, ptr %130, i32 0, i32 55
  %132 = getelementptr inbounds %struct.SideInfoIndices, ptr %131, i32 0, i32 5
  %133 = load i8, ptr %132, align 1, !tbaa !29
  %134 = sext i8 %133 to i32
  %135 = icmp eq i32 %134, 2
  br i1 %135, label %136, label %141

136:                                              ; preds = %128
  %137 = load ptr, ptr %5, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %137, i32 0, i32 0
  %139 = getelementptr inbounds %struct.silk_encoder_state, ptr %138, i32 0, i32 55
  %140 = getelementptr inbounds %struct.SideInfoIndices, ptr %139, i32 0, i32 6
  store i8 0, ptr %140, align 2, !tbaa !31
  br label %209

141:                                              ; preds = %128
  %142 = load ptr, ptr %5, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %142, i32 0, i32 0
  %144 = getelementptr inbounds %struct.silk_encoder_state, ptr %143, i32 0, i32 19
  %145 = load i32, ptr %144, align 8, !tbaa !32
  %146 = mul nsw i32 2, %145
  store i32 %146, ptr %11, align 4, !tbaa !23
  store float 0.000000e+00, ptr %19, align 4, !tbaa !22
  store float 0.000000e+00, ptr %18, align 4, !tbaa !22
  %147 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %147, ptr %30, align 8, !tbaa !5
  %148 = load ptr, ptr %5, align 8, !tbaa !5
  %149 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %148, i32 0, i32 0
  %150 = getelementptr inbounds %struct.silk_encoder_state, ptr %149, i32 0, i32 20
  %151 = load i32, ptr %150, align 4, !tbaa !33
  %152 = trunc i32 %151 to i16
  %153 = sext i16 %152 to i32
  %154 = mul nsw i32 5, %153
  %155 = sdiv i32 %154, 2
  store i32 %155, ptr %12, align 4, !tbaa !23
  store i32 0, ptr %10, align 4, !tbaa !23
  br label %156

156:                                              ; preds = %188, %141
  %157 = load i32, ptr %10, align 4, !tbaa !23
  %158 = load i32, ptr %12, align 4, !tbaa !23
  %159 = icmp slt i32 %157, %158
  br i1 %159, label %160, label %191

160:                                              ; preds = %156
  %161 = load i32, ptr %11, align 4, !tbaa !23
  %162 = sitofp i32 %161 to float
  %163 = load ptr, ptr %30, align 8, !tbaa !5
  %164 = load i32, ptr %11, align 4, !tbaa !23
  %165 = call double @silk_energy_FLP(ptr noundef %163, i32 noundef %164)
  %166 = fptrunc double %165 to float
  %167 = fadd float %162, %166
  store float %167, ptr %16, align 4, !tbaa !22
  %168 = load float, ptr %16, align 4, !tbaa !22
  %169 = fpext float %168 to double
  %170 = call float @silk_log2(double noundef %169)
  store float %170, ptr %17, align 4, !tbaa !22
  %171 = load i32, ptr %10, align 4, !tbaa !23
  %172 = icmp sgt i32 %171, 0
  br i1 %172, label %173, label %182

173:                                              ; preds = %160
  %174 = load float, ptr %17, align 4, !tbaa !22
  %175 = load float, ptr %18, align 4, !tbaa !22
  %176 = fsub float %174, %175
  %177 = fpext float %176 to double
  %178 = call double @llvm.fabs.f64(double %177)
  %179 = fptrunc double %178 to float
  %180 = load float, ptr %19, align 4, !tbaa !22
  %181 = fadd float %180, %179
  store float %181, ptr %19, align 4, !tbaa !22
  br label %182

182:                                              ; preds = %173, %160
  %183 = load float, ptr %17, align 4, !tbaa !22
  store float %183, ptr %18, align 4, !tbaa !22
  %184 = load i32, ptr %11, align 4, !tbaa !23
  %185 = load ptr, ptr %30, align 8, !tbaa !5
  %186 = sext i32 %184 to i64
  %187 = getelementptr inbounds float, ptr %185, i64 %186
  store ptr %187, ptr %30, align 8, !tbaa !5
  br label %188

188:                                              ; preds = %182
  %189 = load i32, ptr %10, align 4, !tbaa !23
  %190 = add nsw i32 %189, 1
  store i32 %190, ptr %10, align 4, !tbaa !23
  br label %156, !llvm.loop !34

191:                                              ; preds = %156
  %192 = load float, ptr %19, align 4, !tbaa !22
  %193 = load i32, ptr %12, align 4, !tbaa !23
  %194 = sub nsw i32 %193, 1
  %195 = sitofp i32 %194 to float
  %196 = fmul float 0x3FE3333340000000, %195
  %197 = fcmp ogt float %192, %196
  br i1 %197, label %198, label %203

198:                                              ; preds = %191
  %199 = load ptr, ptr %5, align 8, !tbaa !5
  %200 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %199, i32 0, i32 0
  %201 = getelementptr inbounds %struct.silk_encoder_state, ptr %200, i32 0, i32 55
  %202 = getelementptr inbounds %struct.SideInfoIndices, ptr %201, i32 0, i32 6
  store i8 0, ptr %202, align 2, !tbaa !31
  br label %208

203:                                              ; preds = %191
  %204 = load ptr, ptr %5, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %204, i32 0, i32 0
  %206 = getelementptr inbounds %struct.silk_encoder_state, ptr %205, i32 0, i32 55
  %207 = getelementptr inbounds %struct.SideInfoIndices, ptr %206, i32 0, i32 6
  store i8 1, ptr %207, align 2, !tbaa !31
  br label %208

208:                                              ; preds = %203, %198
  br label %209

209:                                              ; preds = %208, %136
  %210 = load ptr, ptr %6, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %210, i32 0, i32 13
  %212 = load float, ptr %211, align 4, !tbaa !36
  %213 = fmul float 0x3F50624DE0000000, %212
  store float %213, ptr %23, align 4, !tbaa !22
  %214 = load float, ptr %23, align 4, !tbaa !22
  %215 = load float, ptr %23, align 4, !tbaa !22
  %216 = call float @llvm.fmuladd.f32(float %214, float %215, float 1.000000e+00)
  %217 = fdiv float 0x3FEE147AE0000000, %216
  store float %217, ptr %20, align 4, !tbaa !22
  %218 = load ptr, ptr %5, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %218, i32 0, i32 0
  %220 = getelementptr inbounds %struct.silk_encoder_state, ptr %219, i32 0, i32 43
  %221 = load i32, ptr %220, align 8, !tbaa !37
  %222 = sitofp i32 %221 to float
  %223 = fdiv float %222, 6.553600e+04
  %224 = load ptr, ptr %6, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %224, i32 0, i32 12
  %226 = load float, ptr %225, align 4, !tbaa !26
  %227 = call float @llvm.fmuladd.f32(float 0x3F847AE140000000, float %226, float %223)
  store float %227, ptr %25, align 4, !tbaa !22
  store i32 0, ptr %10, align 4, !tbaa !23
  br label %228

228:                                              ; preds = %411, %209
  %229 = load i32, ptr %10, align 4, !tbaa !23
  %230 = load ptr, ptr %5, align 8, !tbaa !5
  %231 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %230, i32 0, i32 0
  %232 = getelementptr inbounds %struct.silk_encoder_state, ptr %231, i32 0, i32 20
  %233 = load i32, ptr %232, align 4, !tbaa !33
  %234 = icmp slt i32 %229, %233
  br i1 %234, label %235, label %414

235:                                              ; preds = %228
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  %236 = load ptr, ptr %5, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %236, i32 0, i32 0
  %238 = getelementptr inbounds %struct.silk_encoder_state, ptr %237, i32 0, i32 19
  %239 = load i32, ptr %238, align 8, !tbaa !32
  %240 = mul nsw i32 %239, 3
  store i32 %240, ptr %33, align 4, !tbaa !23
  %241 = load ptr, ptr %5, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %241, i32 0, i32 0
  %243 = getelementptr inbounds %struct.silk_encoder_state, ptr %242, i32 0, i32 26
  %244 = load i32, ptr %243, align 4, !tbaa !38
  %245 = load i32, ptr %33, align 4, !tbaa !23
  %246 = sub nsw i32 %244, %245
  %247 = sdiv i32 %246, 2
  store i32 %247, ptr %32, align 4, !tbaa !23
  %248 = getelementptr inbounds [240 x float], ptr %26, i64 0, i64 0
  %249 = load ptr, ptr %29, align 8, !tbaa !5
  %250 = load i32, ptr %32, align 4, !tbaa !23
  call void @silk_apply_sine_window_FLP(ptr noundef %248, ptr noundef %249, i32 noundef 1, i32 noundef %250)
  %251 = load i32, ptr %32, align 4, !tbaa !23
  store i32 %251, ptr %31, align 4, !tbaa !23
  %252 = getelementptr inbounds [240 x float], ptr %26, i64 0, i64 0
  %253 = load i32, ptr %31, align 4, !tbaa !23
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds float, ptr %252, i64 %254
  %256 = load ptr, ptr %29, align 8, !tbaa !5
  %257 = load i32, ptr %31, align 4, !tbaa !23
  %258 = sext i32 %257 to i64
  %259 = getelementptr inbounds float, ptr %256, i64 %258
  %260 = load i32, ptr %33, align 4, !tbaa !23
  %261 = sext i32 %260 to i64
  %262 = mul i64 %261, 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %255, ptr align 4 %259, i64 %262, i1 false)
  %263 = load i32, ptr %33, align 4, !tbaa !23
  %264 = load i32, ptr %31, align 4, !tbaa !23
  %265 = add nsw i32 %264, %263
  store i32 %265, ptr %31, align 4, !tbaa !23
  %266 = getelementptr inbounds [240 x float], ptr %26, i64 0, i64 0
  %267 = load i32, ptr %31, align 4, !tbaa !23
  %268 = sext i32 %267 to i64
  %269 = getelementptr inbounds float, ptr %266, i64 %268
  %270 = load ptr, ptr %29, align 8, !tbaa !5
  %271 = load i32, ptr %31, align 4, !tbaa !23
  %272 = sext i32 %271 to i64
  %273 = getelementptr inbounds float, ptr %270, i64 %272
  %274 = load i32, ptr %32, align 4, !tbaa !23
  call void @silk_apply_sine_window_FLP(ptr noundef %269, ptr noundef %273, i32 noundef 2, i32 noundef %274)
  %275 = load ptr, ptr %5, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %275, i32 0, i32 0
  %277 = getelementptr inbounds %struct.silk_encoder_state, ptr %276, i32 0, i32 22
  %278 = load i32, ptr %277, align 4, !tbaa !39
  %279 = load ptr, ptr %29, align 8, !tbaa !5
  %280 = sext i32 %278 to i64
  %281 = getelementptr inbounds float, ptr %279, i64 %280
  store ptr %281, ptr %29, align 8, !tbaa !5
  %282 = load ptr, ptr %5, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %282, i32 0, i32 0
  %284 = getelementptr inbounds %struct.silk_encoder_state, ptr %283, i32 0, i32 43
  %285 = load i32, ptr %284, align 8, !tbaa !37
  %286 = icmp sgt i32 %285, 0
  br i1 %286, label %287, label %299

287:                                              ; preds = %235
  %288 = getelementptr inbounds [25 x float], ptr %27, i64 0, i64 0
  %289 = getelementptr inbounds [240 x float], ptr %26, i64 0, i64 0
  %290 = load float, ptr %25, align 4, !tbaa !22
  %291 = load ptr, ptr %5, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %291, i32 0, i32 0
  %293 = getelementptr inbounds %struct.silk_encoder_state, ptr %292, i32 0, i32 26
  %294 = load i32, ptr %293, align 4, !tbaa !38
  %295 = load ptr, ptr %5, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %295, i32 0, i32 0
  %297 = getelementptr inbounds %struct.silk_encoder_state, ptr %296, i32 0, i32 34
  %298 = load i32, ptr %297, align 4, !tbaa !40
  call void @silk_warped_autocorrelation_FLP(ptr noundef %288, ptr noundef %289, float noundef %290, i32 noundef %294, i32 noundef %298)
  br label %311

299:                                              ; preds = %235
  %300 = getelementptr inbounds [25 x float], ptr %27, i64 0, i64 0
  %301 = getelementptr inbounds [240 x float], ptr %26, i64 0, i64 0
  %302 = load ptr, ptr %5, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %302, i32 0, i32 0
  %304 = getelementptr inbounds %struct.silk_encoder_state, ptr %303, i32 0, i32 26
  %305 = load i32, ptr %304, align 4, !tbaa !38
  %306 = load ptr, ptr %5, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %306, i32 0, i32 0
  %308 = getelementptr inbounds %struct.silk_encoder_state, ptr %307, i32 0, i32 34
  %309 = load i32, ptr %308, align 4, !tbaa !40
  %310 = add nsw i32 %309, 1
  call void @silk_autocorrelation_FLP(ptr noundef %300, ptr noundef %301, i32 noundef %305, i32 noundef %310)
  br label %311

311:                                              ; preds = %299, %287
  %312 = getelementptr inbounds [25 x float], ptr %27, i64 0, i64 0
  %313 = load float, ptr %312, align 16, !tbaa !22
  %314 = call float @llvm.fmuladd.f32(float %313, float 0x3EFF751040000000, float 1.000000e+00)
  %315 = getelementptr inbounds [25 x float], ptr %27, i64 0, i64 0
  %316 = load float, ptr %315, align 16, !tbaa !22
  %317 = fadd float %316, %314
  store float %317, ptr %315, align 16, !tbaa !22
  %318 = getelementptr inbounds [25 x float], ptr %28, i64 0, i64 0
  %319 = getelementptr inbounds [25 x float], ptr %27, i64 0, i64 0
  %320 = load ptr, ptr %5, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %320, i32 0, i32 0
  %322 = getelementptr inbounds %struct.silk_encoder_state, ptr %321, i32 0, i32 34
  %323 = load i32, ptr %322, align 4, !tbaa !40
  %324 = call float @silk_schur_FLP(ptr noundef %318, ptr noundef %319, i32 noundef %323)
  store float %324, ptr %16, align 4, !tbaa !22
  %325 = load ptr, ptr %6, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %325, i32 0, i32 5
  %327 = load i32, ptr %10, align 4, !tbaa !23
  %328 = mul nsw i32 %327, 24
  %329 = sext i32 %328 to i64
  %330 = getelementptr inbounds [96 x float], ptr %326, i64 0, i64 %329
  %331 = getelementptr inbounds [25 x float], ptr %28, i64 0, i64 0
  %332 = load ptr, ptr %5, align 8, !tbaa !5
  %333 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %332, i32 0, i32 0
  %334 = getelementptr inbounds %struct.silk_encoder_state, ptr %333, i32 0, i32 34
  %335 = load i32, ptr %334, align 4, !tbaa !40
  call void @silk_k2a_FLP(ptr noundef %330, ptr noundef %331, i32 noundef %335)
  %336 = load float, ptr %16, align 4, !tbaa !22
  %337 = fpext float %336 to double
  %338 = call double @sqrt(double noundef %337) #7
  %339 = fptrunc double %338 to float
  %340 = load ptr, ptr %6, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %340, i32 0, i32 0
  %342 = load i32, ptr %10, align 4, !tbaa !23
  %343 = sext i32 %342 to i64
  %344 = getelementptr inbounds [4 x float], ptr %341, i64 0, i64 %343
  store float %339, ptr %344, align 4, !tbaa !22
  %345 = load ptr, ptr %5, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %345, i32 0, i32 0
  %347 = getelementptr inbounds %struct.silk_encoder_state, ptr %346, i32 0, i32 43
  %348 = load i32, ptr %347, align 8, !tbaa !37
  %349 = icmp sgt i32 %348, 0
  br i1 %349, label %350, label %370

350:                                              ; preds = %311
  %351 = load ptr, ptr %6, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %351, i32 0, i32 5
  %353 = load i32, ptr %10, align 4, !tbaa !23
  %354 = mul nsw i32 %353, 24
  %355 = sext i32 %354 to i64
  %356 = getelementptr inbounds [96 x float], ptr %352, i64 0, i64 %355
  %357 = load float, ptr %25, align 4, !tbaa !22
  %358 = load ptr, ptr %5, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %358, i32 0, i32 0
  %360 = getelementptr inbounds %struct.silk_encoder_state, ptr %359, i32 0, i32 34
  %361 = load i32, ptr %360, align 4, !tbaa !40
  %362 = call float @warped_gain(ptr noundef %356, float noundef %357, i32 noundef %361)
  %363 = load ptr, ptr %6, align 8, !tbaa !5
  %364 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %363, i32 0, i32 0
  %365 = load i32, ptr %10, align 4, !tbaa !23
  %366 = sext i32 %365 to i64
  %367 = getelementptr inbounds [4 x float], ptr %364, i64 0, i64 %366
  %368 = load float, ptr %367, align 4, !tbaa !22
  %369 = fmul float %368, %362
  store float %369, ptr %367, align 4, !tbaa !22
  br label %370

370:                                              ; preds = %350, %311
  %371 = load ptr, ptr %6, align 8, !tbaa !5
  %372 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %371, i32 0, i32 5
  %373 = load i32, ptr %10, align 4, !tbaa !23
  %374 = mul nsw i32 %373, 24
  %375 = sext i32 %374 to i64
  %376 = getelementptr inbounds [96 x float], ptr %372, i64 0, i64 %375
  %377 = load ptr, ptr %5, align 8, !tbaa !5
  %378 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %377, i32 0, i32 0
  %379 = getelementptr inbounds %struct.silk_encoder_state, ptr %378, i32 0, i32 34
  %380 = load i32, ptr %379, align 4, !tbaa !40
  %381 = load float, ptr %20, align 4, !tbaa !22
  call void @silk_bwexpander_FLP(ptr noundef %376, i32 noundef %380, float noundef %381)
  %382 = load ptr, ptr %5, align 8, !tbaa !5
  %383 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %382, i32 0, i32 0
  %384 = getelementptr inbounds %struct.silk_encoder_state, ptr %383, i32 0, i32 43
  %385 = load i32, ptr %384, align 8, !tbaa !37
  %386 = icmp sgt i32 %385, 0
  br i1 %386, label %387, label %399

387:                                              ; preds = %370
  %388 = load ptr, ptr %6, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %388, i32 0, i32 5
  %390 = load i32, ptr %10, align 4, !tbaa !23
  %391 = mul nsw i32 %390, 24
  %392 = sext i32 %391 to i64
  %393 = getelementptr inbounds [96 x float], ptr %389, i64 0, i64 %392
  %394 = load float, ptr %25, align 4, !tbaa !22
  %395 = load ptr, ptr %5, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %395, i32 0, i32 0
  %397 = getelementptr inbounds %struct.silk_encoder_state, ptr %396, i32 0, i32 34
  %398 = load i32, ptr %397, align 4, !tbaa !40
  call void @warped_true2monic_coefs(ptr noundef %393, float noundef %394, float noundef 0x400FFDF3C0000000, i32 noundef %398)
  br label %410

399:                                              ; preds = %370
  %400 = load ptr, ptr %6, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %400, i32 0, i32 5
  %402 = load i32, ptr %10, align 4, !tbaa !23
  %403 = mul nsw i32 %402, 24
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds [96 x float], ptr %401, i64 0, i64 %404
  %406 = load ptr, ptr %5, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %406, i32 0, i32 0
  %408 = getelementptr inbounds %struct.silk_encoder_state, ptr %407, i32 0, i32 34
  %409 = load i32, ptr %408, align 4, !tbaa !40
  call void @limit_coefs(ptr noundef %405, float noundef 0x400FFDF3C0000000, i32 noundef %409)
  br label %410

410:                                              ; preds = %399, %387
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #7
  br label %411

411:                                              ; preds = %410
  %412 = load i32, ptr %10, align 4, !tbaa !23
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %10, align 4, !tbaa !23
  br label %228, !llvm.loop !41

414:                                              ; preds = %228
  %415 = load float, ptr %13, align 4, !tbaa !22
  %416 = fmul float 0xBFC47AE140000000, %415
  %417 = fpext float %416 to double
  %418 = call double @pow(double noundef 2.000000e+00, double noundef %417) #7
  %419 = fptrunc double %418 to float
  store float %419, ptr %21, align 4, !tbaa !22
  %420 = call double @pow(double noundef 2.000000e+00, double noundef 0x3FD47AE140000000) #7
  %421 = fptrunc double %420 to float
  store float %421, ptr %22, align 4, !tbaa !22
  store i32 0, ptr %10, align 4, !tbaa !23
  br label %422

422:                                              ; preds = %446, %414
  %423 = load i32, ptr %10, align 4, !tbaa !23
  %424 = load ptr, ptr %5, align 8, !tbaa !5
  %425 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %424, i32 0, i32 0
  %426 = getelementptr inbounds %struct.silk_encoder_state, ptr %425, i32 0, i32 20
  %427 = load i32, ptr %426, align 4, !tbaa !33
  %428 = icmp slt i32 %423, %427
  br i1 %428, label %429, label %449

429:                                              ; preds = %422
  %430 = load float, ptr %21, align 4, !tbaa !22
  %431 = load ptr, ptr %6, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %431, i32 0, i32 0
  %433 = load i32, ptr %10, align 4, !tbaa !23
  %434 = sext i32 %433 to i64
  %435 = getelementptr inbounds [4 x float], ptr %432, i64 0, i64 %434
  %436 = load float, ptr %435, align 4, !tbaa !22
  %437 = fmul float %436, %430
  store float %437, ptr %435, align 4, !tbaa !22
  %438 = load float, ptr %22, align 4, !tbaa !22
  %439 = load ptr, ptr %6, align 8, !tbaa !5
  %440 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %439, i32 0, i32 0
  %441 = load i32, ptr %10, align 4, !tbaa !23
  %442 = sext i32 %441 to i64
  %443 = getelementptr inbounds [4 x float], ptr %440, i64 0, i64 %442
  %444 = load float, ptr %443, align 4, !tbaa !22
  %445 = fadd float %444, %438
  store float %445, ptr %443, align 4, !tbaa !22
  br label %446

446:                                              ; preds = %429
  %447 = load i32, ptr %10, align 4, !tbaa !23
  %448 = add nsw i32 %447, 1
  store i32 %448, ptr %10, align 4, !tbaa !23
  br label %422, !llvm.loop !42

449:                                              ; preds = %422
  %450 = load ptr, ptr %5, align 8, !tbaa !5
  %451 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %450, i32 0, i32 0
  %452 = getelementptr inbounds %struct.silk_encoder_state, ptr %451, i32 0, i32 49
  %453 = getelementptr inbounds [4 x i32], ptr %452, i64 0, i64 0
  %454 = load i32, ptr %453, align 8, !tbaa !23
  %455 = sitofp i32 %454 to float
  %456 = call float @llvm.fmuladd.f32(float %455, float 0x3F00000000000000, float -1.000000e+00)
  %457 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %456, float 1.000000e+00)
  %458 = fmul float 4.000000e+00, %457
  store float %458, ptr %23, align 4, !tbaa !22
  %459 = load ptr, ptr %5, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %459, i32 0, i32 0
  %461 = getelementptr inbounds %struct.silk_encoder_state, ptr %460, i32 0, i32 7
  %462 = load i32, ptr %461, align 4, !tbaa !28
  %463 = sitofp i32 %462 to float
  %464 = fmul float %463, 3.906250e-03
  %465 = load float, ptr %23, align 4, !tbaa !22
  %466 = fmul float %465, %464
  store float %466, ptr %23, align 4, !tbaa !22
  %467 = load ptr, ptr %5, align 8, !tbaa !5
  %468 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %467, i32 0, i32 0
  %469 = getelementptr inbounds %struct.silk_encoder_state, ptr %468, i32 0, i32 55
  %470 = getelementptr inbounds %struct.SideInfoIndices, ptr %469, i32 0, i32 5
  %471 = load i8, ptr %470, align 1, !tbaa !29
  %472 = sext i8 %471 to i32
  %473 = icmp eq i32 %472, 2
  br i1 %473, label %474, label %528

474:                                              ; preds = %449
  store i32 0, ptr %10, align 4, !tbaa !23
  br label %475

475:                                              ; preds = %516, %474
  %476 = load i32, ptr %10, align 4, !tbaa !23
  %477 = load ptr, ptr %5, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %477, i32 0, i32 0
  %479 = getelementptr inbounds %struct.silk_encoder_state, ptr %478, i32 0, i32 20
  %480 = load i32, ptr %479, align 4, !tbaa !33
  %481 = icmp slt i32 %476, %480
  br i1 %481, label %482, label %519

482:                                              ; preds = %475
  %483 = load ptr, ptr %5, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %483, i32 0, i32 0
  %485 = getelementptr inbounds %struct.silk_encoder_state, ptr %484, i32 0, i32 19
  %486 = load i32, ptr %485, align 8, !tbaa !32
  %487 = sitofp i32 %486 to float
  %488 = fdiv float 0x3FC99999A0000000, %487
  %489 = load ptr, ptr %6, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %489, i32 0, i32 4
  %491 = load i32, ptr %10, align 4, !tbaa !23
  %492 = sext i32 %491 to i64
  %493 = getelementptr inbounds [4 x i32], ptr %490, i64 0, i64 %492
  %494 = load i32, ptr %493, align 4, !tbaa !23
  %495 = sitofp i32 %494 to float
  %496 = fdiv float 3.000000e+00, %495
  %497 = fadd float %488, %496
  store float %497, ptr %24, align 4, !tbaa !22
  %498 = load float, ptr %24, align 4, !tbaa !22
  %499 = fadd float -1.000000e+00, %498
  %500 = load ptr, ptr %6, align 8, !tbaa !5
  %501 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %500, i32 0, i32 6
  %502 = load i32, ptr %10, align 4, !tbaa !23
  %503 = sext i32 %502 to i64
  %504 = getelementptr inbounds [4 x float], ptr %501, i64 0, i64 %503
  store float %499, ptr %504, align 4, !tbaa !22
  %505 = load float, ptr %24, align 4, !tbaa !22
  %506 = fsub float 1.000000e+00, %505
  %507 = load float, ptr %24, align 4, !tbaa !22
  %508 = load float, ptr %23, align 4, !tbaa !22
  %509 = fneg float %507
  %510 = call float @llvm.fmuladd.f32(float %509, float %508, float %506)
  %511 = load ptr, ptr %6, align 8, !tbaa !5
  %512 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %511, i32 0, i32 7
  %513 = load i32, ptr %10, align 4, !tbaa !23
  %514 = sext i32 %513 to i64
  %515 = getelementptr inbounds [4 x float], ptr %512, i64 0, i64 %514
  store float %510, ptr %515, align 4, !tbaa !22
  br label %516

516:                                              ; preds = %482
  %517 = load i32, ptr %10, align 4, !tbaa !23
  %518 = add nsw i32 %517, 1
  store i32 %518, ptr %10, align 4, !tbaa !23
  br label %475, !llvm.loop !43

519:                                              ; preds = %475
  %520 = load ptr, ptr %5, align 8, !tbaa !5
  %521 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %520, i32 0, i32 0
  %522 = getelementptr inbounds %struct.silk_encoder_state, ptr %521, i32 0, i32 7
  %523 = load i32, ptr %522, align 4, !tbaa !28
  %524 = sitofp i32 %523 to float
  %525 = fmul float 0x3FD0CCCCC0000000, %524
  %526 = fneg float %525
  %527 = call float @llvm.fmuladd.f32(float %526, float 3.906250e-03, float -2.500000e-01)
  store float %527, ptr %15, align 4, !tbaa !22
  br label %580

528:                                              ; preds = %449
  %529 = load ptr, ptr %5, align 8, !tbaa !5
  %530 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %529, i32 0, i32 0
  %531 = getelementptr inbounds %struct.silk_encoder_state, ptr %530, i32 0, i32 19
  %532 = load i32, ptr %531, align 8, !tbaa !32
  %533 = sitofp i32 %532 to float
  %534 = fdiv float 0x3FF4CCCCC0000000, %533
  store float %534, ptr %24, align 4, !tbaa !22
  %535 = load float, ptr %24, align 4, !tbaa !22
  %536 = fadd float -1.000000e+00, %535
  %537 = load ptr, ptr %6, align 8, !tbaa !5
  %538 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %537, i32 0, i32 6
  %539 = getelementptr inbounds [4 x float], ptr %538, i64 0, i64 0
  store float %536, ptr %539, align 4, !tbaa !22
  %540 = load float, ptr %24, align 4, !tbaa !22
  %541 = fsub float 1.000000e+00, %540
  %542 = load float, ptr %24, align 4, !tbaa !22
  %543 = load float, ptr %23, align 4, !tbaa !22
  %544 = fmul float %542, %543
  %545 = fneg float %544
  %546 = call float @llvm.fmuladd.f32(float %545, float 0x3FE3333340000000, float %541)
  %547 = load ptr, ptr %6, align 8, !tbaa !5
  %548 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %547, i32 0, i32 7
  %549 = getelementptr inbounds [4 x float], ptr %548, i64 0, i64 0
  store float %546, ptr %549, align 4, !tbaa !22
  store i32 1, ptr %10, align 4, !tbaa !23
  br label %550

550:                                              ; preds = %576, %528
  %551 = load i32, ptr %10, align 4, !tbaa !23
  %552 = load ptr, ptr %5, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %552, i32 0, i32 0
  %554 = getelementptr inbounds %struct.silk_encoder_state, ptr %553, i32 0, i32 20
  %555 = load i32, ptr %554, align 4, !tbaa !33
  %556 = icmp slt i32 %551, %555
  br i1 %556, label %557, label %579

557:                                              ; preds = %550
  %558 = load ptr, ptr %6, align 8, !tbaa !5
  %559 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %558, i32 0, i32 6
  %560 = getelementptr inbounds [4 x float], ptr %559, i64 0, i64 0
  %561 = load float, ptr %560, align 4, !tbaa !22
  %562 = load ptr, ptr %6, align 8, !tbaa !5
  %563 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %562, i32 0, i32 6
  %564 = load i32, ptr %10, align 4, !tbaa !23
  %565 = sext i32 %564 to i64
  %566 = getelementptr inbounds [4 x float], ptr %563, i64 0, i64 %565
  store float %561, ptr %566, align 4, !tbaa !22
  %567 = load ptr, ptr %6, align 8, !tbaa !5
  %568 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %567, i32 0, i32 7
  %569 = getelementptr inbounds [4 x float], ptr %568, i64 0, i64 0
  %570 = load float, ptr %569, align 4, !tbaa !22
  %571 = load ptr, ptr %6, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %571, i32 0, i32 7
  %573 = load i32, ptr %10, align 4, !tbaa !23
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds [4 x float], ptr %572, i64 0, i64 %574
  store float %570, ptr %575, align 4, !tbaa !22
  br label %576

576:                                              ; preds = %557
  %577 = load i32, ptr %10, align 4, !tbaa !23
  %578 = add nsw i32 %577, 1
  store i32 %578, ptr %10, align 4, !tbaa !23
  br label %550, !llvm.loop !44

579:                                              ; preds = %550
  store float -2.500000e-01, ptr %15, align 4, !tbaa !22
  br label %580

580:                                              ; preds = %579, %519
  %581 = load ptr, ptr %5, align 8, !tbaa !5
  %582 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %581, i32 0, i32 0
  %583 = getelementptr inbounds %struct.silk_encoder_state, ptr %582, i32 0, i32 55
  %584 = getelementptr inbounds %struct.SideInfoIndices, ptr %583, i32 0, i32 5
  %585 = load i8, ptr %584, align 1, !tbaa !29
  %586 = sext i8 %585 to i32
  %587 = icmp eq i32 %586, 2
  br i1 %587, label %588, label %608

588:                                              ; preds = %580
  store float 0x3FD3333340000000, ptr %14, align 4, !tbaa !22
  %589 = load ptr, ptr %6, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %589, i32 0, i32 12
  %591 = load float, ptr %590, align 4, !tbaa !26
  %592 = fsub float 1.000000e+00, %591
  %593 = load ptr, ptr %6, align 8, !tbaa !5
  %594 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %593, i32 0, i32 11
  %595 = load float, ptr %594, align 4, !tbaa !24
  %596 = fneg float %592
  %597 = call float @llvm.fmuladd.f32(float %596, float %595, float 1.000000e+00)
  %598 = load float, ptr %14, align 4, !tbaa !22
  %599 = call float @llvm.fmuladd.f32(float 0x3FC99999A0000000, float %597, float %598)
  store float %599, ptr %14, align 4, !tbaa !22
  %600 = load ptr, ptr %5, align 8, !tbaa !5
  %601 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %600, i32 0, i32 3
  %602 = load float, ptr %601, align 4, !tbaa !30
  %603 = fpext float %602 to double
  %604 = call double @sqrt(double noundef %603) #7
  %605 = fptrunc double %604 to float
  %606 = load float, ptr %14, align 4, !tbaa !22
  %607 = fmul float %606, %605
  store float %607, ptr %14, align 4, !tbaa !22
  br label %609

608:                                              ; preds = %580
  store float 0.000000e+00, ptr %14, align 4, !tbaa !22
  br label %609

609:                                              ; preds = %608, %588
  store i32 0, ptr %10, align 4, !tbaa !23
  br label %610

610:                                              ; preds = %652, %609
  %611 = load i32, ptr %10, align 4, !tbaa !23
  %612 = load ptr, ptr %5, align 8, !tbaa !5
  %613 = getelementptr inbounds %struct.silk_encoder_state_FLP, ptr %612, i32 0, i32 0
  %614 = getelementptr inbounds %struct.silk_encoder_state, ptr %613, i32 0, i32 20
  %615 = load i32, ptr %614, align 4, !tbaa !33
  %616 = icmp slt i32 %611, %615
  br i1 %616, label %617, label %655

617:                                              ; preds = %610
  %618 = load float, ptr %14, align 4, !tbaa !22
  %619 = load ptr, ptr %9, align 8, !tbaa !5
  %620 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %619, i32 0, i32 1
  %621 = load float, ptr %620, align 4, !tbaa !45
  %622 = fsub float %618, %621
  %623 = load ptr, ptr %9, align 8, !tbaa !5
  %624 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %623, i32 0, i32 1
  %625 = load float, ptr %624, align 4, !tbaa !45
  %626 = call float @llvm.fmuladd.f32(float 0x3FD99999A0000000, float %622, float %625)
  store float %626, ptr %624, align 4, !tbaa !45
  %627 = load ptr, ptr %9, align 8, !tbaa !5
  %628 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %627, i32 0, i32 1
  %629 = load float, ptr %628, align 4, !tbaa !45
  %630 = load ptr, ptr %6, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %630, i32 0, i32 9
  %632 = load i32, ptr %10, align 4, !tbaa !23
  %633 = sext i32 %632 to i64
  %634 = getelementptr inbounds [4 x float], ptr %631, i64 0, i64 %633
  store float %629, ptr %634, align 4, !tbaa !22
  %635 = load float, ptr %15, align 4, !tbaa !22
  %636 = load ptr, ptr %9, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %636, i32 0, i32 2
  %638 = load float, ptr %637, align 4, !tbaa !46
  %639 = fsub float %635, %638
  %640 = load ptr, ptr %9, align 8, !tbaa !5
  %641 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %640, i32 0, i32 2
  %642 = load float, ptr %641, align 4, !tbaa !46
  %643 = call float @llvm.fmuladd.f32(float 0x3FD99999A0000000, float %639, float %642)
  store float %643, ptr %641, align 4, !tbaa !46
  %644 = load ptr, ptr %9, align 8, !tbaa !5
  %645 = getelementptr inbounds %struct.silk_shape_state_FLP, ptr %644, i32 0, i32 2
  %646 = load float, ptr %645, align 4, !tbaa !46
  %647 = load ptr, ptr %6, align 8, !tbaa !5
  %648 = getelementptr inbounds %struct.silk_encoder_control_FLP, ptr %647, i32 0, i32 8
  %649 = load i32, ptr %10, align 4, !tbaa !23
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds [4 x float], ptr %648, i64 0, i64 %650
  store float %646, ptr %651, align 4, !tbaa !22
  br label %652

652:                                              ; preds = %617
  %653 = load i32, ptr %10, align 4, !tbaa !23
  %654 = add nsw i32 %653, 1
  store i32 %654, ptr %10, align 4, !tbaa !23
  br label %610, !llvm.loop !47

655:                                              ; preds = %610
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #7
  call void @llvm.lifetime.end.p0(i64 100, ptr %28) #7
  call void @llvm.lifetime.end.p0(i64 100, ptr %27) #7
  call void @llvm.lifetime.end.p0(i64 960, ptr %26) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #7
  call void @llvm.lifetime.end.p0(i64 4, 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 4, ptr %17) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #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: inlinehint nounwind uwtable
declare hidden float @silk_sigmoid(float noundef) #2

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

declare double @silk_energy_FLP(ptr noundef, i32 noundef) #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @silk_log2(double noundef) #2

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

declare void @silk_apply_sine_window_FLP(ptr noundef, ptr noundef, i32 noundef, i32 noundef) #4

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

declare void @silk_warped_autocorrelation_FLP(ptr noundef, ptr noundef, float noundef, i32 noundef, i32 noundef) #4

declare void @silk_autocorrelation_FLP(ptr noundef, ptr noundef, i32 noundef, i32 noundef) #4

declare float @silk_schur_FLP(ptr noundef, ptr noundef, i32 noundef) #4

declare void @silk_k2a_FLP(ptr noundef, ptr noundef, i32 noundef) #4

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @warped_gain(ptr noundef, float noundef, i32 noundef) #2

declare void @silk_bwexpander_FLP(ptr noundef, i32 noundef, float noundef) #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @warped_true2monic_coefs(ptr noundef, float noundef, float noundef, i32 noundef) #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @limit_coefs(ptr noundef, float noundef, i32 noundef) #2

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

; Function Attrs: nounwind
declare double @pow(double noundef, double noundef) #6

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !12, i64 4600}
!10 = !{!"", !11, i64 0, !19, i64 7192, !7, i64 7204, !20, i64 10084}
!11 = !{!"", !7, i64 0, !12, i64 8, !12, i64 12, !13, i64 16, !14, i64 36, !16, i64 148, !7, i64 4500, !12, i64 4532, !12, i64 4536, !7, i64 4540, !7, i64 4541, !12, i64 4544, !12, i64 4548, !12, i64 4552, !12, i64 4556, !12, i64 4560, !12, i64 4564, !12, i64 4568, !12, i64 4572, !12, i64 4576, !12, i64 4580, !12, i64 4584, !12, i64 4588, !12, i64 4592, !12, i64 4596, !12, i64 4600, !12, i64 4604, !12, i64 4608, !12, i64 4612, !12, i64 4616, !12, i64 4620, !12, i64 4624, !12, i64 4628, !12, i64 4632, !12, i64 4636, !12, i64 4640, !12, i64 4644, !12, i64 4648, !12, i64 4652, !12, i64 4656, !12, i64 4660, !12, i64 4664, !12, i64 4668, !12, i64 4672, !12, i64 4676, !12, i64 4680, !6, i64 4688, !6, i64 4696, !6, i64 4704, !7, i64 4712, !12, i64 4728, !12, i64 4732, !7, i64 4736, !7, i64 4739, !7, i64 4740, !17, i64 4752, !7, i64 4788, !12, i64 5108, !7, i64 5112, !12, i64 5756, !12, i64 5760, !12, i64 5764, !12, i64 5768, !12, i64 5772, !12, i64 5776, !12, i64 5780, !12, i64 5784, !15, i64 5788, !18, i64 5792, !12, i64 6096, !12, i64 6100, !12, i64 6104, !12, i64 6108, !12, i64 6112, !12, i64 6116, !7, i64 6120, !7, i64 6228}
!12 = !{!"int", !7, i64 0}
!13 = !{!"", !7, i64 0, !12, i64 8, !12, i64 12, !12, i64 16}
!14 = !{!"", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 40, !15, i64 56, !7, i64 60, !7, i64 76, !7, i64 92, !12, i64 108}
!15 = !{!"short", !7, i64 0}
!16 = !{!"", !7, i64 0, !7, i64 1280, !7, i64 3840, !7, i64 4224, !12, i64 4320, !12, i64 4324, !12, i64 4328, !12, i64 4332, !12, i64 4336, !12, i64 4340, !12, i64 4344, !12, i64 4348}
!17 = !{!"", !7, i64 0, !7, i64 4, !7, i64 8, !15, i64 26, !7, i64 28, !7, i64 29, !7, i64 30, !7, i64 31, !7, i64 32, !7, i64 33, !7, i64 34}
!18 = !{!"_silk_resampler_state_struct", !7, i64 0, !7, i64 24, !7, i64 168, !12, i64 264, !12, i64 268, !12, i64 272, !12, i64 276, !12, i64 280, !12, i64 284, !12, i64 288, !12, i64 292, !6, i64 296}
!19 = !{!"", !7, i64 0, !20, i64 4, !20, i64 8}
!20 = !{!"float", !7, i64 0}
!21 = !{!10, !12, i64 4732}
!22 = !{!20, !20, i64 0}
!23 = !{!12, !12, i64 0}
!24 = !{!25, !20, i64 696}
!25 = !{!"", !7, i64 0, !7, i64 16, !7, i64 144, !20, i64 224, !7, i64 228, !7, i64 244, !7, i64 628, !7, i64 644, !7, i64 660, !7, i64 676, !20, i64 692, !20, i64 696, !20, i64 700, !20, i64 704, !20, i64 708, !7, i64 712, !7, i64 728, !7, i64 744}
!26 = !{!25, !20, i64 700}
!27 = !{!10, !12, i64 4676}
!28 = !{!10, !12, i64 4532}
!29 = !{!10, !7, i64 4781}
!30 = !{!10, !20, i64 10084}
!31 = !{!10, !7, i64 4782}
!32 = !{!10, !12, i64 4576}
!33 = !{!10, !12, i64 4580}
!34 = distinct !{!34, !35}
!35 = !{!"llvm.loop.mustprogress"}
!36 = !{!25, !20, i64 704}
!37 = !{!10, !12, i64 4672}
!38 = !{!10, !12, i64 4604}
!39 = !{!10, !12, i64 4588}
!40 = !{!10, !12, i64 4636}
!41 = distinct !{!41, !35}
!42 = distinct !{!42, !35}
!43 = distinct !{!43, !35}
!44 = distinct !{!44, !35}
!45 = !{!19, !20, i64 4}
!46 = !{!19, !20, i64 8}
!47 = distinct !{!47, !35}


; 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: nounwind uwtable
define dso_local void @silk_noise_shape_analysis_FLP(ptr nocapture noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3) local_unnamed_addr #0 {
  %5 = alloca [240 x float], align 16
  %6 = alloca [25 x float], align 16
  %7 = alloca [25 x float], align 16
  call void @llvm.lifetime.start.p0(i64 960, ptr nonnull %5) #7
  call void @llvm.lifetime.start.p0(i64 100, ptr nonnull %6) #7
  call void @llvm.lifetime.start.p0(i64 100, ptr nonnull %7) #7
  %8 = getelementptr inbounds i8, ptr %0, i64 4600
  %9 = load i32, ptr %8, align 8, !tbaa !5
  %10 = sext i32 %9 to i64
  %11 = sub nsw i64 0, %10
  %12 = getelementptr inbounds float, ptr %3, i64 %11
  %13 = getelementptr inbounds i8, ptr %0, i64 4732
  %14 = load i32, ptr %13, align 4, !tbaa !20
  %15 = sitofp i32 %14 to float
  %16 = fmul float %15, 7.812500e-03
  %17 = getelementptr inbounds i8, ptr %0, i64 4712
  %18 = load i32, ptr %17, align 8, !tbaa !21
  %19 = getelementptr inbounds i8, ptr %0, i64 4716
  %20 = load i32, ptr %19, align 4, !tbaa !21
  %21 = add nsw i32 %20, %18
  %22 = sitofp i32 %21 to float
  %23 = fmul float %22, 5.000000e-01
  %24 = fmul float %23, 0x3F00000000000000
  %25 = getelementptr inbounds i8, ptr %1, i64 696
  store float %24, ptr %25, align 4, !tbaa !22
  %26 = fadd float %16, -2.000000e+01
  %27 = fmul float %26, 2.500000e-01
  %28 = tail call float @silk_sigmoid(float noundef %27)
  %29 = getelementptr inbounds i8, ptr %1, i64 700
  store float %28, ptr %29, align 4, !tbaa !24
  %30 = getelementptr inbounds i8, ptr %0, i64 4676
  %31 = load i32, ptr %30, align 4, !tbaa !25
  %32 = icmp eq i32 %31, 0
  br i1 %32, label %33, label %45

33:                                               ; preds = %4
  %34 = getelementptr inbounds i8, ptr %0, i64 4532
  %35 = load i32, ptr %34, align 4, !tbaa !26
  %36 = sitofp i32 %35 to float
  %37 = fneg float %36
  %38 = tail call float @llvm.fmuladd.f32(float %37, float 3.906250e-03, float 1.000000e+00)
  %39 = load float, ptr %25, align 4, !tbaa !22
  %40 = tail call float @llvm.fmuladd.f32(float %39, float 5.000000e-01, float 5.000000e-01)
  %41 = fmul float %28, -2.000000e+00
  %42 = fmul float %41, %40
  %43 = fmul float %38, %42
  %44 = tail call float @llvm.fmuladd.f32(float %43, float %38, float %16)
  br label %45

45:                                               ; preds = %33, %4
  %.0168 = phi float [ %44, %33 ], [ %16, %4 ]
  %46 = getelementptr inbounds i8, ptr %0, i64 4781
  %47 = load i8, ptr %46, align 1, !tbaa !27
  %48 = icmp eq i8 %47, 2
  br i1 %48, label %49, label %54

49:                                               ; preds = %45
  %50 = getelementptr inbounds i8, ptr %0, i64 10084
  %51 = load float, ptr %50, align 4, !tbaa !28
  %52 = tail call float @llvm.fmuladd.f32(float %51, float 2.000000e+00, float %.0168)
  %53 = getelementptr inbounds i8, ptr %0, i64 4782
  store i8 0, ptr %53, align 2, !tbaa !29
  br label %95

54:                                               ; preds = %45
  %55 = load i32, ptr %13, align 4, !tbaa !20
  %56 = sitofp i32 %55 to float
  %57 = fmul float %56, 0xBFD99999A0000000
  %58 = tail call float @llvm.fmuladd.f32(float %57, float 7.812500e-03, float 6.000000e+00)
  %59 = load float, ptr %25, align 4, !tbaa !22
  %60 = fsub float 1.000000e+00, %59
  %61 = tail call float @llvm.fmuladd.f32(float %58, float %60, float %.0168)
  %62 = getelementptr inbounds i8, ptr %0, i64 4576
  %63 = load i32, ptr %62, align 8, !tbaa !30
  %64 = shl nsw i32 %63, 1
  %65 = getelementptr inbounds i8, ptr %0, i64 4580
  %66 = load i32, ptr %65, align 4, !tbaa !31
  %sext = shl i32 %66, 16
  %67 = ashr exact i32 %sext, 16
  %68 = mul nsw i32 %67, 5
  %69 = sdiv i32 %68, 2
  %70 = icmp sgt i32 %67, 0
  br i1 %70, label %.peel.next, label %._crit_edge

.peel.next:                                       ; preds = %54
  %71 = sitofp i32 %64 to float
  %72 = sext i32 %64 to i64
  %73 = tail call double @silk_energy_FLP(ptr noundef %2, i32 noundef %64) #7
  %74 = fptrunc double %73 to float
  %75 = fadd float %71, %74
  %76 = fpext float %75 to double
  %77 = tail call float @silk_log2(double noundef %76)
  br label %78

78:                                               ; preds = %.peel.next, %78
  %.0186 = phi i32 [ 1, %.peel.next ], [ %87, %78 ]
  %.pn = phi ptr [ %2, %.peel.next ], [ %.0171185, %78 ]
  %.0174184 = phi float [ %77, %.peel.next ], [ %83, %78 ]
  %.0175183 = phi float [ 0.000000e+00, %.peel.next ], [ %86, %78 ]
  %.0171185 = getelementptr inbounds float, ptr %.pn, i64 %72
  %79 = tail call double @silk_energy_FLP(ptr noundef %.0171185, i32 noundef %64) #7
  %80 = fptrunc double %79 to float
  %81 = fadd float %71, %80
  %82 = fpext float %81 to double
  %83 = tail call float @silk_log2(double noundef %82)
  %84 = fsub float %83, %.0174184
  %85 = tail call float @llvm.fabs.f32(float %84)
  %86 = fadd float %.0175183, %85
  %87 = add nuw nsw i32 %.0186, 1
  %exitcond.not = icmp eq i32 %69, %87
  br i1 %exitcond.not, label %._crit_edge, label %78, !llvm.loop !32

._crit_edge:                                      ; preds = %78, %54
  %.0175.lcssa = phi float [ 0.000000e+00, %54 ], [ %86, %78 ]
  %88 = add nsw i32 %69, -1
  %89 = sitofp i32 %88 to float
  %90 = fmul float %89, 0x3FE3333340000000
  %91 = fcmp ogt float %.0175.lcssa, %90
  %92 = getelementptr inbounds i8, ptr %0, i64 4782
  br i1 %91, label %93, label %94

93:                                               ; preds = %._crit_edge
  store i8 0, ptr %92, align 2, !tbaa !29
  br label %95

94:                                               ; preds = %._crit_edge
  store i8 1, ptr %92, align 2, !tbaa !29
  br label %95

95:                                               ; preds = %93, %94, %49
  %.1169180 = phi float [ %61, %93 ], [ %61, %94 ], [ %52, %49 ]
  %96 = getelementptr inbounds i8, ptr %1, i64 704
  %97 = load float, ptr %96, align 4, !tbaa !35
  %98 = fmul float %97, 0x3F50624DE0000000
  %99 = tail call float @llvm.fmuladd.f32(float %98, float %98, float 1.000000e+00)
  %100 = fdiv float 0x3FEE147AE0000000, %99
  %101 = getelementptr inbounds i8, ptr %0, i64 4672
  %102 = load i32, ptr %101, align 8, !tbaa !36
  %103 = sitofp i32 %102 to float
  %104 = fmul float %103, 0x3EF0000000000000
  %105 = load float, ptr %29, align 4, !tbaa !24
  %106 = tail call float @llvm.fmuladd.f32(float %105, float 0x3F847AE140000000, float %104)
  %107 = getelementptr inbounds i8, ptr %0, i64 4580
  %108 = load i32, ptr %107, align 4, !tbaa !31
  %109 = icmp sgt i32 %108, 0
  br i1 %109, label %.lr.ph190, label %._crit_edge191

.lr.ph190:                                        ; preds = %95
  %110 = getelementptr inbounds i8, ptr %0, i64 4576
  %111 = getelementptr inbounds i8, ptr %0, i64 4604
  %112 = getelementptr inbounds i8, ptr %0, i64 4588
  %113 = getelementptr inbounds i8, ptr %0, i64 4636
  %114 = getelementptr inbounds i8, ptr %1, i64 244
  br label %115

115:                                              ; preds = %.lr.ph190, %164
  %indvars.iv = phi i64 [ 0, %.lr.ph190 ], [ %indvars.iv.next, %164 ]
  %.0172187 = phi ptr [ %12, %.lr.ph190 ], [ %132, %164 ]
  %116 = load i32, ptr %110, align 8, !tbaa !30
  %117 = mul nsw i32 %116, 3
  %118 = load i32, ptr %111, align 4, !tbaa !37
  %119 = sub nsw i32 %118, %117
  %120 = sdiv i32 %119, 2
  call void @silk_apply_sine_window_FLP(ptr noundef nonnull %5, ptr noundef %.0172187, i32 noundef 1, i32 noundef %120) #7
  %121 = sext i32 %120 to i64
  %122 = getelementptr inbounds float, ptr %5, i64 %121
  %123 = getelementptr inbounds float, ptr %.0172187, i64 %121
  %124 = sext i32 %117 to i64
  %125 = shl nsw i64 %124, 2
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 4 %122, ptr align 4 %123, i64 %125, i1 false)
  %126 = add nsw i32 %120, %117
  %127 = sext i32 %126 to i64
  %128 = getelementptr inbounds float, ptr %5, i64 %127
  %129 = getelementptr inbounds float, ptr %.0172187, i64 %127
  call void @silk_apply_sine_window_FLP(ptr noundef nonnull %128, ptr noundef %129, i32 noundef 2, i32 noundef %120) #7
  %130 = load i32, ptr %112, align 4, !tbaa !38
  %131 = sext i32 %130 to i64
  %132 = getelementptr inbounds float, ptr %.0172187, i64 %131
  %133 = load i32, ptr %101, align 8, !tbaa !36
  %134 = icmp sgt i32 %133, 0
  %135 = load i32, ptr %111, align 4, !tbaa !37
  %136 = load i32, ptr %113, align 4, !tbaa !39
  br i1 %134, label %137, label %138

137:                                              ; preds = %115
  call void @silk_warped_autocorrelation_FLP(ptr noundef nonnull %6, ptr noundef nonnull %5, float noundef %106, i32 noundef %135, i32 noundef %136) #7
  br label %140

138:                                              ; preds = %115
  %139 = add nsw i32 %136, 1
  call void @silk_autocorrelation_FLP(ptr noundef nonnull %6, ptr noundef nonnull %5, i32 noundef %135, i32 noundef %139) #7
  br label %140

140:                                              ; preds = %138, %137
  %141 = load float, ptr %6, align 16, !tbaa !40
  %142 = call float @llvm.fmuladd.f32(float %141, float 0x3EFF751040000000, float 1.000000e+00)
  %143 = fadd float %141, %142
  store float %143, ptr %6, align 16, !tbaa !40
  %144 = load i32, ptr %113, align 4, !tbaa !39
  %145 = call float @silk_schur_FLP(ptr noundef nonnull %7, ptr noundef nonnull %6, i32 noundef %144) #7
  %146 = mul nuw nsw i64 %indvars.iv, 24
  %147 = getelementptr inbounds [96 x float], ptr %114, i64 0, i64 %146
  %148 = load i32, ptr %113, align 4, !tbaa !39
  call void @silk_k2a_FLP(ptr noundef nonnull %147, ptr noundef nonnull %7, i32 noundef %148) #7
  %sqrtf178 = call float @sqrtf(float noundef %145) #8
  %149 = getelementptr inbounds [4 x float], ptr %1, i64 0, i64 %indvars.iv
  store float %sqrtf178, ptr %149, align 4, !tbaa !40
  %150 = load i32, ptr %101, align 8, !tbaa !36
  %151 = icmp sgt i32 %150, 0
  br i1 %151, label %152, label %157

152:                                              ; preds = %140
  %153 = load i32, ptr %113, align 4, !tbaa !39
  %154 = call float @warped_gain(ptr noundef nonnull %147, float noundef %106, i32 noundef %153)
  %155 = load float, ptr %149, align 4, !tbaa !40
  %156 = fmul float %154, %155
  store float %156, ptr %149, align 4, !tbaa !40
  br label %157

157:                                              ; preds = %152, %140
  %158 = load i32, ptr %113, align 4, !tbaa !39
  call void @silk_bwexpander_FLP(ptr noundef nonnull %147, i32 noundef %158, float noundef %100) #7
  %159 = load i32, ptr %101, align 8, !tbaa !36
  %160 = icmp sgt i32 %159, 0
  %161 = load i32, ptr %113, align 4, !tbaa !39
  br i1 %160, label %162, label %163

162:                                              ; preds = %157
  call void @warped_true2monic_coefs(ptr noundef nonnull %147, float noundef %106, float noundef 0x400FFDF3C0000000, i32 noundef %161)
  br label %164

163:                                              ; preds = %157
  call void @limit_coefs(ptr noundef nonnull %147, float noundef 0x400FFDF3C0000000, i32 noundef %161)
  br label %164

164:                                              ; preds = %163, %162
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %165 = load i32, ptr %107, align 4, !tbaa !31
  %166 = sext i32 %165 to i64
  %167 = icmp slt i64 %indvars.iv.next, %166
  br i1 %167, label %115, label %._crit_edge191, !llvm.loop !41

._crit_edge191:                                   ; preds = %164, %95
  %168 = fmul float %.1169180, 0xBFC47AE140000000
  %169 = fpext float %168 to double
  %exp2 = call double @exp2(double %169) #7
  %170 = fptrunc double %exp2 to float
  %171 = load i32, ptr %107, align 4, !tbaa !31
  %172 = icmp sgt i32 %171, 0
  br i1 %172, label %.lr.ph194.preheader, label %._crit_edge195

.lr.ph194.preheader:                              ; preds = %._crit_edge191
  %wide.trip.count = zext nneg i32 %171 to i64
  %min.iters.check = icmp ult i32 %171, 8
  br i1 %min.iters.check, label %.lr.ph194.preheader247, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph194.preheader
  %n.vec = and i64 %wide.trip.count, 2147483640
  %broadcast.splatinsert = insertelement <4 x float> poison, float %170, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %173 = getelementptr inbounds [4 x float], ptr %1, i64 0, i64 %index
  %174 = getelementptr inbounds i8, ptr %173, i64 16
  %wide.load = load <4 x float>, ptr %173, align 4, !tbaa !40
  %wide.load230 = load <4 x float>, ptr %174, align 4, !tbaa !40
  %175 = fmul <4 x float> %wide.load, %broadcast.splat
  %176 = fmul <4 x float> %wide.load230, %broadcast.splat
  %177 = fadd <4 x float> %175, <float 0x3FF3F92980000000, float 0x3FF3F92980000000, float 0x3FF3F92980000000, float 0x3FF3F92980000000>
  %178 = fadd <4 x float> %176, <float 0x3FF3F92980000000, float 0x3FF3F92980000000, float 0x3FF3F92980000000, float 0x3FF3F92980000000>
  store <4 x float> %177, ptr %173, align 4, !tbaa !40
  store <4 x float> %178, ptr %174, align 4, !tbaa !40
  %index.next = add nuw i64 %index, 8
  %179 = icmp eq i64 %index.next, %n.vec
  br i1 %179, label %middle.block, label %vector.body, !llvm.loop !42

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %._crit_edge195, label %.lr.ph194.preheader247

.lr.ph194.preheader247:                           ; preds = %middle.block, %.lr.ph194.preheader
  %indvars.iv209.ph = phi i64 [ 0, %.lr.ph194.preheader ], [ %n.vec, %middle.block ]
  br label %.lr.ph194

.lr.ph194:                                        ; preds = %.lr.ph194.preheader247, %.lr.ph194
  %indvars.iv209 = phi i64 [ %indvars.iv.next210, %.lr.ph194 ], [ %indvars.iv209.ph, %.lr.ph194.preheader247 ]
  %180 = getelementptr inbounds [4 x float], ptr %1, i64 0, i64 %indvars.iv209
  %181 = load float, ptr %180, align 4, !tbaa !40
  %182 = fmul float %181, %170
  %183 = fadd float %182, 0x3FF3F92980000000
  store float %183, ptr %180, align 4, !tbaa !40
  %indvars.iv.next210 = add nuw nsw i64 %indvars.iv209, 1
  %exitcond212.not = icmp eq i64 %indvars.iv.next210, %wide.trip.count
  br i1 %exitcond212.not, label %._crit_edge195, label %.lr.ph194, !llvm.loop !45

._crit_edge195:                                   ; preds = %.lr.ph194, %middle.block, %._crit_edge191
  %184 = load i32, ptr %17, align 8, !tbaa !21
  %185 = sitofp i32 %184 to float
  %186 = call float @llvm.fmuladd.f32(float %185, float 0x3F00000000000000, float -1.000000e+00)
  %187 = call float @llvm.fmuladd.f32(float %186, float 5.000000e-01, float 1.000000e+00)
  %188 = fmul float %187, 4.000000e+00
  %189 = getelementptr inbounds i8, ptr %0, i64 4532
  %190 = load i32, ptr %189, align 4, !tbaa !26
  %191 = sitofp i32 %190 to float
  %192 = fmul float %191, 3.906250e-03
  %193 = fmul float %192, %188
  %194 = load i8, ptr %46, align 1, !tbaa !27
  %195 = icmp eq i8 %194, 2
  br i1 %195, label %.preheader, label %227

.preheader:                                       ; preds = %._crit_edge195
  br i1 %172, label %.lr.ph201, label %._crit_edge202

.lr.ph201:                                        ; preds = %.preheader
  %196 = getelementptr inbounds i8, ptr %0, i64 4576
  %197 = load i32, ptr %196, align 8, !tbaa !30
  %198 = sitofp i32 %197 to float
  %199 = fdiv float 0x3FC99999A0000000, %198
  %200 = getelementptr inbounds i8, ptr %1, i64 228
  %201 = getelementptr inbounds i8, ptr %1, i64 628
  %202 = getelementptr inbounds i8, ptr %1, i64 644
  %wide.trip.count221 = zext nneg i32 %171 to i64
  %min.iters.check233 = icmp ult i32 %171, 4
  br i1 %min.iters.check233, label %scalar.ph232.preheader, label %vector.ph234

vector.ph234:                                     ; preds = %.lr.ph201
  %n.vec236 = and i64 %wide.trip.count221, 2147483644
  %broadcast.splatinsert241 = insertelement <4 x float> poison, float %199, i64 0
  %broadcast.splat242 = shufflevector <4 x float> %broadcast.splatinsert241, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert243 = insertelement <4 x float> poison, float %193, i64 0
  %broadcast.splat244 = shufflevector <4 x float> %broadcast.splatinsert243, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body238

vector.body238:                                   ; preds = %vector.body238, %vector.ph234
  %index239 = phi i64 [ 0, %vector.ph234 ], [ %index.next245, %vector.body238 ]
  %203 = getelementptr inbounds [4 x i32], ptr %200, i64 0, i64 %index239
  %wide.load240 = load <4 x i32>, ptr %203, align 4, !tbaa !21
  %204 = sitofp <4 x i32> %wide.load240 to <4 x float>
  %205 = fdiv <4 x float> <float 3.000000e+00, float 3.000000e+00, float 3.000000e+00, float 3.000000e+00>, %204
  %206 = fadd <4 x float> %broadcast.splat242, %205
  %207 = fadd <4 x float> %206, <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>
  %208 = getelementptr inbounds [4 x float], ptr %201, i64 0, i64 %index239
  store <4 x float> %207, ptr %208, align 4, !tbaa !40
  %209 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %206
  %210 = fneg <4 x float> %206
  %211 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %210, <4 x float> %broadcast.splat244, <4 x float> %209)
  %212 = getelementptr inbounds [4 x float], ptr %202, i64 0, i64 %index239
  store <4 x float> %211, ptr %212, align 4, !tbaa !40
  %index.next245 = add nuw i64 %index239, 4
  %213 = icmp eq i64 %index.next245, %n.vec236
  br i1 %213, label %middle.block231, label %vector.body238, !llvm.loop !46

middle.block231:                                  ; preds = %vector.body238
  %cmp.n246 = icmp eq i64 %n.vec236, %wide.trip.count221
  br i1 %cmp.n246, label %._crit_edge202, label %scalar.ph232.preheader

scalar.ph232.preheader:                           ; preds = %middle.block231, %.lr.ph201
  %indvars.iv218.ph = phi i64 [ 0, %.lr.ph201 ], [ %n.vec236, %middle.block231 ]
  br label %scalar.ph232

scalar.ph232:                                     ; preds = %scalar.ph232.preheader, %scalar.ph232
  %indvars.iv218 = phi i64 [ %indvars.iv.next219, %scalar.ph232 ], [ %indvars.iv218.ph, %scalar.ph232.preheader ]
  %214 = getelementptr inbounds [4 x i32], ptr %200, i64 0, i64 %indvars.iv218
  %215 = load i32, ptr %214, align 4, !tbaa !21
  %216 = sitofp i32 %215 to float
  %217 = fdiv float 3.000000e+00, %216
  %218 = fadd float %199, %217
  %219 = fadd float %218, -1.000000e+00
  %220 = getelementptr inbounds [4 x float], ptr %201, i64 0, i64 %indvars.iv218
  store float %219, ptr %220, align 4, !tbaa !40
  %221 = fsub float 1.000000e+00, %218
  %222 = fneg float %218
  %223 = call float @llvm.fmuladd.f32(float %222, float %193, float %221)
  %224 = getelementptr inbounds [4 x float], ptr %202, i64 0, i64 %indvars.iv218
  store float %223, ptr %224, align 4, !tbaa !40
  %indvars.iv.next219 = add nuw nsw i64 %indvars.iv218, 1
  %exitcond222.not = icmp eq i64 %indvars.iv.next219, %wide.trip.count221
  br i1 %exitcond222.not, label %._crit_edge202, label %scalar.ph232, !llvm.loop !47

._crit_edge202:                                   ; preds = %scalar.ph232, %middle.block231, %.preheader
  %225 = fmul float %191, 0xBFD0CCCCC0000000
  %226 = call float @llvm.fmuladd.f32(float %225, float 3.906250e-03, float -2.500000e-01)
  br label %.loopexit

227:                                              ; preds = %._crit_edge195
  %228 = getelementptr inbounds i8, ptr %0, i64 4576
  %229 = load i32, ptr %228, align 8, !tbaa !30
  %230 = sitofp i32 %229 to float
  %231 = fdiv float 0x3FF4CCCCC0000000, %230
  %232 = fadd float %231, -1.000000e+00
  %233 = getelementptr inbounds i8, ptr %1, i64 628
  store float %232, ptr %233, align 4, !tbaa !40
  %234 = fsub float 1.000000e+00, %231
  %235 = fneg float %231
  %236 = fmul float %193, %235
  %237 = call float @llvm.fmuladd.f32(float %236, float 0x3FE3333340000000, float %234)
  %238 = getelementptr inbounds i8, ptr %1, i64 644
  store float %237, ptr %238, align 4, !tbaa !40
  %239 = icmp sgt i32 %171, 1
  br i1 %239, label %.lr.ph199.preheader, label %.loopexit.thread

.lr.ph199.preheader:                              ; preds = %227
  %wide.trip.count216 = zext nneg i32 %171 to i64
  %240 = add nsw i64 %wide.trip.count216, -1
  %241 = add nsw i64 %wide.trip.count216, -2
  %xtraiter = and i64 %240, 3
  %242 = icmp ult i64 %241, 3
  br i1 %242, label %.loopexit.loopexit.unr-lcssa, label %.lr.ph199.preheader.new

.lr.ph199.preheader.new:                          ; preds = %.lr.ph199.preheader
  %unroll_iter = and i64 %240, -4
  br label %.lr.ph199

.lr.ph199:                                        ; preds = %.lr.ph199, %.lr.ph199.preheader.new
  %indvars.iv213 = phi i64 [ 1, %.lr.ph199.preheader.new ], [ %indvars.iv.next214.3, %.lr.ph199 ]
  %niter = phi i64 [ 0, %.lr.ph199.preheader.new ], [ %niter.next.3, %.lr.ph199 ]
  %243 = getelementptr inbounds [4 x float], ptr %233, i64 0, i64 %indvars.iv213
  store float %232, ptr %243, align 4, !tbaa !40
  %244 = load float, ptr %238, align 4, !tbaa !40
  %245 = getelementptr inbounds [4 x float], ptr %238, i64 0, i64 %indvars.iv213
  store float %244, ptr %245, align 4, !tbaa !40
  %indvars.iv.next214 = add nuw nsw i64 %indvars.iv213, 1
  %246 = getelementptr inbounds [4 x float], ptr %233, i64 0, i64 %indvars.iv.next214
  store float %232, ptr %246, align 4, !tbaa !40
  %247 = load float, ptr %238, align 4, !tbaa !40
  %248 = getelementptr inbounds [4 x float], ptr %238, i64 0, i64 %indvars.iv.next214
  store float %247, ptr %248, align 4, !tbaa !40
  %indvars.iv.next214.1 = add nuw nsw i64 %indvars.iv213, 2
  %249 = getelementptr inbounds [4 x float], ptr %233, i64 0, i64 %indvars.iv.next214.1
  store float %232, ptr %249, align 4, !tbaa !40
  %250 = load float, ptr %238, align 4, !tbaa !40
  %251 = getelementptr inbounds [4 x float], ptr %238, i64 0, i64 %indvars.iv.next214.1
  store float %250, ptr %251, align 4, !tbaa !40
  %indvars.iv.next214.2 = add nuw nsw i64 %indvars.iv213, 3
  %252 = getelementptr inbounds [4 x float], ptr %233, i64 0, i64 %indvars.iv.next214.2
  store float %232, ptr %252, align 4, !tbaa !40
  %253 = load float, ptr %238, align 4, !tbaa !40
  %254 = getelementptr inbounds [4 x float], ptr %238, i64 0, i64 %indvars.iv.next214.2
  store float %253, ptr %254, align 4, !tbaa !40
  %indvars.iv.next214.3 = add nuw nsw i64 %indvars.iv213, 4
  %niter.next.3 = add nuw i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %.loopexit.loopexit.unr-lcssa, label %.lr.ph199, !llvm.loop !48

.loopexit.loopexit.unr-lcssa:                     ; preds = %.lr.ph199, %.lr.ph199.preheader
  %indvars.iv213.unr = phi i64 [ 1, %.lr.ph199.preheader ], [ %indvars.iv.next214.3, %.lr.ph199 ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.loopexit, label %.lr.ph199.epil

.lr.ph199.epil:                                   ; preds = %.loopexit.loopexit.unr-lcssa, %.lr.ph199.epil
  %indvars.iv213.epil = phi i64 [ %indvars.iv.next214.epil, %.lr.ph199.epil ], [ %indvars.iv213.unr, %.loopexit.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.lr.ph199.epil ], [ 0, %.loopexit.loopexit.unr-lcssa ]
  %255 = getelementptr inbounds [4 x float], ptr %233, i64 0, i64 %indvars.iv213.epil
  store float %232, ptr %255, align 4, !tbaa !40
  %256 = load float, ptr %238, align 4, !tbaa !40
  %257 = getelementptr inbounds [4 x float], ptr %238, i64 0, i64 %indvars.iv213.epil
  store float %256, ptr %257, align 4, !tbaa !40
  %indvars.iv.next214.epil = add nuw nsw i64 %indvars.iv213.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %.loopexit, label %.lr.ph199.epil, !llvm.loop !49

.loopexit:                                        ; preds = %.loopexit.loopexit.unr-lcssa, %.lr.ph199.epil, %._crit_edge202
  %.0173 = phi float [ %226, %._crit_edge202 ], [ -2.500000e-01, %.lr.ph199.epil ], [ -2.500000e-01, %.loopexit.loopexit.unr-lcssa ]
  br i1 %195, label %258, label %.loopexit.thread

258:                                              ; preds = %.loopexit
  %259 = load float, ptr %29, align 4, !tbaa !24
  %260 = fsub float 1.000000e+00, %259
  %261 = load float, ptr %25, align 4, !tbaa !22
  %262 = fneg float %260
  %263 = call float @llvm.fmuladd.f32(float %262, float %261, float 1.000000e+00)
  %264 = call float @llvm.fmuladd.f32(float %263, float 0x3FC99999A0000000, float 0x3FD3333340000000)
  %265 = getelementptr inbounds i8, ptr %0, i64 10084
  %266 = load float, ptr %265, align 4, !tbaa !28
  %sqrtf = call float @sqrtf(float noundef %266) #8
  %267 = fmul float %264, %sqrtf
  %.pre = load i32, ptr %107, align 4, !tbaa !31
  br label %.loopexit.thread

.loopexit.thread:                                 ; preds = %227, %.loopexit, %258
  %.0173229 = phi float [ %.0173, %258 ], [ %.0173, %.loopexit ], [ -2.500000e-01, %227 ]
  %268 = phi i32 [ %.pre, %258 ], [ %171, %.loopexit ], [ %171, %227 ]
  %.0170 = phi float [ %267, %258 ], [ 0.000000e+00, %.loopexit ], [ 0.000000e+00, %227 ]
  %269 = icmp sgt i32 %268, 0
  br i1 %269, label %.lr.ph205, label %._crit_edge206

.lr.ph205:                                        ; preds = %.loopexit.thread
  %270 = getelementptr inbounds i8, ptr %0, i64 7196
  %271 = getelementptr inbounds i8, ptr %1, i64 676
  %272 = getelementptr inbounds i8, ptr %0, i64 7200
  %273 = getelementptr inbounds i8, ptr %1, i64 660
  %wide.trip.count226 = zext nneg i32 %268 to i64
  br label %274

274:                                              ; preds = %.lr.ph205, %274
  %indvars.iv223 = phi i64 [ 0, %.lr.ph205 ], [ %indvars.iv.next224, %274 ]
  %275 = load float, ptr %270, align 4, !tbaa !51
  %276 = fsub float %.0170, %275
  %277 = call float @llvm.fmuladd.f32(float %276, float 0x3FD99999A0000000, float %275)
  store float %277, ptr %270, align 4, !tbaa !51
  %278 = getelementptr inbounds [4 x float], ptr %271, i64 0, i64 %indvars.iv223
  store float %277, ptr %278, align 4, !tbaa !40
  %279 = load float, ptr %272, align 4, !tbaa !52
  %280 = fsub float %.0173229, %279
  %281 = call float @llvm.fmuladd.f32(float %280, float 0x3FD99999A0000000, float %279)
  store float %281, ptr %272, align 4, !tbaa !52
  %282 = getelementptr inbounds [4 x float], ptr %273, i64 0, i64 %indvars.iv223
  store float %281, ptr %282, align 4, !tbaa !40
  %indvars.iv.next224 = add nuw nsw i64 %indvars.iv223, 1
  %exitcond227.not = icmp eq i64 %indvars.iv.next224, %wide.trip.count226
  br i1 %exitcond227.not, label %._crit_edge206, label %274, !llvm.loop !53

._crit_edge206:                                   ; preds = %274, %.loopexit.thread
  call void @llvm.lifetime.end.p0(i64 100, ptr nonnull %7) #7
  call void @llvm.lifetime.end.p0(i64 100, ptr nonnull %6) #7
  call void @llvm.lifetime.end.p0(i64 960, ptr nonnull %5) #7
  ret void
}

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @silk_sigmoid(float noundef) local_unnamed_addr #2

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @silk_log2(double noundef) local_unnamed_addr #2

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

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

declare void @silk_warped_autocorrelation_FLP(ptr noundef, ptr noundef, float noundef, i32 noundef, i32 noundef) local_unnamed_addr #4

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

declare float @silk_schur_FLP(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #4

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @warped_gain(ptr noundef, float noundef, i32 noundef) local_unnamed_addr #2

declare void @silk_bwexpander_FLP(ptr noundef, i32 noundef, float noundef) local_unnamed_addr #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @warped_true2monic_coefs(ptr noundef, float noundef, float noundef, i32 noundef) local_unnamed_addr #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @limit_coefs(ptr noundef, float noundef, i32 noundef) 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 float @llvm.fabs.f32(float) #6

declare double @exp2(double) local_unnamed_addr

declare float @sqrtf(float) local_unnamed_addr

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #6

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

!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, !10, i64 4600}
!6 = !{!"", !7, i64 0, !18, i64 7192, !8, i64 7204, !19, i64 10084}
!7 = !{!"", !8, i64 0, !10, i64 8, !10, i64 12, !11, i64 16, !12, i64 36, !14, i64 148, !8, i64 4500, !10, i64 4532, !10, i64 4536, !8, i64 4540, !8, i64 4541, !10, i64 4544, !10, i64 4548, !10, i64 4552, !10, i64 4556, !10, i64 4560, !10, i64 4564, !10, i64 4568, !10, i64 4572, !10, i64 4576, !10, i64 4580, !10, i64 4584, !10, i64 4588, !10, i64 4592, !10, i64 4596, !10, i64 4600, !10, i64 4604, !10, i64 4608, !10, i64 4612, !10, i64 4616, !10, i64 4620, !10, i64 4624, !10, i64 4628, !10, i64 4632, !10, i64 4636, !10, i64 4640, !10, i64 4644, !10, i64 4648, !10, i64 4652, !10, i64 4656, !10, i64 4660, !10, i64 4664, !10, i64 4668, !10, i64 4672, !10, i64 4676, !10, i64 4680, !15, i64 4688, !15, i64 4696, !15, i64 4704, !8, i64 4712, !10, i64 4728, !10, i64 4732, !8, i64 4736, !8, i64 4739, !8, i64 4740, !16, i64 4752, !8, i64 4788, !10, i64 5108, !8, i64 5112, !10, i64 5756, !10, i64 5760, !10, i64 5764, !10, i64 5768, !10, i64 5772, !10, i64 5776, !10, i64 5780, !10, i64 5784, !13, i64 5788, !17, i64 5792, !10, i64 6096, !10, i64 6100, !10, i64 6104, !10, i64 6108, !10, i64 6112, !10, i64 6116, !8, i64 6120, !8, i64 6228}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"", !8, i64 0, !10, i64 8, !10, i64 12, !10, i64 16}
!12 = !{!"", !8, i64 0, !8, i64 8, !8, i64 16, !8, i64 24, !8, i64 40, !13, i64 56, !8, i64 60, !8, i64 76, !8, i64 92, !10, i64 108}
!13 = !{!"short", !8, i64 0}
!14 = !{!"", !8, i64 0, !8, i64 1280, !8, i64 3840, !8, i64 4224, !10, i64 4320, !10, i64 4324, !10, i64 4328, !10, i64 4332, !10, i64 4336, !10, i64 4340, !10, i64 4344, !10, i64 4348}
!15 = !{!"any pointer", !8, i64 0}
!16 = !{!"", !8, i64 0, !8, i64 4, !8, i64 8, !13, i64 26, !8, i64 28, !8, i64 29, !8, i64 30, !8, i64 31, !8, i64 32, !8, i64 33, !8, i64 34}
!17 = !{!"_silk_resampler_state_struct", !8, i64 0, !8, i64 24, !8, i64 168, !10, i64 264, !10, i64 268, !10, i64 272, !10, i64 276, !10, i64 280, !10, i64 284, !10, i64 288, !10, i64 292, !15, i64 296}
!18 = !{!"", !8, i64 0, !19, i64 4, !19, i64 8}
!19 = !{!"float", !8, i64 0}
!20 = !{!6, !10, i64 4732}
!21 = !{!10, !10, i64 0}
!22 = !{!23, !19, i64 696}
!23 = !{!"", !8, i64 0, !8, i64 16, !8, i64 144, !19, i64 224, !8, i64 228, !8, i64 244, !8, i64 628, !8, i64 644, !8, i64 660, !8, i64 676, !19, i64 692, !19, i64 696, !19, i64 700, !19, i64 704, !19, i64 708, !8, i64 712, !8, i64 728, !8, i64 744}
!24 = !{!23, !19, i64 700}
!25 = !{!6, !10, i64 4676}
!26 = !{!6, !10, i64 4532}
!27 = !{!6, !8, i64 4781}
!28 = !{!6, !19, i64 10084}
!29 = !{!6, !8, i64 4782}
!30 = !{!6, !10, i64 4576}
!31 = !{!6, !10, i64 4580}
!32 = distinct !{!32, !33, !34}
!33 = !{!"llvm.loop.mustprogress"}
!34 = !{!"llvm.loop.peeled.count", i32 1}
!35 = !{!23, !19, i64 704}
!36 = !{!6, !10, i64 4672}
!37 = !{!6, !10, i64 4604}
!38 = !{!6, !10, i64 4588}
!39 = !{!6, !10, i64 4636}
!40 = !{!19, !19, i64 0}
!41 = distinct !{!41, !33}
!42 = distinct !{!42, !33, !43, !44}
!43 = !{!"llvm.loop.isvectorized", i32 1}
!44 = !{!"llvm.loop.unroll.runtime.disable"}
!45 = distinct !{!45, !33, !44, !43}
!46 = distinct !{!46, !33, !43, !44}
!47 = distinct !{!47, !33, !44, !43}
!48 = distinct !{!48, !33}
!49 = distinct !{!49, !50}
!50 = !{!"llvm.loop.unroll.disable"}
!51 = !{!18, !19, i64 4}
!52 = !{!18, !19, i64 8}
!53 = distinct !{!53, !33}


; Effective O3 passes: BDCEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopFullUnrollPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass