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

; 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: 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: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80)) #1 align 2

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

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

; Function Attrs: mustprogress uwtable
define dso_local void @_Z7DerYYV9P12ImageContentS0_(ptr noundef %0, ptr noundef %1) #3 {
  %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
  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
  %11 = load ptr, ptr %3, align 8, !tbaa !5
  %12 = call noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80) %11)
  store i32 %12, ptr %5, align 4, !tbaa !9
  %13 = load ptr, ptr %3, align 8, !tbaa !5
  %14 = call noundef i32 @_ZNK12ImageContent1xEv(ptr noundef nonnull align 8 dereferenceable(80) %13)
  store i32 %14, ptr %6, align 4, !tbaa !9
  %15 = load ptr, ptr %3, align 8, !tbaa !5
  %16 = getelementptr inbounds %class.ImageContent, ptr %15, i32 0, i32 4
  %17 = load ptr, ptr %16, align 8, !tbaa !11
  store ptr %17, ptr %9, align 8, !tbaa !5
  %18 = load ptr, ptr %4, align 8, !tbaa !5
  %19 = getelementptr inbounds %class.ImageContent, ptr %18, i32 0, i32 4
  %20 = load ptr, ptr %19, align 8, !tbaa !11
  store ptr %20, ptr %10, align 8, !tbaa !5
  store i32 0, ptr %8, align 4, !tbaa !9
  br label %21

21:                                               ; preds = %1038, %2
  %22 = load i32, ptr %8, align 4, !tbaa !9
  %23 = load i32, ptr %6, align 4, !tbaa !9
  %24 = icmp slt i32 %22, %23
  br i1 %24, label %25, label %1041

25:                                               ; preds = %21
  store i32 5, ptr %7, align 4, !tbaa !9
  br label %26

26:                                               ; preds = %148, %25
  %27 = load i32, ptr %7, align 4, !tbaa !9
  %28 = load i32, ptr %5, align 4, !tbaa !9
  %29 = sub nsw i32 %28, 5
  %30 = icmp slt i32 %27, %29
  br i1 %30, label %31, label %151

31:                                               ; preds = %26
  %32 = load ptr, ptr %9, align 8, !tbaa !5
  %33 = load i32, ptr %7, align 4, !tbaa !9
  %34 = sub nsw i32 %33, 5
  %35 = sext i32 %34 to i64
  %36 = getelementptr inbounds ptr, ptr %32, i64 %35
  %37 = load ptr, ptr %36, align 8, !tbaa !5
  %38 = load i32, ptr %8, align 4, !tbaa !9
  %39 = sext i32 %38 to i64
  %40 = getelementptr inbounds float, ptr %37, i64 %39
  %41 = load float, ptr %40, align 4, !tbaa !13
  %42 = fpext float %41 to double
  %43 = load ptr, ptr %9, align 8, !tbaa !5
  %44 = load i32, ptr %7, align 4, !tbaa !9
  %45 = sub nsw i32 %44, 4
  %46 = sext i32 %45 to i64
  %47 = getelementptr inbounds ptr, ptr %43, i64 %46
  %48 = load ptr, ptr %47, align 8, !tbaa !5
  %49 = load i32, ptr %8, align 4, !tbaa !9
  %50 = sext i32 %49 to i64
  %51 = getelementptr inbounds float, ptr %48, i64 %50
  %52 = load float, ptr %51, align 4, !tbaa !13
  %53 = fpext float %52 to double
  %54 = fmul double 2.160000e-01, %53
  %55 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %42, double %54)
  %56 = load ptr, ptr %9, align 8, !tbaa !5
  %57 = load i32, ptr %7, align 4, !tbaa !9
  %58 = sub nsw i32 %57, 3
  %59 = sext i32 %58 to i64
  %60 = getelementptr inbounds ptr, ptr %56, i64 %59
  %61 = load ptr, ptr %60, align 8, !tbaa !5
  %62 = load i32, ptr %8, align 4, !tbaa !9
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds float, ptr %61, i64 %63
  %65 = load float, ptr %64, align 4, !tbaa !13
  %66 = fpext float %65 to double
  %67 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %66, double %55)
  %68 = load ptr, ptr %9, align 8, !tbaa !5
  %69 = load i32, ptr %7, align 4, !tbaa !9
  %70 = sub nsw i32 %69, 1
  %71 = sext i32 %70 to i64
  %72 = getelementptr inbounds ptr, ptr %68, i64 %71
  %73 = load ptr, ptr %72, align 8, !tbaa !5
  %74 = load i32, ptr %8, align 4, !tbaa !9
  %75 = sext i32 %74 to i64
  %76 = getelementptr inbounds float, ptr %73, i64 %75
  %77 = load float, ptr %76, align 4, !tbaa !13
  %78 = fpext float %77 to double
  %79 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %78, double %67)
  %80 = load ptr, ptr %9, align 8, !tbaa !5
  %81 = load i32, ptr %7, align 4, !tbaa !9
  %82 = sext i32 %81 to i64
  %83 = getelementptr inbounds ptr, ptr %80, i64 %82
  %84 = load ptr, ptr %83, align 8, !tbaa !5
  %85 = load i32, ptr %8, align 4, !tbaa !9
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds float, ptr %84, i64 %86
  %88 = load float, ptr %87, align 4, !tbaa !13
  %89 = fpext float %88 to double
  %90 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %89, double %79)
  %91 = load ptr, ptr %9, align 8, !tbaa !5
  %92 = load i32, ptr %7, align 4, !tbaa !9
  %93 = add nsw i32 %92, 1
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds ptr, ptr %91, i64 %94
  %96 = load ptr, ptr %95, align 8, !tbaa !5
  %97 = load i32, ptr %8, align 4, !tbaa !9
  %98 = sext i32 %97 to i64
  %99 = getelementptr inbounds float, ptr %96, i64 %98
  %100 = load float, ptr %99, align 4, !tbaa !13
  %101 = fpext float %100 to double
  %102 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %101, double %90)
  %103 = load ptr, ptr %9, align 8, !tbaa !5
  %104 = load i32, ptr %7, align 4, !tbaa !9
  %105 = add nsw i32 %104, 3
  %106 = sext i32 %105 to i64
  %107 = getelementptr inbounds ptr, ptr %103, i64 %106
  %108 = load ptr, ptr %107, align 8, !tbaa !5
  %109 = load i32, ptr %8, align 4, !tbaa !9
  %110 = sext i32 %109 to i64
  %111 = getelementptr inbounds float, ptr %108, i64 %110
  %112 = load float, ptr %111, align 4, !tbaa !13
  %113 = fpext float %112 to double
  %114 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %113, double %102)
  %115 = load ptr, ptr %9, align 8, !tbaa !5
  %116 = load i32, ptr %7, align 4, !tbaa !9
  %117 = add nsw i32 %116, 4
  %118 = sext i32 %117 to i64
  %119 = getelementptr inbounds ptr, ptr %115, i64 %118
  %120 = load ptr, ptr %119, align 8, !tbaa !5
  %121 = load i32, ptr %8, align 4, !tbaa !9
  %122 = sext i32 %121 to i64
  %123 = getelementptr inbounds float, ptr %120, i64 %122
  %124 = load float, ptr %123, align 4, !tbaa !13
  %125 = fpext float %124 to double
  %126 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %125, double %114)
  %127 = load ptr, ptr %9, align 8, !tbaa !5
  %128 = load i32, ptr %7, align 4, !tbaa !9
  %129 = add nsw i32 %128, 5
  %130 = sext i32 %129 to i64
  %131 = getelementptr inbounds ptr, ptr %127, i64 %130
  %132 = load ptr, ptr %131, align 8, !tbaa !5
  %133 = load i32, ptr %8, align 4, !tbaa !9
  %134 = sext i32 %133 to i64
  %135 = getelementptr inbounds float, ptr %132, i64 %134
  %136 = load float, ptr %135, align 4, !tbaa !13
  %137 = fpext float %136 to double
  %138 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %137, double %126)
  %139 = fptrunc double %138 to float
  %140 = load ptr, ptr %10, align 8, !tbaa !5
  %141 = load i32, ptr %7, align 4, !tbaa !9
  %142 = sext i32 %141 to i64
  %143 = getelementptr inbounds ptr, ptr %140, i64 %142
  %144 = load ptr, ptr %143, align 8, !tbaa !5
  %145 = load i32, ptr %8, align 4, !tbaa !9
  %146 = sext i32 %145 to i64
  %147 = getelementptr inbounds float, ptr %144, i64 %146
  store float %139, ptr %147, align 4, !tbaa !13
  br label %148

148:                                              ; preds = %31
  %149 = load i32, ptr %7, align 4, !tbaa !9
  %150 = add nsw i32 %149, 1
  store i32 %150, ptr %7, align 4, !tbaa !9
  br label %26, !llvm.loop !15

151:                                              ; preds = %26
  store i32 4, ptr %7, align 4, !tbaa !9
  %152 = load ptr, ptr %9, align 8, !tbaa !5
  %153 = load i32, ptr %7, align 4, !tbaa !9
  %154 = sub nsw i32 %153, 4
  %155 = sext i32 %154 to i64
  %156 = getelementptr inbounds ptr, ptr %152, i64 %155
  %157 = load ptr, ptr %156, align 8, !tbaa !5
  %158 = load i32, ptr %8, align 4, !tbaa !9
  %159 = sext i32 %158 to i64
  %160 = getelementptr inbounds float, ptr %157, i64 %159
  %161 = load float, ptr %160, align 4, !tbaa !13
  %162 = fpext float %161 to double
  %163 = load ptr, ptr %9, align 8, !tbaa !5
  %164 = load i32, ptr %7, align 4, !tbaa !9
  %165 = sub nsw i32 %164, 3
  %166 = sext i32 %165 to i64
  %167 = getelementptr inbounds ptr, ptr %163, i64 %166
  %168 = load ptr, ptr %167, align 8, !tbaa !5
  %169 = load i32, ptr %8, align 4, !tbaa !9
  %170 = sext i32 %169 to i64
  %171 = getelementptr inbounds float, ptr %168, i64 %170
  %172 = load float, ptr %171, align 4, !tbaa !13
  %173 = fpext float %172 to double
  %174 = fmul double 2.160000e-01, %173
  %175 = call double @llvm.fmuladd.f64(double 3.440000e-01, double %162, double %174)
  %176 = load ptr, ptr %9, align 8, !tbaa !5
  %177 = load i32, ptr %7, align 4, !tbaa !9
  %178 = sub nsw i32 %177, 1
  %179 = sext i32 %178 to i64
  %180 = getelementptr inbounds ptr, ptr %176, i64 %179
  %181 = load ptr, ptr %180, align 8, !tbaa !5
  %182 = load i32, ptr %8, align 4, !tbaa !9
  %183 = sext i32 %182 to i64
  %184 = getelementptr inbounds float, ptr %181, i64 %183
  %185 = load float, ptr %184, align 4, !tbaa !13
  %186 = fpext float %185 to double
  %187 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %186, double %175)
  %188 = load ptr, ptr %9, align 8, !tbaa !5
  %189 = load i32, ptr %7, align 4, !tbaa !9
  %190 = sext i32 %189 to i64
  %191 = getelementptr inbounds ptr, ptr %188, i64 %190
  %192 = load ptr, ptr %191, align 8, !tbaa !5
  %193 = load i32, ptr %8, align 4, !tbaa !9
  %194 = sext i32 %193 to i64
  %195 = getelementptr inbounds float, ptr %192, i64 %194
  %196 = load float, ptr %195, align 4, !tbaa !13
  %197 = fpext float %196 to double
  %198 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %197, double %187)
  %199 = load ptr, ptr %9, align 8, !tbaa !5
  %200 = load i32, ptr %7, align 4, !tbaa !9
  %201 = add nsw i32 %200, 1
  %202 = sext i32 %201 to i64
  %203 = getelementptr inbounds ptr, ptr %199, i64 %202
  %204 = load ptr, ptr %203, align 8, !tbaa !5
  %205 = load i32, ptr %8, align 4, !tbaa !9
  %206 = sext i32 %205 to i64
  %207 = getelementptr inbounds float, ptr %204, i64 %206
  %208 = load float, ptr %207, align 4, !tbaa !13
  %209 = fpext float %208 to double
  %210 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %209, double %198)
  %211 = load ptr, ptr %9, align 8, !tbaa !5
  %212 = load i32, ptr %7, align 4, !tbaa !9
  %213 = add nsw i32 %212, 3
  %214 = sext i32 %213 to i64
  %215 = getelementptr inbounds ptr, ptr %211, i64 %214
  %216 = load ptr, ptr %215, align 8, !tbaa !5
  %217 = load i32, ptr %8, align 4, !tbaa !9
  %218 = sext i32 %217 to i64
  %219 = getelementptr inbounds float, ptr %216, i64 %218
  %220 = load float, ptr %219, align 4, !tbaa !13
  %221 = fpext float %220 to double
  %222 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %221, double %210)
  %223 = load ptr, ptr %9, align 8, !tbaa !5
  %224 = load i32, ptr %7, align 4, !tbaa !9
  %225 = add nsw i32 %224, 4
  %226 = sext i32 %225 to i64
  %227 = getelementptr inbounds ptr, ptr %223, i64 %226
  %228 = load ptr, ptr %227, align 8, !tbaa !5
  %229 = load i32, ptr %8, align 4, !tbaa !9
  %230 = sext i32 %229 to i64
  %231 = getelementptr inbounds float, ptr %228, i64 %230
  %232 = load float, ptr %231, align 4, !tbaa !13
  %233 = fpext float %232 to double
  %234 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %233, double %222)
  %235 = load ptr, ptr %9, align 8, !tbaa !5
  %236 = load i32, ptr %7, align 4, !tbaa !9
  %237 = add nsw i32 %236, 5
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds ptr, ptr %235, i64 %238
  %240 = load ptr, ptr %239, align 8, !tbaa !5
  %241 = load i32, ptr %8, align 4, !tbaa !9
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds float, ptr %240, i64 %242
  %244 = load float, ptr %243, align 4, !tbaa !13
  %245 = fpext float %244 to double
  %246 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %245, double %234)
  %247 = fptrunc double %246 to float
  %248 = load ptr, ptr %10, align 8, !tbaa !5
  %249 = load i32, ptr %7, align 4, !tbaa !9
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds ptr, ptr %248, i64 %250
  %252 = load ptr, ptr %251, align 8, !tbaa !5
  %253 = load i32, ptr %8, align 4, !tbaa !9
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds float, ptr %252, i64 %254
  store float %247, ptr %255, align 4, !tbaa !13
  store i32 3, ptr %7, align 4, !tbaa !9
  %256 = load ptr, ptr %9, align 8, !tbaa !5
  %257 = load i32, ptr %7, align 4, !tbaa !9
  %258 = sub nsw i32 %257, 3
  %259 = sext i32 %258 to i64
  %260 = getelementptr inbounds ptr, ptr %256, i64 %259
  %261 = load ptr, ptr %260, align 8, !tbaa !5
  %262 = load i32, ptr %8, align 4, !tbaa !9
  %263 = sext i32 %262 to i64
  %264 = getelementptr inbounds float, ptr %261, i64 %263
  %265 = load float, ptr %264, align 4, !tbaa !13
  %266 = fpext float %265 to double
  %267 = load ptr, ptr %9, align 8, !tbaa !5
  %268 = load i32, ptr %7, align 4, !tbaa !9
  %269 = sub nsw i32 %268, 1
  %270 = sext i32 %269 to i64
  %271 = getelementptr inbounds ptr, ptr %267, i64 %270
  %272 = load ptr, ptr %271, align 8, !tbaa !5
  %273 = load i32, ptr %8, align 4, !tbaa !9
  %274 = sext i32 %273 to i64
  %275 = getelementptr inbounds float, ptr %272, i64 %274
  %276 = load float, ptr %275, align 4, !tbaa !13
  %277 = fpext float %276 to double
  %278 = fmul double 3.170000e-01, %277
  %279 = fneg double %278
  %280 = call double @llvm.fmuladd.f64(double 5.600000e-01, double %266, double %279)
  %281 = load ptr, ptr %9, align 8, !tbaa !5
  %282 = load i32, ptr %7, align 4, !tbaa !9
  %283 = sext i32 %282 to i64
  %284 = getelementptr inbounds ptr, ptr %281, i64 %283
  %285 = load ptr, ptr %284, align 8, !tbaa !5
  %286 = load i32, ptr %8, align 4, !tbaa !9
  %287 = sext i32 %286 to i64
  %288 = getelementptr inbounds float, ptr %285, i64 %287
  %289 = load float, ptr %288, align 4, !tbaa !13
  %290 = fpext float %289 to double
  %291 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %290, double %280)
  %292 = load ptr, ptr %9, align 8, !tbaa !5
  %293 = load i32, ptr %7, align 4, !tbaa !9
  %294 = add nsw i32 %293, 1
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds ptr, ptr %292, i64 %295
  %297 = load ptr, ptr %296, align 8, !tbaa !5
  %298 = load i32, ptr %8, align 4, !tbaa !9
  %299 = sext i32 %298 to i64
  %300 = getelementptr inbounds float, ptr %297, i64 %299
  %301 = load float, ptr %300, align 4, !tbaa !13
  %302 = fpext float %301 to double
  %303 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %302, double %291)
  %304 = load ptr, ptr %9, align 8, !tbaa !5
  %305 = load i32, ptr %7, align 4, !tbaa !9
  %306 = add nsw i32 %305, 3
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds ptr, ptr %304, i64 %307
  %309 = load ptr, ptr %308, align 8, !tbaa !5
  %310 = load i32, ptr %8, align 4, !tbaa !9
  %311 = sext i32 %310 to i64
  %312 = getelementptr inbounds float, ptr %309, i64 %311
  %313 = load float, ptr %312, align 4, !tbaa !13
  %314 = fpext float %313 to double
  %315 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %314, double %303)
  %316 = load ptr, ptr %9, align 8, !tbaa !5
  %317 = load i32, ptr %7, align 4, !tbaa !9
  %318 = add nsw i32 %317, 4
  %319 = sext i32 %318 to i64
  %320 = getelementptr inbounds ptr, ptr %316, i64 %319
  %321 = load ptr, ptr %320, align 8, !tbaa !5
  %322 = load i32, ptr %8, align 4, !tbaa !9
  %323 = sext i32 %322 to i64
  %324 = getelementptr inbounds float, ptr %321, i64 %323
  %325 = load float, ptr %324, align 4, !tbaa !13
  %326 = fpext float %325 to double
  %327 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %326, double %315)
  %328 = load ptr, ptr %9, align 8, !tbaa !5
  %329 = load i32, ptr %7, align 4, !tbaa !9
  %330 = add nsw i32 %329, 5
  %331 = sext i32 %330 to i64
  %332 = getelementptr inbounds ptr, ptr %328, i64 %331
  %333 = load ptr, ptr %332, align 8, !tbaa !5
  %334 = load i32, ptr %8, align 4, !tbaa !9
  %335 = sext i32 %334 to i64
  %336 = getelementptr inbounds float, ptr %333, i64 %335
  %337 = load float, ptr %336, align 4, !tbaa !13
  %338 = fpext float %337 to double
  %339 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %338, double %327)
  %340 = fptrunc double %339 to float
  %341 = load ptr, ptr %10, align 8, !tbaa !5
  %342 = load i32, ptr %7, align 4, !tbaa !9
  %343 = sext i32 %342 to i64
  %344 = getelementptr inbounds ptr, ptr %341, i64 %343
  %345 = load ptr, ptr %344, align 8, !tbaa !5
  %346 = load i32, ptr %8, align 4, !tbaa !9
  %347 = sext i32 %346 to i64
  %348 = getelementptr inbounds float, ptr %345, i64 %347
  store float %340, ptr %348, align 4, !tbaa !13
  store i32 2, ptr %7, align 4, !tbaa !9
  %349 = load ptr, ptr %9, align 8, !tbaa !5
  %350 = load i32, ptr %7, align 4, !tbaa !9
  %351 = sub nsw i32 %350, 2
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds ptr, ptr %349, i64 %352
  %354 = load ptr, ptr %353, align 8, !tbaa !5
  %355 = load i32, ptr %8, align 4, !tbaa !9
  %356 = sext i32 %355 to i64
  %357 = getelementptr inbounds float, ptr %354, i64 %356
  %358 = load float, ptr %357, align 4, !tbaa !13
  %359 = fpext float %358 to double
  %360 = load ptr, ptr %9, align 8, !tbaa !5
  %361 = load i32, ptr %7, align 4, !tbaa !9
  %362 = sub nsw i32 %361, 1
  %363 = sext i32 %362 to i64
  %364 = getelementptr inbounds ptr, ptr %360, i64 %363
  %365 = load ptr, ptr %364, align 8, !tbaa !5
  %366 = load i32, ptr %8, align 4, !tbaa !9
  %367 = sext i32 %366 to i64
  %368 = getelementptr inbounds float, ptr %365, i64 %367
  %369 = load float, ptr %368, align 4, !tbaa !13
  %370 = fpext float %369 to double
  %371 = fmul double 3.170000e-01, %370
  %372 = fneg double %371
  %373 = call double @llvm.fmuladd.f64(double 5.600000e-01, double %359, double %372)
  %374 = load ptr, ptr %9, align 8, !tbaa !5
  %375 = load i32, ptr %7, align 4, !tbaa !9
  %376 = sext i32 %375 to i64
  %377 = getelementptr inbounds ptr, ptr %374, i64 %376
  %378 = load ptr, ptr %377, align 8, !tbaa !5
  %379 = load i32, ptr %8, align 4, !tbaa !9
  %380 = sext i32 %379 to i64
  %381 = getelementptr inbounds float, ptr %378, i64 %380
  %382 = load float, ptr %381, align 4, !tbaa !13
  %383 = fpext float %382 to double
  %384 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %383, double %373)
  %385 = load ptr, ptr %9, align 8, !tbaa !5
  %386 = load i32, ptr %7, align 4, !tbaa !9
  %387 = add nsw i32 %386, 1
  %388 = sext i32 %387 to i64
  %389 = getelementptr inbounds ptr, ptr %385, i64 %388
  %390 = load ptr, ptr %389, align 8, !tbaa !5
  %391 = load i32, ptr %8, align 4, !tbaa !9
  %392 = sext i32 %391 to i64
  %393 = getelementptr inbounds float, ptr %390, i64 %392
  %394 = load float, ptr %393, align 4, !tbaa !13
  %395 = fpext float %394 to double
  %396 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %395, double %384)
  %397 = load ptr, ptr %9, align 8, !tbaa !5
  %398 = load i32, ptr %7, align 4, !tbaa !9
  %399 = add nsw i32 %398, 3
  %400 = sext i32 %399 to i64
  %401 = getelementptr inbounds ptr, ptr %397, i64 %400
  %402 = load ptr, ptr %401, align 8, !tbaa !5
  %403 = load i32, ptr %8, align 4, !tbaa !9
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds float, ptr %402, i64 %404
  %406 = load float, ptr %405, align 4, !tbaa !13
  %407 = fpext float %406 to double
  %408 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %407, double %396)
  %409 = load ptr, ptr %9, align 8, !tbaa !5
  %410 = load i32, ptr %7, align 4, !tbaa !9
  %411 = add nsw i32 %410, 4
  %412 = sext i32 %411 to i64
  %413 = getelementptr inbounds ptr, ptr %409, i64 %412
  %414 = load ptr, ptr %413, align 8, !tbaa !5
  %415 = load i32, ptr %8, align 4, !tbaa !9
  %416 = sext i32 %415 to i64
  %417 = getelementptr inbounds float, ptr %414, i64 %416
  %418 = load float, ptr %417, align 4, !tbaa !13
  %419 = fpext float %418 to double
  %420 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %419, double %408)
  %421 = load ptr, ptr %9, align 8, !tbaa !5
  %422 = load i32, ptr %7, align 4, !tbaa !9
  %423 = add nsw i32 %422, 5
  %424 = sext i32 %423 to i64
  %425 = getelementptr inbounds ptr, ptr %421, i64 %424
  %426 = load ptr, ptr %425, align 8, !tbaa !5
  %427 = load i32, ptr %8, align 4, !tbaa !9
  %428 = sext i32 %427 to i64
  %429 = getelementptr inbounds float, ptr %426, i64 %428
  %430 = load float, ptr %429, align 4, !tbaa !13
  %431 = fpext float %430 to double
  %432 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %431, double %420)
  %433 = fptrunc double %432 to float
  %434 = load ptr, ptr %10, align 8, !tbaa !5
  %435 = load i32, ptr %7, align 4, !tbaa !9
  %436 = sext i32 %435 to i64
  %437 = getelementptr inbounds ptr, ptr %434, i64 %436
  %438 = load ptr, ptr %437, align 8, !tbaa !5
  %439 = load i32, ptr %8, align 4, !tbaa !9
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds float, ptr %438, i64 %440
  store float %433, ptr %441, align 4, !tbaa !13
  store i32 1, ptr %7, align 4, !tbaa !9
  %442 = load ptr, ptr %9, align 8, !tbaa !5
  %443 = load i32, ptr %7, align 4, !tbaa !9
  %444 = sub nsw i32 %443, 1
  %445 = sext i32 %444 to i64
  %446 = getelementptr inbounds ptr, ptr %442, i64 %445
  %447 = load ptr, ptr %446, align 8, !tbaa !5
  %448 = load i32, ptr %8, align 4, !tbaa !9
  %449 = sext i32 %448 to i64
  %450 = getelementptr inbounds float, ptr %447, i64 %449
  %451 = load float, ptr %450, align 4, !tbaa !13
  %452 = fpext float %451 to double
  %453 = load ptr, ptr %9, align 8, !tbaa !5
  %454 = load i32, ptr %7, align 4, !tbaa !9
  %455 = sext i32 %454 to i64
  %456 = getelementptr inbounds ptr, ptr %453, i64 %455
  %457 = load ptr, ptr %456, align 8, !tbaa !5
  %458 = load i32, ptr %8, align 4, !tbaa !9
  %459 = sext i32 %458 to i64
  %460 = getelementptr inbounds float, ptr %457, i64 %459
  %461 = load float, ptr %460, align 4, !tbaa !13
  %462 = fpext float %461 to double
  %463 = fmul double 4.850000e-01, %462
  %464 = fneg double %463
  %465 = call double @llvm.fmuladd.f64(double 2.430000e-01, double %452, double %464)
  %466 = load ptr, ptr %9, align 8, !tbaa !5
  %467 = load i32, ptr %7, align 4, !tbaa !9
  %468 = add nsw i32 %467, 1
  %469 = sext i32 %468 to i64
  %470 = getelementptr inbounds ptr, ptr %466, i64 %469
  %471 = load ptr, ptr %470, align 8, !tbaa !5
  %472 = load i32, ptr %8, align 4, !tbaa !9
  %473 = sext i32 %472 to i64
  %474 = getelementptr inbounds float, ptr %471, i64 %473
  %475 = load float, ptr %474, align 4, !tbaa !13
  %476 = fpext float %475 to double
  %477 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %476, double %465)
  %478 = load ptr, ptr %9, align 8, !tbaa !5
  %479 = load i32, ptr %7, align 4, !tbaa !9
  %480 = add nsw i32 %479, 3
  %481 = sext i32 %480 to i64
  %482 = getelementptr inbounds ptr, ptr %478, i64 %481
  %483 = load ptr, ptr %482, align 8, !tbaa !5
  %484 = load i32, ptr %8, align 4, !tbaa !9
  %485 = sext i32 %484 to i64
  %486 = getelementptr inbounds float, ptr %483, i64 %485
  %487 = load float, ptr %486, align 4, !tbaa !13
  %488 = fpext float %487 to double
  %489 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %488, double %477)
  %490 = load ptr, ptr %9, align 8, !tbaa !5
  %491 = load i32, ptr %7, align 4, !tbaa !9
  %492 = add nsw i32 %491, 4
  %493 = sext i32 %492 to i64
  %494 = getelementptr inbounds ptr, ptr %490, i64 %493
  %495 = load ptr, ptr %494, align 8, !tbaa !5
  %496 = load i32, ptr %8, align 4, !tbaa !9
  %497 = sext i32 %496 to i64
  %498 = getelementptr inbounds float, ptr %495, i64 %497
  %499 = load float, ptr %498, align 4, !tbaa !13
  %500 = fpext float %499 to double
  %501 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %500, double %489)
  %502 = load ptr, ptr %9, align 8, !tbaa !5
  %503 = load i32, ptr %7, align 4, !tbaa !9
  %504 = add nsw i32 %503, 5
  %505 = sext i32 %504 to i64
  %506 = getelementptr inbounds ptr, ptr %502, i64 %505
  %507 = load ptr, ptr %506, align 8, !tbaa !5
  %508 = load i32, ptr %8, align 4, !tbaa !9
  %509 = sext i32 %508 to i64
  %510 = getelementptr inbounds float, ptr %507, i64 %509
  %511 = load float, ptr %510, align 4, !tbaa !13
  %512 = fpext float %511 to double
  %513 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %512, double %501)
  %514 = fptrunc double %513 to float
  %515 = load ptr, ptr %10, align 8, !tbaa !5
  %516 = load i32, ptr %7, align 4, !tbaa !9
  %517 = sext i32 %516 to i64
  %518 = getelementptr inbounds ptr, ptr %515, i64 %517
  %519 = load ptr, ptr %518, align 8, !tbaa !5
  %520 = load i32, ptr %8, align 4, !tbaa !9
  %521 = sext i32 %520 to i64
  %522 = getelementptr inbounds float, ptr %519, i64 %521
  store float %514, ptr %522, align 4, !tbaa !13
  store i32 0, ptr %7, align 4, !tbaa !9
  %523 = load ptr, ptr %9, align 8, !tbaa !5
  %524 = load i32, ptr %7, align 4, !tbaa !9
  %525 = sext i32 %524 to i64
  %526 = getelementptr inbounds ptr, ptr %523, i64 %525
  %527 = load ptr, ptr %526, align 8, !tbaa !5
  %528 = load i32, ptr %8, align 4, !tbaa !9
  %529 = sext i32 %528 to i64
  %530 = getelementptr inbounds float, ptr %527, i64 %529
  %531 = load float, ptr %530, align 4, !tbaa !13
  %532 = fpext float %531 to double
  %533 = load ptr, ptr %9, align 8, !tbaa !5
  %534 = load i32, ptr %7, align 4, !tbaa !9
  %535 = add nsw i32 %534, 1
  %536 = sext i32 %535 to i64
  %537 = getelementptr inbounds ptr, ptr %533, i64 %536
  %538 = load ptr, ptr %537, align 8, !tbaa !5
  %539 = load i32, ptr %8, align 4, !tbaa !9
  %540 = sext i32 %539 to i64
  %541 = getelementptr inbounds float, ptr %538, i64 %540
  %542 = load float, ptr %541, align 4, !tbaa !13
  %543 = fpext float %542 to double
  %544 = fmul double 3.170000e-01, %543
  %545 = fneg double %544
  %546 = call double @llvm.fmuladd.f64(double -2.430000e-01, double %532, double %545)
  %547 = load ptr, ptr %9, align 8, !tbaa !5
  %548 = load i32, ptr %7, align 4, !tbaa !9
  %549 = add nsw i32 %548, 3
  %550 = sext i32 %549 to i64
  %551 = getelementptr inbounds ptr, ptr %547, i64 %550
  %552 = load ptr, ptr %551, align 8, !tbaa !5
  %553 = load i32, ptr %8, align 4, !tbaa !9
  %554 = sext i32 %553 to i64
  %555 = getelementptr inbounds float, ptr %552, i64 %554
  %556 = load float, ptr %555, align 4, !tbaa !13
  %557 = fpext float %556 to double
  %558 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %557, double %546)
  %559 = load ptr, ptr %9, align 8, !tbaa !5
  %560 = load i32, ptr %7, align 4, !tbaa !9
  %561 = add nsw i32 %560, 4
  %562 = sext i32 %561 to i64
  %563 = getelementptr inbounds ptr, ptr %559, i64 %562
  %564 = load ptr, ptr %563, align 8, !tbaa !5
  %565 = load i32, ptr %8, align 4, !tbaa !9
  %566 = sext i32 %565 to i64
  %567 = getelementptr inbounds float, ptr %564, i64 %566
  %568 = load float, ptr %567, align 4, !tbaa !13
  %569 = fpext float %568 to double
  %570 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %569, double %558)
  %571 = load ptr, ptr %9, align 8, !tbaa !5
  %572 = load i32, ptr %7, align 4, !tbaa !9
  %573 = add nsw i32 %572, 5
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds ptr, ptr %571, i64 %574
  %576 = load ptr, ptr %575, align 8, !tbaa !5
  %577 = load i32, ptr %8, align 4, !tbaa !9
  %578 = sext i32 %577 to i64
  %579 = getelementptr inbounds float, ptr %576, i64 %578
  %580 = load float, ptr %579, align 4, !tbaa !13
  %581 = fpext float %580 to double
  %582 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %581, double %570)
  %583 = fptrunc double %582 to float
  %584 = load ptr, ptr %10, align 8, !tbaa !5
  %585 = load i32, ptr %7, align 4, !tbaa !9
  %586 = sext i32 %585 to i64
  %587 = getelementptr inbounds ptr, ptr %584, i64 %586
  %588 = load ptr, ptr %587, align 8, !tbaa !5
  %589 = load i32, ptr %8, align 4, !tbaa !9
  %590 = sext i32 %589 to i64
  %591 = getelementptr inbounds float, ptr %588, i64 %590
  store float %583, ptr %591, align 4, !tbaa !13
  %592 = load i32, ptr %5, align 4, !tbaa !9
  %593 = sub nsw i32 %592, 5
  store i32 %593, ptr %7, align 4, !tbaa !9
  %594 = load ptr, ptr %9, align 8, !tbaa !5
  %595 = load i32, ptr %7, align 4, !tbaa !9
  %596 = sub nsw i32 %595, 5
  %597 = sext i32 %596 to i64
  %598 = getelementptr inbounds ptr, ptr %594, i64 %597
  %599 = load ptr, ptr %598, align 8, !tbaa !5
  %600 = load i32, ptr %8, align 4, !tbaa !9
  %601 = sext i32 %600 to i64
  %602 = getelementptr inbounds float, ptr %599, i64 %601
  %603 = load float, ptr %602, align 4, !tbaa !13
  %604 = fpext float %603 to double
  %605 = load ptr, ptr %9, align 8, !tbaa !5
  %606 = load i32, ptr %7, align 4, !tbaa !9
  %607 = sub nsw i32 %606, 4
  %608 = sext i32 %607 to i64
  %609 = getelementptr inbounds ptr, ptr %605, i64 %608
  %610 = load ptr, ptr %609, align 8, !tbaa !5
  %611 = load i32, ptr %8, align 4, !tbaa !9
  %612 = sext i32 %611 to i64
  %613 = getelementptr inbounds float, ptr %610, i64 %612
  %614 = load float, ptr %613, align 4, !tbaa !13
  %615 = fpext float %614 to double
  %616 = fmul double 2.160000e-01, %615
  %617 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %604, double %616)
  %618 = load ptr, ptr %9, align 8, !tbaa !5
  %619 = load i32, ptr %7, align 4, !tbaa !9
  %620 = sub nsw i32 %619, 3
  %621 = sext i32 %620 to i64
  %622 = getelementptr inbounds ptr, ptr %618, i64 %621
  %623 = load ptr, ptr %622, align 8, !tbaa !5
  %624 = load i32, ptr %8, align 4, !tbaa !9
  %625 = sext i32 %624 to i64
  %626 = getelementptr inbounds float, ptr %623, i64 %625
  %627 = load float, ptr %626, align 4, !tbaa !13
  %628 = fpext float %627 to double
  %629 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %628, double %617)
  %630 = load ptr, ptr %9, align 8, !tbaa !5
  %631 = load i32, ptr %7, align 4, !tbaa !9
  %632 = sub nsw i32 %631, 1
  %633 = sext i32 %632 to i64
  %634 = getelementptr inbounds ptr, ptr %630, i64 %633
  %635 = load ptr, ptr %634, align 8, !tbaa !5
  %636 = load i32, ptr %8, align 4, !tbaa !9
  %637 = sext i32 %636 to i64
  %638 = getelementptr inbounds float, ptr %635, i64 %637
  %639 = load float, ptr %638, align 4, !tbaa !13
  %640 = fpext float %639 to double
  %641 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %640, double %629)
  %642 = load ptr, ptr %9, align 8, !tbaa !5
  %643 = load i32, ptr %7, align 4, !tbaa !9
  %644 = sext i32 %643 to i64
  %645 = getelementptr inbounds ptr, ptr %642, i64 %644
  %646 = load ptr, ptr %645, align 8, !tbaa !5
  %647 = load i32, ptr %8, align 4, !tbaa !9
  %648 = sext i32 %647 to i64
  %649 = getelementptr inbounds float, ptr %646, i64 %648
  %650 = load float, ptr %649, align 4, !tbaa !13
  %651 = fpext float %650 to double
  %652 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %651, double %641)
  %653 = load ptr, ptr %9, align 8, !tbaa !5
  %654 = load i32, ptr %7, align 4, !tbaa !9
  %655 = add nsw i32 %654, 1
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds ptr, ptr %653, i64 %656
  %658 = load ptr, ptr %657, align 8, !tbaa !5
  %659 = load i32, ptr %8, align 4, !tbaa !9
  %660 = sext i32 %659 to i64
  %661 = getelementptr inbounds float, ptr %658, i64 %660
  %662 = load float, ptr %661, align 4, !tbaa !13
  %663 = fpext float %662 to double
  %664 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %663, double %652)
  %665 = load ptr, ptr %9, align 8, !tbaa !5
  %666 = load i32, ptr %7, align 4, !tbaa !9
  %667 = add nsw i32 %666, 3
  %668 = sext i32 %667 to i64
  %669 = getelementptr inbounds ptr, ptr %665, i64 %668
  %670 = load ptr, ptr %669, align 8, !tbaa !5
  %671 = load i32, ptr %8, align 4, !tbaa !9
  %672 = sext i32 %671 to i64
  %673 = getelementptr inbounds float, ptr %670, i64 %672
  %674 = load float, ptr %673, align 4, !tbaa !13
  %675 = fpext float %674 to double
  %676 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %675, double %664)
  %677 = load ptr, ptr %9, align 8, !tbaa !5
  %678 = load i32, ptr %7, align 4, !tbaa !9
  %679 = add nsw i32 %678, 4
  %680 = sext i32 %679 to i64
  %681 = getelementptr inbounds ptr, ptr %677, i64 %680
  %682 = load ptr, ptr %681, align 8, !tbaa !5
  %683 = load i32, ptr %8, align 4, !tbaa !9
  %684 = sext i32 %683 to i64
  %685 = getelementptr inbounds float, ptr %682, i64 %684
  %686 = load float, ptr %685, align 4, !tbaa !13
  %687 = fpext float %686 to double
  %688 = call double @llvm.fmuladd.f64(double 3.440000e-01, double %687, double %676)
  %689 = fptrunc double %688 to float
  %690 = load ptr, ptr %10, align 8, !tbaa !5
  %691 = load i32, ptr %7, align 4, !tbaa !9
  %692 = sext i32 %691 to i64
  %693 = getelementptr inbounds ptr, ptr %690, i64 %692
  %694 = load ptr, ptr %693, align 8, !tbaa !5
  %695 = load i32, ptr %8, align 4, !tbaa !9
  %696 = sext i32 %695 to i64
  %697 = getelementptr inbounds float, ptr %694, i64 %696
  store float %689, ptr %697, align 4, !tbaa !13
  %698 = load i32, ptr %5, align 4, !tbaa !9
  %699 = sub nsw i32 %698, 4
  store i32 %699, ptr %7, align 4, !tbaa !9
  %700 = load ptr, ptr %9, align 8, !tbaa !5
  %701 = load i32, ptr %7, align 4, !tbaa !9
  %702 = sub nsw i32 %701, 5
  %703 = sext i32 %702 to i64
  %704 = getelementptr inbounds ptr, ptr %700, i64 %703
  %705 = load ptr, ptr %704, align 8, !tbaa !5
  %706 = load i32, ptr %8, align 4, !tbaa !9
  %707 = sext i32 %706 to i64
  %708 = getelementptr inbounds float, ptr %705, i64 %707
  %709 = load float, ptr %708, align 4, !tbaa !13
  %710 = fpext float %709 to double
  %711 = load ptr, ptr %9, align 8, !tbaa !5
  %712 = load i32, ptr %7, align 4, !tbaa !9
  %713 = sub nsw i32 %712, 4
  %714 = sext i32 %713 to i64
  %715 = getelementptr inbounds ptr, ptr %711, i64 %714
  %716 = load ptr, ptr %715, align 8, !tbaa !5
  %717 = load i32, ptr %8, align 4, !tbaa !9
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds float, ptr %716, i64 %718
  %720 = load float, ptr %719, align 4, !tbaa !13
  %721 = fpext float %720 to double
  %722 = fmul double 2.160000e-01, %721
  %723 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %710, double %722)
  %724 = load ptr, ptr %9, align 8, !tbaa !5
  %725 = load i32, ptr %7, align 4, !tbaa !9
  %726 = sub nsw i32 %725, 3
  %727 = sext i32 %726 to i64
  %728 = getelementptr inbounds ptr, ptr %724, i64 %727
  %729 = load ptr, ptr %728, align 8, !tbaa !5
  %730 = load i32, ptr %8, align 4, !tbaa !9
  %731 = sext i32 %730 to i64
  %732 = getelementptr inbounds float, ptr %729, i64 %731
  %733 = load float, ptr %732, align 4, !tbaa !13
  %734 = fpext float %733 to double
  %735 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %734, double %723)
  %736 = load ptr, ptr %9, align 8, !tbaa !5
  %737 = load i32, ptr %7, align 4, !tbaa !9
  %738 = sub nsw i32 %737, 1
  %739 = sext i32 %738 to i64
  %740 = getelementptr inbounds ptr, ptr %736, i64 %739
  %741 = load ptr, ptr %740, align 8, !tbaa !5
  %742 = load i32, ptr %8, align 4, !tbaa !9
  %743 = sext i32 %742 to i64
  %744 = getelementptr inbounds float, ptr %741, i64 %743
  %745 = load float, ptr %744, align 4, !tbaa !13
  %746 = fpext float %745 to double
  %747 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %746, double %735)
  %748 = load ptr, ptr %9, align 8, !tbaa !5
  %749 = load i32, ptr %7, align 4, !tbaa !9
  %750 = sext i32 %749 to i64
  %751 = getelementptr inbounds ptr, ptr %748, i64 %750
  %752 = load ptr, ptr %751, align 8, !tbaa !5
  %753 = load i32, ptr %8, align 4, !tbaa !9
  %754 = sext i32 %753 to i64
  %755 = getelementptr inbounds float, ptr %752, i64 %754
  %756 = load float, ptr %755, align 4, !tbaa !13
  %757 = fpext float %756 to double
  %758 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %757, double %747)
  %759 = load ptr, ptr %9, align 8, !tbaa !5
  %760 = load i32, ptr %7, align 4, !tbaa !9
  %761 = add nsw i32 %760, 1
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds ptr, ptr %759, i64 %762
  %764 = load ptr, ptr %763, align 8, !tbaa !5
  %765 = load i32, ptr %8, align 4, !tbaa !9
  %766 = sext i32 %765 to i64
  %767 = getelementptr inbounds float, ptr %764, i64 %766
  %768 = load float, ptr %767, align 4, !tbaa !13
  %769 = fpext float %768 to double
  %770 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %769, double %758)
  %771 = load ptr, ptr %9, align 8, !tbaa !5
  %772 = load i32, ptr %7, align 4, !tbaa !9
  %773 = add nsw i32 %772, 3
  %774 = sext i32 %773 to i64
  %775 = getelementptr inbounds ptr, ptr %771, i64 %774
  %776 = load ptr, ptr %775, align 8, !tbaa !5
  %777 = load i32, ptr %8, align 4, !tbaa !9
  %778 = sext i32 %777 to i64
  %779 = getelementptr inbounds float, ptr %776, i64 %778
  %780 = load float, ptr %779, align 4, !tbaa !13
  %781 = fpext float %780 to double
  %782 = call double @llvm.fmuladd.f64(double 5.600000e-01, double %781, double %770)
  %783 = fptrunc double %782 to float
  %784 = load ptr, ptr %10, align 8, !tbaa !5
  %785 = load i32, ptr %7, align 4, !tbaa !9
  %786 = sext i32 %785 to i64
  %787 = getelementptr inbounds ptr, ptr %784, i64 %786
  %788 = load ptr, ptr %787, align 8, !tbaa !5
  %789 = load i32, ptr %8, align 4, !tbaa !9
  %790 = sext i32 %789 to i64
  %791 = getelementptr inbounds float, ptr %788, i64 %790
  store float %783, ptr %791, align 4, !tbaa !13
  %792 = load i32, ptr %5, align 4, !tbaa !9
  %793 = sub nsw i32 %792, 3
  store i32 %793, ptr %7, align 4, !tbaa !9
  %794 = load ptr, ptr %9, align 8, !tbaa !5
  %795 = load i32, ptr %7, align 4, !tbaa !9
  %796 = sub nsw i32 %795, 5
  %797 = sext i32 %796 to i64
  %798 = getelementptr inbounds ptr, ptr %794, i64 %797
  %799 = load ptr, ptr %798, align 8, !tbaa !5
  %800 = load i32, ptr %8, align 4, !tbaa !9
  %801 = sext i32 %800 to i64
  %802 = getelementptr inbounds float, ptr %799, i64 %801
  %803 = load float, ptr %802, align 4, !tbaa !13
  %804 = fpext float %803 to double
  %805 = load ptr, ptr %9, align 8, !tbaa !5
  %806 = load i32, ptr %7, align 4, !tbaa !9
  %807 = sub nsw i32 %806, 4
  %808 = sext i32 %807 to i64
  %809 = getelementptr inbounds ptr, ptr %805, i64 %808
  %810 = load ptr, ptr %809, align 8, !tbaa !5
  %811 = load i32, ptr %8, align 4, !tbaa !9
  %812 = sext i32 %811 to i64
  %813 = getelementptr inbounds float, ptr %810, i64 %812
  %814 = load float, ptr %813, align 4, !tbaa !13
  %815 = fpext float %814 to double
  %816 = fmul double 2.160000e-01, %815
  %817 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %804, double %816)
  %818 = load ptr, ptr %9, align 8, !tbaa !5
  %819 = load i32, ptr %7, align 4, !tbaa !9
  %820 = sub nsw i32 %819, 3
  %821 = sext i32 %820 to i64
  %822 = getelementptr inbounds ptr, ptr %818, i64 %821
  %823 = load ptr, ptr %822, align 8, !tbaa !5
  %824 = load i32, ptr %8, align 4, !tbaa !9
  %825 = sext i32 %824 to i64
  %826 = getelementptr inbounds float, ptr %823, i64 %825
  %827 = load float, ptr %826, align 4, !tbaa !13
  %828 = fpext float %827 to double
  %829 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %828, double %817)
  %830 = load ptr, ptr %9, align 8, !tbaa !5
  %831 = load i32, ptr %7, align 4, !tbaa !9
  %832 = sub nsw i32 %831, 1
  %833 = sext i32 %832 to i64
  %834 = getelementptr inbounds ptr, ptr %830, i64 %833
  %835 = load ptr, ptr %834, align 8, !tbaa !5
  %836 = load i32, ptr %8, align 4, !tbaa !9
  %837 = sext i32 %836 to i64
  %838 = getelementptr inbounds float, ptr %835, i64 %837
  %839 = load float, ptr %838, align 4, !tbaa !13
  %840 = fpext float %839 to double
  %841 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %840, double %829)
  %842 = load ptr, ptr %9, align 8, !tbaa !5
  %843 = load i32, ptr %7, align 4, !tbaa !9
  %844 = sext i32 %843 to i64
  %845 = getelementptr inbounds ptr, ptr %842, i64 %844
  %846 = load ptr, ptr %845, align 8, !tbaa !5
  %847 = load i32, ptr %8, align 4, !tbaa !9
  %848 = sext i32 %847 to i64
  %849 = getelementptr inbounds float, ptr %846, i64 %848
  %850 = load float, ptr %849, align 4, !tbaa !13
  %851 = fpext float %850 to double
  %852 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %851, double %841)
  %853 = load ptr, ptr %9, align 8, !tbaa !5
  %854 = load i32, ptr %7, align 4, !tbaa !9
  %855 = add nsw i32 %854, 1
  %856 = sext i32 %855 to i64
  %857 = getelementptr inbounds ptr, ptr %853, i64 %856
  %858 = load ptr, ptr %857, align 8, !tbaa !5
  %859 = load i32, ptr %8, align 4, !tbaa !9
  %860 = sext i32 %859 to i64
  %861 = getelementptr inbounds float, ptr %858, i64 %860
  %862 = load float, ptr %861, align 4, !tbaa !13
  %863 = fpext float %862 to double
  %864 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %863, double %852)
  %865 = load ptr, ptr %9, align 8, !tbaa !5
  %866 = load i32, ptr %7, align 4, !tbaa !9
  %867 = add nsw i32 %866, 2
  %868 = sext i32 %867 to i64
  %869 = getelementptr inbounds ptr, ptr %865, i64 %868
  %870 = load ptr, ptr %869, align 8, !tbaa !5
  %871 = load i32, ptr %8, align 4, !tbaa !9
  %872 = sext i32 %871 to i64
  %873 = getelementptr inbounds float, ptr %870, i64 %872
  %874 = load float, ptr %873, align 4, !tbaa !13
  %875 = fpext float %874 to double
  %876 = call double @llvm.fmuladd.f64(double 5.600000e-01, double %875, double %864)
  %877 = fptrunc double %876 to float
  %878 = load ptr, ptr %10, align 8, !tbaa !5
  %879 = load i32, ptr %7, align 4, !tbaa !9
  %880 = sext i32 %879 to i64
  %881 = getelementptr inbounds ptr, ptr %878, i64 %880
  %882 = load ptr, ptr %881, align 8, !tbaa !5
  %883 = load i32, ptr %8, align 4, !tbaa !9
  %884 = sext i32 %883 to i64
  %885 = getelementptr inbounds float, ptr %882, i64 %884
  store float %877, ptr %885, align 4, !tbaa !13
  %886 = load i32, ptr %5, align 4, !tbaa !9
  %887 = sub nsw i32 %886, 2
  store i32 %887, ptr %7, align 4, !tbaa !9
  %888 = load ptr, ptr %9, align 8, !tbaa !5
  %889 = load i32, ptr %7, align 4, !tbaa !9
  %890 = sub nsw i32 %889, 5
  %891 = sext i32 %890 to i64
  %892 = getelementptr inbounds ptr, ptr %888, i64 %891
  %893 = load ptr, ptr %892, align 8, !tbaa !5
  %894 = load i32, ptr %8, align 4, !tbaa !9
  %895 = sext i32 %894 to i64
  %896 = getelementptr inbounds float, ptr %893, i64 %895
  %897 = load float, ptr %896, align 4, !tbaa !13
  %898 = fpext float %897 to double
  %899 = load ptr, ptr %9, align 8, !tbaa !5
  %900 = load i32, ptr %7, align 4, !tbaa !9
  %901 = sub nsw i32 %900, 4
  %902 = sext i32 %901 to i64
  %903 = getelementptr inbounds ptr, ptr %899, i64 %902
  %904 = load ptr, ptr %903, align 8, !tbaa !5
  %905 = load i32, ptr %8, align 4, !tbaa !9
  %906 = sext i32 %905 to i64
  %907 = getelementptr inbounds float, ptr %904, i64 %906
  %908 = load float, ptr %907, align 4, !tbaa !13
  %909 = fpext float %908 to double
  %910 = fmul double 2.160000e-01, %909
  %911 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %898, double %910)
  %912 = load ptr, ptr %9, align 8, !tbaa !5
  %913 = load i32, ptr %7, align 4, !tbaa !9
  %914 = sub nsw i32 %913, 3
  %915 = sext i32 %914 to i64
  %916 = getelementptr inbounds ptr, ptr %912, i64 %915
  %917 = load ptr, ptr %916, align 8, !tbaa !5
  %918 = load i32, ptr %8, align 4, !tbaa !9
  %919 = sext i32 %918 to i64
  %920 = getelementptr inbounds float, ptr %917, i64 %919
  %921 = load float, ptr %920, align 4, !tbaa !13
  %922 = fpext float %921 to double
  %923 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %922, double %911)
  %924 = load ptr, ptr %9, align 8, !tbaa !5
  %925 = load i32, ptr %7, align 4, !tbaa !9
  %926 = sub nsw i32 %925, 1
  %927 = sext i32 %926 to i64
  %928 = getelementptr inbounds ptr, ptr %924, i64 %927
  %929 = load ptr, ptr %928, align 8, !tbaa !5
  %930 = load i32, ptr %8, align 4, !tbaa !9
  %931 = sext i32 %930 to i64
  %932 = getelementptr inbounds float, ptr %929, i64 %931
  %933 = load float, ptr %932, align 4, !tbaa !13
  %934 = fpext float %933 to double
  %935 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %934, double %923)
  %936 = load ptr, ptr %9, align 8, !tbaa !5
  %937 = load i32, ptr %7, align 4, !tbaa !9
  %938 = sext i32 %937 to i64
  %939 = getelementptr inbounds ptr, ptr %936, i64 %938
  %940 = load ptr, ptr %939, align 8, !tbaa !5
  %941 = load i32, ptr %8, align 4, !tbaa !9
  %942 = sext i32 %941 to i64
  %943 = getelementptr inbounds float, ptr %940, i64 %942
  %944 = load float, ptr %943, align 4, !tbaa !13
  %945 = fpext float %944 to double
  %946 = call double @llvm.fmuladd.f64(double -4.850000e-01, double %945, double %935)
  %947 = load ptr, ptr %9, align 8, !tbaa !5
  %948 = load i32, ptr %7, align 4, !tbaa !9
  %949 = add nsw i32 %948, 1
  %950 = sext i32 %949 to i64
  %951 = getelementptr inbounds ptr, ptr %947, i64 %950
  %952 = load ptr, ptr %951, align 8, !tbaa !5
  %953 = load i32, ptr %8, align 4, !tbaa !9
  %954 = sext i32 %953 to i64
  %955 = getelementptr inbounds float, ptr %952, i64 %954
  %956 = load float, ptr %955, align 4, !tbaa !13
  %957 = fpext float %956 to double
  %958 = call double @llvm.fmuladd.f64(double 2.430000e-01, double %957, double %946)
  %959 = fptrunc double %958 to float
  %960 = load ptr, ptr %10, align 8, !tbaa !5
  %961 = load i32, ptr %7, align 4, !tbaa !9
  %962 = sext i32 %961 to i64
  %963 = getelementptr inbounds ptr, ptr %960, i64 %962
  %964 = load ptr, ptr %963, align 8, !tbaa !5
  %965 = load i32, ptr %8, align 4, !tbaa !9
  %966 = sext i32 %965 to i64
  %967 = getelementptr inbounds float, ptr %964, i64 %966
  store float %959, ptr %967, align 4, !tbaa !13
  %968 = load i32, ptr %5, align 4, !tbaa !9
  %969 = sub nsw i32 %968, 1
  store i32 %969, ptr %7, align 4, !tbaa !9
  %970 = load ptr, ptr %9, align 8, !tbaa !5
  %971 = load i32, ptr %7, align 4, !tbaa !9
  %972 = sub nsw i32 %971, 5
  %973 = sext i32 %972 to i64
  %974 = getelementptr inbounds ptr, ptr %970, i64 %973
  %975 = load ptr, ptr %974, align 8, !tbaa !5
  %976 = load i32, ptr %8, align 4, !tbaa !9
  %977 = sext i32 %976 to i64
  %978 = getelementptr inbounds float, ptr %975, i64 %977
  %979 = load float, ptr %978, align 4, !tbaa !13
  %980 = fpext float %979 to double
  %981 = load ptr, ptr %9, align 8, !tbaa !5
  %982 = load i32, ptr %7, align 4, !tbaa !9
  %983 = sub nsw i32 %982, 4
  %984 = sext i32 %983 to i64
  %985 = getelementptr inbounds ptr, ptr %981, i64 %984
  %986 = load ptr, ptr %985, align 8, !tbaa !5
  %987 = load i32, ptr %8, align 4, !tbaa !9
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds float, ptr %986, i64 %988
  %990 = load float, ptr %989, align 4, !tbaa !13
  %991 = fpext float %990 to double
  %992 = fmul double 2.160000e-01, %991
  %993 = call double @llvm.fmuladd.f64(double 1.280000e-01, double %980, double %992)
  %994 = load ptr, ptr %9, align 8, !tbaa !5
  %995 = load i32, ptr %7, align 4, !tbaa !9
  %996 = sub nsw i32 %995, 3
  %997 = sext i32 %996 to i64
  %998 = getelementptr inbounds ptr, ptr %994, i64 %997
  %999 = load ptr, ptr %998, align 8, !tbaa !5
  %1000 = load i32, ptr %8, align 4, !tbaa !9
  %1001 = sext i32 %1000 to i64
  %1002 = getelementptr inbounds float, ptr %999, i64 %1001
  %1003 = load float, ptr %1002, align 4, !tbaa !13
  %1004 = fpext float %1003 to double
  %1005 = call double @llvm.fmuladd.f64(double 2.160000e-01, double %1004, double %993)
  %1006 = load ptr, ptr %9, align 8, !tbaa !5
  %1007 = load i32, ptr %7, align 4, !tbaa !9
  %1008 = sub nsw i32 %1007, 1
  %1009 = sext i32 %1008 to i64
  %1010 = getelementptr inbounds ptr, ptr %1006, i64 %1009
  %1011 = load ptr, ptr %1010, align 8, !tbaa !5
  %1012 = load i32, ptr %8, align 4, !tbaa !9
  %1013 = sext i32 %1012 to i64
  %1014 = getelementptr inbounds float, ptr %1011, i64 %1013
  %1015 = load float, ptr %1014, align 4, !tbaa !13
  %1016 = fpext float %1015 to double
  %1017 = call double @llvm.fmuladd.f64(double -3.170000e-01, double %1016, double %1005)
  %1018 = load ptr, ptr %9, align 8, !tbaa !5
  %1019 = load i32, ptr %7, align 4, !tbaa !9
  %1020 = sext i32 %1019 to i64
  %1021 = getelementptr inbounds ptr, ptr %1018, i64 %1020
  %1022 = load ptr, ptr %1021, align 8, !tbaa !5
  %1023 = load i32, ptr %8, align 4, !tbaa !9
  %1024 = sext i32 %1023 to i64
  %1025 = getelementptr inbounds float, ptr %1022, i64 %1024
  %1026 = load float, ptr %1025, align 4, !tbaa !13
  %1027 = fpext float %1026 to double
  %1028 = call double @llvm.fmuladd.f64(double -2.430000e-01, double %1027, double %1017)
  %1029 = fptrunc double %1028 to float
  %1030 = load ptr, ptr %10, align 8, !tbaa !5
  %1031 = load i32, ptr %7, align 4, !tbaa !9
  %1032 = sext i32 %1031 to i64
  %1033 = getelementptr inbounds ptr, ptr %1030, i64 %1032
  %1034 = load ptr, ptr %1033, align 8, !tbaa !5
  %1035 = load i32, ptr %8, align 4, !tbaa !9
  %1036 = sext i32 %1035 to i64
  %1037 = getelementptr inbounds float, ptr %1034, i64 %1036
  store float %1029, ptr %1037, align 4, !tbaa !13
  br label %1038

1038:                                             ; preds = %151
  %1039 = load i32, ptr %8, align 4, !tbaa !9
  %1040 = add nsw i32 %1039, 1
  store i32 %1040, ptr %8, align 4, !tbaa !9
  br label %21, !llvm.loop !17

1041:                                             ; preds = %21
  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
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 #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}


; 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: inlinehint mustprogress nounwind uwtable
declare dso_local noundef i32 @_ZNK12ImageContent1yEv(ptr noundef nonnull align 8 dereferenceable(80)) local_unnamed_addr #0 align 2

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

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

; Function Attrs: mustprogress nounwind uwtable
define dso_local void @_Z7DerYYV9P12ImageContentS0_(ptr noundef nonnull %0, ptr nocapture noundef readonly %1) local_unnamed_addr #2 {
  %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 %4, 0
  br i1 %9, label %.preheader.lr.ph, label %._crit_edge276

.preheader.lr.ph:                                 ; preds = %2
  %10 = add i32 %3, -5
  %11 = icmp sgt i32 %3, 10
  %12 = load ptr, ptr %6, align 8, !tbaa !11
  %13 = getelementptr inbounds i8, ptr %6, i64 8
  %14 = load ptr, ptr %13, align 8, !tbaa !11
  %15 = getelementptr inbounds i8, ptr %6, i64 24
  %16 = load ptr, ptr %15, align 8, !tbaa !11
  %17 = getelementptr inbounds i8, ptr %6, i64 32
  %18 = load ptr, ptr %17, align 8, !tbaa !11
  %19 = getelementptr i8, ptr %6, i64 40
  %20 = load ptr, ptr %19, align 8, !tbaa !11
  %21 = getelementptr inbounds i8, ptr %6, i64 56
  %22 = load ptr, ptr %21, align 8, !tbaa !11
  %23 = getelementptr inbounds i8, ptr %6, i64 64
  %24 = load ptr, ptr %23, align 8, !tbaa !11
  %25 = getelementptr inbounds i8, ptr %6, i64 72
  %26 = load ptr, ptr %25, align 8, !tbaa !11
  %27 = getelementptr inbounds i8, ptr %8, i64 32
  %28 = load ptr, ptr %27, align 8, !tbaa !11
  %29 = getelementptr inbounds i8, ptr %6, i64 16
  %30 = load ptr, ptr %29, align 8, !tbaa !11
  %31 = getelementptr inbounds i8, ptr %6, i64 48
  %32 = load ptr, ptr %31, align 8, !tbaa !11
  %33 = getelementptr inbounds i8, ptr %8, i64 24
  %34 = load ptr, ptr %33, align 8, !tbaa !11
  %35 = getelementptr inbounds i8, ptr %8, i64 16
  %36 = load ptr, ptr %35, align 8, !tbaa !11
  %37 = getelementptr inbounds i8, ptr %8, i64 8
  %38 = load ptr, ptr %37, align 8, !tbaa !11
  %39 = load ptr, ptr %8, align 8, !tbaa !11
  %40 = sext i32 %3 to i64
  %41 = getelementptr ptr, ptr %6, i64 %40
  %42 = getelementptr i8, ptr %41, i64 -80
  %43 = load ptr, ptr %42, align 8, !tbaa !11
  %44 = getelementptr i8, ptr %41, i64 -72
  %45 = load ptr, ptr %44, align 8, !tbaa !11
  %46 = getelementptr i8, ptr %41, i64 -64
  %47 = load ptr, ptr %46, align 8, !tbaa !11
  %48 = getelementptr i8, ptr %41, i64 -48
  %49 = load ptr, ptr %48, align 8, !tbaa !11
  %50 = sext i32 %10 to i64
  %51 = getelementptr inbounds ptr, ptr %6, i64 %50
  %52 = load ptr, ptr %51, align 8, !tbaa !11
  %53 = getelementptr i8, ptr %41, i64 -32
  %54 = load ptr, ptr %53, align 8, !tbaa !11
  %55 = getelementptr i8, ptr %41, i64 -16
  %56 = load ptr, ptr %55, align 8, !tbaa !11
  %57 = getelementptr i8, ptr %41, i64 -8
  %58 = load ptr, ptr %57, align 8, !tbaa !11
  %59 = getelementptr inbounds ptr, ptr %8, i64 %50
  %60 = load ptr, ptr %59, align 8, !tbaa !11
  %61 = getelementptr i8, ptr %41, i64 -56
  %62 = load ptr, ptr %61, align 8, !tbaa !11
  %63 = getelementptr i8, ptr %41, i64 -40
  %64 = load ptr, ptr %63, align 8, !tbaa !11
  %65 = getelementptr i8, ptr %41, i64 -24
  %66 = load ptr, ptr %65, align 8, !tbaa !11
  %67 = sext i32 %3 to i64
  %68 = getelementptr ptr, ptr %8, i64 %67
  %69 = getelementptr i8, ptr %68, i64 -32
  %70 = load ptr, ptr %69, align 8, !tbaa !11
  %71 = sext i32 %3 to i64
  %72 = getelementptr ptr, ptr %8, i64 %71
  %73 = getelementptr i8, ptr %72, i64 -24
  %74 = load ptr, ptr %73, align 8, !tbaa !11
  %75 = sext i32 %3 to i64
  %76 = getelementptr ptr, ptr %8, i64 %75
  %77 = getelementptr i8, ptr %76, i64 -16
  %78 = load ptr, ptr %77, align 8, !tbaa !11
  %79 = sext i32 %3 to i64
  %80 = getelementptr ptr, ptr %8, i64 %79
  %81 = getelementptr i8, ptr %80, i64 -8
  %82 = load ptr, ptr %81, align 8, !tbaa !11
  %wide.trip.count281 = zext nneg i32 %4 to i64
  %wide.trip.count = zext nneg i32 %10 to i64
  br label %.preheader

.preheader:                                       ; preds = %.preheader.lr.ph, %._crit_edge
  %indvars.iv278 = phi i64 [ 0, %.preheader.lr.ph ], [ %indvars.iv.next279, %._crit_edge ]
  br i1 %11, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %.preheader
  %.pre = load ptr, ptr %19, align 8, !tbaa !11
  br label %83

83:                                               ; preds = %.lr.ph, %83
  %84 = phi ptr [ %.pre, %.lr.ph ], [ %115, %83 ]
  %indvars.iv = phi i64 [ 5, %.lr.ph ], [ %indvars.iv.next, %83 ]
  %85 = getelementptr ptr, ptr %6, i64 %indvars.iv
  %86 = getelementptr i8, ptr %85, i64 -40
  %87 = load ptr, ptr %86, align 8, !tbaa !11
  %88 = getelementptr inbounds float, ptr %87, i64 %indvars.iv278
  %89 = load float, ptr %88, align 4, !tbaa !12
  %90 = fpext float %89 to double
  %91 = getelementptr i8, ptr %85, i64 -32
  %92 = load ptr, ptr %91, align 8, !tbaa !11
  %93 = getelementptr inbounds float, ptr %92, i64 %indvars.iv278
  %94 = load float, ptr %93, align 4, !tbaa !12
  %95 = fpext float %94 to double
  %96 = fmul double %95, 2.160000e-01
  %97 = tail call double @llvm.fmuladd.f64(double %90, double 1.280000e-01, double %96)
  %98 = getelementptr i8, ptr %85, i64 -24
  %99 = load ptr, ptr %98, align 8, !tbaa !11
  %100 = getelementptr inbounds float, ptr %99, i64 %indvars.iv278
  %101 = load float, ptr %100, align 4, !tbaa !12
  %102 = fpext float %101 to double
  %103 = tail call double @llvm.fmuladd.f64(double %102, double 2.160000e-01, double %97)
  %104 = getelementptr i8, ptr %85, i64 -8
  %105 = load ptr, ptr %104, align 8, !tbaa !11
  %106 = getelementptr inbounds float, ptr %105, i64 %indvars.iv278
  %107 = load float, ptr %106, align 4, !tbaa !12
  %108 = fpext float %107 to double
  %109 = tail call double @llvm.fmuladd.f64(double %108, double -3.170000e-01, double %103)
  %110 = getelementptr inbounds float, ptr %84, i64 %indvars.iv278
  %111 = load float, ptr %110, align 4, !tbaa !12
  %112 = fpext float %111 to double
  %113 = tail call double @llvm.fmuladd.f64(double %112, double -4.850000e-01, double %109)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %114 = getelementptr inbounds ptr, ptr %6, i64 %indvars.iv.next
  %115 = load ptr, ptr %114, align 8, !tbaa !11
  %116 = getelementptr inbounds float, ptr %115, i64 %indvars.iv278
  %117 = load float, ptr %116, align 4, !tbaa !12
  %118 = fpext float %117 to double
  %119 = tail call double @llvm.fmuladd.f64(double %118, double -3.170000e-01, double %113)
  %120 = getelementptr inbounds i8, ptr %85, i64 24
  %121 = load ptr, ptr %120, align 8, !tbaa !11
  %122 = getelementptr inbounds float, ptr %121, i64 %indvars.iv278
  %123 = load float, ptr %122, align 4, !tbaa !12
  %124 = fpext float %123 to double
  %125 = tail call double @llvm.fmuladd.f64(double %124, double 2.160000e-01, double %119)
  %126 = getelementptr inbounds i8, ptr %85, i64 32
  %127 = load ptr, ptr %126, align 8, !tbaa !11
  %128 = getelementptr inbounds float, ptr %127, i64 %indvars.iv278
  %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.160000e-01, double %125)
  %132 = getelementptr inbounds i8, ptr %85, i64 40
  %133 = load ptr, ptr %132, align 8, !tbaa !11
  %134 = getelementptr inbounds float, ptr %133, i64 %indvars.iv278
  %135 = load float, ptr %134, align 4, !tbaa !12
  %136 = fpext float %135 to double
  %137 = tail call double @llvm.fmuladd.f64(double %136, double 1.280000e-01, double %131)
  %138 = fptrunc double %137 to float
  %139 = getelementptr inbounds ptr, ptr %8, i64 %indvars.iv
  %140 = load ptr, ptr %139, align 8, !tbaa !11
  %141 = getelementptr inbounds float, ptr %140, i64 %indvars.iv278
  store float %138, ptr %141, align 4, !tbaa !12
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge, label %83, !llvm.loop !14

._crit_edge:                                      ; preds = %83, %.preheader
  %142 = getelementptr inbounds float, ptr %12, i64 %indvars.iv278
  %143 = load float, ptr %142, align 4, !tbaa !12
  %144 = fpext float %143 to double
  %145 = getelementptr inbounds float, ptr %14, i64 %indvars.iv278
  %146 = load float, ptr %145, align 4, !tbaa !12
  %147 = fpext float %146 to double
  %148 = fmul double %147, 2.160000e-01
  %149 = tail call double @llvm.fmuladd.f64(double %144, double 3.440000e-01, double %148)
  %150 = getelementptr inbounds float, ptr %16, i64 %indvars.iv278
  %151 = load float, ptr %150, align 4, !tbaa !12
  %152 = fpext float %151 to double
  %153 = tail call double @llvm.fmuladd.f64(double %152, double -3.170000e-01, double %149)
  %154 = getelementptr inbounds float, ptr %18, i64 %indvars.iv278
  %155 = load float, ptr %154, align 4, !tbaa !12
  %156 = fpext float %155 to double
  %157 = tail call double @llvm.fmuladd.f64(double %156, double -4.850000e-01, double %153)
  %158 = getelementptr inbounds float, ptr %20, i64 %indvars.iv278
  %159 = load float, ptr %158, align 4, !tbaa !12
  %160 = fpext float %159 to double
  %161 = tail call double @llvm.fmuladd.f64(double %160, double -3.170000e-01, double %157)
  %162 = getelementptr inbounds float, ptr %22, i64 %indvars.iv278
  %163 = load float, ptr %162, align 4, !tbaa !12
  %164 = fpext float %163 to double
  %165 = tail call double @llvm.fmuladd.f64(double %164, double 2.160000e-01, double %161)
  %166 = getelementptr inbounds float, ptr %24, i64 %indvars.iv278
  %167 = load float, ptr %166, align 4, !tbaa !12
  %168 = fpext float %167 to double
  %169 = tail call double @llvm.fmuladd.f64(double %168, double 2.160000e-01, double %165)
  %170 = getelementptr inbounds float, ptr %26, i64 %indvars.iv278
  %171 = load float, ptr %170, align 4, !tbaa !12
  %172 = fpext float %171 to double
  %173 = tail call double @llvm.fmuladd.f64(double %172, double 1.280000e-01, double %169)
  %174 = fptrunc double %173 to float
  %175 = getelementptr inbounds float, ptr %28, i64 %indvars.iv278
  store float %174, ptr %175, align 4, !tbaa !12
  %176 = load float, ptr %142, align 4, !tbaa !12
  %177 = fpext float %176 to double
  %178 = getelementptr inbounds float, ptr %30, i64 %indvars.iv278
  %179 = load float, ptr %178, align 4, !tbaa !12
  %180 = fpext float %179 to double
  %181 = fmul double %180, -3.170000e-01
  %182 = tail call double @llvm.fmuladd.f64(double %177, double 5.600000e-01, double %181)
  %183 = load float, ptr %150, align 4, !tbaa !12
  %184 = fpext float %183 to double
  %185 = tail call double @llvm.fmuladd.f64(double %184, double -4.850000e-01, double %182)
  %186 = load float, ptr %154, align 4, !tbaa !12
  %187 = fpext float %186 to double
  %188 = tail call double @llvm.fmuladd.f64(double %187, double -3.170000e-01, double %185)
  %189 = getelementptr inbounds float, ptr %32, i64 %indvars.iv278
  %190 = load float, ptr %189, align 4, !tbaa !12
  %191 = fpext float %190 to double
  %192 = tail call double @llvm.fmuladd.f64(double %191, double 2.160000e-01, double %188)
  %193 = load float, ptr %162, align 4, !tbaa !12
  %194 = fpext float %193 to double
  %195 = tail call double @llvm.fmuladd.f64(double %194, double 2.160000e-01, double %192)
  %196 = load float, ptr %166, align 4, !tbaa !12
  %197 = fpext float %196 to double
  %198 = tail call double @llvm.fmuladd.f64(double %197, double 1.280000e-01, double %195)
  %199 = fptrunc double %198 to float
  %200 = getelementptr inbounds float, ptr %34, i64 %indvars.iv278
  store float %199, ptr %200, align 4, !tbaa !12
  %201 = load float, ptr %142, align 4, !tbaa !12
  %202 = fpext float %201 to double
  %203 = load float, ptr %145, align 4, !tbaa !12
  %204 = fpext float %203 to double
  %205 = fmul double %204, -3.170000e-01
  %206 = tail call double @llvm.fmuladd.f64(double %202, double 5.600000e-01, double %205)
  %207 = load float, ptr %178, align 4, !tbaa !12
  %208 = fpext float %207 to double
  %209 = tail call double @llvm.fmuladd.f64(double %208, double -4.850000e-01, double %206)
  %210 = load float, ptr %150, align 4, !tbaa !12
  %211 = fpext float %210 to double
  %212 = tail call double @llvm.fmuladd.f64(double %211, double -3.170000e-01, double %209)
  %213 = load float, ptr %158, align 4, !tbaa !12
  %214 = fpext float %213 to double
  %215 = tail call double @llvm.fmuladd.f64(double %214, double 2.160000e-01, double %212)
  %216 = load float, ptr %189, align 4, !tbaa !12
  %217 = fpext float %216 to double
  %218 = tail call double @llvm.fmuladd.f64(double %217, double 2.160000e-01, double %215)
  %219 = load float, ptr %162, align 4, !tbaa !12
  %220 = fpext float %219 to double
  %221 = tail call double @llvm.fmuladd.f64(double %220, double 1.280000e-01, double %218)
  %222 = fptrunc double %221 to float
  %223 = getelementptr inbounds float, ptr %36, i64 %indvars.iv278
  store float %222, ptr %223, align 4, !tbaa !12
  %224 = load float, ptr %142, align 4, !tbaa !12
  %225 = fpext float %224 to double
  %226 = load float, ptr %145, align 4, !tbaa !12
  %227 = fpext float %226 to double
  %228 = fmul double %227, -4.850000e-01
  %229 = tail call double @llvm.fmuladd.f64(double %225, double 2.430000e-01, double %228)
  %230 = load float, ptr %178, align 4, !tbaa !12
  %231 = fpext float %230 to double
  %232 = tail call double @llvm.fmuladd.f64(double %231, double -3.170000e-01, double %229)
  %233 = load float, ptr %154, align 4, !tbaa !12
  %234 = fpext float %233 to double
  %235 = tail call double @llvm.fmuladd.f64(double %234, double 2.160000e-01, double %232)
  %236 = load float, ptr %158, align 4, !tbaa !12
  %237 = fpext float %236 to double
  %238 = tail call double @llvm.fmuladd.f64(double %237, double 2.160000e-01, double %235)
  %239 = load float, ptr %189, align 4, !tbaa !12
  %240 = fpext float %239 to double
  %241 = tail call double @llvm.fmuladd.f64(double %240, double 1.280000e-01, double %238)
  %242 = fptrunc double %241 to float
  %243 = getelementptr inbounds float, ptr %38, i64 %indvars.iv278
  store float %242, ptr %243, align 4, !tbaa !12
  %244 = load float, ptr %142, align 4, !tbaa !12
  %245 = fpext float %244 to double
  %246 = load float, ptr %145, align 4, !tbaa !12
  %247 = fpext float %246 to double
  %248 = fmul double %247, -3.170000e-01
  %249 = tail call double @llvm.fmuladd.f64(double %245, double -2.430000e-01, double %248)
  %250 = load float, ptr %150, align 4, !tbaa !12
  %251 = fpext float %250 to double
  %252 = tail call double @llvm.fmuladd.f64(double %251, double 2.160000e-01, double %249)
  %253 = load float, ptr %154, align 4, !tbaa !12
  %254 = fpext float %253 to double
  %255 = tail call double @llvm.fmuladd.f64(double %254, double 2.160000e-01, double %252)
  %256 = load float, ptr %158, align 4, !tbaa !12
  %257 = fpext float %256 to double
  %258 = tail call double @llvm.fmuladd.f64(double %257, double 1.280000e-01, double %255)
  %259 = fptrunc double %258 to float
  %260 = getelementptr inbounds float, ptr %39, i64 %indvars.iv278
  store float %259, ptr %260, align 4, !tbaa !12
  %261 = getelementptr inbounds float, ptr %43, i64 %indvars.iv278
  %262 = load float, ptr %261, align 4, !tbaa !12
  %263 = fpext float %262 to double
  %264 = getelementptr inbounds float, ptr %45, i64 %indvars.iv278
  %265 = load float, ptr %264, align 4, !tbaa !12
  %266 = fpext float %265 to double
  %267 = fmul double %266, 2.160000e-01
  %268 = tail call double @llvm.fmuladd.f64(double %263, double 1.280000e-01, double %267)
  %269 = getelementptr inbounds float, ptr %47, i64 %indvars.iv278
  %270 = load float, ptr %269, align 4, !tbaa !12
  %271 = fpext float %270 to double
  %272 = tail call double @llvm.fmuladd.f64(double %271, double 2.160000e-01, double %268)
  %273 = getelementptr inbounds float, ptr %49, i64 %indvars.iv278
  %274 = load float, ptr %273, align 4, !tbaa !12
  %275 = fpext float %274 to double
  %276 = tail call double @llvm.fmuladd.f64(double %275, double -3.170000e-01, double %272)
  %277 = getelementptr inbounds float, ptr %52, i64 %indvars.iv278
  %278 = load float, ptr %277, align 4, !tbaa !12
  %279 = fpext float %278 to double
  %280 = tail call double @llvm.fmuladd.f64(double %279, double -4.850000e-01, double %276)
  %281 = getelementptr inbounds float, ptr %54, i64 %indvars.iv278
  %282 = load float, ptr %281, align 4, !tbaa !12
  %283 = fpext float %282 to double
  %284 = tail call double @llvm.fmuladd.f64(double %283, double -3.170000e-01, double %280)
  %285 = getelementptr inbounds float, ptr %56, i64 %indvars.iv278
  %286 = load float, ptr %285, align 4, !tbaa !12
  %287 = fpext float %286 to double
  %288 = tail call double @llvm.fmuladd.f64(double %287, double 2.160000e-01, double %284)
  %289 = getelementptr inbounds float, ptr %58, i64 %indvars.iv278
  %290 = load float, ptr %289, align 4, !tbaa !12
  %291 = fpext float %290 to double
  %292 = tail call double @llvm.fmuladd.f64(double %291, double 3.440000e-01, double %288)
  %293 = fptrunc double %292 to float
  %294 = getelementptr inbounds float, ptr %60, i64 %indvars.iv278
  store float %293, ptr %294, align 4, !tbaa !12
  %295 = load float, ptr %264, align 4, !tbaa !12
  %296 = fpext float %295 to double
  %297 = load float, ptr %269, align 4, !tbaa !12
  %298 = fpext float %297 to double
  %299 = fmul double %298, 2.160000e-01
  %300 = tail call double @llvm.fmuladd.f64(double %296, double 1.280000e-01, double %299)
  %301 = getelementptr inbounds float, ptr %62, i64 %indvars.iv278
  %302 = load float, ptr %301, align 4, !tbaa !12
  %303 = fpext float %302 to double
  %304 = tail call double @llvm.fmuladd.f64(double %303, double 2.160000e-01, double %300)
  %305 = getelementptr inbounds float, ptr %64, i64 %indvars.iv278
  %306 = load float, ptr %305, align 4, !tbaa !12
  %307 = fpext float %306 to double
  %308 = tail call double @llvm.fmuladd.f64(double %307, double -3.170000e-01, double %304)
  %309 = load float, ptr %281, align 4, !tbaa !12
  %310 = fpext float %309 to double
  %311 = tail call double @llvm.fmuladd.f64(double %310, double -4.850000e-01, double %308)
  %312 = getelementptr inbounds float, ptr %66, i64 %indvars.iv278
  %313 = load float, ptr %312, align 4, !tbaa !12
  %314 = fpext float %313 to double
  %315 = tail call double @llvm.fmuladd.f64(double %314, double -3.170000e-01, double %311)
  %316 = load float, ptr %289, align 4, !tbaa !12
  %317 = fpext float %316 to double
  %318 = tail call double @llvm.fmuladd.f64(double %317, double 5.600000e-01, double %315)
  %319 = fptrunc double %318 to float
  %320 = getelementptr inbounds float, ptr %70, i64 %indvars.iv278
  store float %319, ptr %320, align 4, !tbaa !12
  %321 = load float, ptr %269, align 4, !tbaa !12
  %322 = fpext float %321 to double
  %323 = load float, ptr %301, align 4, !tbaa !12
  %324 = fpext float %323 to double
  %325 = fmul double %324, 2.160000e-01
  %326 = tail call double @llvm.fmuladd.f64(double %322, double 1.280000e-01, double %325)
  %327 = load float, ptr %273, align 4, !tbaa !12
  %328 = fpext float %327 to double
  %329 = tail call double @llvm.fmuladd.f64(double %328, double 2.160000e-01, double %326)
  %330 = load float, ptr %281, align 4, !tbaa !12
  %331 = fpext float %330 to double
  %332 = tail call double @llvm.fmuladd.f64(double %331, double -3.170000e-01, double %329)
  %333 = load float, ptr %312, align 4, !tbaa !12
  %334 = fpext float %333 to double
  %335 = tail call double @llvm.fmuladd.f64(double %334, double -4.850000e-01, double %332)
  %336 = load float, ptr %285, align 4, !tbaa !12
  %337 = fpext float %336 to double
  %338 = tail call double @llvm.fmuladd.f64(double %337, double -3.170000e-01, double %335)
  %339 = load float, ptr %289, align 4, !tbaa !12
  %340 = fpext float %339 to double
  %341 = tail call double @llvm.fmuladd.f64(double %340, double 5.600000e-01, double %338)
  %342 = fptrunc double %341 to float
  %343 = getelementptr inbounds float, ptr %74, i64 %indvars.iv278
  store float %342, ptr %343, align 4, !tbaa !12
  %344 = load float, ptr %301, align 4, !tbaa !12
  %345 = fpext float %344 to double
  %346 = load float, ptr %273, align 4, !tbaa !12
  %347 = fpext float %346 to double
  %348 = fmul double %347, 2.160000e-01
  %349 = tail call double @llvm.fmuladd.f64(double %345, double 1.280000e-01, double %348)
  %350 = load float, ptr %305, align 4, !tbaa !12
  %351 = fpext float %350 to double
  %352 = tail call double @llvm.fmuladd.f64(double %351, double 2.160000e-01, double %349)
  %353 = load float, ptr %312, align 4, !tbaa !12
  %354 = fpext float %353 to double
  %355 = tail call double @llvm.fmuladd.f64(double %354, double -3.170000e-01, double %352)
  %356 = load float, ptr %285, align 4, !tbaa !12
  %357 = fpext float %356 to double
  %358 = tail call double @llvm.fmuladd.f64(double %357, double -4.850000e-01, double %355)
  %359 = load float, ptr %289, align 4, !tbaa !12
  %360 = fpext float %359 to double
  %361 = tail call double @llvm.fmuladd.f64(double %360, double 2.430000e-01, double %358)
  %362 = fptrunc double %361 to float
  %363 = getelementptr inbounds float, ptr %78, i64 %indvars.iv278
  store float %362, ptr %363, align 4, !tbaa !12
  %364 = load float, ptr %273, align 4, !tbaa !12
  %365 = fpext float %364 to double
  %366 = load float, ptr %305, align 4, !tbaa !12
  %367 = fpext float %366 to double
  %368 = fmul double %367, 2.160000e-01
  %369 = tail call double @llvm.fmuladd.f64(double %365, double 1.280000e-01, double %368)
  %370 = load float, ptr %281, align 4, !tbaa !12
  %371 = fpext float %370 to double
  %372 = tail call double @llvm.fmuladd.f64(double %371, double 2.160000e-01, double %369)
  %373 = load float, ptr %285, align 4, !tbaa !12
  %374 = fpext float %373 to double
  %375 = tail call double @llvm.fmuladd.f64(double %374, double -3.170000e-01, double %372)
  %376 = load float, ptr %289, align 4, !tbaa !12
  %377 = fpext float %376 to double
  %378 = tail call double @llvm.fmuladd.f64(double %377, double -2.430000e-01, double %375)
  %379 = fptrunc double %378 to float
  %380 = getelementptr inbounds float, ptr %82, i64 %indvars.iv278
  store float %379, ptr %380, align 4, !tbaa !12
  %indvars.iv.next279 = add nuw nsw i64 %indvars.iv278, 1
  %exitcond282.not = icmp eq i64 %indvars.iv.next279, %wide.trip.count281
  br i1 %exitcond282.not, label %._crit_edge276, label %.preheader, !llvm.loop !16

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

attributes #0 = { 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 #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { 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" }

!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 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}


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