; LLVM IR from QiaoLiuHit/LSOTB-TIR :: vlfeat-0.9.19/vl (covdet)

; 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._VlFrameOrientedEllipse = type { float, float, float, float, float, float }
%struct._VlCovDet = type { ptr, ptr, i32, double, double, double, i64, i64, double, i64, ptr, i64, i64, ptr, i64, i32, [4 x %struct._VlCovDetFeatureOrientation], [4 x %struct._VlCovDetFeatureLaplacianScale], i32, [1681 x float], [1681 x float], [1681 x float], [1681 x float], [1089 x float], [10890 x float], [5 x i64] }
%struct._VlCovDetFeatureOrientation = type { double, double }
%struct._VlCovDetFeatureLaplacianScale = type { double, double }

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

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

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

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

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

declare void @vl_imsmooth_f(ptr noundef, i64 noundef, ptr noundef, i64 noundef, i64 noundef, i64 noundef, double noundef, double noundef) #3

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @vl_covdet_extract_patch_helper(ptr noundef, ptr noundef, ptr noundef, ptr noundef, i64 noundef, double noundef, double noundef, ptr noundef, ptr noundef, double noundef, double noundef) #5

declare void @vl_svd2(ptr noundef, ptr noundef, ptr noundef, ptr noundef) #3

; Function Attrs: nounwind uwtable
define dso_local i32 @vl_covdet_extract_affine_shape_for_frame(ptr noundef %0, ptr noundef %1, ptr noundef byval(%struct._VlFrameOrientedEllipse) align 8 %2) #5 {
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca i64, align 8
  %8 = alloca [4 x double], align 16
  %9 = alloca [2 x double], align 16
  %10 = alloca [4 x double], align 16
  %11 = alloca [4 x double], align 16
  %12 = alloca [4 x double], align 16
  %13 = alloca [4 x double], align 16
  %14 = alloca [4 x double], align 16
  %15 = alloca [4 x double], align 16
  %16 = alloca [4 x double], align 16
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca double, align 8
  %20 = alloca double, align 8
  %21 = alloca double, align 8
  %22 = alloca double, align 8
  %23 = alloca i64, align 8
  %24 = alloca i64, align 8
  %25 = alloca double, align 8
  %26 = alloca double, align 8
  %27 = alloca double, align 8
  %28 = alloca double, align 8
  %29 = alloca i64, align 8
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca double, align 8
  %33 = alloca double, align 8
  %34 = alloca double, align 8
  %35 = alloca double, align 8
  %36 = alloca double, align 8
  %37 = alloca [4 x double], align 16
  %38 = alloca double, align 8
  %39 = alloca double, align 8
  %40 = alloca [4 x double], align 16
  %41 = alloca [2 x double], align 16
  %42 = alloca [2 x double], align 16
  %43 = alloca double, align 8
  %44 = alloca double, align 8
  %45 = alloca double, align 8
  %46 = alloca double, align 8
  %47 = alloca double, align 8
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  store i64 0, ptr %7, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 32, ptr %8) #6
  %48 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 2
  %49 = load float, ptr %48, align 8, !tbaa !11
  %50 = fpext float %49 to double
  store double %50, ptr %8, align 8, !tbaa !14
  %51 = getelementptr inbounds double, ptr %8, i64 1
  %52 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 4
  %53 = load float, ptr %52, align 8, !tbaa !16
  %54 = fpext float %53 to double
  store double %54, ptr %51, align 8, !tbaa !14
  %55 = getelementptr inbounds double, ptr %8, i64 2
  %56 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 3
  %57 = load float, ptr %56, align 4, !tbaa !17
  %58 = fpext float %57 to double
  store double %58, ptr %55, align 8, !tbaa !14
  %59 = getelementptr inbounds double, ptr %8, i64 3
  %60 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 5
  %61 = load float, ptr %60, align 4, !tbaa !18
  %62 = fpext float %61 to double
  store double %62, ptr %59, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 16, ptr %9) #6
  %63 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 0
  %64 = load float, ptr %63, align 8, !tbaa !19
  %65 = fpext float %64 to double
  store double %65, ptr %9, align 8, !tbaa !14
  %66 = getelementptr inbounds double, ptr %9, i64 1
  %67 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %2, i32 0, i32 1
  %68 = load float, ptr %67, align 4, !tbaa !20
  %69 = fpext float %68 to double
  store double %69, ptr %66, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 32, ptr %10) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %12) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %13) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %14) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %16) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  store double 1.000000e+00, ptr %19, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  store i64 20, ptr %23, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  store i64 41, ptr %24, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  store double 9.000000e+00, ptr %25, align 8, !tbaa !14
  %70 = load ptr, ptr %6, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %70, ptr align 8 %2, i64 24, i1 false), !tbaa.struct !21
  br label %71

71:                                               ; preds = %430, %3
  br label %72

72:                                               ; preds = %71
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  store double 0.000000e+00, ptr %26, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  store double 0.000000e+00, ptr %27, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  store double 0.000000e+00, ptr %28, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %73 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %74 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 0
  %75 = getelementptr inbounds [4 x double], ptr %11, i64 0, i64 0
  %76 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  call void @vl_svd2(ptr noundef %73, ptr noundef %74, ptr noundef %75, ptr noundef %76)
  %77 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %78 = load double, ptr %77, align 16, !tbaa !14
  %79 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %80 = load double, ptr %79, align 8, !tbaa !14
  %81 = fdiv double %78, %80
  %82 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %83 = load double, ptr %82, align 8, !tbaa !14
  %84 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %85 = load double, ptr %84, align 16, !tbaa !14
  %86 = fdiv double %83, %85
  %87 = fcmp ogt double %81, %86
  br i1 %87, label %88, label %94

88:                                               ; preds = %72
  %89 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %90 = load double, ptr %89, align 16, !tbaa !14
  %91 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %92 = load double, ptr %91, align 8, !tbaa !14
  %93 = fdiv double %90, %92
  br label %100

94:                                               ; preds = %72
  %95 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %96 = load double, ptr %95, align 8, !tbaa !14
  %97 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %98 = load double, ptr %97, align 16, !tbaa !14
  %99 = fdiv double %96, %98
  br label %100

100:                                              ; preds = %94, %88
  %101 = phi double [ %93, %88 ], [ %99, %94 ]
  store double %101, ptr %21, align 8, !tbaa !14
  %102 = load double, ptr %21, align 8, !tbaa !14
  %103 = fcmp ogt double %102, 5.000000e+00
  br i1 %103, label %104, label %105

104:                                              ; preds = %100
  store i32 3, ptr %31, align 4
  br label %428

105:                                              ; preds = %100
  %106 = load i64, ptr %7, align 8, !tbaa !9
  %107 = icmp eq i64 %106, 0
  br i1 %107, label %108, label %122

108:                                              ; preds = %105
  %109 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %110 = load double, ptr %109, align 16, !tbaa !14
  %111 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %112 = load double, ptr %111, align 8, !tbaa !14
  %113 = fcmp olt double %110, %112
  br i1 %113, label %114, label %117

114:                                              ; preds = %108
  %115 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %116 = load double, ptr %115, align 16, !tbaa !14
  br label %120

117:                                              ; preds = %108
  %118 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %119 = load double, ptr %118, align 8, !tbaa !14
  br label %120

120:                                              ; preds = %117, %114
  %121 = phi double [ %116, %114 ], [ %119, %117 ]
  store double %121, ptr %22, align 8, !tbaa !14
  store double 1.000000e+00, ptr %20, align 8, !tbaa !14
  br label %138

122:                                              ; preds = %105
  %123 = load double, ptr %22, align 8, !tbaa !14
  %124 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %125 = load double, ptr %124, align 16, !tbaa !14
  %126 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %127 = load double, ptr %126, align 8, !tbaa !14
  %128 = fcmp olt double %125, %127
  br i1 %128, label %129, label %132

129:                                              ; preds = %122
  %130 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %131 = load double, ptr %130, align 16, !tbaa !14
  br label %135

132:                                              ; preds = %122
  %133 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %134 = load double, ptr %133, align 8, !tbaa !14
  br label %135

135:                                              ; preds = %132, %129
  %136 = phi double [ %131, %129 ], [ %134, %132 ]
  %137 = fdiv double %123, %136
  store double %137, ptr %20, align 8, !tbaa !14
  br label %138

138:                                              ; preds = %135, %120
  %139 = load double, ptr %20, align 8, !tbaa !14
  %140 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %141 = load double, ptr %140, align 16, !tbaa !14
  %142 = fmul double %141, %139
  store double %142, ptr %140, align 16, !tbaa !14
  %143 = load double, ptr %20, align 8, !tbaa !14
  %144 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %145 = load double, ptr %144, align 8, !tbaa !14
  %146 = fmul double %145, %143
  store double %146, ptr %144, align 8, !tbaa !14
  %147 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 0
  %148 = load double, ptr %147, align 16, !tbaa !14
  %149 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %150 = load double, ptr %149, align 16, !tbaa !14
  %151 = fmul double %148, %150
  %152 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  store double %151, ptr %152, align 16, !tbaa !14
  %153 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %154 = load double, ptr %153, align 8, !tbaa !14
  %155 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %156 = load double, ptr %155, align 16, !tbaa !14
  %157 = fmul double %154, %156
  %158 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 1
  store double %157, ptr %158, align 8, !tbaa !14
  %159 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %160 = load double, ptr %159, align 16, !tbaa !14
  %161 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %162 = load double, ptr %161, align 8, !tbaa !14
  %163 = fmul double %160, %162
  %164 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 2
  store double %163, ptr %164, align 16, !tbaa !14
  %165 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %166 = load double, ptr %165, align 8, !tbaa !14
  %167 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %168 = load double, ptr %167, align 8, !tbaa !14
  %169 = fmul double %166, %168
  %170 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 3
  store double %169, ptr %170, align 8, !tbaa !14
  %171 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  %172 = load double, ptr %171, align 16, !tbaa !14
  %173 = fptrunc double %172 to float
  %174 = load ptr, ptr %6, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %174, i32 0, i32 2
  store float %173, ptr %175, align 4, !tbaa !11
  %176 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 1
  %177 = load double, ptr %176, align 8, !tbaa !14
  %178 = fptrunc double %177 to float
  %179 = load ptr, ptr %6, align 8, !tbaa !5
  %180 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %179, i32 0, i32 4
  store float %178, ptr %180, align 4, !tbaa !16
  %181 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 2
  %182 = load double, ptr %181, align 16, !tbaa !14
  %183 = fptrunc double %182 to float
  %184 = load ptr, ptr %6, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %184, i32 0, i32 3
  store float %183, ptr %185, align 4, !tbaa !17
  %186 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 3
  %187 = load double, ptr %186, align 8, !tbaa !14
  %188 = fptrunc double %187 to float
  %189 = load ptr, ptr %6, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %189, i32 0, i32 5
  store float %188, ptr %190, align 4, !tbaa !18
  %191 = load i64, ptr %7, align 8, !tbaa !9
  %192 = add nsw i64 %191, 1
  store i64 %192, ptr %7, align 8, !tbaa !9
  %193 = icmp sge i64 %192, 15
  br i1 %193, label %194, label %195

194:                                              ; preds = %138
  store i32 3, ptr %31, align 4
  br label %428

195:                                              ; preds = %138
  %196 = load ptr, ptr %5, align 8, !tbaa !5
  %197 = load ptr, ptr %5, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct._VlCovDet, ptr %197, i32 0, i32 19
  %199 = getelementptr inbounds [1681 x float], ptr %198, i64 0, i64 0
  %200 = load double, ptr %19, align 8, !tbaa !14
  %201 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  %202 = getelementptr inbounds [2 x double], ptr %9, i64 0, i64 0
  %203 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 0
  %204 = load double, ptr %203, align 16, !tbaa !14
  %205 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %206 = load double, ptr %205, align 8, !tbaa !14
  %207 = call i32 @vl_covdet_extract_patch_helper(ptr noundef %196, ptr noundef %17, ptr noundef %18, ptr noundef %199, i64 noundef 20, double noundef 9.000000e+00, double noundef %200, ptr noundef %201, ptr noundef %202, double noundef %204, double noundef %206)
  store i32 %207, ptr %30, align 4, !tbaa !23
  %208 = load i32, ptr %30, align 4, !tbaa !23
  %209 = icmp ne i32 %208, 0
  br i1 %209, label %210, label %212

210:                                              ; preds = %195
  %211 = load i32, ptr %30, align 4, !tbaa !23
  store i32 %211, ptr %4, align 4
  store i32 1, ptr %31, align 4
  br label %428

212:                                              ; preds = %195
  %213 = load ptr, ptr %5, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct._VlCovDet, ptr %213, i32 0, i32 18
  %215 = load i32, ptr %214, align 8, !tbaa !25
  %216 = icmp ne i32 %215, 0
  br i1 %216, label %217, label %270

217:                                              ; preds = %212
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  %218 = load double, ptr %19, align 8, !tbaa !14
  %219 = load double, ptr %19, align 8, !tbaa !14
  %220 = load double, ptr %17, align 8, !tbaa !14
  %221 = load double, ptr %17, align 8, !tbaa !14
  %222 = fmul double %220, %221
  %223 = fneg double %222
  %224 = call double @llvm.fmuladd.f64(double %218, double %219, double %223)
  %225 = fcmp ogt double %224, 0.000000e+00
  br i1 %225, label %226, label %234

226:                                              ; preds = %217
  %227 = load double, ptr %19, align 8, !tbaa !14
  %228 = load double, ptr %19, align 8, !tbaa !14
  %229 = load double, ptr %17, align 8, !tbaa !14
  %230 = load double, ptr %17, align 8, !tbaa !14
  %231 = fmul double %229, %230
  %232 = fneg double %231
  %233 = call double @llvm.fmuladd.f64(double %227, double %228, double %232)
  br label %235

234:                                              ; preds = %217
  br label %235

235:                                              ; preds = %234, %226
  %236 = phi double [ %233, %226 ], [ 0.000000e+00, %234 ]
  %237 = call double @sqrt(double noundef %236) #6
  store double %237, ptr %32, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %238 = load double, ptr %19, align 8, !tbaa !14
  %239 = load double, ptr %19, align 8, !tbaa !14
  %240 = load double, ptr %18, align 8, !tbaa !14
  %241 = load double, ptr %18, align 8, !tbaa !14
  %242 = fmul double %240, %241
  %243 = fneg double %242
  %244 = call double @llvm.fmuladd.f64(double %238, double %239, double %243)
  %245 = fcmp ogt double %244, 0.000000e+00
  br i1 %245, label %246, label %254

246:                                              ; preds = %235
  %247 = load double, ptr %19, align 8, !tbaa !14
  %248 = load double, ptr %19, align 8, !tbaa !14
  %249 = load double, ptr %18, align 8, !tbaa !14
  %250 = load double, ptr %18, align 8, !tbaa !14
  %251 = fmul double %249, %250
  %252 = fneg double %251
  %253 = call double @llvm.fmuladd.f64(double %247, double %248, double %252)
  br label %255

254:                                              ; preds = %235
  br label %255

255:                                              ; preds = %254, %246
  %256 = phi double [ %253, %246 ], [ 0.000000e+00, %254 ]
  %257 = call double @sqrt(double noundef %256) #6
  store double %257, ptr %33, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  store double 4.500000e-01, ptr %34, align 8, !tbaa !14
  %258 = load ptr, ptr %5, align 8, !tbaa !5
  %259 = getelementptr inbounds %struct._VlCovDet, ptr %258, i32 0, i32 19
  %260 = getelementptr inbounds [1681 x float], ptr %259, i64 0, i64 0
  %261 = load ptr, ptr %5, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct._VlCovDet, ptr %261, i32 0, i32 19
  %263 = getelementptr inbounds [1681 x float], ptr %262, i64 0, i64 0
  %264 = load double, ptr %32, align 8, !tbaa !14
  %265 = load double, ptr %34, align 8, !tbaa !14
  %266 = fdiv double %264, %265
  %267 = load double, ptr %33, align 8, !tbaa !14
  %268 = load double, ptr %34, align 8, !tbaa !14
  %269 = fdiv double %267, %268
  call void @vl_imsmooth_f(ptr noundef %260, i64 noundef 41, ptr noundef %263, i64 noundef 41, i64 noundef 41, i64 noundef 41, double noundef %266, double noundef %269)
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  br label %270

270:                                              ; preds = %255, %212
  %271 = load ptr, ptr %5, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct._VlCovDet, ptr %271, i32 0, i32 20
  %273 = getelementptr inbounds [1681 x float], ptr %272, i64 0, i64 0
  %274 = load ptr, ptr %5, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct._VlCovDet, ptr %274, i32 0, i32 21
  %276 = getelementptr inbounds [1681 x float], ptr %275, i64 0, i64 0
  %277 = load ptr, ptr %5, align 8, !tbaa !5
  %278 = getelementptr inbounds %struct._VlCovDet, ptr %277, i32 0, i32 19
  %279 = getelementptr inbounds [1681 x float], ptr %278, i64 0, i64 0
  call void @vl_imgradient_f(ptr noundef %273, ptr noundef %276, i64 noundef 1, i64 noundef 41, ptr noundef %279, i64 noundef 41, i64 noundef 41, i64 noundef 41)
  store i64 0, ptr %29, align 8, !tbaa !9
  br label %280

280:                                              ; preds = %329, %270
  %281 = load i64, ptr %29, align 8, !tbaa !9
  %282 = icmp slt i64 %281, 1681
  br i1 %282, label %283, label %332

283:                                              ; preds = %280
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  %284 = load ptr, ptr %5, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct._VlCovDet, ptr %284, i32 0, i32 20
  %286 = load i64, ptr %29, align 8, !tbaa !9
  %287 = getelementptr inbounds [1681 x float], ptr %285, i64 0, i64 %286
  %288 = load float, ptr %287, align 4, !tbaa !22
  %289 = fpext float %288 to double
  store double %289, ptr %35, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  %290 = load ptr, ptr %5, align 8, !tbaa !5
  %291 = getelementptr inbounds %struct._VlCovDet, ptr %290, i32 0, i32 21
  %292 = load i64, ptr %29, align 8, !tbaa !9
  %293 = getelementptr inbounds [1681 x float], ptr %291, i64 0, i64 %292
  %294 = load float, ptr %293, align 4, !tbaa !22
  %295 = fpext float %294 to double
  store double %295, ptr %36, align 8, !tbaa !14
  %296 = load double, ptr %35, align 8, !tbaa !14
  %297 = load double, ptr %35, align 8, !tbaa !14
  %298 = fmul double %296, %297
  %299 = load ptr, ptr %5, align 8, !tbaa !5
  %300 = getelementptr inbounds %struct._VlCovDet, ptr %299, i32 0, i32 22
  %301 = load i64, ptr %29, align 8, !tbaa !9
  %302 = getelementptr inbounds [1681 x float], ptr %300, i64 0, i64 %301
  %303 = load float, ptr %302, align 4, !tbaa !22
  %304 = fpext float %303 to double
  %305 = load double, ptr %26, align 8, !tbaa !14
  %306 = call double @llvm.fmuladd.f64(double %298, double %304, double %305)
  store double %306, ptr %26, align 8, !tbaa !14
  %307 = load double, ptr %36, align 8, !tbaa !14
  %308 = load double, ptr %36, align 8, !tbaa !14
  %309 = fmul double %307, %308
  %310 = load ptr, ptr %5, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct._VlCovDet, ptr %310, i32 0, i32 22
  %312 = load i64, ptr %29, align 8, !tbaa !9
  %313 = getelementptr inbounds [1681 x float], ptr %311, i64 0, i64 %312
  %314 = load float, ptr %313, align 4, !tbaa !22
  %315 = fpext float %314 to double
  %316 = load double, ptr %28, align 8, !tbaa !14
  %317 = call double @llvm.fmuladd.f64(double %309, double %315, double %316)
  store double %317, ptr %28, align 8, !tbaa !14
  %318 = load double, ptr %35, align 8, !tbaa !14
  %319 = load double, ptr %36, align 8, !tbaa !14
  %320 = fmul double %318, %319
  %321 = load ptr, ptr %5, align 8, !tbaa !5
  %322 = getelementptr inbounds %struct._VlCovDet, ptr %321, i32 0, i32 22
  %323 = load i64, ptr %29, align 8, !tbaa !9
  %324 = getelementptr inbounds [1681 x float], ptr %322, i64 0, i64 %323
  %325 = load float, ptr %324, align 4, !tbaa !22
  %326 = fpext float %325 to double
  %327 = load double, ptr %27, align 8, !tbaa !14
  %328 = call double @llvm.fmuladd.f64(double %320, double %326, double %327)
  store double %328, ptr %27, align 8, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  br label %329

329:                                              ; preds = %283
  %330 = load i64, ptr %29, align 8, !tbaa !9
  %331 = add nsw i64 %330, 1
  store i64 %331, ptr %29, align 8, !tbaa !9
  br label %280, !llvm.loop !27

332:                                              ; preds = %280
  %333 = load double, ptr %26, align 8, !tbaa !14
  %334 = getelementptr inbounds [4 x double], ptr %13, i64 0, i64 0
  store double %333, ptr %334, align 16, !tbaa !14
  %335 = load double, ptr %27, align 8, !tbaa !14
  %336 = getelementptr inbounds [4 x double], ptr %13, i64 0, i64 1
  store double %335, ptr %336, align 8, !tbaa !14
  %337 = load double, ptr %27, align 8, !tbaa !14
  %338 = getelementptr inbounds [4 x double], ptr %13, i64 0, i64 2
  store double %337, ptr %338, align 16, !tbaa !14
  %339 = load double, ptr %28, align 8, !tbaa !14
  %340 = getelementptr inbounds [4 x double], ptr %13, i64 0, i64 3
  store double %339, ptr %340, align 8, !tbaa !14
  %341 = load double, ptr %26, align 8, !tbaa !14
  %342 = fcmp oeq double %341, 0.000000e+00
  br i1 %342, label %346, label %343

343:                                              ; preds = %332
  %344 = load double, ptr %28, align 8, !tbaa !14
  %345 = fcmp oeq double %344, 0.000000e+00
  br i1 %345, label %346, label %348

346:                                              ; preds = %343, %332
  %347 = load ptr, ptr %6, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %347, ptr align 8 %2, i64 24, i1 false), !tbaa.struct !21
  store i32 3, ptr %31, align 4
  br label %428

348:                                              ; preds = %343
  %349 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 0
  %350 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 0
  %351 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 0
  %352 = getelementptr inbounds [4 x double], ptr %13, i64 0, i64 0
  call void @vl_svd2(ptr noundef %349, ptr noundef %350, ptr noundef %351, ptr noundef %352)
  %353 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 3
  %354 = load double, ptr %353, align 8, !tbaa !14
  %355 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 0
  %356 = load double, ptr %355, align 16, !tbaa !14
  %357 = fdiv double %354, %356
  %358 = fcmp olt double %357, 1.001000e+00
  br i1 %358, label %359, label %367

359:                                              ; preds = %348
  %360 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 0
  %361 = load double, ptr %360, align 16, !tbaa !14
  %362 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 3
  %363 = load double, ptr %362, align 8, !tbaa !14
  %364 = fdiv double %361, %363
  %365 = fcmp olt double %364, 1.001000e+00
  br i1 %365, label %366, label %367

366:                                              ; preds = %359
  store i32 3, ptr %31, align 4
  br label %428

367:                                              ; preds = %359, %348
  call void @llvm.lifetime.start.p0(i64 32, ptr %37) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %368 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 0
  %369 = load double, ptr %368, align 16, !tbaa !14
  %370 = call double @sqrt(double noundef %369) #6
  store double %370, ptr %38, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  %371 = getelementptr inbounds [4 x double], ptr %16, i64 0, i64 3
  %372 = load double, ptr %371, align 8, !tbaa !14
  %373 = call double @sqrt(double noundef %372) #6
  store double %373, ptr %39, align 8, !tbaa !14
  %374 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  %375 = load double, ptr %374, align 16, !tbaa !14
  %376 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 0
  %377 = load double, ptr %376, align 16, !tbaa !14
  %378 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 2
  %379 = load double, ptr %378, align 16, !tbaa !14
  %380 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %381 = load double, ptr %380, align 8, !tbaa !14
  %382 = fmul double %379, %381
  %383 = call double @llvm.fmuladd.f64(double %375, double %377, double %382)
  %384 = load double, ptr %38, align 8, !tbaa !14
  %385 = fdiv double %383, %384
  %386 = getelementptr inbounds [4 x double], ptr %37, i64 0, i64 0
  store double %385, ptr %386, align 16, !tbaa !14
  %387 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 1
  %388 = load double, ptr %387, align 8, !tbaa !14
  %389 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 0
  %390 = load double, ptr %389, align 16, !tbaa !14
  %391 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 3
  %392 = load double, ptr %391, align 8, !tbaa !14
  %393 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %394 = load double, ptr %393, align 8, !tbaa !14
  %395 = fmul double %392, %394
  %396 = call double @llvm.fmuladd.f64(double %388, double %390, double %395)
  %397 = load double, ptr %38, align 8, !tbaa !14
  %398 = fdiv double %396, %397
  %399 = getelementptr inbounds [4 x double], ptr %37, i64 0, i64 1
  store double %398, ptr %399, align 8, !tbaa !14
  %400 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  %401 = load double, ptr %400, align 16, !tbaa !14
  %402 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %403 = load double, ptr %402, align 16, !tbaa !14
  %404 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 2
  %405 = load double, ptr %404, align 16, !tbaa !14
  %406 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %407 = load double, ptr %406, align 8, !tbaa !14
  %408 = fmul double %405, %407
  %409 = call double @llvm.fmuladd.f64(double %401, double %403, double %408)
  %410 = load double, ptr %39, align 8, !tbaa !14
  %411 = fdiv double %409, %410
  %412 = getelementptr inbounds [4 x double], ptr %37, i64 0, i64 2
  store double %411, ptr %412, align 16, !tbaa !14
  %413 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 1
  %414 = load double, ptr %413, align 8, !tbaa !14
  %415 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %416 = load double, ptr %415, align 16, !tbaa !14
  %417 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 3
  %418 = load double, ptr %417, align 8, !tbaa !14
  %419 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %420 = load double, ptr %419, align 8, !tbaa !14
  %421 = fmul double %418, %420
  %422 = call double @llvm.fmuladd.f64(double %414, double %416, double %421)
  %423 = load double, ptr %39, align 8, !tbaa !14
  %424 = fdiv double %422, %423
  %425 = getelementptr inbounds [4 x double], ptr %37, i64 0, i64 3
  store double %424, ptr %425, align 8, !tbaa !14
  %426 = getelementptr inbounds [4 x double], ptr %8, i64 0, i64 0
  %427 = getelementptr inbounds [4 x double], ptr %37, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %426, ptr align 16 %427, i64 32, i1 false)
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %37) #6
  store i32 0, ptr %31, align 4
  br label %428

428:                                              ; preds = %367, %366, %346, %210, %194, %104
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  %429 = load i32, ptr %31, align 4
  switch i32 %429, label %529 [
    i32 0, label %430
    i32 3, label %431
  ]

430:                                              ; preds = %428
  br label %71

431:                                              ; preds = %428
  call void @llvm.lifetime.start.p0(i64 32, ptr %40) #6
  %432 = load ptr, ptr %6, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %432, i32 0, i32 2
  %434 = load float, ptr %433, align 4, !tbaa !11
  %435 = fpext float %434 to double
  store double %435, ptr %40, align 8, !tbaa !14
  %436 = getelementptr inbounds double, ptr %40, i64 1
  %437 = load ptr, ptr %6, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %437, i32 0, i32 4
  %439 = load float, ptr %438, align 4, !tbaa !16
  %440 = fpext float %439 to double
  store double %440, ptr %436, align 8, !tbaa !14
  %441 = getelementptr inbounds double, ptr %40, i64 2
  %442 = load ptr, ptr %6, align 8, !tbaa !5
  %443 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %442, i32 0, i32 3
  %444 = load float, ptr %443, align 4, !tbaa !17
  %445 = fpext float %444 to double
  store double %445, ptr %441, align 8, !tbaa !14
  %446 = getelementptr inbounds double, ptr %40, i64 3
  %447 = load ptr, ptr %6, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %447, i32 0, i32 5
  %449 = load float, ptr %448, align 4, !tbaa !18
  %450 = fpext float %449 to double
  store double %450, ptr %446, align 8, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 16, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %42) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  %451 = load ptr, ptr %5, align 8, !tbaa !5
  %452 = getelementptr inbounds %struct._VlCovDet, ptr %451, i32 0, i32 15
  %453 = load i32, ptr %452, align 8, !tbaa !29
  %454 = icmp ne i32 %453, 0
  br i1 %454, label %455, label %458

455:                                              ; preds = %431
  %456 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 0
  store double 1.000000e+00, ptr %456, align 16, !tbaa !14
  %457 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 1
  store double 0.000000e+00, ptr %457, align 8, !tbaa !14
  br label %461

458:                                              ; preds = %431
  %459 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 0
  store double 0.000000e+00, ptr %459, align 16, !tbaa !14
  %460 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 1
  store double 1.000000e+00, ptr %460, align 8, !tbaa !14
  br label %461

461:                                              ; preds = %458, %455
  %462 = getelementptr inbounds [2 x double], ptr %42, i64 0, i64 0
  %463 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 0
  %464 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 0
  %465 = call i32 @vl_solve_linear_system_2(ptr noundef %462, ptr noundef %463, ptr noundef %464)
  %466 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 1
  %467 = load double, ptr %466, align 8, !tbaa !14
  %468 = getelementptr inbounds [2 x double], ptr %41, i64 0, i64 0
  %469 = load double, ptr %468, align 16, !tbaa !14
  %470 = call double @atan2(double noundef %467, double noundef %469) #6
  store double %470, ptr %43, align 8, !tbaa !14
  %471 = getelementptr inbounds [2 x double], ptr %42, i64 0, i64 1
  %472 = load double, ptr %471, align 8, !tbaa !14
  %473 = getelementptr inbounds [2 x double], ptr %42, i64 0, i64 0
  %474 = load double, ptr %473, align 16, !tbaa !14
  %475 = call double @atan2(double noundef %472, double noundef %474) #6
  store double %475, ptr %44, align 8, !tbaa !14
  %476 = load double, ptr %44, align 8, !tbaa !14
  %477 = load double, ptr %43, align 8, !tbaa !14
  %478 = fsub double %476, %477
  store double %478, ptr %45, align 8, !tbaa !14
  %479 = load double, ptr %45, align 8, !tbaa !14
  %480 = call double @cos(double noundef %479) #6
  store double %480, ptr %46, align 8, !tbaa !14
  %481 = load double, ptr %45, align 8, !tbaa !14
  %482 = call double @sin(double noundef %481) #6
  store double %482, ptr %47, align 8, !tbaa !14
  %483 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 0
  %484 = load double, ptr %483, align 16, !tbaa !14
  %485 = load double, ptr %46, align 8, !tbaa !14
  %486 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 2
  %487 = load double, ptr %486, align 16, !tbaa !14
  %488 = load double, ptr %47, align 8, !tbaa !14
  %489 = fmul double %487, %488
  %490 = call double @llvm.fmuladd.f64(double %484, double %485, double %489)
  %491 = fptrunc double %490 to float
  %492 = load ptr, ptr %6, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %492, i32 0, i32 2
  store float %491, ptr %493, align 4, !tbaa !11
  %494 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 1
  %495 = load double, ptr %494, align 8, !tbaa !14
  %496 = load double, ptr %46, align 8, !tbaa !14
  %497 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 3
  %498 = load double, ptr %497, align 8, !tbaa !14
  %499 = load double, ptr %47, align 8, !tbaa !14
  %500 = fmul double %498, %499
  %501 = call double @llvm.fmuladd.f64(double %495, double %496, double %500)
  %502 = fptrunc double %501 to float
  %503 = load ptr, ptr %6, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %503, i32 0, i32 4
  store float %502, ptr %504, align 4, !tbaa !16
  %505 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 0
  %506 = load double, ptr %505, align 16, !tbaa !14
  %507 = fneg double %506
  %508 = load double, ptr %47, align 8, !tbaa !14
  %509 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 2
  %510 = load double, ptr %509, align 16, !tbaa !14
  %511 = load double, ptr %46, align 8, !tbaa !14
  %512 = fmul double %510, %511
  %513 = call double @llvm.fmuladd.f64(double %507, double %508, double %512)
  %514 = fptrunc double %513 to float
  %515 = load ptr, ptr %6, align 8, !tbaa !5
  %516 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %515, i32 0, i32 3
  store float %514, ptr %516, align 4, !tbaa !17
  %517 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 1
  %518 = load double, ptr %517, align 8, !tbaa !14
  %519 = fneg double %518
  %520 = load double, ptr %47, align 8, !tbaa !14
  %521 = getelementptr inbounds [4 x double], ptr %40, i64 0, i64 3
  %522 = load double, ptr %521, align 8, !tbaa !14
  %523 = load double, ptr %46, align 8, !tbaa !14
  %524 = fmul double %522, %523
  %525 = call double @llvm.fmuladd.f64(double %519, double %520, double %524)
  %526 = fptrunc double %525 to float
  %527 = load ptr, ptr %6, align 8, !tbaa !5
  %528 = getelementptr inbounds %struct._VlFrameOrientedEllipse, ptr %527, i32 0, i32 5
  store float %526, ptr %528, align 4, !tbaa !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %40) #6
  store i32 0, ptr %4, align 4
  store i32 1, ptr %31, align 4
  br label %529

529:                                              ; preds = %461, %428
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %15) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  %530 = load i32, ptr %4, align 4
  ret i32 %530
}

declare void @vl_imgradient_f(ptr noundef, ptr noundef, i64 noundef, i64 noundef, ptr noundef, i64 noundef, i64 noundef, i64 noundef) #3

; Function Attrs: nounwind
declare double @atan2(double noundef, double noundef) #2

; Function Attrs: nounwind
declare double @cos(double noundef) #2

; Function Attrs: nounwind
declare double @sin(double noundef) #2

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { 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 #3 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { 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 #6 = { 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, !10, i64 0}
!10 = !{!"long long", !7, i64 0}
!11 = !{!12, !13, i64 8}
!12 = !{!"_VlFrameOrientedEllipse", !13, i64 0, !13, i64 4, !13, i64 8, !13, i64 12, !13, i64 16, !13, i64 20}
!13 = !{!"float", !7, i64 0}
!14 = !{!15, !15, i64 0}
!15 = !{!"double", !7, i64 0}
!16 = !{!12, !13, i64 16}
!17 = !{!12, !13, i64 12}
!18 = !{!12, !13, i64 20}
!19 = !{!12, !13, i64 0}
!20 = !{!12, !13, i64 4}
!21 = !{i64 0, i64 4, !22, i64 4, i64 4, !22, i64 8, i64 4, !22, i64 12, i64 4, !22, i64 16, i64 4, !22, i64 20, i64 4, !22}
!22 = !{!13, !13, i64 0}
!23 = !{!24, !24, i64 0}
!24 = !{!"int", !7, i64 0}
!25 = !{!26, !24, i64 256}
!26 = !{!"_VlCovDet", !6, i64 0, !6, i64 8, !24, i64 16, !15, i64 24, !15, i64 32, !15, i64 40, !10, i64 48, !10, i64 56, !15, i64 64, !10, i64 72, !6, i64 80, !10, i64 88, !10, i64 96, !6, i64 104, !10, i64 112, !24, i64 120, !7, i64 128, !7, i64 192, !24, i64 256, !7, i64 260, !7, i64 6984, !7, i64 13708, !7, i64 20432, !7, i64 27156, !7, i64 31512, !7, i64 75072}
!27 = distinct !{!27, !28}
!28 = !{!"llvm.loop.mustprogress"}
!29 = !{!26, !24, i64 120}


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

%struct._VlFrameOrientedEllipse = type { float, float, float, float, float, float }

; 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 willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

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

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @sqrt(double noundef) local_unnamed_addr #2

declare i32 @vl_solve_linear_system_2(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #3

declare void @vl_imsmooth_f(ptr noundef, i64 noundef, ptr noundef, i64 noundef, i64 noundef, i64 noundef, double noundef, double noundef) local_unnamed_addr #3

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @vl_covdet_extract_patch_helper(ptr noundef, ptr noundef, ptr noundef, ptr noundef, i64 noundef, double noundef, double noundef, ptr noundef, ptr noundef, double noundef, double noundef) local_unnamed_addr #5

declare void @vl_svd2(ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #3

; Function Attrs: nounwind uwtable
define dso_local i32 @vl_covdet_extract_affine_shape_for_frame(ptr noundef %0, ptr nocapture noundef %1, ptr nocapture noundef readonly byval(%struct._VlFrameOrientedEllipse) align 8 %2) local_unnamed_addr #5 {
  %4 = alloca [4 x double], align 16
  %5 = alloca [2 x double], align 16
  %6 = alloca [4 x double], align 16
  %7 = alloca [4 x double], align 16
  %8 = alloca [4 x double], align 16
  %9 = alloca [4 x double], align 16
  %10 = alloca [4 x double], align 16
  %11 = alloca [4 x double], align 16
  %12 = alloca [4 x double], align 16
  %13 = alloca double, align 8
  %14 = alloca double, align 8
  %15 = alloca [4 x double], align 16
  %16 = alloca [2 x double], align 16
  %17 = alloca [2 x double], align 16
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %4) #7
  %18 = getelementptr inbounds i8, ptr %2, i64 8
  %19 = load <4 x float>, ptr %18, align 8
  %20 = shufflevector <4 x float> %19, <4 x float> poison, <2 x i32> <i32 0, i32 poison>
  %21 = getelementptr inbounds i8, ptr %2, i64 16
  %22 = load float, ptr %21, align 8, !tbaa !5
  %23 = insertelement <2 x float> %20, float %22, i64 1
  %24 = fpext <2 x float> %23 to <2 x double>
  store <2 x double> %24, ptr %4, align 16, !tbaa !10
  %25 = getelementptr inbounds i8, ptr %4, i64 16
  %26 = load <4 x float>, ptr %2, align 8
  %27 = shufflevector <4 x float> %26, <4 x float> poison, <2 x i32> <i32 3, i32 poison>
  %28 = getelementptr inbounds i8, ptr %2, i64 20
  %29 = load float, ptr %28, align 4, !tbaa !12
  %30 = insertelement <2 x float> %27, float %29, i64 1
  %31 = fpext <2 x float> %30 to <2 x double>
  store <2 x double> %31, ptr %25, align 16, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %5) #7
  %32 = load <2 x float>, ptr %2, align 8, !tbaa !13
  %33 = fpext <2 x float> %32 to <2 x double>
  store <2 x double> %33, ptr %5, align 16, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %6) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %7) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %8) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %9) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %10) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %11) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %12) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %13) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %14) #7
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(24) %1, ptr noundef nonnull align 8 dereferenceable(24) %2, i64 24, i1 false), !tbaa.struct !14
  call void @vl_svd2(ptr noundef nonnull %8, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef nonnull %4) #7
  %34 = load double, ptr %8, align 16
  %35 = getelementptr inbounds i8, ptr %8, i64 24
  %36 = load double, ptr %35, align 8
  %37 = insertelement <2 x double> poison, double %34, i64 0
  %38 = insertelement <2 x double> %37, double %36, i64 1
  %39 = insertelement <2 x double> poison, double %36, i64 0
  %40 = insertelement <2 x double> %39, double %34, i64 1
  %41 = fdiv <2 x double> %38, %40
  %42 = extractelement <2 x double> %41, i64 0
  %43 = extractelement <2 x double> %41, i64 1
  %44 = fcmp ogt double %42, %43
  %.126 = select i1 %44, double %42, double %43
  %45 = fcmp ogt double %.126, 5.000000e+00
  br i1 %45, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %3
  %46 = getelementptr inbounds i8, ptr %6, i64 16
  %47 = getelementptr inbounds i8, ptr %1, i64 8
  %48 = getelementptr inbounds i8, ptr %0, i64 260
  %49 = getelementptr inbounds i8, ptr %0, i64 256
  %50 = getelementptr inbounds i8, ptr %0, i64 6984
  %51 = getelementptr inbounds i8, ptr %0, i64 13708
  %52 = getelementptr inbounds i8, ptr %0, i64 20432
  %53 = getelementptr inbounds i8, ptr %9, i64 16
  %54 = getelementptr inbounds i8, ptr %9, i64 24
  %55 = getelementptr inbounds i8, ptr %12, i64 24
  %56 = getelementptr inbounds i8, ptr %10, i64 8
  %57 = getelementptr inbounds i8, ptr %10, i64 16
  %58 = getelementptr inbounds i8, ptr %10, i64 24
  br label %59

59:                                               ; preds = %.lr.ph, %136
  %60 = phi double [ %36, %.lr.ph ], [ %162, %136 ]
  %61 = phi double [ %34, %.lr.ph ], [ %161, %136 ]
  %.089128 = phi i64 [ 0, %.lr.ph ], [ %80, %136 ]
  %.092127 = phi double [ undef, %.lr.ph ], [ %.193, %136 ]
  %62 = icmp eq i64 %.089128, 0
  %63 = fcmp olt double %61, %60
  %64 = select i1 %63, double %61, double %60
  %65 = fdiv double %.092127, %64
  %.193 = select i1 %62, double %64, double %.092127
  %.091 = select i1 %62, double 1.000000e+00, double %65
  %66 = fmul double %61, %.091
  store double %66, ptr %8, align 16, !tbaa !10
  %67 = fmul double %60, %.091
  store double %67, ptr %35, align 8, !tbaa !10
  %68 = load <2 x double>, ptr %6, align 16, !tbaa !10
  %69 = insertelement <2 x double> poison, double %66, i64 0
  %70 = shufflevector <2 x double> %69, <2 x double> poison, <2 x i32> zeroinitializer
  %71 = fmul <2 x double> %70, %68
  store <2 x double> %71, ptr %4, align 16, !tbaa !10
  %72 = load <2 x double>, ptr %46, align 16, !tbaa !10
  %73 = insertelement <2 x double> poison, double %67, i64 0
  %74 = shufflevector <2 x double> %73, <2 x double> poison, <2 x i32> zeroinitializer
  %75 = fmul <2 x double> %74, %72
  store <2 x double> %75, ptr %25, align 16, !tbaa !10
  %76 = shufflevector <2 x double> %71, <2 x double> %75, <2 x i32> <i32 0, i32 2>
  %77 = shufflevector <2 x double> %71, <2 x double> %75, <2 x i32> <i32 1, i32 3>
  %78 = shufflevector <2 x double> %76, <2 x double> %77, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %79 = fptrunc <4 x double> %78 to <4 x float>
  store <4 x float> %79, ptr %47, align 4, !tbaa !13
  %80 = add nuw nsw i64 %.089128, 1
  %exitcond135 = icmp eq i64 %.089128, 14
  br i1 %exitcond135, label %.loopexit, label %81

81:                                               ; preds = %59
  %82 = call i32 @vl_covdet_extract_patch_helper(ptr noundef %0, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef nonnull %48, i64 noundef 20, double noundef 9.000000e+00, double noundef 1.000000e+00, ptr noundef nonnull %4, ptr noundef nonnull %5, double noundef %66, double noundef %67)
  %.not = icmp eq i32 %82, 0
  br i1 %.not, label %83, label %.thread115

83:                                               ; preds = %81
  %84 = load i32, ptr %49, align 8, !tbaa !15
  %.not107 = icmp eq i32 %84, 0
  br i1 %.not107, label %98, label %85

85:                                               ; preds = %83
  %86 = load double, ptr %13, align 8, !tbaa !10
  %87 = fmul double %86, %86
  %88 = fsub double 1.000000e+00, %87
  %89 = fcmp ogt double %88, 0.000000e+00
  %90 = select i1 %89, double %88, double 0.000000e+00
  %sqrt120 = call double @llvm.sqrt.f64(double %90)
  %91 = load double, ptr %14, align 8, !tbaa !10
  %92 = fmul double %91, %91
  %93 = fsub double 1.000000e+00, %92
  %94 = fcmp ogt double %93, 0.000000e+00
  %95 = select i1 %94, double %93, double 0.000000e+00
  %sqrt = call double @llvm.sqrt.f64(double %95)
  %96 = fdiv double %sqrt120, 4.500000e-01
  %97 = fdiv double %sqrt, 4.500000e-01
  call void @vl_imsmooth_f(ptr noundef nonnull %48, i64 noundef 41, ptr noundef nonnull %48, i64 noundef 41, i64 noundef 41, i64 noundef 41, double noundef %96, double noundef %97) #7
  br label %98

98:                                               ; preds = %85, %83
  call void @vl_imgradient_f(ptr noundef nonnull %50, ptr noundef nonnull %51, i64 noundef 1, i64 noundef 41, ptr noundef nonnull %48, i64 noundef 41, i64 noundef 41, i64 noundef 41) #7
  br label %99

99:                                               ; preds = %98, %99
  %.097123 = phi double [ 0.000000e+00, %98 ], [ %115, %99 ]
  %.098122 = phi i64 [ 0, %98 ], [ %119, %99 ]
  %100 = phi <2 x double> [ zeroinitializer, %98 ], [ %118, %99 ]
  %101 = getelementptr inbounds [1681 x float], ptr %50, i64 0, i64 %.098122
  %102 = load float, ptr %101, align 4, !tbaa !13
  %103 = getelementptr inbounds [1681 x float], ptr %51, i64 0, i64 %.098122
  %104 = load float, ptr %103, align 4, !tbaa !13
  %105 = getelementptr inbounds [1681 x float], ptr %52, i64 0, i64 %.098122
  %106 = load float, ptr %105, align 4, !tbaa !13
  %107 = fpext float %106 to double
  %108 = insertelement <2 x float> poison, float %102, i64 0
  %109 = insertelement <2 x float> %108, float %104, i64 1
  %110 = fpext <2 x float> %109 to <2 x double>
  %111 = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> zeroinitializer
  %112 = fmul <2 x double> %111, %110
  %113 = fmul <2 x double> %110, %110
  %114 = extractelement <2 x double> %113, i64 1
  %115 = call double @llvm.fmuladd.f64(double %114, double %107, double %.097123)
  %116 = insertelement <2 x double> poison, double %107, i64 0
  %117 = shufflevector <2 x double> %116, <2 x double> poison, <2 x i32> zeroinitializer
  %118 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %112, <2 x double> %117, <2 x double> %100)
  %119 = add nuw nsw i64 %.098122, 1
  %exitcond.not = icmp eq i64 %119, 1681
  br i1 %exitcond.not, label %120, label %99, !llvm.loop !20

120:                                              ; preds = %99
  store <2 x double> %118, ptr %9, align 16, !tbaa !10
  %121 = extractelement <2 x double> %118, i64 1
  store double %121, ptr %53, align 16, !tbaa !10
  store double %115, ptr %54, align 8, !tbaa !10
  %122 = extractelement <2 x double> %118, i64 0
  %123 = fcmp oeq double %122, 0.000000e+00
  %124 = fcmp oeq double %115, 0.000000e+00
  %or.cond = select i1 %123, i1 true, i1 %124
  br i1 %or.cond, label %125, label %126

125:                                              ; preds = %120
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(24) %1, ptr noundef nonnull align 8 dereferenceable(24) %2, i64 24, i1 false), !tbaa.struct !14
  br label %.loopexit

126:                                              ; preds = %120
  call void @vl_svd2(ptr noundef nonnull %12, ptr noundef nonnull %10, ptr noundef nonnull %11, ptr noundef nonnull %9) #7
  %127 = load double, ptr %55, align 8, !tbaa !10
  %128 = load double, ptr %12, align 16, !tbaa !10
  %129 = insertelement <2 x double> poison, double %127, i64 0
  %130 = insertelement <2 x double> %129, double %128, i64 1
  %131 = insertelement <2 x double> poison, double %128, i64 0
  %132 = insertelement <2 x double> %131, double %127, i64 1
  %133 = fdiv <2 x double> %130, %132
  %134 = fcmp olt <2 x double> %133, <double 1.001000e+00, double 1.001000e+00>
  %shift = shufflevector <2 x i1> %134, <2 x i1> poison, <2 x i32> <i32 1, i32 poison>
  %135 = and <2 x i1> %134, %shift
  %or.cond110 = extractelement <2 x i1> %135, i64 0
  br i1 %or.cond110, label %.loopexit, label %136

136:                                              ; preds = %126
  %137 = call double @sqrt(double noundef %128) #7
  %138 = load double, ptr %55, align 8, !tbaa !10
  %139 = call double @sqrt(double noundef %138) #7
  %140 = load <2 x double>, ptr %10, align 16
  %141 = load <2 x double>, ptr %56, align 8
  %142 = load <2 x double>, ptr %57, align 16
  %143 = load double, ptr %58, align 8, !tbaa !10
  %144 = load <2 x double>, ptr %4, align 16, !tbaa !10
  %145 = load <2 x double>, ptr %25, align 16, !tbaa !10
  %146 = shufflevector <2 x double> %141, <2 x double> poison, <2 x i32> zeroinitializer
  %147 = fmul <2 x double> %146, %145
  %148 = shufflevector <2 x double> %140, <2 x double> poison, <2 x i32> zeroinitializer
  %149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %148, <2 x double> %147)
  %150 = insertelement <2 x double> poison, double %137, i64 0
  %151 = shufflevector <2 x double> %150, <2 x double> poison, <2 x i32> zeroinitializer
  %152 = fdiv <2 x double> %149, %151
  store <2 x double> %152, ptr %4, align 16
  %153 = insertelement <2 x double> poison, double %143, i64 0
  %154 = shufflevector <2 x double> %153, <2 x double> poison, <2 x i32> zeroinitializer
  %155 = fmul <2 x double> %145, %154
  %156 = shufflevector <2 x double> %142, <2 x double> poison, <2 x i32> zeroinitializer
  %157 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %144, <2 x double> %156, <2 x double> %155)
  %158 = insertelement <2 x double> poison, double %139, i64 0
  %159 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> zeroinitializer
  %160 = fdiv <2 x double> %157, %159
  store <2 x double> %160, ptr %25, align 16
  call void @vl_svd2(ptr noundef nonnull %8, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef nonnull %4) #7
  %161 = load double, ptr %8, align 16
  %162 = load double, ptr %35, align 8
  %163 = insertelement <2 x double> poison, double %161, i64 0
  %164 = insertelement <2 x double> %163, double %162, i64 1
  %165 = insertelement <2 x double> poison, double %162, i64 0
  %166 = insertelement <2 x double> %165, double %161, i64 1
  %167 = fdiv <2 x double> %164, %166
  %168 = extractelement <2 x double> %167, i64 0
  %169 = extractelement <2 x double> %167, i64 1
  %170 = fcmp ogt double %168, %169
  %. = select i1 %170, double %168, double %169
  %171 = fcmp ogt double %., 5.000000e+00
  br i1 %171, label %.loopexit, label %59

.loopexit:                                        ; preds = %126, %59, %136, %3, %125
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %15) #7
  %172 = getelementptr inbounds i8, ptr %1, i64 8
  %173 = load float, ptr %172, align 4, !tbaa !22
  %174 = getelementptr inbounds i8, ptr %15, i64 8
  %175 = getelementptr inbounds i8, ptr %1, i64 16
  %176 = load float, ptr %175, align 4, !tbaa !5
  %177 = insertelement <2 x float> poison, float %173, i64 0
  %178 = insertelement <2 x float> %177, float %176, i64 1
  %179 = fpext <2 x float> %178 to <2 x double>
  store <2 x double> %179, ptr %15, align 16, !tbaa !10
  %180 = getelementptr inbounds i8, ptr %15, i64 16
  %181 = getelementptr inbounds i8, ptr %1, i64 12
  %182 = load float, ptr %181, align 4, !tbaa !23
  %183 = getelementptr inbounds i8, ptr %1, i64 20
  %184 = load float, ptr %183, align 4, !tbaa !12
  %185 = insertelement <2 x float> poison, float %182, i64 0
  %186 = insertelement <2 x float> %185, float %184, i64 1
  %187 = fpext <2 x float> %186 to <2 x double>
  store <2 x double> %187, ptr %180, align 16, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %16) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %17) #7
  %188 = getelementptr inbounds i8, ptr %0, i64 120
  %189 = load i32, ptr %188, align 8, !tbaa !24
  %.not108 = icmp eq i32 %189, 0
  %190 = getelementptr inbounds i8, ptr %16, i64 8
  %191 = insertelement <2 x i1> poison, i1 %.not108, i64 0
  %192 = shufflevector <2 x i1> %191, <2 x i1> poison, <2 x i32> zeroinitializer
  %193 = select <2 x i1> %192, <2 x double> <double 0.000000e+00, double 1.000000e+00>, <2 x double> <double 1.000000e+00, double 0.000000e+00>
  store <2 x double> %193, ptr %16, align 16
  %194 = call i32 @vl_solve_linear_system_2(ptr noundef nonnull %17, ptr noundef nonnull %15, ptr noundef nonnull %16) #7
  %195 = load double, ptr %190, align 8, !tbaa !10
  %196 = load double, ptr %16, align 16, !tbaa !10
  %197 = call double @atan2(double noundef %195, double noundef %196) #7
  %198 = getelementptr inbounds i8, ptr %17, i64 8
  %199 = load double, ptr %198, align 8, !tbaa !10
  %200 = load double, ptr %17, align 16, !tbaa !10
  %201 = call double @atan2(double noundef %199, double noundef %200) #7
  %202 = fsub double %201, %197
  %203 = call double @cos(double noundef %202) #7
  %204 = call double @sin(double noundef %202) #7
  %205 = load double, ptr %15, align 16, !tbaa !10
  %206 = load double, ptr %174, align 8, !tbaa !10
  %207 = fneg double %205
  %208 = fneg double %206
  %209 = load <2 x double>, ptr %180, align 16, !tbaa !10
  %210 = shufflevector <2 x double> %209, <2 x double> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
  %211 = insertelement <4 x double> poison, double %204, i64 0
  %212 = insertelement <4 x double> %211, double %203, i64 1
  %213 = shufflevector <4 x double> %212, <4 x double> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  %214 = fmul <4 x double> %213, %210
  %215 = insertelement <4 x double> poison, double %205, i64 0
  %216 = insertelement <4 x double> %215, double %207, i64 1
  %217 = insertelement <4 x double> %216, double %206, i64 2
  %218 = insertelement <4 x double> %217, double %208, i64 3
  %219 = shufflevector <4 x double> %212, <4 x double> poison, <4 x i32> <i32 1, i32 0, i32 1, i32 0>
  %220 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %218, <4 x double> %219, <4 x double> %214)
  %221 = fptrunc <4 x double> %220 to <4 x float>
  store <4 x float> %221, ptr %172, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %15) #7
  br label %.thread115

.thread115:                                       ; preds = %81, %.loopexit
  %.2 = phi i32 [ 0, %.loopexit ], [ %82, %81 ]
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %12) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %11) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %9) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %8) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %7) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %6) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %5) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %4) #7
  ret i32 %.2
}

declare void @vl_imgradient_f(ptr noundef, ptr noundef, i64 noundef, i64 noundef, ptr noundef, i64 noundef, i64 noundef, i64 noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @atan2(double noundef, double noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @cos(double noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @sin(double noundef) local_unnamed_addr #2

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x double> @llvm.fmuladd.v2f64(<2 x double>, <2 x double>, <2 x double>) #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 = { 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" }
attributes #3 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { 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 #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, !7, i64 16}
!6 = !{!"_VlFrameOrientedEllipse", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !7, i64 16, !7, i64 20}
!7 = !{!"float", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!11, !11, i64 0}
!11 = !{!"double", !8, i64 0}
!12 = !{!6, !7, i64 20}
!13 = !{!7, !7, i64 0}
!14 = !{i64 0, i64 4, !13, i64 4, i64 4, !13, i64 8, i64 4, !13, i64 12, i64 4, !13, i64 16, i64 4, !13, i64 20, i64 4, !13}
!15 = !{!16, !18, i64 256}
!16 = !{!"_VlCovDet", !17, i64 0, !17, i64 8, !18, i64 16, !11, i64 24, !11, i64 32, !11, i64 40, !19, i64 48, !19, i64 56, !11, i64 64, !19, i64 72, !17, i64 80, !19, i64 88, !19, i64 96, !17, i64 104, !19, i64 112, !18, i64 120, !8, i64 128, !8, i64 192, !18, i64 256, !8, i64 260, !8, i64 6984, !8, i64 13708, !8, i64 20432, !8, i64 27156, !8, i64 31512, !8, i64 75072}
!17 = !{!"any pointer", !8, i64 0}
!18 = !{!"int", !8, i64 0}
!19 = !{!"long long", !8, i64 0}
!20 = distinct !{!20, !21}
!21 = !{!"llvm.loop.mustprogress"}
!22 = !{!6, !7, i64 8}
!23 = !{!6, !7, i64 12}
!24 = !{!16, !18, i64 120}


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