; LLVM IR from ox-vgg/vise :: src/search_engine/relja_retrival/external/KMCode_relja/descriptor (dog)

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

%class.ImageContent = type { i32, i32, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }

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

23:                                               ; preds = %261, %2
  %24 = load i32, ptr %7, align 4, !tbaa !9
  %25 = load i32, ptr %5, align 4, !tbaa !9
  %26 = icmp slt i32 %24, %25
  br i1 %26, label %27, label %264

27:                                               ; preds = %23
  store i32 3, ptr %8, align 4, !tbaa !9
  br label %28

28:                                               ; preds = %86, %27
  %29 = load i32, ptr %8, align 4, !tbaa !9
  %30 = load i32, ptr %6, align 4, !tbaa !9
  %31 = sub nsw i32 %30, 3
  %32 = icmp slt i32 %29, %31
  br i1 %32, label %33, label %89

33:                                               ; preds = %28
  %34 = load ptr, ptr %9, align 8, !tbaa !5
  %35 = load i32, ptr %7, align 4, !tbaa !9
  %36 = sext i32 %35 to i64
  %37 = getelementptr inbounds ptr, ptr %34, i64 %36
  %38 = load ptr, ptr %37, align 8, !tbaa !5
  %39 = load i32, ptr %8, align 4, !tbaa !9
  %40 = sext i32 %39 to i64
  %41 = getelementptr inbounds float, ptr %38, i64 %40
  store ptr %41, ptr %11, align 8, !tbaa !5
  %42 = load ptr, ptr %11, align 8, !tbaa !5
  %43 = getelementptr inbounds float, ptr %42, i64 -3
  %44 = load float, ptr %43, align 4, !tbaa !13
  %45 = fpext float %44 to double
  %46 = load ptr, ptr %11, align 8, !tbaa !5
  %47 = getelementptr inbounds float, ptr %46, i64 -2
  %48 = load float, ptr %47, align 4, !tbaa !13
  %49 = fpext float %48 to double
  %50 = fmul double 1.050000e-01, %49
  %51 = call double @llvm.fmuladd.f64(double 3.000000e-02, double %45, double %50)
  %52 = load ptr, ptr %11, align 8, !tbaa !5
  %53 = getelementptr inbounds float, ptr %52, i64 -1
  %54 = load float, ptr %53, align 4, !tbaa !13
  %55 = fpext float %54 to double
  %56 = call double @llvm.fmuladd.f64(double 2.220000e-01, double %55, double %51)
  %57 = load ptr, ptr %11, align 8, !tbaa !5
  %58 = getelementptr inbounds float, ptr %57, i64 0
  %59 = load float, ptr %58, align 4, !tbaa !13
  %60 = fpext float %59 to double
  %61 = call double @llvm.fmuladd.f64(double 2.860000e-01, double %60, double %56)
  %62 = load ptr, ptr %11, align 8, !tbaa !5
  %63 = getelementptr inbounds float, ptr %62, i64 1
  %64 = load float, ptr %63, align 4, !tbaa !13
  %65 = fpext float %64 to double
  %66 = call double @llvm.fmuladd.f64(double 2.220000e-01, double %65, double %61)
  %67 = load ptr, ptr %11, align 8, !tbaa !5
  %68 = getelementptr inbounds float, ptr %67, i64 2
  %69 = load float, ptr %68, align 4, !tbaa !13
  %70 = fpext float %69 to double
  %71 = call double @llvm.fmuladd.f64(double 1.050000e-01, double %70, double %66)
  %72 = load ptr, ptr %11, align 8, !tbaa !5
  %73 = getelementptr inbounds float, ptr %72, i64 3
  %74 = load float, ptr %73, align 4, !tbaa !13
  %75 = fpext float %74 to double
  %76 = call double @llvm.fmuladd.f64(double 3.000000e-02, double %75, double %71)
  %77 = fptrunc double %76 to float
  %78 = load ptr, ptr %10, align 8, !tbaa !5
  %79 = load i32, ptr %7, align 4, !tbaa !9
  %80 = sext i32 %79 to i64
  %81 = getelementptr inbounds ptr, ptr %78, i64 %80
  %82 = load ptr, ptr %81, align 8, !tbaa !5
  %83 = load i32, ptr %8, align 4, !tbaa !9
  %84 = sext i32 %83 to i64
  %85 = getelementptr inbounds float, ptr %82, i64 %84
  store float %77, ptr %85, align 4, !tbaa !13
  br label %86

86:                                               ; preds = %33
  %87 = load i32, ptr %8, align 4, !tbaa !9
  %88 = add nsw i32 %87, 1
  store i32 %88, ptr %8, align 4, !tbaa !9
  br label %28, !llvm.loop !15

89:                                               ; preds = %28
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %90

90:                                               ; preds = %166, %89
  %91 = load i32, ptr %8, align 4, !tbaa !9
  %92 = icmp slt i32 %91, 3
  br i1 %92, label %93, label %169

93:                                               ; preds = %90
  %94 = load i32, ptr %8, align 4, !tbaa !9
  %95 = icmp slt i32 %94, 1
  br i1 %95, label %96, label %104

96:                                               ; preds = %93
  %97 = load ptr, ptr %9, align 8, !tbaa !5
  %98 = load i32, ptr %7, align 4, !tbaa !9
  %99 = sext i32 %98 to i64
  %100 = getelementptr inbounds ptr, ptr %97, i64 %99
  %101 = load ptr, ptr %100, align 8, !tbaa !5
  %102 = getelementptr inbounds float, ptr %101, i64 0
  %103 = load float, ptr %102, align 4, !tbaa !13
  br label %115

104:                                              ; preds = %93
  %105 = load ptr, ptr %9, align 8, !tbaa !5
  %106 = load i32, ptr %7, align 4, !tbaa !9
  %107 = sext i32 %106 to i64
  %108 = getelementptr inbounds ptr, ptr %105, i64 %107
  %109 = load ptr, ptr %108, align 8, !tbaa !5
  %110 = load i32, ptr %8, align 4, !tbaa !9
  %111 = sub nsw i32 %110, 1
  %112 = sext i32 %111 to i64
  %113 = getelementptr inbounds float, ptr %109, i64 %112
  %114 = load float, ptr %113, align 4, !tbaa !13
  br label %115

115:                                              ; preds = %104, %96
  %116 = phi float [ %103, %96 ], [ %114, %104 ]
  store float %116, ptr %12, align 4, !tbaa !13
  %117 = load ptr, ptr %9, align 8, !tbaa !5
  %118 = load i32, ptr %7, align 4, !tbaa !9
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds ptr, ptr %117, i64 %119
  %121 = load ptr, ptr %120, align 8, !tbaa !5
  %122 = load i32, ptr %8, align 4, !tbaa !9
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds float, ptr %121, i64 %123
  store ptr %124, ptr %11, align 8, !tbaa !5
  %125 = load ptr, ptr %9, align 8, !tbaa !5
  %126 = load i32, ptr %7, align 4, !tbaa !9
  %127 = sext i32 %126 to i64
  %128 = getelementptr inbounds ptr, ptr %125, i64 %127
  %129 = load ptr, ptr %128, align 8, !tbaa !5
  %130 = getelementptr inbounds float, ptr %129, i64 0
  %131 = load float, ptr %130, align 4, !tbaa !13
  %132 = fpext float %131 to double
  %133 = load float, ptr %12, align 4, !tbaa !13
  %134 = fpext float %133 to double
  %135 = fmul double 2.220000e-01, %134
  %136 = call double @llvm.fmuladd.f64(double 1.350000e-01, double %132, double %135)
  %137 = load ptr, ptr %11, align 8, !tbaa !5
  %138 = getelementptr inbounds float, ptr %137, i64 0
  %139 = load float, ptr %138, align 4, !tbaa !13
  %140 = fpext float %139 to double
  %141 = call double @llvm.fmuladd.f64(double 2.860000e-01, double %140, double %136)
  %142 = load ptr, ptr %11, align 8, !tbaa !5
  %143 = getelementptr inbounds float, ptr %142, i64 1
  %144 = load float, ptr %143, align 4, !tbaa !13
  %145 = fpext float %144 to double
  %146 = call double @llvm.fmuladd.f64(double 2.220000e-01, double %145, double %141)
  %147 = load ptr, ptr %11, align 8, !tbaa !5
  %148 = getelementptr inbounds float, ptr %147, i64 2
  %149 = load float, ptr %148, align 4, !tbaa !13
  %150 = fpext float %149 to double
  %151 = call double @llvm.fmuladd.f64(double 1.050000e-01, double %150, double %146)
  %152 = load ptr, ptr %11, align 8, !tbaa !5
  %153 = getelementptr inbounds float, ptr %152, i64 3
  %154 = load float, ptr %153, align 4, !tbaa !13
  %155 = fpext float %154 to double
  %156 = call double @llvm.fmuladd.f64(double 3.000000e-02, double %155, double %151)
  %157 = fptrunc double %156 to float
  %158 = load ptr, ptr %10, align 8, !tbaa !5
  %159 = load i32, ptr %7, align 4, !tbaa !9
  %160 = sext i32 %159 to i64
  %161 = getelementptr inbounds ptr, ptr %158, i64 %160
  %162 = load ptr, ptr %161, align 8, !tbaa !5
  %163 = load i32, ptr %8, align 4, !tbaa !9
  %164 = sext i32 %163 to i64
  %165 = getelementptr inbounds float, ptr %162, i64 %164
  store float %157, ptr %165, align 4, !tbaa !13
  br label %166

166:                                              ; preds = %115
  %167 = load i32, ptr %8, align 4, !tbaa !9
  %168 = add nsw i32 %167, 1
  store i32 %168, ptr %8, align 4, !tbaa !9
  br label %90, !llvm.loop !17

169:                                              ; preds = %90
  %170 = load i32, ptr %6, align 4, !tbaa !9
  %171 = sub nsw i32 %170, 3
  store i32 %171, ptr %8, align 4, !tbaa !9
  br label %172

172:                                              ; preds = %257, %169
  %173 = load i32, ptr %8, align 4, !tbaa !9
  %174 = load i32, ptr %6, align 4, !tbaa !9
  %175 = icmp slt i32 %173, %174
  br i1 %175, label %176, label %260

176:                                              ; preds = %172
  %177 = load i32, ptr %8, align 4, !tbaa !9
  %178 = load i32, ptr %6, align 4, !tbaa !9
  %179 = sub nsw i32 %178, 1
  %180 = icmp sge i32 %177, %179
  br i1 %180, label %181, label %192

181:                                              ; preds = %176
  %182 = load ptr, ptr %9, align 8, !tbaa !5
  %183 = load i32, ptr %7, align 4, !tbaa !9
  %184 = sext i32 %183 to i64
  %185 = getelementptr inbounds ptr, ptr %182, i64 %184
  %186 = load ptr, ptr %185, align 8, !tbaa !5
  %187 = load i32, ptr %6, align 4, !tbaa !9
  %188 = sub nsw i32 %187, 1
  %189 = sext i32 %188 to i64
  %190 = getelementptr inbounds float, ptr %186, i64 %189
  %191 = load float, ptr %190, align 4, !tbaa !13
  br label %203

192:                                              ; preds = %176
  %193 = load ptr, ptr %9, align 8, !tbaa !5
  %194 = load i32, ptr %7, align 4, !tbaa !9
  %195 = sext i32 %194 to i64
  %196 = getelementptr inbounds ptr, ptr %193, i64 %195
  %197 = load ptr, ptr %196, align 8, !tbaa !5
  %198 = load i32, ptr %8, align 4, !tbaa !9
  %199 = add nsw i32 %198, 1
  %200 = sext i32 %199 to i64
  %201 = getelementptr inbounds float, ptr %197, i64 %200
  %202 = load float, ptr %201, align 4, !tbaa !13
  br label %203

203:                                              ; preds = %192, %181
  %204 = phi float [ %191, %181 ], [ %202, %192 ]
  store float %204, ptr %12, align 4, !tbaa !13
  %205 = load ptr, ptr %9, align 8, !tbaa !5
  %206 = load i32, ptr %7, align 4, !tbaa !9
  %207 = sext i32 %206 to i64
  %208 = getelementptr inbounds ptr, ptr %205, i64 %207
  %209 = load ptr, ptr %208, align 8, !tbaa !5
  %210 = load i32, ptr %8, align 4, !tbaa !9
  %211 = sext i32 %210 to i64
  %212 = getelementptr inbounds float, ptr %209, i64 %211
  store ptr %212, ptr %11, align 8, !tbaa !5
  %213 = load ptr, ptr %11, align 8, !tbaa !5
  %214 = getelementptr inbounds float, ptr %213, i64 -3
  %215 = load float, ptr %214, align 4, !tbaa !13
  %216 = fpext float %215 to double
  %217 = load ptr, ptr %11, align 8, !tbaa !5
  %218 = getelementptr inbounds float, ptr %217, i64 -2
  %219 = load float, ptr %218, align 4, !tbaa !13
  %220 = fpext float %219 to double
  %221 = fmul double 1.050000e-01, %220
  %222 = call double @llvm.fmuladd.f64(double 3.000000e-02, double %216, double %221)
  %223 = load ptr, ptr %11, align 8, !tbaa !5
  %224 = getelementptr inbounds float, ptr %223, i64 -1
  %225 = load float, ptr %224, align 4, !tbaa !13
  %226 = fpext float %225 to double
  %227 = call double @llvm.fmuladd.f64(double 2.220000e-01, double %226, double %222)
  %228 = load ptr, ptr %11, align 8, !tbaa !5
  %229 = getelementptr inbounds float, ptr %228, i64 0
  %230 = load float, ptr %229, align 4, !tbaa !13
  %231 = fpext float %230 to double
  %232 = call double @llvm.fmuladd.f64(double 2.860000e-01, double %231, double %227)
  %233 = load float, ptr %12, align 4, !tbaa !13
  %234 = fpext float %233 to double
  %235 = call double @llvm.fmuladd.f64(double 2.220000e-01, double %234, double %232)
  %236 = load ptr, ptr %9, align 8, !tbaa !5
  %237 = load i32, ptr %7, align 4, !tbaa !9
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds ptr, ptr %236, i64 %238
  %240 = load ptr, ptr %239, align 8, !tbaa !5
  %241 = load i32, ptr %6, align 4, !tbaa !9
  %242 = sub nsw i32 %241, 1
  %243 = sext i32 %242 to i64
  %244 = getelementptr inbounds float, ptr %240, i64 %243
  %245 = load float, ptr %244, align 4, !tbaa !13
  %246 = fpext float %245 to double
  %247 = call double @llvm.fmuladd.f64(double 1.350000e-01, double %246, double %235)
  %248 = fptrunc double %247 to float
  %249 = load ptr, ptr %10, align 8, !tbaa !5
  %250 = load i32, ptr %7, align 4, !tbaa !9
  %251 = sext i32 %250 to i64
  %252 = getelementptr inbounds ptr, ptr %249, i64 %251
  %253 = load ptr, ptr %252, align 8, !tbaa !5
  %254 = load i32, ptr %8, align 4, !tbaa !9
  %255 = sext i32 %254 to i64
  %256 = getelementptr inbounds float, ptr %253, i64 %255
  store float %248, ptr %256, align 4, !tbaa !13
  br label %257

257:                                              ; preds = %203
  %258 = load i32, ptr %8, align 4, !tbaa !9
  %259 = add nsw i32 %258, 1
  store i32 %259, ptr %8, align 4, !tbaa !9
  br label %172, !llvm.loop !18

260:                                              ; preds = %172
  br label %261

261:                                              ; preds = %260
  %262 = load i32, ptr %7, align 4, !tbaa !9
  %263 = add nsw i32 %262, 1
  store i32 %263, ptr %7, align 4, !tbaa !9
  br label %23, !llvm.loop !19

264:                                              ; preds = %23
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #4
  ret void
}

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

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80)) #2 align 2

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1xEv(ptr noundef nonnull align 8 dereferenceable(80)) #2 align 2

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

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

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

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

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


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

; Function Attrs: mustprogress nounwind uwtable
define dso_local void @_Z13_HorConvSqrt2P12ImageContentS0_(ptr noundef nonnull %0, ptr nocapture noundef readonly %1) local_unnamed_addr #0 {
  %3 = tail call noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80) %0)
  %4 = tail call noundef i32 @_ZNK12ImageContent1xEv(ptr noundef nonnull align 8 dereferenceable(80) %0)
  %5 = getelementptr inbounds i8, ptr %0, i64 16
  %6 = load ptr, ptr %5, align 8, !tbaa !5
  %7 = getelementptr inbounds i8, ptr %1, i64 16
  %8 = load ptr, ptr %7, align 8, !tbaa !5
  %9 = icmp sgt i32 %3, 0
  br i1 %9, label %.preheader75.lr.ph, label %._crit_edge

.preheader75.lr.ph:                               ; preds = %2
  %10 = add i32 %4, -3
  %11 = icmp sgt i32 %4, 6
  %12 = add nsw i32 %4, -1
  %13 = sext i32 %12 to i64
  %14 = sext i32 %10 to i64
  %15 = sext i32 %4 to i64
  %wide.trip.count91 = zext nneg i32 %3 to i64
  %wide.trip.count = zext i32 %10 to i64
  %.not = icmp slt i32 %10, %12
  %indvars.iv.next86 = add nsw i64 %14, 1
  %16 = icmp slt i64 %indvars.iv.next86, %15
  %.not.1 = icmp slt i64 %indvars.iv.next86, %13
  %indvars.iv.next86.1 = add nsw i64 %14, 2
  %.not.2 = icmp slt i64 %indvars.iv.next86.1, %13
  %17 = shl nuw nsw i64 %wide.trip.count, 2
  %18 = add nsw i64 %wide.trip.count, -3
  %min.iters.check = icmp ult i64 %18, 4
  %n.vec = and i64 %18, -4
  %ind.end = or i64 %18, 3
  %cmp.n = icmp eq i64 %18, %n.vec
  br label %.preheader75

.preheader75:                                     ; preds = %.preheader75.lr.ph, %222
  %indvars.iv88 = phi i64 [ 0, %.preheader75.lr.ph ], [ %indvars.iv.next89, %222 ]
  %19 = getelementptr inbounds ptr, ptr %6, i64 %indvars.iv88
  %20 = load ptr, ptr %19, align 8, !tbaa !11
  %21 = getelementptr inbounds ptr, ptr %8, i64 %indvars.iv88
  %22 = load ptr, ptr %21, align 8, !tbaa !11
  br i1 %11, label %.lr.ph.preheader, label %.preheader

.lr.ph.preheader:                                 ; preds = %.preheader75
  br i1 %min.iters.check, label %.lr.ph.preheader103, label %vector.memcheck

vector.memcheck:                                  ; preds = %.lr.ph.preheader
  %scevgep95 = getelementptr i8, ptr %22, i64 %17
  %23 = getelementptr i8, ptr %20, i64 %17
  %bound0 = icmp ult ptr %22, %23
  %bound1 = icmp ult ptr %20, %scevgep95
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph.preheader103, label %vector.body

vector.body:                                      ; preds = %vector.memcheck, %vector.body
  %index = phi i64 [ %index.next, %vector.body ], [ 0, %vector.memcheck ]
  %offset.idx = or disjoint i64 %index, 3
  %24 = getelementptr inbounds float, ptr %20, i64 %offset.idx
  %25 = getelementptr inbounds i8, ptr %24, i64 -12
  %wide.load = load <4 x float>, ptr %25, align 4, !tbaa !12, !alias.scope !14
  %26 = fpext <4 x float> %wide.load to <4 x double>
  %27 = getelementptr inbounds i8, ptr %24, i64 -8
  %wide.load97 = load <4 x float>, ptr %27, align 4, !tbaa !12, !alias.scope !14
  %28 = fpext <4 x float> %wide.load97 to <4 x double>
  %29 = fmul <4 x double> %28, <double 1.050000e-01, double 1.050000e-01, double 1.050000e-01, double 1.050000e-01>
  %30 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %26, <4 x double> <double 3.000000e-02, double 3.000000e-02, double 3.000000e-02, double 3.000000e-02>, <4 x double> %29)
  %31 = getelementptr inbounds i8, ptr %24, i64 -4
  %wide.load98 = load <4 x float>, ptr %31, align 4, !tbaa !12, !alias.scope !14
  %32 = fpext <4 x float> %wide.load98 to <4 x double>
  %33 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %32, <4 x double> <double 2.220000e-01, double 2.220000e-01, double 2.220000e-01, double 2.220000e-01>, <4 x double> %30)
  %wide.load99 = load <4 x float>, ptr %24, align 4, !tbaa !12, !alias.scope !14
  %34 = fpext <4 x float> %wide.load99 to <4 x double>
  %35 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %34, <4 x double> <double 2.860000e-01, double 2.860000e-01, double 2.860000e-01, double 2.860000e-01>, <4 x double> %33)
  %36 = getelementptr inbounds i8, ptr %24, i64 4
  %wide.load100 = load <4 x float>, ptr %36, align 4, !tbaa !12, !alias.scope !14
  %37 = fpext <4 x float> %wide.load100 to <4 x double>
  %38 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %37, <4 x double> <double 2.220000e-01, double 2.220000e-01, double 2.220000e-01, double 2.220000e-01>, <4 x double> %35)
  %39 = getelementptr inbounds i8, ptr %24, i64 8
  %wide.load101 = load <4 x float>, ptr %39, align 4, !tbaa !12, !alias.scope !14
  %40 = fpext <4 x float> %wide.load101 to <4 x double>
  %41 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %40, <4 x double> <double 1.050000e-01, double 1.050000e-01, double 1.050000e-01, double 1.050000e-01>, <4 x double> %38)
  %42 = getelementptr inbounds i8, ptr %24, i64 12
  %wide.load102 = load <4 x float>, ptr %42, align 4, !tbaa !12, !alias.scope !14
  %43 = fpext <4 x float> %wide.load102 to <4 x double>
  %44 = tail call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %43, <4 x double> <double 3.000000e-02, double 3.000000e-02, double 3.000000e-02, double 3.000000e-02>, <4 x double> %41)
  %45 = fptrunc <4 x double> %44 to <4 x float>
  %46 = getelementptr inbounds float, ptr %22, i64 %offset.idx
  store <4 x float> %45, ptr %46, align 4, !tbaa !12, !alias.scope !17, !noalias !14
  %index.next = add nuw i64 %index, 4
  %47 = icmp eq i64 %index.next, %n.vec
  br i1 %47, label %middle.block, label %vector.body, !llvm.loop !19

middle.block:                                     ; preds = %vector.body
  br i1 %cmp.n, label %.preheader, label %.lr.ph.preheader103

.lr.ph.preheader103:                              ; preds = %middle.block, %vector.memcheck, %.lr.ph.preheader
  %indvars.iv.ph = phi i64 [ 3, %vector.memcheck ], [ 3, %.lr.ph.preheader ], [ %ind.end, %middle.block ]
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader103, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %indvars.iv.ph, %.lr.ph.preheader103 ]
  %48 = getelementptr inbounds float, ptr %20, i64 %indvars.iv
  %49 = getelementptr inbounds i8, ptr %48, i64 -12
  %50 = load float, ptr %49, align 4, !tbaa !12
  %51 = fpext float %50 to double
  %52 = getelementptr inbounds i8, ptr %48, i64 -8
  %53 = load float, ptr %52, align 4, !tbaa !12
  %54 = fpext float %53 to double
  %55 = fmul double %54, 1.050000e-01
  %56 = tail call double @llvm.fmuladd.f64(double %51, double 3.000000e-02, double %55)
  %57 = getelementptr inbounds i8, ptr %48, i64 -4
  %58 = load float, ptr %57, align 4, !tbaa !12
  %59 = fpext float %58 to double
  %60 = tail call double @llvm.fmuladd.f64(double %59, double 2.220000e-01, double %56)
  %61 = load float, ptr %48, align 4, !tbaa !12
  %62 = fpext float %61 to double
  %63 = tail call double @llvm.fmuladd.f64(double %62, double 2.860000e-01, double %60)
  %64 = getelementptr inbounds i8, ptr %48, i64 4
  %65 = load float, ptr %64, align 4, !tbaa !12
  %66 = fpext float %65 to double
  %67 = tail call double @llvm.fmuladd.f64(double %66, double 2.220000e-01, double %63)
  %68 = getelementptr inbounds i8, ptr %48, i64 8
  %69 = load float, ptr %68, align 4, !tbaa !12
  %70 = fpext float %69 to double
  %71 = tail call double @llvm.fmuladd.f64(double %70, double 1.050000e-01, double %67)
  %72 = getelementptr inbounds i8, ptr %48, i64 12
  %73 = load float, ptr %72, align 4, !tbaa !12
  %74 = fpext float %73 to double
  %75 = tail call double @llvm.fmuladd.f64(double %74, double 3.000000e-02, double %71)
  %76 = fptrunc double %75 to float
  %77 = getelementptr inbounds float, ptr %22, i64 %indvars.iv
  store float %76, ptr %77, align 4, !tbaa !12
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %.preheader, label %.lr.ph, !llvm.loop !23

.preheader:                                       ; preds = %.lr.ph, %middle.block, %.preheader75
  %78 = load float, ptr %20, align 4, !tbaa !12
  %79 = fpext float %78 to double
  %80 = fmul double %79, 2.220000e-01
  %81 = tail call double @llvm.fmuladd.f64(double %79, double 1.350000e-01, double %80)
  %82 = tail call double @llvm.fmuladd.f64(double %79, double 2.860000e-01, double %81)
  %83 = getelementptr i8, ptr %20, i64 4
  %84 = load float, ptr %83, align 4, !tbaa !12
  %85 = fpext float %84 to double
  %86 = tail call double @llvm.fmuladd.f64(double %85, double 2.220000e-01, double %82)
  %87 = getelementptr i8, ptr %20, i64 8
  %88 = load float, ptr %87, align 4, !tbaa !12
  %89 = fpext float %88 to double
  %90 = tail call double @llvm.fmuladd.f64(double %89, double 1.050000e-01, double %86)
  %91 = getelementptr inbounds i8, ptr %20, i64 12
  %92 = load float, ptr %91, align 4, !tbaa !12
  %93 = fpext float %92 to double
  %94 = tail call double @llvm.fmuladd.f64(double %93, double 3.000000e-02, double %90)
  %95 = fptrunc double %94 to float
  store float %95, ptr %22, align 4, !tbaa !12
  %96 = load float, ptr %20, align 4, !tbaa !12
  %97 = fpext float %96 to double
  %98 = fpext float %96 to double
  %99 = fmul double %98, 2.220000e-01
  %100 = tail call double @llvm.fmuladd.f64(double %97, double 1.350000e-01, double %99)
  %101 = load float, ptr %83, align 4, !tbaa !12
  %102 = fpext float %101 to double
  %103 = tail call double @llvm.fmuladd.f64(double %102, double 2.860000e-01, double %100)
  %104 = getelementptr i8, ptr %20, i64 8
  %105 = load float, ptr %104, align 4, !tbaa !12
  %106 = fpext float %105 to double
  %107 = tail call double @llvm.fmuladd.f64(double %106, double 2.220000e-01, double %103)
  %108 = getelementptr i8, ptr %20, i64 12
  %109 = load float, ptr %108, align 4, !tbaa !12
  %110 = fpext float %109 to double
  %111 = tail call double @llvm.fmuladd.f64(double %110, double 1.050000e-01, double %107)
  %112 = getelementptr i8, ptr %20, i64 16
  %113 = load float, ptr %112, align 4, !tbaa !12
  %114 = fpext float %113 to double
  %115 = tail call double @llvm.fmuladd.f64(double %114, double 3.000000e-02, double %111)
  %116 = fptrunc double %115 to float
  %117 = getelementptr inbounds i8, ptr %22, i64 4
  store float %116, ptr %117, align 4, !tbaa !12
  %118 = getelementptr i8, ptr %20, i64 4
  %119 = load float, ptr %118, align 4, !tbaa !12
  %120 = load float, ptr %20, align 4, !tbaa !12
  %121 = fpext float %120 to double
  %122 = fpext float %119 to double
  %123 = fmul double %122, 2.220000e-01
  %124 = tail call double @llvm.fmuladd.f64(double %121, double 1.350000e-01, double %123)
  %125 = load float, ptr %87, align 4, !tbaa !12
  %126 = fpext float %125 to double
  %127 = tail call double @llvm.fmuladd.f64(double %126, double 2.860000e-01, double %124)
  %128 = getelementptr i8, ptr %20, i64 12
  %129 = load float, ptr %128, align 4, !tbaa !12
  %130 = fpext float %129 to double
  %131 = tail call double @llvm.fmuladd.f64(double %130, double 2.220000e-01, double %127)
  %132 = getelementptr i8, ptr %20, i64 16
  %133 = load float, ptr %132, align 4, !tbaa !12
  %134 = fpext float %133 to double
  %135 = tail call double @llvm.fmuladd.f64(double %134, double 1.050000e-01, double %131)
  %136 = getelementptr i8, ptr %20, i64 20
  %137 = load float, ptr %136, align 4, !tbaa !12
  %138 = fpext float %137 to double
  %139 = tail call double @llvm.fmuladd.f64(double %138, double 3.000000e-02, double %135)
  %140 = fptrunc double %139 to float
  %141 = getelementptr inbounds i8, ptr %22, i64 8
  store float %140, ptr %141, align 4, !tbaa !12
  %142 = getelementptr inbounds float, ptr %20, i64 %13
  %143 = getelementptr float, ptr %20, i64 %14
  %144 = getelementptr i8, ptr %143, i64 4
  %.in = select i1 %.not, ptr %144, ptr %142
  %145 = load float, ptr %.in, align 4, !tbaa !12
  %146 = getelementptr inbounds float, ptr %20, i64 %14
  %147 = getelementptr inbounds i8, ptr %146, i64 -12
  %148 = load float, ptr %147, align 4, !tbaa !12
  %149 = fpext float %148 to double
  %150 = getelementptr inbounds i8, ptr %146, i64 -8
  %151 = load float, ptr %150, align 4, !tbaa !12
  %152 = fpext float %151 to double
  %153 = fmul double %152, 1.050000e-01
  %154 = tail call double @llvm.fmuladd.f64(double %149, double 3.000000e-02, double %153)
  %155 = getelementptr inbounds i8, ptr %146, i64 -4
  %156 = load float, ptr %155, align 4, !tbaa !12
  %157 = fpext float %156 to double
  %158 = tail call double @llvm.fmuladd.f64(double %157, double 2.220000e-01, double %154)
  %159 = load float, ptr %146, align 4, !tbaa !12
  %160 = fpext float %159 to double
  %161 = tail call double @llvm.fmuladd.f64(double %160, double 2.860000e-01, double %158)
  %162 = fpext float %145 to double
  %163 = tail call double @llvm.fmuladd.f64(double %162, double 2.220000e-01, double %161)
  %164 = load float, ptr %142, align 4, !tbaa !12
  %165 = fpext float %164 to double
  %166 = tail call double @llvm.fmuladd.f64(double %165, double 1.350000e-01, double %163)
  %167 = fptrunc double %166 to float
  %168 = getelementptr inbounds float, ptr %22, i64 %14
  store float %167, ptr %168, align 4, !tbaa !12
  br i1 %16, label %169, label %222, !llvm.loop !24

169:                                              ; preds = %.preheader
  %170 = getelementptr float, ptr %20, i64 %indvars.iv.next86
  %171 = getelementptr i8, ptr %170, i64 4
  %.in.1 = select i1 %.not.1, ptr %171, ptr %142
  %172 = load float, ptr %.in.1, align 4, !tbaa !12
  %173 = getelementptr inbounds float, ptr %20, i64 %indvars.iv.next86
  %174 = getelementptr inbounds i8, ptr %173, i64 -12
  %175 = load float, ptr %174, align 4, !tbaa !12
  %176 = fpext float %175 to double
  %177 = getelementptr inbounds i8, ptr %173, i64 -8
  %178 = load float, ptr %177, align 4, !tbaa !12
  %179 = fpext float %178 to double
  %180 = fmul double %179, 1.050000e-01
  %181 = tail call double @llvm.fmuladd.f64(double %176, double 3.000000e-02, double %180)
  %182 = getelementptr inbounds i8, ptr %173, i64 -4
  %183 = load float, ptr %182, align 4, !tbaa !12
  %184 = fpext float %183 to double
  %185 = tail call double @llvm.fmuladd.f64(double %184, double 2.220000e-01, double %181)
  %186 = load float, ptr %173, align 4, !tbaa !12
  %187 = fpext float %186 to double
  %188 = tail call double @llvm.fmuladd.f64(double %187, double 2.860000e-01, double %185)
  %189 = fpext float %172 to double
  %190 = tail call double @llvm.fmuladd.f64(double %189, double 2.220000e-01, double %188)
  %191 = load float, ptr %142, align 4, !tbaa !12
  %192 = fpext float %191 to double
  %193 = tail call double @llvm.fmuladd.f64(double %192, double 1.350000e-01, double %190)
  %194 = fptrunc double %193 to float
  %195 = getelementptr inbounds float, ptr %22, i64 %indvars.iv.next86
  store float %194, ptr %195, align 4, !tbaa !12
  %196 = getelementptr float, ptr %20, i64 %indvars.iv.next86.1
  %197 = getelementptr i8, ptr %196, i64 4
  %.in.2 = select i1 %.not.2, ptr %197, ptr %142
  %198 = load float, ptr %.in.2, align 4, !tbaa !12
  %199 = getelementptr inbounds float, ptr %20, i64 %indvars.iv.next86.1
  %200 = getelementptr inbounds i8, ptr %199, i64 -12
  %201 = load float, ptr %200, align 4, !tbaa !12
  %202 = fpext float %201 to double
  %203 = getelementptr inbounds i8, ptr %199, i64 -8
  %204 = load float, ptr %203, align 4, !tbaa !12
  %205 = fpext float %204 to double
  %206 = fmul double %205, 1.050000e-01
  %207 = tail call double @llvm.fmuladd.f64(double %202, double 3.000000e-02, double %206)
  %208 = getelementptr inbounds i8, ptr %199, i64 -4
  %209 = load float, ptr %208, align 4, !tbaa !12
  %210 = fpext float %209 to double
  %211 = tail call double @llvm.fmuladd.f64(double %210, double 2.220000e-01, double %207)
  %212 = load float, ptr %199, align 4, !tbaa !12
  %213 = fpext float %212 to double
  %214 = tail call double @llvm.fmuladd.f64(double %213, double 2.860000e-01, double %211)
  %215 = fpext float %198 to double
  %216 = tail call double @llvm.fmuladd.f64(double %215, double 2.220000e-01, double %214)
  %217 = load float, ptr %142, align 4, !tbaa !12
  %218 = fpext float %217 to double
  %219 = tail call double @llvm.fmuladd.f64(double %218, double 1.350000e-01, double %216)
  %220 = fptrunc double %219 to float
  %221 = getelementptr inbounds float, ptr %22, i64 %indvars.iv.next86.1
  store float %220, ptr %221, align 4, !tbaa !12
  br label %222

222:                                              ; preds = %169, %.preheader
  %indvars.iv.next89 = add nuw nsw i64 %indvars.iv88, 1
  %exitcond92.not = icmp eq i64 %indvars.iv.next89, %wide.trip.count91
  br i1 %exitcond92.not, label %._crit_edge, label %.preheader75, !llvm.loop !25

._crit_edge:                                      ; preds = %222, %2
  ret void
}

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80)) local_unnamed_addr #1 align 2

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1xEv(ptr noundef nonnull align 8 dereferenceable(80)) local_unnamed_addr #1 align 2

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

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

attributes #0 = { mustprogress nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { inlinehint mustprogress nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }

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

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


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