; LLVM IR from CLASS-SZ/class_sz :: class-sz/tools (r8lib)

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

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

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

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

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local double @r8mat_det_4d(ptr noundef) #3

; Function Attrs: nounwind uwtable
define dso_local ptr @r8mat_inverse_4d(ptr noundef %0) #3 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca double, align 8
  %6 = alloca i32, align 4
  store ptr %0, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #4
  %7 = load ptr, ptr %3, align 8, !tbaa !5
  %8 = call double @r8mat_det_4d(ptr noundef %7)
  store double %8, ptr %5, align 8, !tbaa !9
  %9 = load double, ptr %5, align 8, !tbaa !9
  %10 = fcmp oeq double %9, 0.000000e+00
  br i1 %10, label %11, label %12

11:                                               ; preds = %1
  store ptr null, ptr %2, align 8
  store i32 1, ptr %6, align 4
  br label %999

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

999:                                              ; preds = %12, %11
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #4
  %1000 = load ptr, ptr %2, align 8
  ret ptr %1000
}

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}


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

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

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare dso_local double @r8mat_det_4d(ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local noalias noundef ptr @r8mat_inverse_4d(ptr noundef %0) local_unnamed_addr #2 {
  %2 = tail call double @r8mat_det_4d(ptr noundef %0)
  %3 = fcmp oeq double %2, 0.000000e+00
  br i1 %3, label %182, label %4

4:                                                ; preds = %1
  %5 = tail call noalias dereferenceable_or_null(128) ptr @malloc(i64 noundef 128) #3
  %6 = getelementptr inbounds i8, ptr %0, i64 40
  %7 = load double, ptr %6, align 8, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %0, i64 80
  %9 = load double, ptr %8, align 8, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %0, i64 120
  %11 = load double, ptr %10, align 8, !tbaa !5
  %12 = getelementptr inbounds i8, ptr %0, i64 112
  %13 = load double, ptr %12, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %0, i64 88
  %15 = load double, ptr %14, align 8, !tbaa !5
  %16 = fneg double %13
  %17 = fmul double %15, %16
  %18 = tail call double @llvm.fmuladd.f64(double %9, double %11, double %17)
  %19 = getelementptr inbounds i8, ptr %0, i64 72
  %20 = load double, ptr %19, align 8, !tbaa !5
  %21 = getelementptr inbounds i8, ptr %0, i64 56
  %22 = load double, ptr %21, align 8, !tbaa !5
  %23 = getelementptr inbounds i8, ptr %0, i64 48
  %24 = load double, ptr %23, align 8, !tbaa !5
  %25 = fneg double %24
  %26 = fmul double %11, %25
  %27 = tail call double @llvm.fmuladd.f64(double %13, double %22, double %26)
  %28 = fmul double %20, %27
  %29 = tail call double @llvm.fmuladd.f64(double %7, double %18, double %28)
  %30 = getelementptr inbounds i8, ptr %0, i64 104
  %31 = load double, ptr %30, align 8, !tbaa !5
  %32 = fneg double %9
  %33 = fmul double %22, %32
  %34 = tail call double @llvm.fmuladd.f64(double %24, double %15, double %33)
  %35 = tail call double @llvm.fmuladd.f64(double %31, double %34, double %29)
  %36 = getelementptr inbounds i8, ptr %0, i64 8
  %37 = load double, ptr %36, align 8, !tbaa !5
  %38 = getelementptr inbounds i8, ptr %0, i64 24
  %39 = load double, ptr %38, align 8, !tbaa !5
  %40 = getelementptr inbounds i8, ptr %0, i64 16
  %41 = load double, ptr %40, align 8, !tbaa !5
  %42 = fneg double %41
  %43 = fmul double %11, %42
  %44 = tail call double @llvm.fmuladd.f64(double %13, double %39, double %43)
  %45 = fmul double %20, %44
  %46 = tail call double @llvm.fmuladd.f64(double %37, double %18, double %45)
  %47 = fmul double %39, %32
  %48 = tail call double @llvm.fmuladd.f64(double %41, double %15, double %47)
  %49 = tail call double @llvm.fmuladd.f64(double %31, double %48, double %46)
  %50 = fneg double %49
  %51 = insertelement <2 x double> poison, double %35, i64 0
  %52 = insertelement <2 x double> %51, double %50, i64 1
  %53 = insertelement <2 x double> poison, double %2, i64 0
  %54 = shufflevector <2 x double> %53, <2 x double> poison, <2 x i32> zeroinitializer
  %55 = fdiv <2 x double> %52, %54
  store <2 x double> %55, ptr %5, align 8, !tbaa !5
  %56 = fmul double %22, %16
  %57 = tail call double @llvm.fmuladd.f64(double %24, double %11, double %56)
  %58 = fmul double %7, %44
  %59 = tail call double @llvm.fmuladd.f64(double %37, double %57, double %58)
  %60 = fmul double %39, %25
  %61 = tail call double @llvm.fmuladd.f64(double %41, double %22, double %60)
  %62 = tail call double @llvm.fmuladd.f64(double %31, double %61, double %59)
  %63 = getelementptr inbounds i8, ptr %5, i64 16
  %64 = fmul double %15, %42
  %65 = tail call double @llvm.fmuladd.f64(double %9, double %39, double %64)
  %66 = fmul double %7, %65
  %67 = tail call double @llvm.fmuladd.f64(double %37, double %34, double %66)
  %68 = tail call double @llvm.fmuladd.f64(double %20, double %61, double %67)
  %69 = fneg double %68
  %70 = insertelement <2 x double> poison, double %62, i64 0
  %71 = insertelement <2 x double> %70, double %69, i64 1
  %72 = fdiv <2 x double> %71, %54
  store <2 x double> %72, ptr %63, align 8, !tbaa !5
  %73 = getelementptr inbounds i8, ptr %0, i64 32
  %74 = load double, ptr %73, align 8, !tbaa !5
  %75 = getelementptr inbounds i8, ptr %0, i64 64
  %76 = load double, ptr %75, align 8, !tbaa !5
  %77 = fmul double %27, %76
  %78 = tail call double @llvm.fmuladd.f64(double %74, double %18, double %77)
  %79 = getelementptr inbounds i8, ptr %0, i64 96
  %80 = load double, ptr %79, align 8, !tbaa !5
  %81 = tail call double @llvm.fmuladd.f64(double %80, double %34, double %78)
  %82 = fneg double %81
  %83 = getelementptr inbounds i8, ptr %5, i64 32
  %84 = load double, ptr %0, align 8, !tbaa !5
  %85 = fmul double %44, %76
  %86 = tail call double @llvm.fmuladd.f64(double %84, double %18, double %85)
  %87 = tail call double @llvm.fmuladd.f64(double %80, double %48, double %86)
  %88 = insertelement <2 x double> poison, double %82, i64 0
  %89 = insertelement <2 x double> %88, double %87, i64 1
  %90 = fdiv <2 x double> %89, %54
  store <2 x double> %90, ptr %83, align 8, !tbaa !5
  %91 = fmul double %44, %74
  %92 = tail call double @llvm.fmuladd.f64(double %84, double %57, double %91)
  %93 = tail call double @llvm.fmuladd.f64(double %80, double %61, double %92)
  %94 = fneg double %93
  %95 = getelementptr inbounds i8, ptr %5, i64 48
  %96 = fmul double %65, %74
  %97 = tail call double @llvm.fmuladd.f64(double %84, double %34, double %96)
  %98 = tail call double @llvm.fmuladd.f64(double %76, double %61, double %97)
  %99 = insertelement <2 x double> poison, double %94, i64 0
  %100 = insertelement <2 x double> %99, double %98, i64 1
  %101 = fdiv <2 x double> %100, %54
  store <2 x double> %101, ptr %95, align 8, !tbaa !5
  %102 = fneg double %31
  %103 = fmul double %15, %102
  %104 = tail call double @llvm.fmuladd.f64(double %20, double %11, double %103)
  %105 = fneg double %7
  %106 = fmul double %11, %105
  %107 = tail call double @llvm.fmuladd.f64(double %31, double %22, double %106)
  %108 = fmul double %107, %76
  %109 = tail call double @llvm.fmuladd.f64(double %74, double %104, double %108)
  %110 = fneg double %20
  %111 = fmul double %22, %110
  %112 = tail call double @llvm.fmuladd.f64(double %7, double %15, double %111)
  %113 = tail call double @llvm.fmuladd.f64(double %80, double %112, double %109)
  %114 = getelementptr inbounds i8, ptr %5, i64 64
  %115 = fneg double %37
  %116 = fmul double %11, %115
  %117 = tail call double @llvm.fmuladd.f64(double %31, double %39, double %116)
  %118 = fmul double %117, %76
  %119 = tail call double @llvm.fmuladd.f64(double %84, double %104, double %118)
  %120 = fmul double %39, %110
  %121 = tail call double @llvm.fmuladd.f64(double %37, double %15, double %120)
  %122 = tail call double @llvm.fmuladd.f64(double %80, double %121, double %119)
  %123 = fneg double %122
  %124 = insertelement <2 x double> poison, double %113, i64 0
  %125 = insertelement <2 x double> %124, double %123, i64 1
  %126 = fdiv <2 x double> %125, %54
  store <2 x double> %126, ptr %114, align 8, !tbaa !5
  %127 = fmul double %22, %102
  %128 = tail call double @llvm.fmuladd.f64(double %7, double %11, double %127)
  %129 = fmul double %117, %74
  %130 = tail call double @llvm.fmuladd.f64(double %84, double %128, double %129)
  %131 = fmul double %39, %105
  %132 = tail call double @llvm.fmuladd.f64(double %37, double %22, double %131)
  %133 = tail call double @llvm.fmuladd.f64(double %80, double %132, double %130)
  %134 = getelementptr inbounds i8, ptr %5, i64 80
  %135 = fmul double %15, %115
  %136 = tail call double @llvm.fmuladd.f64(double %20, double %39, double %135)
  %137 = fmul double %136, %74
  %138 = tail call double @llvm.fmuladd.f64(double %84, double %112, double %137)
  %139 = tail call double @llvm.fmuladd.f64(double %76, double %132, double %138)
  %140 = fneg double %139
  %141 = insertelement <2 x double> poison, double %133, i64 0
  %142 = insertelement <2 x double> %141, double %140, i64 1
  %143 = fdiv <2 x double> %142, %54
  store <2 x double> %143, ptr %134, align 8, !tbaa !5
  %144 = fmul double %9, %102
  %145 = tail call double @llvm.fmuladd.f64(double %20, double %13, double %144)
  %146 = fmul double %13, %105
  %147 = tail call double @llvm.fmuladd.f64(double %31, double %24, double %146)
  %148 = fmul double %147, %76
  %149 = tail call double @llvm.fmuladd.f64(double %74, double %145, double %148)
  %150 = fmul double %24, %110
  %151 = tail call double @llvm.fmuladd.f64(double %7, double %9, double %150)
  %152 = tail call double @llvm.fmuladd.f64(double %80, double %151, double %149)
  %153 = fneg double %152
  %154 = getelementptr inbounds i8, ptr %5, i64 96
  %155 = fmul double %13, %115
  %156 = tail call double @llvm.fmuladd.f64(double %31, double %41, double %155)
  %157 = fmul double %156, %76
  %158 = tail call double @llvm.fmuladd.f64(double %84, double %145, double %157)
  %159 = fmul double %41, %110
  %160 = tail call double @llvm.fmuladd.f64(double %37, double %9, double %159)
  %161 = tail call double @llvm.fmuladd.f64(double %80, double %160, double %158)
  %162 = insertelement <2 x double> poison, double %153, i64 0
  %163 = insertelement <2 x double> %162, double %161, i64 1
  %164 = fdiv <2 x double> %163, %54
  store <2 x double> %164, ptr %154, align 8, !tbaa !5
  %165 = fmul double %24, %102
  %166 = tail call double @llvm.fmuladd.f64(double %7, double %13, double %165)
  %167 = fmul double %156, %74
  %168 = tail call double @llvm.fmuladd.f64(double %84, double %166, double %167)
  %169 = fmul double %41, %105
  %170 = tail call double @llvm.fmuladd.f64(double %37, double %24, double %169)
  %171 = tail call double @llvm.fmuladd.f64(double %80, double %170, double %168)
  %172 = fneg double %171
  %173 = getelementptr inbounds i8, ptr %5, i64 112
  %174 = fmul double %9, %115
  %175 = tail call double @llvm.fmuladd.f64(double %20, double %41, double %174)
  %176 = fmul double %175, %74
  %177 = tail call double @llvm.fmuladd.f64(double %84, double %151, double %176)
  %178 = tail call double @llvm.fmuladd.f64(double %76, double %170, double %177)
  %179 = insertelement <2 x double> poison, double %172, i64 0
  %180 = insertelement <2 x double> %179, double %178, i64 1
  %181 = fdiv <2 x double> %180, %54
  store <2 x double> %181, ptr %173, align 8, !tbaa !5
  br label %182

182:                                              ; preds = %1, %4
  %.0 = phi ptr [ %5, %4 ], [ null, %1 ]
  ret ptr %.0
}

attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #1 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "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 = { 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 allocsize(0) }

!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"}


; Effective O3 passes: EarlyCSEPass,GlobalOptPass,InferFunctionAttrsPass,InstCombinePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass