; LLVM IR from jgaeddert/liquid-dsp :: sandbox (ellip_func_test)

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

@.str = external hidden unnamed_addr constant [77 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [45 x i8], align 1

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

; Function Attrs: nounwind
declare float @sqrtf(float noundef) #1

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

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @ellipkf(float noundef, i32 noundef, ptr noundef, ptr noundef) #3

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #4

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #4

; Function Attrs: nounwind uwtable
declare dso_local float @ellipdegf(float noundef, float noundef, i32 noundef) #3

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_cdf(<2 x float> noundef, float noundef, i32 noundef) #5

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

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

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_snf(<2 x float> noundef, float noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_asnf(<2 x float> noundef, float noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
define dso_local i32 @ellip_azpkf(i32 noundef %0, float noundef %1, float noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5) #5 {
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca float, align 4
  %10 = alloca float, align 4
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca i32, 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 float, align 4
  %27 = alloca float, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca ptr, align 8
  %31 = alloca i64, align 8
  %32 = alloca i32, align 4
  %33 = alloca float, align 4
  %34 = alloca i64, align 8
  %35 = alloca { float, float }, align 4
  %36 = alloca { float, float }, align 4
  %37 = alloca i64, align 8
  %38 = alloca { float, float }, align 4
  %39 = alloca { float, float }, align 4
  %40 = alloca { float, float }, align 4
  %41 = alloca { float, float }, align 4
  %42 = alloca { float, float }, align 4
  %43 = alloca i64, align 8
  %44 = alloca { float, float }, align 4
  %45 = alloca { float, float }, align 4
  %46 = alloca { float, float }, align 4
  %47 = alloca { float, float }, align 4
  %48 = alloca { float, float }, align 4
  %49 = alloca { float, float }, align 4
  %50 = alloca { float, float }, align 4
  %51 = alloca { float, float }, align 4
  %52 = alloca { float, float }, align 4
  %53 = alloca i32, align 4
  %54 = alloca i32, align 4
  %55 = alloca { float, float }, align 4
  %56 = alloca { float, float }, align 4
  store i32 %0, ptr %8, align 4, !tbaa !5
  store float %1, ptr %9, align 4, !tbaa !9
  store float %2, ptr %10, align 4, !tbaa !9
  store ptr %3, ptr %11, align 8, !tbaa !11
  store ptr %4, ptr %12, align 8, !tbaa !11
  store ptr %5, ptr %13, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  store float 0x3FC45F3060000000, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #7
  %57 = load float, ptr %14, align 4, !tbaa !9
  %58 = fpext float %57 to double
  %59 = fmul double 1.100000e+00, %58
  %60 = fptrunc double %59 to float
  store float %60, ptr %15, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #7
  store i32 7, ptr %16, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #7
  %61 = load float, ptr %14, align 4, !tbaa !9
  %62 = fpext float %61 to double
  %63 = fmul double 0x401921FB54442D18, %62
  %64 = fptrunc double %63 to float
  store float %64, ptr %17, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #7
  %65 = load float, ptr %15, align 4, !tbaa !9
  %66 = fpext float %65 to double
  %67 = fmul double 0x401921FB54442D18, %66
  %68 = fptrunc double %67 to float
  store float %68, ptr %18, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #7
  %69 = load float, ptr %9, align 4, !tbaa !9
  store float %69, ptr %19, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #7
  %70 = load float, ptr %10, align 4, !tbaa !9
  store float %70, ptr %20, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #7
  %71 = load float, ptr %17, align 4, !tbaa !9
  %72 = load float, ptr %18, align 4, !tbaa !9
  %73 = fdiv float %71, %72
  store float %73, ptr %21, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #7
  %74 = load float, ptr %19, align 4, !tbaa !9
  %75 = load float, ptr %20, align 4, !tbaa !9
  %76 = fdiv float %74, %75
  store float %76, ptr %22, align 4, !tbaa !9
  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 4, ptr %26) #7
  %77 = load float, ptr %21, align 4, !tbaa !9
  %78 = load i32, ptr %16, align 4, !tbaa !5
  %79 = call i32 @ellipkf(float noundef %77, i32 noundef %78, ptr noundef %23, ptr noundef %24)
  %80 = load float, ptr %22, align 4, !tbaa !9
  %81 = load i32, ptr %16, align 4, !tbaa !5
  %82 = call i32 @ellipkf(float noundef %80, i32 noundef %81, ptr noundef %25, ptr noundef %26)
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #7
  %83 = load i32, ptr %8, align 4, !tbaa !5
  %84 = uitofp i32 %83 to float
  store float %84, ptr %27, align 4, !tbaa !9
  %85 = load float, ptr %27, align 4, !tbaa !9
  %86 = load float, ptr %22, align 4, !tbaa !9
  %87 = load i32, ptr %16, align 4, !tbaa !5
  %88 = call float @ellipdegf(float noundef %85, float noundef %86, i32 noundef %87)
  store float %88, ptr %21, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #7
  %89 = load float, ptr %27, align 4, !tbaa !9
  %90 = fdiv float %89, 2.000000e+00
  %91 = call float @llvm.floor.f32(float %90)
  %92 = fptoui float %91 to i32
  store i32 %92, ptr %28, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #7
  %93 = load float, ptr %27, align 4, !tbaa !9
  %94 = fptoui float %93 to i32
  %95 = urem i32 %94, 2
  store i32 %95, ptr %29, align 4, !tbaa !5
  %96 = load i32, ptr %28, align 4, !tbaa !5
  %97 = zext i32 %96 to i64
  %98 = call ptr @llvm.stacksave.p0()
  store ptr %98, ptr %30, align 8
  %99 = alloca float, i64 %97, align 16
  store i64 %97, ptr %31, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #7
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %100

100:                                              ; preds = %115, %6
  %101 = load i32, ptr %32, align 4, !tbaa !5
  %102 = load i32, ptr %28, align 4, !tbaa !5
  %103 = icmp ult i32 %101, %102
  br i1 %103, label %104, label %118

104:                                              ; preds = %100
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  %105 = load i32, ptr %32, align 4, !tbaa !5
  %106 = uitofp i32 %105 to float
  %107 = fadd float %106, 1.000000e+00
  store float %107, ptr %33, align 4, !tbaa !9
  %108 = load float, ptr %33, align 4, !tbaa !9
  %109 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %108, float -1.000000e+00)
  %110 = load float, ptr %27, align 4, !tbaa !9
  %111 = fdiv float %109, %110
  %112 = load i32, ptr %32, align 4, !tbaa !5
  %113 = zext i32 %112 to i64
  %114 = getelementptr inbounds float, ptr %99, i64 %113
  store float %111, ptr %114, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  br label %115

115:                                              ; preds = %104
  %116 = load i32, ptr %32, align 4, !tbaa !5
  %117 = add i32 %116, 1
  store i32 %117, ptr %32, align 4, !tbaa !5
  br label %100, !llvm.loop !13

118:                                              ; preds = %100
  %119 = load i32, ptr %28, align 4, !tbaa !5
  %120 = zext i32 %119 to i64
  %121 = alloca { float, float }, i64 %120, align 16
  store i64 %120, ptr %34, align 8
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %122

122:                                              ; preds = %146, %118
  %123 = load i32, ptr %32, align 4, !tbaa !5
  %124 = load i32, ptr %28, align 4, !tbaa !5
  %125 = icmp ult i32 %123, %124
  br i1 %125, label %126, label %149

126:                                              ; preds = %122
  %127 = load i32, ptr %32, align 4, !tbaa !5
  %128 = zext i32 %127 to i64
  %129 = getelementptr inbounds float, ptr %99, i64 %128
  %130 = load float, ptr %129, align 4, !tbaa !9
  %131 = load float, ptr %21, align 4, !tbaa !9
  %132 = load i32, ptr %16, align 4, !tbaa !5
  %133 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 0
  %134 = getelementptr inbounds { float, float }, ptr %35, i32 0, i32 1
  store float %130, ptr %133, align 4
  store float 0.000000e+00, ptr %134, align 4
  %135 = load <2 x float>, ptr %35, align 4
  %136 = call <2 x float> @ellip_cdf(<2 x float> noundef %135, float noundef %131, i32 noundef %132)
  store <2 x float> %136, ptr %36, align 4
  %137 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 0
  %138 = load float, ptr %137, align 4
  %139 = getelementptr inbounds { float, float }, ptr %36, i32 0, i32 1
  %140 = load float, ptr %139, align 4
  %141 = load i32, ptr %32, align 4, !tbaa !5
  %142 = zext i32 %141 to i64
  %143 = getelementptr inbounds { float, float }, ptr %121, i64 %142
  %144 = getelementptr inbounds { float, float }, ptr %143, i32 0, i32 0
  %145 = getelementptr inbounds { float, float }, ptr %143, i32 0, i32 1
  store float %138, ptr %144, align 8
  store float %140, ptr %145, align 4
  br label %146

146:                                              ; preds = %126
  %147 = load i32, ptr %32, align 4, !tbaa !5
  %148 = add i32 %147, 1
  store i32 %148, ptr %32, align 4, !tbaa !5
  br label %122, !llvm.loop !15

149:                                              ; preds = %122
  %150 = load i32, ptr %28, align 4, !tbaa !5
  %151 = zext i32 %150 to i64
  %152 = alloca { float, float }, i64 %151, align 16
  store i64 %151, ptr %37, align 8
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %153

153:                                              ; preds = %181, %149
  %154 = load i32, ptr %32, align 4, !tbaa !5
  %155 = load i32, ptr %28, align 4, !tbaa !5
  %156 = icmp ult i32 %154, %155
  br i1 %156, label %157, label %184

157:                                              ; preds = %153
  %158 = load float, ptr %17, align 4, !tbaa !9
  %159 = fmul float 0.000000e+00, %158
  %160 = fmul float 1.000000e+00, %158
  %161 = load float, ptr %21, align 4, !tbaa !9
  %162 = load i32, ptr %32, align 4, !tbaa !5
  %163 = zext i32 %162 to i64
  %164 = getelementptr inbounds { float, float }, ptr %121, i64 %163
  %165 = getelementptr inbounds { float, float }, ptr %164, i32 0, i32 0
  %166 = load float, ptr %165, align 8
  %167 = getelementptr inbounds { float, float }, ptr %164, i32 0, i32 1
  %168 = load float, ptr %167, align 4
  %169 = fmul float %161, %166
  %170 = fmul float %161, %168
  %171 = call <2 x float> @__divsc3(float noundef %159, float noundef %160, float noundef %169, float noundef %170) #7
  store <2 x float> %171, ptr %38, align 4
  %172 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 0
  %173 = load float, ptr %172, align 4
  %174 = getelementptr inbounds { float, float }, ptr %38, i32 0, i32 1
  %175 = load float, ptr %174, align 4
  %176 = load i32, ptr %32, align 4, !tbaa !5
  %177 = zext i32 %176 to i64
  %178 = getelementptr inbounds { float, float }, ptr %152, i64 %177
  %179 = getelementptr inbounds { float, float }, ptr %178, i32 0, i32 0
  %180 = getelementptr inbounds { float, float }, ptr %178, i32 0, i32 1
  store float %173, ptr %179, align 8
  store float %175, ptr %180, align 4
  br label %181

181:                                              ; preds = %157
  %182 = load i32, ptr %32, align 4, !tbaa !5
  %183 = add i32 %182, 1
  store i32 %183, ptr %32, align 4, !tbaa !5
  br label %153, !llvm.loop !16

184:                                              ; preds = %153
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #7
  %185 = load float, ptr %19, align 4, !tbaa !9
  %186 = fdiv float 0.000000e+00, %185
  %187 = fdiv float 1.000000e+00, %185
  %188 = load float, ptr %22, align 4, !tbaa !9
  %189 = load i32, ptr %16, align 4, !tbaa !5
  %190 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 0
  %191 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 1
  store float %186, ptr %190, align 4
  store float %187, ptr %191, align 4
  %192 = load <2 x float>, ptr %40, align 4
  %193 = call <2 x float> @ellip_asnf(<2 x float> noundef %192, float noundef %188, i32 noundef %189)
  store <2 x float> %193, ptr %41, align 4
  %194 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 0
  %195 = load float, ptr %194, align 4
  %196 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 1
  %197 = load float, ptr %196, align 4
  %198 = fmul float -0.000000e+00, %195
  %199 = fmul float -1.000000e+00, %197
  %200 = fmul float -0.000000e+00, %197
  %201 = fmul float -1.000000e+00, %195
  %202 = fsub float %198, %199
  %203 = fadd float %200, %201
  %204 = fcmp uno float %202, %202
  br i1 %204, label %205, label %213, !prof !17

205:                                              ; preds = %184
  %206 = fcmp uno float %203, %203
  br i1 %206, label %207, label %213, !prof !17

207:                                              ; preds = %205
  %208 = call <2 x float> @__mulsc3(float noundef -0.000000e+00, float noundef -1.000000e+00, float noundef %195, float noundef %197) #7
  store <2 x float> %208, ptr %42, align 4
  %209 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 0
  %210 = load float, ptr %209, align 4
  %211 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 1
  %212 = load float, ptr %211, align 4
  br label %213

213:                                              ; preds = %207, %205, %184
  %214 = phi float [ %202, %184 ], [ %202, %205 ], [ %210, %207 ]
  %215 = phi float [ %203, %184 ], [ %203, %205 ], [ %212, %207 ]
  %216 = load float, ptr %27, align 4, !tbaa !9
  %217 = fdiv float %214, %216
  %218 = fdiv float %215, %216
  %219 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 0
  %220 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 1
  store float %217, ptr %219, align 4
  store float %218, ptr %220, align 4
  %221 = load i32, ptr %28, align 4, !tbaa !5
  %222 = zext i32 %221 to i64
  %223 = alloca { float, float }, i64 %222, align 16
  store i64 %222, ptr %43, align 8
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %224

224:                                              ; preds = %293, %213
  %225 = load i32, ptr %32, align 4, !tbaa !5
  %226 = load i32, ptr %28, align 4, !tbaa !5
  %227 = icmp ult i32 %225, %226
  br i1 %227, label %228, label %296

228:                                              ; preds = %224
  %229 = load float, ptr %17, align 4, !tbaa !9
  %230 = fmul float %229, 0.000000e+00
  %231 = fmul float %229, 1.000000e+00
  %232 = load i32, ptr %32, align 4, !tbaa !5
  %233 = zext i32 %232 to i64
  %234 = getelementptr inbounds float, ptr %99, i64 %233
  %235 = load float, ptr %234, align 4, !tbaa !9
  %236 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 0
  %237 = load float, ptr %236, align 4
  %238 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 1
  %239 = load float, ptr %238, align 4
  %240 = fmul float 0.000000e+00, %237
  %241 = fmul float 1.000000e+00, %239
  %242 = fmul float 0.000000e+00, %239
  %243 = fmul float 1.000000e+00, %237
  %244 = fsub float %240, %241
  %245 = fadd float %242, %243
  %246 = fcmp uno float %244, %244
  br i1 %246, label %247, label %255, !prof !17

247:                                              ; preds = %228
  %248 = fcmp uno float %245, %245
  br i1 %248, label %249, label %255, !prof !17

249:                                              ; preds = %247
  %250 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 1.000000e+00, float noundef %237, float noundef %239) #7
  store <2 x float> %250, ptr %44, align 4
  %251 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 0
  %252 = load float, ptr %251, align 4
  %253 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 1
  %254 = load float, ptr %253, align 4
  br label %255

255:                                              ; preds = %249, %247, %228
  %256 = phi float [ %244, %228 ], [ %244, %247 ], [ %252, %249 ]
  %257 = phi float [ %245, %228 ], [ %245, %247 ], [ %254, %249 ]
  %258 = fsub float %235, %256
  %259 = fneg float %257
  %260 = load float, ptr %21, align 4, !tbaa !9
  %261 = load i32, ptr %16, align 4, !tbaa !5
  %262 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 0
  %263 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 1
  store float %258, ptr %262, align 4
  store float %259, ptr %263, align 4
  %264 = load <2 x float>, ptr %45, align 4
  %265 = call <2 x float> @ellip_cdf(<2 x float> noundef %264, float noundef %260, i32 noundef %261)
  store <2 x float> %265, ptr %46, align 4
  %266 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 0
  %267 = load float, ptr %266, align 4
  %268 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 1
  %269 = load float, ptr %268, align 4
  %270 = fmul float %230, %267
  %271 = fmul float %231, %269
  %272 = fmul float %230, %269
  %273 = fmul float %231, %267
  %274 = fsub float %270, %271
  %275 = fadd float %272, %273
  %276 = fcmp uno float %274, %274
  br i1 %276, label %277, label %285, !prof !17

277:                                              ; preds = %255
  %278 = fcmp uno float %275, %275
  br i1 %278, label %279, label %285, !prof !17

279:                                              ; preds = %277
  %280 = call <2 x float> @__mulsc3(float noundef %230, float noundef %231, float noundef %267, float noundef %269) #7
  store <2 x float> %280, ptr %47, align 4
  %281 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 0
  %282 = load float, ptr %281, align 4
  %283 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 1
  %284 = load float, ptr %283, align 4
  br label %285

285:                                              ; preds = %279, %277, %255
  %286 = phi float [ %274, %255 ], [ %274, %277 ], [ %282, %279 ]
  %287 = phi float [ %275, %255 ], [ %275, %277 ], [ %284, %279 ]
  %288 = load i32, ptr %32, align 4, !tbaa !5
  %289 = zext i32 %288 to i64
  %290 = getelementptr inbounds { float, float }, ptr %223, i64 %289
  %291 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 0
  %292 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 1
  store float %286, ptr %291, align 8
  store float %287, ptr %292, align 4
  br label %293

293:                                              ; preds = %285
  %294 = load i32, ptr %32, align 4, !tbaa !5
  %295 = add i32 %294, 1
  store i32 %295, ptr %32, align 4, !tbaa !5
  br label %224, !llvm.loop !18

296:                                              ; preds = %224
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #7
  %297 = load float, ptr %17, align 4, !tbaa !9
  %298 = fmul float %297, 0.000000e+00
  %299 = fmul float %297, 1.000000e+00
  %300 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 0
  %301 = load float, ptr %300, align 4
  %302 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 1
  %303 = load float, ptr %302, align 4
  %304 = fmul float 0.000000e+00, %301
  %305 = fmul float 1.000000e+00, %303
  %306 = fmul float 0.000000e+00, %303
  %307 = fmul float 1.000000e+00, %301
  %308 = fsub float %304, %305
  %309 = fadd float %306, %307
  %310 = fcmp uno float %308, %308
  br i1 %310, label %311, label %319, !prof !17

311:                                              ; preds = %296
  %312 = fcmp uno float %309, %309
  br i1 %312, label %313, label %319, !prof !17

313:                                              ; preds = %311
  %314 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 1.000000e+00, float noundef %301, float noundef %303) #7
  store <2 x float> %314, ptr %49, align 4
  %315 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 0
  %316 = load float, ptr %315, align 4
  %317 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 1
  %318 = load float, ptr %317, align 4
  br label %319

319:                                              ; preds = %313, %311, %296
  %320 = phi float [ %308, %296 ], [ %308, %311 ], [ %316, %313 ]
  %321 = phi float [ %309, %296 ], [ %309, %311 ], [ %318, %313 ]
  %322 = load float, ptr %21, align 4, !tbaa !9
  %323 = load i32, ptr %16, align 4, !tbaa !5
  %324 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 0
  %325 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 1
  store float %320, ptr %324, align 4
  store float %321, ptr %325, align 4
  %326 = load <2 x float>, ptr %50, align 4
  %327 = call <2 x float> @ellip_snf(<2 x float> noundef %326, float noundef %322, i32 noundef %323)
  store <2 x float> %327, ptr %51, align 4
  %328 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 0
  %329 = load float, ptr %328, align 4
  %330 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 1
  %331 = load float, ptr %330, align 4
  %332 = fmul float %298, %329
  %333 = fmul float %299, %331
  %334 = fmul float %298, %331
  %335 = fmul float %299, %329
  %336 = fsub float %332, %333
  %337 = fadd float %334, %335
  %338 = fcmp uno float %336, %336
  br i1 %338, label %339, label %347, !prof !17

339:                                              ; preds = %319
  %340 = fcmp uno float %337, %337
  br i1 %340, label %341, label %347, !prof !17

341:                                              ; preds = %339
  %342 = call <2 x float> @__mulsc3(float noundef %298, float noundef %299, float noundef %329, float noundef %331) #7
  store <2 x float> %342, ptr %52, align 4
  %343 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 0
  %344 = load float, ptr %343, align 4
  %345 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 1
  %346 = load float, ptr %345, align 4
  br label %347

347:                                              ; preds = %341, %339, %319
  %348 = phi float [ %336, %319 ], [ %336, %339 ], [ %344, %341 ]
  %349 = phi float [ %337, %319 ], [ %337, %339 ], [ %346, %341 ]
  %350 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 0
  %351 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 1
  store float %348, ptr %350, align 4
  store float %349, ptr %351, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #7
  store i32 0, ptr %53, align 4, !tbaa !5
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %352

352:                                              ; preds = %386, %347
  %353 = load i32, ptr %32, align 4, !tbaa !5
  %354 = load i32, ptr %28, align 4, !tbaa !5
  %355 = icmp ult i32 %353, %354
  br i1 %355, label %356, label %389

356:                                              ; preds = %352
  %357 = load i32, ptr %32, align 4, !tbaa !5
  %358 = zext i32 %357 to i64
  %359 = getelementptr inbounds { float, float }, ptr %223, i64 %358
  %360 = getelementptr inbounds { float, float }, ptr %359, i32 0, i32 0
  %361 = load float, ptr %360, align 8
  %362 = getelementptr inbounds { float, float }, ptr %359, i32 0, i32 1
  %363 = load float, ptr %362, align 4
  %364 = load ptr, ptr %12, align 8, !tbaa !11
  %365 = load i32, ptr %53, align 4, !tbaa !5
  %366 = add i32 %365, 1
  store i32 %366, ptr %53, align 4, !tbaa !5
  %367 = zext i32 %365 to i64
  %368 = getelementptr inbounds { float, float }, ptr %364, i64 %367
  %369 = getelementptr inbounds { float, float }, ptr %368, i32 0, i32 0
  %370 = getelementptr inbounds { float, float }, ptr %368, i32 0, i32 1
  store float %361, ptr %369, align 4
  store float %363, ptr %370, align 4
  %371 = load i32, ptr %32, align 4, !tbaa !5
  %372 = zext i32 %371 to i64
  %373 = getelementptr inbounds { float, float }, ptr %223, i64 %372
  %374 = getelementptr inbounds { float, float }, ptr %373, i32 0, i32 0
  %375 = load float, ptr %374, align 8
  %376 = getelementptr inbounds { float, float }, ptr %373, i32 0, i32 1
  %377 = load float, ptr %376, align 4
  %378 = fneg float %377
  %379 = load ptr, ptr %12, align 8, !tbaa !11
  %380 = load i32, ptr %53, align 4, !tbaa !5
  %381 = add i32 %380, 1
  store i32 %381, ptr %53, align 4, !tbaa !5
  %382 = zext i32 %380 to i64
  %383 = getelementptr inbounds { float, float }, ptr %379, i64 %382
  %384 = getelementptr inbounds { float, float }, ptr %383, i32 0, i32 0
  %385 = getelementptr inbounds { float, float }, ptr %383, i32 0, i32 1
  store float %375, ptr %384, align 4
  store float %378, ptr %385, align 4
  br label %386

386:                                              ; preds = %356
  %387 = load i32, ptr %32, align 4, !tbaa !5
  %388 = add i32 %387, 1
  store i32 %388, ptr %32, align 4, !tbaa !5
  br label %352, !llvm.loop !19

389:                                              ; preds = %352
  %390 = load i32, ptr %29, align 4, !tbaa !5
  %391 = icmp ne i32 %390, 0
  br i1 %391, label %392, label %404

392:                                              ; preds = %389
  %393 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 0
  %394 = load float, ptr %393, align 4
  %395 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 1
  %396 = load float, ptr %395, align 4
  %397 = load ptr, ptr %12, align 8, !tbaa !11
  %398 = load i32, ptr %53, align 4, !tbaa !5
  %399 = add i32 %398, 1
  store i32 %399, ptr %53, align 4, !tbaa !5
  %400 = zext i32 %398 to i64
  %401 = getelementptr inbounds { float, float }, ptr %397, i64 %400
  %402 = getelementptr inbounds { float, float }, ptr %401, i32 0, i32 0
  %403 = getelementptr inbounds { float, float }, ptr %401, i32 0, i32 1
  store float %394, ptr %402, align 4
  store float %396, ptr %403, align 4
  br label %404

404:                                              ; preds = %392, %389
  %405 = load i32, ptr %53, align 4, !tbaa !5
  %406 = load i32, ptr %8, align 4, !tbaa !5
  %407 = icmp ne i32 %405, %406
  br i1 %407, label %408, label %410

408:                                              ; preds = %404
  %409 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 385, ptr noundef @.str.1)
  store i32 %409, ptr %7, align 4
  store i32 1, ptr %54, align 4
  br label %542

410:                                              ; preds = %404
  store i32 0, ptr %53, align 4, !tbaa !5
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %411

411:                                              ; preds = %445, %410
  %412 = load i32, ptr %32, align 4, !tbaa !5
  %413 = load i32, ptr %28, align 4, !tbaa !5
  %414 = icmp ult i32 %412, %413
  br i1 %414, label %415, label %448

415:                                              ; preds = %411
  %416 = load i32, ptr %32, align 4, !tbaa !5
  %417 = zext i32 %416 to i64
  %418 = getelementptr inbounds { float, float }, ptr %152, i64 %417
  %419 = getelementptr inbounds { float, float }, ptr %418, i32 0, i32 0
  %420 = load float, ptr %419, align 8
  %421 = getelementptr inbounds { float, float }, ptr %418, i32 0, i32 1
  %422 = load float, ptr %421, align 4
  %423 = load ptr, ptr %11, align 8, !tbaa !11
  %424 = load i32, ptr %53, align 4, !tbaa !5
  %425 = add i32 %424, 1
  store i32 %425, ptr %53, align 4, !tbaa !5
  %426 = zext i32 %424 to i64
  %427 = getelementptr inbounds { float, float }, ptr %423, i64 %426
  %428 = getelementptr inbounds { float, float }, ptr %427, i32 0, i32 0
  %429 = getelementptr inbounds { float, float }, ptr %427, i32 0, i32 1
  store float %420, ptr %428, align 4
  store float %422, ptr %429, align 4
  %430 = load i32, ptr %32, align 4, !tbaa !5
  %431 = zext i32 %430 to i64
  %432 = getelementptr inbounds { float, float }, ptr %152, i64 %431
  %433 = getelementptr inbounds { float, float }, ptr %432, i32 0, i32 0
  %434 = load float, ptr %433, align 8
  %435 = getelementptr inbounds { float, float }, ptr %432, i32 0, i32 1
  %436 = load float, ptr %435, align 4
  %437 = fneg float %436
  %438 = load ptr, ptr %11, align 8, !tbaa !11
  %439 = load i32, ptr %53, align 4, !tbaa !5
  %440 = add i32 %439, 1
  store i32 %440, ptr %53, align 4, !tbaa !5
  %441 = zext i32 %439 to i64
  %442 = getelementptr inbounds { float, float }, ptr %438, i64 %441
  %443 = getelementptr inbounds { float, float }, ptr %442, i32 0, i32 0
  %444 = getelementptr inbounds { float, float }, ptr %442, i32 0, i32 1
  store float %434, ptr %443, align 4
  store float %437, ptr %444, align 4
  br label %445

445:                                              ; preds = %415
  %446 = load i32, ptr %32, align 4, !tbaa !5
  %447 = add i32 %446, 1
  store i32 %447, ptr %32, align 4, !tbaa !5
  br label %411, !llvm.loop !20

448:                                              ; preds = %411
  %449 = load i32, ptr %53, align 4, !tbaa !5
  %450 = load i32, ptr %28, align 4, !tbaa !5
  %451 = mul i32 2, %450
  %452 = icmp ne i32 %449, %451
  br i1 %452, label %453, label %455

453:                                              ; preds = %448
  %454 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef @.str, i32 noundef 393, ptr noundef @.str.2)
  store i32 %454, ptr %7, align 4
  store i32 1, ptr %54, align 4
  br label %542

455:                                              ; preds = %448
  %456 = load i32, ptr %29, align 4, !tbaa !5
  %457 = icmp ne i32 %456, 0
  br i1 %457, label %458, label %459

458:                                              ; preds = %455
  br label %465

459:                                              ; preds = %455
  %460 = load float, ptr %9, align 4, !tbaa !9
  %461 = load float, ptr %9, align 4, !tbaa !9
  %462 = call float @llvm.fmuladd.f32(float %460, float %461, float 1.000000e+00)
  %463 = call float @sqrtf(float noundef %462) #7
  %464 = fdiv float 1.000000e+00, %463
  br label %465

465:                                              ; preds = %459, %458
  %466 = phi float [ 1.000000e+00, %458 ], [ %464, %459 ]
  %467 = load ptr, ptr %13, align 8, !tbaa !11
  %468 = getelementptr inbounds { float, float }, ptr %467, i32 0, i32 0
  %469 = getelementptr inbounds { float, float }, ptr %467, i32 0, i32 1
  store float %466, ptr %468, align 4
  store float 0.000000e+00, ptr %469, align 4
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %470

470:                                              ; preds = %508, %465
  %471 = load i32, ptr %32, align 4, !tbaa !5
  %472 = load i32, ptr %8, align 4, !tbaa !5
  %473 = icmp ult i32 %471, %472
  br i1 %473, label %474, label %511

474:                                              ; preds = %470
  %475 = load ptr, ptr %12, align 8, !tbaa !11
  %476 = load i32, ptr %32, align 4, !tbaa !5
  %477 = zext i32 %476 to i64
  %478 = getelementptr inbounds { float, float }, ptr %475, i64 %477
  %479 = getelementptr inbounds { float, float }, ptr %478, i32 0, i32 0
  %480 = load float, ptr %479, align 4
  %481 = getelementptr inbounds { float, float }, ptr %478, i32 0, i32 1
  %482 = load float, ptr %481, align 4
  %483 = load ptr, ptr %13, align 8, !tbaa !11
  %484 = getelementptr inbounds { float, float }, ptr %483, i32 0, i32 0
  %485 = load float, ptr %484, align 4
  %486 = getelementptr inbounds { float, float }, ptr %483, i32 0, i32 1
  %487 = load float, ptr %486, align 4
  %488 = fmul float %485, %480
  %489 = fmul float %487, %482
  %490 = fmul float %485, %482
  %491 = fmul float %487, %480
  %492 = fsub float %488, %489
  %493 = fadd float %490, %491
  %494 = fcmp uno float %492, %492
  br i1 %494, label %495, label %503, !prof !17

495:                                              ; preds = %474
  %496 = fcmp uno float %493, %493
  br i1 %496, label %497, label %503, !prof !17

497:                                              ; preds = %495
  %498 = call <2 x float> @__mulsc3(float noundef %485, float noundef %487, float noundef %480, float noundef %482) #7
  store <2 x float> %498, ptr %55, align 4
  %499 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 0
  %500 = load float, ptr %499, align 4
  %501 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 1
  %502 = load float, ptr %501, align 4
  br label %503

503:                                              ; preds = %497, %495, %474
  %504 = phi float [ %492, %474 ], [ %492, %495 ], [ %500, %497 ]
  %505 = phi float [ %493, %474 ], [ %493, %495 ], [ %502, %497 ]
  %506 = getelementptr inbounds { float, float }, ptr %483, i32 0, i32 0
  %507 = getelementptr inbounds { float, float }, ptr %483, i32 0, i32 1
  store float %504, ptr %506, align 4
  store float %505, ptr %507, align 4
  br label %508

508:                                              ; preds = %503
  %509 = load i32, ptr %32, align 4, !tbaa !5
  %510 = add i32 %509, 1
  store i32 %510, ptr %32, align 4, !tbaa !5
  br label %470, !llvm.loop !21

511:                                              ; preds = %470
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %512

512:                                              ; preds = %538, %511
  %513 = load i32, ptr %32, align 4, !tbaa !5
  %514 = load i32, ptr %28, align 4, !tbaa !5
  %515 = mul i32 2, %514
  %516 = icmp ult i32 %513, %515
  br i1 %516, label %517, label %541

517:                                              ; preds = %512
  %518 = load ptr, ptr %11, align 8, !tbaa !11
  %519 = load i32, ptr %32, align 4, !tbaa !5
  %520 = zext i32 %519 to i64
  %521 = getelementptr inbounds { float, float }, ptr %518, i64 %520
  %522 = getelementptr inbounds { float, float }, ptr %521, i32 0, i32 0
  %523 = load float, ptr %522, align 4
  %524 = getelementptr inbounds { float, float }, ptr %521, i32 0, i32 1
  %525 = load float, ptr %524, align 4
  %526 = load ptr, ptr %13, align 8, !tbaa !11
  %527 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 0
  %528 = load float, ptr %527, align 4
  %529 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 1
  %530 = load float, ptr %529, align 4
  %531 = call <2 x float> @__divsc3(float noundef %528, float noundef %530, float noundef %523, float noundef %525) #7
  store <2 x float> %531, ptr %56, align 4
  %532 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 0
  %533 = load float, ptr %532, align 4
  %534 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 1
  %535 = load float, ptr %534, align 4
  %536 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 0
  %537 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 1
  store float %533, ptr %536, align 4
  store float %535, ptr %537, align 4
  br label %538

538:                                              ; preds = %517
  %539 = load i32, ptr %32, align 4, !tbaa !5
  %540 = add i32 %539, 1
  store i32 %540, ptr %32, align 4, !tbaa !5
  br label %512, !llvm.loop !22

541:                                              ; preds = %512
  store i32 0, ptr %7, align 4
  store i32 1, ptr %54, align 4
  br label %542

542:                                              ; preds = %541, %453, %408
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #7
  %543 = load ptr, ptr %30, align 8
  call void @llvm.stackrestore.p0(ptr %543)
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #7
  call void @llvm.lifetime.end.p0(i64 4, 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
  %544 = load i32, ptr %7, align 4
  ret i32 %544
}

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

declare i32 @liquid_error_fl(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) #6

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 #4 = { nocallback nofree nosync nounwind willreturn }
attributes #5 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { "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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}
!17 = !{!"branch_weights", i32 1, i32 1048575}
!18 = distinct !{!18, !14}
!19 = distinct !{!19, !14}
!20 = distinct !{!20, !14}
!21 = distinct !{!21, !14}
!22 = distinct !{!22, !14}


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

@.str = external hidden unnamed_addr constant [77 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [45 x i8], align 1

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

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

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @ellipkf(float noundef, i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #3

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #3

; Function Attrs: nounwind uwtable
declare dso_local float @ellipdegf(float noundef, float noundef, i32 noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_cdf(<2 x float> noundef, float noundef, i32 noundef) local_unnamed_addr #4

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

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

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_snf(<2 x float> noundef, float noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @ellip_asnf(<2 x float> noundef, float noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
define dso_local i32 @ellip_azpkf(i32 noundef %0, float noundef %1, float noundef %2, ptr nocapture noundef %3, ptr nocapture noundef %4, ptr nocapture noundef writeonly %5) local_unnamed_addr #4 {
  %7 = alloca float, align 4
  %8 = alloca float, align 4
  %9 = alloca float, align 4
  %10 = alloca float, align 4
  %11 = fdiv float %1, %2
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %7) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %8) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %9) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %10) #7
  %12 = call i32 @ellipkf(float noundef 0x3FED1745A0000000, i32 noundef 7, ptr noundef nonnull %7, ptr noundef nonnull %8)
  %13 = call i32 @ellipkf(float noundef %11, i32 noundef 7, ptr noundef nonnull %9, ptr noundef nonnull %10)
  %14 = uitofp i32 %0 to float
  %15 = call float @ellipdegf(float noundef %14, float noundef %11, i32 noundef 7)
  %16 = fmul float %14, 5.000000e-01
  %17 = call float @llvm.floor.f32(float %16)
  %18 = fptoui float %17 to i32
  %19 = fptoui float %14 to i32
  %20 = and i32 %19, 1
  %21 = zext i32 %18 to i64
  %22 = call ptr @llvm.stacksave.p0()
  %23 = alloca float, i64 %21, align 16
  %.not162 = icmp eq i32 %18, 0
  br i1 %.not162, label %._crit_edge138.thread, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %6
  %min.iters.check = icmp ult i32 %18, 4
  br i1 %min.iters.check, label %.lr.ph.preheader285, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph.preheader
  %n.vec = and i64 %21, 4294967292
  %broadcast.splatinsert = insertelement <4 x float> poison, float %14, 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 ]
  %vec.ind = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %24 = uitofp <4 x i32> %vec.ind to <4 x float>
  %25 = fadd <4 x float> %24, <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
  %26 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %25, <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>)
  %27 = fdiv <4 x float> %26, %broadcast.splat
  %28 = getelementptr inbounds float, ptr %23, i64 %index
  store <4 x float> %27, ptr %28, align 16, !tbaa !5
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, <i32 4, i32 4, i32 4, i32 4>
  %29 = icmp eq i64 %index.next, %n.vec
  br i1 %29, label %middle.block, label %vector.body, !llvm.loop !9

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %21
  br i1 %cmp.n, label %._crit_edge, label %.lr.ph.preheader285

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

.lr.ph:                                           ; preds = %.lr.ph.preheader285, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %indvars.iv.ph, %.lr.ph.preheader285 ]
  %30 = trunc nuw i64 %indvars.iv to i32
  %31 = uitofp i32 %30 to float
  %32 = fadd float %31, 1.000000e+00
  %33 = call float @llvm.fmuladd.f32(float %32, float 2.000000e+00, float -1.000000e+00)
  %34 = fdiv float %33, %14
  %35 = getelementptr inbounds float, ptr %23, i64 %indvars.iv
  store float %34, ptr %35, align 4, !tbaa !5
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %21
  br i1 %exitcond.not, label %._crit_edge, label %.lr.ph, !llvm.loop !13

._crit_edge:                                      ; preds = %.lr.ph, %middle.block
  %36 = alloca { float, float }, i64 %21, align 16
  br i1 %.not162, label %._crit_edge138.thread, label %.lr.ph137

.lr.ph137:                                        ; preds = %._crit_edge, %.lr.ph137
  %indvars.iv172 = phi i64 [ %indvars.iv.next173, %.lr.ph137 ], [ 0, %._crit_edge ]
  %37 = getelementptr inbounds float, ptr %23, i64 %indvars.iv172
  %38 = load float, ptr %37, align 4, !tbaa !5
  %.sroa.028.4.vec.insert = insertelement <2 x float> <float poison, float 0.000000e+00>, float %38, i64 0
  %39 = call <2 x float> @ellip_cdf(<2 x float> noundef %.sroa.028.4.vec.insert, float noundef %15, i32 noundef 7)
  %40 = getelementptr inbounds { float, float }, ptr %36, i64 %indvars.iv172
  store <2 x float> %39, ptr %40, align 8
  %indvars.iv.next173 = add nuw nsw i64 %indvars.iv172, 1
  %exitcond176.not = icmp eq i64 %indvars.iv.next173, %21
  br i1 %exitcond176.not, label %._crit_edge138, label %.lr.ph137, !llvm.loop !14

._crit_edge138.thread:                            ; preds = %._crit_edge, %6
  %41 = alloca { float, float }, i64 %21, align 16
  br label %._crit_edge142

._crit_edge138:                                   ; preds = %.lr.ph137
  %42 = alloca { float, float }, i64 %21, align 16
  br i1 %.not162, label %._crit_edge142, label %.lr.ph141

.lr.ph141:                                        ; preds = %._crit_edge138, %.lr.ph141
  %indvars.iv177 = phi i64 [ %indvars.iv.next178, %.lr.ph141 ], [ 0, %._crit_edge138 ]
  %43 = getelementptr inbounds { float, float }, ptr %36, i64 %indvars.iv177
  %44 = load float, ptr %43, align 8
  %45 = getelementptr inbounds i8, ptr %43, i64 4
  %46 = load float, ptr %45, align 4
  %47 = fmul float %15, %44
  %48 = fmul float %15, %46
  %49 = call <2 x float> @__divsc3(float noundef 0.000000e+00, float noundef 0x3FEFFFFFE0000000, float noundef %47, float noundef %48) #7
  %50 = getelementptr inbounds { float, float }, ptr %42, i64 %indvars.iv177
  store <2 x float> %49, ptr %50, align 8
  %indvars.iv.next178 = add nuw nsw i64 %indvars.iv177, 1
  %exitcond181.not = icmp eq i64 %indvars.iv.next178, %21
  br i1 %exitcond181.not, label %._crit_edge142, label %.lr.ph141, !llvm.loop !15

._crit_edge142:                                   ; preds = %.lr.ph141, %._crit_edge138.thread, %._crit_edge138
  %51 = phi ptr [ %41, %._crit_edge138.thread ], [ %42, %._crit_edge138 ], [ %42, %.lr.ph141 ]
  %52 = insertelement <2 x float> poison, float %1, i64 0
  %53 = shufflevector <2 x float> %52, <2 x float> poison, <2 x i32> zeroinitializer
  %54 = fdiv <2 x float> <float 0.000000e+00, float 1.000000e+00>, %53
  %55 = call <2 x float> @ellip_asnf(<2 x float> noundef %54, float noundef %11, i32 noundef 7)
  %.sroa.020.0.vec.extract = extractelement <2 x float> %55, i64 0
  %.sroa.020.4.vec.extract = extractelement <2 x float> %55, i64 1
  %56 = fmul float %.sroa.020.0.vec.extract, 0.000000e+00
  %57 = fmul float %.sroa.020.4.vec.extract, -0.000000e+00
  %58 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %59 = insertelement <2 x float> %58, float %57, i64 1
  %60 = insertelement <2 x float> %58, float %56, i64 0
  %61 = fsub <2 x float> %59, %60
  %62 = extractelement <2 x float> %61, i64 0
  %63 = fcmp uno float %62, 0.000000e+00
  br i1 %63, label %64, label %69, !prof !16

64:                                               ; preds = %._crit_edge142
  %65 = extractelement <2 x float> %61, i64 1
  %66 = fcmp uno float %65, 0.000000e+00
  br i1 %66, label %67, label %69, !prof !16

67:                                               ; preds = %64
  %68 = call <2 x float> @__mulsc3(float noundef -0.000000e+00, float noundef -1.000000e+00, float noundef %.sroa.020.0.vec.extract, float noundef %.sroa.020.4.vec.extract) #7
  br label %69

69:                                               ; preds = %67, %64, %._crit_edge142
  %70 = phi <2 x float> [ %61, %._crit_edge142 ], [ %61, %64 ], [ %68, %67 ]
  %71 = insertelement <2 x float> poison, float %14, i64 0
  %72 = shufflevector <2 x float> %71, <2 x float> poison, <2 x i32> zeroinitializer
  %73 = fdiv <2 x float> %70, %72
  %74 = alloca { float, float }, i64 %21, align 16
  %75 = fmul <2 x float> %73, zeroinitializer
  %76 = shufflevector <2 x float> %73, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %77 = fadd <2 x float> %75, %76
  %78 = fsub <2 x float> %75, %76
  %79 = shufflevector <2 x float> %78, <2 x float> %77, <2 x i32> <i32 0, i32 3>
  br i1 %.not162, label %._crit_edge146, label %.lr.ph145

.lr.ph145:                                        ; preds = %69
  %80 = extractelement <2 x float> %78, i64 0
  %81 = fcmp uno float %80, 0.000000e+00
  %82 = extractelement <2 x float> %77, i64 1
  %83 = fcmp uno float %82, 0.000000e+00
  %84 = extractelement <2 x float> %73, i64 0
  %85 = extractelement <2 x float> %73, i64 1
  br label %86

86:                                               ; preds = %.lr.ph145, %113
  %indvars.iv182 = phi i64 [ 0, %.lr.ph145 ], [ %indvars.iv.next183, %113 ]
  %87 = getelementptr inbounds float, ptr %23, i64 %indvars.iv182
  %88 = load float, ptr %87, align 4, !tbaa !5
  br i1 %81, label %89, label %92, !prof !16

89:                                               ; preds = %86
  br i1 %83, label %90, label %92, !prof !16

90:                                               ; preds = %89
  %91 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 1.000000e+00, float noundef %84, float noundef %85) #7
  br label %92

92:                                               ; preds = %90, %89, %86
  %93 = phi <2 x float> [ %79, %86 ], [ %79, %89 ], [ %91, %90 ]
  %94 = extractelement <2 x float> %93, i64 0
  %95 = fsub float %88, %94
  %96 = fneg <2 x float> %93
  %.sroa.016.4.vec.insert = insertelement <2 x float> %96, float %95, i64 0
  %97 = call <2 x float> @ellip_cdf(<2 x float> noundef %.sroa.016.4.vec.insert, float noundef %15, i32 noundef 7)
  %98 = fmul <2 x float> %97, zeroinitializer
  %99 = fmul <2 x float> %97, <float 0x3FEFFFFFE0000000, float 0x3FEFFFFFE0000000>
  %100 = shufflevector <2 x float> %99, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %101 = fsub <2 x float> %98, %100
  %102 = fadd <2 x float> %98, %100
  %103 = shufflevector <2 x float> %101, <2 x float> %102, <2 x i32> <i32 0, i32 3>
  %104 = extractelement <2 x float> %101, i64 0
  %105 = fcmp uno float %104, 0.000000e+00
  br i1 %105, label %106, label %113, !prof !16

106:                                              ; preds = %92
  %107 = extractelement <2 x float> %102, i64 1
  %108 = fcmp uno float %107, 0.000000e+00
  br i1 %108, label %109, label %113, !prof !16

109:                                              ; preds = %106
  %110 = extractelement <2 x float> %97, i64 0
  %111 = extractelement <2 x float> %97, i64 1
  %112 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 0x3FEFFFFFE0000000, float noundef %110, float noundef %111) #7
  br label %113

113:                                              ; preds = %109, %106, %92
  %114 = phi <2 x float> [ %103, %92 ], [ %103, %106 ], [ %112, %109 ]
  %115 = getelementptr inbounds { float, float }, ptr %74, i64 %indvars.iv182
  store <2 x float> %114, ptr %115, align 8
  %indvars.iv.next183 = add nuw nsw i64 %indvars.iv182, 1
  %exitcond186.not = icmp eq i64 %indvars.iv.next183, %21
  br i1 %exitcond186.not, label %._crit_edge146, label %86, !llvm.loop !17

._crit_edge146:                                   ; preds = %113, %69
  %116 = extractelement <2 x float> %78, i64 0
  %117 = fcmp uno float %116, 0.000000e+00
  br i1 %117, label %118, label %125, !prof !16

118:                                              ; preds = %._crit_edge146
  %119 = extractelement <2 x float> %77, i64 1
  %120 = fcmp uno float %119, 0.000000e+00
  br i1 %120, label %121, label %125, !prof !16

121:                                              ; preds = %118
  %122 = extractelement <2 x float> %73, i64 0
  %123 = extractelement <2 x float> %73, i64 1
  %124 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 1.000000e+00, float noundef %122, float noundef %123) #7
  br label %125

125:                                              ; preds = %121, %118, %._crit_edge146
  %126 = phi <2 x float> [ %79, %._crit_edge146 ], [ %79, %118 ], [ %124, %121 ]
  %127 = call <2 x float> @ellip_snf(<2 x float> noundef %126, float noundef %15, i32 noundef 7)
  %128 = fmul <2 x float> %127, zeroinitializer
  %129 = fmul <2 x float> %127, <float 0x3FEFFFFFE0000000, float 0x3FEFFFFFE0000000>
  %130 = shufflevector <2 x float> %129, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %131 = fsub <2 x float> %128, %130
  %132 = fadd <2 x float> %128, %130
  %133 = shufflevector <2 x float> %131, <2 x float> %132, <2 x i32> <i32 0, i32 3>
  %134 = extractelement <2 x float> %131, i64 0
  %135 = fcmp uno float %134, 0.000000e+00
  br i1 %135, label %136, label %143, !prof !16

136:                                              ; preds = %125
  %137 = extractelement <2 x float> %132, i64 1
  %138 = fcmp uno float %137, 0.000000e+00
  br i1 %138, label %139, label %143, !prof !16

139:                                              ; preds = %136
  %140 = extractelement <2 x float> %127, i64 0
  %141 = extractelement <2 x float> %127, i64 1
  %142 = call <2 x float> @__mulsc3(float noundef 0.000000e+00, float noundef 0x3FEFFFFFE0000000, float noundef %140, float noundef %141) #7
  br label %143

143:                                              ; preds = %139, %136, %125
  %144 = phi <2 x float> [ %133, %125 ], [ %133, %136 ], [ %142, %139 ]
  br i1 %.not162, label %._crit_edge151, label %.lr.ph150.preheader

.lr.ph150.preheader:                              ; preds = %143
  %min.iters.check232 = icmp ult i32 %18, 24
  br i1 %min.iters.check232, label %.lr.ph150.preheader283, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %.lr.ph150.preheader
  %145 = add nsw i64 %21, -1
  %146 = icmp ugt i64 %145, 4294967295
  %scevgep = getelementptr i8, ptr %4, i64 8
  %mul.result = shl nsw i64 %145, 4
  %147 = getelementptr i8, ptr %scevgep, i64 %mul.result
  %148 = icmp ult ptr %147, %scevgep
  %scevgep219 = getelementptr i8, ptr %4, i64 12
  %mul.result221 = shl nsw i64 %145, 4
  %149 = getelementptr i8, ptr %scevgep219, i64 %mul.result221
  %150 = icmp ult ptr %149, %scevgep219
  %scevgep223 = getelementptr i8, ptr %4, i64 4
  %mul.result225 = shl nsw i64 %145, 4
  %151 = getelementptr i8, ptr %scevgep223, i64 %mul.result225
  %152 = icmp ult ptr %151, %scevgep223
  %mul.result228 = shl nsw i64 %145, 4
  %153 = getelementptr i8, ptr %4, i64 %mul.result228
  %154 = icmp ult ptr %153, %4
  %155 = or i1 %148, %146
  %156 = or i1 %150, %155
  %157 = or i1 %152, %156
  %158 = or i1 %154, %157
  br i1 %158, label %.lr.ph150.preheader283, label %vector.ph233

vector.ph233:                                     ; preds = %vector.scevcheck
  %n.vec235 = and i64 %21, 4294967292
  %.cast = trunc nuw i64 %n.vec235 to i32
  %ind.end = shl i32 %.cast, 1
  %invariant.gep = getelementptr i8, ptr %4, i64 -12
  br label %vector.body238

vector.body238:                                   ; preds = %vector.body238, %vector.ph233
  %index239 = phi i64 [ 0, %vector.ph233 ], [ %index.next242, %vector.body238 ]
  %offset.idx = shl i64 %index239, 1
  %159 = getelementptr inbounds { float, float }, ptr %74, i64 %index239
  %wide.vec = load <8 x float>, ptr %159, align 16
  %strided.vec = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec241 = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %160 = fneg <4 x float> %strided.vec241
  %161 = and i64 %offset.idx, 4294967288
  %162 = or disjoint i64 %161, 1
  %gep = getelementptr { float, float }, ptr %invariant.gep, i64 %162, i32 1
  %163 = shufflevector <4 x float> %strided.vec, <4 x float> %strided.vec241, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %164 = shufflevector <4 x float> %strided.vec, <4 x float> %160, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec = shufflevector <8 x float> %163, <8 x float> %164, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
  store <16 x float> %interleaved.vec, ptr %gep, align 4
  %index.next242 = add nuw i64 %index239, 4
  %165 = icmp eq i64 %index.next242, %n.vec235
  br i1 %165, label %middle.block230, label %vector.body238, !llvm.loop !18

middle.block230:                                  ; preds = %vector.body238
  %cmp.n243 = icmp eq i64 %n.vec235, %21
  br i1 %cmp.n243, label %._crit_edge151, label %.lr.ph150.preheader283

.lr.ph150.preheader283:                           ; preds = %middle.block230, %vector.scevcheck, %.lr.ph150.preheader
  %indvars.iv187.ph = phi i64 [ 0, %vector.scevcheck ], [ 0, %.lr.ph150.preheader ], [ %n.vec235, %middle.block230 ]
  %.0124148.ph = phi i32 [ 0, %vector.scevcheck ], [ 0, %.lr.ph150.preheader ], [ %ind.end, %middle.block230 ]
  %xtraiter = and i64 %21, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.lr.ph150.prol.loopexit, label %.lr.ph150.prol

.lr.ph150.prol:                                   ; preds = %.lr.ph150.preheader283
  %166 = getelementptr inbounds { float, float }, ptr %74, i64 %indvars.iv187.ph
  %167 = or disjoint i32 %.0124148.ph, 1
  %168 = zext i32 %.0124148.ph to i64
  %169 = getelementptr inbounds { float, float }, ptr %4, i64 %168
  %170 = load <2 x float>, ptr %166, align 16
  store <2 x float> %170, ptr %169, align 4
  %171 = extractelement <2 x float> %170, i64 1
  %172 = fneg float %171
  %173 = add i32 %.0124148.ph, 2
  %174 = zext i32 %167 to i64
  %175 = getelementptr inbounds { float, float }, ptr %4, i64 %174
  %176 = getelementptr inbounds i8, ptr %175, i64 4
  %177 = extractelement <2 x float> %170, i64 0
  store float %177, ptr %175, align 4
  store float %172, ptr %176, align 4
  %indvars.iv.next188.prol = or disjoint i64 %indvars.iv187.ph, 1
  br label %.lr.ph150.prol.loopexit

.lr.ph150.prol.loopexit:                          ; preds = %.lr.ph150.prol, %.lr.ph150.preheader283
  %.lcssa284.unr = phi i32 [ poison, %.lr.ph150.preheader283 ], [ %173, %.lr.ph150.prol ]
  %indvars.iv187.unr = phi i64 [ %indvars.iv187.ph, %.lr.ph150.preheader283 ], [ %indvars.iv.next188.prol, %.lr.ph150.prol ]
  %.0124148.unr = phi i32 [ %.0124148.ph, %.lr.ph150.preheader283 ], [ %173, %.lr.ph150.prol ]
  %178 = add nsw i64 %21, -1
  %179 = icmp eq i64 %indvars.iv187.ph, %178
  br i1 %179, label %._crit_edge151, label %.lr.ph150.preheader283.new

.lr.ph150.preheader283.new:                       ; preds = %.lr.ph150.prol.loopexit
  %invariant.gep291 = getelementptr i8, ptr %74, i64 8
  br label %.lr.ph150

.lr.ph150:                                        ; preds = %.lr.ph150, %.lr.ph150.preheader283.new
  %indvars.iv187 = phi i64 [ %indvars.iv187.unr, %.lr.ph150.preheader283.new ], [ %indvars.iv.next188.1, %.lr.ph150 ]
  %.0124148 = phi i32 [ %.0124148.unr, %.lr.ph150.preheader283.new ], [ %198, %.lr.ph150 ]
  %180 = getelementptr inbounds { float, float }, ptr %74, i64 %indvars.iv187
  %181 = or disjoint i32 %.0124148, 1
  %182 = zext i32 %.0124148 to i64
  %183 = getelementptr inbounds { float, float }, ptr %4, i64 %182
  %184 = load <2 x float>, ptr %180, align 8
  store <2 x float> %184, ptr %183, align 4
  %185 = extractelement <2 x float> %184, i64 1
  %186 = fneg float %185
  %187 = add i32 %.0124148, 2
  %188 = zext i32 %181 to i64
  %189 = getelementptr inbounds { float, float }, ptr %4, i64 %188
  %190 = getelementptr inbounds i8, ptr %189, i64 4
  %191 = extractelement <2 x float> %184, i64 0
  store float %191, ptr %189, align 4
  store float %186, ptr %190, align 4
  %gep292 = getelementptr { float, float }, ptr %invariant.gep291, i64 %indvars.iv187
  %192 = or disjoint i32 %187, 1
  %193 = zext i32 %187 to i64
  %194 = getelementptr inbounds { float, float }, ptr %4, i64 %193
  %195 = load <2 x float>, ptr %gep292, align 8
  store <2 x float> %195, ptr %194, align 4
  %196 = extractelement <2 x float> %195, i64 1
  %197 = fneg float %196
  %198 = add i32 %.0124148, 4
  %199 = zext i32 %192 to i64
  %200 = getelementptr inbounds { float, float }, ptr %4, i64 %199
  %201 = getelementptr inbounds i8, ptr %200, i64 4
  %202 = extractelement <2 x float> %195, i64 0
  store float %202, ptr %200, align 4
  store float %197, ptr %201, align 4
  %indvars.iv.next188.1 = add nuw nsw i64 %indvars.iv187, 2
  %exitcond191.not.1 = icmp eq i64 %indvars.iv.next188.1, %21
  br i1 %exitcond191.not.1, label %._crit_edge151, label %.lr.ph150, !llvm.loop !19

._crit_edge151:                                   ; preds = %.lr.ph150.prol.loopexit, %.lr.ph150, %middle.block230, %143
  %.0124.lcssa = phi i32 [ 0, %143 ], [ %ind.end, %middle.block230 ], [ %.lcssa284.unr, %.lr.ph150.prol.loopexit ], [ %198, %.lr.ph150 ]
  %.not = icmp eq i32 %20, 0
  br i1 %.not, label %207, label %203

203:                                              ; preds = %._crit_edge151
  %204 = or disjoint i32 %.0124.lcssa, 1
  %205 = zext i32 %.0124.lcssa to i64
  %206 = getelementptr inbounds { float, float }, ptr %4, i64 %205
  store <2 x float> %144, ptr %206, align 4
  br label %207

207:                                              ; preds = %203, %._crit_edge151
  %.1 = phi i32 [ %204, %203 ], [ %.0124.lcssa, %._crit_edge151 ]
  %.not131 = icmp eq i32 %.1, %0
  br i1 %.not131, label %.preheader133, label %243

.preheader133:                                    ; preds = %207
  br i1 %.not162, label %._crit_edge155, label %.lr.ph154.preheader

.lr.ph154.preheader:                              ; preds = %.preheader133
  %min.iters.check262 = icmp ult i32 %18, 24
  br i1 %min.iters.check262, label %.lr.ph154.preheader281, label %vector.scevcheck244

.lr.ph154.preheader281:                           ; preds = %middle.block260, %vector.scevcheck244, %.lr.ph154.preheader
  %indvars.iv192.ph = phi i64 [ 0, %vector.scevcheck244 ], [ 0, %.lr.ph154.preheader ], [ %n.vec265, %middle.block260 ]
  %.2153.ph = phi i32 [ 0, %vector.scevcheck244 ], [ 0, %.lr.ph154.preheader ], [ %ind.end268, %middle.block260 ]
  %xtraiter286 = and i64 %21, 1
  %lcmp.mod287.not = icmp eq i64 %xtraiter286, 0
  br i1 %lcmp.mod287.not, label %.lr.ph154.prol.loopexit, label %.lr.ph154.prol

.lr.ph154.prol:                                   ; preds = %.lr.ph154.preheader281
  %208 = getelementptr inbounds { float, float }, ptr %51, i64 %indvars.iv192.ph
  %209 = or disjoint i32 %.2153.ph, 1
  %210 = zext i32 %.2153.ph to i64
  %211 = getelementptr inbounds { float, float }, ptr %3, i64 %210
  %212 = load <2 x float>, ptr %208, align 16
  store <2 x float> %212, ptr %211, align 4
  %213 = extractelement <2 x float> %212, i64 1
  %214 = fneg float %213
  %215 = add i32 %.2153.ph, 2
  %216 = zext i32 %209 to i64
  %217 = getelementptr inbounds { float, float }, ptr %3, i64 %216
  %218 = getelementptr inbounds i8, ptr %217, i64 4
  %219 = extractelement <2 x float> %212, i64 0
  store float %219, ptr %217, align 4
  store float %214, ptr %218, align 4
  %indvars.iv.next193.prol = or disjoint i64 %indvars.iv192.ph, 1
  br label %.lr.ph154.prol.loopexit

.lr.ph154.prol.loopexit:                          ; preds = %.lr.ph154.prol, %.lr.ph154.preheader281
  %.lcssa282.unr = phi i32 [ poison, %.lr.ph154.preheader281 ], [ %215, %.lr.ph154.prol ]
  %indvars.iv192.unr = phi i64 [ %indvars.iv192.ph, %.lr.ph154.preheader281 ], [ %indvars.iv.next193.prol, %.lr.ph154.prol ]
  %.2153.unr = phi i32 [ %.2153.ph, %.lr.ph154.preheader281 ], [ %215, %.lr.ph154.prol ]
  %220 = add nsw i64 %21, -1
  %221 = icmp eq i64 %indvars.iv192.ph, %220
  br i1 %221, label %._crit_edge155, label %.lr.ph154

vector.scevcheck244:                              ; preds = %.lr.ph154.preheader
  %222 = add nsw i64 %21, -1
  %223 = icmp ugt i64 %222, 4294967295
  %scevgep245 = getelementptr i8, ptr %3, i64 8
  %mul.result247 = shl nsw i64 %222, 4
  %224 = getelementptr i8, ptr %scevgep245, i64 %mul.result247
  %225 = icmp ult ptr %224, %scevgep245
  %scevgep249 = getelementptr i8, ptr %3, i64 12
  %mul.result251 = shl nsw i64 %222, 4
  %226 = getelementptr i8, ptr %scevgep249, i64 %mul.result251
  %227 = icmp ult ptr %226, %scevgep249
  %scevgep253 = getelementptr i8, ptr %3, i64 4
  %mul.result255 = shl nsw i64 %222, 4
  %228 = getelementptr i8, ptr %scevgep253, i64 %mul.result255
  %229 = icmp ult ptr %228, %scevgep253
  %mul.result258 = shl nsw i64 %222, 4
  %230 = getelementptr i8, ptr %3, i64 %mul.result258
  %231 = icmp ult ptr %230, %3
  %232 = or i1 %225, %223
  %233 = or i1 %227, %232
  %234 = or i1 %229, %233
  %235 = or i1 %231, %234
  br i1 %235, label %.lr.ph154.preheader281, label %vector.ph263

vector.ph263:                                     ; preds = %vector.scevcheck244
  %n.vec265 = and i64 %21, 4294967292
  %.cast267 = trunc nuw i64 %n.vec265 to i32
  %ind.end268 = shl i32 %.cast267, 1
  %invariant.gep293 = getelementptr i8, ptr %3, i64 -12
  br label %vector.body270

vector.body270:                                   ; preds = %vector.body270, %vector.ph263
  %index271 = phi i64 [ 0, %vector.ph263 ], [ %index.next278, %vector.body270 ]
  %offset.idx273 = shl i64 %index271, 1
  %236 = getelementptr inbounds { float, float }, ptr %51, i64 %index271
  %wide.vec274 = load <8 x float>, ptr %236, align 16
  %strided.vec275 = shufflevector <8 x float> %wide.vec274, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec276 = shufflevector <8 x float> %wide.vec274, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %237 = fneg <4 x float> %strided.vec276
  %238 = and i64 %offset.idx273, 4294967288
  %239 = or disjoint i64 %238, 1
  %gep294 = getelementptr { float, float }, ptr %invariant.gep293, i64 %239, i32 1
  %240 = shufflevector <4 x float> %strided.vec275, <4 x float> %strided.vec276, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %241 = shufflevector <4 x float> %strided.vec275, <4 x float> %237, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  %interleaved.vec277 = shufflevector <8 x float> %240, <8 x float> %241, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
  store <16 x float> %interleaved.vec277, ptr %gep294, align 4
  %index.next278 = add nuw i64 %index271, 4
  %242 = icmp eq i64 %index.next278, %n.vec265
  br i1 %242, label %middle.block260, label %vector.body270, !llvm.loop !20

middle.block260:                                  ; preds = %vector.body270
  %cmp.n279 = icmp eq i64 %n.vec265, %21
  br i1 %cmp.n279, label %._crit_edge155, label %.lr.ph154.preheader281

243:                                              ; preds = %207
  %244 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 385, ptr noundef nonnull @.str.1) #7
  br label %.loopexit

.lr.ph154:                                        ; preds = %.lr.ph154.prol.loopexit, %.lr.ph154
  %indvars.iv192 = phi i64 [ %indvars.iv.next193.1, %.lr.ph154 ], [ %indvars.iv192.unr, %.lr.ph154.prol.loopexit ]
  %.2153 = phi i32 [ %264, %.lr.ph154 ], [ %.2153.unr, %.lr.ph154.prol.loopexit ]
  %245 = getelementptr inbounds { float, float }, ptr %51, i64 %indvars.iv192
  %246 = or disjoint i32 %.2153, 1
  %247 = zext i32 %.2153 to i64
  %248 = getelementptr inbounds { float, float }, ptr %3, i64 %247
  %249 = load <2 x float>, ptr %245, align 8
  store <2 x float> %249, ptr %248, align 4
  %250 = extractelement <2 x float> %249, i64 1
  %251 = fneg float %250
  %252 = add i32 %.2153, 2
  %253 = zext i32 %246 to i64
  %254 = getelementptr inbounds { float, float }, ptr %3, i64 %253
  %255 = getelementptr inbounds i8, ptr %254, i64 4
  %256 = extractelement <2 x float> %249, i64 0
  store float %256, ptr %254, align 4
  store float %251, ptr %255, align 4
  %indvars.iv.next193 = add nuw nsw i64 %indvars.iv192, 1
  %257 = getelementptr inbounds { float, float }, ptr %51, i64 %indvars.iv.next193
  %258 = or disjoint i32 %252, 1
  %259 = zext i32 %252 to i64
  %260 = getelementptr inbounds { float, float }, ptr %3, i64 %259
  %261 = load <2 x float>, ptr %257, align 8
  store <2 x float> %261, ptr %260, align 4
  %262 = extractelement <2 x float> %261, i64 1
  %263 = fneg float %262
  %264 = add i32 %.2153, 4
  %265 = zext i32 %258 to i64
  %266 = getelementptr inbounds { float, float }, ptr %3, i64 %265
  %267 = getelementptr inbounds i8, ptr %266, i64 4
  %268 = extractelement <2 x float> %261, i64 0
  store float %268, ptr %266, align 4
  store float %263, ptr %267, align 4
  %indvars.iv.next193.1 = add nuw nsw i64 %indvars.iv192, 2
  %exitcond196.not.1 = icmp eq i64 %indvars.iv.next193.1, %21
  br i1 %exitcond196.not.1, label %._crit_edge155, label %.lr.ph154, !llvm.loop !21

._crit_edge155:                                   ; preds = %.lr.ph154.prol.loopexit, %.lr.ph154, %middle.block260, %.preheader133
  %.2.lcssa = phi i32 [ 0, %.preheader133 ], [ %ind.end268, %middle.block260 ], [ %.lcssa282.unr, %.lr.ph154.prol.loopexit ], [ %264, %.lr.ph154 ]
  %269 = shl i32 %18, 1
  %.not132 = icmp eq i32 %.2.lcssa, %269
  br i1 %.not132, label %272, label %270

270:                                              ; preds = %._crit_edge155
  %271 = call i32 (i32, ptr, i32, ptr, ...) @liquid_error_fl(i32 noundef 1, ptr noundef nonnull @.str, i32 noundef 393, ptr noundef nonnull @.str.2) #7
  br label %.loopexit

272:                                              ; preds = %._crit_edge155
  br i1 %.not, label %273, label %276

273:                                              ; preds = %272
  %274 = call float @llvm.fmuladd.f32(float %1, float %1, float 1.000000e+00)
  %sqrt = call float @llvm.sqrt.f32(float %274)
  %275 = fdiv float 1.000000e+00, %sqrt
  br label %276

276:                                              ; preds = %272, %273
  %277 = phi float [ %275, %273 ], [ 1.000000e+00, %272 ]
  %278 = getelementptr inbounds i8, ptr %5, i64 4
  store float %277, ptr %5, align 4
  store float 0.000000e+00, ptr %278, align 4
  %.not168 = icmp eq i32 %0, 0
  br i1 %.not168, label %.preheader, label %.lr.ph159.preheader

.lr.ph159.preheader:                              ; preds = %276
  %wide.trip.count200 = zext i32 %0 to i64
  br label %.lr.ph159

.preheader:                                       ; preds = %298, %276
  %279 = phi float [ 0.000000e+00, %276 ], [ %300, %298 ]
  %280 = phi float [ %277, %276 ], [ %299, %298 ]
  %.not169 = icmp eq i32 %.2.lcssa, 0
  br i1 %.not169, label %.loopexit, label %.lr.ph161.preheader

.lr.ph161.preheader:                              ; preds = %.preheader
  %wide.trip.count205 = zext i32 %.2.lcssa to i64
  br label %.lr.ph161

.lr.ph159:                                        ; preds = %.lr.ph159.preheader, %298
  %281 = phi float [ 0.000000e+00, %.lr.ph159.preheader ], [ %300, %298 ]
  %282 = phi float [ %277, %.lr.ph159.preheader ], [ %299, %298 ]
  %indvars.iv197 = phi i64 [ 0, %.lr.ph159.preheader ], [ %indvars.iv.next198, %298 ]
  %283 = getelementptr inbounds { float, float }, ptr %4, i64 %indvars.iv197
  %284 = load float, ptr %283, align 4
  %285 = getelementptr inbounds i8, ptr %283, i64 4
  %286 = load float, ptr %285, align 4
  %287 = fmul float %284, %282
  %288 = fmul float %286, %281
  %289 = fmul float %286, %282
  %290 = fmul float %284, %281
  %291 = fsub float %287, %288
  %292 = fadd float %289, %290
  %293 = fcmp uno float %291, 0.000000e+00
  br i1 %293, label %294, label %298, !prof !16

294:                                              ; preds = %.lr.ph159
  %295 = fcmp uno float %292, 0.000000e+00
  br i1 %295, label %296, label %298, !prof !16

296:                                              ; preds = %294
  %297 = call <2 x float> @__mulsc3(float noundef %282, float noundef %281, float noundef %284, float noundef %286) #7
  %.sroa.01.0.vec.extract = extractelement <2 x float> %297, i64 0
  %.sroa.01.4.vec.extract = extractelement <2 x float> %297, i64 1
  br label %298

298:                                              ; preds = %296, %294, %.lr.ph159
  %299 = phi float [ %291, %.lr.ph159 ], [ %291, %294 ], [ %.sroa.01.0.vec.extract, %296 ]
  %300 = phi float [ %292, %.lr.ph159 ], [ %292, %294 ], [ %.sroa.01.4.vec.extract, %296 ]
  store float %299, ptr %5, align 4
  store float %300, ptr %278, align 4
  %indvars.iv.next198 = add nuw nsw i64 %indvars.iv197, 1
  %exitcond201.not = icmp eq i64 %indvars.iv.next198, %wide.trip.count200
  br i1 %exitcond201.not, label %.preheader, label %.lr.ph159, !llvm.loop !22

.lr.ph161:                                        ; preds = %.lr.ph161.preheader, %.lr.ph161
  %301 = phi float [ %279, %.lr.ph161.preheader ], [ %309, %.lr.ph161 ]
  %302 = phi float [ %280, %.lr.ph161.preheader ], [ %308, %.lr.ph161 ]
  %indvars.iv202 = phi i64 [ 0, %.lr.ph161.preheader ], [ %indvars.iv.next203, %.lr.ph161 ]
  %303 = getelementptr inbounds { float, float }, ptr %3, i64 %indvars.iv202
  %304 = load float, ptr %303, align 4
  %305 = getelementptr inbounds i8, ptr %303, i64 4
  %306 = load float, ptr %305, align 4
  %307 = call <2 x float> @__divsc3(float noundef %302, float noundef %301, float noundef %304, float noundef %306) #7
  store <2 x float> %307, ptr %5, align 4
  %indvars.iv.next203 = add nuw nsw i64 %indvars.iv202, 1
  %exitcond206.not = icmp eq i64 %indvars.iv.next203, %wide.trip.count205
  %308 = extractelement <2 x float> %307, i64 0
  %309 = extractelement <2 x float> %307, i64 1
  br i1 %exitcond206.not, label %.loopexit, label %.lr.ph161, !llvm.loop !23

.loopexit:                                        ; preds = %.lr.ph161, %.preheader, %270, %243
  %.0 = phi i32 [ %244, %243 ], [ %271, %270 ], [ 0, %.preheader ], [ 0, %.lr.ph161 ]
  call void @llvm.stackrestore.p0(ptr %22)
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %7) #7
  ret i32 %.0
}

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

declare i32 @liquid_error_fl(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) local_unnamed_addr #5

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

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

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

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


; Effective O3 passes: AggressiveInstCombinePass,BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass