; LLVM IR from sourceryinstitute/MORFEUS-Source :: src/FV/src/mesh_optimize/OptMS (SMsearch)

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

%struct.__SMlocal_mesh = type { i32, i32, i32, [3 x double], [3 x double], [3 x double], ptr, ptr, ptr, i32, double, ptr, double, i32, i32, i32, ptr, ptr, ptr }
%struct.__SMoptimal = type { i32, i32, i32, i32, i32, i32, i32, double, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, [3 x double], double, double, ptr, ptr, ptr, ptr, [3 x i32], i32 }
%struct.__SMactive = type { i32, i32, ptr, double }

@.str = external hidden unnamed_addr constant [18 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [108 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [27 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @SMsearchDirection(ptr noundef %0) #0 {
  %2 = alloca i32, align 4
  %3 = alloca ptr, align 8
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca double, align 8
  %12 = alloca double, align 8
  %13 = alloca double, align 8
  %14 = alloca double, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca ptr, align 8
  %22 = alloca double, align 8
  %23 = alloca ptr, align 8
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca double, align 8
  store ptr %0, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #5
  %31 = load ptr, ptr %3, align 8, !tbaa !5
  %32 = icmp eq ptr %31, null
  br i1 %32, label %33, label %35

33:                                               ; preds = %1
  %34 = call i32 @SMerror(i32 noundef 33, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 56, i32 noundef 0, ptr noundef null)
  store i32 %34, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

35:                                               ; preds = %1
  %36 = load ptr, ptr %3, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.__SMlocal_mesh, ptr %36, i32 0, i32 16
  %38 = load ptr, ptr %37, align 8, !tbaa !9
  store ptr %38, ptr %23, align 8, !tbaa !5
  %39 = load ptr, ptr %23, align 8, !tbaa !5
  %40 = getelementptr inbounds %struct.__SMoptimal, ptr %39, i32 0, i32 11
  %41 = load ptr, ptr %40, align 8, !tbaa !13
  store ptr %41, ptr %15, align 8, !tbaa !5
  %42 = load ptr, ptr %23, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.__SMoptimal, ptr %42, i32 0, i32 14
  %44 = load ptr, ptr %43, align 8, !tbaa !15
  %45 = getelementptr inbounds %struct.__SMactive, ptr %44, i32 0, i32 0
  %46 = load i32, ptr %45, align 8, !tbaa !16
  store i32 %46, ptr %6, align 4, !tbaa !18
  %47 = load ptr, ptr %23, align 8, !tbaa !5
  %48 = getelementptr inbounds %struct.__SMoptimal, ptr %47, i32 0, i32 14
  %49 = load ptr, ptr %48, align 8, !tbaa !15
  %50 = getelementptr inbounds %struct.__SMactive, ptr %49, i32 0, i32 2
  %51 = load ptr, ptr %50, align 8, !tbaa !19
  store ptr %51, ptr %7, align 8, !tbaa !5
  %52 = load i32, ptr %6, align 4, !tbaa !18
  %53 = icmp eq i32 %52, 0
  br i1 %53, label %54, label %56

54:                                               ; preds = %35
  %55 = call i32 @SMerror(i32 noundef 42, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 57, i32 noundef 0, ptr noundef @.str.3)
  store i32 %55, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

56:                                               ; preds = %35
  %57 = load ptr, ptr %3, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.__SMlocal_mesh, ptr %57, i32 0, i32 0
  %59 = load i32, ptr %58, align 8, !tbaa !20
  store i32 %59, ptr %9, align 4, !tbaa !18
  %60 = load i32, ptr %6, align 4, !tbaa !18
  switch i32 %60, label %458 [
    i32 1, label %61
    i32 2, label %162
  ]

61:                                               ; preds = %56
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #5
  %62 = load i32, ptr %9, align 4, !tbaa !18
  %63 = icmp eq i32 %62, 2
  br i1 %63, label %64, label %89

64:                                               ; preds = %61
  %65 = load ptr, ptr %15, align 8, !tbaa !5
  %66 = load ptr, ptr %7, align 8, !tbaa !5
  %67 = getelementptr inbounds i32, ptr %66, i64 0
  %68 = load i32, ptr %67, align 4, !tbaa !18
  %69 = sext i32 %68 to i64
  %70 = getelementptr inbounds ptr, ptr %65, i64 %69
  %71 = load ptr, ptr %70, align 8, !tbaa !5
  %72 = getelementptr inbounds double, ptr %71, i64 0
  %73 = load double, ptr %72, align 8, !tbaa !21
  %74 = load ptr, ptr %23, align 8, !tbaa !5
  %75 = getelementptr inbounds %struct.__SMoptimal, ptr %74, i32 0, i32 18
  %76 = getelementptr inbounds [3 x double], ptr %75, i64 0, i64 0
  store double %73, ptr %76, align 8, !tbaa !21
  %77 = load ptr, ptr %15, align 8, !tbaa !5
  %78 = load ptr, ptr %7, align 8, !tbaa !5
  %79 = getelementptr inbounds i32, ptr %78, i64 0
  %80 = load i32, ptr %79, align 4, !tbaa !18
  %81 = sext i32 %80 to i64
  %82 = getelementptr inbounds ptr, ptr %77, i64 %81
  %83 = load ptr, ptr %82, align 8, !tbaa !5
  %84 = getelementptr inbounds double, ptr %83, i64 1
  %85 = load double, ptr %84, align 8, !tbaa !21
  %86 = load ptr, ptr %23, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.__SMoptimal, ptr %86, i32 0, i32 18
  %88 = getelementptr inbounds [3 x double], ptr %87, i64 0, i64 1
  store double %85, ptr %88, align 8, !tbaa !21
  br label %156

89:                                               ; preds = %61
  %90 = load i32, ptr %9, align 4, !tbaa !18
  %91 = icmp eq i32 %90, 3
  br i1 %91, label %92, label %129

92:                                               ; preds = %89
  %93 = load ptr, ptr %15, align 8, !tbaa !5
  %94 = load ptr, ptr %7, align 8, !tbaa !5
  %95 = getelementptr inbounds i32, ptr %94, i64 0
  %96 = load i32, ptr %95, align 4, !tbaa !18
  %97 = sext i32 %96 to i64
  %98 = getelementptr inbounds ptr, ptr %93, i64 %97
  %99 = load ptr, ptr %98, align 8, !tbaa !5
  %100 = getelementptr inbounds double, ptr %99, i64 0
  %101 = load double, ptr %100, align 8, !tbaa !21
  %102 = load ptr, ptr %23, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.__SMoptimal, ptr %102, i32 0, i32 18
  %104 = getelementptr inbounds [3 x double], ptr %103, i64 0, i64 0
  store double %101, ptr %104, align 8, !tbaa !21
  %105 = load ptr, ptr %15, align 8, !tbaa !5
  %106 = load ptr, ptr %7, align 8, !tbaa !5
  %107 = getelementptr inbounds i32, ptr %106, i64 0
  %108 = load i32, ptr %107, align 4, !tbaa !18
  %109 = sext i32 %108 to i64
  %110 = getelementptr inbounds ptr, ptr %105, i64 %109
  %111 = load ptr, ptr %110, align 8, !tbaa !5
  %112 = getelementptr inbounds double, ptr %111, i64 1
  %113 = load double, ptr %112, align 8, !tbaa !21
  %114 = load ptr, ptr %23, align 8, !tbaa !5
  %115 = getelementptr inbounds %struct.__SMoptimal, ptr %114, i32 0, i32 18
  %116 = getelementptr inbounds [3 x double], ptr %115, i64 0, i64 1
  store double %113, ptr %116, align 8, !tbaa !21
  %117 = load ptr, ptr %15, align 8, !tbaa !5
  %118 = load ptr, ptr %7, align 8, !tbaa !5
  %119 = getelementptr inbounds i32, ptr %118, i64 0
  %120 = load i32, ptr %119, align 4, !tbaa !18
  %121 = sext i32 %120 to i64
  %122 = getelementptr inbounds ptr, ptr %117, i64 %121
  %123 = load ptr, ptr %122, align 8, !tbaa !5
  %124 = getelementptr inbounds double, ptr %123, i64 2
  %125 = load double, ptr %124, align 8, !tbaa !21
  %126 = load ptr, ptr %23, align 8, !tbaa !5
  %127 = getelementptr inbounds %struct.__SMoptimal, ptr %126, i32 0, i32 18
  %128 = getelementptr inbounds [3 x double], ptr %127, i64 0, i64 2
  store double %125, ptr %128, align 8, !tbaa !21
  br label %155

129:                                              ; preds = %89
  store i32 0, ptr %25, align 4, !tbaa !18
  br label %130

130:                                              ; preds = %151, %129
  %131 = load i32, ptr %25, align 4, !tbaa !18
  %132 = load i32, ptr %9, align 4, !tbaa !18
  %133 = icmp slt i32 %131, %132
  br i1 %133, label %134, label %154

134:                                              ; preds = %130
  %135 = load ptr, ptr %15, align 8, !tbaa !5
  %136 = load ptr, ptr %7, align 8, !tbaa !5
  %137 = getelementptr inbounds i32, ptr %136, i64 0
  %138 = load i32, ptr %137, align 4, !tbaa !18
  %139 = sext i32 %138 to i64
  %140 = getelementptr inbounds ptr, ptr %135, i64 %139
  %141 = load ptr, ptr %140, align 8, !tbaa !5
  %142 = load i32, ptr %25, align 4, !tbaa !18
  %143 = sext i32 %142 to i64
  %144 = getelementptr inbounds double, ptr %141, i64 %143
  %145 = load double, ptr %144, align 8, !tbaa !21
  %146 = load ptr, ptr %23, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.__SMoptimal, ptr %146, i32 0, i32 18
  %148 = load i32, ptr %25, align 4, !tbaa !18
  %149 = sext i32 %148 to i64
  %150 = getelementptr inbounds [3 x double], ptr %147, i64 0, i64 %149
  store double %145, ptr %150, align 8, !tbaa !21
  br label %151

151:                                              ; preds = %134
  %152 = load i32, ptr %25, align 4, !tbaa !18
  %153 = add nsw i32 %152, 1
  store i32 %153, ptr %25, align 4, !tbaa !18
  br label %130, !llvm.loop !22

154:                                              ; preds = %130
  br label %155

155:                                              ; preds = %154, %92
  br label %156

156:                                              ; preds = %155, %64
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  %157 = load ptr, ptr %7, align 8, !tbaa !5
  %158 = getelementptr inbounds i32, ptr %157, i64 0
  %159 = load i32, ptr %158, align 4, !tbaa !18
  %160 = load ptr, ptr %23, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.__SMoptimal, ptr %160, i32 0, i32 17
  store i32 %159, ptr %161, align 8, !tbaa !24
  br label %758

162:                                              ; preds = %56
  %163 = load i32, ptr %6, align 4, !tbaa !18
  %164 = load ptr, ptr %15, align 8, !tbaa !5
  %165 = load ptr, ptr %7, align 8, !tbaa !5
  %166 = load i32, ptr %9, align 4, !tbaa !18
  %167 = call i32 @SMgetActiveDirections(i32 noundef %163, ptr noundef %164, ptr noundef %165, i32 noundef %166, ptr noundef %16)
  store i32 %167, ptr %4, align 4, !tbaa !18
  %168 = load i32, ptr %4, align 4, !tbaa !18
  %169 = icmp ne i32 %168, 0
  br i1 %169, label %170, label %173

170:                                              ; preds = %162
  %171 = load i32, ptr %4, align 4, !tbaa !18
  %172 = call i32 @SMerror(i32 noundef 58, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %171, i32 noundef 0, ptr noundef null)
  store i32 %172, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

173:                                              ; preds = %162
  %174 = load i32, ptr %6, align 4, !tbaa !18
  %175 = load ptr, ptr %16, align 8, !tbaa !5
  %176 = load ptr, ptr %23, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.__SMoptimal, ptr %176, i32 0, i32 23
  %178 = load ptr, ptr %177, align 8, !tbaa !25
  %179 = load i32, ptr %9, align 4, !tbaa !18
  %180 = call i32 @SMformGrammian(i32 noundef %174, ptr noundef %175, ptr noundef %178, i32 noundef %179)
  store i32 %180, ptr %4, align 4, !tbaa !18
  %181 = load i32, ptr %4, align 4, !tbaa !18
  %182 = icmp ne i32 %181, 0
  br i1 %182, label %183, label %186

183:                                              ; preds = %173
  %184 = load i32, ptr %4, align 4, !tbaa !18
  %185 = call i32 @SMerror(i32 noundef 61, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %184, i32 noundef 0, ptr noundef null)
  store i32 %185, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

186:                                              ; preds = %173
  %187 = load ptr, ptr %23, align 8, !tbaa !5
  %188 = call i32 @SMformPDGrammian(ptr noundef %187)
  store i32 %188, ptr %4, align 4, !tbaa !18
  %189 = load i32, ptr %4, align 4, !tbaa !18
  %190 = icmp ne i32 %189, 0
  br i1 %190, label %191, label %194

191:                                              ; preds = %186
  %192 = load i32, ptr %4, align 4, !tbaa !18
  %193 = call i32 @SMerror(i32 noundef 62, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %192, i32 noundef 0, ptr noundef null)
  store i32 %193, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

194:                                              ; preds = %186
  %195 = load ptr, ptr %23, align 8, !tbaa !5
  %196 = getelementptr inbounds %struct.__SMoptimal, ptr %195, i32 0, i32 23
  %197 = load ptr, ptr %196, align 8, !tbaa !25
  store ptr %197, ptr %19, align 8, !tbaa !5
  %198 = load ptr, ptr %19, align 8, !tbaa !5
  %199 = getelementptr inbounds ptr, ptr %198, i64 0
  %200 = load ptr, ptr %199, align 8, !tbaa !5
  %201 = getelementptr inbounds double, ptr %200, i64 0
  %202 = load double, ptr %201, align 8, !tbaa !21
  %203 = load ptr, ptr %19, align 8, !tbaa !5
  %204 = getelementptr inbounds ptr, ptr %203, i64 1
  %205 = load ptr, ptr %204, align 8, !tbaa !5
  %206 = getelementptr inbounds double, ptr %205, i64 1
  %207 = load double, ptr %206, align 8, !tbaa !21
  %208 = fadd double %202, %207
  %209 = load ptr, ptr %19, align 8, !tbaa !5
  %210 = getelementptr inbounds ptr, ptr %209, i64 0
  %211 = load ptr, ptr %210, align 8, !tbaa !5
  %212 = getelementptr inbounds double, ptr %211, i64 1
  %213 = load double, ptr %212, align 8, !tbaa !21
  %214 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %213, double %208)
  store double %214, ptr %14, align 8, !tbaa !21
  store i32 1, ptr %8, align 4, !tbaa !18
  %215 = load double, ptr %14, align 8, !tbaa !21
  %216 = call double @llvm.fabs.f64(double %215)
  %217 = fcmp ogt double %216, 1.000000e-15
  br i1 %217, label %218, label %349

218:                                              ; preds = %194
  %219 = load ptr, ptr %19, align 8, !tbaa !5
  %220 = getelementptr inbounds ptr, ptr %219, i64 0
  %221 = load ptr, ptr %220, align 8, !tbaa !5
  %222 = getelementptr inbounds double, ptr %221, i64 0
  %223 = load double, ptr %222, align 8, !tbaa !21
  %224 = load ptr, ptr %19, align 8, !tbaa !5
  %225 = getelementptr inbounds ptr, ptr %224, i64 0
  %226 = load ptr, ptr %225, align 8, !tbaa !5
  %227 = getelementptr inbounds double, ptr %226, i64 1
  %228 = load double, ptr %227, align 8, !tbaa !21
  %229 = fsub double %223, %228
  %230 = load double, ptr %14, align 8, !tbaa !21
  %231 = fdiv double %229, %230
  store double %231, ptr %12, align 8, !tbaa !21
  %232 = load double, ptr %12, align 8, !tbaa !21
  %233 = fsub double 1.000000e+00, %232
  store double %233, ptr %11, align 8, !tbaa !21
  %234 = load double, ptr %12, align 8, !tbaa !21
  %235 = fcmp olt double %234, 0.000000e+00
  br i1 %235, label %239, label %236

236:                                              ; preds = %218
  %237 = load double, ptr %12, align 8, !tbaa !21
  %238 = fcmp ogt double %237, 1.000000e+00
  br i1 %238, label %239, label %240

239:                                              ; preds = %236, %218
  store i32 0, ptr %8, align 4, !tbaa !18
  br label %240

240:                                              ; preds = %239, %236
  %241 = load i32, ptr %8, align 4, !tbaa !18
  %242 = icmp ne i32 %241, 0
  br i1 %242, label %243, label %276

243:                                              ; preds = %240
  store i32 0, ptr %5, align 4, !tbaa !18
  br label %244

244:                                              ; preds = %272, %243
  %245 = load i32, ptr %5, align 4, !tbaa !18
  %246 = load i32, ptr %9, align 4, !tbaa !18
  %247 = icmp slt i32 %245, %246
  br i1 %247, label %248, label %275

248:                                              ; preds = %244
  %249 = load double, ptr %11, align 8, !tbaa !21
  %250 = load ptr, ptr %16, align 8, !tbaa !5
  %251 = getelementptr inbounds ptr, ptr %250, i64 0
  %252 = load ptr, ptr %251, align 8, !tbaa !5
  %253 = load i32, ptr %5, align 4, !tbaa !18
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds double, ptr %252, i64 %254
  %256 = load double, ptr %255, align 8, !tbaa !21
  %257 = load double, ptr %12, align 8, !tbaa !21
  %258 = load ptr, ptr %16, align 8, !tbaa !5
  %259 = getelementptr inbounds ptr, ptr %258, i64 1
  %260 = load ptr, ptr %259, align 8, !tbaa !5
  %261 = load i32, ptr %5, align 4, !tbaa !18
  %262 = sext i32 %261 to i64
  %263 = getelementptr inbounds double, ptr %260, i64 %262
  %264 = load double, ptr %263, align 8, !tbaa !21
  %265 = fmul double %257, %264
  %266 = call double @llvm.fmuladd.f64(double %249, double %256, double %265)
  %267 = load ptr, ptr %23, align 8, !tbaa !5
  %268 = getelementptr inbounds %struct.__SMoptimal, ptr %267, i32 0, i32 18
  %269 = load i32, ptr %5, align 4, !tbaa !18
  %270 = sext i32 %269 to i64
  %271 = getelementptr inbounds [3 x double], ptr %268, i64 0, i64 %270
  store double %266, ptr %271, align 8, !tbaa !21
  br label %272

272:                                              ; preds = %248
  %273 = load i32, ptr %5, align 4, !tbaa !18
  %274 = add nsw i32 %273, 1
  store i32 %274, ptr %5, align 4, !tbaa !18
  br label %244, !llvm.loop !26

275:                                              ; preds = %244
  br label %348

276:                                              ; preds = %240
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #5
  %277 = load i32, ptr %9, align 4, !tbaa !18
  %278 = icmp eq i32 %277, 2
  br i1 %278, label %279, label %296

279:                                              ; preds = %276
  %280 = load ptr, ptr %16, align 8, !tbaa !5
  %281 = getelementptr inbounds ptr, ptr %280, i64 0
  %282 = load ptr, ptr %281, align 8, !tbaa !5
  %283 = getelementptr inbounds double, ptr %282, i64 0
  %284 = load double, ptr %283, align 8, !tbaa !21
  %285 = load ptr, ptr %23, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.__SMoptimal, ptr %285, i32 0, i32 18
  %287 = getelementptr inbounds [3 x double], ptr %286, i64 0, i64 0
  store double %284, ptr %287, align 8, !tbaa !21
  %288 = load ptr, ptr %16, align 8, !tbaa !5
  %289 = getelementptr inbounds ptr, ptr %288, i64 0
  %290 = load ptr, ptr %289, align 8, !tbaa !5
  %291 = getelementptr inbounds double, ptr %290, i64 1
  %292 = load double, ptr %291, align 8, !tbaa !21
  %293 = load ptr, ptr %23, align 8, !tbaa !5
  %294 = getelementptr inbounds %struct.__SMoptimal, ptr %293, i32 0, i32 18
  %295 = getelementptr inbounds [3 x double], ptr %294, i64 0, i64 1
  store double %292, ptr %295, align 8, !tbaa !21
  br label %347

296:                                              ; preds = %276
  %297 = load i32, ptr %9, align 4, !tbaa !18
  %298 = icmp eq i32 %297, 3
  br i1 %298, label %299, label %324

299:                                              ; preds = %296
  %300 = load ptr, ptr %16, align 8, !tbaa !5
  %301 = getelementptr inbounds ptr, ptr %300, i64 0
  %302 = load ptr, ptr %301, align 8, !tbaa !5
  %303 = getelementptr inbounds double, ptr %302, i64 0
  %304 = load double, ptr %303, align 8, !tbaa !21
  %305 = load ptr, ptr %23, align 8, !tbaa !5
  %306 = getelementptr inbounds %struct.__SMoptimal, ptr %305, i32 0, i32 18
  %307 = getelementptr inbounds [3 x double], ptr %306, i64 0, i64 0
  store double %304, ptr %307, align 8, !tbaa !21
  %308 = load ptr, ptr %16, align 8, !tbaa !5
  %309 = getelementptr inbounds ptr, ptr %308, i64 0
  %310 = load ptr, ptr %309, align 8, !tbaa !5
  %311 = getelementptr inbounds double, ptr %310, i64 1
  %312 = load double, ptr %311, align 8, !tbaa !21
  %313 = load ptr, ptr %23, align 8, !tbaa !5
  %314 = getelementptr inbounds %struct.__SMoptimal, ptr %313, i32 0, i32 18
  %315 = getelementptr inbounds [3 x double], ptr %314, i64 0, i64 1
  store double %312, ptr %315, align 8, !tbaa !21
  %316 = load ptr, ptr %16, align 8, !tbaa !5
  %317 = getelementptr inbounds ptr, ptr %316, i64 0
  %318 = load ptr, ptr %317, align 8, !tbaa !5
  %319 = getelementptr inbounds double, ptr %318, i64 2
  %320 = load double, ptr %319, align 8, !tbaa !21
  %321 = load ptr, ptr %23, align 8, !tbaa !5
  %322 = getelementptr inbounds %struct.__SMoptimal, ptr %321, i32 0, i32 18
  %323 = getelementptr inbounds [3 x double], ptr %322, i64 0, i64 2
  store double %320, ptr %323, align 8, !tbaa !21
  br label %346

324:                                              ; preds = %296
  store i32 0, ptr %26, align 4, !tbaa !18
  br label %325

325:                                              ; preds = %342, %324
  %326 = load i32, ptr %26, align 4, !tbaa !18
  %327 = load i32, ptr %9, align 4, !tbaa !18
  %328 = icmp slt i32 %326, %327
  br i1 %328, label %329, label %345

329:                                              ; preds = %325
  %330 = load ptr, ptr %16, align 8, !tbaa !5
  %331 = getelementptr inbounds ptr, ptr %330, i64 0
  %332 = load ptr, ptr %331, align 8, !tbaa !5
  %333 = load i32, ptr %26, align 4, !tbaa !18
  %334 = sext i32 %333 to i64
  %335 = getelementptr inbounds double, ptr %332, i64 %334
  %336 = load double, ptr %335, align 8, !tbaa !21
  %337 = load ptr, ptr %23, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.__SMoptimal, ptr %337, i32 0, i32 18
  %339 = load i32, ptr %26, align 4, !tbaa !18
  %340 = sext i32 %339 to i64
  %341 = getelementptr inbounds [3 x double], ptr %338, i64 0, i64 %340
  store double %336, ptr %341, align 8, !tbaa !21
  br label %342

342:                                              ; preds = %329
  %343 = load i32, ptr %26, align 4, !tbaa !18
  %344 = add nsw i32 %343, 1
  store i32 %344, ptr %26, align 4, !tbaa !18
  br label %325, !llvm.loop !27

345:                                              ; preds = %325
  br label %346

346:                                              ; preds = %345, %299
  br label %347

347:                                              ; preds = %346, %279
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  br label %348

348:                                              ; preds = %347, %275
  br label %421

349:                                              ; preds = %194
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #5
  %350 = load i32, ptr %9, align 4, !tbaa !18
  %351 = icmp eq i32 %350, 2
  br i1 %351, label %352, label %369

352:                                              ; preds = %349
  %353 = load ptr, ptr %16, align 8, !tbaa !5
  %354 = getelementptr inbounds ptr, ptr %353, i64 0
  %355 = load ptr, ptr %354, align 8, !tbaa !5
  %356 = getelementptr inbounds double, ptr %355, i64 0
  %357 = load double, ptr %356, align 8, !tbaa !21
  %358 = load ptr, ptr %23, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.__SMoptimal, ptr %358, i32 0, i32 18
  %360 = getelementptr inbounds [3 x double], ptr %359, i64 0, i64 0
  store double %357, ptr %360, align 8, !tbaa !21
  %361 = load ptr, ptr %16, align 8, !tbaa !5
  %362 = getelementptr inbounds ptr, ptr %361, i64 0
  %363 = load ptr, ptr %362, align 8, !tbaa !5
  %364 = getelementptr inbounds double, ptr %363, i64 1
  %365 = load double, ptr %364, align 8, !tbaa !21
  %366 = load ptr, ptr %23, align 8, !tbaa !5
  %367 = getelementptr inbounds %struct.__SMoptimal, ptr %366, i32 0, i32 18
  %368 = getelementptr inbounds [3 x double], ptr %367, i64 0, i64 1
  store double %365, ptr %368, align 8, !tbaa !21
  br label %420

369:                                              ; preds = %349
  %370 = load i32, ptr %9, align 4, !tbaa !18
  %371 = icmp eq i32 %370, 3
  br i1 %371, label %372, label %397

372:                                              ; preds = %369
  %373 = load ptr, ptr %16, align 8, !tbaa !5
  %374 = getelementptr inbounds ptr, ptr %373, i64 0
  %375 = load ptr, ptr %374, align 8, !tbaa !5
  %376 = getelementptr inbounds double, ptr %375, i64 0
  %377 = load double, ptr %376, align 8, !tbaa !21
  %378 = load ptr, ptr %23, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.__SMoptimal, ptr %378, i32 0, i32 18
  %380 = getelementptr inbounds [3 x double], ptr %379, i64 0, i64 0
  store double %377, ptr %380, align 8, !tbaa !21
  %381 = load ptr, ptr %16, align 8, !tbaa !5
  %382 = getelementptr inbounds ptr, ptr %381, i64 0
  %383 = load ptr, ptr %382, align 8, !tbaa !5
  %384 = getelementptr inbounds double, ptr %383, i64 1
  %385 = load double, ptr %384, align 8, !tbaa !21
  %386 = load ptr, ptr %23, align 8, !tbaa !5
  %387 = getelementptr inbounds %struct.__SMoptimal, ptr %386, i32 0, i32 18
  %388 = getelementptr inbounds [3 x double], ptr %387, i64 0, i64 1
  store double %385, ptr %388, align 8, !tbaa !21
  %389 = load ptr, ptr %16, align 8, !tbaa !5
  %390 = getelementptr inbounds ptr, ptr %389, i64 0
  %391 = load ptr, ptr %390, align 8, !tbaa !5
  %392 = getelementptr inbounds double, ptr %391, i64 2
  %393 = load double, ptr %392, align 8, !tbaa !21
  %394 = load ptr, ptr %23, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.__SMoptimal, ptr %394, i32 0, i32 18
  %396 = getelementptr inbounds [3 x double], ptr %395, i64 0, i64 2
  store double %393, ptr %396, align 8, !tbaa !21
  br label %419

397:                                              ; preds = %369
  store i32 0, ptr %27, align 4, !tbaa !18
  br label %398

398:                                              ; preds = %415, %397
  %399 = load i32, ptr %27, align 4, !tbaa !18
  %400 = load i32, ptr %9, align 4, !tbaa !18
  %401 = icmp slt i32 %399, %400
  br i1 %401, label %402, label %418

402:                                              ; preds = %398
  %403 = load ptr, ptr %16, align 8, !tbaa !5
  %404 = getelementptr inbounds ptr, ptr %403, i64 0
  %405 = load ptr, ptr %404, align 8, !tbaa !5
  %406 = load i32, ptr %27, align 4, !tbaa !18
  %407 = sext i32 %406 to i64
  %408 = getelementptr inbounds double, ptr %405, i64 %407
  %409 = load double, ptr %408, align 8, !tbaa !21
  %410 = load ptr, ptr %23, align 8, !tbaa !5
  %411 = getelementptr inbounds %struct.__SMoptimal, ptr %410, i32 0, i32 18
  %412 = load i32, ptr %27, align 4, !tbaa !18
  %413 = sext i32 %412 to i64
  %414 = getelementptr inbounds [3 x double], ptr %411, i64 0, i64 %413
  store double %409, ptr %414, align 8, !tbaa !21
  br label %415

415:                                              ; preds = %402
  %416 = load i32, ptr %27, align 4, !tbaa !18
  %417 = add nsw i32 %416, 1
  store i32 %417, ptr %27, align 4, !tbaa !18
  br label %398, !llvm.loop !28

418:                                              ; preds = %398
  br label %419

419:                                              ; preds = %418, %372
  br label %420

420:                                              ; preds = %419, %352
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #5
  br label %421

421:                                              ; preds = %420, %348
  %422 = load ptr, ptr %7, align 8, !tbaa !5
  %423 = getelementptr inbounds i32, ptr %422, i64 0
  %424 = load i32, ptr %423, align 4, !tbaa !18
  %425 = load ptr, ptr %23, align 8, !tbaa !5
  %426 = getelementptr inbounds %struct.__SMoptimal, ptr %425, i32 0, i32 17
  store i32 %424, ptr %426, align 8, !tbaa !24
  store i32 0, ptr %5, align 4, !tbaa !18
  br label %427

427:                                              ; preds = %447, %421
  %428 = load i32, ptr %5, align 4, !tbaa !18
  %429 = load i32, ptr %6, align 4, !tbaa !18
  %430 = icmp slt i32 %428, %429
  br i1 %430, label %431, label %450

431:                                              ; preds = %427
  %432 = load ptr, ptr %16, align 8, !tbaa !5
  %433 = load i32, ptr %5, align 4, !tbaa !18
  %434 = sext i32 %433 to i64
  %435 = getelementptr inbounds ptr, ptr %432, i64 %434
  %436 = load ptr, ptr %435, align 8, !tbaa !5
  %437 = icmp eq ptr %436, null
  br i1 %437, label %438, label %440

438:                                              ; preds = %431
  %439 = call i32 @SMerror(i32 noundef 86, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %439, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

440:                                              ; preds = %431
  %441 = load ptr, ptr %16, align 8, !tbaa !5
  %442 = load i32, ptr %5, align 4, !tbaa !18
  %443 = sext i32 %442 to i64
  %444 = getelementptr inbounds ptr, ptr %441, i64 %443
  %445 = load ptr, ptr %444, align 8, !tbaa !5
  call void @free(ptr noundef %445) #5
  br label %446

446:                                              ; preds = %440
  br label %447

447:                                              ; preds = %446
  %448 = load i32, ptr %5, align 4, !tbaa !18
  %449 = add nsw i32 %448, 1
  store i32 %449, ptr %5, align 4, !tbaa !18
  br label %427, !llvm.loop !29

450:                                              ; preds = %427
  %451 = load ptr, ptr %16, align 8, !tbaa !5
  %452 = icmp eq ptr %451, null
  br i1 %452, label %453, label %455

453:                                              ; preds = %450
  %454 = call i32 @SMerror(i32 noundef 87, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %454, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

455:                                              ; preds = %450
  %456 = load ptr, ptr %16, align 8, !tbaa !5
  call void @free(ptr noundef %456) #5
  br label %457

457:                                              ; preds = %455
  br label %758

458:                                              ; preds = %56
  %459 = load i32, ptr %6, align 4, !tbaa !18
  %460 = load ptr, ptr %15, align 8, !tbaa !5
  %461 = load ptr, ptr %7, align 8, !tbaa !5
  %462 = load i32, ptr %9, align 4, !tbaa !18
  %463 = call i32 @SMgetActiveDirections(i32 noundef %459, ptr noundef %460, ptr noundef %461, i32 noundef %462, ptr noundef %16)
  store i32 %463, ptr %4, align 4, !tbaa !18
  %464 = load i32, ptr %4, align 4, !tbaa !18
  %465 = icmp ne i32 %464, 0
  br i1 %465, label %466, label %469

466:                                              ; preds = %458
  %467 = load i32, ptr %4, align 4, !tbaa !18
  %468 = call i32 @SMerror(i32 noundef 99, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %467, i32 noundef 0, ptr noundef null)
  store i32 %468, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

469:                                              ; preds = %458
  %470 = load i32, ptr %6, align 4, !tbaa !18
  %471 = load ptr, ptr %16, align 8, !tbaa !5
  %472 = load ptr, ptr %23, align 8, !tbaa !5
  %473 = getelementptr inbounds %struct.__SMoptimal, ptr %472, i32 0, i32 23
  %474 = load ptr, ptr %473, align 8, !tbaa !25
  %475 = load i32, ptr %9, align 4, !tbaa !18
  %476 = call i32 @SMformGrammian(i32 noundef %470, ptr noundef %471, ptr noundef %474, i32 noundef %475)
  store i32 %476, ptr %4, align 4, !tbaa !18
  %477 = load i32, ptr %4, align 4, !tbaa !18
  %478 = icmp ne i32 %477, 0
  br i1 %478, label %479, label %482

479:                                              ; preds = %469
  %480 = load i32, ptr %4, align 4, !tbaa !18
  %481 = call i32 @SMerror(i32 noundef 102, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %480, i32 noundef 0, ptr noundef null)
  store i32 %481, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

482:                                              ; preds = %469
  %483 = load ptr, ptr %23, align 8, !tbaa !5
  %484 = call i32 @SMformPDGrammian(ptr noundef %483)
  store i32 %484, ptr %4, align 4, !tbaa !18
  %485 = load i32, ptr %4, align 4, !tbaa !18
  %486 = icmp ne i32 %485, 0
  br i1 %486, label %487, label %490

487:                                              ; preds = %482
  %488 = load i32, ptr %4, align 4, !tbaa !18
  %489 = call i32 @SMerror(i32 noundef 103, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %488, i32 noundef 0, ptr noundef null)
  store i32 %489, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

490:                                              ; preds = %482
  %491 = load ptr, ptr %23, align 8, !tbaa !5
  %492 = getelementptr inbounds %struct.__SMoptimal, ptr %491, i32 0, i32 23
  %493 = load ptr, ptr %492, align 8, !tbaa !25
  store ptr %493, ptr %19, align 8, !tbaa !5
  %494 = load i32, ptr %9, align 4, !tbaa !18
  switch i32 %494, label %726 [
    i32 2, label %495
    i32 3, label %507
  ]

495:                                              ; preds = %490
  %496 = load i32, ptr %6, align 4, !tbaa !18
  %497 = load ptr, ptr %19, align 8, !tbaa !5
  %498 = load ptr, ptr %16, align 8, !tbaa !5
  %499 = load ptr, ptr %23, align 8, !tbaa !5
  %500 = call i32 @SMsearchEdgesFaces(i32 noundef %496, ptr noundef %497, ptr noundef %498, ptr noundef %499)
  store i32 %500, ptr %4, align 4, !tbaa !18
  %501 = load i32, ptr %4, align 4, !tbaa !18
  %502 = icmp ne i32 %501, 0
  br i1 %502, label %503, label %506

503:                                              ; preds = %495
  %504 = load i32, ptr %4, align 4, !tbaa !18
  %505 = call i32 @SMerror(i32 noundef 108, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %504, i32 noundef 0, ptr noundef null)
  store i32 %505, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

506:                                              ; preds = %495
  br label %726

507:                                              ; preds = %490
  %508 = load i32, ptr %6, align 4, !tbaa !18
  %509 = icmp eq i32 %508, 3
  br i1 %509, label %510, label %713

510:                                              ; preds = %507
  %511 = load i32, ptr %6, align 4, !tbaa !18
  %512 = load ptr, ptr %23, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.__SMoptimal, ptr %512, i32 0, i32 23
  %514 = load ptr, ptr %513, align 8, !tbaa !25
  %515 = call i32 @SMsingularTest(i32 noundef %511, ptr noundef %514, ptr noundef %10)
  store i32 %515, ptr %4, align 4, !tbaa !18
  %516 = load i32, ptr %4, align 4, !tbaa !18
  %517 = icmp ne i32 %516, 0
  br i1 %517, label %518, label %521

518:                                              ; preds = %510
  %519 = load i32, ptr %4, align 4, !tbaa !18
  %520 = call i32 @SMerror(i32 noundef 112, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %519, i32 noundef 0, ptr noundef null)
  store i32 %520, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

521:                                              ; preds = %510
  %522 = load i32, ptr %10, align 4, !tbaa !18
  %523 = icmp ne i32 %522, 0
  br i1 %523, label %700, label %524

524:                                              ; preds = %521
  %525 = load i32, ptr %6, align 4, !tbaa !18
  %526 = load ptr, ptr %19, align 8, !tbaa !5
  %527 = call i32 @SMformReducedMatrix(i32 noundef %525, ptr noundef %526, ptr noundef %20)
  store i32 %527, ptr %4, align 4, !tbaa !18
  %528 = load i32, ptr %4, align 4, !tbaa !18
  %529 = icmp ne i32 %528, 0
  br i1 %529, label %530, label %533

530:                                              ; preds = %524
  %531 = load i32, ptr %4, align 4, !tbaa !18
  %532 = call i32 @SMerror(i32 noundef 115, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %531, i32 noundef 0, ptr noundef null)
  store i32 %532, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

533:                                              ; preds = %524
  %534 = load ptr, ptr %19, align 8, !tbaa !5
  %535 = getelementptr inbounds ptr, ptr %534, i64 0
  %536 = load ptr, ptr %535, align 8, !tbaa !5
  %537 = getelementptr inbounds double, ptr %536, i64 0
  %538 = load double, ptr %537, align 8, !tbaa !21
  %539 = load ptr, ptr %19, align 8, !tbaa !5
  %540 = getelementptr inbounds ptr, ptr %539, i64 1
  %541 = load ptr, ptr %540, align 8, !tbaa !5
  %542 = getelementptr inbounds double, ptr %541, i64 0
  %543 = load double, ptr %542, align 8, !tbaa !21
  %544 = fsub double %538, %543
  store double %544, ptr %17, align 8, !tbaa !21
  %545 = load ptr, ptr %19, align 8, !tbaa !5
  %546 = getelementptr inbounds ptr, ptr %545, i64 0
  %547 = load ptr, ptr %546, align 8, !tbaa !5
  %548 = getelementptr inbounds double, ptr %547, i64 0
  %549 = load double, ptr %548, align 8, !tbaa !21
  %550 = load ptr, ptr %19, align 8, !tbaa !5
  %551 = getelementptr inbounds ptr, ptr %550, i64 2
  %552 = load ptr, ptr %551, align 8, !tbaa !5
  %553 = getelementptr inbounds double, ptr %552, i64 0
  %554 = load double, ptr %553, align 8, !tbaa !21
  %555 = fsub double %549, %554
  store double %555, ptr %18, align 8, !tbaa !21
  %556 = load ptr, ptr %20, align 8, !tbaa !5
  %557 = getelementptr inbounds ptr, ptr %556, i64 0
  %558 = load ptr, ptr %557, align 8, !tbaa !5
  %559 = getelementptr inbounds double, ptr %558, i64 0
  %560 = load double, ptr %559, align 8, !tbaa !21
  %561 = load ptr, ptr %20, align 8, !tbaa !5
  %562 = getelementptr inbounds ptr, ptr %561, i64 0
  %563 = load ptr, ptr %562, align 8, !tbaa !5
  %564 = getelementptr inbounds double, ptr %563, i64 1
  %565 = load double, ptr %564, align 8, !tbaa !21
  %566 = load ptr, ptr %20, align 8, !tbaa !5
  %567 = getelementptr inbounds ptr, ptr %566, i64 1
  %568 = load ptr, ptr %567, align 8, !tbaa !5
  %569 = getelementptr inbounds double, ptr %568, i64 0
  %570 = load double, ptr %569, align 8, !tbaa !21
  %571 = load ptr, ptr %20, align 8, !tbaa !5
  %572 = getelementptr inbounds ptr, ptr %571, i64 1
  %573 = load ptr, ptr %572, align 8, !tbaa !5
  %574 = getelementptr inbounds double, ptr %573, i64 1
  %575 = load double, ptr %574, align 8, !tbaa !21
  %576 = load double, ptr %17, align 8, !tbaa !21
  %577 = load double, ptr %18, align 8, !tbaa !21
  %578 = call i32 @SMsolve2x2(double noundef %560, double noundef %565, double noundef %570, double noundef %575, double noundef %576, double noundef %577, ptr noundef %21)
  store i32 %578, ptr %4, align 4, !tbaa !18
  %579 = load i32, ptr %4, align 4, !tbaa !18
  %580 = icmp ne i32 %579, 0
  br i1 %580, label %581, label %584

581:                                              ; preds = %533
  %582 = load i32, ptr %4, align 4, !tbaa !18
  %583 = call i32 @SMerror(i32 noundef 119, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %582, i32 noundef 0, ptr noundef null)
  store i32 %583, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

584:                                              ; preds = %533
  %585 = load ptr, ptr %21, align 8, !tbaa !5
  %586 = icmp ne ptr %585, null
  br i1 %586, label %587, label %687

587:                                              ; preds = %584
  %588 = load ptr, ptr %21, align 8, !tbaa !5
  %589 = getelementptr inbounds double, ptr %588, i64 0
  %590 = load double, ptr %589, align 8, !tbaa !21
  %591 = fsub double 1.000000e+00, %590
  %592 = load ptr, ptr %21, align 8, !tbaa !5
  %593 = getelementptr inbounds double, ptr %592, i64 1
  %594 = load double, ptr %593, align 8, !tbaa !21
  %595 = fsub double %591, %594
  store double %595, ptr %11, align 8, !tbaa !21
  %596 = load ptr, ptr %21, align 8, !tbaa !5
  %597 = getelementptr inbounds double, ptr %596, i64 0
  %598 = load double, ptr %597, align 8, !tbaa !21
  store double %598, ptr %12, align 8, !tbaa !21
  %599 = load ptr, ptr %21, align 8, !tbaa !5
  %600 = getelementptr inbounds double, ptr %599, i64 1
  %601 = load double, ptr %600, align 8, !tbaa !21
  store double %601, ptr %13, align 8, !tbaa !21
  store i32 0, ptr %5, align 4, !tbaa !18
  br label %602

602:                                              ; preds = %639, %587
  %603 = load i32, ptr %5, align 4, !tbaa !18
  %604 = load i32, ptr %9, align 4, !tbaa !18
  %605 = icmp slt i32 %603, %604
  br i1 %605, label %606, label %642

606:                                              ; preds = %602
  %607 = load double, ptr %11, align 8, !tbaa !21
  %608 = load ptr, ptr %16, align 8, !tbaa !5
  %609 = getelementptr inbounds ptr, ptr %608, i64 0
  %610 = load ptr, ptr %609, align 8, !tbaa !5
  %611 = load i32, ptr %5, align 4, !tbaa !18
  %612 = sext i32 %611 to i64
  %613 = getelementptr inbounds double, ptr %610, i64 %612
  %614 = load double, ptr %613, align 8, !tbaa !21
  %615 = load double, ptr %12, align 8, !tbaa !21
  %616 = load ptr, ptr %16, align 8, !tbaa !5
  %617 = getelementptr inbounds ptr, ptr %616, i64 1
  %618 = load ptr, ptr %617, align 8, !tbaa !5
  %619 = load i32, ptr %5, align 4, !tbaa !18
  %620 = sext i32 %619 to i64
  %621 = getelementptr inbounds double, ptr %618, i64 %620
  %622 = load double, ptr %621, align 8, !tbaa !21
  %623 = fmul double %615, %622
  %624 = call double @llvm.fmuladd.f64(double %607, double %614, double %623)
  %625 = load double, ptr %13, align 8, !tbaa !21
  %626 = load ptr, ptr %16, align 8, !tbaa !5
  %627 = getelementptr inbounds ptr, ptr %626, i64 2
  %628 = load ptr, ptr %627, align 8, !tbaa !5
  %629 = load i32, ptr %5, align 4, !tbaa !18
  %630 = sext i32 %629 to i64
  %631 = getelementptr inbounds double, ptr %628, i64 %630
  %632 = load double, ptr %631, align 8, !tbaa !21
  %633 = call double @llvm.fmuladd.f64(double %625, double %632, double %624)
  %634 = load ptr, ptr %23, align 8, !tbaa !5
  %635 = getelementptr inbounds %struct.__SMoptimal, ptr %634, i32 0, i32 18
  %636 = load i32, ptr %5, align 4, !tbaa !18
  %637 = sext i32 %636 to i64
  %638 = getelementptr inbounds [3 x double], ptr %635, i64 0, i64 %637
  store double %633, ptr %638, align 8, !tbaa !21
  br label %639

639:                                              ; preds = %606
  %640 = load i32, ptr %5, align 4, !tbaa !18
  %641 = add nsw i32 %640, 1
  store i32 %641, ptr %5, align 4, !tbaa !18
  br label %602, !llvm.loop !30

642:                                              ; preds = %602
  %643 = load ptr, ptr %7, align 8, !tbaa !5
  %644 = getelementptr inbounds i32, ptr %643, i64 0
  %645 = load i32, ptr %644, align 4, !tbaa !18
  %646 = load ptr, ptr %23, align 8, !tbaa !5
  %647 = getelementptr inbounds %struct.__SMoptimal, ptr %646, i32 0, i32 17
  store i32 %645, ptr %647, align 8, !tbaa !24
  store i32 0, ptr %5, align 4, !tbaa !18
  br label %648

648:                                              ; preds = %669, %642
  %649 = load i32, ptr %5, align 4, !tbaa !18
  %650 = load i32, ptr %6, align 4, !tbaa !18
  %651 = sub nsw i32 %650, 1
  %652 = icmp slt i32 %649, %651
  br i1 %652, label %653, label %672

653:                                              ; preds = %648
  %654 = load ptr, ptr %20, align 8, !tbaa !5
  %655 = load i32, ptr %5, align 4, !tbaa !18
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds ptr, ptr %654, i64 %656
  %658 = load ptr, ptr %657, align 8, !tbaa !5
  %659 = icmp eq ptr %658, null
  br i1 %659, label %660, label %662

660:                                              ; preds = %653
  %661 = call i32 @SMerror(i32 noundef 127, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %661, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

662:                                              ; preds = %653
  %663 = load ptr, ptr %20, align 8, !tbaa !5
  %664 = load i32, ptr %5, align 4, !tbaa !18
  %665 = sext i32 %664 to i64
  %666 = getelementptr inbounds ptr, ptr %663, i64 %665
  %667 = load ptr, ptr %666, align 8, !tbaa !5
  call void @free(ptr noundef %667) #5
  br label %668

668:                                              ; preds = %662
  br label %669

669:                                              ; preds = %668
  %670 = load i32, ptr %5, align 4, !tbaa !18
  %671 = add nsw i32 %670, 1
  store i32 %671, ptr %5, align 4, !tbaa !18
  br label %648, !llvm.loop !31

672:                                              ; preds = %648
  %673 = load ptr, ptr %20, align 8, !tbaa !5
  %674 = icmp eq ptr %673, null
  br i1 %674, label %675, label %677

675:                                              ; preds = %672
  %676 = call i32 @SMerror(i32 noundef 128, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %676, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

677:                                              ; preds = %672
  %678 = load ptr, ptr %20, align 8, !tbaa !5
  call void @free(ptr noundef %678) #5
  br label %679

679:                                              ; preds = %677
  %680 = load ptr, ptr %21, align 8, !tbaa !5
  %681 = icmp eq ptr %680, null
  br i1 %681, label %682, label %684

682:                                              ; preds = %679
  %683 = call i32 @SMerror(i32 noundef 128, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %683, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

684:                                              ; preds = %679
  %685 = load ptr, ptr %21, align 8, !tbaa !5
  call void @free(ptr noundef %685) #5
  br label %686

686:                                              ; preds = %684
  br label %699

687:                                              ; preds = %584
  %688 = load i32, ptr %6, align 4, !tbaa !18
  %689 = load ptr, ptr %19, align 8, !tbaa !5
  %690 = load ptr, ptr %16, align 8, !tbaa !5
  %691 = load ptr, ptr %23, align 8, !tbaa !5
  %692 = call i32 @SMsearchEdgesFaces(i32 noundef %688, ptr noundef %689, ptr noundef %690, ptr noundef %691)
  store i32 %692, ptr %4, align 4, !tbaa !18
  %693 = load i32, ptr %4, align 4, !tbaa !18
  %694 = icmp ne i32 %693, 0
  br i1 %694, label %695, label %698

695:                                              ; preds = %687
  %696 = load i32, ptr %4, align 4, !tbaa !18
  %697 = call i32 @SMerror(i32 noundef 131, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %696, i32 noundef 0, ptr noundef null)
  store i32 %697, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

698:                                              ; preds = %687
  br label %699

699:                                              ; preds = %698, %686
  br label %712

700:                                              ; preds = %521
  %701 = load i32, ptr %6, align 4, !tbaa !18
  %702 = load ptr, ptr %19, align 8, !tbaa !5
  %703 = load ptr, ptr %16, align 8, !tbaa !5
  %704 = load ptr, ptr %23, align 8, !tbaa !5
  %705 = call i32 @SMsearchEdgesFaces(i32 noundef %701, ptr noundef %702, ptr noundef %703, ptr noundef %704)
  store i32 %705, ptr %4, align 4, !tbaa !18
  %706 = load i32, ptr %4, align 4, !tbaa !18
  %707 = icmp ne i32 %706, 0
  br i1 %707, label %708, label %711

708:                                              ; preds = %700
  %709 = load i32, ptr %4, align 4, !tbaa !18
  %710 = call i32 @SMerror(i32 noundef 135, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %709, i32 noundef 0, ptr noundef null)
  store i32 %710, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

711:                                              ; preds = %700
  br label %712

712:                                              ; preds = %711, %699
  br label %725

713:                                              ; preds = %507
  %714 = load i32, ptr %6, align 4, !tbaa !18
  %715 = load ptr, ptr %19, align 8, !tbaa !5
  %716 = load ptr, ptr %16, align 8, !tbaa !5
  %717 = load ptr, ptr %23, align 8, !tbaa !5
  %718 = call i32 @SMsearchEdgesFaces(i32 noundef %714, ptr noundef %715, ptr noundef %716, ptr noundef %717)
  store i32 %718, ptr %4, align 4, !tbaa !18
  %719 = load i32, ptr %4, align 4, !tbaa !18
  %720 = icmp ne i32 %719, 0
  br i1 %720, label %721, label %724

721:                                              ; preds = %713
  %722 = load i32, ptr %4, align 4, !tbaa !18
  %723 = call i32 @SMerror(i32 noundef 139, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef %722, i32 noundef 0, ptr noundef null)
  store i32 %723, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

724:                                              ; preds = %713
  br label %725

725:                                              ; preds = %724, %712
  br label %726

726:                                              ; preds = %725, %506, %490
  store i32 0, ptr %5, align 4, !tbaa !18
  br label %727

727:                                              ; preds = %747, %726
  %728 = load i32, ptr %5, align 4, !tbaa !18
  %729 = load i32, ptr %6, align 4, !tbaa !18
  %730 = icmp slt i32 %728, %729
  br i1 %730, label %731, label %750

731:                                              ; preds = %727
  %732 = load ptr, ptr %16, align 8, !tbaa !5
  %733 = load i32, ptr %5, align 4, !tbaa !18
  %734 = sext i32 %733 to i64
  %735 = getelementptr inbounds ptr, ptr %732, i64 %734
  %736 = load ptr, ptr %735, align 8, !tbaa !5
  %737 = icmp eq ptr %736, null
  br i1 %737, label %738, label %740

738:                                              ; preds = %731
  %739 = call i32 @SMerror(i32 noundef 143, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %739, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

740:                                              ; preds = %731
  %741 = load ptr, ptr %16, align 8, !tbaa !5
  %742 = load i32, ptr %5, align 4, !tbaa !18
  %743 = sext i32 %742 to i64
  %744 = getelementptr inbounds ptr, ptr %741, i64 %743
  %745 = load ptr, ptr %744, align 8, !tbaa !5
  call void @free(ptr noundef %745) #5
  br label %746

746:                                              ; preds = %740
  br label %747

747:                                              ; preds = %746
  %748 = load i32, ptr %5, align 4, !tbaa !18
  %749 = add nsw i32 %748, 1
  store i32 %749, ptr %5, align 4, !tbaa !18
  br label %727, !llvm.loop !32

750:                                              ; preds = %727
  %751 = load ptr, ptr %16, align 8, !tbaa !5
  %752 = icmp eq ptr %751, null
  br i1 %752, label %753, label %755

753:                                              ; preds = %750
  %754 = call i32 @SMerror(i32 noundef 144, ptr noundef @.str, ptr noundef @.str.1, ptr noundef @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null)
  store i32 %754, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

755:                                              ; preds = %750
  %756 = load ptr, ptr %16, align 8, !tbaa !5
  call void @free(ptr noundef %756) #5
  br label %757

757:                                              ; preds = %755
  br label %758

758:                                              ; preds = %757, %457, %156
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #5
  %759 = load i32, ptr %9, align 4, !tbaa !18
  %760 = icmp eq i32 %759, 2
  br i1 %760, label %761, label %780

761:                                              ; preds = %758
  %762 = load ptr, ptr %23, align 8, !tbaa !5
  %763 = getelementptr inbounds %struct.__SMoptimal, ptr %762, i32 0, i32 18
  %764 = getelementptr inbounds [3 x double], ptr %763, i64 0, i64 0
  %765 = load double, ptr %764, align 8, !tbaa !21
  %766 = load ptr, ptr %23, align 8, !tbaa !5
  %767 = getelementptr inbounds %struct.__SMoptimal, ptr %766, i32 0, i32 18
  %768 = getelementptr inbounds [3 x double], ptr %767, i64 0, i64 0
  %769 = load double, ptr %768, align 8, !tbaa !21
  %770 = load ptr, ptr %23, align 8, !tbaa !5
  %771 = getelementptr inbounds %struct.__SMoptimal, ptr %770, i32 0, i32 18
  %772 = getelementptr inbounds [3 x double], ptr %771, i64 0, i64 1
  %773 = load double, ptr %772, align 8, !tbaa !21
  %774 = load ptr, ptr %23, align 8, !tbaa !5
  %775 = getelementptr inbounds %struct.__SMoptimal, ptr %774, i32 0, i32 18
  %776 = getelementptr inbounds [3 x double], ptr %775, i64 0, i64 1
  %777 = load double, ptr %776, align 8, !tbaa !21
  %778 = fmul double %773, %777
  %779 = call double @llvm.fmuladd.f64(double %765, double %769, double %778)
  store double %779, ptr %22, align 8, !tbaa !21
  br label %836

780:                                              ; preds = %758
  %781 = load i32, ptr %9, align 4, !tbaa !18
  %782 = icmp eq i32 %781, 3
  br i1 %782, label %783, label %811

783:                                              ; preds = %780
  %784 = load ptr, ptr %23, align 8, !tbaa !5
  %785 = getelementptr inbounds %struct.__SMoptimal, ptr %784, i32 0, i32 18
  %786 = getelementptr inbounds [3 x double], ptr %785, i64 0, i64 0
  %787 = load double, ptr %786, align 8, !tbaa !21
  %788 = load ptr, ptr %23, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.__SMoptimal, ptr %788, i32 0, i32 18
  %790 = getelementptr inbounds [3 x double], ptr %789, i64 0, i64 0
  %791 = load double, ptr %790, align 8, !tbaa !21
  %792 = load ptr, ptr %23, align 8, !tbaa !5
  %793 = getelementptr inbounds %struct.__SMoptimal, ptr %792, i32 0, i32 18
  %794 = getelementptr inbounds [3 x double], ptr %793, i64 0, i64 1
  %795 = load double, ptr %794, align 8, !tbaa !21
  %796 = load ptr, ptr %23, align 8, !tbaa !5
  %797 = getelementptr inbounds %struct.__SMoptimal, ptr %796, i32 0, i32 18
  %798 = getelementptr inbounds [3 x double], ptr %797, i64 0, i64 1
  %799 = load double, ptr %798, align 8, !tbaa !21
  %800 = fmul double %795, %799
  %801 = call double @llvm.fmuladd.f64(double %787, double %791, double %800)
  %802 = load ptr, ptr %23, align 8, !tbaa !5
  %803 = getelementptr inbounds %struct.__SMoptimal, ptr %802, i32 0, i32 18
  %804 = getelementptr inbounds [3 x double], ptr %803, i64 0, i64 2
  %805 = load double, ptr %804, align 8, !tbaa !21
  %806 = load ptr, ptr %23, align 8, !tbaa !5
  %807 = getelementptr inbounds %struct.__SMoptimal, ptr %806, i32 0, i32 18
  %808 = getelementptr inbounds [3 x double], ptr %807, i64 0, i64 2
  %809 = load double, ptr %808, align 8, !tbaa !21
  %810 = call double @llvm.fmuladd.f64(double %805, double %809, double %801)
  store double %810, ptr %22, align 8, !tbaa !21
  br label %835

811:                                              ; preds = %780
  store i32 0, ptr %28, align 4, !tbaa !18
  br label %812

812:                                              ; preds = %831, %811
  %813 = load i32, ptr %28, align 4, !tbaa !18
  %814 = load i32, ptr %9, align 4, !tbaa !18
  %815 = icmp slt i32 %813, %814
  br i1 %815, label %816, label %834

816:                                              ; preds = %812
  %817 = load ptr, ptr %23, align 8, !tbaa !5
  %818 = getelementptr inbounds %struct.__SMoptimal, ptr %817, i32 0, i32 18
  %819 = load i32, ptr %28, align 4, !tbaa !18
  %820 = sext i32 %819 to i64
  %821 = getelementptr inbounds [3 x double], ptr %818, i64 0, i64 %820
  %822 = load double, ptr %821, align 8, !tbaa !21
  %823 = load ptr, ptr %23, align 8, !tbaa !5
  %824 = getelementptr inbounds %struct.__SMoptimal, ptr %823, i32 0, i32 18
  %825 = load i32, ptr %28, align 4, !tbaa !18
  %826 = sext i32 %825 to i64
  %827 = getelementptr inbounds [3 x double], ptr %824, i64 0, i64 %826
  %828 = load double, ptr %827, align 8, !tbaa !21
  %829 = load double, ptr %22, align 8, !tbaa !21
  %830 = call double @llvm.fmuladd.f64(double %822, double %828, double %829)
  store double %830, ptr %22, align 8, !tbaa !21
  br label %831

831:                                              ; preds = %816
  %832 = load i32, ptr %28, align 4, !tbaa !18
  %833 = add nsw i32 %832, 1
  store i32 %833, ptr %28, align 4, !tbaa !18
  br label %812, !llvm.loop !33

834:                                              ; preds = %812
  br label %835

835:                                              ; preds = %834, %783
  br label %836

836:                                              ; preds = %835, %761
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #5
  %837 = load double, ptr %22, align 8, !tbaa !21
  %838 = call double @llvm.fabs.f64(double %837)
  %839 = fcmp olt double %838, 1.000000e-13
  br i1 %839, label %840, label %843

840:                                              ; preds = %836
  %841 = load ptr, ptr %23, align 8, !tbaa !5
  %842 = getelementptr inbounds %struct.__SMoptimal, ptr %841, i32 0, i32 4
  store i32 105, ptr %842, align 8, !tbaa !34
  br label %1004

843:                                              ; preds = %836
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #5
  %844 = load i32, ptr %9, align 4, !tbaa !18
  %845 = icmp eq i32 %844, 2
  br i1 %845, label %846, label %888

846:                                              ; preds = %843
  %847 = load ptr, ptr %23, align 8, !tbaa !5
  %848 = getelementptr inbounds %struct.__SMoptimal, ptr %847, i32 0, i32 18
  %849 = getelementptr inbounds [3 x double], ptr %848, i64 0, i64 0
  %850 = load double, ptr %849, align 8, !tbaa !21
  %851 = load ptr, ptr %23, align 8, !tbaa !5
  %852 = getelementptr inbounds %struct.__SMoptimal, ptr %851, i32 0, i32 18
  %853 = getelementptr inbounds [3 x double], ptr %852, i64 0, i64 0
  %854 = load double, ptr %853, align 8, !tbaa !21
  %855 = load ptr, ptr %23, align 8, !tbaa !5
  %856 = getelementptr inbounds %struct.__SMoptimal, ptr %855, i32 0, i32 18
  %857 = getelementptr inbounds [3 x double], ptr %856, i64 0, i64 1
  %858 = load double, ptr %857, align 8, !tbaa !21
  %859 = load ptr, ptr %23, align 8, !tbaa !5
  %860 = getelementptr inbounds %struct.__SMoptimal, ptr %859, i32 0, i32 18
  %861 = getelementptr inbounds [3 x double], ptr %860, i64 0, i64 1
  %862 = load double, ptr %861, align 8, !tbaa !21
  %863 = fmul double %858, %862
  %864 = call double @llvm.fmuladd.f64(double %850, double %854, double %863)
  %865 = call double @sqrt(double noundef %864) #5
  store double %865, ptr %30, align 8, !tbaa !21
  %866 = load double, ptr %30, align 8, !tbaa !21
  %867 = fcmp une double %866, 0.000000e+00
  br i1 %867, label %868, label %887

868:                                              ; preds = %846
  %869 = load ptr, ptr %23, align 8, !tbaa !5
  %870 = getelementptr inbounds %struct.__SMoptimal, ptr %869, i32 0, i32 18
  %871 = getelementptr inbounds [3 x double], ptr %870, i64 0, i64 0
  %872 = load double, ptr %871, align 8, !tbaa !21
  %873 = load double, ptr %30, align 8, !tbaa !21
  %874 = fdiv double %872, %873
  %875 = load ptr, ptr %23, align 8, !tbaa !5
  %876 = getelementptr inbounds %struct.__SMoptimal, ptr %875, i32 0, i32 18
  %877 = getelementptr inbounds [3 x double], ptr %876, i64 0, i64 0
  store double %874, ptr %877, align 8, !tbaa !21
  %878 = load ptr, ptr %23, align 8, !tbaa !5
  %879 = getelementptr inbounds %struct.__SMoptimal, ptr %878, i32 0, i32 18
  %880 = getelementptr inbounds [3 x double], ptr %879, i64 0, i64 1
  %881 = load double, ptr %880, align 8, !tbaa !21
  %882 = load double, ptr %30, align 8, !tbaa !21
  %883 = fdiv double %881, %882
  %884 = load ptr, ptr %23, align 8, !tbaa !5
  %885 = getelementptr inbounds %struct.__SMoptimal, ptr %884, i32 0, i32 18
  %886 = getelementptr inbounds [3 x double], ptr %885, i64 0, i64 1
  store double %883, ptr %886, align 8, !tbaa !21
  br label %887

887:                                              ; preds = %868, %846
  br label %1003

888:                                              ; preds = %843
  %889 = load i32, ptr %9, align 4, !tbaa !18
  %890 = icmp eq i32 %889, 3
  br i1 %890, label %891, label %951

891:                                              ; preds = %888
  %892 = load ptr, ptr %23, align 8, !tbaa !5
  %893 = getelementptr inbounds %struct.__SMoptimal, ptr %892, i32 0, i32 18
  %894 = getelementptr inbounds [3 x double], ptr %893, i64 0, i64 0
  %895 = load double, ptr %894, align 8, !tbaa !21
  %896 = load ptr, ptr %23, align 8, !tbaa !5
  %897 = getelementptr inbounds %struct.__SMoptimal, ptr %896, i32 0, i32 18
  %898 = getelementptr inbounds [3 x double], ptr %897, i64 0, i64 0
  %899 = load double, ptr %898, align 8, !tbaa !21
  %900 = load ptr, ptr %23, align 8, !tbaa !5
  %901 = getelementptr inbounds %struct.__SMoptimal, ptr %900, i32 0, i32 18
  %902 = getelementptr inbounds [3 x double], ptr %901, i64 0, i64 1
  %903 = load double, ptr %902, align 8, !tbaa !21
  %904 = load ptr, ptr %23, align 8, !tbaa !5
  %905 = getelementptr inbounds %struct.__SMoptimal, ptr %904, i32 0, i32 18
  %906 = getelementptr inbounds [3 x double], ptr %905, i64 0, i64 1
  %907 = load double, ptr %906, align 8, !tbaa !21
  %908 = fmul double %903, %907
  %909 = call double @llvm.fmuladd.f64(double %895, double %899, double %908)
  %910 = load ptr, ptr %23, align 8, !tbaa !5
  %911 = getelementptr inbounds %struct.__SMoptimal, ptr %910, i32 0, i32 18
  %912 = getelementptr inbounds [3 x double], ptr %911, i64 0, i64 2
  %913 = load double, ptr %912, align 8, !tbaa !21
  %914 = load ptr, ptr %23, align 8, !tbaa !5
  %915 = getelementptr inbounds %struct.__SMoptimal, ptr %914, i32 0, i32 18
  %916 = getelementptr inbounds [3 x double], ptr %915, i64 0, i64 2
  %917 = load double, ptr %916, align 8, !tbaa !21
  %918 = call double @llvm.fmuladd.f64(double %913, double %917, double %909)
  %919 = call double @sqrt(double noundef %918) #5
  store double %919, ptr %30, align 8, !tbaa !21
  %920 = load double, ptr %30, align 8, !tbaa !21
  %921 = fcmp une double %920, 0.000000e+00
  br i1 %921, label %922, label %950

922:                                              ; preds = %891
  %923 = load ptr, ptr %23, align 8, !tbaa !5
  %924 = getelementptr inbounds %struct.__SMoptimal, ptr %923, i32 0, i32 18
  %925 = getelementptr inbounds [3 x double], ptr %924, i64 0, i64 0
  %926 = load double, ptr %925, align 8, !tbaa !21
  %927 = load double, ptr %30, align 8, !tbaa !21
  %928 = fdiv double %926, %927
  %929 = load ptr, ptr %23, align 8, !tbaa !5
  %930 = getelementptr inbounds %struct.__SMoptimal, ptr %929, i32 0, i32 18
  %931 = getelementptr inbounds [3 x double], ptr %930, i64 0, i64 0
  store double %928, ptr %931, align 8, !tbaa !21
  %932 = load ptr, ptr %23, align 8, !tbaa !5
  %933 = getelementptr inbounds %struct.__SMoptimal, ptr %932, i32 0, i32 18
  %934 = getelementptr inbounds [3 x double], ptr %933, i64 0, i64 1
  %935 = load double, ptr %934, align 8, !tbaa !21
  %936 = load double, ptr %30, align 8, !tbaa !21
  %937 = fdiv double %935, %936
  %938 = load ptr, ptr %23, align 8, !tbaa !5
  %939 = getelementptr inbounds %struct.__SMoptimal, ptr %938, i32 0, i32 18
  %940 = getelementptr inbounds [3 x double], ptr %939, i64 0, i64 1
  store double %937, ptr %940, align 8, !tbaa !21
  %941 = load ptr, ptr %23, align 8, !tbaa !5
  %942 = getelementptr inbounds %struct.__SMoptimal, ptr %941, i32 0, i32 18
  %943 = getelementptr inbounds [3 x double], ptr %942, i64 0, i64 2
  %944 = load double, ptr %943, align 8, !tbaa !21
  %945 = load double, ptr %30, align 8, !tbaa !21
  %946 = fdiv double %944, %945
  %947 = load ptr, ptr %23, align 8, !tbaa !5
  %948 = getelementptr inbounds %struct.__SMoptimal, ptr %947, i32 0, i32 18
  %949 = getelementptr inbounds [3 x double], ptr %948, i64 0, i64 2
  store double %946, ptr %949, align 8, !tbaa !21
  br label %950

950:                                              ; preds = %922, %891
  br label %1002

951:                                              ; preds = %888
  store i32 0, ptr %29, align 4, !tbaa !18
  br label %952

952:                                              ; preds = %972, %951
  %953 = load i32, ptr %29, align 4, !tbaa !18
  %954 = load i32, ptr %9, align 4, !tbaa !18
  %955 = icmp slt i32 %953, %954
  br i1 %955, label %956, label %975

956:                                              ; preds = %952
  %957 = load ptr, ptr %23, align 8, !tbaa !5
  %958 = getelementptr inbounds %struct.__SMoptimal, ptr %957, i32 0, i32 18
  %959 = load i32, ptr %29, align 4, !tbaa !18
  %960 = sext i32 %959 to i64
  %961 = getelementptr inbounds [3 x double], ptr %958, i64 0, i64 %960
  %962 = load double, ptr %961, align 8, !tbaa !21
  %963 = load ptr, ptr %23, align 8, !tbaa !5
  %964 = getelementptr inbounds %struct.__SMoptimal, ptr %963, i32 0, i32 18
  %965 = load i32, ptr %29, align 4, !tbaa !18
  %966 = sext i32 %965 to i64
  %967 = getelementptr inbounds [3 x double], ptr %964, i64 0, i64 %966
  %968 = load double, ptr %967, align 8, !tbaa !21
  %969 = fadd double %962, %968
  %970 = load double, ptr %30, align 8, !tbaa !21
  %971 = fadd double %970, %969
  store double %971, ptr %30, align 8, !tbaa !21
  br label %972

972:                                              ; preds = %956
  %973 = load i32, ptr %29, align 4, !tbaa !18
  %974 = add nsw i32 %973, 1
  store i32 %974, ptr %29, align 4, !tbaa !18
  br label %952, !llvm.loop !35

975:                                              ; preds = %952
  %976 = load double, ptr %30, align 8, !tbaa !21
  %977 = fcmp une double %976, 0.000000e+00
  br i1 %977, label %978, label %1001

978:                                              ; preds = %975
  store i32 0, ptr %29, align 4, !tbaa !18
  br label %979

979:                                              ; preds = %997, %978
  %980 = load i32, ptr %29, align 4, !tbaa !18
  %981 = load i32, ptr %9, align 4, !tbaa !18
  %982 = icmp slt i32 %980, %981
  br i1 %982, label %983, label %1000

983:                                              ; preds = %979
  %984 = load ptr, ptr %23, align 8, !tbaa !5
  %985 = getelementptr inbounds %struct.__SMoptimal, ptr %984, i32 0, i32 18
  %986 = load i32, ptr %29, align 4, !tbaa !18
  %987 = sext i32 %986 to i64
  %988 = getelementptr inbounds [3 x double], ptr %985, i64 0, i64 %987
  %989 = load double, ptr %988, align 8, !tbaa !21
  %990 = load double, ptr %30, align 8, !tbaa !21
  %991 = fdiv double %989, %990
  %992 = load ptr, ptr %23, align 8, !tbaa !5
  %993 = getelementptr inbounds %struct.__SMoptimal, ptr %992, i32 0, i32 18
  %994 = load i32, ptr %29, align 4, !tbaa !18
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds [3 x double], ptr %993, i64 0, i64 %995
  store double %991, ptr %996, align 8, !tbaa !21
  br label %997

997:                                              ; preds = %983
  %998 = load i32, ptr %29, align 4, !tbaa !18
  %999 = add nsw i32 %998, 1
  store i32 %999, ptr %29, align 4, !tbaa !18
  br label %979, !llvm.loop !36

1000:                                             ; preds = %979
  br label %1001

1001:                                             ; preds = %1000, %975
  br label %1002

1002:                                             ; preds = %1001, %950
  br label %1003

1003:                                             ; preds = %1002, %887
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #5
  br label %1004

1004:                                             ; preds = %1003, %840
  store i32 0, ptr %4, align 4, !tbaa !18
  store i32 0, ptr %2, align 4
  store i32 1, ptr %24, align 4
  br label %1005

1005:                                             ; preds = %1004, %753, %738, %721, %708, %695, %682, %675, %660, %581, %530, %518, %503, %487, %479, %466, %453, %438, %191, %183, %170, %54, %33
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #5
  %1006 = load i32, ptr %2, align 4
  ret i32 %1006
}

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

declare i32 @SMerror(i32 noundef, ptr noundef, ptr noundef, ptr noundef, i32 noundef, i32 noundef, ptr noundef) #2

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @SMgetActiveDirections(i32 noundef, ptr noundef, ptr noundef, i32 noundef, ptr noundef) #0

declare i32 @SMformGrammian(i32 noundef, ptr noundef, ptr noundef, i32 noundef) #2

declare i32 @SMformPDGrammian(ptr noundef) #2

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

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

; Function Attrs: nounwind
declare void @free(ptr noundef) #4

; Function Attrs: nounwind uwtable
declare dso_local i32 @SMsearchEdgesFaces(i32 noundef, ptr noundef, ptr noundef, ptr noundef) #0

declare i32 @SMsingularTest(i32 noundef, ptr noundef, ptr noundef) #2

declare i32 @SMformReducedMatrix(i32 noundef, ptr noundef, ptr noundef) #2

declare i32 @SMsolve2x2(double noundef, double noundef, double noundef, double noundef, double noundef, double noundef, ptr noundef) #2

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 160}
!10 = !{!"__SMlocal_mesh", !11, i64 0, !11, i64 4, !11, i64 8, !7, i64 16, !7, i64 40, !7, i64 64, !6, i64 88, !6, i64 96, !6, i64 104, !11, i64 112, !12, i64 120, !6, i64 128, !12, i64 136, !11, i64 144, !11, i64 148, !11, i64 152, !6, i64 160, !6, i64 168, !6, i64 176}
!11 = !{!"int", !7, i64 0}
!12 = !{!"double", !7, i64 0}
!13 = !{!14, !6, i64 56}
!14 = !{!"__SMoptimal", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !11, i64 24, !12, i64 32, !11, i64 40, !11, i64 44, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !11, i64 104, !7, i64 112, !12, i64 136, !12, i64 144, !6, i64 152, !6, i64 160, !6, i64 168, !6, i64 176, !7, i64 184, !11, i64 196}
!15 = !{!14, !6, i64 80}
!16 = !{!17, !11, i64 0}
!17 = !{!"__SMactive", !11, i64 0, !11, i64 4, !6, i64 8, !12, i64 16}
!18 = !{!11, !11, i64 0}
!19 = !{!17, !6, i64 8}
!20 = !{!10, !11, i64 0}
!21 = !{!12, !12, i64 0}
!22 = distinct !{!22, !23}
!23 = !{!"llvm.loop.mustprogress"}
!24 = !{!14, !11, i64 104}
!25 = !{!14, !6, i64 168}
!26 = distinct !{!26, !23}
!27 = distinct !{!27, !23}
!28 = distinct !{!28, !23}
!29 = distinct !{!29, !23}
!30 = distinct !{!30, !23}
!31 = distinct !{!31, !23}
!32 = distinct !{!32, !23}
!33 = distinct !{!33, !23}
!34 = !{!14, !11, i64 16}
!35 = distinct !{!35, !23}
!36 = distinct !{!36, !23}


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

@.str = external hidden unnamed_addr constant [18 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [108 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [27 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @SMsearchDirection(ptr noundef readonly %0) local_unnamed_addr #0 {
  %2 = alloca i32, align 4
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %2) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %3) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %4) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %5) #6
  %6 = icmp eq ptr %0, null
  br i1 %6, label %7, label %9

7:                                                ; preds = %1
  %8 = tail call i32 @SMerror(i32 noundef 33, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 56, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

9:                                                ; preds = %1
  %10 = getelementptr inbounds i8, ptr %0, i64 160
  %11 = load ptr, ptr %10, align 8, !tbaa !5
  %12 = ptrtoint ptr %11 to i64
  %13 = getelementptr inbounds i8, ptr %11, i64 56
  %14 = load ptr, ptr %13, align 8, !tbaa !12
  %15 = getelementptr inbounds i8, ptr %11, i64 80
  %16 = load ptr, ptr %15, align 8, !tbaa !14
  %17 = load i32, ptr %16, align 8, !tbaa !15
  %18 = getelementptr inbounds i8, ptr %16, i64 8
  %19 = load ptr, ptr %18, align 8, !tbaa !17
  %20 = icmp eq i32 %17, 0
  br i1 %20, label %21, label %23

21:                                               ; preds = %9
  %22 = tail call i32 @SMerror(i32 noundef 42, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 57, i32 noundef 0, ptr noundef nonnull @.str.3) #6
  br label %.loopexit

23:                                               ; preds = %9
  %24 = load i32, ptr %0, align 8, !tbaa !18
  switch i32 %17, label %267 [
    i32 1, label %25
    i32 2, label %79
  ]

25:                                               ; preds = %23
  switch i32 %24, label %.preheader311 [
    i32 2, label %44
    i32 3, label %52
  ]

.preheader311:                                    ; preds = %25
  %26 = icmp sgt i32 %24, 0
  %.pre = load i32, ptr %19, align 4, !tbaa !19
  br i1 %26, label %.lr.ph327, label %.loopexit312

.lr.ph327:                                        ; preds = %.preheader311
  %27 = sext i32 %.pre to i64
  %28 = getelementptr inbounds ptr, ptr %14, i64 %27
  %29 = load ptr, ptr %28, align 8, !tbaa !20
  %30 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count368 = zext nneg i32 %24 to i64
  %min.iters.check459 = icmp ult i32 %24, 8
  br i1 %min.iters.check459, label %scalar.ph458.preheader, label %vector.memcheck455

scalar.ph458.preheader:                           ; preds = %middle.block457, %vector.memcheck455, %.lr.ph327
  %indvars.iv365.ph = phi i64 [ 0, %vector.memcheck455 ], [ 0, %.lr.ph327 ], [ %n.vec462, %middle.block457 ]
  %xtraiter493 = and i64 %wide.trip.count368, 3
  %lcmp.mod494.not = icmp eq i64 %xtraiter493, 0
  br i1 %lcmp.mod494.not, label %scalar.ph458.prol.loopexit, label %scalar.ph458.prol

scalar.ph458.prol:                                ; preds = %scalar.ph458.preheader, %scalar.ph458.prol
  %indvars.iv365.prol = phi i64 [ %indvars.iv.next366.prol, %scalar.ph458.prol ], [ %indvars.iv365.ph, %scalar.ph458.preheader ]
  %prol.iter495 = phi i64 [ %prol.iter495.next, %scalar.ph458.prol ], [ 0, %scalar.ph458.preheader ]
  %31 = getelementptr inbounds double, ptr %29, i64 %indvars.iv365.prol
  %32 = load double, ptr %31, align 8, !tbaa !21
  %33 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %indvars.iv365.prol
  store double %32, ptr %33, align 8, !tbaa !21
  %indvars.iv.next366.prol = add nuw nsw i64 %indvars.iv365.prol, 1
  %prol.iter495.next = add i64 %prol.iter495, 1
  %prol.iter495.cmp.not = icmp eq i64 %prol.iter495.next, %xtraiter493
  br i1 %prol.iter495.cmp.not, label %scalar.ph458.prol.loopexit, label %scalar.ph458.prol, !llvm.loop !22

scalar.ph458.prol.loopexit:                       ; preds = %scalar.ph458.prol, %scalar.ph458.preheader
  %indvars.iv365.unr = phi i64 [ %indvars.iv365.ph, %scalar.ph458.preheader ], [ %indvars.iv.next366.prol, %scalar.ph458.prol ]
  %34 = sub nsw i64 %indvars.iv365.ph, %wide.trip.count368
  %35 = icmp ugt i64 %34, -4
  br i1 %35, label %.loopexit312, label %scalar.ph458

vector.memcheck455:                               ; preds = %.lr.ph327
  %36 = ptrtoint ptr %29 to i64
  %37 = add i64 %12, 112
  %38 = sub i64 %37, %36
  %diff.check456 = icmp ult i64 %38, 32
  br i1 %diff.check456, label %scalar.ph458.preheader, label %vector.ph460

vector.ph460:                                     ; preds = %vector.memcheck455
  %n.vec462 = and i64 %wide.trip.count368, 2147483644
  br label %vector.body464

vector.body464:                                   ; preds = %vector.body464, %vector.ph460
  %index465 = phi i64 [ 0, %vector.ph460 ], [ %index.next468, %vector.body464 ]
  %39 = getelementptr inbounds double, ptr %29, i64 %index465
  %40 = getelementptr inbounds i8, ptr %39, i64 16
  %wide.load466 = load <2 x double>, ptr %39, align 8, !tbaa !21
  %wide.load467 = load <2 x double>, ptr %40, align 8, !tbaa !21
  %41 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %index465
  %42 = getelementptr inbounds i8, ptr %41, i64 16
  store <2 x double> %wide.load466, ptr %41, align 8, !tbaa !21
  store <2 x double> %wide.load467, ptr %42, align 8, !tbaa !21
  %index.next468 = add nuw i64 %index465, 4
  %43 = icmp eq i64 %index.next468, %n.vec462
  br i1 %43, label %middle.block457, label %vector.body464, !llvm.loop !24

middle.block457:                                  ; preds = %vector.body464
  %cmp.n469 = icmp eq i64 %n.vec462, %wide.trip.count368
  br i1 %cmp.n469, label %.loopexit312, label %scalar.ph458.preheader

44:                                               ; preds = %25
  %45 = load i32, ptr %19, align 4, !tbaa !19
  %46 = sext i32 %45 to i64
  %47 = getelementptr inbounds ptr, ptr %14, i64 %46
  %48 = load ptr, ptr %47, align 8, !tbaa !20
  %49 = load double, ptr %48, align 8, !tbaa !21
  %50 = getelementptr inbounds i8, ptr %11, i64 112
  store double %49, ptr %50, align 8, !tbaa !21
  %51 = getelementptr inbounds i8, ptr %48, i64 8
  br label %.loopexit312.sink.split

52:                                               ; preds = %25
  %53 = load i32, ptr %19, align 4, !tbaa !19
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds ptr, ptr %14, i64 %54
  %56 = load ptr, ptr %55, align 8, !tbaa !20
  %57 = load double, ptr %56, align 8, !tbaa !21
  %58 = getelementptr inbounds i8, ptr %11, i64 112
  store double %57, ptr %58, align 8, !tbaa !21
  %59 = getelementptr inbounds i8, ptr %56, i64 8
  %60 = load double, ptr %59, align 8, !tbaa !21
  %61 = getelementptr inbounds i8, ptr %11, i64 120
  store double %60, ptr %61, align 8, !tbaa !21
  %62 = getelementptr inbounds i8, ptr %56, i64 16
  br label %.loopexit312.sink.split

scalar.ph458:                                     ; preds = %scalar.ph458.prol.loopexit, %scalar.ph458
  %indvars.iv365 = phi i64 [ %indvars.iv.next366.3, %scalar.ph458 ], [ %indvars.iv365.unr, %scalar.ph458.prol.loopexit ]
  %63 = getelementptr inbounds double, ptr %29, i64 %indvars.iv365
  %64 = load double, ptr %63, align 8, !tbaa !21
  %65 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %indvars.iv365
  store double %64, ptr %65, align 8, !tbaa !21
  %indvars.iv.next366 = add nuw nsw i64 %indvars.iv365, 1
  %66 = getelementptr inbounds double, ptr %29, i64 %indvars.iv.next366
  %67 = load double, ptr %66, align 8, !tbaa !21
  %68 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %indvars.iv.next366
  store double %67, ptr %68, align 8, !tbaa !21
  %indvars.iv.next366.1 = add nuw nsw i64 %indvars.iv365, 2
  %69 = getelementptr inbounds double, ptr %29, i64 %indvars.iv.next366.1
  %70 = load double, ptr %69, align 8, !tbaa !21
  %71 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %indvars.iv.next366.1
  store double %70, ptr %71, align 8, !tbaa !21
  %indvars.iv.next366.2 = add nuw nsw i64 %indvars.iv365, 3
  %72 = getelementptr inbounds double, ptr %29, i64 %indvars.iv.next366.2
  %73 = load double, ptr %72, align 8, !tbaa !21
  %74 = getelementptr inbounds [3 x double], ptr %30, i64 0, i64 %indvars.iv.next366.2
  store double %73, ptr %74, align 8, !tbaa !21
  %indvars.iv.next366.3 = add nuw nsw i64 %indvars.iv365, 4
  %exitcond369.not.3 = icmp eq i64 %indvars.iv.next366.3, %wide.trip.count368
  br i1 %exitcond369.not.3, label %.loopexit312, label %scalar.ph458, !llvm.loop !28

.loopexit312.sink.split:                          ; preds = %44, %52
  %.sink412 = phi ptr [ %62, %52 ], [ %51, %44 ]
  %.sink411 = phi i64 [ 128, %52 ], [ 120, %44 ]
  %.ph = phi i32 [ %53, %52 ], [ %45, %44 ]
  %75 = load double, ptr %.sink412, align 8, !tbaa !21
  %76 = getelementptr inbounds i8, ptr %11, i64 %.sink411
  store double %75, ptr %76, align 8, !tbaa !21
  br label %.loopexit312

.loopexit312:                                     ; preds = %scalar.ph458.prol.loopexit, %scalar.ph458, %middle.block457, %.loopexit312.sink.split, %.preheader311
  %77 = phi i32 [ %.pre, %.preheader311 ], [ %.ph, %.loopexit312.sink.split ], [ %.pre, %middle.block457 ], [ %.pre, %scalar.ph458 ], [ %.pre, %scalar.ph458.prol.loopexit ]
  %78 = getelementptr inbounds i8, ptr %11, i64 104
  store i32 %77, ptr %78, align 8, !tbaa !29
  br label %418

79:                                               ; preds = %23
  %80 = call i32 @SMgetActiveDirections(i32 noundef 2, ptr noundef %14, ptr noundef %19, i32 noundef %24, ptr noundef nonnull %3)
  %.not = icmp eq i32 %80, 0
  br i1 %.not, label %83, label %81

81:                                               ; preds = %79
  %82 = call i32 @SMerror(i32 noundef 58, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %80, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

83:                                               ; preds = %79
  %84 = load ptr, ptr %3, align 8, !tbaa !20
  %85 = getelementptr inbounds i8, ptr %11, i64 168
  %86 = load ptr, ptr %85, align 8, !tbaa !30
  %87 = call i32 @SMformGrammian(i32 noundef 2, ptr noundef %84, ptr noundef %86, i32 noundef %24) #6
  %.not287 = icmp eq i32 %87, 0
  br i1 %.not287, label %90, label %88

88:                                               ; preds = %83
  %89 = call i32 @SMerror(i32 noundef 61, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %87, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

90:                                               ; preds = %83
  %91 = call i32 @SMformPDGrammian(ptr noundef nonnull %11) #6
  %.not288 = icmp eq i32 %91, 0
  br i1 %.not288, label %94, label %92

92:                                               ; preds = %90
  %93 = call i32 @SMerror(i32 noundef 62, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %91, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

94:                                               ; preds = %90
  %95 = load ptr, ptr %85, align 8, !tbaa !30
  %96 = load ptr, ptr %95, align 8, !tbaa !20
  %97 = load double, ptr %96, align 8, !tbaa !21
  %98 = getelementptr inbounds i8, ptr %95, i64 8
  %99 = load ptr, ptr %98, align 8, !tbaa !20
  %100 = getelementptr inbounds i8, ptr %99, i64 8
  %101 = load double, ptr %100, align 8, !tbaa !21
  %102 = fadd double %97, %101
  %103 = getelementptr inbounds i8, ptr %96, i64 8
  %104 = load double, ptr %103, align 8, !tbaa !21
  %105 = call double @llvm.fmuladd.f64(double %104, double -2.000000e+00, double %102)
  %106 = call double @llvm.fabs.f64(double %105)
  %107 = fcmp ogt double %106, 1.000000e-15
  br i1 %107, label %108, label %204

108:                                              ; preds = %94
  %109 = fsub double %97, %104
  %110 = fdiv double %109, %105
  %111 = fsub double 1.000000e+00, %110
  %112 = fcmp olt double %110, 0.000000e+00
  %113 = fcmp ogt double %110, 1.000000e+00
  %or.cond = or i1 %112, %113
  br i1 %or.cond, label %159, label %.preheader315

.preheader315:                                    ; preds = %108
  %114 = icmp sgt i32 %24, 0
  br i1 %114, label %.lr.ph321, label %.lr.ph325.preheader

.lr.ph321:                                        ; preds = %.preheader315
  %115 = load ptr, ptr %3, align 8, !tbaa !20
  %116 = load ptr, ptr %115, align 8, !tbaa !20
  %117 = getelementptr inbounds i8, ptr %115, i64 8
  %118 = load ptr, ptr %117, align 8, !tbaa !20
  %119 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count353 = zext nneg i32 %24 to i64
  %min.iters.check425 = icmp ult i32 %24, 6
  br i1 %min.iters.check425, label %scalar.ph424.preheader, label %vector.memcheck420

vector.memcheck420:                               ; preds = %.lr.ph321
  %120 = ptrtoint ptr %118 to i64
  %121 = ptrtoint ptr %116 to i64
  %122 = add i64 %12, 112
  %123 = sub i64 %122, %121
  %diff.check421 = icmp ult i64 %123, 32
  %124 = sub i64 %122, %120
  %diff.check422 = icmp ult i64 %124, 32
  %conflict.rdx = or i1 %diff.check421, %diff.check422
  br i1 %conflict.rdx, label %scalar.ph424.preheader, label %vector.ph426

vector.ph426:                                     ; preds = %vector.memcheck420
  %n.vec428 = and i64 %wide.trip.count353, 2147483644
  %broadcast.splatinsert = insertelement <2 x double> poison, double %110, i64 0
  %broadcast.splat = shufflevector <2 x double> %broadcast.splatinsert, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert436 = insertelement <2 x double> poison, double %111, i64 0
  %broadcast.splat437 = shufflevector <2 x double> %broadcast.splatinsert436, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body430

vector.body430:                                   ; preds = %vector.body430, %vector.ph426
  %index431 = phi i64 [ 0, %vector.ph426 ], [ %index.next438, %vector.body430 ]
  %125 = getelementptr inbounds double, ptr %116, i64 %index431
  %126 = getelementptr inbounds i8, ptr %125, i64 16
  %wide.load432 = load <2 x double>, ptr %125, align 8, !tbaa !21
  %wide.load433 = load <2 x double>, ptr %126, align 8, !tbaa !21
  %127 = getelementptr inbounds double, ptr %118, i64 %index431
  %128 = getelementptr inbounds i8, ptr %127, i64 16
  %wide.load434 = load <2 x double>, ptr %127, align 8, !tbaa !21
  %wide.load435 = load <2 x double>, ptr %128, align 8, !tbaa !21
  %129 = fmul <2 x double> %broadcast.splat, %wide.load434
  %130 = fmul <2 x double> %broadcast.splat, %wide.load435
  %131 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %broadcast.splat437, <2 x double> %wide.load432, <2 x double> %129)
  %132 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %broadcast.splat437, <2 x double> %wide.load433, <2 x double> %130)
  %133 = getelementptr inbounds [3 x double], ptr %119, i64 0, i64 %index431
  %134 = getelementptr inbounds i8, ptr %133, i64 16
  store <2 x double> %131, ptr %133, align 8, !tbaa !21
  store <2 x double> %132, ptr %134, align 8, !tbaa !21
  %index.next438 = add nuw i64 %index431, 4
  %135 = icmp eq i64 %index.next438, %n.vec428
  br i1 %135, label %middle.block423, label %vector.body430, !llvm.loop !31

middle.block423:                                  ; preds = %vector.body430
  %cmp.n439 = icmp eq i64 %n.vec428, %wide.trip.count353
  br i1 %cmp.n439, label %.lr.ph325.preheader, label %scalar.ph424.preheader

scalar.ph424.preheader:                           ; preds = %middle.block423, %vector.memcheck420, %.lr.ph321
  %indvars.iv350.ph = phi i64 [ 0, %vector.memcheck420 ], [ 0, %.lr.ph321 ], [ %n.vec428, %middle.block423 ]
  %xtraiter487 = and i64 %wide.trip.count353, 1
  %lcmp.mod488.not = icmp eq i64 %xtraiter487, 0
  br i1 %lcmp.mod488.not, label %scalar.ph424.prol.loopexit, label %scalar.ph424.prol

scalar.ph424.prol:                                ; preds = %scalar.ph424.preheader
  %136 = getelementptr inbounds double, ptr %116, i64 %indvars.iv350.ph
  %137 = load double, ptr %136, align 8, !tbaa !21
  %138 = getelementptr inbounds double, ptr %118, i64 %indvars.iv350.ph
  %139 = load double, ptr %138, align 8, !tbaa !21
  %140 = fmul double %110, %139
  %141 = call double @llvm.fmuladd.f64(double %111, double %137, double %140)
  %142 = getelementptr inbounds [3 x double], ptr %119, i64 0, i64 %indvars.iv350.ph
  store double %141, ptr %142, align 8, !tbaa !21
  %indvars.iv.next351.prol = or disjoint i64 %indvars.iv350.ph, 1
  br label %scalar.ph424.prol.loopexit

scalar.ph424.prol.loopexit:                       ; preds = %scalar.ph424.prol, %scalar.ph424.preheader
  %indvars.iv350.unr = phi i64 [ %indvars.iv350.ph, %scalar.ph424.preheader ], [ %indvars.iv.next351.prol, %scalar.ph424.prol ]
  %143 = add nsw i64 %wide.trip.count353, -1
  %144 = icmp eq i64 %indvars.iv350.ph, %143
  br i1 %144, label %.lr.ph325.preheader, label %scalar.ph424

scalar.ph424:                                     ; preds = %scalar.ph424.prol.loopexit, %scalar.ph424
  %indvars.iv350 = phi i64 [ %indvars.iv.next351.1, %scalar.ph424 ], [ %indvars.iv350.unr, %scalar.ph424.prol.loopexit ]
  %145 = getelementptr inbounds double, ptr %116, i64 %indvars.iv350
  %146 = load double, ptr %145, align 8, !tbaa !21
  %147 = getelementptr inbounds double, ptr %118, i64 %indvars.iv350
  %148 = load double, ptr %147, align 8, !tbaa !21
  %149 = fmul double %110, %148
  %150 = call double @llvm.fmuladd.f64(double %111, double %146, double %149)
  %151 = getelementptr inbounds [3 x double], ptr %119, i64 0, i64 %indvars.iv350
  store double %150, ptr %151, align 8, !tbaa !21
  %indvars.iv.next351 = add nuw nsw i64 %indvars.iv350, 1
  %152 = getelementptr inbounds double, ptr %116, i64 %indvars.iv.next351
  %153 = load double, ptr %152, align 8, !tbaa !21
  %154 = getelementptr inbounds double, ptr %118, i64 %indvars.iv.next351
  %155 = load double, ptr %154, align 8, !tbaa !21
  %156 = fmul double %110, %155
  %157 = call double @llvm.fmuladd.f64(double %111, double %153, double %156)
  %158 = getelementptr inbounds [3 x double], ptr %119, i64 0, i64 %indvars.iv.next351
  store double %157, ptr %158, align 8, !tbaa !21
  %indvars.iv.next351.1 = add nuw nsw i64 %indvars.iv350, 2
  %exitcond354.not.1 = icmp eq i64 %indvars.iv.next351.1, %wide.trip.count353
  br i1 %exitcond354.not.1, label %.lr.ph325.preheader, label %scalar.ph424, !llvm.loop !32

159:                                              ; preds = %108
  switch i32 %24, label %.preheader313 [
    i32 2, label %177
    i32 3, label %183
  ]

.preheader313:                                    ; preds = %159
  %160 = icmp sgt i32 %24, 0
  br i1 %160, label %.lr.ph323, label %.lr.ph325.preheader

.lr.ph323:                                        ; preds = %.preheader313
  %161 = load ptr, ptr %3, align 8, !tbaa !20
  %162 = load ptr, ptr %161, align 8, !tbaa !20
  %163 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count358 = zext nneg i32 %24 to i64
  %min.iters.check444 = icmp ult i32 %24, 8
  br i1 %min.iters.check444, label %scalar.ph443.preheader, label %vector.memcheck440

scalar.ph443.preheader:                           ; preds = %middle.block442, %vector.memcheck440, %.lr.ph323
  %indvars.iv355.ph = phi i64 [ 0, %vector.memcheck440 ], [ 0, %.lr.ph323 ], [ %n.vec447, %middle.block442 ]
  %xtraiter490 = and i64 %wide.trip.count358, 3
  %lcmp.mod491.not = icmp eq i64 %xtraiter490, 0
  br i1 %lcmp.mod491.not, label %scalar.ph443.prol.loopexit, label %scalar.ph443.prol

scalar.ph443.prol:                                ; preds = %scalar.ph443.preheader, %scalar.ph443.prol
  %indvars.iv355.prol = phi i64 [ %indvars.iv.next356.prol, %scalar.ph443.prol ], [ %indvars.iv355.ph, %scalar.ph443.preheader ]
  %prol.iter492 = phi i64 [ %prol.iter492.next, %scalar.ph443.prol ], [ 0, %scalar.ph443.preheader ]
  %164 = getelementptr inbounds double, ptr %162, i64 %indvars.iv355.prol
  %165 = load double, ptr %164, align 8, !tbaa !21
  %166 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %indvars.iv355.prol
  store double %165, ptr %166, align 8, !tbaa !21
  %indvars.iv.next356.prol = add nuw nsw i64 %indvars.iv355.prol, 1
  %prol.iter492.next = add i64 %prol.iter492, 1
  %prol.iter492.cmp.not = icmp eq i64 %prol.iter492.next, %xtraiter490
  br i1 %prol.iter492.cmp.not, label %scalar.ph443.prol.loopexit, label %scalar.ph443.prol, !llvm.loop !33

scalar.ph443.prol.loopexit:                       ; preds = %scalar.ph443.prol, %scalar.ph443.preheader
  %indvars.iv355.unr = phi i64 [ %indvars.iv355.ph, %scalar.ph443.preheader ], [ %indvars.iv.next356.prol, %scalar.ph443.prol ]
  %167 = sub nsw i64 %indvars.iv355.ph, %wide.trip.count358
  %168 = icmp ugt i64 %167, -4
  br i1 %168, label %.lr.ph325.preheader, label %scalar.ph443

vector.memcheck440:                               ; preds = %.lr.ph323
  %169 = ptrtoint ptr %162 to i64
  %170 = add i64 %12, 112
  %171 = sub i64 %170, %169
  %diff.check441 = icmp ult i64 %171, 32
  br i1 %diff.check441, label %scalar.ph443.preheader, label %vector.ph445

vector.ph445:                                     ; preds = %vector.memcheck440
  %n.vec447 = and i64 %wide.trip.count358, 2147483644
  br label %vector.body449

vector.body449:                                   ; preds = %vector.body449, %vector.ph445
  %index450 = phi i64 [ 0, %vector.ph445 ], [ %index.next453, %vector.body449 ]
  %172 = getelementptr inbounds double, ptr %162, i64 %index450
  %173 = getelementptr inbounds i8, ptr %172, i64 16
  %wide.load451 = load <2 x double>, ptr %172, align 8, !tbaa !21
  %wide.load452 = load <2 x double>, ptr %173, align 8, !tbaa !21
  %174 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %index450
  %175 = getelementptr inbounds i8, ptr %174, i64 16
  store <2 x double> %wide.load451, ptr %174, align 8, !tbaa !21
  store <2 x double> %wide.load452, ptr %175, align 8, !tbaa !21
  %index.next453 = add nuw i64 %index450, 4
  %176 = icmp eq i64 %index.next453, %n.vec447
  br i1 %176, label %middle.block442, label %vector.body449, !llvm.loop !34

middle.block442:                                  ; preds = %vector.body449
  %cmp.n454 = icmp eq i64 %n.vec447, %wide.trip.count358
  br i1 %cmp.n454, label %.lr.ph325.preheader, label %scalar.ph443.preheader

177:                                              ; preds = %159
  %178 = load ptr, ptr %3, align 8, !tbaa !20
  %179 = load ptr, ptr %178, align 8, !tbaa !20
  %180 = load double, ptr %179, align 8, !tbaa !21
  %181 = getelementptr inbounds i8, ptr %11, i64 112
  store double %180, ptr %181, align 8, !tbaa !21
  %182 = getelementptr inbounds i8, ptr %179, i64 8
  br label %.lr.ph325.preheader.sink.split

183:                                              ; preds = %159
  %184 = load ptr, ptr %3, align 8, !tbaa !20
  %185 = load ptr, ptr %184, align 8, !tbaa !20
  %186 = load double, ptr %185, align 8, !tbaa !21
  %187 = getelementptr inbounds i8, ptr %11, i64 112
  store double %186, ptr %187, align 8, !tbaa !21
  %188 = getelementptr inbounds i8, ptr %185, i64 8
  %189 = load double, ptr %188, align 8, !tbaa !21
  %190 = getelementptr inbounds i8, ptr %11, i64 120
  store double %189, ptr %190, align 8, !tbaa !21
  %191 = getelementptr inbounds i8, ptr %185, i64 16
  br label %.lr.ph325.preheader.sink.split

scalar.ph443:                                     ; preds = %scalar.ph443.prol.loopexit, %scalar.ph443
  %indvars.iv355 = phi i64 [ %indvars.iv.next356.3, %scalar.ph443 ], [ %indvars.iv355.unr, %scalar.ph443.prol.loopexit ]
  %192 = getelementptr inbounds double, ptr %162, i64 %indvars.iv355
  %193 = load double, ptr %192, align 8, !tbaa !21
  %194 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %indvars.iv355
  store double %193, ptr %194, align 8, !tbaa !21
  %indvars.iv.next356 = add nuw nsw i64 %indvars.iv355, 1
  %195 = getelementptr inbounds double, ptr %162, i64 %indvars.iv.next356
  %196 = load double, ptr %195, align 8, !tbaa !21
  %197 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %indvars.iv.next356
  store double %196, ptr %197, align 8, !tbaa !21
  %indvars.iv.next356.1 = add nuw nsw i64 %indvars.iv355, 2
  %198 = getelementptr inbounds double, ptr %162, i64 %indvars.iv.next356.1
  %199 = load double, ptr %198, align 8, !tbaa !21
  %200 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %indvars.iv.next356.1
  store double %199, ptr %200, align 8, !tbaa !21
  %indvars.iv.next356.2 = add nuw nsw i64 %indvars.iv355, 3
  %201 = getelementptr inbounds double, ptr %162, i64 %indvars.iv.next356.2
  %202 = load double, ptr %201, align 8, !tbaa !21
  %203 = getelementptr inbounds [3 x double], ptr %163, i64 0, i64 %indvars.iv.next356.2
  store double %202, ptr %203, align 8, !tbaa !21
  %indvars.iv.next356.3 = add nuw nsw i64 %indvars.iv355, 4
  %exitcond359.not.3 = icmp eq i64 %indvars.iv.next356.3, %wide.trip.count358
  br i1 %exitcond359.not.3, label %.lr.ph325.preheader, label %scalar.ph443, !llvm.loop !35

204:                                              ; preds = %94
  switch i32 %24, label %.preheader317 [
    i32 2, label %222
    i32 3, label %228
  ]

.preheader317:                                    ; preds = %204
  %205 = icmp sgt i32 %24, 0
  br i1 %205, label %.lr.ph, label %.lr.ph325.preheader

.lr.ph:                                           ; preds = %.preheader317
  %206 = load ptr, ptr %3, align 8, !tbaa !20
  %207 = load ptr, ptr %206, align 8, !tbaa !20
  %208 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count = zext nneg i32 %24 to i64
  %min.iters.check = icmp ult i32 %24, 8
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.memcheck

scalar.ph.preheader:                              ; preds = %middle.block, %vector.memcheck, %.lr.ph
  %indvars.iv.ph = phi i64 [ 0, %vector.memcheck ], [ 0, %.lr.ph ], [ %n.vec, %middle.block ]
  %xtraiter = and i64 %wide.trip.count, 3
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader, %scalar.ph.prol
  %indvars.iv.prol = phi i64 [ %indvars.iv.next.prol, %scalar.ph.prol ], [ %indvars.iv.ph, %scalar.ph.preheader ]
  %prol.iter = phi i64 [ %prol.iter.next, %scalar.ph.prol ], [ 0, %scalar.ph.preheader ]
  %209 = getelementptr inbounds double, ptr %207, i64 %indvars.iv.prol
  %210 = load double, ptr %209, align 8, !tbaa !21
  %211 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %indvars.iv.prol
  store double %210, ptr %211, align 8, !tbaa !21
  %indvars.iv.next.prol = add nuw nsw i64 %indvars.iv.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol, !llvm.loop !36

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %scalar.ph.preheader
  %indvars.iv.unr = phi i64 [ %indvars.iv.ph, %scalar.ph.preheader ], [ %indvars.iv.next.prol, %scalar.ph.prol ]
  %212 = sub nsw i64 %indvars.iv.ph, %wide.trip.count
  %213 = icmp ugt i64 %212, -4
  br i1 %213, label %.lr.ph325.preheader, label %scalar.ph

vector.memcheck:                                  ; preds = %.lr.ph
  %214 = ptrtoint ptr %207 to i64
  %215 = add i64 %12, 112
  %216 = sub i64 %215, %214
  %diff.check = icmp ult i64 %216, 32
  br i1 %diff.check, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %vector.memcheck
  %n.vec = and i64 %wide.trip.count, 2147483644
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %217 = getelementptr inbounds double, ptr %207, i64 %index
  %218 = getelementptr inbounds i8, ptr %217, i64 16
  %wide.load = load <2 x double>, ptr %217, align 8, !tbaa !21
  %wide.load419 = load <2 x double>, ptr %218, align 8, !tbaa !21
  %219 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %index
  %220 = getelementptr inbounds i8, ptr %219, i64 16
  store <2 x double> %wide.load, ptr %219, align 8, !tbaa !21
  store <2 x double> %wide.load419, ptr %220, align 8, !tbaa !21
  %index.next = add nuw i64 %index, 4
  %221 = icmp eq i64 %index.next, %n.vec
  br i1 %221, label %middle.block, label %vector.body, !llvm.loop !37

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %.lr.ph325.preheader, label %scalar.ph.preheader

222:                                              ; preds = %204
  %223 = load ptr, ptr %3, align 8, !tbaa !20
  %224 = load ptr, ptr %223, align 8, !tbaa !20
  %225 = load double, ptr %224, align 8, !tbaa !21
  %226 = getelementptr inbounds i8, ptr %11, i64 112
  store double %225, ptr %226, align 8, !tbaa !21
  %227 = getelementptr inbounds i8, ptr %224, i64 8
  br label %.lr.ph325.preheader.sink.split

228:                                              ; preds = %204
  %229 = load ptr, ptr %3, align 8, !tbaa !20
  %230 = load ptr, ptr %229, align 8, !tbaa !20
  %231 = load double, ptr %230, align 8, !tbaa !21
  %232 = getelementptr inbounds i8, ptr %11, i64 112
  store double %231, ptr %232, align 8, !tbaa !21
  %233 = getelementptr inbounds i8, ptr %230, i64 8
  %234 = load double, ptr %233, align 8, !tbaa !21
  %235 = getelementptr inbounds i8, ptr %11, i64 120
  store double %234, ptr %235, align 8, !tbaa !21
  %236 = getelementptr inbounds i8, ptr %230, i64 16
  br label %.lr.ph325.preheader.sink.split

scalar.ph:                                        ; preds = %scalar.ph.prol.loopexit, %scalar.ph
  %indvars.iv = phi i64 [ %indvars.iv.next.3, %scalar.ph ], [ %indvars.iv.unr, %scalar.ph.prol.loopexit ]
  %237 = getelementptr inbounds double, ptr %207, i64 %indvars.iv
  %238 = load double, ptr %237, align 8, !tbaa !21
  %239 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %indvars.iv
  store double %238, ptr %239, align 8, !tbaa !21
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %240 = getelementptr inbounds double, ptr %207, i64 %indvars.iv.next
  %241 = load double, ptr %240, align 8, !tbaa !21
  %242 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %indvars.iv.next
  store double %241, ptr %242, align 8, !tbaa !21
  %indvars.iv.next.1 = add nuw nsw i64 %indvars.iv, 2
  %243 = getelementptr inbounds double, ptr %207, i64 %indvars.iv.next.1
  %244 = load double, ptr %243, align 8, !tbaa !21
  %245 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %indvars.iv.next.1
  store double %244, ptr %245, align 8, !tbaa !21
  %indvars.iv.next.2 = add nuw nsw i64 %indvars.iv, 3
  %246 = getelementptr inbounds double, ptr %207, i64 %indvars.iv.next.2
  %247 = load double, ptr %246, align 8, !tbaa !21
  %248 = getelementptr inbounds [3 x double], ptr %208, i64 0, i64 %indvars.iv.next.2
  store double %247, ptr %248, align 8, !tbaa !21
  %indvars.iv.next.3 = add nuw nsw i64 %indvars.iv, 4
  %exitcond.not.3 = icmp eq i64 %indvars.iv.next.3, %wide.trip.count
  br i1 %exitcond.not.3, label %.lr.ph325.preheader, label %scalar.ph, !llvm.loop !38

.lr.ph325.preheader.sink.split:                   ; preds = %222, %228, %177, %183
  %.sink415 = phi ptr [ %191, %183 ], [ %182, %177 ], [ %236, %228 ], [ %227, %222 ]
  %.sink414 = phi i64 [ 128, %183 ], [ 120, %177 ], [ 128, %228 ], [ 120, %222 ]
  %249 = load double, ptr %.sink415, align 8, !tbaa !21
  %250 = getelementptr inbounds i8, ptr %11, i64 %.sink414
  store double %249, ptr %250, align 8, !tbaa !21
  br label %.lr.ph325.preheader

.lr.ph325.preheader:                              ; preds = %scalar.ph.prol.loopexit, %scalar.ph, %scalar.ph424.prol.loopexit, %scalar.ph424, %scalar.ph443.prol.loopexit, %scalar.ph443, %middle.block, %middle.block423, %middle.block442, %.lr.ph325.preheader.sink.split, %.preheader313, %.preheader315, %.preheader317
  %251 = load i32, ptr %19, align 4, !tbaa !19
  %252 = getelementptr inbounds i8, ptr %11, i64 104
  store i32 %251, ptr %252, align 8, !tbaa !29
  %253 = load ptr, ptr %3, align 8, !tbaa !20
  %254 = load ptr, ptr %253, align 8, !tbaa !20
  %255 = icmp eq ptr %254, null
  br i1 %255, label %256, label %.lr.ph325.1

256:                                              ; preds = %.lr.ph325.1, %.lr.ph325.preheader
  %257 = call i32 @SMerror(i32 noundef 86, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

.lr.ph325.1:                                      ; preds = %.lr.ph325.preheader
  call void @free(ptr noundef nonnull %254) #6
  %258 = load ptr, ptr %3, align 8, !tbaa !20
  %259 = getelementptr inbounds i8, ptr %258, i64 8
  %260 = load ptr, ptr %259, align 8, !tbaa !20
  %261 = icmp eq ptr %260, null
  br i1 %261, label %256, label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph325.1
  call void @free(ptr noundef nonnull %260) #6
  %262 = load ptr, ptr %3, align 8, !tbaa !20
  %263 = icmp eq ptr %262, null
  br i1 %263, label %264, label %266

264:                                              ; preds = %._crit_edge
  %265 = call i32 @SMerror(i32 noundef 87, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

266:                                              ; preds = %._crit_edge
  call void @free(ptr noundef nonnull %262) #6
  br label %418

267:                                              ; preds = %23
  %268 = call i32 @SMgetActiveDirections(i32 noundef %17, ptr noundef %14, ptr noundef %19, i32 noundef %24, ptr noundef nonnull %3)
  %.not290 = icmp eq i32 %268, 0
  br i1 %.not290, label %271, label %269

269:                                              ; preds = %267
  %270 = call i32 @SMerror(i32 noundef 99, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %268, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

271:                                              ; preds = %267
  %272 = load ptr, ptr %3, align 8, !tbaa !20
  %273 = getelementptr inbounds i8, ptr %11, i64 168
  %274 = load ptr, ptr %273, align 8, !tbaa !30
  %275 = call i32 @SMformGrammian(i32 noundef %17, ptr noundef %272, ptr noundef %274, i32 noundef %24) #6
  %.not291 = icmp eq i32 %275, 0
  br i1 %.not291, label %278, label %276

276:                                              ; preds = %271
  %277 = call i32 @SMerror(i32 noundef 102, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %275, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

278:                                              ; preds = %271
  %279 = call i32 @SMformPDGrammian(ptr noundef nonnull %11) #6
  %.not292 = icmp eq i32 %279, 0
  br i1 %.not292, label %282, label %280

280:                                              ; preds = %278
  %281 = call i32 @SMerror(i32 noundef 103, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %279, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

282:                                              ; preds = %278
  %283 = load ptr, ptr %273, align 8, !tbaa !30
  switch i32 %24, label %404 [
    i32 2, label %284
    i32 3, label %289
  ]

284:                                              ; preds = %282
  %285 = load ptr, ptr %3, align 8, !tbaa !20
  %286 = call i32 @SMsearchEdgesFaces(i32 noundef %17, ptr noundef %283, ptr noundef %285, ptr noundef nonnull %11)
  %.not301 = icmp eq i32 %286, 0
  br i1 %.not301, label %404, label %287

287:                                              ; preds = %284
  %288 = call i32 @SMerror(i32 noundef 108, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %286, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

289:                                              ; preds = %282
  %290 = icmp eq i32 %17, 3
  br i1 %290, label %291, label %399

291:                                              ; preds = %289
  %292 = call i32 @SMsingularTest(i32 noundef 3, ptr noundef %283, ptr noundef nonnull %2) #6
  %.not294 = icmp eq i32 %292, 0
  br i1 %.not294, label %295, label %293

293:                                              ; preds = %291
  %294 = call i32 @SMerror(i32 noundef 112, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %292, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

295:                                              ; preds = %291
  %296 = load i32, ptr %2, align 4, !tbaa !19
  %.not295 = icmp eq i32 %296, 0
  br i1 %.not295, label %297, label %394

297:                                              ; preds = %295
  %298 = call i32 @SMformReducedMatrix(i32 noundef 3, ptr noundef %283, ptr noundef nonnull %4) #6
  %.not296 = icmp eq i32 %298, 0
  br i1 %.not296, label %301, label %299

299:                                              ; preds = %297
  %300 = call i32 @SMerror(i32 noundef 115, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %298, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

301:                                              ; preds = %297
  %302 = load ptr, ptr %283, align 8, !tbaa !20
  %303 = load double, ptr %302, align 8, !tbaa !21
  %304 = getelementptr inbounds i8, ptr %283, i64 8
  %305 = load ptr, ptr %304, align 8, !tbaa !20
  %306 = load double, ptr %305, align 8, !tbaa !21
  %307 = fsub double %303, %306
  %308 = getelementptr inbounds i8, ptr %283, i64 16
  %309 = load ptr, ptr %308, align 8, !tbaa !20
  %310 = load double, ptr %309, align 8, !tbaa !21
  %311 = fsub double %303, %310
  %312 = load ptr, ptr %4, align 8, !tbaa !20
  %313 = load ptr, ptr %312, align 8, !tbaa !20
  %314 = load double, ptr %313, align 8, !tbaa !21
  %315 = getelementptr inbounds i8, ptr %313, i64 8
  %316 = load double, ptr %315, align 8, !tbaa !21
  %317 = getelementptr inbounds i8, ptr %312, i64 8
  %318 = load ptr, ptr %317, align 8, !tbaa !20
  %319 = load double, ptr %318, align 8, !tbaa !21
  %320 = getelementptr inbounds i8, ptr %318, i64 8
  %321 = load double, ptr %320, align 8, !tbaa !21
  %322 = call i32 @SMsolve2x2(double noundef %314, double noundef %316, double noundef %319, double noundef %321, double noundef %307, double noundef %311, ptr noundef nonnull %5) #6
  %.not297 = icmp eq i32 %322, 0
  br i1 %.not297, label %325, label %323

323:                                              ; preds = %301
  %324 = call i32 @SMerror(i32 noundef 119, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %322, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

325:                                              ; preds = %301
  %326 = load ptr, ptr %5, align 8, !tbaa !20
  %.not298 = icmp eq ptr %326, null
  br i1 %.not298, label %389, label %327

327:                                              ; preds = %325
  %328 = load double, ptr %326, align 8, !tbaa !21
  %329 = fsub double 1.000000e+00, %328
  %330 = getelementptr inbounds i8, ptr %326, i64 8
  %331 = load double, ptr %330, align 8, !tbaa !21
  %332 = fsub double %329, %331
  %333 = load ptr, ptr %3, align 8, !tbaa !20
  %334 = load ptr, ptr %333, align 8, !tbaa !20
  %335 = getelementptr inbounds i8, ptr %333, i64 8
  %336 = load ptr, ptr %335, align 8, !tbaa !20
  %337 = getelementptr inbounds i8, ptr %333, i64 16
  %338 = load ptr, ptr %337, align 8, !tbaa !20
  %339 = getelementptr inbounds i8, ptr %11, i64 112
  %340 = load double, ptr %334, align 8, !tbaa !21
  %341 = load double, ptr %336, align 8, !tbaa !21
  %342 = fmul double %328, %341
  %343 = call double @llvm.fmuladd.f64(double %332, double %340, double %342)
  %344 = load double, ptr %338, align 8, !tbaa !21
  %345 = call double @llvm.fmuladd.f64(double %331, double %344, double %343)
  store double %345, ptr %339, align 8, !tbaa !21
  %346 = getelementptr inbounds i8, ptr %334, i64 8
  %347 = load double, ptr %346, align 8, !tbaa !21
  %348 = getelementptr inbounds i8, ptr %336, i64 8
  %349 = load double, ptr %348, align 8, !tbaa !21
  %350 = fmul double %328, %349
  %351 = call double @llvm.fmuladd.f64(double %332, double %347, double %350)
  %352 = getelementptr inbounds i8, ptr %338, i64 8
  %353 = load double, ptr %352, align 8, !tbaa !21
  %354 = call double @llvm.fmuladd.f64(double %331, double %353, double %351)
  %355 = getelementptr inbounds i8, ptr %11, i64 120
  store double %354, ptr %355, align 8, !tbaa !21
  %356 = getelementptr inbounds i8, ptr %334, i64 16
  %357 = load double, ptr %356, align 8, !tbaa !21
  %358 = getelementptr inbounds i8, ptr %336, i64 16
  %359 = load double, ptr %358, align 8, !tbaa !21
  %360 = fmul double %328, %359
  %361 = call double @llvm.fmuladd.f64(double %332, double %357, double %360)
  %362 = getelementptr inbounds i8, ptr %338, i64 16
  %363 = load double, ptr %362, align 8, !tbaa !21
  %364 = call double @llvm.fmuladd.f64(double %331, double %363, double %361)
  %365 = getelementptr inbounds i8, ptr %11, i64 128
  store double %364, ptr %365, align 8, !tbaa !21
  %366 = load i32, ptr %19, align 4, !tbaa !19
  %367 = getelementptr inbounds i8, ptr %11, i64 104
  store i32 %366, ptr %367, align 8, !tbaa !29
  %368 = load ptr, ptr %4, align 8, !tbaa !20
  %369 = load ptr, ptr %368, align 8, !tbaa !20
  %370 = icmp eq ptr %369, null
  br i1 %370, label %371, label %373

371:                                              ; preds = %373, %327
  %372 = call i32 @SMerror(i32 noundef 127, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

373:                                              ; preds = %327
  call void @free(ptr noundef nonnull %369) #6
  %374 = load ptr, ptr %4, align 8, !tbaa !20
  %375 = getelementptr inbounds i8, ptr %374, i64 8
  %376 = load ptr, ptr %375, align 8, !tbaa !20
  %377 = icmp eq ptr %376, null
  br i1 %377, label %371, label %378

378:                                              ; preds = %373
  call void @free(ptr noundef nonnull %376) #6
  %379 = load ptr, ptr %4, align 8, !tbaa !20
  %380 = icmp eq ptr %379, null
  br i1 %380, label %381, label %383

381:                                              ; preds = %378
  %382 = call i32 @SMerror(i32 noundef 128, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

383:                                              ; preds = %378
  call void @free(ptr noundef nonnull %379) #6
  %384 = load ptr, ptr %5, align 8, !tbaa !20
  %385 = icmp eq ptr %384, null
  br i1 %385, label %386, label %388

386:                                              ; preds = %383
  %387 = call i32 @SMerror(i32 noundef 128, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

388:                                              ; preds = %383
  call void @free(ptr noundef nonnull %384) #6
  br label %.lr.ph332.preheader

389:                                              ; preds = %325
  %390 = load ptr, ptr %3, align 8, !tbaa !20
  %391 = call i32 @SMsearchEdgesFaces(i32 noundef 3, ptr noundef nonnull %283, ptr noundef %390, ptr noundef nonnull %11)
  %.not299 = icmp eq i32 %391, 0
  br i1 %.not299, label %.lr.ph332.preheader, label %392

392:                                              ; preds = %389
  %393 = call i32 @SMerror(i32 noundef 131, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %391, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

394:                                              ; preds = %295
  %395 = load ptr, ptr %3, align 8, !tbaa !20
  %396 = call i32 @SMsearchEdgesFaces(i32 noundef 3, ptr noundef %283, ptr noundef %395, ptr noundef nonnull %11)
  %.not300 = icmp eq i32 %396, 0
  br i1 %.not300, label %.lr.ph332.preheader, label %397

397:                                              ; preds = %394
  %398 = call i32 @SMerror(i32 noundef 135, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %396, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

399:                                              ; preds = %289
  %400 = load ptr, ptr %3, align 8, !tbaa !20
  %401 = call i32 @SMsearchEdgesFaces(i32 noundef %17, ptr noundef %283, ptr noundef %400, ptr noundef nonnull %11)
  %.not293 = icmp eq i32 %401, 0
  br i1 %.not293, label %404, label %402

402:                                              ; preds = %399
  %403 = call i32 @SMerror(i32 noundef 139, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef %401, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

404:                                              ; preds = %399, %284, %282
  %405 = icmp sgt i32 %17, 0
  br i1 %405, label %.lr.ph332.preheader, label %._crit_edge333

.lr.ph332.preheader:                              ; preds = %389, %388, %394, %404
  %wide.trip.count380 = zext nneg i32 %17 to i64
  br label %.lr.ph332

.lr.ph332:                                        ; preds = %.lr.ph332.preheader, %412
  %indvars.iv377 = phi i64 [ 0, %.lr.ph332.preheader ], [ %indvars.iv.next378, %412 ]
  %406 = load ptr, ptr %3, align 8, !tbaa !20
  %407 = getelementptr inbounds ptr, ptr %406, i64 %indvars.iv377
  %408 = load ptr, ptr %407, align 8, !tbaa !20
  %409 = icmp eq ptr %408, null
  br i1 %409, label %410, label %412

410:                                              ; preds = %.lr.ph332
  %411 = call i32 @SMerror(i32 noundef 143, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

412:                                              ; preds = %.lr.ph332
  call void @free(ptr noundef nonnull %408) #6
  %indvars.iv.next378 = add nuw nsw i64 %indvars.iv377, 1
  %exitcond381.not = icmp eq i64 %indvars.iv.next378, %wide.trip.count380
  br i1 %exitcond381.not, label %._crit_edge333, label %.lr.ph332, !llvm.loop !39

._crit_edge333:                                   ; preds = %412, %404
  %413 = load ptr, ptr %3, align 8, !tbaa !20
  %414 = icmp eq ptr %413, null
  br i1 %414, label %415, label %417

415:                                              ; preds = %._crit_edge333
  %416 = call i32 @SMerror(i32 noundef 144, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.2, i32 noundef 60, i32 noundef 0, ptr noundef null) #6
  br label %.loopexit

417:                                              ; preds = %._crit_edge333
  call void @free(ptr noundef nonnull %413) #6
  br label %418

418:                                              ; preds = %417, %266, %.loopexit312
  switch i32 %24, label %.preheader310 [
    i32 2, label %.thread304
    i32 3, label %.thread
  ]

.preheader310:                                    ; preds = %418
  %419 = icmp sgt i32 %24, 0
  br i1 %419, label %.lr.ph336, label %._crit_edge337.thread

.lr.ph336:                                        ; preds = %.preheader310
  %420 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count385 = zext nneg i32 %24 to i64
  %xtraiter496 = and i64 %wide.trip.count385, 3
  %421 = icmp ult i32 %24, 4
  br i1 %421, label %._crit_edge337.unr-lcssa, label %.lr.ph336.new

.lr.ph336.new:                                    ; preds = %.lr.ph336
  %unroll_iter = and i64 %wide.trip.count385, 2147483644
  br label %422

422:                                              ; preds = %422, %.lr.ph336.new
  %indvars.iv382 = phi i64 [ 0, %.lr.ph336.new ], [ %indvars.iv.next383.3, %422 ]
  %.0254334 = phi double [ undef, %.lr.ph336.new ], [ %434, %422 ]
  %niter = phi i64 [ 0, %.lr.ph336.new ], [ %niter.next.3, %422 ]
  %423 = getelementptr inbounds [3 x double], ptr %420, i64 0, i64 %indvars.iv382
  %424 = load double, ptr %423, align 8, !tbaa !21
  %425 = call double @llvm.fmuladd.f64(double %424, double %424, double %.0254334)
  %indvars.iv.next383 = or disjoint i64 %indvars.iv382, 1
  %426 = getelementptr inbounds [3 x double], ptr %420, i64 0, i64 %indvars.iv.next383
  %427 = load double, ptr %426, align 8, !tbaa !21
  %428 = call double @llvm.fmuladd.f64(double %427, double %427, double %425)
  %indvars.iv.next383.1 = or disjoint i64 %indvars.iv382, 2
  %429 = getelementptr inbounds [3 x double], ptr %420, i64 0, i64 %indvars.iv.next383.1
  %430 = load double, ptr %429, align 8, !tbaa !21
  %431 = call double @llvm.fmuladd.f64(double %430, double %430, double %428)
  %indvars.iv.next383.2 = or disjoint i64 %indvars.iv382, 3
  %432 = getelementptr inbounds [3 x double], ptr %420, i64 0, i64 %indvars.iv.next383.2
  %433 = load double, ptr %432, align 8, !tbaa !21
  %434 = call double @llvm.fmuladd.f64(double %433, double %433, double %431)
  %indvars.iv.next383.3 = add nuw nsw i64 %indvars.iv382, 4
  %niter.next.3 = add i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %._crit_edge337.unr-lcssa, label %422, !llvm.loop !40

._crit_edge337.unr-lcssa:                         ; preds = %422, %.lr.ph336
  %.lcssa484.ph = phi double [ poison, %.lr.ph336 ], [ %434, %422 ]
  %indvars.iv382.unr = phi i64 [ 0, %.lr.ph336 ], [ %indvars.iv.next383.3, %422 ]
  %.0254334.unr = phi double [ undef, %.lr.ph336 ], [ %434, %422 ]
  %lcmp.mod497.not = icmp eq i64 %xtraiter496, 0
  br i1 %lcmp.mod497.not, label %._crit_edge337, label %.epil.preheader

.epil.preheader:                                  ; preds = %._crit_edge337.unr-lcssa, %.epil.preheader
  %indvars.iv382.epil = phi i64 [ %indvars.iv.next383.epil, %.epil.preheader ], [ %indvars.iv382.unr, %._crit_edge337.unr-lcssa ]
  %.0254334.epil = phi double [ %437, %.epil.preheader ], [ %.0254334.unr, %._crit_edge337.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.epil.preheader ], [ 0, %._crit_edge337.unr-lcssa ]
  %435 = getelementptr inbounds [3 x double], ptr %420, i64 0, i64 %indvars.iv382.epil
  %436 = load double, ptr %435, align 8, !tbaa !21
  %437 = call double @llvm.fmuladd.f64(double %436, double %436, double %.0254334.epil)
  %indvars.iv.next383.epil = add nuw nsw i64 %indvars.iv382.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter496
  br i1 %epil.iter.cmp.not, label %._crit_edge337, label %.epil.preheader, !llvm.loop !41

._crit_edge337:                                   ; preds = %.epil.preheader, %._crit_edge337.unr-lcssa
  %.lcssa484 = phi double [ %.lcssa484.ph, %._crit_edge337.unr-lcssa ], [ %437, %.epil.preheader ]
  %438 = call double @llvm.fabs.f64(double %.lcssa484)
  %439 = fcmp olt double %438, 1.000000e-13
  br i1 %439, label %461, label %.preheader309

._crit_edge337.thread:                            ; preds = %.preheader310
  %440 = call double @llvm.fabs.f64(double undef)
  %441 = fcmp olt double %440, 1.000000e-13
  br i1 %441, label %461, label %.loopexit

.thread304:                                       ; preds = %418
  %442 = getelementptr inbounds i8, ptr %11, i64 112
  %443 = load double, ptr %442, align 8, !tbaa !21
  %444 = getelementptr inbounds i8, ptr %11, i64 120
  %445 = load double, ptr %444, align 8, !tbaa !21
  %446 = fmul double %445, %445
  %447 = call double @llvm.fmuladd.f64(double %443, double %443, double %446)
  %448 = call double @llvm.fabs.f64(double %447)
  %449 = fcmp olt double %448, 1.000000e-13
  br i1 %449, label %461, label %.thread306

.thread:                                          ; preds = %418
  %450 = getelementptr inbounds i8, ptr %11, i64 112
  %451 = load <2 x double>, ptr %450, align 8, !tbaa !21
  %452 = fmul <2 x double> %451, %451
  %453 = extractelement <2 x double> %452, i64 1
  %454 = extractelement <2 x double> %451, i64 0
  %455 = call double @llvm.fmuladd.f64(double %454, double %454, double %453)
  %456 = getelementptr inbounds i8, ptr %11, i64 128
  %457 = load double, ptr %456, align 8, !tbaa !21
  %458 = call double @llvm.fmuladd.f64(double %457, double %457, double %455)
  %459 = call double @llvm.fabs.f64(double %458)
  %460 = fcmp olt double %459, 1.000000e-13
  br i1 %460, label %461, label %.thread307

461:                                              ; preds = %._crit_edge337.thread, %.thread304, %.thread, %._crit_edge337
  %462 = getelementptr inbounds i8, ptr %11, i64 16
  store i32 105, ptr %462, align 8, !tbaa !42
  br label %.loopexit

.preheader309:                                    ; preds = %._crit_edge337
  br i1 %419, label %.lr.ph340, label %.loopexit

.lr.ph340:                                        ; preds = %.preheader309
  %463 = getelementptr inbounds i8, ptr %11, i64 112
  %xtraiter500 = and i64 %wide.trip.count385, 3
  %464 = icmp ult i32 %24, 4
  br i1 %464, label %._crit_edge341.unr-lcssa, label %.lr.ph340.new

.lr.ph340.new:                                    ; preds = %.lr.ph340
  %unroll_iter504 = and i64 %wide.trip.count385, 2147483644
  br label %478

.thread306:                                       ; preds = %.thread304
  %sqrt = call double @llvm.sqrt.f64(double %447)
  %465 = fcmp une double %sqrt, 0.000000e+00
  br i1 %465, label %466, label %.loopexit

466:                                              ; preds = %.thread306
  %467 = getelementptr inbounds i8, ptr %11, i64 112
  %468 = load <2 x double>, ptr %467, align 8, !tbaa !21
  %469 = insertelement <2 x double> poison, double %sqrt, i64 0
  %470 = shufflevector <2 x double> %469, <2 x double> poison, <2 x i32> zeroinitializer
  %471 = fdiv <2 x double> %468, %470
  store <2 x double> %471, ptr %467, align 8, !tbaa !21
  br label %.loopexit

.thread307:                                       ; preds = %.thread
  %sqrt308 = call double @llvm.sqrt.f64(double %458)
  %472 = fcmp une double %sqrt308, 0.000000e+00
  br i1 %472, label %473, label %.loopexit

473:                                              ; preds = %.thread307
  %474 = insertelement <2 x double> poison, double %sqrt308, i64 0
  %475 = shufflevector <2 x double> %474, <2 x double> poison, <2 x i32> zeroinitializer
  %476 = fdiv <2 x double> %451, %475
  store <2 x double> %476, ptr %450, align 8, !tbaa !21
  %477 = fdiv double %457, %sqrt308
  store double %477, ptr %456, align 8, !tbaa !21
  br label %.loopexit

478:                                              ; preds = %478, %.lr.ph340.new
  %indvars.iv387 = phi i64 [ 0, %.lr.ph340.new ], [ %indvars.iv.next388.3, %478 ]
  %.0339 = phi double [ undef, %.lr.ph340.new ], [ %494, %478 ]
  %niter505 = phi i64 [ 0, %.lr.ph340.new ], [ %niter505.next.3, %478 ]
  %479 = getelementptr inbounds [3 x double], ptr %463, i64 0, i64 %indvars.iv387
  %480 = load double, ptr %479, align 8, !tbaa !21
  %481 = fadd double %480, %480
  %482 = fadd double %.0339, %481
  %indvars.iv.next388 = or disjoint i64 %indvars.iv387, 1
  %483 = getelementptr inbounds [3 x double], ptr %463, i64 0, i64 %indvars.iv.next388
  %484 = load double, ptr %483, align 8, !tbaa !21
  %485 = fadd double %484, %484
  %486 = fadd double %482, %485
  %indvars.iv.next388.1 = or disjoint i64 %indvars.iv387, 2
  %487 = getelementptr inbounds [3 x double], ptr %463, i64 0, i64 %indvars.iv.next388.1
  %488 = load double, ptr %487, align 8, !tbaa !21
  %489 = fadd double %488, %488
  %490 = fadd double %486, %489
  %indvars.iv.next388.2 = or disjoint i64 %indvars.iv387, 3
  %491 = getelementptr inbounds [3 x double], ptr %463, i64 0, i64 %indvars.iv.next388.2
  %492 = load double, ptr %491, align 8, !tbaa !21
  %493 = fadd double %492, %492
  %494 = fadd double %490, %493
  %indvars.iv.next388.3 = add nuw nsw i64 %indvars.iv387, 4
  %niter505.next.3 = add i64 %niter505, 4
  %niter505.ncmp.3 = icmp eq i64 %niter505.next.3, %unroll_iter504
  br i1 %niter505.ncmp.3, label %._crit_edge341.unr-lcssa, label %478, !llvm.loop !43

._crit_edge341.unr-lcssa:                         ; preds = %478, %.lr.ph340
  %.lcssa.ph = phi double [ poison, %.lr.ph340 ], [ %494, %478 ]
  %indvars.iv387.unr = phi i64 [ 0, %.lr.ph340 ], [ %indvars.iv.next388.3, %478 ]
  %.0339.unr = phi double [ undef, %.lr.ph340 ], [ %494, %478 ]
  %lcmp.mod502.not = icmp eq i64 %xtraiter500, 0
  br i1 %lcmp.mod502.not, label %._crit_edge341, label %.epil.preheader499

.epil.preheader499:                               ; preds = %._crit_edge341.unr-lcssa, %.epil.preheader499
  %indvars.iv387.epil = phi i64 [ %indvars.iv.next388.epil, %.epil.preheader499 ], [ %indvars.iv387.unr, %._crit_edge341.unr-lcssa ]
  %.0339.epil = phi double [ %498, %.epil.preheader499 ], [ %.0339.unr, %._crit_edge341.unr-lcssa ]
  %epil.iter501 = phi i64 [ %epil.iter501.next, %.epil.preheader499 ], [ 0, %._crit_edge341.unr-lcssa ]
  %495 = getelementptr inbounds [3 x double], ptr %463, i64 0, i64 %indvars.iv387.epil
  %496 = load double, ptr %495, align 8, !tbaa !21
  %497 = fadd double %496, %496
  %498 = fadd double %.0339.epil, %497
  %indvars.iv.next388.epil = add nuw nsw i64 %indvars.iv387.epil, 1
  %epil.iter501.next = add i64 %epil.iter501, 1
  %epil.iter501.cmp.not = icmp eq i64 %epil.iter501.next, %xtraiter500
  br i1 %epil.iter501.cmp.not, label %._crit_edge341, label %.epil.preheader499, !llvm.loop !44

._crit_edge341:                                   ; preds = %.epil.preheader499, %._crit_edge341.unr-lcssa
  %.lcssa = phi double [ %.lcssa.ph, %._crit_edge341.unr-lcssa ], [ %498, %.epil.preheader499 ]
  %499 = fcmp une double %.lcssa, 0.000000e+00
  %or.cond345 = and i1 %499, %419
  br i1 %or.cond345, label %.lr.ph344, label %.loopexit

.lr.ph344:                                        ; preds = %._crit_edge341
  %500 = getelementptr inbounds i8, ptr %11, i64 112
  %wide.trip.count395 = zext nneg i32 %24 to i64
  %min.iters.check472 = icmp eq i32 %24, 1
  br i1 %min.iters.check472, label %scalar.ph471.preheader, label %vector.ph473

vector.ph473:                                     ; preds = %.lr.ph344
  %n.vec475 = and i64 %wide.trip.count385, 2147483646
  %broadcast.splatinsert480 = insertelement <2 x double> poison, double %.lcssa, i64 0
  %broadcast.splat481 = shufflevector <2 x double> %broadcast.splatinsert480, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body477

vector.body477:                                   ; preds = %vector.body477, %vector.ph473
  %index478 = phi i64 [ 0, %vector.ph473 ], [ %index.next482, %vector.body477 ]
  %501 = getelementptr inbounds [3 x double], ptr %500, i64 0, i64 %index478
  %wide.load479 = load <2 x double>, ptr %501, align 8, !tbaa !21
  %502 = fdiv <2 x double> %wide.load479, %broadcast.splat481
  store <2 x double> %502, ptr %501, align 8, !tbaa !21
  %index.next482 = add nuw i64 %index478, 2
  %503 = icmp eq i64 %index.next482, %n.vec475
  br i1 %503, label %middle.block470, label %vector.body477, !llvm.loop !45

middle.block470:                                  ; preds = %vector.body477
  %cmp.n483 = icmp eq i64 %n.vec475, %wide.trip.count385
  br i1 %cmp.n483, label %.loopexit, label %scalar.ph471.preheader

scalar.ph471.preheader:                           ; preds = %middle.block470, %.lr.ph344
  %indvars.iv392.ph = phi i64 [ 0, %.lr.ph344 ], [ %n.vec475, %middle.block470 ]
  br label %scalar.ph471

scalar.ph471:                                     ; preds = %scalar.ph471.preheader, %scalar.ph471
  %indvars.iv392 = phi i64 [ %indvars.iv.next393, %scalar.ph471 ], [ %indvars.iv392.ph, %scalar.ph471.preheader ]
  %504 = getelementptr inbounds [3 x double], ptr %500, i64 0, i64 %indvars.iv392
  %505 = load double, ptr %504, align 8, !tbaa !21
  %506 = fdiv double %505, %.lcssa
  store double %506, ptr %504, align 8, !tbaa !21
  %indvars.iv.next393 = add nuw nsw i64 %indvars.iv392, 1
  %exitcond396.not = icmp eq i64 %indvars.iv.next393, %wide.trip.count395
  br i1 %exitcond396.not, label %.loopexit, label %scalar.ph471, !llvm.loop !46

.loopexit:                                        ; preds = %scalar.ph471, %middle.block470, %._crit_edge337.thread, %.preheader309, %461, %473, %.thread307, %._crit_edge341, %.thread306, %466, %415, %410, %402, %397, %392, %386, %381, %371, %323, %299, %293, %287, %280, %276, %269, %264, %256, %92, %88, %81, %21, %7
  %.0253 = phi i32 [ %8, %7 ], [ %22, %21 ], [ %270, %269 ], [ %277, %276 ], [ %281, %280 ], [ %411, %410 ], [ %416, %415 ], [ %294, %293 ], [ %398, %397 ], [ %300, %299 ], [ %324, %323 ], [ %372, %371 ], [ %382, %381 ], [ %387, %386 ], [ %393, %392 ], [ %403, %402 ], [ %288, %287 ], [ %82, %81 ], [ %89, %88 ], [ %93, %92 ], [ %257, %256 ], [ %265, %264 ], [ 0, %466 ], [ 0, %.thread306 ], [ 0, %._crit_edge341 ], [ 0, %.thread307 ], [ 0, %473 ], [ 0, %461 ], [ 0, %.preheader309 ], [ 0, %._crit_edge337.thread ], [ 0, %middle.block470 ], [ 0, %scalar.ph471 ]
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %5) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %3) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %2) #6
  ret i32 %.0253
}

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

declare i32 @SMerror(i32 noundef, ptr noundef, ptr noundef, ptr noundef, i32 noundef, i32 noundef, ptr noundef) local_unnamed_addr #2

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @SMgetActiveDirections(i32 noundef, ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #0

declare i32 @SMformGrammian(i32 noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #2

declare i32 @SMformPDGrammian(ptr noundef) local_unnamed_addr #2

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

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

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare dso_local i32 @SMsearchEdgesFaces(i32 noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

declare i32 @SMsingularTest(i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @SMformReducedMatrix(i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare i32 @SMsolve2x2(double noundef, double noundef, double noundef, double noundef, double noundef, double noundef, ptr noundef) local_unnamed_addr #2

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !10, i64 160}
!6 = !{!"__SMlocal_mesh", !7, i64 0, !7, i64 4, !7, i64 8, !8, i64 16, !8, i64 40, !8, i64 64, !10, i64 88, !10, i64 96, !10, i64 104, !7, i64 112, !11, i64 120, !10, i64 128, !11, i64 136, !7, i64 144, !7, i64 148, !7, i64 152, !10, i64 160, !10, i64 168, !10, i64 176}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!"double", !8, i64 0}
!12 = !{!13, !10, i64 56}
!13 = !{!"__SMoptimal", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !7, i64 16, !7, i64 20, !7, i64 24, !11, i64 32, !7, i64 40, !7, i64 44, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !7, i64 104, !8, i64 112, !11, i64 136, !11, i64 144, !10, i64 152, !10, i64 160, !10, i64 168, !10, i64 176, !8, i64 184, !7, i64 196}
!14 = !{!13, !10, i64 80}
!15 = !{!16, !7, i64 0}
!16 = !{!"__SMactive", !7, i64 0, !7, i64 4, !10, i64 8, !11, i64 16}
!17 = !{!16, !10, i64 8}
!18 = !{!6, !7, i64 0}
!19 = !{!7, !7, i64 0}
!20 = !{!10, !10, i64 0}
!21 = !{!11, !11, i64 0}
!22 = distinct !{!22, !23}
!23 = !{!"llvm.loop.unroll.disable"}
!24 = distinct !{!24, !25, !26, !27}
!25 = !{!"llvm.loop.mustprogress"}
!26 = !{!"llvm.loop.isvectorized", i32 1}
!27 = !{!"llvm.loop.unroll.runtime.disable"}
!28 = distinct !{!28, !25, !26}
!29 = !{!13, !7, i64 104}
!30 = !{!13, !10, i64 168}
!31 = distinct !{!31, !25, !26, !27}
!32 = distinct !{!32, !25, !26}
!33 = distinct !{!33, !23}
!34 = distinct !{!34, !25, !26, !27}
!35 = distinct !{!35, !25, !26}
!36 = distinct !{!36, !23}
!37 = distinct !{!37, !25, !26, !27}
!38 = distinct !{!38, !25, !26}
!39 = distinct !{!39, !25}
!40 = distinct !{!40, !25}
!41 = distinct !{!41, !23}
!42 = !{!13, !7, i64 16}
!43 = distinct !{!43, !25}
!44 = distinct !{!44, !23}
!45 = distinct !{!45, !25, !26, !27}
!46 = distinct !{!46, !25, !27, !26}


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