; LLVM IR from OpenMathLib/OpenBLAS :: lapack-netlib/SRC (zhetrs2)

; 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 [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.5 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zhetrs2_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9) #0 {
  %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 ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca i32, align 4
  %27 = alloca %struct.doublecomplex, align 8
  %28 = alloca %struct.doublecomplex, align 8
  %29 = alloca %struct.doublecomplex, align 8
  %30 = alloca %struct.doublecomplex, align 8
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca double, align 8
  %35 = alloca %struct.doublecomplex, align 8
  %36 = alloca i32, align 4
  %37 = alloca i32, align 4
  %38 = alloca %struct.doublecomplex, align 8
  %39 = alloca %struct.doublecomplex, align 8
  %40 = alloca i32, align 4
  %41 = alloca %struct.doublecomplex, align 8
  %42 = alloca %struct.doublecomplex, align 8
  %43 = alloca i32, align 4
  store ptr %0, ptr %11, align 8, !tbaa !5
  store ptr %1, ptr %12, align 8, !tbaa !5
  store ptr %2, ptr %13, align 8, !tbaa !5
  store ptr %3, ptr %14, align 8, !tbaa !5
  store ptr %4, ptr %15, align 8, !tbaa !5
  store ptr %5, ptr %16, align 8, !tbaa !5
  store ptr %6, ptr %17, align 8, !tbaa !5
  store ptr %7, ptr %18, align 8, !tbaa !5
  store ptr %8, ptr %19, align 8, !tbaa !5
  store ptr %9, ptr %20, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %27) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %29) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %30) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %38) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %39) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %41) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %42) #5
  %44 = load ptr, ptr %15, align 8, !tbaa !5
  %45 = load i32, ptr %44, align 4, !tbaa !9
  store i32 %45, ptr %21, align 4, !tbaa !9
  %46 = load i32, ptr %21, align 4, !tbaa !9
  %47 = mul nsw i32 %46, 1
  %48 = add nsw i32 1, %47
  store i32 %48, ptr %22, align 4, !tbaa !9
  %49 = load i32, ptr %22, align 4, !tbaa !9
  %50 = load ptr, ptr %14, align 8, !tbaa !5
  %51 = sext i32 %49 to i64
  %52 = sub i64 0, %51
  %53 = getelementptr inbounds %struct.doublecomplex, ptr %50, i64 %52
  store ptr %53, ptr %14, align 8, !tbaa !5
  %54 = load ptr, ptr %16, align 8, !tbaa !5
  %55 = getelementptr inbounds i32, ptr %54, i32 -1
  store ptr %55, ptr %16, align 8, !tbaa !5
  %56 = load ptr, ptr %18, align 8, !tbaa !5
  %57 = load i32, ptr %56, align 4, !tbaa !9
  store i32 %57, ptr %23, align 4, !tbaa !9
  %58 = load i32, ptr %23, align 4, !tbaa !9
  %59 = mul nsw i32 %58, 1
  %60 = add nsw i32 1, %59
  store i32 %60, ptr %24, align 4, !tbaa !9
  %61 = load i32, ptr %24, align 4, !tbaa !9
  %62 = load ptr, ptr %17, align 8, !tbaa !5
  %63 = sext i32 %61 to i64
  %64 = sub i64 0, %63
  %65 = getelementptr inbounds %struct.doublecomplex, ptr %62, i64 %64
  store ptr %65, ptr %17, align 8, !tbaa !5
  %66 = load ptr, ptr %19, align 8, !tbaa !5
  %67 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 -1
  store ptr %67, ptr %19, align 8, !tbaa !5
  %68 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 0, ptr %68, align 4, !tbaa !9
  %69 = load ptr, ptr %11, align 8, !tbaa !5
  %70 = call i32 @lsame_(ptr noundef %69, ptr noundef @.str)
  store i32 %70, ptr %37, align 4, !tbaa !9
  %71 = load i32, ptr %37, align 4, !tbaa !9
  %72 = icmp ne i32 %71, 0
  br i1 %72, label %79, label %73

73:                                               ; preds = %10
  %74 = load ptr, ptr %11, align 8, !tbaa !5
  %75 = call i32 @lsame_(ptr noundef %74, ptr noundef @.str.1)
  %76 = icmp ne i32 %75, 0
  br i1 %76, label %79, label %77

77:                                               ; preds = %73
  %78 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -1, ptr %78, align 4, !tbaa !9
  br label %125

79:                                               ; preds = %73, %10
  %80 = load ptr, ptr %12, align 8, !tbaa !5
  %81 = load i32, ptr %80, align 4, !tbaa !9
  %82 = icmp slt i32 %81, 0
  br i1 %82, label %83, label %85

83:                                               ; preds = %79
  %84 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -2, ptr %84, align 4, !tbaa !9
  br label %124

85:                                               ; preds = %79
  %86 = load ptr, ptr %13, align 8, !tbaa !5
  %87 = load i32, ptr %86, align 4, !tbaa !9
  %88 = icmp slt i32 %87, 0
  br i1 %88, label %89, label %91

89:                                               ; preds = %85
  %90 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -3, ptr %90, align 4, !tbaa !9
  br label %123

91:                                               ; preds = %85
  %92 = load ptr, ptr %15, align 8, !tbaa !5
  %93 = load i32, ptr %92, align 4, !tbaa !9
  %94 = load ptr, ptr %12, align 8, !tbaa !5
  %95 = load i32, ptr %94, align 4, !tbaa !9
  %96 = icmp sge i32 1, %95
  br i1 %96, label %97, label %98

97:                                               ; preds = %91
  br label %101

98:                                               ; preds = %91
  %99 = load ptr, ptr %12, align 8, !tbaa !5
  %100 = load i32, ptr %99, align 4, !tbaa !9
  br label %101

101:                                              ; preds = %98, %97
  %102 = phi i32 [ 1, %97 ], [ %100, %98 ]
  %103 = icmp slt i32 %93, %102
  br i1 %103, label %104, label %106

104:                                              ; preds = %101
  %105 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -5, ptr %105, align 4, !tbaa !9
  br label %122

106:                                              ; preds = %101
  %107 = load ptr, ptr %18, align 8, !tbaa !5
  %108 = load i32, ptr %107, align 4, !tbaa !9
  %109 = load ptr, ptr %12, align 8, !tbaa !5
  %110 = load i32, ptr %109, align 4, !tbaa !9
  %111 = icmp sge i32 1, %110
  br i1 %111, label %112, label %113

112:                                              ; preds = %106
  br label %116

113:                                              ; preds = %106
  %114 = load ptr, ptr %12, align 8, !tbaa !5
  %115 = load i32, ptr %114, align 4, !tbaa !9
  br label %116

116:                                              ; preds = %113, %112
  %117 = phi i32 [ 1, %112 ], [ %115, %113 ]
  %118 = icmp slt i32 %108, %117
  br i1 %118, label %119, label %121

119:                                              ; preds = %116
  %120 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -8, ptr %120, align 4, !tbaa !9
  br label %121

121:                                              ; preds = %119, %116
  br label %122

122:                                              ; preds = %121, %104
  br label %123

123:                                              ; preds = %122, %89
  br label %124

124:                                              ; preds = %123, %83
  br label %125

125:                                              ; preds = %124, %77
  %126 = load ptr, ptr %20, align 8, !tbaa !5
  %127 = load i32, ptr %126, align 4, !tbaa !9
  %128 = icmp ne i32 %127, 0
  br i1 %128, label %129, label %134

129:                                              ; preds = %125
  %130 = load ptr, ptr %20, align 8, !tbaa !5
  %131 = load i32, ptr %130, align 4, !tbaa !9
  %132 = sub nsw i32 0, %131
  store i32 %132, ptr %25, align 4, !tbaa !9
  %133 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %25, i32 noundef 7)
  store i32 1, ptr %43, align 4
  br label %1269

134:                                              ; preds = %125
  %135 = load ptr, ptr %12, align 8, !tbaa !5
  %136 = load i32, ptr %135, align 4, !tbaa !9
  %137 = icmp eq i32 %136, 0
  br i1 %137, label %142, label %138

138:                                              ; preds = %134
  %139 = load ptr, ptr %13, align 8, !tbaa !5
  %140 = load i32, ptr %139, align 4, !tbaa !9
  %141 = icmp eq i32 %140, 0
  br i1 %141, label %142, label %143

142:                                              ; preds = %138, %134
  store i32 1, ptr %43, align 4
  br label %1269

143:                                              ; preds = %138
  %144 = load ptr, ptr %11, align 8, !tbaa !5
  %145 = load ptr, ptr %12, align 8, !tbaa !5
  %146 = load ptr, ptr %14, align 8, !tbaa !5
  %147 = load i32, ptr %22, align 4, !tbaa !9
  %148 = sext i32 %147 to i64
  %149 = getelementptr inbounds %struct.doublecomplex, ptr %146, i64 %148
  %150 = load ptr, ptr %15, align 8, !tbaa !5
  %151 = load ptr, ptr %16, align 8, !tbaa !5
  %152 = getelementptr inbounds i32, ptr %151, i64 1
  %153 = load ptr, ptr %19, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.doublecomplex, ptr %153, i64 1
  call void @zsyconv_(ptr noundef %144, ptr noundef @.str.3, ptr noundef %145, ptr noundef %149, ptr noundef %150, ptr noundef %152, ptr noundef %154, ptr noundef %36)
  %155 = load i32, ptr %37, align 4, !tbaa !9
  %156 = icmp ne i32 %155, 0
  br i1 %156, label %157, label %717

157:                                              ; preds = %143
  %158 = load ptr, ptr %12, align 8, !tbaa !5
  %159 = load i32, ptr %158, align 4, !tbaa !9
  store i32 %159, ptr %33, align 4, !tbaa !9
  br label %160

160:                                              ; preds = %234, %157
  %161 = load i32, ptr %33, align 4, !tbaa !9
  %162 = icmp sge i32 %161, 1
  br i1 %162, label %163, label %235

163:                                              ; preds = %160
  %164 = load ptr, ptr %16, align 8, !tbaa !5
  %165 = load i32, ptr %33, align 4, !tbaa !9
  %166 = sext i32 %165 to i64
  %167 = getelementptr inbounds i32, ptr %164, i64 %166
  %168 = load i32, ptr %167, align 4, !tbaa !9
  %169 = icmp sgt i32 %168, 0
  br i1 %169, label %170, label %198

170:                                              ; preds = %163
  %171 = load ptr, ptr %16, align 8, !tbaa !5
  %172 = load i32, ptr %33, align 4, !tbaa !9
  %173 = sext i32 %172 to i64
  %174 = getelementptr inbounds i32, ptr %171, i64 %173
  %175 = load i32, ptr %174, align 4, !tbaa !9
  store i32 %175, ptr %40, align 4, !tbaa !9
  %176 = load i32, ptr %40, align 4, !tbaa !9
  %177 = load i32, ptr %33, align 4, !tbaa !9
  %178 = icmp ne i32 %176, %177
  br i1 %178, label %179, label %195

179:                                              ; preds = %170
  %180 = load ptr, ptr %13, align 8, !tbaa !5
  %181 = load ptr, ptr %17, align 8, !tbaa !5
  %182 = load i32, ptr %33, align 4, !tbaa !9
  %183 = load i32, ptr %23, align 4, !tbaa !9
  %184 = add nsw i32 %182, %183
  %185 = sext i32 %184 to i64
  %186 = getelementptr inbounds %struct.doublecomplex, ptr %181, i64 %185
  %187 = load ptr, ptr %18, align 8, !tbaa !5
  %188 = load ptr, ptr %17, align 8, !tbaa !5
  %189 = load i32, ptr %40, align 4, !tbaa !9
  %190 = load i32, ptr %23, align 4, !tbaa !9
  %191 = add nsw i32 %189, %190
  %192 = sext i32 %191 to i64
  %193 = getelementptr inbounds %struct.doublecomplex, ptr %188, i64 %192
  %194 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %180, ptr noundef %186, ptr noundef %187, ptr noundef %193, ptr noundef %194)
  br label %195

195:                                              ; preds = %179, %170
  %196 = load i32, ptr %33, align 4, !tbaa !9
  %197 = add nsw i32 %196, -1
  store i32 %197, ptr %33, align 4, !tbaa !9
  br label %234

198:                                              ; preds = %163
  %199 = load ptr, ptr %16, align 8, !tbaa !5
  %200 = load i32, ptr %33, align 4, !tbaa !9
  %201 = sext i32 %200 to i64
  %202 = getelementptr inbounds i32, ptr %199, i64 %201
  %203 = load i32, ptr %202, align 4, !tbaa !9
  %204 = sub nsw i32 0, %203
  store i32 %204, ptr %40, align 4, !tbaa !9
  %205 = load i32, ptr %40, align 4, !tbaa !9
  %206 = load ptr, ptr %16, align 8, !tbaa !5
  %207 = load i32, ptr %33, align 4, !tbaa !9
  %208 = sub nsw i32 %207, 1
  %209 = sext i32 %208 to i64
  %210 = getelementptr inbounds i32, ptr %206, i64 %209
  %211 = load i32, ptr %210, align 4, !tbaa !9
  %212 = sub nsw i32 0, %211
  %213 = icmp eq i32 %205, %212
  br i1 %213, label %214, label %231

214:                                              ; preds = %198
  %215 = load ptr, ptr %13, align 8, !tbaa !5
  %216 = load ptr, ptr %17, align 8, !tbaa !5
  %217 = load i32, ptr %33, align 4, !tbaa !9
  %218 = sub nsw i32 %217, 1
  %219 = load i32, ptr %23, align 4, !tbaa !9
  %220 = add nsw i32 %218, %219
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds %struct.doublecomplex, ptr %216, i64 %221
  %223 = load ptr, ptr %18, align 8, !tbaa !5
  %224 = load ptr, ptr %17, align 8, !tbaa !5
  %225 = load i32, ptr %40, align 4, !tbaa !9
  %226 = load i32, ptr %23, align 4, !tbaa !9
  %227 = add nsw i32 %225, %226
  %228 = sext i32 %227 to i64
  %229 = getelementptr inbounds %struct.doublecomplex, ptr %224, i64 %228
  %230 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %215, ptr noundef %222, ptr noundef %223, ptr noundef %229, ptr noundef %230)
  br label %231

231:                                              ; preds = %214, %198
  %232 = load i32, ptr %33, align 4, !tbaa !9
  %233 = add nsw i32 %232, -2
  store i32 %233, ptr %33, align 4, !tbaa !9
  br label %234

234:                                              ; preds = %231, %195
  br label %160, !llvm.loop !11

235:                                              ; preds = %160
  %236 = load ptr, ptr %12, align 8, !tbaa !5
  %237 = load ptr, ptr %13, align 8, !tbaa !5
  %238 = load ptr, ptr %14, align 8, !tbaa !5
  %239 = load i32, ptr %22, align 4, !tbaa !9
  %240 = sext i32 %239 to i64
  %241 = getelementptr inbounds %struct.doublecomplex, ptr %238, i64 %240
  %242 = load ptr, ptr %15, align 8, !tbaa !5
  %243 = load ptr, ptr %17, align 8, !tbaa !5
  %244 = load i32, ptr %24, align 4, !tbaa !9
  %245 = sext i32 %244 to i64
  %246 = getelementptr inbounds %struct.doublecomplex, ptr %243, i64 %245
  %247 = load ptr, ptr %18, align 8, !tbaa !5
  call void @ztrsm_(ptr noundef @.str.1, ptr noundef @.str, ptr noundef @.str.4, ptr noundef @.str, ptr noundef %236, ptr noundef %237, ptr noundef @c_b1, ptr noundef %241, ptr noundef %242, ptr noundef %246, ptr noundef %247)
  %248 = load ptr, ptr %12, align 8, !tbaa !5
  %249 = load i32, ptr %248, align 4, !tbaa !9
  store i32 %249, ptr %31, align 4, !tbaa !9
  br label %250

250:                                              ; preds = %619, %235
  %251 = load i32, ptr %31, align 4, !tbaa !9
  %252 = icmp sge i32 %251, 1
  br i1 %252, label %253, label %622

253:                                              ; preds = %250
  %254 = load ptr, ptr %16, align 8, !tbaa !5
  %255 = load i32, ptr %31, align 4, !tbaa !9
  %256 = sext i32 %255 to i64
  %257 = getelementptr inbounds i32, ptr %254, i64 %256
  %258 = load i32, ptr %257, align 4, !tbaa !9
  %259 = icmp sgt i32 %258, 0
  br i1 %259, label %260, label %281

260:                                              ; preds = %253
  %261 = load i32, ptr %31, align 4, !tbaa !9
  %262 = load i32, ptr %31, align 4, !tbaa !9
  %263 = load i32, ptr %21, align 4, !tbaa !9
  %264 = mul nsw i32 %262, %263
  %265 = add nsw i32 %261, %264
  store i32 %265, ptr %25, align 4, !tbaa !9
  %266 = load ptr, ptr %14, align 8, !tbaa !5
  %267 = load i32, ptr %25, align 4, !tbaa !9
  %268 = sext i32 %267 to i64
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %266, i64 %268
  %270 = getelementptr inbounds %struct.doublecomplex, ptr %269, i32 0, i32 0
  %271 = load double, ptr %270, align 8, !tbaa !13
  %272 = fdiv double 1.000000e+00, %271
  store double %272, ptr %34, align 8, !tbaa !16
  %273 = load ptr, ptr %13, align 8, !tbaa !5
  %274 = load ptr, ptr %17, align 8, !tbaa !5
  %275 = load i32, ptr %31, align 4, !tbaa !9
  %276 = load i32, ptr %23, align 4, !tbaa !9
  %277 = add nsw i32 %275, %276
  %278 = sext i32 %277 to i64
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %274, i64 %278
  %280 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zdscal_(ptr noundef %273, ptr noundef %34, ptr noundef %279, ptr noundef %280)
  br label %619

281:                                              ; preds = %253
  %282 = load i32, ptr %31, align 4, !tbaa !9
  %283 = icmp sgt i32 %282, 1
  br i1 %283, label %284, label %618

284:                                              ; preds = %281
  %285 = load ptr, ptr %16, align 8, !tbaa !5
  %286 = load i32, ptr %31, align 4, !tbaa !9
  %287 = sub nsw i32 %286, 1
  %288 = sext i32 %287 to i64
  %289 = getelementptr inbounds i32, ptr %285, i64 %288
  %290 = load i32, ptr %289, align 4, !tbaa !9
  %291 = load ptr, ptr %16, align 8, !tbaa !5
  %292 = load i32, ptr %31, align 4, !tbaa !9
  %293 = sext i32 %292 to i64
  %294 = getelementptr inbounds i32, ptr %291, i64 %293
  %295 = load i32, ptr %294, align 4, !tbaa !9
  %296 = icmp eq i32 %290, %295
  br i1 %296, label %297, label %617

297:                                              ; preds = %284
  %298 = load i32, ptr %31, align 4, !tbaa !9
  store i32 %298, ptr %25, align 4, !tbaa !9
  %299 = load ptr, ptr %19, align 8, !tbaa !5
  %300 = load i32, ptr %25, align 4, !tbaa !9
  %301 = sext i32 %300 to i64
  %302 = getelementptr inbounds %struct.doublecomplex, ptr %299, i64 %301
  %303 = getelementptr inbounds %struct.doublecomplex, ptr %302, i32 0, i32 0
  %304 = load double, ptr %303, align 8, !tbaa !13
  %305 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %304, ptr %305, align 8, !tbaa !13
  %306 = load ptr, ptr %19, align 8, !tbaa !5
  %307 = load i32, ptr %25, align 4, !tbaa !9
  %308 = sext i32 %307 to i64
  %309 = getelementptr inbounds %struct.doublecomplex, ptr %306, i64 %308
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %309, i32 0, i32 1
  %311 = load double, ptr %310, align 8, !tbaa !17
  %312 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %311, ptr %312, align 8, !tbaa !17
  %313 = load ptr, ptr %14, align 8, !tbaa !5
  %314 = load i32, ptr %31, align 4, !tbaa !9
  %315 = sub nsw i32 %314, 1
  %316 = load i32, ptr %31, align 4, !tbaa !9
  %317 = sub nsw i32 %316, 1
  %318 = load i32, ptr %21, align 4, !tbaa !9
  %319 = mul nsw i32 %317, %318
  %320 = add nsw i32 %315, %319
  %321 = sext i32 %320 to i64
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %313, i64 %321
  %323 = call { double, double } @Cd(ptr noundef %322)
  %324 = extractvalue { double, double } %323, 0
  %325 = extractvalue { double, double } %323, 1
  %326 = call { double, double } @Cd(ptr noundef %30)
  %327 = extractvalue { double, double } %326, 0
  %328 = extractvalue { double, double } %326, 1
  %329 = call { double, double } @__divdc3(double noundef %324, double noundef %325, double noundef %327, double noundef %328) #5
  %330 = extractvalue { double, double } %329, 0
  %331 = extractvalue { double, double } %329, 1
  %332 = call ptr @_pCd(ptr noundef %27)
  %333 = getelementptr inbounds { double, double }, ptr %332, i32 0, i32 0
  %334 = getelementptr inbounds { double, double }, ptr %332, i32 0, i32 1
  store double %330, ptr %333, align 8
  store double %331, ptr %334, align 8
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %336 = load double, ptr %335, align 8, !tbaa !13
  %337 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %336, ptr %337, align 8, !tbaa !13
  %338 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %339 = load double, ptr %338, align 8, !tbaa !17
  %340 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %339, ptr %340, align 8, !tbaa !17
  %341 = call { double, double } @Cd(ptr noundef %30)
  %342 = extractvalue { double, double } %341, 0
  %343 = extractvalue { double, double } %341, 1
  %344 = fneg double %343
  %345 = call ptr @_pCd(ptr noundef %28)
  %346 = getelementptr inbounds { double, double }, ptr %345, i32 0, i32 0
  %347 = getelementptr inbounds { double, double }, ptr %345, i32 0, i32 1
  store double %342, ptr %346, align 8
  store double %344, ptr %347, align 8
  %348 = load ptr, ptr %14, align 8, !tbaa !5
  %349 = load i32, ptr %31, align 4, !tbaa !9
  %350 = load i32, ptr %31, align 4, !tbaa !9
  %351 = load i32, ptr %21, align 4, !tbaa !9
  %352 = mul nsw i32 %350, %351
  %353 = add nsw i32 %349, %352
  %354 = sext i32 %353 to i64
  %355 = getelementptr inbounds %struct.doublecomplex, ptr %348, i64 %354
  %356 = call { double, double } @Cd(ptr noundef %355)
  %357 = extractvalue { double, double } %356, 0
  %358 = extractvalue { double, double } %356, 1
  %359 = call { double, double } @Cd(ptr noundef %28)
  %360 = extractvalue { double, double } %359, 0
  %361 = extractvalue { double, double } %359, 1
  %362 = call { double, double } @__divdc3(double noundef %357, double noundef %358, double noundef %360, double noundef %361) #5
  %363 = extractvalue { double, double } %362, 0
  %364 = extractvalue { double, double } %362, 1
  %365 = call ptr @_pCd(ptr noundef %27)
  %366 = getelementptr inbounds { double, double }, ptr %365, i32 0, i32 0
  %367 = getelementptr inbounds { double, double }, ptr %365, i32 0, i32 1
  store double %363, ptr %366, align 8
  store double %364, ptr %367, align 8
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %369 = load double, ptr %368, align 8, !tbaa !13
  %370 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  store double %369, ptr %370, align 8, !tbaa !13
  %371 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %372 = load double, ptr %371, align 8, !tbaa !17
  %373 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  store double %372, ptr %373, align 8, !tbaa !17
  %374 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %375 = load double, ptr %374, align 8, !tbaa !13
  %376 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %377 = load double, ptr %376, align 8, !tbaa !13
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %379 = load double, ptr %378, align 8, !tbaa !17
  %380 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %381 = load double, ptr %380, align 8, !tbaa !17
  %382 = fmul double %379, %381
  %383 = fneg double %382
  %384 = call double @llvm.fmuladd.f64(double %375, double %377, double %383)
  %385 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %384, ptr %385, align 8, !tbaa !13
  %386 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %387 = load double, ptr %386, align 8, !tbaa !13
  %388 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %389 = load double, ptr %388, align 8, !tbaa !17
  %390 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %391 = load double, ptr %390, align 8, !tbaa !17
  %392 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %393 = load double, ptr %392, align 8, !tbaa !13
  %394 = fmul double %391, %393
  %395 = call double @llvm.fmuladd.f64(double %387, double %389, double %394)
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %395, ptr %396, align 8, !tbaa !17
  %397 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %398 = load double, ptr %397, align 8, !tbaa !13
  %399 = fsub double %398, 1.000000e+00
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %399, ptr %400, align 8, !tbaa !13
  %401 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %402 = load double, ptr %401, align 8, !tbaa !17
  %403 = fadd double %402, 0.000000e+00
  %404 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %403, ptr %404, align 8, !tbaa !17
  %405 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %406 = load double, ptr %405, align 8, !tbaa !13
  %407 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %406, ptr %407, align 8, !tbaa !13
  %408 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %409 = load double, ptr %408, align 8, !tbaa !17
  %410 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %409, ptr %410, align 8, !tbaa !17
  %411 = load ptr, ptr %13, align 8, !tbaa !5
  %412 = load i32, ptr %411, align 4, !tbaa !9
  store i32 %412, ptr %25, align 4, !tbaa !9
  store i32 1, ptr %32, align 4, !tbaa !9
  br label %413

413:                                              ; preds = %611, %297
  %414 = load i32, ptr %32, align 4, !tbaa !9
  %415 = load i32, ptr %25, align 4, !tbaa !9
  %416 = icmp sle i32 %414, %415
  br i1 %416, label %417, label %614

417:                                              ; preds = %413
  %418 = load ptr, ptr %17, align 8, !tbaa !5
  %419 = load i32, ptr %31, align 4, !tbaa !9
  %420 = sub nsw i32 %419, 1
  %421 = load i32, ptr %32, align 4, !tbaa !9
  %422 = load i32, ptr %23, align 4, !tbaa !9
  %423 = mul nsw i32 %421, %422
  %424 = add nsw i32 %420, %423
  %425 = sext i32 %424 to i64
  %426 = getelementptr inbounds %struct.doublecomplex, ptr %418, i64 %425
  %427 = call { double, double } @Cd(ptr noundef %426)
  %428 = extractvalue { double, double } %427, 0
  %429 = extractvalue { double, double } %427, 1
  %430 = call { double, double } @Cd(ptr noundef %30)
  %431 = extractvalue { double, double } %430, 0
  %432 = extractvalue { double, double } %430, 1
  %433 = call { double, double } @__divdc3(double noundef %428, double noundef %429, double noundef %431, double noundef %432) #5
  %434 = extractvalue { double, double } %433, 0
  %435 = extractvalue { double, double } %433, 1
  %436 = call ptr @_pCd(ptr noundef %27)
  %437 = getelementptr inbounds { double, double }, ptr %436, i32 0, i32 0
  %438 = getelementptr inbounds { double, double }, ptr %436, i32 0, i32 1
  store double %434, ptr %437, align 8
  store double %435, ptr %438, align 8
  %439 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %440 = load double, ptr %439, align 8, !tbaa !13
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %440, ptr %441, align 8, !tbaa !13
  %442 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %443 = load double, ptr %442, align 8, !tbaa !17
  %444 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %443, ptr %444, align 8, !tbaa !17
  %445 = call { double, double } @Cd(ptr noundef %30)
  %446 = extractvalue { double, double } %445, 0
  %447 = extractvalue { double, double } %445, 1
  %448 = fneg double %447
  %449 = call ptr @_pCd(ptr noundef %28)
  %450 = getelementptr inbounds { double, double }, ptr %449, i32 0, i32 0
  %451 = getelementptr inbounds { double, double }, ptr %449, i32 0, i32 1
  store double %446, ptr %450, align 8
  store double %448, ptr %451, align 8
  %452 = load ptr, ptr %17, align 8, !tbaa !5
  %453 = load i32, ptr %31, align 4, !tbaa !9
  %454 = load i32, ptr %32, align 4, !tbaa !9
  %455 = load i32, ptr %23, align 4, !tbaa !9
  %456 = mul nsw i32 %454, %455
  %457 = add nsw i32 %453, %456
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %452, i64 %458
  %460 = call { double, double } @Cd(ptr noundef %459)
  %461 = extractvalue { double, double } %460, 0
  %462 = extractvalue { double, double } %460, 1
  %463 = call { double, double } @Cd(ptr noundef %28)
  %464 = extractvalue { double, double } %463, 0
  %465 = extractvalue { double, double } %463, 1
  %466 = call { double, double } @__divdc3(double noundef %461, double noundef %462, double noundef %464, double noundef %465) #5
  %467 = extractvalue { double, double } %466, 0
  %468 = extractvalue { double, double } %466, 1
  %469 = call ptr @_pCd(ptr noundef %27)
  %470 = getelementptr inbounds { double, double }, ptr %469, i32 0, i32 0
  %471 = getelementptr inbounds { double, double }, ptr %469, i32 0, i32 1
  store double %467, ptr %470, align 8
  store double %468, ptr %471, align 8
  %472 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %473 = load double, ptr %472, align 8, !tbaa !13
  %474 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %473, ptr %474, align 8, !tbaa !13
  %475 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %476 = load double, ptr %475, align 8, !tbaa !17
  %477 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %476, ptr %477, align 8, !tbaa !17
  %478 = load i32, ptr %31, align 4, !tbaa !9
  %479 = sub nsw i32 %478, 1
  %480 = load i32, ptr %32, align 4, !tbaa !9
  %481 = load i32, ptr %23, align 4, !tbaa !9
  %482 = mul nsw i32 %480, %481
  %483 = add nsw i32 %479, %482
  store i32 %483, ptr %26, align 4, !tbaa !9
  %484 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %485 = load double, ptr %484, align 8, !tbaa !13
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %487 = load double, ptr %486, align 8, !tbaa !13
  %488 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %489 = load double, ptr %488, align 8, !tbaa !17
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %491 = load double, ptr %490, align 8, !tbaa !17
  %492 = fmul double %489, %491
  %493 = fneg double %492
  %494 = call double @llvm.fmuladd.f64(double %485, double %487, double %493)
  %495 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %494, ptr %495, align 8, !tbaa !13
  %496 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %497 = load double, ptr %496, align 8, !tbaa !13
  %498 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %499 = load double, ptr %498, align 8, !tbaa !17
  %500 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %501 = load double, ptr %500, align 8, !tbaa !17
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %503 = load double, ptr %502, align 8, !tbaa !13
  %504 = fmul double %501, %503
  %505 = call double @llvm.fmuladd.f64(double %497, double %499, double %504)
  %506 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %505, ptr %506, align 8, !tbaa !17
  %507 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %508 = load double, ptr %507, align 8, !tbaa !13
  %509 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %510 = load double, ptr %509, align 8, !tbaa !13
  %511 = fsub double %508, %510
  %512 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %511, ptr %512, align 8, !tbaa !13
  %513 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %514 = load double, ptr %513, align 8, !tbaa !17
  %515 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %516 = load double, ptr %515, align 8, !tbaa !17
  %517 = fsub double %514, %516
  %518 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %517, ptr %518, align 8, !tbaa !17
  %519 = call { double, double } @Cd(ptr noundef %28)
  %520 = extractvalue { double, double } %519, 0
  %521 = extractvalue { double, double } %519, 1
  %522 = call { double, double } @Cd(ptr noundef %35)
  %523 = extractvalue { double, double } %522, 0
  %524 = extractvalue { double, double } %522, 1
  %525 = call { double, double } @__divdc3(double noundef %520, double noundef %521, double noundef %523, double noundef %524) #5
  %526 = extractvalue { double, double } %525, 0
  %527 = extractvalue { double, double } %525, 1
  %528 = call ptr @_pCd(ptr noundef %27)
  %529 = getelementptr inbounds { double, double }, ptr %528, i32 0, i32 0
  %530 = getelementptr inbounds { double, double }, ptr %528, i32 0, i32 1
  store double %526, ptr %529, align 8
  store double %527, ptr %530, align 8
  %531 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %532 = load double, ptr %531, align 8, !tbaa !13
  %533 = load ptr, ptr %17, align 8, !tbaa !5
  %534 = load i32, ptr %26, align 4, !tbaa !9
  %535 = sext i32 %534 to i64
  %536 = getelementptr inbounds %struct.doublecomplex, ptr %533, i64 %535
  %537 = getelementptr inbounds %struct.doublecomplex, ptr %536, i32 0, i32 0
  store double %532, ptr %537, align 8, !tbaa !13
  %538 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %539 = load double, ptr %538, align 8, !tbaa !17
  %540 = load ptr, ptr %17, align 8, !tbaa !5
  %541 = load i32, ptr %26, align 4, !tbaa !9
  %542 = sext i32 %541 to i64
  %543 = getelementptr inbounds %struct.doublecomplex, ptr %540, i64 %542
  %544 = getelementptr inbounds %struct.doublecomplex, ptr %543, i32 0, i32 1
  store double %539, ptr %544, align 8, !tbaa !17
  %545 = load i32, ptr %31, align 4, !tbaa !9
  %546 = load i32, ptr %32, align 4, !tbaa !9
  %547 = load i32, ptr %23, align 4, !tbaa !9
  %548 = mul nsw i32 %546, %547
  %549 = add nsw i32 %545, %548
  store i32 %549, ptr %26, align 4, !tbaa !9
  %550 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %551 = load double, ptr %550, align 8, !tbaa !13
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %553 = load double, ptr %552, align 8, !tbaa !13
  %554 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %555 = load double, ptr %554, align 8, !tbaa !17
  %556 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %557 = load double, ptr %556, align 8, !tbaa !17
  %558 = fmul double %555, %557
  %559 = fneg double %558
  %560 = call double @llvm.fmuladd.f64(double %551, double %553, double %559)
  %561 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %560, ptr %561, align 8, !tbaa !13
  %562 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %563 = load double, ptr %562, align 8, !tbaa !13
  %564 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %565 = load double, ptr %564, align 8, !tbaa !17
  %566 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %567 = load double, ptr %566, align 8, !tbaa !17
  %568 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %569 = load double, ptr %568, align 8, !tbaa !13
  %570 = fmul double %567, %569
  %571 = call double @llvm.fmuladd.f64(double %563, double %565, double %570)
  %572 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %571, ptr %572, align 8, !tbaa !17
  %573 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %574 = load double, ptr %573, align 8, !tbaa !13
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %576 = load double, ptr %575, align 8, !tbaa !13
  %577 = fsub double %574, %576
  %578 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %577, ptr %578, align 8, !tbaa !13
  %579 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %580 = load double, ptr %579, align 8, !tbaa !17
  %581 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %582 = load double, ptr %581, align 8, !tbaa !17
  %583 = fsub double %580, %582
  %584 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %583, ptr %584, align 8, !tbaa !17
  %585 = call { double, double } @Cd(ptr noundef %28)
  %586 = extractvalue { double, double } %585, 0
  %587 = extractvalue { double, double } %585, 1
  %588 = call { double, double } @Cd(ptr noundef %35)
  %589 = extractvalue { double, double } %588, 0
  %590 = extractvalue { double, double } %588, 1
  %591 = call { double, double } @__divdc3(double noundef %586, double noundef %587, double noundef %589, double noundef %590) #5
  %592 = extractvalue { double, double } %591, 0
  %593 = extractvalue { double, double } %591, 1
  %594 = call ptr @_pCd(ptr noundef %27)
  %595 = getelementptr inbounds { double, double }, ptr %594, i32 0, i32 0
  %596 = getelementptr inbounds { double, double }, ptr %594, i32 0, i32 1
  store double %592, ptr %595, align 8
  store double %593, ptr %596, align 8
  %597 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %598 = load double, ptr %597, align 8, !tbaa !13
  %599 = load ptr, ptr %17, align 8, !tbaa !5
  %600 = load i32, ptr %26, align 4, !tbaa !9
  %601 = sext i32 %600 to i64
  %602 = getelementptr inbounds %struct.doublecomplex, ptr %599, i64 %601
  %603 = getelementptr inbounds %struct.doublecomplex, ptr %602, i32 0, i32 0
  store double %598, ptr %603, align 8, !tbaa !13
  %604 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %605 = load double, ptr %604, align 8, !tbaa !17
  %606 = load ptr, ptr %17, align 8, !tbaa !5
  %607 = load i32, ptr %26, align 4, !tbaa !9
  %608 = sext i32 %607 to i64
  %609 = getelementptr inbounds %struct.doublecomplex, ptr %606, i64 %608
  %610 = getelementptr inbounds %struct.doublecomplex, ptr %609, i32 0, i32 1
  store double %605, ptr %610, align 8, !tbaa !17
  br label %611

611:                                              ; preds = %417
  %612 = load i32, ptr %32, align 4, !tbaa !9
  %613 = add nsw i32 %612, 1
  store i32 %613, ptr %32, align 4, !tbaa !9
  br label %413, !llvm.loop !18

614:                                              ; preds = %413
  %615 = load i32, ptr %31, align 4, !tbaa !9
  %616 = add nsw i32 %615, -1
  store i32 %616, ptr %31, align 4, !tbaa !9
  br label %617

617:                                              ; preds = %614, %284
  br label %618

618:                                              ; preds = %617, %281
  br label %619

619:                                              ; preds = %618, %260
  %620 = load i32, ptr %31, align 4, !tbaa !9
  %621 = add nsw i32 %620, -1
  store i32 %621, ptr %31, align 4, !tbaa !9
  br label %250, !llvm.loop !19

622:                                              ; preds = %250
  %623 = load ptr, ptr %12, align 8, !tbaa !5
  %624 = load ptr, ptr %13, align 8, !tbaa !5
  %625 = load ptr, ptr %14, align 8, !tbaa !5
  %626 = load i32, ptr %22, align 4, !tbaa !9
  %627 = sext i32 %626 to i64
  %628 = getelementptr inbounds %struct.doublecomplex, ptr %625, i64 %627
  %629 = load ptr, ptr %15, align 8, !tbaa !5
  %630 = load ptr, ptr %17, align 8, !tbaa !5
  %631 = load i32, ptr %24, align 4, !tbaa !9
  %632 = sext i32 %631 to i64
  %633 = getelementptr inbounds %struct.doublecomplex, ptr %630, i64 %632
  %634 = load ptr, ptr %18, align 8, !tbaa !5
  call void @ztrsm_(ptr noundef @.str.1, ptr noundef @.str, ptr noundef @.str.3, ptr noundef @.str, ptr noundef %623, ptr noundef %624, ptr noundef @c_b1, ptr noundef %628, ptr noundef %629, ptr noundef %633, ptr noundef %634)
  store i32 1, ptr %33, align 4, !tbaa !9
  br label %635

635:                                              ; preds = %715, %622
  %636 = load i32, ptr %33, align 4, !tbaa !9
  %637 = load ptr, ptr %12, align 8, !tbaa !5
  %638 = load i32, ptr %637, align 4, !tbaa !9
  %639 = icmp sle i32 %636, %638
  br i1 %639, label %640, label %716

640:                                              ; preds = %635
  %641 = load ptr, ptr %16, align 8, !tbaa !5
  %642 = load i32, ptr %33, align 4, !tbaa !9
  %643 = sext i32 %642 to i64
  %644 = getelementptr inbounds i32, ptr %641, i64 %643
  %645 = load i32, ptr %644, align 4, !tbaa !9
  %646 = icmp sgt i32 %645, 0
  br i1 %646, label %647, label %675

647:                                              ; preds = %640
  %648 = load ptr, ptr %16, align 8, !tbaa !5
  %649 = load i32, ptr %33, align 4, !tbaa !9
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds i32, ptr %648, i64 %650
  %652 = load i32, ptr %651, align 4, !tbaa !9
  store i32 %652, ptr %40, align 4, !tbaa !9
  %653 = load i32, ptr %40, align 4, !tbaa !9
  %654 = load i32, ptr %33, align 4, !tbaa !9
  %655 = icmp ne i32 %653, %654
  br i1 %655, label %656, label %672

656:                                              ; preds = %647
  %657 = load ptr, ptr %13, align 8, !tbaa !5
  %658 = load ptr, ptr %17, align 8, !tbaa !5
  %659 = load i32, ptr %33, align 4, !tbaa !9
  %660 = load i32, ptr %23, align 4, !tbaa !9
  %661 = add nsw i32 %659, %660
  %662 = sext i32 %661 to i64
  %663 = getelementptr inbounds %struct.doublecomplex, ptr %658, i64 %662
  %664 = load ptr, ptr %18, align 8, !tbaa !5
  %665 = load ptr, ptr %17, align 8, !tbaa !5
  %666 = load i32, ptr %40, align 4, !tbaa !9
  %667 = load i32, ptr %23, align 4, !tbaa !9
  %668 = add nsw i32 %666, %667
  %669 = sext i32 %668 to i64
  %670 = getelementptr inbounds %struct.doublecomplex, ptr %665, i64 %669
  %671 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %657, ptr noundef %663, ptr noundef %664, ptr noundef %670, ptr noundef %671)
  br label %672

672:                                              ; preds = %656, %647
  %673 = load i32, ptr %33, align 4, !tbaa !9
  %674 = add nsw i32 %673, 1
  store i32 %674, ptr %33, align 4, !tbaa !9
  br label %715

675:                                              ; preds = %640
  %676 = load ptr, ptr %16, align 8, !tbaa !5
  %677 = load i32, ptr %33, align 4, !tbaa !9
  %678 = sext i32 %677 to i64
  %679 = getelementptr inbounds i32, ptr %676, i64 %678
  %680 = load i32, ptr %679, align 4, !tbaa !9
  %681 = sub nsw i32 0, %680
  store i32 %681, ptr %40, align 4, !tbaa !9
  %682 = load i32, ptr %33, align 4, !tbaa !9
  %683 = load ptr, ptr %12, align 8, !tbaa !5
  %684 = load i32, ptr %683, align 4, !tbaa !9
  %685 = icmp slt i32 %682, %684
  br i1 %685, label %686, label %712

686:                                              ; preds = %675
  %687 = load i32, ptr %40, align 4, !tbaa !9
  %688 = load ptr, ptr %16, align 8, !tbaa !5
  %689 = load i32, ptr %33, align 4, !tbaa !9
  %690 = add nsw i32 %689, 1
  %691 = sext i32 %690 to i64
  %692 = getelementptr inbounds i32, ptr %688, i64 %691
  %693 = load i32, ptr %692, align 4, !tbaa !9
  %694 = sub nsw i32 0, %693
  %695 = icmp eq i32 %687, %694
  br i1 %695, label %696, label %712

696:                                              ; preds = %686
  %697 = load ptr, ptr %13, align 8, !tbaa !5
  %698 = load ptr, ptr %17, align 8, !tbaa !5
  %699 = load i32, ptr %33, align 4, !tbaa !9
  %700 = load i32, ptr %23, align 4, !tbaa !9
  %701 = add nsw i32 %699, %700
  %702 = sext i32 %701 to i64
  %703 = getelementptr inbounds %struct.doublecomplex, ptr %698, i64 %702
  %704 = load ptr, ptr %18, align 8, !tbaa !5
  %705 = load ptr, ptr %17, align 8, !tbaa !5
  %706 = load i32, ptr %40, align 4, !tbaa !9
  %707 = load i32, ptr %23, align 4, !tbaa !9
  %708 = add nsw i32 %706, %707
  %709 = sext i32 %708 to i64
  %710 = getelementptr inbounds %struct.doublecomplex, ptr %705, i64 %709
  %711 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %697, ptr noundef %703, ptr noundef %704, ptr noundef %710, ptr noundef %711)
  br label %712

712:                                              ; preds = %696, %686, %675
  %713 = load i32, ptr %33, align 4, !tbaa !9
  %714 = add nsw i32 %713, 2
  store i32 %714, ptr %33, align 4, !tbaa !9
  br label %715

715:                                              ; preds = %712, %672
  br label %635, !llvm.loop !20

716:                                              ; preds = %635
  br label %1257

717:                                              ; preds = %143
  store i32 1, ptr %33, align 4, !tbaa !9
  br label %718

718:                                              ; preds = %794, %717
  %719 = load i32, ptr %33, align 4, !tbaa !9
  %720 = load ptr, ptr %12, align 8, !tbaa !5
  %721 = load i32, ptr %720, align 4, !tbaa !9
  %722 = icmp sle i32 %719, %721
  br i1 %722, label %723, label %795

723:                                              ; preds = %718
  %724 = load ptr, ptr %16, align 8, !tbaa !5
  %725 = load i32, ptr %33, align 4, !tbaa !9
  %726 = sext i32 %725 to i64
  %727 = getelementptr inbounds i32, ptr %724, i64 %726
  %728 = load i32, ptr %727, align 4, !tbaa !9
  %729 = icmp sgt i32 %728, 0
  br i1 %729, label %730, label %758

730:                                              ; preds = %723
  %731 = load ptr, ptr %16, align 8, !tbaa !5
  %732 = load i32, ptr %33, align 4, !tbaa !9
  %733 = sext i32 %732 to i64
  %734 = getelementptr inbounds i32, ptr %731, i64 %733
  %735 = load i32, ptr %734, align 4, !tbaa !9
  store i32 %735, ptr %40, align 4, !tbaa !9
  %736 = load i32, ptr %40, align 4, !tbaa !9
  %737 = load i32, ptr %33, align 4, !tbaa !9
  %738 = icmp ne i32 %736, %737
  br i1 %738, label %739, label %755

739:                                              ; preds = %730
  %740 = load ptr, ptr %13, align 8, !tbaa !5
  %741 = load ptr, ptr %17, align 8, !tbaa !5
  %742 = load i32, ptr %33, align 4, !tbaa !9
  %743 = load i32, ptr %23, align 4, !tbaa !9
  %744 = add nsw i32 %742, %743
  %745 = sext i32 %744 to i64
  %746 = getelementptr inbounds %struct.doublecomplex, ptr %741, i64 %745
  %747 = load ptr, ptr %18, align 8, !tbaa !5
  %748 = load ptr, ptr %17, align 8, !tbaa !5
  %749 = load i32, ptr %40, align 4, !tbaa !9
  %750 = load i32, ptr %23, align 4, !tbaa !9
  %751 = add nsw i32 %749, %750
  %752 = sext i32 %751 to i64
  %753 = getelementptr inbounds %struct.doublecomplex, ptr %748, i64 %752
  %754 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %740, ptr noundef %746, ptr noundef %747, ptr noundef %753, ptr noundef %754)
  br label %755

755:                                              ; preds = %739, %730
  %756 = load i32, ptr %33, align 4, !tbaa !9
  %757 = add nsw i32 %756, 1
  store i32 %757, ptr %33, align 4, !tbaa !9
  br label %794

758:                                              ; preds = %723
  %759 = load ptr, ptr %16, align 8, !tbaa !5
  %760 = load i32, ptr %33, align 4, !tbaa !9
  %761 = add nsw i32 %760, 1
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds i32, ptr %759, i64 %762
  %764 = load i32, ptr %763, align 4, !tbaa !9
  %765 = sub nsw i32 0, %764
  store i32 %765, ptr %40, align 4, !tbaa !9
  %766 = load i32, ptr %40, align 4, !tbaa !9
  %767 = load ptr, ptr %16, align 8, !tbaa !5
  %768 = load i32, ptr %33, align 4, !tbaa !9
  %769 = sext i32 %768 to i64
  %770 = getelementptr inbounds i32, ptr %767, i64 %769
  %771 = load i32, ptr %770, align 4, !tbaa !9
  %772 = sub nsw i32 0, %771
  %773 = icmp eq i32 %766, %772
  br i1 %773, label %774, label %791

774:                                              ; preds = %758
  %775 = load ptr, ptr %13, align 8, !tbaa !5
  %776 = load ptr, ptr %17, align 8, !tbaa !5
  %777 = load i32, ptr %33, align 4, !tbaa !9
  %778 = add nsw i32 %777, 1
  %779 = load i32, ptr %23, align 4, !tbaa !9
  %780 = add nsw i32 %778, %779
  %781 = sext i32 %780 to i64
  %782 = getelementptr inbounds %struct.doublecomplex, ptr %776, i64 %781
  %783 = load ptr, ptr %18, align 8, !tbaa !5
  %784 = load ptr, ptr %17, align 8, !tbaa !5
  %785 = load i32, ptr %40, align 4, !tbaa !9
  %786 = load i32, ptr %23, align 4, !tbaa !9
  %787 = add nsw i32 %785, %786
  %788 = sext i32 %787 to i64
  %789 = getelementptr inbounds %struct.doublecomplex, ptr %784, i64 %788
  %790 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %775, ptr noundef %782, ptr noundef %783, ptr noundef %789, ptr noundef %790)
  br label %791

791:                                              ; preds = %774, %758
  %792 = load i32, ptr %33, align 4, !tbaa !9
  %793 = add nsw i32 %792, 2
  store i32 %793, ptr %33, align 4, !tbaa !9
  br label %794

794:                                              ; preds = %791, %755
  br label %718, !llvm.loop !21

795:                                              ; preds = %718
  %796 = load ptr, ptr %12, align 8, !tbaa !5
  %797 = load ptr, ptr %13, align 8, !tbaa !5
  %798 = load ptr, ptr %14, align 8, !tbaa !5
  %799 = load i32, ptr %22, align 4, !tbaa !9
  %800 = sext i32 %799 to i64
  %801 = getelementptr inbounds %struct.doublecomplex, ptr %798, i64 %800
  %802 = load ptr, ptr %15, align 8, !tbaa !5
  %803 = load ptr, ptr %17, align 8, !tbaa !5
  %804 = load i32, ptr %24, align 4, !tbaa !9
  %805 = sext i32 %804 to i64
  %806 = getelementptr inbounds %struct.doublecomplex, ptr %803, i64 %805
  %807 = load ptr, ptr %18, align 8, !tbaa !5
  call void @ztrsm_(ptr noundef @.str.1, ptr noundef @.str.1, ptr noundef @.str.4, ptr noundef @.str, ptr noundef %796, ptr noundef %797, ptr noundef @c_b1, ptr noundef %801, ptr noundef %802, ptr noundef %806, ptr noundef %807)
  store i32 1, ptr %31, align 4, !tbaa !9
  br label %808

808:                                              ; preds = %1161, %795
  %809 = load i32, ptr %31, align 4, !tbaa !9
  %810 = load ptr, ptr %12, align 8, !tbaa !5
  %811 = load i32, ptr %810, align 4, !tbaa !9
  %812 = icmp sle i32 %809, %811
  br i1 %812, label %813, label %1164

813:                                              ; preds = %808
  %814 = load ptr, ptr %16, align 8, !tbaa !5
  %815 = load i32, ptr %31, align 4, !tbaa !9
  %816 = sext i32 %815 to i64
  %817 = getelementptr inbounds i32, ptr %814, i64 %816
  %818 = load i32, ptr %817, align 4, !tbaa !9
  %819 = icmp sgt i32 %818, 0
  br i1 %819, label %820, label %841

820:                                              ; preds = %813
  %821 = load i32, ptr %31, align 4, !tbaa !9
  %822 = load i32, ptr %31, align 4, !tbaa !9
  %823 = load i32, ptr %21, align 4, !tbaa !9
  %824 = mul nsw i32 %822, %823
  %825 = add nsw i32 %821, %824
  store i32 %825, ptr %25, align 4, !tbaa !9
  %826 = load ptr, ptr %14, align 8, !tbaa !5
  %827 = load i32, ptr %25, align 4, !tbaa !9
  %828 = sext i32 %827 to i64
  %829 = getelementptr inbounds %struct.doublecomplex, ptr %826, i64 %828
  %830 = getelementptr inbounds %struct.doublecomplex, ptr %829, i32 0, i32 0
  %831 = load double, ptr %830, align 8, !tbaa !13
  %832 = fdiv double 1.000000e+00, %831
  store double %832, ptr %34, align 8, !tbaa !16
  %833 = load ptr, ptr %13, align 8, !tbaa !5
  %834 = load ptr, ptr %17, align 8, !tbaa !5
  %835 = load i32, ptr %31, align 4, !tbaa !9
  %836 = load i32, ptr %23, align 4, !tbaa !9
  %837 = add nsw i32 %835, %836
  %838 = sext i32 %837 to i64
  %839 = getelementptr inbounds %struct.doublecomplex, ptr %834, i64 %838
  %840 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zdscal_(ptr noundef %833, ptr noundef %34, ptr noundef %839, ptr noundef %840)
  br label %1161

841:                                              ; preds = %813
  %842 = load i32, ptr %31, align 4, !tbaa !9
  store i32 %842, ptr %25, align 4, !tbaa !9
  %843 = load ptr, ptr %19, align 8, !tbaa !5
  %844 = load i32, ptr %25, align 4, !tbaa !9
  %845 = sext i32 %844 to i64
  %846 = getelementptr inbounds %struct.doublecomplex, ptr %843, i64 %845
  %847 = getelementptr inbounds %struct.doublecomplex, ptr %846, i32 0, i32 0
  %848 = load double, ptr %847, align 8, !tbaa !13
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %848, ptr %849, align 8, !tbaa !13
  %850 = load ptr, ptr %19, align 8, !tbaa !5
  %851 = load i32, ptr %25, align 4, !tbaa !9
  %852 = sext i32 %851 to i64
  %853 = getelementptr inbounds %struct.doublecomplex, ptr %850, i64 %852
  %854 = getelementptr inbounds %struct.doublecomplex, ptr %853, i32 0, i32 1
  %855 = load double, ptr %854, align 8, !tbaa !17
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %855, ptr %856, align 8, !tbaa !17
  %857 = call { double, double } @Cd(ptr noundef %30)
  %858 = extractvalue { double, double } %857, 0
  %859 = extractvalue { double, double } %857, 1
  %860 = fneg double %859
  %861 = call ptr @_pCd(ptr noundef %28)
  %862 = getelementptr inbounds { double, double }, ptr %861, i32 0, i32 0
  %863 = getelementptr inbounds { double, double }, ptr %861, i32 0, i32 1
  store double %858, ptr %862, align 8
  store double %860, ptr %863, align 8
  %864 = load ptr, ptr %14, align 8, !tbaa !5
  %865 = load i32, ptr %31, align 4, !tbaa !9
  %866 = load i32, ptr %31, align 4, !tbaa !9
  %867 = load i32, ptr %21, align 4, !tbaa !9
  %868 = mul nsw i32 %866, %867
  %869 = add nsw i32 %865, %868
  %870 = sext i32 %869 to i64
  %871 = getelementptr inbounds %struct.doublecomplex, ptr %864, i64 %870
  %872 = call { double, double } @Cd(ptr noundef %871)
  %873 = extractvalue { double, double } %872, 0
  %874 = extractvalue { double, double } %872, 1
  %875 = call { double, double } @Cd(ptr noundef %28)
  %876 = extractvalue { double, double } %875, 0
  %877 = extractvalue { double, double } %875, 1
  %878 = call { double, double } @__divdc3(double noundef %873, double noundef %874, double noundef %876, double noundef %877) #5
  %879 = extractvalue { double, double } %878, 0
  %880 = extractvalue { double, double } %878, 1
  %881 = call ptr @_pCd(ptr noundef %27)
  %882 = getelementptr inbounds { double, double }, ptr %881, i32 0, i32 0
  %883 = getelementptr inbounds { double, double }, ptr %881, i32 0, i32 1
  store double %879, ptr %882, align 8
  store double %880, ptr %883, align 8
  %884 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %885 = load double, ptr %884, align 8, !tbaa !13
  %886 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %885, ptr %886, align 8, !tbaa !13
  %887 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %888 = load double, ptr %887, align 8, !tbaa !17
  %889 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %888, ptr %889, align 8, !tbaa !17
  %890 = load ptr, ptr %14, align 8, !tbaa !5
  %891 = load i32, ptr %31, align 4, !tbaa !9
  %892 = add nsw i32 %891, 1
  %893 = load i32, ptr %31, align 4, !tbaa !9
  %894 = add nsw i32 %893, 1
  %895 = load i32, ptr %21, align 4, !tbaa !9
  %896 = mul nsw i32 %894, %895
  %897 = add nsw i32 %892, %896
  %898 = sext i32 %897 to i64
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %890, i64 %898
  %900 = call { double, double } @Cd(ptr noundef %899)
  %901 = extractvalue { double, double } %900, 0
  %902 = extractvalue { double, double } %900, 1
  %903 = call { double, double } @Cd(ptr noundef %30)
  %904 = extractvalue { double, double } %903, 0
  %905 = extractvalue { double, double } %903, 1
  %906 = call { double, double } @__divdc3(double noundef %901, double noundef %902, double noundef %904, double noundef %905) #5
  %907 = extractvalue { double, double } %906, 0
  %908 = extractvalue { double, double } %906, 1
  %909 = call ptr @_pCd(ptr noundef %27)
  %910 = getelementptr inbounds { double, double }, ptr %909, i32 0, i32 0
  %911 = getelementptr inbounds { double, double }, ptr %909, i32 0, i32 1
  store double %907, ptr %910, align 8
  store double %908, ptr %911, align 8
  %912 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %913 = load double, ptr %912, align 8, !tbaa !13
  %914 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  store double %913, ptr %914, align 8, !tbaa !13
  %915 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %916 = load double, ptr %915, align 8, !tbaa !17
  %917 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  store double %916, ptr %917, align 8, !tbaa !17
  %918 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %919 = load double, ptr %918, align 8, !tbaa !13
  %920 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %921 = load double, ptr %920, align 8, !tbaa !13
  %922 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %923 = load double, ptr %922, align 8, !tbaa !17
  %924 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %925 = load double, ptr %924, align 8, !tbaa !17
  %926 = fmul double %923, %925
  %927 = fneg double %926
  %928 = call double @llvm.fmuladd.f64(double %919, double %921, double %927)
  %929 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %928, ptr %929, align 8, !tbaa !13
  %930 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %931 = load double, ptr %930, align 8, !tbaa !13
  %932 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %933 = load double, ptr %932, align 8, !tbaa !17
  %934 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %935 = load double, ptr %934, align 8, !tbaa !17
  %936 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %937 = load double, ptr %936, align 8, !tbaa !13
  %938 = fmul double %935, %937
  %939 = call double @llvm.fmuladd.f64(double %931, double %933, double %938)
  %940 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %939, ptr %940, align 8, !tbaa !17
  %941 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %942 = load double, ptr %941, align 8, !tbaa !13
  %943 = fsub double %942, 1.000000e+00
  %944 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %943, ptr %944, align 8, !tbaa !13
  %945 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %946 = load double, ptr %945, align 8, !tbaa !17
  %947 = fadd double %946, 0.000000e+00
  %948 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %947, ptr %948, align 8, !tbaa !17
  %949 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %950 = load double, ptr %949, align 8, !tbaa !13
  %951 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %950, ptr %951, align 8, !tbaa !13
  %952 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %953 = load double, ptr %952, align 8, !tbaa !17
  %954 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %953, ptr %954, align 8, !tbaa !17
  %955 = load ptr, ptr %13, align 8, !tbaa !5
  %956 = load i32, ptr %955, align 4, !tbaa !9
  store i32 %956, ptr %25, align 4, !tbaa !9
  store i32 1, ptr %32, align 4, !tbaa !9
  br label %957

957:                                              ; preds = %1155, %841
  %958 = load i32, ptr %32, align 4, !tbaa !9
  %959 = load i32, ptr %25, align 4, !tbaa !9
  %960 = icmp sle i32 %958, %959
  br i1 %960, label %961, label %1158

961:                                              ; preds = %957
  %962 = call { double, double } @Cd(ptr noundef %30)
  %963 = extractvalue { double, double } %962, 0
  %964 = extractvalue { double, double } %962, 1
  %965 = fneg double %964
  %966 = call ptr @_pCd(ptr noundef %28)
  %967 = getelementptr inbounds { double, double }, ptr %966, i32 0, i32 0
  %968 = getelementptr inbounds { double, double }, ptr %966, i32 0, i32 1
  store double %963, ptr %967, align 8
  store double %965, ptr %968, align 8
  %969 = load ptr, ptr %17, align 8, !tbaa !5
  %970 = load i32, ptr %31, align 4, !tbaa !9
  %971 = load i32, ptr %32, align 4, !tbaa !9
  %972 = load i32, ptr %23, align 4, !tbaa !9
  %973 = mul nsw i32 %971, %972
  %974 = add nsw i32 %970, %973
  %975 = sext i32 %974 to i64
  %976 = getelementptr inbounds %struct.doublecomplex, ptr %969, i64 %975
  %977 = call { double, double } @Cd(ptr noundef %976)
  %978 = extractvalue { double, double } %977, 0
  %979 = extractvalue { double, double } %977, 1
  %980 = call { double, double } @Cd(ptr noundef %28)
  %981 = extractvalue { double, double } %980, 0
  %982 = extractvalue { double, double } %980, 1
  %983 = call { double, double } @__divdc3(double noundef %978, double noundef %979, double noundef %981, double noundef %982) #5
  %984 = extractvalue { double, double } %983, 0
  %985 = extractvalue { double, double } %983, 1
  %986 = call ptr @_pCd(ptr noundef %27)
  %987 = getelementptr inbounds { double, double }, ptr %986, i32 0, i32 0
  %988 = getelementptr inbounds { double, double }, ptr %986, i32 0, i32 1
  store double %984, ptr %987, align 8
  store double %985, ptr %988, align 8
  %989 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %990 = load double, ptr %989, align 8, !tbaa !13
  %991 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %990, ptr %991, align 8, !tbaa !13
  %992 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %993 = load double, ptr %992, align 8, !tbaa !17
  %994 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %993, ptr %994, align 8, !tbaa !17
  %995 = load ptr, ptr %17, align 8, !tbaa !5
  %996 = load i32, ptr %31, align 4, !tbaa !9
  %997 = add nsw i32 %996, 1
  %998 = load i32, ptr %32, align 4, !tbaa !9
  %999 = load i32, ptr %23, align 4, !tbaa !9
  %1000 = mul nsw i32 %998, %999
  %1001 = add nsw i32 %997, %1000
  %1002 = sext i32 %1001 to i64
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %995, i64 %1002
  %1004 = call { double, double } @Cd(ptr noundef %1003)
  %1005 = extractvalue { double, double } %1004, 0
  %1006 = extractvalue { double, double } %1004, 1
  %1007 = call { double, double } @Cd(ptr noundef %30)
  %1008 = extractvalue { double, double } %1007, 0
  %1009 = extractvalue { double, double } %1007, 1
  %1010 = call { double, double } @__divdc3(double noundef %1005, double noundef %1006, double noundef %1008, double noundef %1009) #5
  %1011 = extractvalue { double, double } %1010, 0
  %1012 = extractvalue { double, double } %1010, 1
  %1013 = call ptr @_pCd(ptr noundef %27)
  %1014 = getelementptr inbounds { double, double }, ptr %1013, i32 0, i32 0
  %1015 = getelementptr inbounds { double, double }, ptr %1013, i32 0, i32 1
  store double %1011, ptr %1014, align 8
  store double %1012, ptr %1015, align 8
  %1016 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1017 = load double, ptr %1016, align 8, !tbaa !13
  %1018 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1017, ptr %1018, align 8, !tbaa !13
  %1019 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1020 = load double, ptr %1019, align 8, !tbaa !17
  %1021 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1020, ptr %1021, align 8, !tbaa !17
  %1022 = load i32, ptr %31, align 4, !tbaa !9
  %1023 = load i32, ptr %32, align 4, !tbaa !9
  %1024 = load i32, ptr %23, align 4, !tbaa !9
  %1025 = mul nsw i32 %1023, %1024
  %1026 = add nsw i32 %1022, %1025
  store i32 %1026, ptr %26, align 4, !tbaa !9
  %1027 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %1028 = load double, ptr %1027, align 8, !tbaa !13
  %1029 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1030 = load double, ptr %1029, align 8, !tbaa !13
  %1031 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %1032 = load double, ptr %1031, align 8, !tbaa !17
  %1033 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1034 = load double, ptr %1033, align 8, !tbaa !17
  %1035 = fmul double %1032, %1034
  %1036 = fneg double %1035
  %1037 = call double @llvm.fmuladd.f64(double %1028, double %1030, double %1036)
  %1038 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %1037, ptr %1038, align 8, !tbaa !13
  %1039 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %1040 = load double, ptr %1039, align 8, !tbaa !13
  %1041 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1042 = load double, ptr %1041, align 8, !tbaa !17
  %1043 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %1044 = load double, ptr %1043, align 8, !tbaa !17
  %1045 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1046 = load double, ptr %1045, align 8, !tbaa !13
  %1047 = fmul double %1044, %1046
  %1048 = call double @llvm.fmuladd.f64(double %1040, double %1042, double %1047)
  %1049 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1048, ptr %1049, align 8, !tbaa !17
  %1050 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1051 = load double, ptr %1050, align 8, !tbaa !13
  %1052 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1053 = load double, ptr %1052, align 8, !tbaa !13
  %1054 = fsub double %1051, %1053
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %1054, ptr %1055, align 8, !tbaa !13
  %1056 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1057 = load double, ptr %1056, align 8, !tbaa !17
  %1058 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1059 = load double, ptr %1058, align 8, !tbaa !17
  %1060 = fsub double %1057, %1059
  %1061 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %1060, ptr %1061, align 8, !tbaa !17
  %1062 = call { double, double } @Cd(ptr noundef %28)
  %1063 = extractvalue { double, double } %1062, 0
  %1064 = extractvalue { double, double } %1062, 1
  %1065 = call { double, double } @Cd(ptr noundef %35)
  %1066 = extractvalue { double, double } %1065, 0
  %1067 = extractvalue { double, double } %1065, 1
  %1068 = call { double, double } @__divdc3(double noundef %1063, double noundef %1064, double noundef %1066, double noundef %1067) #5
  %1069 = extractvalue { double, double } %1068, 0
  %1070 = extractvalue { double, double } %1068, 1
  %1071 = call ptr @_pCd(ptr noundef %27)
  %1072 = getelementptr inbounds { double, double }, ptr %1071, i32 0, i32 0
  %1073 = getelementptr inbounds { double, double }, ptr %1071, i32 0, i32 1
  store double %1069, ptr %1072, align 8
  store double %1070, ptr %1073, align 8
  %1074 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1075 = load double, ptr %1074, align 8, !tbaa !13
  %1076 = load ptr, ptr %17, align 8, !tbaa !5
  %1077 = load i32, ptr %26, align 4, !tbaa !9
  %1078 = sext i32 %1077 to i64
  %1079 = getelementptr inbounds %struct.doublecomplex, ptr %1076, i64 %1078
  %1080 = getelementptr inbounds %struct.doublecomplex, ptr %1079, i32 0, i32 0
  store double %1075, ptr %1080, align 8, !tbaa !13
  %1081 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1082 = load double, ptr %1081, align 8, !tbaa !17
  %1083 = load ptr, ptr %17, align 8, !tbaa !5
  %1084 = load i32, ptr %26, align 4, !tbaa !9
  %1085 = sext i32 %1084 to i64
  %1086 = getelementptr inbounds %struct.doublecomplex, ptr %1083, i64 %1085
  %1087 = getelementptr inbounds %struct.doublecomplex, ptr %1086, i32 0, i32 1
  store double %1082, ptr %1087, align 8, !tbaa !17
  %1088 = load i32, ptr %31, align 4, !tbaa !9
  %1089 = add nsw i32 %1088, 1
  %1090 = load i32, ptr %32, align 4, !tbaa !9
  %1091 = load i32, ptr %23, align 4, !tbaa !9
  %1092 = mul nsw i32 %1090, %1091
  %1093 = add nsw i32 %1089, %1092
  store i32 %1093, ptr %26, align 4, !tbaa !9
  %1094 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1095 = load double, ptr %1094, align 8, !tbaa !13
  %1096 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1097 = load double, ptr %1096, align 8, !tbaa !13
  %1098 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1099 = load double, ptr %1098, align 8, !tbaa !17
  %1100 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1101 = load double, ptr %1100, align 8, !tbaa !17
  %1102 = fmul double %1099, %1101
  %1103 = fneg double %1102
  %1104 = call double @llvm.fmuladd.f64(double %1095, double %1097, double %1103)
  %1105 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %1104, ptr %1105, align 8, !tbaa !13
  %1106 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1107 = load double, ptr %1106, align 8, !tbaa !13
  %1108 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1109 = load double, ptr %1108, align 8, !tbaa !17
  %1110 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1111 = load double, ptr %1110, align 8, !tbaa !17
  %1112 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1113 = load double, ptr %1112, align 8, !tbaa !13
  %1114 = fmul double %1111, %1113
  %1115 = call double @llvm.fmuladd.f64(double %1107, double %1109, double %1114)
  %1116 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1115, ptr %1116, align 8, !tbaa !17
  %1117 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1118 = load double, ptr %1117, align 8, !tbaa !13
  %1119 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1120 = load double, ptr %1119, align 8, !tbaa !13
  %1121 = fsub double %1118, %1120
  %1122 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %1121, ptr %1122, align 8, !tbaa !13
  %1123 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1124 = load double, ptr %1123, align 8, !tbaa !17
  %1125 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1126 = load double, ptr %1125, align 8, !tbaa !17
  %1127 = fsub double %1124, %1126
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %1127, ptr %1128, align 8, !tbaa !17
  %1129 = call { double, double } @Cd(ptr noundef %28)
  %1130 = extractvalue { double, double } %1129, 0
  %1131 = extractvalue { double, double } %1129, 1
  %1132 = call { double, double } @Cd(ptr noundef %35)
  %1133 = extractvalue { double, double } %1132, 0
  %1134 = extractvalue { double, double } %1132, 1
  %1135 = call { double, double } @__divdc3(double noundef %1130, double noundef %1131, double noundef %1133, double noundef %1134) #5
  %1136 = extractvalue { double, double } %1135, 0
  %1137 = extractvalue { double, double } %1135, 1
  %1138 = call ptr @_pCd(ptr noundef %27)
  %1139 = getelementptr inbounds { double, double }, ptr %1138, i32 0, i32 0
  %1140 = getelementptr inbounds { double, double }, ptr %1138, i32 0, i32 1
  store double %1136, ptr %1139, align 8
  store double %1137, ptr %1140, align 8
  %1141 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1142 = load double, ptr %1141, align 8, !tbaa !13
  %1143 = load ptr, ptr %17, align 8, !tbaa !5
  %1144 = load i32, ptr %26, align 4, !tbaa !9
  %1145 = sext i32 %1144 to i64
  %1146 = getelementptr inbounds %struct.doublecomplex, ptr %1143, i64 %1145
  %1147 = getelementptr inbounds %struct.doublecomplex, ptr %1146, i32 0, i32 0
  store double %1142, ptr %1147, align 8, !tbaa !13
  %1148 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1149 = load double, ptr %1148, align 8, !tbaa !17
  %1150 = load ptr, ptr %17, align 8, !tbaa !5
  %1151 = load i32, ptr %26, align 4, !tbaa !9
  %1152 = sext i32 %1151 to i64
  %1153 = getelementptr inbounds %struct.doublecomplex, ptr %1150, i64 %1152
  %1154 = getelementptr inbounds %struct.doublecomplex, ptr %1153, i32 0, i32 1
  store double %1149, ptr %1154, align 8, !tbaa !17
  br label %1155

1155:                                             ; preds = %961
  %1156 = load i32, ptr %32, align 4, !tbaa !9
  %1157 = add nsw i32 %1156, 1
  store i32 %1157, ptr %32, align 4, !tbaa !9
  br label %957, !llvm.loop !22

1158:                                             ; preds = %957
  %1159 = load i32, ptr %31, align 4, !tbaa !9
  %1160 = add nsw i32 %1159, 1
  store i32 %1160, ptr %31, align 4, !tbaa !9
  br label %1161

1161:                                             ; preds = %1158, %820
  %1162 = load i32, ptr %31, align 4, !tbaa !9
  %1163 = add nsw i32 %1162, 1
  store i32 %1163, ptr %31, align 4, !tbaa !9
  br label %808, !llvm.loop !23

1164:                                             ; preds = %808
  %1165 = load ptr, ptr %12, align 8, !tbaa !5
  %1166 = load ptr, ptr %13, align 8, !tbaa !5
  %1167 = load ptr, ptr %14, align 8, !tbaa !5
  %1168 = load i32, ptr %22, align 4, !tbaa !9
  %1169 = sext i32 %1168 to i64
  %1170 = getelementptr inbounds %struct.doublecomplex, ptr %1167, i64 %1169
  %1171 = load ptr, ptr %15, align 8, !tbaa !5
  %1172 = load ptr, ptr %17, align 8, !tbaa !5
  %1173 = load i32, ptr %24, align 4, !tbaa !9
  %1174 = sext i32 %1173 to i64
  %1175 = getelementptr inbounds %struct.doublecomplex, ptr %1172, i64 %1174
  %1176 = load ptr, ptr %18, align 8, !tbaa !5
  call void @ztrsm_(ptr noundef @.str.1, ptr noundef @.str.1, ptr noundef @.str.3, ptr noundef @.str, ptr noundef %1165, ptr noundef %1166, ptr noundef @c_b1, ptr noundef %1170, ptr noundef %1171, ptr noundef %1175, ptr noundef %1176)
  %1177 = load ptr, ptr %12, align 8, !tbaa !5
  %1178 = load i32, ptr %1177, align 4, !tbaa !9
  store i32 %1178, ptr %33, align 4, !tbaa !9
  br label %1179

1179:                                             ; preds = %1255, %1164
  %1180 = load i32, ptr %33, align 4, !tbaa !9
  %1181 = icmp sge i32 %1180, 1
  br i1 %1181, label %1182, label %1256

1182:                                             ; preds = %1179
  %1183 = load ptr, ptr %16, align 8, !tbaa !5
  %1184 = load i32, ptr %33, align 4, !tbaa !9
  %1185 = sext i32 %1184 to i64
  %1186 = getelementptr inbounds i32, ptr %1183, i64 %1185
  %1187 = load i32, ptr %1186, align 4, !tbaa !9
  %1188 = icmp sgt i32 %1187, 0
  br i1 %1188, label %1189, label %1217

1189:                                             ; preds = %1182
  %1190 = load ptr, ptr %16, align 8, !tbaa !5
  %1191 = load i32, ptr %33, align 4, !tbaa !9
  %1192 = sext i32 %1191 to i64
  %1193 = getelementptr inbounds i32, ptr %1190, i64 %1192
  %1194 = load i32, ptr %1193, align 4, !tbaa !9
  store i32 %1194, ptr %40, align 4, !tbaa !9
  %1195 = load i32, ptr %40, align 4, !tbaa !9
  %1196 = load i32, ptr %33, align 4, !tbaa !9
  %1197 = icmp ne i32 %1195, %1196
  br i1 %1197, label %1198, label %1214

1198:                                             ; preds = %1189
  %1199 = load ptr, ptr %13, align 8, !tbaa !5
  %1200 = load ptr, ptr %17, align 8, !tbaa !5
  %1201 = load i32, ptr %33, align 4, !tbaa !9
  %1202 = load i32, ptr %23, align 4, !tbaa !9
  %1203 = add nsw i32 %1201, %1202
  %1204 = sext i32 %1203 to i64
  %1205 = getelementptr inbounds %struct.doublecomplex, ptr %1200, i64 %1204
  %1206 = load ptr, ptr %18, align 8, !tbaa !5
  %1207 = load ptr, ptr %17, align 8, !tbaa !5
  %1208 = load i32, ptr %40, align 4, !tbaa !9
  %1209 = load i32, ptr %23, align 4, !tbaa !9
  %1210 = add nsw i32 %1208, %1209
  %1211 = sext i32 %1210 to i64
  %1212 = getelementptr inbounds %struct.doublecomplex, ptr %1207, i64 %1211
  %1213 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %1199, ptr noundef %1205, ptr noundef %1206, ptr noundef %1212, ptr noundef %1213)
  br label %1214

1214:                                             ; preds = %1198, %1189
  %1215 = load i32, ptr %33, align 4, !tbaa !9
  %1216 = add nsw i32 %1215, -1
  store i32 %1216, ptr %33, align 4, !tbaa !9
  br label %1255

1217:                                             ; preds = %1182
  %1218 = load ptr, ptr %16, align 8, !tbaa !5
  %1219 = load i32, ptr %33, align 4, !tbaa !9
  %1220 = sext i32 %1219 to i64
  %1221 = getelementptr inbounds i32, ptr %1218, i64 %1220
  %1222 = load i32, ptr %1221, align 4, !tbaa !9
  %1223 = sub nsw i32 0, %1222
  store i32 %1223, ptr %40, align 4, !tbaa !9
  %1224 = load i32, ptr %33, align 4, !tbaa !9
  %1225 = icmp sgt i32 %1224, 1
  br i1 %1225, label %1226, label %1252

1226:                                             ; preds = %1217
  %1227 = load i32, ptr %40, align 4, !tbaa !9
  %1228 = load ptr, ptr %16, align 8, !tbaa !5
  %1229 = load i32, ptr %33, align 4, !tbaa !9
  %1230 = sub nsw i32 %1229, 1
  %1231 = sext i32 %1230 to i64
  %1232 = getelementptr inbounds i32, ptr %1228, i64 %1231
  %1233 = load i32, ptr %1232, align 4, !tbaa !9
  %1234 = sub nsw i32 0, %1233
  %1235 = icmp eq i32 %1227, %1234
  br i1 %1235, label %1236, label %1252

1236:                                             ; preds = %1226
  %1237 = load ptr, ptr %13, align 8, !tbaa !5
  %1238 = load ptr, ptr %17, align 8, !tbaa !5
  %1239 = load i32, ptr %33, align 4, !tbaa !9
  %1240 = load i32, ptr %23, align 4, !tbaa !9
  %1241 = add nsw i32 %1239, %1240
  %1242 = sext i32 %1241 to i64
  %1243 = getelementptr inbounds %struct.doublecomplex, ptr %1238, i64 %1242
  %1244 = load ptr, ptr %18, align 8, !tbaa !5
  %1245 = load ptr, ptr %17, align 8, !tbaa !5
  %1246 = load i32, ptr %40, align 4, !tbaa !9
  %1247 = load i32, ptr %23, align 4, !tbaa !9
  %1248 = add nsw i32 %1246, %1247
  %1249 = sext i32 %1248 to i64
  %1250 = getelementptr inbounds %struct.doublecomplex, ptr %1245, i64 %1249
  %1251 = load ptr, ptr %18, align 8, !tbaa !5
  call void @zswap_(ptr noundef %1237, ptr noundef %1243, ptr noundef %1244, ptr noundef %1250, ptr noundef %1251)
  br label %1252

1252:                                             ; preds = %1236, %1226, %1217
  %1253 = load i32, ptr %33, align 4, !tbaa !9
  %1254 = add nsw i32 %1253, -2
  store i32 %1254, ptr %33, align 4, !tbaa !9
  br label %1255

1255:                                             ; preds = %1252, %1214
  br label %1179, !llvm.loop !24

1256:                                             ; preds = %1179
  br label %1257

1257:                                             ; preds = %1256, %716
  %1258 = load ptr, ptr %11, align 8, !tbaa !5
  %1259 = load ptr, ptr %12, align 8, !tbaa !5
  %1260 = load ptr, ptr %14, align 8, !tbaa !5
  %1261 = load i32, ptr %22, align 4, !tbaa !9
  %1262 = sext i32 %1261 to i64
  %1263 = getelementptr inbounds %struct.doublecomplex, ptr %1260, i64 %1262
  %1264 = load ptr, ptr %15, align 8, !tbaa !5
  %1265 = load ptr, ptr %16, align 8, !tbaa !5
  %1266 = getelementptr inbounds i32, ptr %1265, i64 1
  %1267 = load ptr, ptr %19, align 8, !tbaa !5
  %1268 = getelementptr inbounds %struct.doublecomplex, ptr %1267, i64 1
  call void @zsyconv_(ptr noundef %1258, ptr noundef @.str.5, ptr noundef %1259, ptr noundef %1263, ptr noundef %1264, ptr noundef %1266, ptr noundef %1268, ptr noundef %36)
  store i32 1, ptr %43, align 4
  br label %1269

1269:                                             ; preds = %1257, %142, %129
  call void @llvm.lifetime.end.p0(i64 16, ptr %42) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %38) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #5
  ret void
}

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

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

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

declare void @zsyconv_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

declare void @zswap_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

declare void @ztrsm_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

declare void @zdscal_(ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden { double, double } @Cd(ptr noundef) #3

declare { double, double } @__divdc3(double, double, double, double)

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(ptr noundef) #3

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

; 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 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !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 = !{!15, !15, i64 0}
!17 = !{!14, !15, i64 8}
!18 = distinct !{!18, !12}
!19 = distinct !{!19, !12}
!20 = distinct !{!20, !12}
!21 = distinct !{!21, !12}
!22 = distinct !{!22, !12}
!23 = distinct !{!23, !12}
!24 = distinct !{!24, !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 [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.5 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zhetrs2_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr nocapture noundef %9) local_unnamed_addr #0 {
  %11 = alloca i32, align 4
  %12 = alloca %struct.doublecomplex, align 16
  %13 = alloca %struct.doublecomplex, align 16
  %14 = alloca %struct.doublecomplex, align 16
  %15 = alloca double, align 8
  %16 = alloca %struct.doublecomplex, align 16
  %17 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %11) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %12) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %13) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %14) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %16) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %17) #5
  %18 = load i32, ptr %4, align 4, !tbaa !5
  %narrow = xor i32 %18, -1
  %19 = sext i32 %narrow to i64
  %20 = getelementptr inbounds %struct.doublecomplex, ptr %3, i64 %19
  %21 = getelementptr inbounds i8, ptr %5, i64 -4
  %22 = load i32, ptr %7, align 4, !tbaa !5
  %narrow411 = xor i32 %22, -1
  %23 = sext i32 %narrow411 to i64
  %24 = getelementptr inbounds %struct.doublecomplex, ptr %6, i64 %23
  %25 = getelementptr inbounds i8, ptr %8, i64 -16
  store i32 0, ptr %9, align 4, !tbaa !5
  %26 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #5
  %.not = icmp eq i32 %26, 0
  br i1 %.not, label %27, label %29

27:                                               ; preds = %10
  %28 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #5
  %.not403 = icmp eq i32 %28, 0
  br i1 %.not403, label %.thread.sink.split, label %29

29:                                               ; preds = %27, %10
  %30 = load i32, ptr %1, align 4, !tbaa !5
  %31 = icmp slt i32 %30, 0
  br i1 %31, label %.thread.sink.split, label %32

32:                                               ; preds = %29
  %33 = load i32, ptr %2, align 4, !tbaa !5
  %34 = icmp slt i32 %33, 0
  br i1 %34, label %.thread.sink.split, label %35

35:                                               ; preds = %32
  %36 = load i32, ptr %4, align 4, !tbaa !5
  %spec.select = tail call i32 @llvm.umax.i32(i32 %30, i32 1)
  %37 = icmp slt i32 %36, %spec.select
  br i1 %37, label %.thread.sink.split, label %38

38:                                               ; preds = %35
  %39 = load i32, ptr %7, align 4, !tbaa !5
  %40 = icmp slt i32 %39, %spec.select
  br i1 %40, label %.thread.sink.split, label %41

41:                                               ; preds = %38
  %.pr = load i32, ptr %9, align 4, !tbaa !5
  %.not404 = icmp eq i32 %.pr, 0
  br i1 %.not404, label %45, label %.thread

.thread.sink.split:                               ; preds = %38, %35, %32, %29, %27
  %.sink = phi i32 [ -1, %27 ], [ -2, %29 ], [ -3, %32 ], [ -5, %35 ], [ -8, %38 ]
  store i32 %.sink, ptr %9, align 4, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %.thread.sink.split, %41
  %42 = phi i32 [ %.pr, %41 ], [ %.sink, %.thread.sink.split ]
  %43 = sub nsw i32 0, %42
  store i32 %43, ptr %11, align 4, !tbaa !5
  %44 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %11, i32 noundef 7) #5
  br label %423

45:                                               ; preds = %41
  %46 = icmp eq i32 %30, 0
  %47 = icmp eq i32 %33, 0
  %or.cond = or i1 %46, %47
  br i1 %or.cond, label %423, label %48

48:                                               ; preds = %45
  call void @zsyconv_(ptr noundef %0, ptr noundef nonnull @.str.3, ptr noundef nonnull %1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %5, ptr noundef %8, ptr noundef nonnull %17) #5
  %49 = load i32, ptr %1, align 4, !tbaa !5
  br i1 %.not, label %.preheader, label %50

.preheader:                                       ; preds = %48
  %.not405435 = icmp slt i32 %49, 1
  br i1 %.not405435, label %._crit_edge438, label %.lr.ph437

50:                                               ; preds = %48
  %51 = icmp sgt i32 %49, 0
  br i1 %51, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %50, %69
  %.0422 = phi i32 [ %70, %69 ], [ %49, %50 ]
  %52 = zext nneg i32 %.0422 to i64
  %53 = getelementptr inbounds i32, ptr %21, i64 %52
  %54 = load i32, ptr %53, align 4, !tbaa !5
  %55 = icmp sgt i32 %54, 0
  br i1 %55, label %56, label %59

56:                                               ; preds = %.lr.ph
  %.not416 = icmp eq i32 %54, %.0422
  br i1 %.not416, label %69, label %57

57:                                               ; preds = %56
  %58 = add nsw i32 %54, %22
  br label %.sink.split

59:                                               ; preds = %.lr.ph
  %60 = add nsw i32 %.0422, -1
  %61 = zext nneg i32 %60 to i64
  %62 = getelementptr inbounds i32, ptr %21, i64 %61
  %63 = load i32, ptr %62, align 4, !tbaa !5
  %64 = icmp eq i32 %63, %54
  br i1 %64, label %65, label %69

65:                                               ; preds = %59
  %66 = sub i32 %22, %54
  br label %.sink.split

.sink.split:                                      ; preds = %57, %65
  %.sink471 = phi i32 [ %66, %65 ], [ %58, %57 ]
  %.pn487 = phi i32 [ %60, %65 ], [ %.0422, %57 ]
  %.sink464.ph = phi i32 [ -2, %65 ], [ -1, %57 ]
  %.pn.in = add nsw i32 %.pn487, %22
  %.pn = sext i32 %.pn.in to i64
  %.sink468 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %.pn
  %67 = sext i32 %.sink471 to i64
  %68 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %67
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink468, ptr noundef nonnull %7, ptr noundef %68, ptr noundef nonnull %7) #5
  br label %69

69:                                               ; preds = %.sink.split, %59, %56
  %.sink464 = phi i32 [ -1, %56 ], [ -2, %59 ], [ %.sink464.ph, %.sink.split ]
  %70 = add nsw i32 %.0422, %.sink464
  %71 = icmp sgt i32 %70, 0
  br i1 %71, label %.lr.ph, label %._crit_edge, !llvm.loop !9

._crit_edge:                                      ; preds = %69, %50
  call void @ztrsm_(ptr noundef nonnull @.str.1, ptr noundef nonnull @.str, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str, ptr noundef nonnull %1, ptr noundef nonnull %2, ptr noundef nonnull @c_b1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %6, ptr noundef nonnull %7) #5
  %72 = load i32, ptr %1, align 4, !tbaa !5
  %73 = icmp sgt i32 %72, 0
  br i1 %73, label %.lr.ph429, label %._crit_edge430

.lr.ph429:                                        ; preds = %._crit_edge
  %74 = add i32 %18, 1
  %75 = getelementptr inbounds i8, ptr %12, i64 8
  %76 = sext i32 %22 to i64
  br label %77

77:                                               ; preds = %.lr.ph429, %.loopexit421
  %.0382427 = phi i32 [ %72, %.lr.ph429 ], [ %218, %.loopexit421 ]
  %78 = zext nneg i32 %.0382427 to i64
  %79 = getelementptr inbounds i32, ptr %21, i64 %78
  %80 = load i32, ptr %79, align 4, !tbaa !5
  %81 = icmp sgt i32 %80, 0
  br i1 %81, label %82, label %91

82:                                               ; preds = %77
  %83 = mul i32 %.0382427, %74
  %84 = sext i32 %83 to i64
  %85 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %84
  %86 = load double, ptr %85, align 8, !tbaa !11
  %87 = fdiv double 1.000000e+00, %86
  store double %87, ptr %15, align 8, !tbaa !14
  %88 = add nsw i32 %.0382427, %22
  %89 = sext i32 %88 to i64
  %90 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %89
  call void @zdscal_(ptr noundef nonnull %2, ptr noundef nonnull %15, ptr noundef %90, ptr noundef nonnull %7) #5
  br label %.loopexit421

91:                                               ; preds = %77
  %.not414 = icmp eq i32 %.0382427, 1
  br i1 %.not414, label %._crit_edge430, label %92

92:                                               ; preds = %91
  %93 = add nsw i32 %.0382427, -1
  %94 = zext nneg i32 %93 to i64
  %95 = getelementptr inbounds i32, ptr %21, i64 %94
  %96 = load i32, ptr %95, align 4, !tbaa !5
  %97 = icmp eq i32 %96, %80
  br i1 %97, label %98, label %.loopexit421

98:                                               ; preds = %92
  %99 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %78
  %100 = load <2 x double>, ptr %99, align 8, !tbaa !14
  store <2 x double> %100, ptr %14, align 16, !tbaa !14
  %101 = mul i32 %93, %74
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %102
  %104 = call { double, double } @Cd(ptr noundef %103)
  %105 = extractvalue { double, double } %104, 0
  %106 = extractvalue { double, double } %104, 1
  %107 = call { double, double } @Cd(ptr noundef nonnull %14)
  %108 = extractvalue { double, double } %107, 0
  %109 = extractvalue { double, double } %107, 1
  %110 = call { double, double } @__divdc3(double noundef %105, double noundef %106, double noundef %108, double noundef %109) #5
  %111 = extractvalue { double, double } %110, 0
  %112 = extractvalue { double, double } %110, 1
  %113 = call ptr @_pCd(ptr noundef nonnull %12)
  %114 = getelementptr inbounds i8, ptr %113, i64 8
  store double %111, ptr %113, align 8
  store double %112, ptr %114, align 8
  %115 = load <2 x double>, ptr %12, align 16
  %116 = load double, ptr %75, align 8, !tbaa !15
  %117 = call { double, double } @Cd(ptr noundef nonnull %14)
  %118 = extractvalue { double, double } %117, 0
  %119 = extractvalue { double, double } %117, 1
  %120 = fneg double %119
  %121 = call ptr @_pCd(ptr noundef nonnull %13)
  %122 = getelementptr inbounds i8, ptr %121, i64 8
  store double %118, ptr %121, align 8
  store double %120, ptr %122, align 8
  %123 = mul i32 %.0382427, %74
  %124 = sext i32 %123 to i64
  %125 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %124
  %126 = call { double, double } @Cd(ptr noundef %125)
  %127 = extractvalue { double, double } %126, 0
  %128 = extractvalue { double, double } %126, 1
  %129 = call { double, double } @Cd(ptr noundef nonnull %13)
  %130 = extractvalue { double, double } %129, 0
  %131 = extractvalue { double, double } %129, 1
  %132 = call { double, double } @__divdc3(double noundef %127, double noundef %128, double noundef %130, double noundef %131) #5
  %133 = extractvalue { double, double } %132, 0
  %134 = extractvalue { double, double } %132, 1
  %135 = call ptr @_pCd(ptr noundef nonnull %12)
  %136 = getelementptr inbounds i8, ptr %135, i64 8
  store double %133, ptr %135, align 8
  store double %134, ptr %136, align 8
  %137 = fneg double %116
  %138 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %139 = insertelement <2 x double> poison, double %116, i64 0
  %140 = insertelement <2 x double> %139, double %137, i64 1
  %141 = fmul <2 x double> %138, %140
  %142 = shufflevector <2 x double> %141, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %143 = shufflevector <2 x double> %115, <2 x double> poison, <2 x i32> zeroinitializer
  %144 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %143, <2 x double> %138, <2 x double> %142)
  store <2 x double> %144, ptr %13, align 16, !tbaa !14
  %145 = fadd <2 x double> %144, <double -1.000000e+00, double 0.000000e+00>
  store <2 x double> %145, ptr %12, align 16, !tbaa !14
  store <2 x double> %145, ptr %16, align 16, !tbaa !14
  %146 = load i32, ptr %2, align 4, !tbaa !5
  %.not415423 = icmp slt i32 %146, 1
  br i1 %.not415423, label %.loopexit421, label %.lr.ph426

.lr.ph426:                                        ; preds = %98
  %147 = zext nneg i32 %93 to i64
  %148 = zext nneg i32 %.0382427 to i64
  %invariant.gep = getelementptr %struct.doublecomplex, ptr %24, i64 %147
  %invariant.gep458 = getelementptr %struct.doublecomplex, ptr %24, i64 %148
  %149 = zext nneg i32 %146 to i64
  %150 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> zeroinitializer
  %151 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %152 = fneg <2 x double> %138
  %153 = shufflevector <2 x double> %151, <2 x double> %152, <2 x i32> <i32 0, i32 3>
  br label %154

154:                                              ; preds = %.lr.ph426, %154
  %indvars.iv = phi i64 [ 1, %.lr.ph426 ], [ %indvars.iv.next, %154 ]
  %155 = mul nsw i64 %indvars.iv, %76
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %155
  %156 = call { double, double } @Cd(ptr noundef %gep)
  %157 = extractvalue { double, double } %156, 0
  %158 = extractvalue { double, double } %156, 1
  %159 = call { double, double } @Cd(ptr noundef nonnull %14)
  %160 = extractvalue { double, double } %159, 0
  %161 = extractvalue { double, double } %159, 1
  %162 = call { double, double } @__divdc3(double noundef %157, double noundef %158, double noundef %160, double noundef %161) #5
  %163 = extractvalue { double, double } %162, 0
  %164 = extractvalue { double, double } %162, 1
  %165 = call ptr @_pCd(ptr noundef nonnull %12)
  %166 = getelementptr inbounds i8, ptr %165, i64 8
  store double %163, ptr %165, align 8
  store double %164, ptr %166, align 8
  %gep459 = getelementptr %struct.doublecomplex, ptr %invariant.gep458, i64 %155
  %167 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %168 = call { double, double } @Cd(ptr noundef nonnull %14)
  %169 = extractvalue { double, double } %168, 0
  %170 = extractvalue { double, double } %168, 1
  %171 = fneg double %170
  %172 = call ptr @_pCd(ptr noundef nonnull %13)
  %173 = getelementptr inbounds i8, ptr %172, i64 8
  store double %169, ptr %172, align 8
  store double %171, ptr %173, align 8
  %174 = call { double, double } @Cd(ptr noundef %gep459)
  %175 = extractvalue { double, double } %174, 0
  %176 = extractvalue { double, double } %174, 1
  %177 = call { double, double } @Cd(ptr noundef nonnull %13)
  %178 = extractvalue { double, double } %177, 0
  %179 = extractvalue { double, double } %177, 1
  %180 = call { double, double } @__divdc3(double noundef %175, double noundef %176, double noundef %178, double noundef %179) #5
  %181 = extractvalue { double, double } %180, 0
  %182 = extractvalue { double, double } %180, 1
  %183 = call ptr @_pCd(ptr noundef nonnull %12)
  %184 = getelementptr inbounds i8, ptr %183, i64 8
  store double %181, ptr %183, align 8
  store double %182, ptr %184, align 8
  %185 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %186 = fmul <2 x double> %167, %153
  %187 = shufflevector <2 x double> %186, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %188 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %150, <2 x double> %167, <2 x double> %187)
  %189 = fsub <2 x double> %188, %185
  store <2 x double> %189, ptr %13, align 16, !tbaa !14
  %190 = call { double, double } @Cd(ptr noundef nonnull %13)
  %191 = extractvalue { double, double } %190, 0
  %192 = extractvalue { double, double } %190, 1
  %193 = call { double, double } @Cd(ptr noundef nonnull %16)
  %194 = extractvalue { double, double } %193, 0
  %195 = extractvalue { double, double } %193, 1
  %196 = call { double, double } @__divdc3(double noundef %191, double noundef %192, double noundef %194, double noundef %195) #5
  %197 = extractvalue { double, double } %196, 0
  %198 = extractvalue { double, double } %196, 1
  %199 = call ptr @_pCd(ptr noundef nonnull %12)
  %200 = getelementptr inbounds i8, ptr %199, i64 8
  store double %197, ptr %199, align 8
  store double %198, ptr %200, align 8
  %201 = load <2 x double>, ptr %12, align 16, !tbaa !14
  store <2 x double> %201, ptr %gep, align 8, !tbaa !14
  %202 = fmul <2 x double> %185, %140
  %203 = shufflevector <2 x double> %202, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %204 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %143, <2 x double> %185, <2 x double> %203)
  %205 = fsub <2 x double> %204, %167
  store <2 x double> %205, ptr %13, align 16, !tbaa !14
  %206 = call { double, double } @Cd(ptr noundef nonnull %13)
  %207 = extractvalue { double, double } %206, 0
  %208 = extractvalue { double, double } %206, 1
  %209 = call { double, double } @Cd(ptr noundef nonnull %16)
  %210 = extractvalue { double, double } %209, 0
  %211 = extractvalue { double, double } %209, 1
  %212 = call { double, double } @__divdc3(double noundef %207, double noundef %208, double noundef %210, double noundef %211) #5
  %213 = extractvalue { double, double } %212, 0
  %214 = extractvalue { double, double } %212, 1
  %215 = call ptr @_pCd(ptr noundef nonnull %12)
  %216 = getelementptr inbounds i8, ptr %215, i64 8
  store double %213, ptr %215, align 8
  store double %214, ptr %216, align 8
  %217 = load <2 x double>, ptr %12, align 16, !tbaa !14
  store <2 x double> %217, ptr %gep459, align 8, !tbaa !14
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %.not415.not = icmp ult i64 %indvars.iv, %149
  br i1 %.not415.not, label %154, label %.loopexit421, !llvm.loop !16

.loopexit421:                                     ; preds = %154, %98, %92, %82
  %.1383 = phi i32 [ %.0382427, %82 ], [ %.0382427, %92 ], [ %93, %98 ], [ %93, %154 ]
  %218 = add nsw i32 %.1383, -1
  %219 = icmp sgt i32 %.1383, 1
  br i1 %219, label %77, label %._crit_edge430, !llvm.loop !17

._crit_edge430:                                   ; preds = %91, %.loopexit421, %._crit_edge
  call void @ztrsm_(ptr noundef nonnull @.str.1, ptr noundef nonnull @.str, ptr noundef nonnull @.str.3, ptr noundef nonnull @.str, ptr noundef nonnull %1, ptr noundef nonnull %2, ptr noundef nonnull @c_b1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %6, ptr noundef nonnull %7) #5
  %220 = load i32, ptr %1, align 4, !tbaa !5
  %.not412431 = icmp slt i32 %220, 1
  br i1 %.not412431, label %.loopexit, label %.lr.ph434

.lr.ph434:                                        ; preds = %._crit_edge430, %239
  %221 = phi i32 [ %241, %239 ], [ %220, %._crit_edge430 ]
  %.2432 = phi i32 [ %240, %239 ], [ 1, %._crit_edge430 ]
  %222 = sext i32 %.2432 to i64
  %223 = getelementptr inbounds i32, ptr %21, i64 %222
  %224 = load i32, ptr %223, align 4, !tbaa !5
  %225 = icmp sgt i32 %224, 0
  br i1 %225, label %226, label %229

226:                                              ; preds = %.lr.ph434
  %.not413 = icmp eq i32 %224, %.2432
  br i1 %.not413, label %239, label %227

227:                                              ; preds = %226
  %228 = add nsw i32 %224, %22
  br label %.sink.split472

229:                                              ; preds = %.lr.ph434
  %230 = icmp slt i32 %.2432, %221
  br i1 %230, label %231, label %239

231:                                              ; preds = %229
  %232 = getelementptr i8, ptr %223, i64 4
  %233 = load i32, ptr %232, align 4, !tbaa !5
  %234 = icmp eq i32 %233, %224
  br i1 %234, label %235, label %239

235:                                              ; preds = %231
  %236 = sub i32 %22, %224
  br label %.sink.split472

.sink.split472:                                   ; preds = %227, %235
  %.sink476 = phi i32 [ %236, %235 ], [ %228, %227 ]
  %.sink465.ph = phi i32 [ 2, %235 ], [ 1, %227 ]
  %.pn488.in = add nsw i32 %.2432, %22
  %.pn488 = sext i32 %.pn488.in to i64
  %.sink473 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %.pn488
  %237 = sext i32 %.sink476 to i64
  %238 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %237
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink473, ptr noundef nonnull %7, ptr noundef %238, ptr noundef nonnull %7) #5
  br label %239

239:                                              ; preds = %.sink.split472, %229, %231, %226
  %.sink465 = phi i32 [ 1, %226 ], [ 2, %231 ], [ 2, %229 ], [ %.sink465.ph, %.sink.split472 ]
  %240 = add nsw i32 %.2432, %.sink465
  %241 = load i32, ptr %1, align 4, !tbaa !5
  %.not412 = icmp sgt i32 %240, %241
  br i1 %.not412, label %.loopexit, label %.lr.ph434, !llvm.loop !18

.lr.ph437:                                        ; preds = %.preheader, %259
  %.4436 = phi i32 [ %260, %259 ], [ 1, %.preheader ]
  %242 = sext i32 %.4436 to i64
  %243 = getelementptr inbounds i32, ptr %21, i64 %242
  %244 = load i32, ptr %243, align 4, !tbaa !5
  %245 = icmp sgt i32 %244, 0
  br i1 %245, label %246, label %249

246:                                              ; preds = %.lr.ph437
  %.not410 = icmp eq i32 %244, %.4436
  br i1 %.not410, label %259, label %247

247:                                              ; preds = %246
  %248 = add nsw i32 %244, %22
  br label %.sink.split477

249:                                              ; preds = %.lr.ph437
  %250 = add nsw i32 %.4436, 1
  %251 = sext i32 %250 to i64
  %252 = getelementptr inbounds i32, ptr %21, i64 %251
  %253 = load i32, ptr %252, align 4, !tbaa !5
  %254 = icmp eq i32 %244, %253
  br i1 %254, label %255, label %259

255:                                              ; preds = %249
  %256 = sub i32 %22, %244
  br label %.sink.split477

.sink.split477:                                   ; preds = %247, %255
  %.sink481 = phi i32 [ %256, %255 ], [ %248, %247 ]
  %.pn490 = phi i32 [ %250, %255 ], [ %.4436, %247 ]
  %.sink466.ph = phi i32 [ 2, %255 ], [ 1, %247 ]
  %.pn489.in = add nsw i32 %.pn490, %22
  %.pn489 = sext i32 %.pn489.in to i64
  %.sink478 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %.pn489
  %257 = sext i32 %.sink481 to i64
  %258 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %257
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink478, ptr noundef nonnull %7, ptr noundef %258, ptr noundef nonnull %7) #5
  br label %259

259:                                              ; preds = %.sink.split477, %249, %246
  %.sink466 = phi i32 [ 1, %246 ], [ 2, %249 ], [ %.sink466.ph, %.sink.split477 ]
  %260 = add nsw i32 %.4436, %.sink466
  %261 = load i32, ptr %1, align 4, !tbaa !5
  %.not405 = icmp sgt i32 %260, %261
  br i1 %.not405, label %._crit_edge438, label %.lr.ph437, !llvm.loop !19

._crit_edge438:                                   ; preds = %259, %.preheader
  call void @ztrsm_(ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str, ptr noundef nonnull %1, ptr noundef nonnull %2, ptr noundef nonnull @c_b1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %6, ptr noundef nonnull %7) #5
  %262 = load i32, ptr %1, align 4, !tbaa !5
  %.not406443 = icmp slt i32 %262, 1
  br i1 %.not406443, label %._crit_edge447, label %.lr.ph446

.lr.ph446:                                        ; preds = %._crit_edge438
  %263 = add i32 %18, 1
  %264 = getelementptr inbounds i8, ptr %12, i64 8
  %265 = sext i32 %22 to i64
  br label %266

266:                                              ; preds = %.lr.ph446, %.loopexit419
  %.2384444 = phi i32 [ 1, %.lr.ph446 ], [ %400, %.loopexit419 ]
  %267 = sext i32 %.2384444 to i64
  %268 = getelementptr inbounds i32, ptr %21, i64 %267
  %269 = load i32, ptr %268, align 4, !tbaa !5
  %270 = icmp sgt i32 %269, 0
  br i1 %270, label %271, label %280

271:                                              ; preds = %266
  %272 = mul i32 %.2384444, %263
  %273 = sext i32 %272 to i64
  %274 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %273
  %275 = load double, ptr %274, align 8, !tbaa !11
  %276 = fdiv double 1.000000e+00, %275
  store double %276, ptr %15, align 8, !tbaa !14
  %277 = add nsw i32 %.2384444, %22
  %278 = sext i32 %277 to i64
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %278
  call void @zdscal_(ptr noundef nonnull %2, ptr noundef nonnull %15, ptr noundef %279, ptr noundef nonnull %7) #5
  br label %.loopexit419

280:                                              ; preds = %266
  %281 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %267
  %282 = load <2 x double>, ptr %281, align 8, !tbaa !14
  store <2 x double> %282, ptr %14, align 16, !tbaa !14
  %283 = call { double, double } @Cd(ptr noundef nonnull %14)
  %284 = extractvalue { double, double } %283, 0
  %285 = extractvalue { double, double } %283, 1
  %286 = fneg double %285
  %287 = call ptr @_pCd(ptr noundef nonnull %13)
  %288 = getelementptr inbounds i8, ptr %287, i64 8
  store double %284, ptr %287, align 8
  store double %286, ptr %288, align 8
  %289 = mul i32 %.2384444, %263
  %290 = sext i32 %289 to i64
  %291 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %290
  %292 = call { double, double } @Cd(ptr noundef %291)
  %293 = extractvalue { double, double } %292, 0
  %294 = extractvalue { double, double } %292, 1
  %295 = call { double, double } @Cd(ptr noundef nonnull %13)
  %296 = extractvalue { double, double } %295, 0
  %297 = extractvalue { double, double } %295, 1
  %298 = call { double, double } @__divdc3(double noundef %293, double noundef %294, double noundef %296, double noundef %297) #5
  %299 = extractvalue { double, double } %298, 0
  %300 = extractvalue { double, double } %298, 1
  %301 = call ptr @_pCd(ptr noundef nonnull %12)
  %302 = getelementptr inbounds i8, ptr %301, i64 8
  store double %299, ptr %301, align 8
  store double %300, ptr %302, align 8
  %303 = load <2 x double>, ptr %12, align 16
  %304 = load double, ptr %264, align 8, !tbaa !15
  %305 = add nsw i32 %.2384444, 1
  %306 = mul i32 %305, %263
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %307
  %309 = call { double, double } @Cd(ptr noundef %308)
  %310 = extractvalue { double, double } %309, 0
  %311 = extractvalue { double, double } %309, 1
  %312 = call { double, double } @Cd(ptr noundef nonnull %14)
  %313 = extractvalue { double, double } %312, 0
  %314 = extractvalue { double, double } %312, 1
  %315 = call { double, double } @__divdc3(double noundef %310, double noundef %311, double noundef %313, double noundef %314) #5
  %316 = extractvalue { double, double } %315, 0
  %317 = extractvalue { double, double } %315, 1
  %318 = call ptr @_pCd(ptr noundef nonnull %12)
  %319 = getelementptr inbounds i8, ptr %318, i64 8
  store double %316, ptr %318, align 8
  store double %317, ptr %319, align 8
  %320 = fneg double %304
  %321 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %322 = insertelement <2 x double> poison, double %304, i64 0
  %323 = insertelement <2 x double> %322, double %320, i64 1
  %324 = fmul <2 x double> %321, %323
  %325 = shufflevector <2 x double> %324, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %326 = shufflevector <2 x double> %303, <2 x double> poison, <2 x i32> zeroinitializer
  %327 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %326, <2 x double> %321, <2 x double> %325)
  store <2 x double> %327, ptr %13, align 16, !tbaa !14
  %328 = fadd <2 x double> %327, <double -1.000000e+00, double 0.000000e+00>
  store <2 x double> %328, ptr %12, align 16, !tbaa !14
  store <2 x double> %328, ptr %16, align 16, !tbaa !14
  %329 = load i32, ptr %2, align 4, !tbaa !5
  %.not409439 = icmp slt i32 %329, 1
  br i1 %.not409439, label %.loopexit419, label %.lr.ph442

.lr.ph442:                                        ; preds = %280
  %330 = sext i32 %305 to i64
  %invariant.gep460 = getelementptr %struct.doublecomplex, ptr %24, i64 %267
  %invariant.gep462 = getelementptr %struct.doublecomplex, ptr %24, i64 %330
  %331 = zext nneg i32 %329 to i64
  %332 = shufflevector <2 x double> %321, <2 x double> poison, <2 x i32> zeroinitializer
  %333 = shufflevector <2 x double> %321, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %334 = fneg <2 x double> %321
  %335 = shufflevector <2 x double> %333, <2 x double> %334, <2 x i32> <i32 0, i32 3>
  br label %336

336:                                              ; preds = %.lr.ph442, %336
  %indvars.iv453 = phi i64 [ 1, %.lr.ph442 ], [ %indvars.iv.next454, %336 ]
  %337 = call { double, double } @Cd(ptr noundef nonnull %14)
  %338 = extractvalue { double, double } %337, 0
  %339 = extractvalue { double, double } %337, 1
  %340 = fneg double %339
  %341 = call ptr @_pCd(ptr noundef nonnull %13)
  %342 = getelementptr inbounds i8, ptr %341, i64 8
  store double %338, ptr %341, align 8
  store double %340, ptr %342, align 8
  %343 = mul nsw i64 %indvars.iv453, %265
  %gep461 = getelementptr %struct.doublecomplex, ptr %invariant.gep460, i64 %343
  %344 = call { double, double } @Cd(ptr noundef %gep461)
  %345 = extractvalue { double, double } %344, 0
  %346 = extractvalue { double, double } %344, 1
  %347 = call { double, double } @Cd(ptr noundef nonnull %13)
  %348 = extractvalue { double, double } %347, 0
  %349 = extractvalue { double, double } %347, 1
  %350 = call { double, double } @__divdc3(double noundef %345, double noundef %346, double noundef %348, double noundef %349) #5
  %351 = extractvalue { double, double } %350, 0
  %352 = extractvalue { double, double } %350, 1
  %353 = call ptr @_pCd(ptr noundef nonnull %12)
  %354 = getelementptr inbounds i8, ptr %353, i64 8
  store double %351, ptr %353, align 8
  store double %352, ptr %354, align 8
  %gep463 = getelementptr %struct.doublecomplex, ptr %invariant.gep462, i64 %343
  %355 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %356 = call { double, double } @Cd(ptr noundef %gep463)
  %357 = extractvalue { double, double } %356, 0
  %358 = extractvalue { double, double } %356, 1
  %359 = call { double, double } @Cd(ptr noundef nonnull %14)
  %360 = extractvalue { double, double } %359, 0
  %361 = extractvalue { double, double } %359, 1
  %362 = call { double, double } @__divdc3(double noundef %357, double noundef %358, double noundef %360, double noundef %361) #5
  %363 = extractvalue { double, double } %362, 0
  %364 = extractvalue { double, double } %362, 1
  %365 = call ptr @_pCd(ptr noundef nonnull %12)
  %366 = getelementptr inbounds i8, ptr %365, i64 8
  store double %363, ptr %365, align 8
  store double %364, ptr %366, align 8
  %367 = load <2 x double>, ptr %12, align 16, !tbaa !14
  %368 = fmul <2 x double> %355, %335
  %369 = shufflevector <2 x double> %368, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %370 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %332, <2 x double> %355, <2 x double> %369)
  %371 = fsub <2 x double> %370, %367
  store <2 x double> %371, ptr %13, align 16, !tbaa !14
  %372 = call { double, double } @Cd(ptr noundef nonnull %13)
  %373 = extractvalue { double, double } %372, 0
  %374 = extractvalue { double, double } %372, 1
  %375 = call { double, double } @Cd(ptr noundef nonnull %16)
  %376 = extractvalue { double, double } %375, 0
  %377 = extractvalue { double, double } %375, 1
  %378 = call { double, double } @__divdc3(double noundef %373, double noundef %374, double noundef %376, double noundef %377) #5
  %379 = extractvalue { double, double } %378, 0
  %380 = extractvalue { double, double } %378, 1
  %381 = call ptr @_pCd(ptr noundef nonnull %12)
  %382 = getelementptr inbounds i8, ptr %381, i64 8
  store double %379, ptr %381, align 8
  store double %380, ptr %382, align 8
  %383 = load <2 x double>, ptr %12, align 16, !tbaa !14
  store <2 x double> %383, ptr %gep461, align 8, !tbaa !14
  %384 = fmul <2 x double> %367, %323
  %385 = shufflevector <2 x double> %384, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %386 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %326, <2 x double> %367, <2 x double> %385)
  %387 = fsub <2 x double> %386, %355
  store <2 x double> %387, ptr %13, align 16, !tbaa !14
  %388 = call { double, double } @Cd(ptr noundef nonnull %13)
  %389 = extractvalue { double, double } %388, 0
  %390 = extractvalue { double, double } %388, 1
  %391 = call { double, double } @Cd(ptr noundef nonnull %16)
  %392 = extractvalue { double, double } %391, 0
  %393 = extractvalue { double, double } %391, 1
  %394 = call { double, double } @__divdc3(double noundef %389, double noundef %390, double noundef %392, double noundef %393) #5
  %395 = extractvalue { double, double } %394, 0
  %396 = extractvalue { double, double } %394, 1
  %397 = call ptr @_pCd(ptr noundef nonnull %12)
  %398 = getelementptr inbounds i8, ptr %397, i64 8
  store double %395, ptr %397, align 8
  store double %396, ptr %398, align 8
  %399 = load <2 x double>, ptr %12, align 16, !tbaa !14
  store <2 x double> %399, ptr %gep463, align 8, !tbaa !14
  %indvars.iv.next454 = add nuw nsw i64 %indvars.iv453, 1
  %.not409.not = icmp ult i64 %indvars.iv453, %331
  br i1 %.not409.not, label %336, label %.loopexit419, !llvm.loop !20

.loopexit419:                                     ; preds = %336, %280, %271
  %.3385 = phi i32 [ %.2384444, %271 ], [ %305, %280 ], [ %305, %336 ]
  %400 = add nsw i32 %.3385, 1
  %401 = load i32, ptr %1, align 4, !tbaa !5
  %.not406.not = icmp slt i32 %.3385, %401
  br i1 %.not406.not, label %266, label %._crit_edge447, !llvm.loop !21

._crit_edge447:                                   ; preds = %.loopexit419, %._crit_edge438
  call void @ztrsm_(ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.1, ptr noundef nonnull @.str.3, ptr noundef nonnull @.str, ptr noundef nonnull %1, ptr noundef nonnull %2, ptr noundef nonnull @c_b1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %6, ptr noundef nonnull %7) #5
  %402 = load i32, ptr %1, align 4, !tbaa !5
  %403 = icmp sgt i32 %402, 0
  br i1 %403, label %.lr.ph450, label %.loopexit

.lr.ph450:                                        ; preds = %._crit_edge447, %420
  %.6448 = phi i32 [ %421, %420 ], [ %402, %._crit_edge447 ]
  %404 = zext nneg i32 %.6448 to i64
  %405 = getelementptr inbounds i32, ptr %21, i64 %404
  %406 = load i32, ptr %405, align 4, !tbaa !5
  %407 = icmp sgt i32 %406, 0
  br i1 %407, label %408, label %411

408:                                              ; preds = %.lr.ph450
  %.not408 = icmp eq i32 %406, %.6448
  br i1 %.not408, label %420, label %409

409:                                              ; preds = %408
  %410 = add nsw i32 %406, %22
  br label %.sink.split482

411:                                              ; preds = %.lr.ph450
  %.not407 = icmp eq i32 %.6448, 1
  br i1 %.not407, label %420, label %412

412:                                              ; preds = %411
  %413 = getelementptr i8, ptr %405, i64 -4
  %414 = load i32, ptr %413, align 4, !tbaa !5
  %415 = icmp eq i32 %414, %406
  br i1 %415, label %416, label %420

416:                                              ; preds = %412
  %417 = sub i32 %22, %406
  br label %.sink.split482

.sink.split482:                                   ; preds = %409, %416
  %.sink486 = phi i32 [ %417, %416 ], [ %410, %409 ]
  %.sink467.ph = phi i32 [ -2, %416 ], [ -1, %409 ]
  %.pn491.in = add nsw i32 %.6448, %22
  %.pn491 = sext i32 %.pn491.in to i64
  %.sink483 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %.pn491
  %418 = sext i32 %.sink486 to i64
  %419 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %418
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink483, ptr noundef nonnull %7, ptr noundef %419, ptr noundef nonnull %7) #5
  br label %420

420:                                              ; preds = %.sink.split482, %411, %412, %408
  %.sink467 = phi i32 [ -1, %408 ], [ -2, %412 ], [ -2, %411 ], [ %.sink467.ph, %.sink.split482 ]
  %421 = add nsw i32 %.6448, %.sink467
  %422 = icmp sgt i32 %421, 0
  br i1 %422, label %.lr.ph450, label %.loopexit, !llvm.loop !22

.loopexit:                                        ; preds = %239, %420, %._crit_edge430, %._crit_edge447
  call void @zsyconv_(ptr noundef %0, ptr noundef nonnull @.str.5, ptr noundef nonnull %1, ptr noundef %3, ptr noundef nonnull %4, ptr noundef %5, ptr noundef %8, ptr noundef nonnull %17) #5
  br label %423

423:                                              ; preds = %45, %.loopexit, %.thread
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %17) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %13) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %12) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %11) #5
  ret void
}

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

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

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

declare void @zsyconv_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @zswap_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @ztrsm_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @zdscal_(ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden { double, double } @Cd(ptr noundef) local_unnamed_addr #3

declare { double, double } @__divdc3(double, double, double, double) local_unnamed_addr

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(ptr noundef) local_unnamed_addr #3

; 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 nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.umax.i32(i32, i32) #4

; 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 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = distinct !{!9, !10}
!10 = !{!"llvm.loop.mustprogress"}
!11 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 8}
!13 = !{!"double", !7, i64 0}
!14 = !{!13, !13, i64 0}
!15 = !{!12, !13, i64 8}
!16 = distinct !{!16, !10}
!17 = distinct !{!17, !10}
!18 = distinct !{!18, !10}
!19 = distinct !{!19, !10}
!20 = distinct !{!20, !10}
!21 = distinct !{!21, !10}
!22 = distinct !{!22, !10}


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