; LLVM IR from ivan-pi/periodic-lbm :: third-party (dugks_cavity)

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

@ex = external dso_local global [3 x double], align 16
@ey = external dso_local global [3 x double], align 16
@dx = external dso_local global double, align 8
@yc = external dso_local global [32 x double], align 16
@xc = external dso_local global [32 x double], align 16
@dt = external dso_local global double, align 8
@wb = external dso_local global double, align 8
@f_plus = external dso_local global [32 x [32 x [3 x [3 x double]]]], align 16
@xf_face = external dso_local global [33 x [3 x [3 x double]]], align 16

; 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 speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #1

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

; Function Attrs: nounwind uwtable
declare dso_local double @feq(i32 noundef, i32 noundef, double noundef, double noundef, double noundef) #2

; Function Attrs: nounwind uwtable
define dso_local void @InterpX(i32 noundef %0) #2 {
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca double, align 8
  %10 = alloca double, align 8
  %11 = alloca double, align 8
  %12 = alloca double, align 8
  %13 = alloca double, align 8
  %14 = alloca double, align 8
  %15 = alloca double, align 8
  %16 = alloca double, align 8
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca double, align 8
  %20 = alloca double, align 8
  %21 = alloca double, align 8
  store i32 %0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #3
  %22 = load i32, ptr %2, align 4, !tbaa !5
  %23 = sub nsw i32 %22, 1
  store i32 %23, ptr %7, align 4, !tbaa !5
  %24 = load i32, ptr %2, align 4, !tbaa !5
  %25 = add nsw i32 %24, 1
  store i32 %25, ptr %8, align 4, !tbaa !5
  %26 = load i32, ptr %2, align 4, !tbaa !5
  %27 = sext i32 %26 to i64
  %28 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %27
  %29 = load double, ptr %28, align 8, !tbaa !9
  %30 = load i32, ptr %7, align 4, !tbaa !5
  %31 = sext i32 %30 to i64
  %32 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %31
  %33 = load double, ptr %32, align 8, !tbaa !9
  %34 = fsub double %29, %33
  store double %34, ptr %18, align 8, !tbaa !9
  %35 = load i32, ptr %8, align 4, !tbaa !5
  %36 = sext i32 %35 to i64
  %37 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %36
  %38 = load double, ptr %37, align 8, !tbaa !9
  %39 = load i32, ptr %2, align 4, !tbaa !5
  %40 = sext i32 %39 to i64
  %41 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %40
  %42 = load double, ptr %41, align 8, !tbaa !9
  %43 = fsub double %38, %42
  store double %43, ptr %17, align 8, !tbaa !9
  %44 = load double, ptr %17, align 8, !tbaa !9
  %45 = load double, ptr %18, align 8, !tbaa !9
  %46 = fsub double %44, %45
  %47 = load double, ptr %18, align 8, !tbaa !9
  %48 = load double, ptr %17, align 8, !tbaa !9
  %49 = fmul double %47, %48
  %50 = fdiv double %46, %49
  store double %50, ptr %21, align 8, !tbaa !9
  %51 = load double, ptr %17, align 8, !tbaa !9
  %52 = load double, ptr %18, align 8, !tbaa !9
  %53 = load double, ptr %17, align 8, !tbaa !9
  %54 = load double, ptr %18, align 8, !tbaa !9
  %55 = fadd double %53, %54
  %56 = fmul double %52, %55
  %57 = fdiv double %51, %56
  store double %57, ptr %19, align 8, !tbaa !9
  %58 = load double, ptr %18, align 8, !tbaa !9
  %59 = load double, ptr %17, align 8, !tbaa !9
  %60 = load double, ptr %17, align 8, !tbaa !9
  %61 = load double, ptr %18, align 8, !tbaa !9
  %62 = fadd double %60, %61
  %63 = fmul double %59, %62
  %64 = fdiv double %58, %63
  store double %64, ptr %20, align 8, !tbaa !9
  store i32 1, ptr %3, align 4, !tbaa !5
  br label %65

65:                                               ; preds = %274, %1
  %66 = load i32, ptr %3, align 4, !tbaa !5
  %67 = icmp sle i32 %66, 31
  br i1 %67, label %68, label %277

68:                                               ; preds = %65
  %69 = load i32, ptr %3, align 4, !tbaa !5
  %70 = sub nsw i32 %69, 1
  store i32 %70, ptr %6, align 4, !tbaa !5
  %71 = load i32, ptr %3, align 4, !tbaa !5
  %72 = sext i32 %71 to i64
  %73 = getelementptr inbounds [32 x double], ptr @xc, i64 0, i64 %72
  %74 = load double, ptr %73, align 8, !tbaa !9
  %75 = load i32, ptr %6, align 4, !tbaa !5
  %76 = sext i32 %75 to i64
  %77 = getelementptr inbounds [32 x double], ptr @xc, i64 0, i64 %76
  %78 = load double, ptr %77, align 8, !tbaa !9
  %79 = fsub double %74, %78
  store double %79, ptr @dx, align 8, !tbaa !9
  store i32 0, ptr %5, align 4, !tbaa !5
  br label %80

80:                                               ; preds = %270, %68
  %81 = load i32, ptr %5, align 4, !tbaa !5
  %82 = icmp slt i32 %81, 3
  br i1 %82, label %83, label %273

83:                                               ; preds = %80
  store i32 0, ptr %4, align 4, !tbaa !5
  br label %84

84:                                               ; preds = %266, %83
  %85 = load i32, ptr %4, align 4, !tbaa !5
  %86 = icmp slt i32 %85, 3
  br i1 %86, label %87, label %269

87:                                               ; preds = %84
  %88 = load i32, ptr %2, align 4, !tbaa !5
  %89 = sext i32 %88 to i64
  %90 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %89
  %91 = load i32, ptr %3, align 4, !tbaa !5
  %92 = sext i32 %91 to i64
  %93 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %90, i64 0, i64 %92
  %94 = load i32, ptr %4, align 4, !tbaa !5
  %95 = sext i32 %94 to i64
  %96 = getelementptr inbounds [3 x [3 x double]], ptr %93, i64 0, i64 %95
  %97 = load i32, ptr %5, align 4, !tbaa !5
  %98 = sext i32 %97 to i64
  %99 = getelementptr inbounds [3 x double], ptr %96, i64 0, i64 %98
  %100 = load double, ptr %99, align 8, !tbaa !9
  %101 = load i32, ptr %2, align 4, !tbaa !5
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %102
  %104 = load i32, ptr %6, align 4, !tbaa !5
  %105 = sext i32 %104 to i64
  %106 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %103, i64 0, i64 %105
  %107 = load i32, ptr %4, align 4, !tbaa !5
  %108 = sext i32 %107 to i64
  %109 = getelementptr inbounds [3 x [3 x double]], ptr %106, i64 0, i64 %108
  %110 = load i32, ptr %5, align 4, !tbaa !5
  %111 = sext i32 %110 to i64
  %112 = getelementptr inbounds [3 x double], ptr %109, i64 0, i64 %111
  %113 = load double, ptr %112, align 8, !tbaa !9
  %114 = fadd double %100, %113
  %115 = fmul double 5.000000e-01, %114
  store double %115, ptr %11, align 8, !tbaa !9
  %116 = load i32, ptr %2, align 4, !tbaa !5
  %117 = sext i32 %116 to i64
  %118 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %117
  %119 = load i32, ptr %3, align 4, !tbaa !5
  %120 = sext i32 %119 to i64
  %121 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %118, i64 0, i64 %120
  %122 = load i32, ptr %4, align 4, !tbaa !5
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds [3 x [3 x double]], ptr %121, i64 0, i64 %123
  %125 = load i32, ptr %5, align 4, !tbaa !5
  %126 = sext i32 %125 to i64
  %127 = getelementptr inbounds [3 x double], ptr %124, i64 0, i64 %126
  %128 = load double, ptr %127, align 8, !tbaa !9
  %129 = load i32, ptr %2, align 4, !tbaa !5
  %130 = sext i32 %129 to i64
  %131 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %130
  %132 = load i32, ptr %6, align 4, !tbaa !5
  %133 = sext i32 %132 to i64
  %134 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %131, i64 0, i64 %133
  %135 = load i32, ptr %4, align 4, !tbaa !5
  %136 = sext i32 %135 to i64
  %137 = getelementptr inbounds [3 x [3 x double]], ptr %134, i64 0, i64 %136
  %138 = load i32, ptr %5, align 4, !tbaa !5
  %139 = sext i32 %138 to i64
  %140 = getelementptr inbounds [3 x double], ptr %137, i64 0, i64 %139
  %141 = load double, ptr %140, align 8, !tbaa !9
  %142 = fsub double %128, %141
  %143 = load double, ptr @dx, align 8, !tbaa !9
  %144 = fdiv double %142, %143
  store double %144, ptr %12, align 8, !tbaa !9
  %145 = load double, ptr %21, align 8, !tbaa !9
  %146 = load i32, ptr %2, align 4, !tbaa !5
  %147 = sext i32 %146 to i64
  %148 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %147
  %149 = load i32, ptr %6, align 4, !tbaa !5
  %150 = sext i32 %149 to i64
  %151 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %148, i64 0, i64 %150
  %152 = load i32, ptr %4, align 4, !tbaa !5
  %153 = sext i32 %152 to i64
  %154 = getelementptr inbounds [3 x [3 x double]], ptr %151, i64 0, i64 %153
  %155 = load i32, ptr %5, align 4, !tbaa !5
  %156 = sext i32 %155 to i64
  %157 = getelementptr inbounds [3 x double], ptr %154, i64 0, i64 %156
  %158 = load double, ptr %157, align 8, !tbaa !9
  %159 = load i32, ptr %2, align 4, !tbaa !5
  %160 = sext i32 %159 to i64
  %161 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %160
  %162 = load i32, ptr %3, align 4, !tbaa !5
  %163 = sext i32 %162 to i64
  %164 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %161, i64 0, i64 %163
  %165 = load i32, ptr %4, align 4, !tbaa !5
  %166 = sext i32 %165 to i64
  %167 = getelementptr inbounds [3 x [3 x double]], ptr %164, i64 0, i64 %166
  %168 = load i32, ptr %5, align 4, !tbaa !5
  %169 = sext i32 %168 to i64
  %170 = getelementptr inbounds [3 x double], ptr %167, i64 0, i64 %169
  %171 = load double, ptr %170, align 8, !tbaa !9
  %172 = fadd double %158, %171
  %173 = load double, ptr %20, align 8, !tbaa !9
  %174 = load i32, ptr %8, align 4, !tbaa !5
  %175 = sext i32 %174 to i64
  %176 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %175
  %177 = load i32, ptr %6, align 4, !tbaa !5
  %178 = sext i32 %177 to i64
  %179 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %176, i64 0, i64 %178
  %180 = load i32, ptr %4, align 4, !tbaa !5
  %181 = sext i32 %180 to i64
  %182 = getelementptr inbounds [3 x [3 x double]], ptr %179, i64 0, i64 %181
  %183 = load i32, ptr %5, align 4, !tbaa !5
  %184 = sext i32 %183 to i64
  %185 = getelementptr inbounds [3 x double], ptr %182, i64 0, i64 %184
  %186 = load double, ptr %185, align 8, !tbaa !9
  %187 = load i32, ptr %8, align 4, !tbaa !5
  %188 = sext i32 %187 to i64
  %189 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %188
  %190 = load i32, ptr %3, align 4, !tbaa !5
  %191 = sext i32 %190 to i64
  %192 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %189, i64 0, i64 %191
  %193 = load i32, ptr %4, align 4, !tbaa !5
  %194 = sext i32 %193 to i64
  %195 = getelementptr inbounds [3 x [3 x double]], ptr %192, i64 0, i64 %194
  %196 = load i32, ptr %5, align 4, !tbaa !5
  %197 = sext i32 %196 to i64
  %198 = getelementptr inbounds [3 x double], ptr %195, i64 0, i64 %197
  %199 = load double, ptr %198, align 8, !tbaa !9
  %200 = fadd double %186, %199
  %201 = fmul double %173, %200
  %202 = call double @llvm.fmuladd.f64(double %145, double %172, double %201)
  %203 = load double, ptr %19, align 8, !tbaa !9
  %204 = load i32, ptr %7, align 4, !tbaa !5
  %205 = sext i32 %204 to i64
  %206 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %205
  %207 = load i32, ptr %6, align 4, !tbaa !5
  %208 = sext i32 %207 to i64
  %209 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %206, i64 0, i64 %208
  %210 = load i32, ptr %4, align 4, !tbaa !5
  %211 = sext i32 %210 to i64
  %212 = getelementptr inbounds [3 x [3 x double]], ptr %209, i64 0, i64 %211
  %213 = load i32, ptr %5, align 4, !tbaa !5
  %214 = sext i32 %213 to i64
  %215 = getelementptr inbounds [3 x double], ptr %212, i64 0, i64 %214
  %216 = load double, ptr %215, align 8, !tbaa !9
  %217 = load i32, ptr %7, align 4, !tbaa !5
  %218 = sext i32 %217 to i64
  %219 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %218
  %220 = load i32, ptr %3, align 4, !tbaa !5
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds [32 x [3 x [3 x double]]], ptr %219, i64 0, i64 %221
  %223 = load i32, ptr %4, align 4, !tbaa !5
  %224 = sext i32 %223 to i64
  %225 = getelementptr inbounds [3 x [3 x double]], ptr %222, i64 0, i64 %224
  %226 = load i32, ptr %5, align 4, !tbaa !5
  %227 = sext i32 %226 to i64
  %228 = getelementptr inbounds [3 x double], ptr %225, i64 0, i64 %227
  %229 = load double, ptr %228, align 8, !tbaa !9
  %230 = fadd double %216, %229
  %231 = fneg double %203
  %232 = call double @llvm.fmuladd.f64(double %231, double %230, double %202)
  %233 = fmul double 5.000000e-01, %232
  store double %233, ptr %13, align 8, !tbaa !9
  %234 = load i32, ptr %4, align 4, !tbaa !5
  %235 = sext i32 %234 to i64
  %236 = getelementptr inbounds [3 x double], ptr @ex, i64 0, i64 %235
  %237 = load double, ptr %236, align 8, !tbaa !9
  %238 = fmul double 5.000000e-01, %237
  %239 = load double, ptr @dt, align 8, !tbaa !9
  %240 = fmul double %238, %239
  store double %240, ptr %9, align 8, !tbaa !9
  %241 = load i32, ptr %5, align 4, !tbaa !5
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds [3 x double], ptr @ey, i64 0, i64 %242
  %244 = load double, ptr %243, align 8, !tbaa !9
  %245 = fmul double 5.000000e-01, %244
  %246 = load double, ptr @dt, align 8, !tbaa !9
  %247 = fmul double %245, %246
  store double %247, ptr %10, align 8, !tbaa !9
  %248 = load double, ptr %11, align 8, !tbaa !9
  %249 = load double, ptr %9, align 8, !tbaa !9
  %250 = load double, ptr %12, align 8, !tbaa !9
  %251 = fneg double %249
  %252 = call double @llvm.fmuladd.f64(double %251, double %250, double %248)
  %253 = load double, ptr %10, align 8, !tbaa !9
  %254 = load double, ptr %13, align 8, !tbaa !9
  %255 = fneg double %253
  %256 = call double @llvm.fmuladd.f64(double %255, double %254, double %252)
  %257 = load i32, ptr %3, align 4, !tbaa !5
  %258 = sext i32 %257 to i64
  %259 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %258
  %260 = load i32, ptr %4, align 4, !tbaa !5
  %261 = sext i32 %260 to i64
  %262 = getelementptr inbounds [3 x [3 x double]], ptr %259, i64 0, i64 %261
  %263 = load i32, ptr %5, align 4, !tbaa !5
  %264 = sext i32 %263 to i64
  %265 = getelementptr inbounds [3 x double], ptr %262, i64 0, i64 %264
  store double %256, ptr %265, align 8, !tbaa !9
  br label %266

266:                                              ; preds = %87
  %267 = load i32, ptr %4, align 4, !tbaa !5
  %268 = add nsw i32 %267, 1
  store i32 %268, ptr %4, align 4, !tbaa !5
  br label %84, !llvm.loop !11

269:                                              ; preds = %84
  br label %270

270:                                              ; preds = %269
  %271 = load i32, ptr %5, align 4, !tbaa !5
  %272 = add nsw i32 %271, 1
  store i32 %272, ptr %5, align 4, !tbaa !5
  br label %80, !llvm.loop !13

273:                                              ; preds = %80
  br label %274

274:                                              ; preds = %273
  %275 = load i32, ptr %3, align 4, !tbaa !5
  %276 = add nsw i32 %275, 1
  store i32 %276, ptr %3, align 4, !tbaa !5
  br label %65, !llvm.loop !14

277:                                              ; preds = %65
  store i32 1, ptr %3, align 4, !tbaa !5
  br label %278

278:                                              ; preds = %395, %277
  %279 = load i32, ptr %3, align 4, !tbaa !5
  %280 = icmp sle i32 %279, 31
  br i1 %280, label %281, label %398

281:                                              ; preds = %278
  store double 0.000000e+00, ptr %16, align 8, !tbaa !9
  store double 0.000000e+00, ptr %15, align 8, !tbaa !9
  store double 0.000000e+00, ptr %14, align 8, !tbaa !9
  store i32 0, ptr %4, align 4, !tbaa !5
  br label %282

282:                                              ; preds = %338, %281
  %283 = load i32, ptr %4, align 4, !tbaa !5
  %284 = icmp slt i32 %283, 3
  br i1 %284, label %285, label %341

285:                                              ; preds = %282
  store i32 0, ptr %5, align 4, !tbaa !5
  br label %286

286:                                              ; preds = %334, %285
  %287 = load i32, ptr %5, align 4, !tbaa !5
  %288 = icmp slt i32 %287, 3
  br i1 %288, label %289, label %337

289:                                              ; preds = %286
  %290 = load i32, ptr %3, align 4, !tbaa !5
  %291 = sext i32 %290 to i64
  %292 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %291
  %293 = load i32, ptr %4, align 4, !tbaa !5
  %294 = sext i32 %293 to i64
  %295 = getelementptr inbounds [3 x [3 x double]], ptr %292, i64 0, i64 %294
  %296 = load i32, ptr %5, align 4, !tbaa !5
  %297 = sext i32 %296 to i64
  %298 = getelementptr inbounds [3 x double], ptr %295, i64 0, i64 %297
  %299 = load double, ptr %298, align 8, !tbaa !9
  %300 = load double, ptr %16, align 8, !tbaa !9
  %301 = fadd double %300, %299
  store double %301, ptr %16, align 8, !tbaa !9
  %302 = load i32, ptr %4, align 4, !tbaa !5
  %303 = sext i32 %302 to i64
  %304 = getelementptr inbounds [3 x double], ptr @ex, i64 0, i64 %303
  %305 = load double, ptr %304, align 8, !tbaa !9
  %306 = load i32, ptr %3, align 4, !tbaa !5
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %307
  %309 = load i32, ptr %4, align 4, !tbaa !5
  %310 = sext i32 %309 to i64
  %311 = getelementptr inbounds [3 x [3 x double]], ptr %308, i64 0, i64 %310
  %312 = load i32, ptr %5, align 4, !tbaa !5
  %313 = sext i32 %312 to i64
  %314 = getelementptr inbounds [3 x double], ptr %311, i64 0, i64 %313
  %315 = load double, ptr %314, align 8, !tbaa !9
  %316 = load double, ptr %14, align 8, !tbaa !9
  %317 = call double @llvm.fmuladd.f64(double %305, double %315, double %316)
  store double %317, ptr %14, align 8, !tbaa !9
  %318 = load i32, ptr %5, align 4, !tbaa !5
  %319 = sext i32 %318 to i64
  %320 = getelementptr inbounds [3 x double], ptr @ey, i64 0, i64 %319
  %321 = load double, ptr %320, align 8, !tbaa !9
  %322 = load i32, ptr %3, align 4, !tbaa !5
  %323 = sext i32 %322 to i64
  %324 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %323
  %325 = load i32, ptr %4, align 4, !tbaa !5
  %326 = sext i32 %325 to i64
  %327 = getelementptr inbounds [3 x [3 x double]], ptr %324, i64 0, i64 %326
  %328 = load i32, ptr %5, align 4, !tbaa !5
  %329 = sext i32 %328 to i64
  %330 = getelementptr inbounds [3 x double], ptr %327, i64 0, i64 %329
  %331 = load double, ptr %330, align 8, !tbaa !9
  %332 = load double, ptr %15, align 8, !tbaa !9
  %333 = call double @llvm.fmuladd.f64(double %321, double %331, double %332)
  store double %333, ptr %15, align 8, !tbaa !9
  br label %334

334:                                              ; preds = %289
  %335 = load i32, ptr %5, align 4, !tbaa !5
  %336 = add nsw i32 %335, 1
  store i32 %336, ptr %5, align 4, !tbaa !5
  br label %286, !llvm.loop !15

337:                                              ; preds = %286
  br label %338

338:                                              ; preds = %337
  %339 = load i32, ptr %4, align 4, !tbaa !5
  %340 = add nsw i32 %339, 1
  store i32 %340, ptr %4, align 4, !tbaa !5
  br label %282, !llvm.loop !16

341:                                              ; preds = %282
  %342 = load double, ptr %16, align 8, !tbaa !9
  %343 = load double, ptr %14, align 8, !tbaa !9
  %344 = fdiv double %343, %342
  store double %344, ptr %14, align 8, !tbaa !9
  %345 = load double, ptr %16, align 8, !tbaa !9
  %346 = load double, ptr %15, align 8, !tbaa !9
  %347 = fdiv double %346, %345
  store double %347, ptr %15, align 8, !tbaa !9
  store i32 0, ptr %4, align 4, !tbaa !5
  br label %348

348:                                              ; preds = %391, %341
  %349 = load i32, ptr %4, align 4, !tbaa !5
  %350 = icmp slt i32 %349, 3
  br i1 %350, label %351, label %394

351:                                              ; preds = %348
  store i32 0, ptr %5, align 4, !tbaa !5
  br label %352

352:                                              ; preds = %387, %351
  %353 = load i32, ptr %5, align 4, !tbaa !5
  %354 = icmp slt i32 %353, 3
  br i1 %354, label %355, label %390

355:                                              ; preds = %352
  %356 = load double, ptr @wb, align 8, !tbaa !9
  %357 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %356, double 1.000000e+00)
  %358 = load i32, ptr %3, align 4, !tbaa !5
  %359 = sext i32 %358 to i64
  %360 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %359
  %361 = load i32, ptr %4, align 4, !tbaa !5
  %362 = sext i32 %361 to i64
  %363 = getelementptr inbounds [3 x [3 x double]], ptr %360, i64 0, i64 %362
  %364 = load i32, ptr %5, align 4, !tbaa !5
  %365 = sext i32 %364 to i64
  %366 = getelementptr inbounds [3 x double], ptr %363, i64 0, i64 %365
  %367 = load double, ptr %366, align 8, !tbaa !9
  %368 = load double, ptr @wb, align 8, !tbaa !9
  %369 = fmul double 5.000000e-01, %368
  %370 = load i32, ptr %4, align 4, !tbaa !5
  %371 = load i32, ptr %5, align 4, !tbaa !5
  %372 = load double, ptr %14, align 8, !tbaa !9
  %373 = load double, ptr %15, align 8, !tbaa !9
  %374 = load double, ptr %16, align 8, !tbaa !9
  %375 = call double @feq(i32 noundef %370, i32 noundef %371, double noundef %372, double noundef %373, double noundef %374)
  %376 = fmul double %369, %375
  %377 = call double @llvm.fmuladd.f64(double %357, double %367, double %376)
  %378 = load i32, ptr %3, align 4, !tbaa !5
  %379 = sext i32 %378 to i64
  %380 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %379
  %381 = load i32, ptr %4, align 4, !tbaa !5
  %382 = sext i32 %381 to i64
  %383 = getelementptr inbounds [3 x [3 x double]], ptr %380, i64 0, i64 %382
  %384 = load i32, ptr %5, align 4, !tbaa !5
  %385 = sext i32 %384 to i64
  %386 = getelementptr inbounds [3 x double], ptr %383, i64 0, i64 %385
  store double %377, ptr %386, align 8, !tbaa !9
  br label %387

387:                                              ; preds = %355
  %388 = load i32, ptr %5, align 4, !tbaa !5
  %389 = add nsw i32 %388, 1
  store i32 %389, ptr %5, align 4, !tbaa !5
  br label %352, !llvm.loop !17

390:                                              ; preds = %352
  br label %391

391:                                              ; preds = %390
  %392 = load i32, ptr %4, align 4, !tbaa !5
  %393 = add nsw i32 %392, 1
  store i32 %393, ptr %4, align 4, !tbaa !5
  br label %348, !llvm.loop !18

394:                                              ; preds = %348
  br label %395

395:                                              ; preds = %394
  %396 = load i32, ptr %3, align 4, !tbaa !5
  %397 = add nsw i32 %396, 1
  store i32 %397, ptr %3, align 4, !tbaa !5
  br label %278, !llvm.loop !19

398:                                              ; preds = %278
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #3
  ret void
}

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

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

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


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

@ex = external dso_local local_unnamed_addr global [3 x double], align 16
@ey = external dso_local local_unnamed_addr global [3 x double], align 16
@dx = external dso_local local_unnamed_addr global double, align 8
@yc = external dso_local local_unnamed_addr global [32 x double], align 16
@xc = external dso_local local_unnamed_addr global [32 x double], align 16
@dt = external dso_local local_unnamed_addr global double, align 8
@wb = external dso_local local_unnamed_addr global double, align 8
@f_plus = external dso_local local_unnamed_addr global [32 x [32 x [3 x [3 x double]]]], align 16
@xf_face = external dso_local local_unnamed_addr global [33 x [3 x [3 x double]]], align 16

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

; Function Attrs: nounwind uwtable
declare dso_local double @feq(i32 noundef, i32 noundef, double noundef, double noundef, double noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local void @InterpX(i32 noundef %0) local_unnamed_addr #1 {
  %2 = add nsw i32 %0, -1
  %3 = add nsw i32 %0, 1
  %4 = sext i32 %0 to i64
  %5 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %4
  %6 = load double, ptr %5, align 8, !tbaa !5
  %7 = sext i32 %2 to i64
  %8 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %7
  %9 = load double, ptr %8, align 8, !tbaa !5
  %10 = fsub double %6, %9
  %11 = sext i32 %3 to i64
  %12 = getelementptr inbounds [32 x double], ptr @yc, i64 0, i64 %11
  %13 = load double, ptr %12, align 8, !tbaa !5
  %14 = fsub double %13, %6
  %15 = fsub double %14, %10
  %16 = fmul double %10, %14
  %17 = fdiv double %15, %16
  %18 = fadd double %10, %14
  %19 = fmul double %10, %18
  %20 = fmul double %14, %18
  %21 = fdiv double %10, %20
  %22 = fneg double %14
  %23 = fdiv double %22, %19
  %24 = load double, ptr @dt, align 8, !tbaa !5
  %.pre = load double, ptr @xc, align 16, !tbaa !5
  %.pre176.pre = load double, ptr @ex, align 16, !tbaa !5
  %.pre177.pre = load double, ptr getelementptr inbounds (i8, ptr @ex, i64 8), align 8, !tbaa !5
  %.pre178.pre = load double, ptr getelementptr inbounds (i8, ptr @ex, i64 16), align 16, !tbaa !5
  %25 = fmul double %.pre176.pre, -5.000000e-01
  %26 = fmul double %25, %24
  %27 = fmul double %.pre177.pre, -5.000000e-01
  %28 = fmul double %27, %24
  %29 = fmul double %.pre178.pre, -5.000000e-01
  %30 = fmul double %29, %24
  %31 = load double, ptr @ey, align 16, !tbaa !5
  %32 = fmul double %31, -5.000000e-01
  %33 = fmul double %24, %32
  %34 = load double, ptr getelementptr inbounds (i8, ptr @ey, i64 8), align 8, !tbaa !5
  %35 = fmul double %34, -5.000000e-01
  %36 = fmul double %24, %35
  %37 = load double, ptr getelementptr inbounds (i8, ptr @ey, i64 16), align 16, !tbaa !5
  %38 = fmul double %37, -5.000000e-01
  %39 = fmul double %24, %38
  br label %.preheader132

.preheader131:                                    ; preds = %.preheader132
  store double %43, ptr @dx, align 8, !tbaa !5
  br label %.preheader130

.preheader132:                                    ; preds = %1, %.preheader132
  %40 = phi double [ %.pre, %1 ], [ %42, %.preheader132 ]
  %indvars.iv152 = phi i64 [ 1, %1 ], [ %indvars.iv.next153, %.preheader132 ]
  %41 = getelementptr inbounds [32 x double], ptr @xc, i64 0, i64 %indvars.iv152
  %42 = load double, ptr %41, align 8, !tbaa !5
  %43 = fsub double %42, %40
  %44 = add nsw i64 %indvars.iv152, -1
  %45 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 0, i64 0
  %46 = load double, ptr %45, align 8, !tbaa !5
  %47 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 0, i64 0
  %48 = load double, ptr %47, align 8, !tbaa !5
  %49 = fadd double %46, %48
  %50 = fmul double %49, 5.000000e-01
  %51 = fsub double %46, %48
  %52 = fdiv double %51, %43
  %53 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 0, i64 0
  %54 = load double, ptr %53, align 8, !tbaa !5
  %55 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 0, i64 0
  %56 = load double, ptr %55, align 8, !tbaa !5
  %57 = fadd double %54, %56
  %58 = fmul double %21, %57
  %59 = tail call double @llvm.fmuladd.f64(double %17, double %49, double %58)
  %60 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 0, i64 0
  %61 = load double, ptr %60, align 8, !tbaa !5
  %62 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 0, i64 0
  %63 = load double, ptr %62, align 8, !tbaa !5
  %64 = fadd double %61, %63
  %65 = tail call double @llvm.fmuladd.f64(double %23, double %64, double %59)
  %66 = fmul double %65, 5.000000e-01
  %67 = tail call double @llvm.fmuladd.f64(double %26, double %52, double %50)
  %68 = tail call double @llvm.fmuladd.f64(double %33, double %66, double %67)
  %69 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 0, i64 0
  store double %68, ptr %69, align 8, !tbaa !5
  %70 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 1, i64 0
  %71 = load double, ptr %70, align 8, !tbaa !5
  %72 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 1, i64 0
  %73 = load double, ptr %72, align 8, !tbaa !5
  %74 = fadd double %71, %73
  %75 = fmul double %74, 5.000000e-01
  %76 = fsub double %71, %73
  %77 = fdiv double %76, %43
  %78 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 1, i64 0
  %79 = load double, ptr %78, align 8, !tbaa !5
  %80 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 1, i64 0
  %81 = load double, ptr %80, align 8, !tbaa !5
  %82 = fadd double %79, %81
  %83 = fmul double %21, %82
  %84 = tail call double @llvm.fmuladd.f64(double %17, double %74, double %83)
  %85 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 1, i64 0
  %86 = load double, ptr %85, align 8, !tbaa !5
  %87 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 1, i64 0
  %88 = load double, ptr %87, align 8, !tbaa !5
  %89 = fadd double %86, %88
  %90 = tail call double @llvm.fmuladd.f64(double %23, double %89, double %84)
  %91 = fmul double %90, 5.000000e-01
  %92 = tail call double @llvm.fmuladd.f64(double %28, double %77, double %75)
  %93 = tail call double @llvm.fmuladd.f64(double %33, double %91, double %92)
  %94 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 1, i64 0
  store double %93, ptr %94, align 8, !tbaa !5
  %95 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 2, i64 0
  %96 = load double, ptr %95, align 8, !tbaa !5
  %97 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 2, i64 0
  %98 = load double, ptr %97, align 8, !tbaa !5
  %99 = fadd double %96, %98
  %100 = fmul double %99, 5.000000e-01
  %101 = fsub double %96, %98
  %102 = fdiv double %101, %43
  %103 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 2, i64 0
  %104 = load double, ptr %103, align 8, !tbaa !5
  %105 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 2, i64 0
  %106 = load double, ptr %105, align 8, !tbaa !5
  %107 = fadd double %104, %106
  %108 = fmul double %21, %107
  %109 = tail call double @llvm.fmuladd.f64(double %17, double %99, double %108)
  %110 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 2, i64 0
  %111 = load double, ptr %110, align 8, !tbaa !5
  %112 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 2, i64 0
  %113 = load double, ptr %112, align 8, !tbaa !5
  %114 = fadd double %111, %113
  %115 = tail call double @llvm.fmuladd.f64(double %23, double %114, double %109)
  %116 = fmul double %115, 5.000000e-01
  %117 = tail call double @llvm.fmuladd.f64(double %30, double %102, double %100)
  %118 = tail call double @llvm.fmuladd.f64(double %33, double %116, double %117)
  %119 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 2, i64 0
  store double %118, ptr %119, align 8, !tbaa !5
  %120 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 0, i64 1
  %121 = load double, ptr %120, align 8, !tbaa !5
  %122 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 0, i64 1
  %123 = load double, ptr %122, align 8, !tbaa !5
  %124 = fadd double %121, %123
  %125 = fmul double %124, 5.000000e-01
  %126 = fsub double %121, %123
  %127 = fdiv double %126, %43
  %128 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 0, i64 1
  %129 = load double, ptr %128, align 8, !tbaa !5
  %130 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 0, i64 1
  %131 = load double, ptr %130, align 8, !tbaa !5
  %132 = fadd double %129, %131
  %133 = fmul double %21, %132
  %134 = tail call double @llvm.fmuladd.f64(double %17, double %124, double %133)
  %135 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 0, i64 1
  %136 = load double, ptr %135, align 8, !tbaa !5
  %137 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 0, i64 1
  %138 = load double, ptr %137, align 8, !tbaa !5
  %139 = fadd double %136, %138
  %140 = tail call double @llvm.fmuladd.f64(double %23, double %139, double %134)
  %141 = fmul double %140, 5.000000e-01
  %142 = tail call double @llvm.fmuladd.f64(double %26, double %127, double %125)
  %143 = tail call double @llvm.fmuladd.f64(double %36, double %141, double %142)
  %144 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 0, i64 1
  store double %143, ptr %144, align 8, !tbaa !5
  %145 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 1, i64 1
  %146 = load double, ptr %145, align 8, !tbaa !5
  %147 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 1, i64 1
  %148 = load double, ptr %147, align 8, !tbaa !5
  %149 = fadd double %146, %148
  %150 = fmul double %149, 5.000000e-01
  %151 = fsub double %146, %148
  %152 = fdiv double %151, %43
  %153 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 1, i64 1
  %154 = load double, ptr %153, align 8, !tbaa !5
  %155 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 1, i64 1
  %156 = load double, ptr %155, align 8, !tbaa !5
  %157 = fadd double %154, %156
  %158 = fmul double %21, %157
  %159 = tail call double @llvm.fmuladd.f64(double %17, double %149, double %158)
  %160 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 1, i64 1
  %161 = load double, ptr %160, align 8, !tbaa !5
  %162 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 1, i64 1
  %163 = load double, ptr %162, align 8, !tbaa !5
  %164 = fadd double %161, %163
  %165 = tail call double @llvm.fmuladd.f64(double %23, double %164, double %159)
  %166 = fmul double %165, 5.000000e-01
  %167 = tail call double @llvm.fmuladd.f64(double %28, double %152, double %150)
  %168 = tail call double @llvm.fmuladd.f64(double %36, double %166, double %167)
  %169 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 1, i64 1
  store double %168, ptr %169, align 8, !tbaa !5
  %170 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 2, i64 1
  %171 = load double, ptr %170, align 8, !tbaa !5
  %172 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 2, i64 1
  %173 = load double, ptr %172, align 8, !tbaa !5
  %174 = fadd double %171, %173
  %175 = fmul double %174, 5.000000e-01
  %176 = fsub double %171, %173
  %177 = fdiv double %176, %43
  %178 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 2, i64 1
  %179 = load double, ptr %178, align 8, !tbaa !5
  %180 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 2, i64 1
  %181 = load double, ptr %180, align 8, !tbaa !5
  %182 = fadd double %179, %181
  %183 = fmul double %21, %182
  %184 = tail call double @llvm.fmuladd.f64(double %17, double %174, double %183)
  %185 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 2, i64 1
  %186 = load double, ptr %185, align 8, !tbaa !5
  %187 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 2, i64 1
  %188 = load double, ptr %187, align 8, !tbaa !5
  %189 = fadd double %186, %188
  %190 = tail call double @llvm.fmuladd.f64(double %23, double %189, double %184)
  %191 = fmul double %190, 5.000000e-01
  %192 = tail call double @llvm.fmuladd.f64(double %30, double %177, double %175)
  %193 = tail call double @llvm.fmuladd.f64(double %36, double %191, double %192)
  %194 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 2, i64 1
  store double %193, ptr %194, align 8, !tbaa !5
  %195 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 0, i64 2
  %196 = load double, ptr %195, align 8, !tbaa !5
  %197 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 0, i64 2
  %198 = load double, ptr %197, align 8, !tbaa !5
  %199 = fadd double %196, %198
  %200 = fmul double %199, 5.000000e-01
  %201 = fsub double %196, %198
  %202 = fdiv double %201, %43
  %203 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 0, i64 2
  %204 = load double, ptr %203, align 8, !tbaa !5
  %205 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 0, i64 2
  %206 = load double, ptr %205, align 8, !tbaa !5
  %207 = fadd double %204, %206
  %208 = fmul double %21, %207
  %209 = tail call double @llvm.fmuladd.f64(double %17, double %199, double %208)
  %210 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 0, i64 2
  %211 = load double, ptr %210, align 8, !tbaa !5
  %212 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 0, i64 2
  %213 = load double, ptr %212, align 8, !tbaa !5
  %214 = fadd double %211, %213
  %215 = tail call double @llvm.fmuladd.f64(double %23, double %214, double %209)
  %216 = fmul double %215, 5.000000e-01
  %217 = tail call double @llvm.fmuladd.f64(double %26, double %202, double %200)
  %218 = tail call double @llvm.fmuladd.f64(double %39, double %216, double %217)
  %219 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 0, i64 2
  store double %218, ptr %219, align 8, !tbaa !5
  %220 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 1, i64 2
  %221 = load double, ptr %220, align 8, !tbaa !5
  %222 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 1, i64 2
  %223 = load double, ptr %222, align 8, !tbaa !5
  %224 = fadd double %221, %223
  %225 = fmul double %224, 5.000000e-01
  %226 = fsub double %221, %223
  %227 = fdiv double %226, %43
  %228 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 1, i64 2
  %229 = load double, ptr %228, align 8, !tbaa !5
  %230 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 1, i64 2
  %231 = load double, ptr %230, align 8, !tbaa !5
  %232 = fadd double %229, %231
  %233 = fmul double %21, %232
  %234 = tail call double @llvm.fmuladd.f64(double %17, double %224, double %233)
  %235 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 1, i64 2
  %236 = load double, ptr %235, align 8, !tbaa !5
  %237 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 1, i64 2
  %238 = load double, ptr %237, align 8, !tbaa !5
  %239 = fadd double %236, %238
  %240 = tail call double @llvm.fmuladd.f64(double %23, double %239, double %234)
  %241 = fmul double %240, 5.000000e-01
  %242 = tail call double @llvm.fmuladd.f64(double %28, double %227, double %225)
  %243 = tail call double @llvm.fmuladd.f64(double %39, double %241, double %242)
  %244 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 1, i64 2
  store double %243, ptr %244, align 8, !tbaa !5
  %245 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %indvars.iv152, i64 2, i64 2
  %246 = load double, ptr %245, align 8, !tbaa !5
  %247 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %4, i64 %44, i64 2, i64 2
  %248 = load double, ptr %247, align 8, !tbaa !5
  %249 = fadd double %246, %248
  %250 = fmul double %249, 5.000000e-01
  %251 = fsub double %246, %248
  %252 = fdiv double %251, %43
  %253 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %44, i64 2, i64 2
  %254 = load double, ptr %253, align 8, !tbaa !5
  %255 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %11, i64 %indvars.iv152, i64 2, i64 2
  %256 = load double, ptr %255, align 8, !tbaa !5
  %257 = fadd double %254, %256
  %258 = fmul double %21, %257
  %259 = tail call double @llvm.fmuladd.f64(double %17, double %249, double %258)
  %260 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %44, i64 2, i64 2
  %261 = load double, ptr %260, align 8, !tbaa !5
  %262 = getelementptr inbounds [32 x [32 x [3 x [3 x double]]]], ptr @f_plus, i64 0, i64 %7, i64 %indvars.iv152, i64 2, i64 2
  %263 = load double, ptr %262, align 8, !tbaa !5
  %264 = fadd double %261, %263
  %265 = tail call double @llvm.fmuladd.f64(double %23, double %264, double %259)
  %266 = fmul double %265, 5.000000e-01
  %267 = tail call double @llvm.fmuladd.f64(double %30, double %252, double %250)
  %268 = tail call double @llvm.fmuladd.f64(double %39, double %266, double %267)
  %269 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv152, i64 2, i64 2
  store double %268, ptr %269, align 8, !tbaa !5
  %indvars.iv.next153 = add nuw nsw i64 %indvars.iv152, 1
  %exitcond155.not = icmp eq i64 %indvars.iv.next153, 32
  br i1 %exitcond155.not, label %.preheader131, label %.preheader132, !llvm.loop !9

.preheader130:                                    ; preds = %.preheader131, %.preheader130
  %indvars.iv172 = phi i64 [ 1, %.preheader131 ], [ %indvars.iv.next173, %.preheader130 ]
  %270 = load double, ptr @ex, align 16, !tbaa !5
  %271 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 0, i64 0
  %272 = load double, ptr %271, align 8, !tbaa !5
  %273 = fadd double %272, 0.000000e+00
  %274 = tail call double @llvm.fmuladd.f64(double %270, double %272, double 0.000000e+00)
  %275 = load double, ptr @ey, align 16, !tbaa !5
  %276 = tail call double @llvm.fmuladd.f64(double %275, double %272, double 0.000000e+00)
  %277 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 0, i64 1
  %278 = load double, ptr %277, align 8, !tbaa !5
  %279 = fadd double %273, %278
  %280 = tail call double @llvm.fmuladd.f64(double %270, double %278, double %274)
  %281 = load double, ptr getelementptr inbounds (i8, ptr @ey, i64 8), align 8, !tbaa !5
  %282 = tail call double @llvm.fmuladd.f64(double %281, double %278, double %276)
  %283 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 0, i64 2
  %284 = load double, ptr %283, align 8, !tbaa !5
  %285 = fadd double %279, %284
  %286 = tail call double @llvm.fmuladd.f64(double %270, double %284, double %280)
  %287 = load double, ptr getelementptr inbounds (i8, ptr @ey, i64 16), align 16, !tbaa !5
  %288 = tail call double @llvm.fmuladd.f64(double %287, double %284, double %282)
  %289 = load double, ptr getelementptr inbounds (i8, ptr @ex, i64 8), align 8, !tbaa !5
  %290 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 1, i64 0
  %291 = load double, ptr %290, align 8, !tbaa !5
  %292 = fadd double %285, %291
  %293 = tail call double @llvm.fmuladd.f64(double %289, double %291, double %286)
  %294 = tail call double @llvm.fmuladd.f64(double %275, double %291, double %288)
  %295 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 1, i64 1
  %296 = load double, ptr %295, align 8, !tbaa !5
  %297 = fadd double %292, %296
  %298 = tail call double @llvm.fmuladd.f64(double %289, double %296, double %293)
  %299 = tail call double @llvm.fmuladd.f64(double %281, double %296, double %294)
  %300 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 1, i64 2
  %301 = load double, ptr %300, align 8, !tbaa !5
  %302 = fadd double %297, %301
  %303 = tail call double @llvm.fmuladd.f64(double %289, double %301, double %298)
  %304 = tail call double @llvm.fmuladd.f64(double %287, double %301, double %299)
  %305 = load double, ptr getelementptr inbounds (i8, ptr @ex, i64 16), align 16, !tbaa !5
  %306 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 2, i64 0
  %307 = load double, ptr %306, align 8, !tbaa !5
  %308 = fadd double %302, %307
  %309 = tail call double @llvm.fmuladd.f64(double %305, double %307, double %303)
  %310 = tail call double @llvm.fmuladd.f64(double %275, double %307, double %304)
  %311 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 2, i64 1
  %312 = load double, ptr %311, align 8, !tbaa !5
  %313 = fadd double %308, %312
  %314 = tail call double @llvm.fmuladd.f64(double %305, double %312, double %309)
  %315 = tail call double @llvm.fmuladd.f64(double %281, double %312, double %310)
  %316 = getelementptr inbounds [33 x [3 x [3 x double]]], ptr @xf_face, i64 0, i64 %indvars.iv172, i64 2, i64 2
  %317 = load double, ptr %316, align 8, !tbaa !5
  %318 = fadd double %313, %317
  %319 = tail call double @llvm.fmuladd.f64(double %305, double %317, double %314)
  %320 = tail call double @llvm.fmuladd.f64(double %287, double %317, double %315)
  %321 = fdiv double %319, %318
  %322 = fdiv double %320, %318
  %323 = load double, ptr @wb, align 8, !tbaa !5
  %324 = tail call double @llvm.fmuladd.f64(double %323, double -5.000000e-01, double 1.000000e+00)
  %325 = fmul double %323, 5.000000e-01
  %326 = tail call double @feq(i32 noundef 0, i32 noundef 0, double noundef %321, double noundef %322, double noundef %318)
  %327 = fmul double %325, %326
  %328 = tail call double @llvm.fmuladd.f64(double %324, double %272, double %327)
  store double %328, ptr %271, align 8, !tbaa !5
  %329 = load double, ptr @wb, align 8, !tbaa !5
  %330 = tail call double @llvm.fmuladd.f64(double %329, double -5.000000e-01, double 1.000000e+00)
  %331 = load double, ptr %277, align 8, !tbaa !5
  %332 = fmul double %329, 5.000000e-01
  %333 = tail call double @feq(i32 noundef 0, i32 noundef 1, double noundef %321, double noundef %322, double noundef %318)
  %334 = fmul double %332, %333
  %335 = tail call double @llvm.fmuladd.f64(double %330, double %331, double %334)
  store double %335, ptr %277, align 8, !tbaa !5
  %336 = load double, ptr @wb, align 8, !tbaa !5
  %337 = tail call double @llvm.fmuladd.f64(double %336, double -5.000000e-01, double 1.000000e+00)
  %338 = load double, ptr %283, align 8, !tbaa !5
  %339 = fmul double %336, 5.000000e-01
  %340 = tail call double @feq(i32 noundef 0, i32 noundef 2, double noundef %321, double noundef %322, double noundef %318)
  %341 = fmul double %339, %340
  %342 = tail call double @llvm.fmuladd.f64(double %337, double %338, double %341)
  store double %342, ptr %283, align 8, !tbaa !5
  %343 = load double, ptr @wb, align 8, !tbaa !5
  %344 = tail call double @llvm.fmuladd.f64(double %343, double -5.000000e-01, double 1.000000e+00)
  %345 = load double, ptr %290, align 8, !tbaa !5
  %346 = fmul double %343, 5.000000e-01
  %347 = tail call double @feq(i32 noundef 1, i32 noundef 0, double noundef %321, double noundef %322, double noundef %318)
  %348 = fmul double %346, %347
  %349 = tail call double @llvm.fmuladd.f64(double %344, double %345, double %348)
  store double %349, ptr %290, align 8, !tbaa !5
  %350 = load double, ptr @wb, align 8, !tbaa !5
  %351 = tail call double @llvm.fmuladd.f64(double %350, double -5.000000e-01, double 1.000000e+00)
  %352 = load double, ptr %295, align 8, !tbaa !5
  %353 = fmul double %350, 5.000000e-01
  %354 = tail call double @feq(i32 noundef 1, i32 noundef 1, double noundef %321, double noundef %322, double noundef %318)
  %355 = fmul double %353, %354
  %356 = tail call double @llvm.fmuladd.f64(double %351, double %352, double %355)
  store double %356, ptr %295, align 8, !tbaa !5
  %357 = load double, ptr @wb, align 8, !tbaa !5
  %358 = tail call double @llvm.fmuladd.f64(double %357, double -5.000000e-01, double 1.000000e+00)
  %359 = load double, ptr %300, align 8, !tbaa !5
  %360 = fmul double %357, 5.000000e-01
  %361 = tail call double @feq(i32 noundef 1, i32 noundef 2, double noundef %321, double noundef %322, double noundef %318)
  %362 = fmul double %360, %361
  %363 = tail call double @llvm.fmuladd.f64(double %358, double %359, double %362)
  store double %363, ptr %300, align 8, !tbaa !5
  %364 = load double, ptr @wb, align 8, !tbaa !5
  %365 = tail call double @llvm.fmuladd.f64(double %364, double -5.000000e-01, double 1.000000e+00)
  %366 = load double, ptr %306, align 8, !tbaa !5
  %367 = fmul double %364, 5.000000e-01
  %368 = tail call double @feq(i32 noundef 2, i32 noundef 0, double noundef %321, double noundef %322, double noundef %318)
  %369 = fmul double %367, %368
  %370 = tail call double @llvm.fmuladd.f64(double %365, double %366, double %369)
  store double %370, ptr %306, align 8, !tbaa !5
  %371 = load double, ptr @wb, align 8, !tbaa !5
  %372 = tail call double @llvm.fmuladd.f64(double %371, double -5.000000e-01, double 1.000000e+00)
  %373 = load double, ptr %311, align 8, !tbaa !5
  %374 = fmul double %371, 5.000000e-01
  %375 = tail call double @feq(i32 noundef 2, i32 noundef 1, double noundef %321, double noundef %322, double noundef %318)
  %376 = fmul double %374, %375
  %377 = tail call double @llvm.fmuladd.f64(double %372, double %373, double %376)
  store double %377, ptr %311, align 8, !tbaa !5
  %378 = load double, ptr @wb, align 8, !tbaa !5
  %379 = tail call double @llvm.fmuladd.f64(double %378, double -5.000000e-01, double 1.000000e+00)
  %380 = load double, ptr %316, align 8, !tbaa !5
  %381 = fmul double %378, 5.000000e-01
  %382 = tail call double @feq(i32 noundef 2, i32 noundef 2, double noundef %321, double noundef %322, double noundef %318)
  %383 = fmul double %381, %382
  %384 = tail call double @llvm.fmuladd.f64(double %379, double %380, double %383)
  store double %384, ptr %316, align 8, !tbaa !5
  %indvars.iv.next173 = add nuw nsw i64 %indvars.iv172, 1
  %exitcond175.not = icmp eq i64 %indvars.iv.next173, 32
  br i1 %exitcond175.not, label %385, label %.preheader130, !llvm.loop !11

385:                                              ; preds = %.preheader130
  ret void
}

attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #1 = { 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, !6, i64 0}
!6 = !{!"double", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = distinct !{!11, !10}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass