; LLVM IR from niuyishuai/PDCABB :: LAPACK_BLAS/LAPACK (zgttrf)

; 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.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @zgttrf_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6) #0 {
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca i64, align 8
  %17 = alloca i64, align 8
  %18 = alloca i64, align 8
  %19 = alloca i64, align 8
  %20 = alloca double, align 8
  %21 = alloca double, align 8
  %22 = alloca double, align 8
  %23 = alloca double, align 8
  %24 = alloca %struct.doublecomplex, align 8
  %25 = alloca %struct.doublecomplex, align 8
  %26 = alloca i64, align 8
  %27 = alloca %struct.doublecomplex, align 8
  %28 = alloca %struct.doublecomplex, align 8
  %29 = alloca i32, align 4
  store ptr %0, ptr %9, align 8, !tbaa !5
  store ptr %1, ptr %10, align 8, !tbaa !5
  store ptr %2, ptr %11, align 8, !tbaa !5
  store ptr %3, ptr %12, align 8, !tbaa !5
  store ptr %4, ptr %13, align 8, !tbaa !5
  store ptr %5, ptr %14, align 8, !tbaa !5
  store ptr %6, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr %24) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr %27) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #4
  %30 = load ptr, ptr %14, align 8, !tbaa !5
  %31 = getelementptr inbounds i64, ptr %30, i32 -1
  store ptr %31, ptr %14, align 8, !tbaa !5
  %32 = load ptr, ptr %13, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 -1
  store ptr %33, ptr %13, align 8, !tbaa !5
  %34 = load ptr, ptr %12, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 -1
  store ptr %35, ptr %12, align 8, !tbaa !5
  %36 = load ptr, ptr %11, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 -1
  store ptr %37, ptr %11, align 8, !tbaa !5
  %38 = load ptr, ptr %10, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 -1
  store ptr %39, ptr %10, align 8, !tbaa !5
  %40 = load ptr, ptr %15, align 8, !tbaa !5
  store i64 0, ptr %40, align 8, !tbaa !9
  %41 = load ptr, ptr %9, align 8, !tbaa !5
  %42 = load i64, ptr %41, align 8, !tbaa !9
  %43 = icmp slt i64 %42, 0
  br i1 %43, label %44, label %50

44:                                               ; preds = %7
  %45 = load ptr, ptr %15, align 8, !tbaa !5
  store i64 -1, ptr %45, align 8, !tbaa !9
  %46 = load ptr, ptr %15, align 8, !tbaa !5
  %47 = load i64, ptr %46, align 8, !tbaa !9
  %48 = sub nsw i64 0, %47
  store i64 %48, ptr %16, align 8, !tbaa !9
  %49 = call i32 @xerbla_(ptr noundef @.str, ptr noundef %16)
  store i32 0, ptr %8, align 4
  store i32 1, ptr %29, align 4
  br label %910

50:                                               ; preds = %7
  %51 = load ptr, ptr %9, align 8, !tbaa !5
  %52 = load i64, ptr %51, align 8, !tbaa !9
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %54, label %55

54:                                               ; preds = %50
  store i32 0, ptr %8, align 4
  store i32 1, ptr %29, align 4
  br label %910

55:                                               ; preds = %50
  %56 = load ptr, ptr %9, align 8, !tbaa !5
  %57 = load i64, ptr %56, align 8, !tbaa !9
  store i64 %57, ptr %16, align 8, !tbaa !9
  store i64 1, ptr %26, align 8, !tbaa !9
  br label %58

58:                                               ; preds = %67, %55
  %59 = load i64, ptr %26, align 8, !tbaa !9
  %60 = load i64, ptr %16, align 8, !tbaa !9
  %61 = icmp sle i64 %59, %60
  br i1 %61, label %62, label %70

62:                                               ; preds = %58
  %63 = load i64, ptr %26, align 8, !tbaa !9
  %64 = load ptr, ptr %14, align 8, !tbaa !5
  %65 = load i64, ptr %26, align 8, !tbaa !9
  %66 = getelementptr inbounds i64, ptr %64, i64 %65
  store i64 %63, ptr %66, align 8, !tbaa !9
  br label %67

67:                                               ; preds = %62
  %68 = load i64, ptr %26, align 8, !tbaa !9
  %69 = add nsw i64 %68, 1
  store i64 %69, ptr %26, align 8, !tbaa !9
  br label %58, !llvm.loop !11

70:                                               ; preds = %58
  %71 = load ptr, ptr %9, align 8, !tbaa !5
  %72 = load i64, ptr %71, align 8, !tbaa !9
  %73 = sub nsw i64 %72, 2
  store i64 %73, ptr %16, align 8, !tbaa !9
  store i64 1, ptr %26, align 8, !tbaa !9
  br label %74

74:                                               ; preds = %88, %70
  %75 = load i64, ptr %26, align 8, !tbaa !9
  %76 = load i64, ptr %16, align 8, !tbaa !9
  %77 = icmp sle i64 %75, %76
  br i1 %77, label %78, label %91

78:                                               ; preds = %74
  %79 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %79, ptr %17, align 8, !tbaa !9
  %80 = load ptr, ptr %13, align 8, !tbaa !5
  %81 = load i64, ptr %17, align 8, !tbaa !9
  %82 = getelementptr inbounds %struct.doublecomplex, ptr %80, i64 %81
  %83 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double 0.000000e+00, ptr %83, align 8, !tbaa !13
  %84 = load ptr, ptr %13, align 8, !tbaa !5
  %85 = load i64, ptr %17, align 8, !tbaa !9
  %86 = getelementptr inbounds %struct.doublecomplex, ptr %84, i64 %85
  %87 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double 0.000000e+00, ptr %87, align 8, !tbaa !16
  br label %88

88:                                               ; preds = %78
  %89 = load i64, ptr %26, align 8, !tbaa !9
  %90 = add nsw i64 %89, 1
  store i64 %90, ptr %26, align 8, !tbaa !9
  br label %74, !llvm.loop !17

91:                                               ; preds = %74
  %92 = load ptr, ptr %9, align 8, !tbaa !5
  %93 = load i64, ptr %92, align 8, !tbaa !9
  %94 = sub nsw i64 %93, 2
  store i64 %94, ptr %16, align 8, !tbaa !9
  store i64 1, ptr %26, align 8, !tbaa !9
  br label %95

95:                                               ; preds = %516, %91
  %96 = load i64, ptr %26, align 8, !tbaa !9
  %97 = load i64, ptr %16, align 8, !tbaa !9
  %98 = icmp sle i64 %96, %97
  br i1 %98, label %99, label %519

99:                                               ; preds = %95
  %100 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %100, ptr %17, align 8, !tbaa !9
  %101 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %101, ptr %18, align 8, !tbaa !9
  %102 = load ptr, ptr %11, align 8, !tbaa !5
  %103 = load i64, ptr %17, align 8, !tbaa !9
  %104 = getelementptr inbounds %struct.doublecomplex, ptr %102, i64 %103
  %105 = getelementptr inbounds %struct.doublecomplex, ptr %104, i32 0, i32 0
  %106 = load double, ptr %105, align 8, !tbaa !13
  store double %106, ptr %20, align 8, !tbaa !18
  %107 = load double, ptr %20, align 8, !tbaa !18
  %108 = fcmp oge double %107, 0.000000e+00
  br i1 %108, label %109, label %111

109:                                              ; preds = %99
  %110 = load double, ptr %20, align 8, !tbaa !18
  br label %114

111:                                              ; preds = %99
  %112 = load double, ptr %20, align 8, !tbaa !18
  %113 = fneg double %112
  br label %114

114:                                              ; preds = %111, %109
  %115 = phi double [ %110, %109 ], [ %113, %111 ]
  %116 = load ptr, ptr %11, align 8, !tbaa !5
  %117 = load i64, ptr %26, align 8, !tbaa !9
  %118 = getelementptr inbounds %struct.doublecomplex, ptr %116, i64 %117
  %119 = call double @d_imag(ptr noundef %118)
  store double %119, ptr %21, align 8, !tbaa !18
  %120 = load double, ptr %21, align 8, !tbaa !18
  %121 = fcmp oge double %120, 0.000000e+00
  br i1 %121, label %122, label %124

122:                                              ; preds = %114
  %123 = load double, ptr %21, align 8, !tbaa !18
  br label %127

124:                                              ; preds = %114
  %125 = load double, ptr %21, align 8, !tbaa !18
  %126 = fneg double %125
  br label %127

127:                                              ; preds = %124, %122
  %128 = phi double [ %123, %122 ], [ %126, %124 ]
  %129 = fadd double %115, %128
  %130 = load ptr, ptr %10, align 8, !tbaa !5
  %131 = load i64, ptr %18, align 8, !tbaa !9
  %132 = getelementptr inbounds %struct.doublecomplex, ptr %130, i64 %131
  %133 = getelementptr inbounds %struct.doublecomplex, ptr %132, i32 0, i32 0
  %134 = load double, ptr %133, align 8, !tbaa !13
  store double %134, ptr %22, align 8, !tbaa !18
  %135 = load double, ptr %22, align 8, !tbaa !18
  %136 = fcmp oge double %135, 0.000000e+00
  br i1 %136, label %137, label %139

137:                                              ; preds = %127
  %138 = load double, ptr %22, align 8, !tbaa !18
  br label %142

139:                                              ; preds = %127
  %140 = load double, ptr %22, align 8, !tbaa !18
  %141 = fneg double %140
  br label %142

142:                                              ; preds = %139, %137
  %143 = phi double [ %138, %137 ], [ %141, %139 ]
  %144 = load ptr, ptr %10, align 8, !tbaa !5
  %145 = load i64, ptr %26, align 8, !tbaa !9
  %146 = getelementptr inbounds %struct.doublecomplex, ptr %144, i64 %145
  %147 = call double @d_imag(ptr noundef %146)
  store double %147, ptr %23, align 8, !tbaa !18
  %148 = load double, ptr %23, align 8, !tbaa !18
  %149 = fcmp oge double %148, 0.000000e+00
  br i1 %149, label %150, label %152

150:                                              ; preds = %142
  %151 = load double, ptr %23, align 8, !tbaa !18
  br label %155

152:                                              ; preds = %142
  %153 = load double, ptr %23, align 8, !tbaa !18
  %154 = fneg double %153
  br label %155

155:                                              ; preds = %152, %150
  %156 = phi double [ %151, %150 ], [ %154, %152 ]
  %157 = fadd double %143, %156
  %158 = fcmp oge double %129, %157
  br i1 %158, label %159, label %287

159:                                              ; preds = %155
  %160 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %160, ptr %17, align 8, !tbaa !9
  %161 = load ptr, ptr %11, align 8, !tbaa !5
  %162 = load i64, ptr %17, align 8, !tbaa !9
  %163 = getelementptr inbounds %struct.doublecomplex, ptr %161, i64 %162
  %164 = getelementptr inbounds %struct.doublecomplex, ptr %163, i32 0, i32 0
  %165 = load double, ptr %164, align 8, !tbaa !13
  store double %165, ptr %20, align 8, !tbaa !18
  %166 = load double, ptr %20, align 8, !tbaa !18
  %167 = fcmp oge double %166, 0.000000e+00
  br i1 %167, label %168, label %170

168:                                              ; preds = %159
  %169 = load double, ptr %20, align 8, !tbaa !18
  br label %173

170:                                              ; preds = %159
  %171 = load double, ptr %20, align 8, !tbaa !18
  %172 = fneg double %171
  br label %173

173:                                              ; preds = %170, %168
  %174 = phi double [ %169, %168 ], [ %172, %170 ]
  %175 = load ptr, ptr %11, align 8, !tbaa !5
  %176 = load i64, ptr %26, align 8, !tbaa !9
  %177 = getelementptr inbounds %struct.doublecomplex, ptr %175, i64 %176
  %178 = call double @d_imag(ptr noundef %177)
  store double %178, ptr %21, align 8, !tbaa !18
  %179 = load double, ptr %21, align 8, !tbaa !18
  %180 = fcmp oge double %179, 0.000000e+00
  br i1 %180, label %181, label %183

181:                                              ; preds = %173
  %182 = load double, ptr %21, align 8, !tbaa !18
  br label %186

183:                                              ; preds = %173
  %184 = load double, ptr %21, align 8, !tbaa !18
  %185 = fneg double %184
  br label %186

186:                                              ; preds = %183, %181
  %187 = phi double [ %182, %181 ], [ %185, %183 ]
  %188 = fadd double %174, %187
  %189 = fcmp une double %188, 0.000000e+00
  br i1 %189, label %190, label %286

190:                                              ; preds = %186
  %191 = load ptr, ptr %10, align 8, !tbaa !5
  %192 = load i64, ptr %26, align 8, !tbaa !9
  %193 = getelementptr inbounds %struct.doublecomplex, ptr %191, i64 %192
  %194 = load ptr, ptr %11, align 8, !tbaa !5
  %195 = load i64, ptr %26, align 8, !tbaa !9
  %196 = getelementptr inbounds %struct.doublecomplex, ptr %194, i64 %195
  call void @z_div(ptr noundef %24, ptr noundef %193, ptr noundef %196)
  %197 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %198 = load double, ptr %197, align 8, !tbaa !13
  %199 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %198, ptr %199, align 8, !tbaa !13
  %200 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %201 = load double, ptr %200, align 8, !tbaa !16
  %202 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %201, ptr %202, align 8, !tbaa !16
  %203 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %203, ptr %17, align 8, !tbaa !9
  %204 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %205 = load double, ptr %204, align 8, !tbaa !13
  %206 = load ptr, ptr %10, align 8, !tbaa !5
  %207 = load i64, ptr %17, align 8, !tbaa !9
  %208 = getelementptr inbounds %struct.doublecomplex, ptr %206, i64 %207
  %209 = getelementptr inbounds %struct.doublecomplex, ptr %208, i32 0, i32 0
  store double %205, ptr %209, align 8, !tbaa !13
  %210 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %211 = load double, ptr %210, align 8, !tbaa !16
  %212 = load ptr, ptr %10, align 8, !tbaa !5
  %213 = load i64, ptr %17, align 8, !tbaa !9
  %214 = getelementptr inbounds %struct.doublecomplex, ptr %212, i64 %213
  %215 = getelementptr inbounds %struct.doublecomplex, ptr %214, i32 0, i32 1
  store double %211, ptr %215, align 8, !tbaa !16
  %216 = load i64, ptr %26, align 8, !tbaa !9
  %217 = add nsw i64 %216, 1
  store i64 %217, ptr %17, align 8, !tbaa !9
  %218 = load i64, ptr %26, align 8, !tbaa !9
  %219 = add nsw i64 %218, 1
  store i64 %219, ptr %18, align 8, !tbaa !9
  %220 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %220, ptr %19, align 8, !tbaa !9
  %221 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %222 = load double, ptr %221, align 8, !tbaa !13
  %223 = load ptr, ptr %12, align 8, !tbaa !5
  %224 = load i64, ptr %19, align 8, !tbaa !9
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %223, i64 %224
  %226 = getelementptr inbounds %struct.doublecomplex, ptr %225, i32 0, i32 0
  %227 = load double, ptr %226, align 8, !tbaa !13
  %228 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %229 = load double, ptr %228, align 8, !tbaa !16
  %230 = load ptr, ptr %12, align 8, !tbaa !5
  %231 = load i64, ptr %19, align 8, !tbaa !9
  %232 = getelementptr inbounds %struct.doublecomplex, ptr %230, i64 %231
  %233 = getelementptr inbounds %struct.doublecomplex, ptr %232, i32 0, i32 1
  %234 = load double, ptr %233, align 8, !tbaa !16
  %235 = fmul double %229, %234
  %236 = fneg double %235
  %237 = call double @llvm.fmuladd.f64(double %222, double %227, double %236)
  %238 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %237, ptr %238, align 8, !tbaa !13
  %239 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %240 = load double, ptr %239, align 8, !tbaa !13
  %241 = load ptr, ptr %12, align 8, !tbaa !5
  %242 = load i64, ptr %19, align 8, !tbaa !9
  %243 = getelementptr inbounds %struct.doublecomplex, ptr %241, i64 %242
  %244 = getelementptr inbounds %struct.doublecomplex, ptr %243, i32 0, i32 1
  %245 = load double, ptr %244, align 8, !tbaa !16
  %246 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %247 = load double, ptr %246, align 8, !tbaa !16
  %248 = load ptr, ptr %12, align 8, !tbaa !5
  %249 = load i64, ptr %19, align 8, !tbaa !9
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %248, i64 %249
  %251 = getelementptr inbounds %struct.doublecomplex, ptr %250, i32 0, i32 0
  %252 = load double, ptr %251, align 8, !tbaa !13
  %253 = fmul double %247, %252
  %254 = call double @llvm.fmuladd.f64(double %240, double %245, double %253)
  %255 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %254, ptr %255, align 8, !tbaa !16
  %256 = load ptr, ptr %11, align 8, !tbaa !5
  %257 = load i64, ptr %18, align 8, !tbaa !9
  %258 = getelementptr inbounds %struct.doublecomplex, ptr %256, i64 %257
  %259 = getelementptr inbounds %struct.doublecomplex, ptr %258, i32 0, i32 0
  %260 = load double, ptr %259, align 8, !tbaa !13
  %261 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %262 = load double, ptr %261, align 8, !tbaa !13
  %263 = fsub double %260, %262
  %264 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %263, ptr %264, align 8, !tbaa !13
  %265 = load ptr, ptr %11, align 8, !tbaa !5
  %266 = load i64, ptr %18, align 8, !tbaa !9
  %267 = getelementptr inbounds %struct.doublecomplex, ptr %265, i64 %266
  %268 = getelementptr inbounds %struct.doublecomplex, ptr %267, i32 0, i32 1
  %269 = load double, ptr %268, align 8, !tbaa !16
  %270 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %271 = load double, ptr %270, align 8, !tbaa !16
  %272 = fsub double %269, %271
  %273 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %272, ptr %273, align 8, !tbaa !16
  %274 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %275 = load double, ptr %274, align 8, !tbaa !13
  %276 = load ptr, ptr %11, align 8, !tbaa !5
  %277 = load i64, ptr %17, align 8, !tbaa !9
  %278 = getelementptr inbounds %struct.doublecomplex, ptr %276, i64 %277
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %278, i32 0, i32 0
  store double %275, ptr %279, align 8, !tbaa !13
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %281 = load double, ptr %280, align 8, !tbaa !16
  %282 = load ptr, ptr %11, align 8, !tbaa !5
  %283 = load i64, ptr %17, align 8, !tbaa !9
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %282, i64 %283
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %284, i32 0, i32 1
  store double %281, ptr %285, align 8, !tbaa !16
  br label %286

286:                                              ; preds = %190, %186
  br label %515

287:                                              ; preds = %155
  %288 = load ptr, ptr %11, align 8, !tbaa !5
  %289 = load i64, ptr %26, align 8, !tbaa !9
  %290 = getelementptr inbounds %struct.doublecomplex, ptr %288, i64 %289
  %291 = load ptr, ptr %10, align 8, !tbaa !5
  %292 = load i64, ptr %26, align 8, !tbaa !9
  %293 = getelementptr inbounds %struct.doublecomplex, ptr %291, i64 %292
  call void @z_div(ptr noundef %24, ptr noundef %290, ptr noundef %293)
  %294 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %295 = load double, ptr %294, align 8, !tbaa !13
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %295, ptr %296, align 8, !tbaa !13
  %297 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %298 = load double, ptr %297, align 8, !tbaa !16
  %299 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %298, ptr %299, align 8, !tbaa !16
  %300 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %300, ptr %17, align 8, !tbaa !9
  %301 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %301, ptr %18, align 8, !tbaa !9
  %302 = load ptr, ptr %10, align 8, !tbaa !5
  %303 = load i64, ptr %18, align 8, !tbaa !9
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %302, i64 %303
  %305 = getelementptr inbounds %struct.doublecomplex, ptr %304, i32 0, i32 0
  %306 = load double, ptr %305, align 8, !tbaa !13
  %307 = load ptr, ptr %11, align 8, !tbaa !5
  %308 = load i64, ptr %17, align 8, !tbaa !9
  %309 = getelementptr inbounds %struct.doublecomplex, ptr %307, i64 %308
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %309, i32 0, i32 0
  store double %306, ptr %310, align 8, !tbaa !13
  %311 = load ptr, ptr %10, align 8, !tbaa !5
  %312 = load i64, ptr %18, align 8, !tbaa !9
  %313 = getelementptr inbounds %struct.doublecomplex, ptr %311, i64 %312
  %314 = getelementptr inbounds %struct.doublecomplex, ptr %313, i32 0, i32 1
  %315 = load double, ptr %314, align 8, !tbaa !16
  %316 = load ptr, ptr %11, align 8, !tbaa !5
  %317 = load i64, ptr %17, align 8, !tbaa !9
  %318 = getelementptr inbounds %struct.doublecomplex, ptr %316, i64 %317
  %319 = getelementptr inbounds %struct.doublecomplex, ptr %318, i32 0, i32 1
  store double %315, ptr %319, align 8, !tbaa !16
  %320 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %320, ptr %17, align 8, !tbaa !9
  %321 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %322 = load double, ptr %321, align 8, !tbaa !13
  %323 = load ptr, ptr %10, align 8, !tbaa !5
  %324 = load i64, ptr %17, align 8, !tbaa !9
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %323, i64 %324
  %326 = getelementptr inbounds %struct.doublecomplex, ptr %325, i32 0, i32 0
  store double %322, ptr %326, align 8, !tbaa !13
  %327 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %328 = load double, ptr %327, align 8, !tbaa !16
  %329 = load ptr, ptr %10, align 8, !tbaa !5
  %330 = load i64, ptr %17, align 8, !tbaa !9
  %331 = getelementptr inbounds %struct.doublecomplex, ptr %329, i64 %330
  %332 = getelementptr inbounds %struct.doublecomplex, ptr %331, i32 0, i32 1
  store double %328, ptr %332, align 8, !tbaa !16
  %333 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %333, ptr %17, align 8, !tbaa !9
  %334 = load ptr, ptr %12, align 8, !tbaa !5
  %335 = load i64, ptr %17, align 8, !tbaa !9
  %336 = getelementptr inbounds %struct.doublecomplex, ptr %334, i64 %335
  %337 = getelementptr inbounds %struct.doublecomplex, ptr %336, i32 0, i32 0
  %338 = load double, ptr %337, align 8, !tbaa !13
  %339 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %338, ptr %339, align 8, !tbaa !13
  %340 = load ptr, ptr %12, align 8, !tbaa !5
  %341 = load i64, ptr %17, align 8, !tbaa !9
  %342 = getelementptr inbounds %struct.doublecomplex, ptr %340, i64 %341
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %342, i32 0, i32 1
  %344 = load double, ptr %343, align 8, !tbaa !16
  %345 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %344, ptr %345, align 8, !tbaa !16
  %346 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %346, ptr %17, align 8, !tbaa !9
  %347 = load i64, ptr %26, align 8, !tbaa !9
  %348 = add nsw i64 %347, 1
  store i64 %348, ptr %18, align 8, !tbaa !9
  %349 = load ptr, ptr %11, align 8, !tbaa !5
  %350 = load i64, ptr %18, align 8, !tbaa !9
  %351 = getelementptr inbounds %struct.doublecomplex, ptr %349, i64 %350
  %352 = getelementptr inbounds %struct.doublecomplex, ptr %351, i32 0, i32 0
  %353 = load double, ptr %352, align 8, !tbaa !13
  %354 = load ptr, ptr %12, align 8, !tbaa !5
  %355 = load i64, ptr %17, align 8, !tbaa !9
  %356 = getelementptr inbounds %struct.doublecomplex, ptr %354, i64 %355
  %357 = getelementptr inbounds %struct.doublecomplex, ptr %356, i32 0, i32 0
  store double %353, ptr %357, align 8, !tbaa !13
  %358 = load ptr, ptr %11, align 8, !tbaa !5
  %359 = load i64, ptr %18, align 8, !tbaa !9
  %360 = getelementptr inbounds %struct.doublecomplex, ptr %358, i64 %359
  %361 = getelementptr inbounds %struct.doublecomplex, ptr %360, i32 0, i32 1
  %362 = load double, ptr %361, align 8, !tbaa !16
  %363 = load ptr, ptr %12, align 8, !tbaa !5
  %364 = load i64, ptr %17, align 8, !tbaa !9
  %365 = getelementptr inbounds %struct.doublecomplex, ptr %363, i64 %364
  %366 = getelementptr inbounds %struct.doublecomplex, ptr %365, i32 0, i32 1
  store double %362, ptr %366, align 8, !tbaa !16
  %367 = load i64, ptr %26, align 8, !tbaa !9
  %368 = add nsw i64 %367, 1
  store i64 %368, ptr %17, align 8, !tbaa !9
  %369 = load i64, ptr %26, align 8, !tbaa !9
  %370 = add nsw i64 %369, 1
  store i64 %370, ptr %18, align 8, !tbaa !9
  %371 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %372 = load double, ptr %371, align 8, !tbaa !13
  %373 = load ptr, ptr %11, align 8, !tbaa !5
  %374 = load i64, ptr %18, align 8, !tbaa !9
  %375 = getelementptr inbounds %struct.doublecomplex, ptr %373, i64 %374
  %376 = getelementptr inbounds %struct.doublecomplex, ptr %375, i32 0, i32 0
  %377 = load double, ptr %376, align 8, !tbaa !13
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %379 = load double, ptr %378, align 8, !tbaa !16
  %380 = load ptr, ptr %11, align 8, !tbaa !5
  %381 = load i64, ptr %18, align 8, !tbaa !9
  %382 = getelementptr inbounds %struct.doublecomplex, ptr %380, i64 %381
  %383 = getelementptr inbounds %struct.doublecomplex, ptr %382, i32 0, i32 1
  %384 = load double, ptr %383, align 8, !tbaa !16
  %385 = fmul double %379, %384
  %386 = fneg double %385
  %387 = call double @llvm.fmuladd.f64(double %372, double %377, double %386)
  %388 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %387, ptr %388, align 8, !tbaa !13
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %390 = load double, ptr %389, align 8, !tbaa !13
  %391 = load ptr, ptr %11, align 8, !tbaa !5
  %392 = load i64, ptr %18, align 8, !tbaa !9
  %393 = getelementptr inbounds %struct.doublecomplex, ptr %391, i64 %392
  %394 = getelementptr inbounds %struct.doublecomplex, ptr %393, i32 0, i32 1
  %395 = load double, ptr %394, align 8, !tbaa !16
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %397 = load double, ptr %396, align 8, !tbaa !16
  %398 = load ptr, ptr %11, align 8, !tbaa !5
  %399 = load i64, ptr %18, align 8, !tbaa !9
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %398, i64 %399
  %401 = getelementptr inbounds %struct.doublecomplex, ptr %400, i32 0, i32 0
  %402 = load double, ptr %401, align 8, !tbaa !13
  %403 = fmul double %397, %402
  %404 = call double @llvm.fmuladd.f64(double %390, double %395, double %403)
  %405 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %404, ptr %405, align 8, !tbaa !16
  %406 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %407 = load double, ptr %406, align 8, !tbaa !13
  %408 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %409 = load double, ptr %408, align 8, !tbaa !13
  %410 = fsub double %407, %409
  %411 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %410, ptr %411, align 8, !tbaa !13
  %412 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %413 = load double, ptr %412, align 8, !tbaa !16
  %414 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %415 = load double, ptr %414, align 8, !tbaa !16
  %416 = fsub double %413, %415
  %417 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %416, ptr %417, align 8, !tbaa !16
  %418 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %419 = load double, ptr %418, align 8, !tbaa !13
  %420 = load ptr, ptr %11, align 8, !tbaa !5
  %421 = load i64, ptr %17, align 8, !tbaa !9
  %422 = getelementptr inbounds %struct.doublecomplex, ptr %420, i64 %421
  %423 = getelementptr inbounds %struct.doublecomplex, ptr %422, i32 0, i32 0
  store double %419, ptr %423, align 8, !tbaa !13
  %424 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %425 = load double, ptr %424, align 8, !tbaa !16
  %426 = load ptr, ptr %11, align 8, !tbaa !5
  %427 = load i64, ptr %17, align 8, !tbaa !9
  %428 = getelementptr inbounds %struct.doublecomplex, ptr %426, i64 %427
  %429 = getelementptr inbounds %struct.doublecomplex, ptr %428, i32 0, i32 1
  store double %425, ptr %429, align 8, !tbaa !16
  %430 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %430, ptr %17, align 8, !tbaa !9
  %431 = load i64, ptr %26, align 8, !tbaa !9
  %432 = add nsw i64 %431, 1
  store i64 %432, ptr %18, align 8, !tbaa !9
  %433 = load ptr, ptr %12, align 8, !tbaa !5
  %434 = load i64, ptr %18, align 8, !tbaa !9
  %435 = getelementptr inbounds %struct.doublecomplex, ptr %433, i64 %434
  %436 = getelementptr inbounds %struct.doublecomplex, ptr %435, i32 0, i32 0
  %437 = load double, ptr %436, align 8, !tbaa !13
  %438 = load ptr, ptr %13, align 8, !tbaa !5
  %439 = load i64, ptr %17, align 8, !tbaa !9
  %440 = getelementptr inbounds %struct.doublecomplex, ptr %438, i64 %439
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %440, i32 0, i32 0
  store double %437, ptr %441, align 8, !tbaa !13
  %442 = load ptr, ptr %12, align 8, !tbaa !5
  %443 = load i64, ptr %18, align 8, !tbaa !9
  %444 = getelementptr inbounds %struct.doublecomplex, ptr %442, i64 %443
  %445 = getelementptr inbounds %struct.doublecomplex, ptr %444, i32 0, i32 1
  %446 = load double, ptr %445, align 8, !tbaa !16
  %447 = load ptr, ptr %13, align 8, !tbaa !5
  %448 = load i64, ptr %17, align 8, !tbaa !9
  %449 = getelementptr inbounds %struct.doublecomplex, ptr %447, i64 %448
  %450 = getelementptr inbounds %struct.doublecomplex, ptr %449, i32 0, i32 1
  store double %446, ptr %450, align 8, !tbaa !16
  %451 = load i64, ptr %26, align 8, !tbaa !9
  %452 = add nsw i64 %451, 1
  store i64 %452, ptr %17, align 8, !tbaa !9
  %453 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %454 = load double, ptr %453, align 8, !tbaa !13
  %455 = fneg double %454
  %456 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %455, ptr %456, align 8, !tbaa !13
  %457 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %458 = load double, ptr %457, align 8, !tbaa !16
  %459 = fneg double %458
  %460 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %459, ptr %460, align 8, !tbaa !16
  %461 = load i64, ptr %26, align 8, !tbaa !9
  %462 = add nsw i64 %461, 1
  store i64 %462, ptr %18, align 8, !tbaa !9
  %463 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %464 = load double, ptr %463, align 8, !tbaa !13
  %465 = load ptr, ptr %12, align 8, !tbaa !5
  %466 = load i64, ptr %18, align 8, !tbaa !9
  %467 = getelementptr inbounds %struct.doublecomplex, ptr %465, i64 %466
  %468 = getelementptr inbounds %struct.doublecomplex, ptr %467, i32 0, i32 0
  %469 = load double, ptr %468, align 8, !tbaa !13
  %470 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %471 = load double, ptr %470, align 8, !tbaa !16
  %472 = load ptr, ptr %12, align 8, !tbaa !5
  %473 = load i64, ptr %18, align 8, !tbaa !9
  %474 = getelementptr inbounds %struct.doublecomplex, ptr %472, i64 %473
  %475 = getelementptr inbounds %struct.doublecomplex, ptr %474, i32 0, i32 1
  %476 = load double, ptr %475, align 8, !tbaa !16
  %477 = fmul double %471, %476
  %478 = fneg double %477
  %479 = call double @llvm.fmuladd.f64(double %464, double %469, double %478)
  %480 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %479, ptr %480, align 8, !tbaa !13
  %481 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %482 = load double, ptr %481, align 8, !tbaa !13
  %483 = load ptr, ptr %12, align 8, !tbaa !5
  %484 = load i64, ptr %18, align 8, !tbaa !9
  %485 = getelementptr inbounds %struct.doublecomplex, ptr %483, i64 %484
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %485, i32 0, i32 1
  %487 = load double, ptr %486, align 8, !tbaa !16
  %488 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %489 = load double, ptr %488, align 8, !tbaa !16
  %490 = load ptr, ptr %12, align 8, !tbaa !5
  %491 = load i64, ptr %18, align 8, !tbaa !9
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %490, i64 %491
  %493 = getelementptr inbounds %struct.doublecomplex, ptr %492, i32 0, i32 0
  %494 = load double, ptr %493, align 8, !tbaa !13
  %495 = fmul double %489, %494
  %496 = call double @llvm.fmuladd.f64(double %482, double %487, double %495)
  %497 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %496, ptr %497, align 8, !tbaa !16
  %498 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %499 = load double, ptr %498, align 8, !tbaa !13
  %500 = load ptr, ptr %12, align 8, !tbaa !5
  %501 = load i64, ptr %17, align 8, !tbaa !9
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %500, i64 %501
  %503 = getelementptr inbounds %struct.doublecomplex, ptr %502, i32 0, i32 0
  store double %499, ptr %503, align 8, !tbaa !13
  %504 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %505 = load double, ptr %504, align 8, !tbaa !16
  %506 = load ptr, ptr %12, align 8, !tbaa !5
  %507 = load i64, ptr %17, align 8, !tbaa !9
  %508 = getelementptr inbounds %struct.doublecomplex, ptr %506, i64 %507
  %509 = getelementptr inbounds %struct.doublecomplex, ptr %508, i32 0, i32 1
  store double %505, ptr %509, align 8, !tbaa !16
  %510 = load i64, ptr %26, align 8, !tbaa !9
  %511 = add nsw i64 %510, 1
  %512 = load ptr, ptr %14, align 8, !tbaa !5
  %513 = load i64, ptr %26, align 8, !tbaa !9
  %514 = getelementptr inbounds i64, ptr %512, i64 %513
  store i64 %511, ptr %514, align 8, !tbaa !9
  br label %515

515:                                              ; preds = %287, %286
  br label %516

516:                                              ; preds = %515
  %517 = load i64, ptr %26, align 8, !tbaa !9
  %518 = add nsw i64 %517, 1
  store i64 %518, ptr %26, align 8, !tbaa !9
  br label %95, !llvm.loop !19

519:                                              ; preds = %95
  %520 = load ptr, ptr %9, align 8, !tbaa !5
  %521 = load i64, ptr %520, align 8, !tbaa !9
  %522 = icmp sgt i64 %521, 1
  br i1 %522, label %523, label %863

523:                                              ; preds = %519
  %524 = load ptr, ptr %9, align 8, !tbaa !5
  %525 = load i64, ptr %524, align 8, !tbaa !9
  %526 = sub nsw i64 %525, 1
  store i64 %526, ptr %26, align 8, !tbaa !9
  %527 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %527, ptr %16, align 8, !tbaa !9
  %528 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %528, ptr %17, align 8, !tbaa !9
  %529 = load ptr, ptr %11, align 8, !tbaa !5
  %530 = load i64, ptr %16, align 8, !tbaa !9
  %531 = getelementptr inbounds %struct.doublecomplex, ptr %529, i64 %530
  %532 = getelementptr inbounds %struct.doublecomplex, ptr %531, i32 0, i32 0
  %533 = load double, ptr %532, align 8, !tbaa !13
  store double %533, ptr %20, align 8, !tbaa !18
  %534 = load double, ptr %20, align 8, !tbaa !18
  %535 = fcmp oge double %534, 0.000000e+00
  br i1 %535, label %536, label %538

536:                                              ; preds = %523
  %537 = load double, ptr %20, align 8, !tbaa !18
  br label %541

538:                                              ; preds = %523
  %539 = load double, ptr %20, align 8, !tbaa !18
  %540 = fneg double %539
  br label %541

541:                                              ; preds = %538, %536
  %542 = phi double [ %537, %536 ], [ %540, %538 ]
  %543 = load ptr, ptr %11, align 8, !tbaa !5
  %544 = load i64, ptr %26, align 8, !tbaa !9
  %545 = getelementptr inbounds %struct.doublecomplex, ptr %543, i64 %544
  %546 = call double @d_imag(ptr noundef %545)
  store double %546, ptr %21, align 8, !tbaa !18
  %547 = load double, ptr %21, align 8, !tbaa !18
  %548 = fcmp oge double %547, 0.000000e+00
  br i1 %548, label %549, label %551

549:                                              ; preds = %541
  %550 = load double, ptr %21, align 8, !tbaa !18
  br label %554

551:                                              ; preds = %541
  %552 = load double, ptr %21, align 8, !tbaa !18
  %553 = fneg double %552
  br label %554

554:                                              ; preds = %551, %549
  %555 = phi double [ %550, %549 ], [ %553, %551 ]
  %556 = fadd double %542, %555
  %557 = load ptr, ptr %10, align 8, !tbaa !5
  %558 = load i64, ptr %17, align 8, !tbaa !9
  %559 = getelementptr inbounds %struct.doublecomplex, ptr %557, i64 %558
  %560 = getelementptr inbounds %struct.doublecomplex, ptr %559, i32 0, i32 0
  %561 = load double, ptr %560, align 8, !tbaa !13
  store double %561, ptr %22, align 8, !tbaa !18
  %562 = load double, ptr %22, align 8, !tbaa !18
  %563 = fcmp oge double %562, 0.000000e+00
  br i1 %563, label %564, label %566

564:                                              ; preds = %554
  %565 = load double, ptr %22, align 8, !tbaa !18
  br label %569

566:                                              ; preds = %554
  %567 = load double, ptr %22, align 8, !tbaa !18
  %568 = fneg double %567
  br label %569

569:                                              ; preds = %566, %564
  %570 = phi double [ %565, %564 ], [ %568, %566 ]
  %571 = load ptr, ptr %10, align 8, !tbaa !5
  %572 = load i64, ptr %26, align 8, !tbaa !9
  %573 = getelementptr inbounds %struct.doublecomplex, ptr %571, i64 %572
  %574 = call double @d_imag(ptr noundef %573)
  store double %574, ptr %23, align 8, !tbaa !18
  %575 = load double, ptr %23, align 8, !tbaa !18
  %576 = fcmp oge double %575, 0.000000e+00
  br i1 %576, label %577, label %579

577:                                              ; preds = %569
  %578 = load double, ptr %23, align 8, !tbaa !18
  br label %582

579:                                              ; preds = %569
  %580 = load double, ptr %23, align 8, !tbaa !18
  %581 = fneg double %580
  br label %582

582:                                              ; preds = %579, %577
  %583 = phi double [ %578, %577 ], [ %581, %579 ]
  %584 = fadd double %570, %583
  %585 = fcmp oge double %556, %584
  br i1 %585, label %586, label %714

586:                                              ; preds = %582
  %587 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %587, ptr %16, align 8, !tbaa !9
  %588 = load ptr, ptr %11, align 8, !tbaa !5
  %589 = load i64, ptr %16, align 8, !tbaa !9
  %590 = getelementptr inbounds %struct.doublecomplex, ptr %588, i64 %589
  %591 = getelementptr inbounds %struct.doublecomplex, ptr %590, i32 0, i32 0
  %592 = load double, ptr %591, align 8, !tbaa !13
  store double %592, ptr %20, align 8, !tbaa !18
  %593 = load double, ptr %20, align 8, !tbaa !18
  %594 = fcmp oge double %593, 0.000000e+00
  br i1 %594, label %595, label %597

595:                                              ; preds = %586
  %596 = load double, ptr %20, align 8, !tbaa !18
  br label %600

597:                                              ; preds = %586
  %598 = load double, ptr %20, align 8, !tbaa !18
  %599 = fneg double %598
  br label %600

600:                                              ; preds = %597, %595
  %601 = phi double [ %596, %595 ], [ %599, %597 ]
  %602 = load ptr, ptr %11, align 8, !tbaa !5
  %603 = load i64, ptr %26, align 8, !tbaa !9
  %604 = getelementptr inbounds %struct.doublecomplex, ptr %602, i64 %603
  %605 = call double @d_imag(ptr noundef %604)
  store double %605, ptr %21, align 8, !tbaa !18
  %606 = load double, ptr %21, align 8, !tbaa !18
  %607 = fcmp oge double %606, 0.000000e+00
  br i1 %607, label %608, label %610

608:                                              ; preds = %600
  %609 = load double, ptr %21, align 8, !tbaa !18
  br label %613

610:                                              ; preds = %600
  %611 = load double, ptr %21, align 8, !tbaa !18
  %612 = fneg double %611
  br label %613

613:                                              ; preds = %610, %608
  %614 = phi double [ %609, %608 ], [ %612, %610 ]
  %615 = fadd double %601, %614
  %616 = fcmp une double %615, 0.000000e+00
  br i1 %616, label %617, label %713

617:                                              ; preds = %613
  %618 = load ptr, ptr %10, align 8, !tbaa !5
  %619 = load i64, ptr %26, align 8, !tbaa !9
  %620 = getelementptr inbounds %struct.doublecomplex, ptr %618, i64 %619
  %621 = load ptr, ptr %11, align 8, !tbaa !5
  %622 = load i64, ptr %26, align 8, !tbaa !9
  %623 = getelementptr inbounds %struct.doublecomplex, ptr %621, i64 %622
  call void @z_div(ptr noundef %24, ptr noundef %620, ptr noundef %623)
  %624 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %625 = load double, ptr %624, align 8, !tbaa !13
  %626 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %625, ptr %626, align 8, !tbaa !13
  %627 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %628 = load double, ptr %627, align 8, !tbaa !16
  %629 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %628, ptr %629, align 8, !tbaa !16
  %630 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %630, ptr %16, align 8, !tbaa !9
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %632 = load double, ptr %631, align 8, !tbaa !13
  %633 = load ptr, ptr %10, align 8, !tbaa !5
  %634 = load i64, ptr %16, align 8, !tbaa !9
  %635 = getelementptr inbounds %struct.doublecomplex, ptr %633, i64 %634
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %635, i32 0, i32 0
  store double %632, ptr %636, align 8, !tbaa !13
  %637 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %638 = load double, ptr %637, align 8, !tbaa !16
  %639 = load ptr, ptr %10, align 8, !tbaa !5
  %640 = load i64, ptr %16, align 8, !tbaa !9
  %641 = getelementptr inbounds %struct.doublecomplex, ptr %639, i64 %640
  %642 = getelementptr inbounds %struct.doublecomplex, ptr %641, i32 0, i32 1
  store double %638, ptr %642, align 8, !tbaa !16
  %643 = load i64, ptr %26, align 8, !tbaa !9
  %644 = add nsw i64 %643, 1
  store i64 %644, ptr %16, align 8, !tbaa !9
  %645 = load i64, ptr %26, align 8, !tbaa !9
  %646 = add nsw i64 %645, 1
  store i64 %646, ptr %17, align 8, !tbaa !9
  %647 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %647, ptr %18, align 8, !tbaa !9
  %648 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %649 = load double, ptr %648, align 8, !tbaa !13
  %650 = load ptr, ptr %12, align 8, !tbaa !5
  %651 = load i64, ptr %18, align 8, !tbaa !9
  %652 = getelementptr inbounds %struct.doublecomplex, ptr %650, i64 %651
  %653 = getelementptr inbounds %struct.doublecomplex, ptr %652, i32 0, i32 0
  %654 = load double, ptr %653, align 8, !tbaa !13
  %655 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %656 = load double, ptr %655, align 8, !tbaa !16
  %657 = load ptr, ptr %12, align 8, !tbaa !5
  %658 = load i64, ptr %18, align 8, !tbaa !9
  %659 = getelementptr inbounds %struct.doublecomplex, ptr %657, i64 %658
  %660 = getelementptr inbounds %struct.doublecomplex, ptr %659, i32 0, i32 1
  %661 = load double, ptr %660, align 8, !tbaa !16
  %662 = fmul double %656, %661
  %663 = fneg double %662
  %664 = call double @llvm.fmuladd.f64(double %649, double %654, double %663)
  %665 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %664, ptr %665, align 8, !tbaa !13
  %666 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %667 = load double, ptr %666, align 8, !tbaa !13
  %668 = load ptr, ptr %12, align 8, !tbaa !5
  %669 = load i64, ptr %18, align 8, !tbaa !9
  %670 = getelementptr inbounds %struct.doublecomplex, ptr %668, i64 %669
  %671 = getelementptr inbounds %struct.doublecomplex, ptr %670, i32 0, i32 1
  %672 = load double, ptr %671, align 8, !tbaa !16
  %673 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %674 = load double, ptr %673, align 8, !tbaa !16
  %675 = load ptr, ptr %12, align 8, !tbaa !5
  %676 = load i64, ptr %18, align 8, !tbaa !9
  %677 = getelementptr inbounds %struct.doublecomplex, ptr %675, i64 %676
  %678 = getelementptr inbounds %struct.doublecomplex, ptr %677, i32 0, i32 0
  %679 = load double, ptr %678, align 8, !tbaa !13
  %680 = fmul double %674, %679
  %681 = call double @llvm.fmuladd.f64(double %667, double %672, double %680)
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %681, ptr %682, align 8, !tbaa !16
  %683 = load ptr, ptr %11, align 8, !tbaa !5
  %684 = load i64, ptr %17, align 8, !tbaa !9
  %685 = getelementptr inbounds %struct.doublecomplex, ptr %683, i64 %684
  %686 = getelementptr inbounds %struct.doublecomplex, ptr %685, i32 0, i32 0
  %687 = load double, ptr %686, align 8, !tbaa !13
  %688 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %689 = load double, ptr %688, align 8, !tbaa !13
  %690 = fsub double %687, %689
  %691 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %690, ptr %691, align 8, !tbaa !13
  %692 = load ptr, ptr %11, align 8, !tbaa !5
  %693 = load i64, ptr %17, align 8, !tbaa !9
  %694 = getelementptr inbounds %struct.doublecomplex, ptr %692, i64 %693
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %694, i32 0, i32 1
  %696 = load double, ptr %695, align 8, !tbaa !16
  %697 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %698 = load double, ptr %697, align 8, !tbaa !16
  %699 = fsub double %696, %698
  %700 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %699, ptr %700, align 8, !tbaa !16
  %701 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %702 = load double, ptr %701, align 8, !tbaa !13
  %703 = load ptr, ptr %11, align 8, !tbaa !5
  %704 = load i64, ptr %16, align 8, !tbaa !9
  %705 = getelementptr inbounds %struct.doublecomplex, ptr %703, i64 %704
  %706 = getelementptr inbounds %struct.doublecomplex, ptr %705, i32 0, i32 0
  store double %702, ptr %706, align 8, !tbaa !13
  %707 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %708 = load double, ptr %707, align 8, !tbaa !16
  %709 = load ptr, ptr %11, align 8, !tbaa !5
  %710 = load i64, ptr %16, align 8, !tbaa !9
  %711 = getelementptr inbounds %struct.doublecomplex, ptr %709, i64 %710
  %712 = getelementptr inbounds %struct.doublecomplex, ptr %711, i32 0, i32 1
  store double %708, ptr %712, align 8, !tbaa !16
  br label %713

713:                                              ; preds = %617, %613
  br label %862

714:                                              ; preds = %582
  %715 = load ptr, ptr %11, align 8, !tbaa !5
  %716 = load i64, ptr %26, align 8, !tbaa !9
  %717 = getelementptr inbounds %struct.doublecomplex, ptr %715, i64 %716
  %718 = load ptr, ptr %10, align 8, !tbaa !5
  %719 = load i64, ptr %26, align 8, !tbaa !9
  %720 = getelementptr inbounds %struct.doublecomplex, ptr %718, i64 %719
  call void @z_div(ptr noundef %24, ptr noundef %717, ptr noundef %720)
  %721 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %722 = load double, ptr %721, align 8, !tbaa !13
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %722, ptr %723, align 8, !tbaa !13
  %724 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %725 = load double, ptr %724, align 8, !tbaa !16
  %726 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %725, ptr %726, align 8, !tbaa !16
  %727 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %727, ptr %16, align 8, !tbaa !9
  %728 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %728, ptr %17, align 8, !tbaa !9
  %729 = load ptr, ptr %10, align 8, !tbaa !5
  %730 = load i64, ptr %17, align 8, !tbaa !9
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %729, i64 %730
  %732 = getelementptr inbounds %struct.doublecomplex, ptr %731, i32 0, i32 0
  %733 = load double, ptr %732, align 8, !tbaa !13
  %734 = load ptr, ptr %11, align 8, !tbaa !5
  %735 = load i64, ptr %16, align 8, !tbaa !9
  %736 = getelementptr inbounds %struct.doublecomplex, ptr %734, i64 %735
  %737 = getelementptr inbounds %struct.doublecomplex, ptr %736, i32 0, i32 0
  store double %733, ptr %737, align 8, !tbaa !13
  %738 = load ptr, ptr %10, align 8, !tbaa !5
  %739 = load i64, ptr %17, align 8, !tbaa !9
  %740 = getelementptr inbounds %struct.doublecomplex, ptr %738, i64 %739
  %741 = getelementptr inbounds %struct.doublecomplex, ptr %740, i32 0, i32 1
  %742 = load double, ptr %741, align 8, !tbaa !16
  %743 = load ptr, ptr %11, align 8, !tbaa !5
  %744 = load i64, ptr %16, align 8, !tbaa !9
  %745 = getelementptr inbounds %struct.doublecomplex, ptr %743, i64 %744
  %746 = getelementptr inbounds %struct.doublecomplex, ptr %745, i32 0, i32 1
  store double %742, ptr %746, align 8, !tbaa !16
  %747 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %747, ptr %16, align 8, !tbaa !9
  %748 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %749 = load double, ptr %748, align 8, !tbaa !13
  %750 = load ptr, ptr %10, align 8, !tbaa !5
  %751 = load i64, ptr %16, align 8, !tbaa !9
  %752 = getelementptr inbounds %struct.doublecomplex, ptr %750, i64 %751
  %753 = getelementptr inbounds %struct.doublecomplex, ptr %752, i32 0, i32 0
  store double %749, ptr %753, align 8, !tbaa !13
  %754 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %755 = load double, ptr %754, align 8, !tbaa !16
  %756 = load ptr, ptr %10, align 8, !tbaa !5
  %757 = load i64, ptr %16, align 8, !tbaa !9
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %756, i64 %757
  %759 = getelementptr inbounds %struct.doublecomplex, ptr %758, i32 0, i32 1
  store double %755, ptr %759, align 8, !tbaa !16
  %760 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %760, ptr %16, align 8, !tbaa !9
  %761 = load ptr, ptr %12, align 8, !tbaa !5
  %762 = load i64, ptr %16, align 8, !tbaa !9
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %761, i64 %762
  %764 = getelementptr inbounds %struct.doublecomplex, ptr %763, i32 0, i32 0
  %765 = load double, ptr %764, align 8, !tbaa !13
  %766 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %765, ptr %766, align 8, !tbaa !13
  %767 = load ptr, ptr %12, align 8, !tbaa !5
  %768 = load i64, ptr %16, align 8, !tbaa !9
  %769 = getelementptr inbounds %struct.doublecomplex, ptr %767, i64 %768
  %770 = getelementptr inbounds %struct.doublecomplex, ptr %769, i32 0, i32 1
  %771 = load double, ptr %770, align 8, !tbaa !16
  %772 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %771, ptr %772, align 8, !tbaa !16
  %773 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %773, ptr %16, align 8, !tbaa !9
  %774 = load i64, ptr %26, align 8, !tbaa !9
  %775 = add nsw i64 %774, 1
  store i64 %775, ptr %17, align 8, !tbaa !9
  %776 = load ptr, ptr %11, align 8, !tbaa !5
  %777 = load i64, ptr %17, align 8, !tbaa !9
  %778 = getelementptr inbounds %struct.doublecomplex, ptr %776, i64 %777
  %779 = getelementptr inbounds %struct.doublecomplex, ptr %778, i32 0, i32 0
  %780 = load double, ptr %779, align 8, !tbaa !13
  %781 = load ptr, ptr %12, align 8, !tbaa !5
  %782 = load i64, ptr %16, align 8, !tbaa !9
  %783 = getelementptr inbounds %struct.doublecomplex, ptr %781, i64 %782
  %784 = getelementptr inbounds %struct.doublecomplex, ptr %783, i32 0, i32 0
  store double %780, ptr %784, align 8, !tbaa !13
  %785 = load ptr, ptr %11, align 8, !tbaa !5
  %786 = load i64, ptr %17, align 8, !tbaa !9
  %787 = getelementptr inbounds %struct.doublecomplex, ptr %785, i64 %786
  %788 = getelementptr inbounds %struct.doublecomplex, ptr %787, i32 0, i32 1
  %789 = load double, ptr %788, align 8, !tbaa !16
  %790 = load ptr, ptr %12, align 8, !tbaa !5
  %791 = load i64, ptr %16, align 8, !tbaa !9
  %792 = getelementptr inbounds %struct.doublecomplex, ptr %790, i64 %791
  %793 = getelementptr inbounds %struct.doublecomplex, ptr %792, i32 0, i32 1
  store double %789, ptr %793, align 8, !tbaa !16
  %794 = load i64, ptr %26, align 8, !tbaa !9
  %795 = add nsw i64 %794, 1
  store i64 %795, ptr %16, align 8, !tbaa !9
  %796 = load i64, ptr %26, align 8, !tbaa !9
  %797 = add nsw i64 %796, 1
  store i64 %797, ptr %17, align 8, !tbaa !9
  %798 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %799 = load double, ptr %798, align 8, !tbaa !13
  %800 = load ptr, ptr %11, align 8, !tbaa !5
  %801 = load i64, ptr %17, align 8, !tbaa !9
  %802 = getelementptr inbounds %struct.doublecomplex, ptr %800, i64 %801
  %803 = getelementptr inbounds %struct.doublecomplex, ptr %802, i32 0, i32 0
  %804 = load double, ptr %803, align 8, !tbaa !13
  %805 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %806 = load double, ptr %805, align 8, !tbaa !16
  %807 = load ptr, ptr %11, align 8, !tbaa !5
  %808 = load i64, ptr %17, align 8, !tbaa !9
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %807, i64 %808
  %810 = getelementptr inbounds %struct.doublecomplex, ptr %809, i32 0, i32 1
  %811 = load double, ptr %810, align 8, !tbaa !16
  %812 = fmul double %806, %811
  %813 = fneg double %812
  %814 = call double @llvm.fmuladd.f64(double %799, double %804, double %813)
  %815 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %814, ptr %815, align 8, !tbaa !13
  %816 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %817 = load double, ptr %816, align 8, !tbaa !13
  %818 = load ptr, ptr %11, align 8, !tbaa !5
  %819 = load i64, ptr %17, align 8, !tbaa !9
  %820 = getelementptr inbounds %struct.doublecomplex, ptr %818, i64 %819
  %821 = getelementptr inbounds %struct.doublecomplex, ptr %820, i32 0, i32 1
  %822 = load double, ptr %821, align 8, !tbaa !16
  %823 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %824 = load double, ptr %823, align 8, !tbaa !16
  %825 = load ptr, ptr %11, align 8, !tbaa !5
  %826 = load i64, ptr %17, align 8, !tbaa !9
  %827 = getelementptr inbounds %struct.doublecomplex, ptr %825, i64 %826
  %828 = getelementptr inbounds %struct.doublecomplex, ptr %827, i32 0, i32 0
  %829 = load double, ptr %828, align 8, !tbaa !13
  %830 = fmul double %824, %829
  %831 = call double @llvm.fmuladd.f64(double %817, double %822, double %830)
  %832 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %831, ptr %832, align 8, !tbaa !16
  %833 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %834 = load double, ptr %833, align 8, !tbaa !13
  %835 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %836 = load double, ptr %835, align 8, !tbaa !13
  %837 = fsub double %834, %836
  %838 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %837, ptr %838, align 8, !tbaa !13
  %839 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %840 = load double, ptr %839, align 8, !tbaa !16
  %841 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %842 = load double, ptr %841, align 8, !tbaa !16
  %843 = fsub double %840, %842
  %844 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %843, ptr %844, align 8, !tbaa !16
  %845 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %846 = load double, ptr %845, align 8, !tbaa !13
  %847 = load ptr, ptr %11, align 8, !tbaa !5
  %848 = load i64, ptr %16, align 8, !tbaa !9
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %847, i64 %848
  %850 = getelementptr inbounds %struct.doublecomplex, ptr %849, i32 0, i32 0
  store double %846, ptr %850, align 8, !tbaa !13
  %851 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %852 = load double, ptr %851, align 8, !tbaa !16
  %853 = load ptr, ptr %11, align 8, !tbaa !5
  %854 = load i64, ptr %16, align 8, !tbaa !9
  %855 = getelementptr inbounds %struct.doublecomplex, ptr %853, i64 %854
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %855, i32 0, i32 1
  store double %852, ptr %856, align 8, !tbaa !16
  %857 = load i64, ptr %26, align 8, !tbaa !9
  %858 = add nsw i64 %857, 1
  %859 = load ptr, ptr %14, align 8, !tbaa !5
  %860 = load i64, ptr %26, align 8, !tbaa !9
  %861 = getelementptr inbounds i64, ptr %859, i64 %860
  store i64 %858, ptr %861, align 8, !tbaa !9
  br label %862

862:                                              ; preds = %714, %713
  br label %863

863:                                              ; preds = %862, %519
  %864 = load ptr, ptr %9, align 8, !tbaa !5
  %865 = load i64, ptr %864, align 8, !tbaa !9
  store i64 %865, ptr %16, align 8, !tbaa !9
  store i64 1, ptr %26, align 8, !tbaa !9
  br label %866

866:                                              ; preds = %905, %863
  %867 = load i64, ptr %26, align 8, !tbaa !9
  %868 = load i64, ptr %16, align 8, !tbaa !9
  %869 = icmp sle i64 %867, %868
  br i1 %869, label %870, label %908

870:                                              ; preds = %866
  %871 = load i64, ptr %26, align 8, !tbaa !9
  store i64 %871, ptr %17, align 8, !tbaa !9
  %872 = load ptr, ptr %11, align 8, !tbaa !5
  %873 = load i64, ptr %17, align 8, !tbaa !9
  %874 = getelementptr inbounds %struct.doublecomplex, ptr %872, i64 %873
  %875 = getelementptr inbounds %struct.doublecomplex, ptr %874, i32 0, i32 0
  %876 = load double, ptr %875, align 8, !tbaa !13
  store double %876, ptr %20, align 8, !tbaa !18
  %877 = load double, ptr %20, align 8, !tbaa !18
  %878 = fcmp oge double %877, 0.000000e+00
  br i1 %878, label %879, label %881

879:                                              ; preds = %870
  %880 = load double, ptr %20, align 8, !tbaa !18
  br label %884

881:                                              ; preds = %870
  %882 = load double, ptr %20, align 8, !tbaa !18
  %883 = fneg double %882
  br label %884

884:                                              ; preds = %881, %879
  %885 = phi double [ %880, %879 ], [ %883, %881 ]
  %886 = load ptr, ptr %11, align 8, !tbaa !5
  %887 = load i64, ptr %26, align 8, !tbaa !9
  %888 = getelementptr inbounds %struct.doublecomplex, ptr %886, i64 %887
  %889 = call double @d_imag(ptr noundef %888)
  store double %889, ptr %21, align 8, !tbaa !18
  %890 = load double, ptr %21, align 8, !tbaa !18
  %891 = fcmp oge double %890, 0.000000e+00
  br i1 %891, label %892, label %894

892:                                              ; preds = %884
  %893 = load double, ptr %21, align 8, !tbaa !18
  br label %897

894:                                              ; preds = %884
  %895 = load double, ptr %21, align 8, !tbaa !18
  %896 = fneg double %895
  br label %897

897:                                              ; preds = %894, %892
  %898 = phi double [ %893, %892 ], [ %896, %894 ]
  %899 = fadd double %885, %898
  %900 = fcmp oeq double %899, 0.000000e+00
  br i1 %900, label %901, label %904

901:                                              ; preds = %897
  %902 = load i64, ptr %26, align 8, !tbaa !9
  %903 = load ptr, ptr %15, align 8, !tbaa !5
  store i64 %902, ptr %903, align 8, !tbaa !9
  br label %909

904:                                              ; preds = %897
  br label %905

905:                                              ; preds = %904
  %906 = load i64, ptr %26, align 8, !tbaa !9
  %907 = add nsw i64 %906, 1
  store i64 %907, ptr %26, align 8, !tbaa !9
  br label %866, !llvm.loop !20

908:                                              ; preds = %866
  br label %909

909:                                              ; preds = %908, %901
  store i32 0, ptr %8, align 4
  store i32 1, ptr %29, align 4
  br label %910

910:                                              ; preds = %909, %54, %44
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #4
  %911 = load i32, ptr %8, align 4
  ret i32 %911
}

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

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

declare double @d_imag(ptr noundef) #2

declare void @z_div(ptr noundef, ptr noundef, 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 willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

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 }

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

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


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

%struct.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @zgttrf_(ptr nocapture noundef readonly %0, ptr noundef %1, ptr noundef %2, ptr nocapture noundef %3, ptr nocapture noundef writeonly %4, ptr nocapture noundef writeonly %5, ptr nocapture noundef writeonly %6) local_unnamed_addr #0 {
  %8 = alloca i64, align 8
  %9 = alloca %struct.doublecomplex, align 16
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %8) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %9) #5
  %10 = getelementptr inbounds i8, ptr %5, i64 -8
  %11 = getelementptr inbounds i8, ptr %4, i64 -16
  %12 = getelementptr inbounds i8, ptr %3, i64 -16
  %13 = getelementptr inbounds i8, ptr %2, i64 -16
  %14 = getelementptr inbounds i8, ptr %1, i64 -16
  store i64 0, ptr %6, align 8, !tbaa !5
  %15 = load i64, ptr %0, align 8, !tbaa !5
  %16 = icmp slt i64 %15, 0
  br i1 %16, label %17, label %19

17:                                               ; preds = %7
  store i64 -1, ptr %6, align 8, !tbaa !5
  store i64 1, ptr %8, align 8, !tbaa !5
  %18 = call i32 @xerbla_(ptr noundef nonnull @.str, ptr noundef nonnull %8) #5
  br label %.loopexit

19:                                               ; preds = %7
  %20 = icmp eq i64 %15, 0
  br i1 %20, label %.loopexit, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %19
  %min.iters.check = icmp ult i64 %15, 4
  br i1 %min.iters.check, label %.lr.ph.preheader346, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph.preheader
  %n.vec = and i64 %15, 9223372036854775804
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i64> [ <i64 1, i64 2>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %step.add = add <2 x i64> %vec.ind, <i64 2, i64 2>
  %21 = getelementptr i64, ptr %5, i64 %index
  %22 = getelementptr inbounds i8, ptr %21, i64 16
  store <2 x i64> %vec.ind, ptr %21, align 8, !tbaa !5
  store <2 x i64> %step.add, ptr %22, align 8, !tbaa !5
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <2 x i64> %vec.ind, <i64 4, i64 4>
  %23 = icmp eq i64 %index.next, %n.vec
  br i1 %23, label %middle.block, label %vector.body, !llvm.loop !9

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %15, %n.vec
  br i1 %cmp.n, label %._crit_edge, label %.lr.ph.preheader346

.lr.ph.preheader346:                              ; preds = %middle.block, %.lr.ph.preheader
  %.0323.ph = phi i64 [ 1, %.lr.ph.preheader ], [ %ind.end, %middle.block ]
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader346, %.lr.ph
  %.0323 = phi i64 [ %25, %.lr.ph ], [ %.0323.ph, %.lr.ph.preheader346 ]
  %24 = getelementptr inbounds i64, ptr %10, i64 %.0323
  store i64 %.0323, ptr %24, align 8, !tbaa !5
  %25 = add nuw i64 %.0323, 1
  %exitcond.not = icmp eq i64 %.0323, %15
  br i1 %exitcond.not, label %._crit_edge, label %.lr.ph, !llvm.loop !13

._crit_edge:                                      ; preds = %.lr.ph, %middle.block
  %.pre = load i64, ptr %0, align 8, !tbaa !5
  %26 = add nsw i64 %.pre, -2
  %.not318324 = icmp slt i64 %.pre, 3
  br i1 %.not318324, label %._crit_edge333, label %.lr.ph332

.lr.ph332:                                        ; preds = %._crit_edge
  %27 = shl i64 %.pre, 4
  %28 = add i64 %27, -32
  tail call void @llvm.memset.p0.i64(ptr align 8 %4, i8 0, i64 %28, i1 false), !tbaa !14
  br label %29

29:                                               ; preds = %.lr.ph332, %106
  %.2330 = phi i64 [ 1, %.lr.ph332 ], [ %107, %106 ]
  %30 = getelementptr inbounds %struct.doublecomplex, ptr %13, i64 %.2330
  %31 = load double, ptr %30, align 8, !tbaa !16
  %32 = call double @d_imag(ptr noundef nonnull %30) #5
  %33 = insertelement <2 x double> poison, double %31, i64 0
  %34 = insertelement <2 x double> %33, double %32, i64 1
  %35 = fcmp oge <2 x double> %34, zeroinitializer
  %36 = fneg <2 x double> %34
  %37 = select <2 x i1> %35, <2 x double> %34, <2 x double> %36
  %38 = getelementptr inbounds %struct.doublecomplex, ptr %14, i64 %.2330
  %39 = load double, ptr %38, align 8, !tbaa !16
  %40 = call double @d_imag(ptr noundef nonnull %38) #5
  %41 = insertelement <2 x double> poison, double %39, i64 0
  %42 = insertelement <2 x double> %41, double %40, i64 1
  %43 = fcmp oge <2 x double> %42, zeroinitializer
  %44 = fneg <2 x double> %42
  %45 = select <2 x i1> %43, <2 x double> %42, <2 x double> %44
  %46 = shufflevector <2 x double> %37, <2 x double> %45, <2 x i32> <i32 0, i32 2>
  %47 = shufflevector <2 x double> %37, <2 x double> %45, <2 x i32> <i32 1, i32 3>
  %48 = fadd <2 x double> %46, %47
  %49 = extractelement <2 x double> %48, i64 0
  %50 = extractelement <2 x double> %48, i64 1
  %51 = fcmp ult double %49, %50
  br i1 %51, label %77, label %52

52:                                               ; preds = %29
  %53 = load double, ptr %30, align 8, !tbaa !16
  %54 = call double @d_imag(ptr noundef nonnull %30) #5
  %55 = insertelement <2 x double> poison, double %53, i64 0
  %56 = insertelement <2 x double> %55, double %54, i64 1
  %57 = fcmp oge <2 x double> %56, zeroinitializer
  %58 = fneg <2 x double> %56
  %59 = select <2 x i1> %57, <2 x double> %56, <2 x double> %58
  %shift = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %60 = fadd <2 x double> %59, %shift
  %61 = extractelement <2 x double> %60, i64 0
  %62 = fcmp une double %61, 0.000000e+00
  br i1 %62, label %63, label %106

63:                                               ; preds = %52
  call void @z_div(ptr noundef nonnull %9, ptr noundef nonnull %38, ptr noundef nonnull %30) #5
  %64 = load <2 x double>, ptr %9, align 16, !tbaa !14
  store <2 x double> %64, ptr %38, align 8, !tbaa !14
  %65 = getelementptr inbounds %struct.doublecomplex, ptr %12, i64 %.2330
  %66 = getelementptr %struct.doublecomplex, ptr %2, i64 %.2330
  %67 = load <2 x double>, ptr %65, align 8, !tbaa !14
  %68 = shufflevector <2 x double> %64, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %69 = fneg <2 x double> %64
  %70 = shufflevector <2 x double> %68, <2 x double> %69, <2 x i32> <i32 0, i32 3>
  %71 = fmul <2 x double> %67, %70
  %72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %73 = shufflevector <2 x double> %64, <2 x double> poison, <2 x i32> zeroinitializer
  %74 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %73, <2 x double> %67, <2 x double> %72)
  %75 = load <2 x double>, ptr %66, align 8, !tbaa !14
  %76 = fsub <2 x double> %75, %74
  store <2 x double> %76, ptr %9, align 16, !tbaa !14
  store <2 x double> %76, ptr %66, align 8, !tbaa !14
  br label %106

77:                                               ; preds = %29
  call void @z_div(ptr noundef nonnull %9, ptr noundef nonnull %30, ptr noundef nonnull %38) #5
  %78 = load <2 x double>, ptr %38, align 8, !tbaa !14
  store <2 x double> %78, ptr %30, align 8, !tbaa !14
  %79 = load <2 x double>, ptr %9, align 16, !tbaa !14
  store <2 x double> %79, ptr %38, align 8, !tbaa !14
  %80 = getelementptr inbounds %struct.doublecomplex, ptr %12, i64 %.2330
  %81 = add nuw nsw i64 %.2330, 1
  %82 = getelementptr %struct.doublecomplex, ptr %2, i64 %.2330
  %83 = extractelement <2 x double> %79, i64 1
  %84 = fneg double %83
  %85 = load <2 x double>, ptr %80, align 8, !tbaa !14
  %86 = load <2 x double>, ptr %82, align 8, !tbaa !14
  store <2 x double> %86, ptr %80, align 8, !tbaa !14
  %87 = shufflevector <2 x double> %79, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %88 = insertelement <2 x double> %87, double %84, i64 1
  %89 = fmul <2 x double> %86, %88
  %90 = shufflevector <2 x double> %89, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %91 = shufflevector <2 x double> %79, <2 x double> poison, <2 x i32> zeroinitializer
  %92 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %86, <2 x double> %90)
  %93 = fsub <2 x double> %85, %92
  store <2 x double> %93, ptr %82, align 8, !tbaa !14
  %94 = getelementptr %struct.doublecomplex, ptr %3, i64 %.2330
  %95 = getelementptr inbounds %struct.doublecomplex, ptr %11, i64 %.2330
  %96 = extractelement <2 x double> %79, i64 0
  %97 = fneg double %96
  %98 = load <2 x double>, ptr %94, align 8, !tbaa !14
  store <2 x double> %98, ptr %95, align 8, !tbaa !14
  %99 = insertelement <2 x double> %79, double %84, i64 0
  %100 = fmul <2 x double> %99, %98
  %101 = shufflevector <2 x double> %100, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %102 = insertelement <2 x double> poison, double %97, i64 0
  %103 = shufflevector <2 x double> %102, <2 x double> poison, <2 x i32> zeroinitializer
  %104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %98, <2 x double> %101)
  store <2 x double> %104, ptr %9, align 16, !tbaa !14
  store <2 x double> %104, ptr %94, align 8, !tbaa !14
  %105 = getelementptr inbounds i64, ptr %10, i64 %.2330
  store i64 %81, ptr %105, align 8, !tbaa !5
  br label %106

106:                                              ; preds = %77, %63, %52
  %107 = add nuw nsw i64 %.2330, 1
  %.not319.not = icmp slt i64 %.2330, %26
  br i1 %.not319.not, label %29, label %._crit_edge333.loopexit, !llvm.loop !18

._crit_edge333.loopexit:                          ; preds = %106
  %.pre339 = load i64, ptr %0, align 8, !tbaa !5
  br label %._crit_edge333

._crit_edge333:                                   ; preds = %._crit_edge, %._crit_edge333.loopexit
  %108 = phi i64 [ %.pre339, %._crit_edge333.loopexit ], [ %.pre, %._crit_edge ]
  %109 = icmp sgt i64 %108, 1
  br i1 %109, label %110, label %175

110:                                              ; preds = %._crit_edge333
  %111 = add nsw i64 %108, -1
  %112 = getelementptr inbounds %struct.doublecomplex, ptr %13, i64 %111
  %113 = load double, ptr %112, align 8, !tbaa !16
  %114 = call double @d_imag(ptr noundef nonnull %112) #5
  %115 = insertelement <2 x double> poison, double %113, i64 0
  %116 = insertelement <2 x double> %115, double %114, i64 1
  %117 = fcmp oge <2 x double> %116, zeroinitializer
  %118 = fneg <2 x double> %116
  %119 = select <2 x i1> %117, <2 x double> %116, <2 x double> %118
  %120 = getelementptr inbounds %struct.doublecomplex, ptr %14, i64 %111
  %121 = load double, ptr %120, align 8, !tbaa !16
  %122 = call double @d_imag(ptr noundef nonnull %120) #5
  %123 = insertelement <2 x double> poison, double %121, i64 0
  %124 = insertelement <2 x double> %123, double %122, i64 1
  %125 = fcmp oge <2 x double> %124, zeroinitializer
  %126 = fneg <2 x double> %124
  %127 = select <2 x i1> %125, <2 x double> %124, <2 x double> %126
  %128 = shufflevector <2 x double> %119, <2 x double> %127, <2 x i32> <i32 0, i32 2>
  %129 = shufflevector <2 x double> %119, <2 x double> %127, <2 x i32> <i32 1, i32 3>
  %130 = fadd <2 x double> %128, %129
  %131 = extractelement <2 x double> %130, i64 0
  %132 = extractelement <2 x double> %130, i64 1
  %133 = fcmp ult double %131, %132
  br i1 %133, label %159, label %134

134:                                              ; preds = %110
  %135 = load double, ptr %112, align 8, !tbaa !16
  %136 = call double @d_imag(ptr noundef nonnull %112) #5
  %137 = insertelement <2 x double> poison, double %135, i64 0
  %138 = insertelement <2 x double> %137, double %136, i64 1
  %139 = fcmp oge <2 x double> %138, zeroinitializer
  %140 = fneg <2 x double> %138
  %141 = select <2 x i1> %139, <2 x double> %138, <2 x double> %140
  %shift343 = shufflevector <2 x double> %141, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %142 = fadd <2 x double> %141, %shift343
  %143 = extractelement <2 x double> %142, i64 0
  %144 = fcmp une double %143, 0.000000e+00
  br i1 %144, label %145, label %175

145:                                              ; preds = %134
  call void @z_div(ptr noundef nonnull %9, ptr noundef nonnull %120, ptr noundef nonnull %112) #5
  %146 = load <2 x double>, ptr %9, align 16, !tbaa !14
  store <2 x double> %146, ptr %120, align 8, !tbaa !14
  %147 = getelementptr inbounds %struct.doublecomplex, ptr %12, i64 %111
  %148 = getelementptr inbounds %struct.doublecomplex, ptr %13, i64 %108
  %149 = load <2 x double>, ptr %147, align 8, !tbaa !14
  %150 = shufflevector <2 x double> %146, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %151 = fneg <2 x double> %146
  %152 = shufflevector <2 x double> %150, <2 x double> %151, <2 x i32> <i32 0, i32 3>
  %153 = fmul <2 x double> %149, %152
  %154 = shufflevector <2 x double> %153, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %155 = shufflevector <2 x double> %146, <2 x double> poison, <2 x i32> zeroinitializer
  %156 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %155, <2 x double> %149, <2 x double> %154)
  %157 = load <2 x double>, ptr %148, align 8, !tbaa !14
  %158 = fsub <2 x double> %157, %156
  store <2 x double> %158, ptr %9, align 16, !tbaa !14
  store <2 x double> %158, ptr %148, align 8, !tbaa !14
  br label %175

159:                                              ; preds = %110
  call void @z_div(ptr noundef nonnull %9, ptr noundef nonnull %112, ptr noundef nonnull %120) #5
  %160 = load <2 x double>, ptr %120, align 8, !tbaa !14
  store <2 x double> %160, ptr %112, align 8, !tbaa !14
  %161 = load <2 x double>, ptr %9, align 16, !tbaa !14
  store <2 x double> %161, ptr %120, align 8, !tbaa !14
  %162 = getelementptr inbounds %struct.doublecomplex, ptr %12, i64 %111
  %163 = getelementptr inbounds %struct.doublecomplex, ptr %13, i64 %108
  %164 = load <2 x double>, ptr %162, align 8, !tbaa !14
  %165 = load <2 x double>, ptr %163, align 8, !tbaa !14
  store <2 x double> %165, ptr %162, align 8, !tbaa !14
  %166 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %167 = fneg <2 x double> %161
  %168 = shufflevector <2 x double> %166, <2 x double> %167, <2 x i32> <i32 0, i32 3>
  %169 = fmul <2 x double> %165, %168
  %170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %171 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> zeroinitializer
  %172 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %171, <2 x double> %165, <2 x double> %170)
  %173 = fsub <2 x double> %164, %172
  store <2 x double> %173, ptr %9, align 16, !tbaa !14
  store <2 x double> %173, ptr %163, align 8, !tbaa !14
  %174 = getelementptr inbounds i64, ptr %10, i64 %111
  store i64 %108, ptr %174, align 8, !tbaa !5
  br label %175

175:                                              ; preds = %159, %145, %134, %._crit_edge333
  %176 = load i64, ptr %0, align 8, !tbaa !5
  %.not320334 = icmp slt i64 %176, 1
  br i1 %.not320334, label %.loopexit, label %.lr.ph337

.lr.ph337:                                        ; preds = %175, %189
  %.3335 = phi i64 [ %190, %189 ], [ 1, %175 ]
  %177 = getelementptr inbounds %struct.doublecomplex, ptr %13, i64 %.3335
  %178 = load double, ptr %177, align 8, !tbaa !16
  %179 = call double @d_imag(ptr noundef nonnull %177) #5
  %180 = insertelement <2 x double> poison, double %178, i64 0
  %181 = insertelement <2 x double> %180, double %179, i64 1
  %182 = fcmp oge <2 x double> %181, zeroinitializer
  %183 = fneg <2 x double> %181
  %184 = select <2 x i1> %182, <2 x double> %181, <2 x double> %183
  %shift344 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %185 = fadd <2 x double> %184, %shift344
  %186 = extractelement <2 x double> %185, i64 0
  %187 = fcmp oeq double %186, 0.000000e+00
  br i1 %187, label %188, label %189

188:                                              ; preds = %.lr.ph337
  store i64 %.3335, ptr %6, align 8, !tbaa !5
  br label %.loopexit

189:                                              ; preds = %.lr.ph337
  %190 = add nuw nsw i64 %.3335, 1
  %.not320.not = icmp slt i64 %.3335, %176
  br i1 %.not320.not, label %.lr.ph337, label %.loopexit, !llvm.loop !19

.loopexit:                                        ; preds = %189, %175, %188, %19, %17
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %8) #5
  ret i32 0
}

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

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

declare double @d_imag(ptr noundef) local_unnamed_addr #2

declare void @z_div(ptr noundef, ptr 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: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

; 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>) #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 = { 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 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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 = !{!"long", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10, !11, !12}
!10 = !{!"llvm.loop.mustprogress"}
!11 = !{!"llvm.loop.isvectorized", i32 1}
!12 = !{!"llvm.loop.unroll.runtime.disable"}
!13 = distinct !{!13, !10, !12, !11}
!14 = !{!15, !15, i64 0}
!15 = !{!"double", !7, i64 0}
!16 = !{!17, !15, i64 0}
!17 = !{!"", !15, i64 0, !15, i64 8}
!18 = distinct !{!18, !10}
!19 = distinct !{!19, !10}


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