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

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

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

66:                                               ; preds = %9
  %67 = load ptr, ptr %10, align 8, !tbaa !5
  %68 = call i32 @lsame_(ptr noundef %67, ptr noundef @.str.1)
  %69 = icmp ne i32 %68, 0
  br i1 %69, label %72, label %70

70:                                               ; preds = %66
  %71 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -1, ptr %71, align 4, !tbaa !9
  br label %118

72:                                               ; preds = %66, %9
  %73 = load ptr, ptr %11, align 8, !tbaa !5
  %74 = load i32, ptr %73, align 4, !tbaa !9
  %75 = icmp slt i32 %74, 0
  br i1 %75, label %76, label %78

76:                                               ; preds = %72
  %77 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -2, ptr %77, align 4, !tbaa !9
  br label %117

78:                                               ; preds = %72
  %79 = load ptr, ptr %12, align 8, !tbaa !5
  %80 = load i32, ptr %79, align 4, !tbaa !9
  %81 = icmp slt i32 %80, 0
  br i1 %81, label %82, label %84

82:                                               ; preds = %78
  %83 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -3, ptr %83, align 4, !tbaa !9
  br label %116

84:                                               ; preds = %78
  %85 = load ptr, ptr %14, align 8, !tbaa !5
  %86 = load i32, ptr %85, align 4, !tbaa !9
  %87 = load ptr, ptr %11, align 8, !tbaa !5
  %88 = load i32, ptr %87, align 4, !tbaa !9
  %89 = icmp sge i32 1, %88
  br i1 %89, label %90, label %91

90:                                               ; preds = %84
  br label %94

91:                                               ; preds = %84
  %92 = load ptr, ptr %11, align 8, !tbaa !5
  %93 = load i32, ptr %92, align 4, !tbaa !9
  br label %94

94:                                               ; preds = %91, %90
  %95 = phi i32 [ 1, %90 ], [ %93, %91 ]
  %96 = icmp slt i32 %86, %95
  br i1 %96, label %97, label %99

97:                                               ; preds = %94
  %98 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -5, ptr %98, align 4, !tbaa !9
  br label %115

99:                                               ; preds = %94
  %100 = load ptr, ptr %17, align 8, !tbaa !5
  %101 = load i32, ptr %100, align 4, !tbaa !9
  %102 = load ptr, ptr %11, align 8, !tbaa !5
  %103 = load i32, ptr %102, align 4, !tbaa !9
  %104 = icmp sge i32 1, %103
  br i1 %104, label %105, label %106

105:                                              ; preds = %99
  br label %109

106:                                              ; preds = %99
  %107 = load ptr, ptr %11, align 8, !tbaa !5
  %108 = load i32, ptr %107, align 4, !tbaa !9
  br label %109

109:                                              ; preds = %106, %105
  %110 = phi i32 [ 1, %105 ], [ %108, %106 ]
  %111 = icmp slt i32 %101, %110
  br i1 %111, label %112, label %114

112:                                              ; preds = %109
  %113 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -8, ptr %113, align 4, !tbaa !9
  br label %114

114:                                              ; preds = %112, %109
  br label %115

115:                                              ; preds = %114, %97
  br label %116

116:                                              ; preds = %115, %82
  br label %117

117:                                              ; preds = %116, %76
  br label %118

118:                                              ; preds = %117, %70
  %119 = load ptr, ptr %18, align 8, !tbaa !5
  %120 = load i32, ptr %119, align 4, !tbaa !9
  %121 = icmp ne i32 %120, 0
  br i1 %121, label %122, label %127

122:                                              ; preds = %118
  %123 = load ptr, ptr %18, align 8, !tbaa !5
  %124 = load i32, ptr %123, align 4, !tbaa !9
  %125 = sub nsw i32 0, %124
  store i32 %125, ptr %23, align 4, !tbaa !9
  %126 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %23, i32 noundef 11)
  store i32 1, ptr %38, align 4
  br label %1598

127:                                              ; preds = %118
  %128 = load ptr, ptr %11, align 8, !tbaa !5
  %129 = load i32, ptr %128, align 4, !tbaa !9
  %130 = icmp eq i32 %129, 0
  br i1 %130, label %135, label %131

131:                                              ; preds = %127
  %132 = load ptr, ptr %12, align 8, !tbaa !5
  %133 = load i32, ptr %132, align 4, !tbaa !9
  %134 = icmp eq i32 %133, 0
  br i1 %134, label %135, label %136

135:                                              ; preds = %131, %127
  store i32 1, ptr %38, align 4
  br label %1598

136:                                              ; preds = %131
  %137 = load i32, ptr %32, align 4, !tbaa !9
  %138 = icmp ne i32 %137, 0
  br i1 %138, label %139, label %841

139:                                              ; preds = %136
  %140 = load ptr, ptr %11, align 8, !tbaa !5
  %141 = load i32, ptr %140, align 4, !tbaa !9
  store i32 %141, ptr %30, align 4, !tbaa !9
  br label %142

142:                                              ; preds = %656, %139
  %143 = load i32, ptr %30, align 4, !tbaa !9
  %144 = icmp slt i32 %143, 1
  br i1 %144, label %145, label %146

145:                                              ; preds = %142
  br label %657

146:                                              ; preds = %142
  %147 = load ptr, ptr %15, align 8, !tbaa !5
  %148 = load i32, ptr %30, align 4, !tbaa !9
  %149 = sext i32 %148 to i64
  %150 = getelementptr inbounds i32, ptr %147, i64 %149
  %151 = load i32, ptr %150, align 4, !tbaa !9
  %152 = icmp sgt i32 %151, 0
  br i1 %152, label %153, label %234

153:                                              ; preds = %146
  %154 = load ptr, ptr %15, align 8, !tbaa !5
  %155 = load i32, ptr %30, align 4, !tbaa !9
  %156 = sext i32 %155 to i64
  %157 = getelementptr inbounds i32, ptr %154, i64 %156
  %158 = load i32, ptr %157, align 4, !tbaa !9
  store i32 %158, ptr %35, align 4, !tbaa !9
  %159 = load i32, ptr %35, align 4, !tbaa !9
  %160 = load i32, ptr %30, align 4, !tbaa !9
  %161 = icmp ne i32 %159, %160
  br i1 %161, label %162, label %178

162:                                              ; preds = %153
  %163 = load ptr, ptr %12, align 8, !tbaa !5
  %164 = load ptr, ptr %16, align 8, !tbaa !5
  %165 = load i32, ptr %30, align 4, !tbaa !9
  %166 = load i32, ptr %21, align 4, !tbaa !9
  %167 = add nsw i32 %165, %166
  %168 = sext i32 %167 to i64
  %169 = getelementptr inbounds %struct.doublecomplex, ptr %164, i64 %168
  %170 = load ptr, ptr %17, align 8, !tbaa !5
  %171 = load ptr, ptr %16, align 8, !tbaa !5
  %172 = load i32, ptr %35, align 4, !tbaa !9
  %173 = load i32, ptr %21, align 4, !tbaa !9
  %174 = add nsw i32 %172, %173
  %175 = sext i32 %174 to i64
  %176 = getelementptr inbounds %struct.doublecomplex, ptr %171, i64 %175
  %177 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %163, ptr noundef %169, ptr noundef %170, ptr noundef %176, ptr noundef %177)
  br label %178

178:                                              ; preds = %162, %153
  %179 = load i32, ptr %30, align 4, !tbaa !9
  %180 = sub nsw i32 %179, 1
  store i32 %180, ptr %23, align 4, !tbaa !9
  %181 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %181, align 8, !tbaa !11
  %182 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %182, align 8, !tbaa !14
  %183 = load ptr, ptr %12, align 8, !tbaa !5
  %184 = load ptr, ptr %13, align 8, !tbaa !5
  %185 = load i32, ptr %30, align 4, !tbaa !9
  %186 = load i32, ptr %19, align 4, !tbaa !9
  %187 = mul nsw i32 %185, %186
  %188 = add nsw i32 %187, 1
  %189 = sext i32 %188 to i64
  %190 = getelementptr inbounds %struct.doublecomplex, ptr %184, i64 %189
  %191 = load ptr, ptr %16, align 8, !tbaa !5
  %192 = load i32, ptr %30, align 4, !tbaa !9
  %193 = load i32, ptr %21, align 4, !tbaa !9
  %194 = add nsw i32 %192, %193
  %195 = sext i32 %194 to i64
  %196 = getelementptr inbounds %struct.doublecomplex, ptr %191, i64 %195
  %197 = load ptr, ptr %17, align 8, !tbaa !5
  %198 = load ptr, ptr %16, align 8, !tbaa !5
  %199 = load i32, ptr %21, align 4, !tbaa !9
  %200 = add nsw i32 %199, 1
  %201 = sext i32 %200 to i64
  %202 = getelementptr inbounds %struct.doublecomplex, ptr %198, i64 %201
  %203 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %183, ptr noundef %25, ptr noundef %190, ptr noundef @c__1, ptr noundef %196, ptr noundef %197, ptr noundef %202, ptr noundef %203)
  %204 = call { double, double } @Cd(ptr noundef @c_b1)
  %205 = extractvalue { double, double } %204, 0
  %206 = extractvalue { double, double } %204, 1
  %207 = load ptr, ptr %13, align 8, !tbaa !5
  %208 = load i32, ptr %30, align 4, !tbaa !9
  %209 = load i32, ptr %30, align 4, !tbaa !9
  %210 = load i32, ptr %19, align 4, !tbaa !9
  %211 = mul nsw i32 %209, %210
  %212 = add nsw i32 %208, %211
  %213 = sext i32 %212 to i64
  %214 = getelementptr inbounds %struct.doublecomplex, ptr %207, i64 %213
  %215 = call { double, double } @Cd(ptr noundef %214)
  %216 = extractvalue { double, double } %215, 0
  %217 = extractvalue { double, double } %215, 1
  %218 = call { double, double } @__divdc3(double noundef %205, double noundef %206, double noundef %216, double noundef %217) #5
  %219 = extractvalue { double, double } %218, 0
  %220 = extractvalue { double, double } %218, 1
  %221 = call ptr @_pCd(ptr noundef %25)
  %222 = getelementptr inbounds { double, double }, ptr %221, i32 0, i32 0
  %223 = getelementptr inbounds { double, double }, ptr %221, i32 0, i32 1
  store double %219, ptr %222, align 8
  store double %220, ptr %223, align 8
  %224 = load ptr, ptr %12, align 8, !tbaa !5
  %225 = load ptr, ptr %16, align 8, !tbaa !5
  %226 = load i32, ptr %30, align 4, !tbaa !9
  %227 = load i32, ptr %21, align 4, !tbaa !9
  %228 = add nsw i32 %226, %227
  %229 = sext i32 %228 to i64
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %225, i64 %229
  %231 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zscal_(ptr noundef %224, ptr noundef %25, ptr noundef %230, ptr noundef %231)
  %232 = load i32, ptr %30, align 4, !tbaa !9
  %233 = add nsw i32 %232, -1
  store i32 %233, ptr %30, align 4, !tbaa !9
  br label %656

234:                                              ; preds = %146
  %235 = load ptr, ptr %15, align 8, !tbaa !5
  %236 = load i32, ptr %30, align 4, !tbaa !9
  %237 = sext i32 %236 to i64
  %238 = getelementptr inbounds i32, ptr %235, i64 %237
  %239 = load i32, ptr %238, align 4, !tbaa !9
  %240 = sub nsw i32 0, %239
  store i32 %240, ptr %35, align 4, !tbaa !9
  %241 = load i32, ptr %35, align 4, !tbaa !9
  %242 = load i32, ptr %30, align 4, !tbaa !9
  %243 = icmp ne i32 %241, %242
  br i1 %243, label %244, label %260

244:                                              ; preds = %234
  %245 = load ptr, ptr %12, align 8, !tbaa !5
  %246 = load ptr, ptr %16, align 8, !tbaa !5
  %247 = load i32, ptr %30, align 4, !tbaa !9
  %248 = load i32, ptr %21, align 4, !tbaa !9
  %249 = add nsw i32 %247, %248
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds %struct.doublecomplex, ptr %246, i64 %250
  %252 = load ptr, ptr %17, align 8, !tbaa !5
  %253 = load ptr, ptr %16, align 8, !tbaa !5
  %254 = load i32, ptr %35, align 4, !tbaa !9
  %255 = load i32, ptr %21, align 4, !tbaa !9
  %256 = add nsw i32 %254, %255
  %257 = sext i32 %256 to i64
  %258 = getelementptr inbounds %struct.doublecomplex, ptr %253, i64 %257
  %259 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %245, ptr noundef %251, ptr noundef %252, ptr noundef %258, ptr noundef %259)
  br label %260

260:                                              ; preds = %244, %234
  %261 = load ptr, ptr %15, align 8, !tbaa !5
  %262 = load i32, ptr %30, align 4, !tbaa !9
  %263 = sub nsw i32 %262, 1
  %264 = sext i32 %263 to i64
  %265 = getelementptr inbounds i32, ptr %261, i64 %264
  %266 = load i32, ptr %265, align 4, !tbaa !9
  %267 = sub nsw i32 0, %266
  store i32 %267, ptr %35, align 4, !tbaa !9
  %268 = load i32, ptr %35, align 4, !tbaa !9
  %269 = load i32, ptr %30, align 4, !tbaa !9
  %270 = sub nsw i32 %269, 1
  %271 = icmp ne i32 %268, %270
  br i1 %271, label %272, label %289

272:                                              ; preds = %260
  %273 = load ptr, ptr %12, align 8, !tbaa !5
  %274 = load ptr, ptr %16, align 8, !tbaa !5
  %275 = load i32, ptr %30, align 4, !tbaa !9
  %276 = sub nsw i32 %275, 1
  %277 = load i32, ptr %21, align 4, !tbaa !9
  %278 = add nsw i32 %276, %277
  %279 = sext i32 %278 to i64
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %274, i64 %279
  %281 = load ptr, ptr %17, align 8, !tbaa !5
  %282 = load ptr, ptr %16, align 8, !tbaa !5
  %283 = load i32, ptr %35, align 4, !tbaa !9
  %284 = load i32, ptr %21, align 4, !tbaa !9
  %285 = add nsw i32 %283, %284
  %286 = sext i32 %285 to i64
  %287 = getelementptr inbounds %struct.doublecomplex, ptr %282, i64 %286
  %288 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %273, ptr noundef %280, ptr noundef %281, ptr noundef %287, ptr noundef %288)
  br label %289

289:                                              ; preds = %272, %260
  %290 = load i32, ptr %30, align 4, !tbaa !9
  %291 = icmp sgt i32 %290, 2
  br i1 %291, label %292, label %345

292:                                              ; preds = %289
  %293 = load i32, ptr %30, align 4, !tbaa !9
  %294 = sub nsw i32 %293, 2
  store i32 %294, ptr %23, align 4, !tbaa !9
  %295 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %295, align 8, !tbaa !11
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %296, align 8, !tbaa !14
  %297 = load ptr, ptr %12, align 8, !tbaa !5
  %298 = load ptr, ptr %13, align 8, !tbaa !5
  %299 = load i32, ptr %30, align 4, !tbaa !9
  %300 = load i32, ptr %19, align 4, !tbaa !9
  %301 = mul nsw i32 %299, %300
  %302 = add nsw i32 %301, 1
  %303 = sext i32 %302 to i64
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %298, i64 %303
  %305 = load ptr, ptr %16, align 8, !tbaa !5
  %306 = load i32, ptr %30, align 4, !tbaa !9
  %307 = load i32, ptr %21, align 4, !tbaa !9
  %308 = add nsw i32 %306, %307
  %309 = sext i32 %308 to i64
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %305, i64 %309
  %311 = load ptr, ptr %17, align 8, !tbaa !5
  %312 = load ptr, ptr %16, align 8, !tbaa !5
  %313 = load i32, ptr %21, align 4, !tbaa !9
  %314 = add nsw i32 %313, 1
  %315 = sext i32 %314 to i64
  %316 = getelementptr inbounds %struct.doublecomplex, ptr %312, i64 %315
  %317 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %297, ptr noundef %25, ptr noundef %304, ptr noundef @c__1, ptr noundef %310, ptr noundef %311, ptr noundef %316, ptr noundef %317)
  %318 = load i32, ptr %30, align 4, !tbaa !9
  %319 = sub nsw i32 %318, 2
  store i32 %319, ptr %23, align 4, !tbaa !9
  %320 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %320, align 8, !tbaa !11
  %321 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %321, align 8, !tbaa !14
  %322 = load ptr, ptr %12, align 8, !tbaa !5
  %323 = load ptr, ptr %13, align 8, !tbaa !5
  %324 = load i32, ptr %30, align 4, !tbaa !9
  %325 = sub nsw i32 %324, 1
  %326 = load i32, ptr %19, align 4, !tbaa !9
  %327 = mul nsw i32 %325, %326
  %328 = add nsw i32 %327, 1
  %329 = sext i32 %328 to i64
  %330 = getelementptr inbounds %struct.doublecomplex, ptr %323, i64 %329
  %331 = load ptr, ptr %16, align 8, !tbaa !5
  %332 = load i32, ptr %30, align 4, !tbaa !9
  %333 = sub nsw i32 %332, 1
  %334 = load i32, ptr %21, align 4, !tbaa !9
  %335 = add nsw i32 %333, %334
  %336 = sext i32 %335 to i64
  %337 = getelementptr inbounds %struct.doublecomplex, ptr %331, i64 %336
  %338 = load ptr, ptr %17, align 8, !tbaa !5
  %339 = load ptr, ptr %16, align 8, !tbaa !5
  %340 = load i32, ptr %21, align 4, !tbaa !9
  %341 = add nsw i32 %340, 1
  %342 = sext i32 %341 to i64
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %339, i64 %342
  %344 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %322, ptr noundef %25, ptr noundef %330, ptr noundef @c__1, ptr noundef %337, ptr noundef %338, ptr noundef %343, ptr noundef %344)
  br label %345

345:                                              ; preds = %292, %289
  %346 = load i32, ptr %30, align 4, !tbaa !9
  %347 = sub nsw i32 %346, 1
  %348 = load i32, ptr %30, align 4, !tbaa !9
  %349 = load i32, ptr %19, align 4, !tbaa !9
  %350 = mul nsw i32 %348, %349
  %351 = add nsw i32 %347, %350
  store i32 %351, ptr %23, align 4, !tbaa !9
  %352 = load ptr, ptr %13, align 8, !tbaa !5
  %353 = load i32, ptr %23, align 4, !tbaa !9
  %354 = sext i32 %353 to i64
  %355 = getelementptr inbounds %struct.doublecomplex, ptr %352, i64 %354
  %356 = getelementptr inbounds %struct.doublecomplex, ptr %355, i32 0, i32 0
  %357 = load double, ptr %356, align 8, !tbaa !11
  %358 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %357, ptr %358, align 8, !tbaa !11
  %359 = load ptr, ptr %13, align 8, !tbaa !5
  %360 = load i32, ptr %23, align 4, !tbaa !9
  %361 = sext i32 %360 to i64
  %362 = getelementptr inbounds %struct.doublecomplex, ptr %359, i64 %361
  %363 = getelementptr inbounds %struct.doublecomplex, ptr %362, i32 0, i32 1
  %364 = load double, ptr %363, align 8, !tbaa !14
  %365 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %364, ptr %365, align 8, !tbaa !14
  %366 = load ptr, ptr %13, align 8, !tbaa !5
  %367 = load i32, ptr %30, align 4, !tbaa !9
  %368 = sub nsw i32 %367, 1
  %369 = load i32, ptr %30, align 4, !tbaa !9
  %370 = sub nsw i32 %369, 1
  %371 = load i32, ptr %19, align 4, !tbaa !9
  %372 = mul nsw i32 %370, %371
  %373 = add nsw i32 %368, %372
  %374 = sext i32 %373 to i64
  %375 = getelementptr inbounds %struct.doublecomplex, ptr %366, i64 %374
  %376 = call { double, double } @Cd(ptr noundef %375)
  %377 = extractvalue { double, double } %376, 0
  %378 = extractvalue { double, double } %376, 1
  %379 = call { double, double } @Cd(ptr noundef %28)
  %380 = extractvalue { double, double } %379, 0
  %381 = extractvalue { double, double } %379, 1
  %382 = call { double, double } @__divdc3(double noundef %377, double noundef %378, double noundef %380, double noundef %381) #5
  %383 = extractvalue { double, double } %382, 0
  %384 = extractvalue { double, double } %382, 1
  %385 = call ptr @_pCd(ptr noundef %25)
  %386 = getelementptr inbounds { double, double }, ptr %385, i32 0, i32 0
  %387 = getelementptr inbounds { double, double }, ptr %385, i32 0, i32 1
  store double %383, ptr %386, align 8
  store double %384, ptr %387, align 8
  %388 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %389 = load double, ptr %388, align 8, !tbaa !11
  %390 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  store double %389, ptr %390, align 8, !tbaa !11
  %391 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %392 = load double, ptr %391, align 8, !tbaa !14
  %393 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  store double %392, ptr %393, align 8, !tbaa !14
  %394 = load ptr, ptr %13, align 8, !tbaa !5
  %395 = load i32, ptr %30, align 4, !tbaa !9
  %396 = load i32, ptr %30, align 4, !tbaa !9
  %397 = load i32, ptr %19, align 4, !tbaa !9
  %398 = mul nsw i32 %396, %397
  %399 = add nsw i32 %395, %398
  %400 = sext i32 %399 to i64
  %401 = getelementptr inbounds %struct.doublecomplex, ptr %394, i64 %400
  %402 = call { double, double } @Cd(ptr noundef %401)
  %403 = extractvalue { double, double } %402, 0
  %404 = extractvalue { double, double } %402, 1
  %405 = call { double, double } @Cd(ptr noundef %28)
  %406 = extractvalue { double, double } %405, 0
  %407 = extractvalue { double, double } %405, 1
  %408 = call { double, double } @__divdc3(double noundef %403, double noundef %404, double noundef %406, double noundef %407) #5
  %409 = extractvalue { double, double } %408, 0
  %410 = extractvalue { double, double } %408, 1
  %411 = call ptr @_pCd(ptr noundef %25)
  %412 = getelementptr inbounds { double, double }, ptr %411, i32 0, i32 0
  %413 = getelementptr inbounds { double, double }, ptr %411, i32 0, i32 1
  store double %409, ptr %412, align 8
  store double %410, ptr %413, align 8
  %414 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %415 = load double, ptr %414, align 8, !tbaa !11
  %416 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %415, ptr %416, align 8, !tbaa !11
  %417 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %418 = load double, ptr %417, align 8, !tbaa !14
  %419 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %418, ptr %419, align 8, !tbaa !14
  %420 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %421 = load double, ptr %420, align 8, !tbaa !11
  %422 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %423 = load double, ptr %422, align 8, !tbaa !11
  %424 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %425 = load double, ptr %424, align 8, !tbaa !14
  %426 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %427 = load double, ptr %426, align 8, !tbaa !14
  %428 = fmul double %425, %427
  %429 = fneg double %428
  %430 = call double @llvm.fmuladd.f64(double %421, double %423, double %429)
  %431 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %430, ptr %431, align 8, !tbaa !11
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %433 = load double, ptr %432, align 8, !tbaa !11
  %434 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %435 = load double, ptr %434, align 8, !tbaa !14
  %436 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %437 = load double, ptr %436, align 8, !tbaa !14
  %438 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %439 = load double, ptr %438, align 8, !tbaa !11
  %440 = fmul double %437, %439
  %441 = call double @llvm.fmuladd.f64(double %433, double %435, double %440)
  %442 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %441, ptr %442, align 8, !tbaa !14
  %443 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %444 = load double, ptr %443, align 8, !tbaa !11
  %445 = fsub double %444, 1.000000e+00
  %446 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %445, ptr %446, align 8, !tbaa !11
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %448 = load double, ptr %447, align 8, !tbaa !14
  %449 = fadd double %448, 0.000000e+00
  %450 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %449, ptr %450, align 8, !tbaa !14
  %451 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %452 = load double, ptr %451, align 8, !tbaa !11
  %453 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %452, ptr %453, align 8, !tbaa !11
  %454 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %455 = load double, ptr %454, align 8, !tbaa !14
  %456 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %455, ptr %456, align 8, !tbaa !14
  %457 = load ptr, ptr %12, align 8, !tbaa !5
  %458 = load i32, ptr %457, align 4, !tbaa !9
  store i32 %458, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %29, align 4, !tbaa !9
  br label %459

459:                                              ; preds = %650, %345
  %460 = load i32, ptr %29, align 4, !tbaa !9
  %461 = load i32, ptr %23, align 4, !tbaa !9
  %462 = icmp sle i32 %460, %461
  br i1 %462, label %463, label %653

463:                                              ; preds = %459
  %464 = load ptr, ptr %16, align 8, !tbaa !5
  %465 = load i32, ptr %30, align 4, !tbaa !9
  %466 = sub nsw i32 %465, 1
  %467 = load i32, ptr %29, align 4, !tbaa !9
  %468 = load i32, ptr %21, align 4, !tbaa !9
  %469 = mul nsw i32 %467, %468
  %470 = add nsw i32 %466, %469
  %471 = sext i32 %470 to i64
  %472 = getelementptr inbounds %struct.doublecomplex, ptr %464, i64 %471
  %473 = call { double, double } @Cd(ptr noundef %472)
  %474 = extractvalue { double, double } %473, 0
  %475 = extractvalue { double, double } %473, 1
  %476 = call { double, double } @Cd(ptr noundef %28)
  %477 = extractvalue { double, double } %476, 0
  %478 = extractvalue { double, double } %476, 1
  %479 = call { double, double } @__divdc3(double noundef %474, double noundef %475, double noundef %477, double noundef %478) #5
  %480 = extractvalue { double, double } %479, 0
  %481 = extractvalue { double, double } %479, 1
  %482 = call ptr @_pCd(ptr noundef %25)
  %483 = getelementptr inbounds { double, double }, ptr %482, i32 0, i32 0
  %484 = getelementptr inbounds { double, double }, ptr %482, i32 0, i32 1
  store double %480, ptr %483, align 8
  store double %481, ptr %484, align 8
  %485 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %486 = load double, ptr %485, align 8, !tbaa !11
  %487 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  store double %486, ptr %487, align 8, !tbaa !11
  %488 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %489 = load double, ptr %488, align 8, !tbaa !14
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  store double %489, ptr %490, align 8, !tbaa !14
  %491 = load ptr, ptr %16, align 8, !tbaa !5
  %492 = load i32, ptr %30, align 4, !tbaa !9
  %493 = load i32, ptr %29, align 4, !tbaa !9
  %494 = load i32, ptr %21, align 4, !tbaa !9
  %495 = mul nsw i32 %493, %494
  %496 = add nsw i32 %492, %495
  %497 = sext i32 %496 to i64
  %498 = getelementptr inbounds %struct.doublecomplex, ptr %491, i64 %497
  %499 = call { double, double } @Cd(ptr noundef %498)
  %500 = extractvalue { double, double } %499, 0
  %501 = extractvalue { double, double } %499, 1
  %502 = call { double, double } @Cd(ptr noundef %28)
  %503 = extractvalue { double, double } %502, 0
  %504 = extractvalue { double, double } %502, 1
  %505 = call { double, double } @__divdc3(double noundef %500, double noundef %501, double noundef %503, double noundef %504) #5
  %506 = extractvalue { double, double } %505, 0
  %507 = extractvalue { double, double } %505, 1
  %508 = call ptr @_pCd(ptr noundef %25)
  %509 = getelementptr inbounds { double, double }, ptr %508, i32 0, i32 0
  %510 = getelementptr inbounds { double, double }, ptr %508, i32 0, i32 1
  store double %506, ptr %509, align 8
  store double %507, ptr %510, align 8
  %511 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %512 = load double, ptr %511, align 8, !tbaa !11
  %513 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %512, ptr %513, align 8, !tbaa !11
  %514 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %515 = load double, ptr %514, align 8, !tbaa !14
  %516 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %515, ptr %516, align 8, !tbaa !14
  %517 = load i32, ptr %30, align 4, !tbaa !9
  %518 = sub nsw i32 %517, 1
  %519 = load i32, ptr %29, align 4, !tbaa !9
  %520 = load i32, ptr %21, align 4, !tbaa !9
  %521 = mul nsw i32 %519, %520
  %522 = add nsw i32 %518, %521
  store i32 %522, ptr %24, align 4, !tbaa !9
  %523 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %524 = load double, ptr %523, align 8, !tbaa !11
  %525 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %526 = load double, ptr %525, align 8, !tbaa !11
  %527 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %528 = load double, ptr %527, align 8, !tbaa !14
  %529 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %530 = load double, ptr %529, align 8, !tbaa !14
  %531 = fmul double %528, %530
  %532 = fneg double %531
  %533 = call double @llvm.fmuladd.f64(double %524, double %526, double %532)
  %534 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %533, ptr %534, align 8, !tbaa !11
  %535 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %536 = load double, ptr %535, align 8, !tbaa !11
  %537 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %538 = load double, ptr %537, align 8, !tbaa !14
  %539 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %540 = load double, ptr %539, align 8, !tbaa !14
  %541 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %542 = load double, ptr %541, align 8, !tbaa !11
  %543 = fmul double %540, %542
  %544 = call double @llvm.fmuladd.f64(double %536, double %538, double %543)
  %545 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %544, ptr %545, align 8, !tbaa !14
  %546 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %547 = load double, ptr %546, align 8, !tbaa !11
  %548 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %549 = load double, ptr %548, align 8, !tbaa !11
  %550 = fsub double %547, %549
  %551 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %550, ptr %551, align 8, !tbaa !11
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %553 = load double, ptr %552, align 8, !tbaa !14
  %554 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %555 = load double, ptr %554, align 8, !tbaa !14
  %556 = fsub double %553, %555
  %557 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %556, ptr %557, align 8, !tbaa !14
  %558 = call { double, double } @Cd(ptr noundef %26)
  %559 = extractvalue { double, double } %558, 0
  %560 = extractvalue { double, double } %558, 1
  %561 = call { double, double } @Cd(ptr noundef %31)
  %562 = extractvalue { double, double } %561, 0
  %563 = extractvalue { double, double } %561, 1
  %564 = call { double, double } @__divdc3(double noundef %559, double noundef %560, double noundef %562, double noundef %563) #5
  %565 = extractvalue { double, double } %564, 0
  %566 = extractvalue { double, double } %564, 1
  %567 = call ptr @_pCd(ptr noundef %25)
  %568 = getelementptr inbounds { double, double }, ptr %567, i32 0, i32 0
  %569 = getelementptr inbounds { double, double }, ptr %567, i32 0, i32 1
  store double %565, ptr %568, align 8
  store double %566, ptr %569, align 8
  %570 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %571 = load double, ptr %570, align 8, !tbaa !11
  %572 = load ptr, ptr %16, align 8, !tbaa !5
  %573 = load i32, ptr %24, align 4, !tbaa !9
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %572, i64 %574
  %576 = getelementptr inbounds %struct.doublecomplex, ptr %575, i32 0, i32 0
  store double %571, ptr %576, align 8, !tbaa !11
  %577 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %578 = load double, ptr %577, align 8, !tbaa !14
  %579 = load ptr, ptr %16, align 8, !tbaa !5
  %580 = load i32, ptr %24, align 4, !tbaa !9
  %581 = sext i32 %580 to i64
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %579, i64 %581
  %583 = getelementptr inbounds %struct.doublecomplex, ptr %582, i32 0, i32 1
  store double %578, ptr %583, align 8, !tbaa !14
  %584 = load i32, ptr %30, align 4, !tbaa !9
  %585 = load i32, ptr %29, align 4, !tbaa !9
  %586 = load i32, ptr %21, align 4, !tbaa !9
  %587 = mul nsw i32 %585, %586
  %588 = add nsw i32 %584, %587
  store i32 %588, ptr %24, align 4, !tbaa !9
  %589 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %590 = load double, ptr %589, align 8, !tbaa !11
  %591 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %592 = load double, ptr %591, align 8, !tbaa !11
  %593 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %594 = load double, ptr %593, align 8, !tbaa !14
  %595 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %596 = load double, ptr %595, align 8, !tbaa !14
  %597 = fmul double %594, %596
  %598 = fneg double %597
  %599 = call double @llvm.fmuladd.f64(double %590, double %592, double %598)
  %600 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %599, ptr %600, align 8, !tbaa !11
  %601 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %602 = load double, ptr %601, align 8, !tbaa !11
  %603 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %604 = load double, ptr %603, align 8, !tbaa !14
  %605 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %606 = load double, ptr %605, align 8, !tbaa !14
  %607 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %608 = load double, ptr %607, align 8, !tbaa !11
  %609 = fmul double %606, %608
  %610 = call double @llvm.fmuladd.f64(double %602, double %604, double %609)
  %611 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %610, ptr %611, align 8, !tbaa !14
  %612 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %613 = load double, ptr %612, align 8, !tbaa !11
  %614 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %615 = load double, ptr %614, align 8, !tbaa !11
  %616 = fsub double %613, %615
  %617 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %616, ptr %617, align 8, !tbaa !11
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %619 = load double, ptr %618, align 8, !tbaa !14
  %620 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %621 = load double, ptr %620, align 8, !tbaa !14
  %622 = fsub double %619, %621
  %623 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %622, ptr %623, align 8, !tbaa !14
  %624 = call { double, double } @Cd(ptr noundef %26)
  %625 = extractvalue { double, double } %624, 0
  %626 = extractvalue { double, double } %624, 1
  %627 = call { double, double } @Cd(ptr noundef %31)
  %628 = extractvalue { double, double } %627, 0
  %629 = extractvalue { double, double } %627, 1
  %630 = call { double, double } @__divdc3(double noundef %625, double noundef %626, double noundef %628, double noundef %629) #5
  %631 = extractvalue { double, double } %630, 0
  %632 = extractvalue { double, double } %630, 1
  %633 = call ptr @_pCd(ptr noundef %25)
  %634 = getelementptr inbounds { double, double }, ptr %633, i32 0, i32 0
  %635 = getelementptr inbounds { double, double }, ptr %633, i32 0, i32 1
  store double %631, ptr %634, align 8
  store double %632, ptr %635, align 8
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %637 = load double, ptr %636, align 8, !tbaa !11
  %638 = load ptr, ptr %16, align 8, !tbaa !5
  %639 = load i32, ptr %24, align 4, !tbaa !9
  %640 = sext i32 %639 to i64
  %641 = getelementptr inbounds %struct.doublecomplex, ptr %638, i64 %640
  %642 = getelementptr inbounds %struct.doublecomplex, ptr %641, i32 0, i32 0
  store double %637, ptr %642, align 8, !tbaa !11
  %643 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %644 = load double, ptr %643, align 8, !tbaa !14
  %645 = load ptr, ptr %16, align 8, !tbaa !5
  %646 = load i32, ptr %24, align 4, !tbaa !9
  %647 = sext i32 %646 to i64
  %648 = getelementptr inbounds %struct.doublecomplex, ptr %645, i64 %647
  %649 = getelementptr inbounds %struct.doublecomplex, ptr %648, i32 0, i32 1
  store double %644, ptr %649, align 8, !tbaa !14
  br label %650

650:                                              ; preds = %463
  %651 = load i32, ptr %29, align 4, !tbaa !9
  %652 = add nsw i32 %651, 1
  store i32 %652, ptr %29, align 4, !tbaa !9
  br label %459, !llvm.loop !15

653:                                              ; preds = %459
  %654 = load i32, ptr %30, align 4, !tbaa !9
  %655 = add nsw i32 %654, -2
  store i32 %655, ptr %30, align 4, !tbaa !9
  br label %656

656:                                              ; preds = %653, %178
  br label %142

657:                                              ; preds = %145
  store i32 1, ptr %30, align 4, !tbaa !9
  br label %658

658:                                              ; preds = %839, %657
  %659 = load i32, ptr %30, align 4, !tbaa !9
  %660 = load ptr, ptr %11, align 8, !tbaa !5
  %661 = load i32, ptr %660, align 4, !tbaa !9
  %662 = icmp sgt i32 %659, %661
  br i1 %662, label %663, label %664

663:                                              ; preds = %658
  br label %840

664:                                              ; preds = %658
  %665 = load ptr, ptr %15, align 8, !tbaa !5
  %666 = load i32, ptr %30, align 4, !tbaa !9
  %667 = sext i32 %666 to i64
  %668 = getelementptr inbounds i32, ptr %665, i64 %667
  %669 = load i32, ptr %668, align 4, !tbaa !9
  %670 = icmp sgt i32 %669, 0
  br i1 %670, label %671, label %727

671:                                              ; preds = %664
  %672 = load i32, ptr %30, align 4, !tbaa !9
  %673 = icmp sgt i32 %672, 1
  br i1 %673, label %674, label %699

674:                                              ; preds = %671
  %675 = load i32, ptr %30, align 4, !tbaa !9
  %676 = sub nsw i32 %675, 1
  store i32 %676, ptr %23, align 4, !tbaa !9
  %677 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %677, align 8, !tbaa !11
  %678 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %678, align 8, !tbaa !14
  %679 = load ptr, ptr %12, align 8, !tbaa !5
  %680 = load ptr, ptr %16, align 8, !tbaa !5
  %681 = load i32, ptr %22, align 4, !tbaa !9
  %682 = sext i32 %681 to i64
  %683 = getelementptr inbounds %struct.doublecomplex, ptr %680, i64 %682
  %684 = load ptr, ptr %17, align 8, !tbaa !5
  %685 = load ptr, ptr %13, align 8, !tbaa !5
  %686 = load i32, ptr %30, align 4, !tbaa !9
  %687 = load i32, ptr %19, align 4, !tbaa !9
  %688 = mul nsw i32 %686, %687
  %689 = add nsw i32 %688, 1
  %690 = sext i32 %689 to i64
  %691 = getelementptr inbounds %struct.doublecomplex, ptr %685, i64 %690
  %692 = load ptr, ptr %16, align 8, !tbaa !5
  %693 = load i32, ptr %30, align 4, !tbaa !9
  %694 = load i32, ptr %21, align 4, !tbaa !9
  %695 = add nsw i32 %693, %694
  %696 = sext i32 %695 to i64
  %697 = getelementptr inbounds %struct.doublecomplex, ptr %692, i64 %696
  %698 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %679, ptr noundef %25, ptr noundef %683, ptr noundef %684, ptr noundef %691, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %697, ptr noundef %698)
  br label %699

699:                                              ; preds = %674, %671
  %700 = load ptr, ptr %15, align 8, !tbaa !5
  %701 = load i32, ptr %30, align 4, !tbaa !9
  %702 = sext i32 %701 to i64
  %703 = getelementptr inbounds i32, ptr %700, i64 %702
  %704 = load i32, ptr %703, align 4, !tbaa !9
  store i32 %704, ptr %35, align 4, !tbaa !9
  %705 = load i32, ptr %35, align 4, !tbaa !9
  %706 = load i32, ptr %30, align 4, !tbaa !9
  %707 = icmp ne i32 %705, %706
  br i1 %707, label %708, label %724

708:                                              ; preds = %699
  %709 = load ptr, ptr %12, align 8, !tbaa !5
  %710 = load ptr, ptr %16, align 8, !tbaa !5
  %711 = load i32, ptr %30, align 4, !tbaa !9
  %712 = load i32, ptr %21, align 4, !tbaa !9
  %713 = add nsw i32 %711, %712
  %714 = sext i32 %713 to i64
  %715 = getelementptr inbounds %struct.doublecomplex, ptr %710, i64 %714
  %716 = load ptr, ptr %17, align 8, !tbaa !5
  %717 = load ptr, ptr %16, align 8, !tbaa !5
  %718 = load i32, ptr %35, align 4, !tbaa !9
  %719 = load i32, ptr %21, align 4, !tbaa !9
  %720 = add nsw i32 %718, %719
  %721 = sext i32 %720 to i64
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %717, i64 %721
  %723 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %709, ptr noundef %715, ptr noundef %716, ptr noundef %722, ptr noundef %723)
  br label %724

724:                                              ; preds = %708, %699
  %725 = load i32, ptr %30, align 4, !tbaa !9
  %726 = add nsw i32 %725, 1
  store i32 %726, ptr %30, align 4, !tbaa !9
  br label %839

727:                                              ; preds = %664
  %728 = load i32, ptr %30, align 4, !tbaa !9
  %729 = icmp sgt i32 %728, 1
  br i1 %729, label %730, label %781

730:                                              ; preds = %727
  %731 = load i32, ptr %30, align 4, !tbaa !9
  %732 = sub nsw i32 %731, 1
  store i32 %732, ptr %23, align 4, !tbaa !9
  %733 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %733, align 8, !tbaa !11
  %734 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %734, align 8, !tbaa !14
  %735 = load ptr, ptr %12, align 8, !tbaa !5
  %736 = load ptr, ptr %16, align 8, !tbaa !5
  %737 = load i32, ptr %22, align 4, !tbaa !9
  %738 = sext i32 %737 to i64
  %739 = getelementptr inbounds %struct.doublecomplex, ptr %736, i64 %738
  %740 = load ptr, ptr %17, align 8, !tbaa !5
  %741 = load ptr, ptr %13, align 8, !tbaa !5
  %742 = load i32, ptr %30, align 4, !tbaa !9
  %743 = load i32, ptr %19, align 4, !tbaa !9
  %744 = mul nsw i32 %742, %743
  %745 = add nsw i32 %744, 1
  %746 = sext i32 %745 to i64
  %747 = getelementptr inbounds %struct.doublecomplex, ptr %741, i64 %746
  %748 = load ptr, ptr %16, align 8, !tbaa !5
  %749 = load i32, ptr %30, align 4, !tbaa !9
  %750 = load i32, ptr %21, 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 %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %735, ptr noundef %25, ptr noundef %739, ptr noundef %740, ptr noundef %747, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %753, ptr noundef %754)
  %755 = load i32, ptr %30, align 4, !tbaa !9
  %756 = sub nsw i32 %755, 1
  store i32 %756, ptr %23, align 4, !tbaa !9
  %757 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %757, align 8, !tbaa !11
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %758, align 8, !tbaa !14
  %759 = load ptr, ptr %12, align 8, !tbaa !5
  %760 = load ptr, ptr %16, align 8, !tbaa !5
  %761 = load i32, ptr %22, align 4, !tbaa !9
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %760, i64 %762
  %764 = load ptr, ptr %17, align 8, !tbaa !5
  %765 = load ptr, ptr %13, align 8, !tbaa !5
  %766 = load i32, ptr %30, align 4, !tbaa !9
  %767 = add nsw i32 %766, 1
  %768 = load i32, ptr %19, align 4, !tbaa !9
  %769 = mul nsw i32 %767, %768
  %770 = add nsw i32 %769, 1
  %771 = sext i32 %770 to i64
  %772 = getelementptr inbounds %struct.doublecomplex, ptr %765, i64 %771
  %773 = load ptr, ptr %16, align 8, !tbaa !5
  %774 = load i32, ptr %30, align 4, !tbaa !9
  %775 = add nsw i32 %774, 1
  %776 = load i32, ptr %21, align 4, !tbaa !9
  %777 = add nsw i32 %775, %776
  %778 = sext i32 %777 to i64
  %779 = getelementptr inbounds %struct.doublecomplex, ptr %773, i64 %778
  %780 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %759, ptr noundef %25, ptr noundef %763, ptr noundef %764, ptr noundef %772, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %779, ptr noundef %780)
  br label %781

781:                                              ; preds = %730, %727
  %782 = load ptr, ptr %15, align 8, !tbaa !5
  %783 = load i32, ptr %30, align 4, !tbaa !9
  %784 = sext i32 %783 to i64
  %785 = getelementptr inbounds i32, ptr %782, i64 %784
  %786 = load i32, ptr %785, align 4, !tbaa !9
  %787 = sub nsw i32 0, %786
  store i32 %787, ptr %35, align 4, !tbaa !9
  %788 = load i32, ptr %35, align 4, !tbaa !9
  %789 = load i32, ptr %30, align 4, !tbaa !9
  %790 = icmp ne i32 %788, %789
  br i1 %790, label %791, label %807

791:                                              ; preds = %781
  %792 = load ptr, ptr %12, align 8, !tbaa !5
  %793 = load ptr, ptr %16, align 8, !tbaa !5
  %794 = load i32, ptr %30, align 4, !tbaa !9
  %795 = load i32, ptr %21, align 4, !tbaa !9
  %796 = add nsw i32 %794, %795
  %797 = sext i32 %796 to i64
  %798 = getelementptr inbounds %struct.doublecomplex, ptr %793, i64 %797
  %799 = load ptr, ptr %17, align 8, !tbaa !5
  %800 = load ptr, ptr %16, align 8, !tbaa !5
  %801 = load i32, ptr %35, align 4, !tbaa !9
  %802 = load i32, ptr %21, align 4, !tbaa !9
  %803 = add nsw i32 %801, %802
  %804 = sext i32 %803 to i64
  %805 = getelementptr inbounds %struct.doublecomplex, ptr %800, i64 %804
  %806 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %792, ptr noundef %798, ptr noundef %799, ptr noundef %805, ptr noundef %806)
  br label %807

807:                                              ; preds = %791, %781
  %808 = load ptr, ptr %15, align 8, !tbaa !5
  %809 = load i32, ptr %30, align 4, !tbaa !9
  %810 = add nsw i32 %809, 1
  %811 = sext i32 %810 to i64
  %812 = getelementptr inbounds i32, ptr %808, i64 %811
  %813 = load i32, ptr %812, align 4, !tbaa !9
  %814 = sub nsw i32 0, %813
  store i32 %814, ptr %35, align 4, !tbaa !9
  %815 = load i32, ptr %35, align 4, !tbaa !9
  %816 = load i32, ptr %30, align 4, !tbaa !9
  %817 = add nsw i32 %816, 1
  %818 = icmp ne i32 %815, %817
  br i1 %818, label %819, label %836

819:                                              ; preds = %807
  %820 = load ptr, ptr %12, align 8, !tbaa !5
  %821 = load ptr, ptr %16, align 8, !tbaa !5
  %822 = load i32, ptr %30, align 4, !tbaa !9
  %823 = add nsw i32 %822, 1
  %824 = load i32, ptr %21, align 4, !tbaa !9
  %825 = add nsw i32 %823, %824
  %826 = sext i32 %825 to i64
  %827 = getelementptr inbounds %struct.doublecomplex, ptr %821, i64 %826
  %828 = load ptr, ptr %17, align 8, !tbaa !5
  %829 = load ptr, ptr %16, align 8, !tbaa !5
  %830 = load i32, ptr %35, align 4, !tbaa !9
  %831 = load i32, ptr %21, align 4, !tbaa !9
  %832 = add nsw i32 %830, %831
  %833 = sext i32 %832 to i64
  %834 = getelementptr inbounds %struct.doublecomplex, ptr %829, i64 %833
  %835 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %820, ptr noundef %827, ptr noundef %828, ptr noundef %834, ptr noundef %835)
  br label %836

836:                                              ; preds = %819, %807
  %837 = load i32, ptr %30, align 4, !tbaa !9
  %838 = add nsw i32 %837, 2
  store i32 %838, ptr %30, align 4, !tbaa !9
  br label %839

839:                                              ; preds = %836, %724
  br label %658

840:                                              ; preds = %663
  br label %1597

841:                                              ; preds = %136
  store i32 1, ptr %30, align 4, !tbaa !9
  br label %842

842:                                              ; preds = %1387, %841
  %843 = load i32, ptr %30, align 4, !tbaa !9
  %844 = load ptr, ptr %11, align 8, !tbaa !5
  %845 = load i32, ptr %844, align 4, !tbaa !9
  %846 = icmp sgt i32 %843, %845
  br i1 %846, label %847, label %848

847:                                              ; preds = %842
  br label %1388

848:                                              ; preds = %842
  %849 = load ptr, ptr %15, align 8, !tbaa !5
  %850 = load i32, ptr %30, align 4, !tbaa !9
  %851 = sext i32 %850 to i64
  %852 = getelementptr inbounds i32, ptr %849, i64 %851
  %853 = load i32, ptr %852, align 4, !tbaa !9
  %854 = icmp sgt i32 %853, 0
  br i1 %854, label %855, label %948

855:                                              ; preds = %848
  %856 = load ptr, ptr %15, align 8, !tbaa !5
  %857 = load i32, ptr %30, align 4, !tbaa !9
  %858 = sext i32 %857 to i64
  %859 = getelementptr inbounds i32, ptr %856, i64 %858
  %860 = load i32, ptr %859, align 4, !tbaa !9
  store i32 %860, ptr %35, align 4, !tbaa !9
  %861 = load i32, ptr %35, align 4, !tbaa !9
  %862 = load i32, ptr %30, align 4, !tbaa !9
  %863 = icmp ne i32 %861, %862
  br i1 %863, label %864, label %880

864:                                              ; preds = %855
  %865 = load ptr, ptr %12, align 8, !tbaa !5
  %866 = load ptr, ptr %16, align 8, !tbaa !5
  %867 = load i32, ptr %30, align 4, !tbaa !9
  %868 = load i32, ptr %21, align 4, !tbaa !9
  %869 = add nsw i32 %867, %868
  %870 = sext i32 %869 to i64
  %871 = getelementptr inbounds %struct.doublecomplex, ptr %866, i64 %870
  %872 = load ptr, ptr %17, align 8, !tbaa !5
  %873 = load ptr, ptr %16, align 8, !tbaa !5
  %874 = load i32, ptr %35, align 4, !tbaa !9
  %875 = load i32, ptr %21, align 4, !tbaa !9
  %876 = add nsw i32 %874, %875
  %877 = sext i32 %876 to i64
  %878 = getelementptr inbounds %struct.doublecomplex, ptr %873, i64 %877
  %879 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %865, ptr noundef %871, ptr noundef %872, ptr noundef %878, ptr noundef %879)
  br label %880

880:                                              ; preds = %864, %855
  %881 = load i32, ptr %30, align 4, !tbaa !9
  %882 = load ptr, ptr %11, align 8, !tbaa !5
  %883 = load i32, ptr %882, align 4, !tbaa !9
  %884 = icmp slt i32 %881, %883
  br i1 %884, label %885, label %917

885:                                              ; preds = %880
  %886 = load ptr, ptr %11, align 8, !tbaa !5
  %887 = load i32, ptr %886, align 4, !tbaa !9
  %888 = load i32, ptr %30, align 4, !tbaa !9
  %889 = sub nsw i32 %887, %888
  store i32 %889, ptr %23, align 4, !tbaa !9
  %890 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %890, align 8, !tbaa !11
  %891 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %891, align 8, !tbaa !14
  %892 = load ptr, ptr %12, align 8, !tbaa !5
  %893 = load ptr, ptr %13, align 8, !tbaa !5
  %894 = load i32, ptr %30, align 4, !tbaa !9
  %895 = add nsw i32 %894, 1
  %896 = load i32, ptr %30, align 4, !tbaa !9
  %897 = load i32, ptr %19, align 4, !tbaa !9
  %898 = mul nsw i32 %896, %897
  %899 = add nsw i32 %895, %898
  %900 = sext i32 %899 to i64
  %901 = getelementptr inbounds %struct.doublecomplex, ptr %893, i64 %900
  %902 = load ptr, ptr %16, align 8, !tbaa !5
  %903 = load i32, ptr %30, align 4, !tbaa !9
  %904 = load i32, ptr %21, align 4, !tbaa !9
  %905 = add nsw i32 %903, %904
  %906 = sext i32 %905 to i64
  %907 = getelementptr inbounds %struct.doublecomplex, ptr %902, i64 %906
  %908 = load ptr, ptr %17, align 8, !tbaa !5
  %909 = load ptr, ptr %16, align 8, !tbaa !5
  %910 = load i32, ptr %30, align 4, !tbaa !9
  %911 = add nsw i32 %910, 1
  %912 = load i32, ptr %21, align 4, !tbaa !9
  %913 = add nsw i32 %911, %912
  %914 = sext i32 %913 to i64
  %915 = getelementptr inbounds %struct.doublecomplex, ptr %909, i64 %914
  %916 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %892, ptr noundef %25, ptr noundef %901, ptr noundef @c__1, ptr noundef %907, ptr noundef %908, ptr noundef %915, ptr noundef %916)
  br label %917

917:                                              ; preds = %885, %880
  %918 = call { double, double } @Cd(ptr noundef @c_b1)
  %919 = extractvalue { double, double } %918, 0
  %920 = extractvalue { double, double } %918, 1
  %921 = load ptr, ptr %13, align 8, !tbaa !5
  %922 = load i32, ptr %30, align 4, !tbaa !9
  %923 = load i32, ptr %30, align 4, !tbaa !9
  %924 = load i32, ptr %19, align 4, !tbaa !9
  %925 = mul nsw i32 %923, %924
  %926 = add nsw i32 %922, %925
  %927 = sext i32 %926 to i64
  %928 = getelementptr inbounds %struct.doublecomplex, ptr %921, i64 %927
  %929 = call { double, double } @Cd(ptr noundef %928)
  %930 = extractvalue { double, double } %929, 0
  %931 = extractvalue { double, double } %929, 1
  %932 = call { double, double } @__divdc3(double noundef %919, double noundef %920, double noundef %930, double noundef %931) #5
  %933 = extractvalue { double, double } %932, 0
  %934 = extractvalue { double, double } %932, 1
  %935 = call ptr @_pCd(ptr noundef %25)
  %936 = getelementptr inbounds { double, double }, ptr %935, i32 0, i32 0
  %937 = getelementptr inbounds { double, double }, ptr %935, i32 0, i32 1
  store double %933, ptr %936, align 8
  store double %934, ptr %937, align 8
  %938 = load ptr, ptr %12, align 8, !tbaa !5
  %939 = load ptr, ptr %16, align 8, !tbaa !5
  %940 = load i32, ptr %30, align 4, !tbaa !9
  %941 = load i32, ptr %21, align 4, !tbaa !9
  %942 = add nsw i32 %940, %941
  %943 = sext i32 %942 to i64
  %944 = getelementptr inbounds %struct.doublecomplex, ptr %939, i64 %943
  %945 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zscal_(ptr noundef %938, ptr noundef %25, ptr noundef %944, ptr noundef %945)
  %946 = load i32, ptr %30, align 4, !tbaa !9
  %947 = add nsw i32 %946, 1
  store i32 %947, ptr %30, align 4, !tbaa !9
  br label %1387

948:                                              ; preds = %848
  %949 = load ptr, ptr %15, align 8, !tbaa !5
  %950 = load i32, ptr %30, align 4, !tbaa !9
  %951 = sext i32 %950 to i64
  %952 = getelementptr inbounds i32, ptr %949, i64 %951
  %953 = load i32, ptr %952, align 4, !tbaa !9
  %954 = sub nsw i32 0, %953
  store i32 %954, ptr %35, align 4, !tbaa !9
  %955 = load i32, ptr %35, align 4, !tbaa !9
  %956 = load i32, ptr %30, align 4, !tbaa !9
  %957 = icmp ne i32 %955, %956
  br i1 %957, label %958, label %974

958:                                              ; preds = %948
  %959 = load ptr, ptr %12, align 8, !tbaa !5
  %960 = load ptr, ptr %16, align 8, !tbaa !5
  %961 = load i32, ptr %30, align 4, !tbaa !9
  %962 = load i32, ptr %21, align 4, !tbaa !9
  %963 = add nsw i32 %961, %962
  %964 = sext i32 %963 to i64
  %965 = getelementptr inbounds %struct.doublecomplex, ptr %960, i64 %964
  %966 = load ptr, ptr %17, align 8, !tbaa !5
  %967 = load ptr, ptr %16, align 8, !tbaa !5
  %968 = load i32, ptr %35, align 4, !tbaa !9
  %969 = load i32, ptr %21, align 4, !tbaa !9
  %970 = add nsw i32 %968, %969
  %971 = sext i32 %970 to i64
  %972 = getelementptr inbounds %struct.doublecomplex, ptr %967, i64 %971
  %973 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %959, ptr noundef %965, ptr noundef %966, ptr noundef %972, ptr noundef %973)
  br label %974

974:                                              ; preds = %958, %948
  %975 = load ptr, ptr %15, align 8, !tbaa !5
  %976 = load i32, ptr %30, align 4, !tbaa !9
  %977 = add nsw i32 %976, 1
  %978 = sext i32 %977 to i64
  %979 = getelementptr inbounds i32, ptr %975, i64 %978
  %980 = load i32, ptr %979, align 4, !tbaa !9
  %981 = sub nsw i32 0, %980
  store i32 %981, ptr %35, align 4, !tbaa !9
  %982 = load i32, ptr %35, align 4, !tbaa !9
  %983 = load i32, ptr %30, align 4, !tbaa !9
  %984 = add nsw i32 %983, 1
  %985 = icmp ne i32 %982, %984
  br i1 %985, label %986, label %1003

986:                                              ; preds = %974
  %987 = load ptr, ptr %12, align 8, !tbaa !5
  %988 = load ptr, ptr %16, align 8, !tbaa !5
  %989 = load i32, ptr %30, align 4, !tbaa !9
  %990 = add nsw i32 %989, 1
  %991 = load i32, ptr %21, align 4, !tbaa !9
  %992 = add nsw i32 %990, %991
  %993 = sext i32 %992 to i64
  %994 = getelementptr inbounds %struct.doublecomplex, ptr %988, i64 %993
  %995 = load ptr, ptr %17, align 8, !tbaa !5
  %996 = load ptr, ptr %16, align 8, !tbaa !5
  %997 = load i32, ptr %35, align 4, !tbaa !9
  %998 = load i32, ptr %21, align 4, !tbaa !9
  %999 = add nsw i32 %997, %998
  %1000 = sext i32 %999 to i64
  %1001 = getelementptr inbounds %struct.doublecomplex, ptr %996, i64 %1000
  %1002 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %987, ptr noundef %994, ptr noundef %995, ptr noundef %1001, ptr noundef %1002)
  br label %1003

1003:                                             ; preds = %986, %974
  %1004 = load i32, ptr %30, align 4, !tbaa !9
  %1005 = load ptr, ptr %11, align 8, !tbaa !5
  %1006 = load i32, ptr %1005, align 4, !tbaa !9
  %1007 = sub nsw i32 %1006, 1
  %1008 = icmp slt i32 %1004, %1007
  br i1 %1008, label %1009, label %1076

1009:                                             ; preds = %1003
  %1010 = load ptr, ptr %11, align 8, !tbaa !5
  %1011 = load i32, ptr %1010, align 4, !tbaa !9
  %1012 = load i32, ptr %30, align 4, !tbaa !9
  %1013 = sub nsw i32 %1011, %1012
  %1014 = sub nsw i32 %1013, 1
  store i32 %1014, ptr %23, align 4, !tbaa !9
  %1015 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %1015, align 8, !tbaa !11
  %1016 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %1016, align 8, !tbaa !14
  %1017 = load ptr, ptr %12, align 8, !tbaa !5
  %1018 = load ptr, ptr %13, align 8, !tbaa !5
  %1019 = load i32, ptr %30, align 4, !tbaa !9
  %1020 = add nsw i32 %1019, 2
  %1021 = load i32, ptr %30, align 4, !tbaa !9
  %1022 = load i32, ptr %19, align 4, !tbaa !9
  %1023 = mul nsw i32 %1021, %1022
  %1024 = add nsw i32 %1020, %1023
  %1025 = sext i32 %1024 to i64
  %1026 = getelementptr inbounds %struct.doublecomplex, ptr %1018, i64 %1025
  %1027 = load ptr, ptr %16, align 8, !tbaa !5
  %1028 = load i32, ptr %30, align 4, !tbaa !9
  %1029 = load i32, ptr %21, align 4, !tbaa !9
  %1030 = add nsw i32 %1028, %1029
  %1031 = sext i32 %1030 to i64
  %1032 = getelementptr inbounds %struct.doublecomplex, ptr %1027, i64 %1031
  %1033 = load ptr, ptr %17, align 8, !tbaa !5
  %1034 = load ptr, ptr %16, align 8, !tbaa !5
  %1035 = load i32, ptr %30, align 4, !tbaa !9
  %1036 = add nsw i32 %1035, 2
  %1037 = load i32, ptr %21, align 4, !tbaa !9
  %1038 = add nsw i32 %1036, %1037
  %1039 = sext i32 %1038 to i64
  %1040 = getelementptr inbounds %struct.doublecomplex, ptr %1034, i64 %1039
  %1041 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %1017, ptr noundef %25, ptr noundef %1026, ptr noundef @c__1, ptr noundef %1032, ptr noundef %1033, ptr noundef %1040, ptr noundef %1041)
  %1042 = load ptr, ptr %11, align 8, !tbaa !5
  %1043 = load i32, ptr %1042, align 4, !tbaa !9
  %1044 = load i32, ptr %30, align 4, !tbaa !9
  %1045 = sub nsw i32 %1043, %1044
  %1046 = sub nsw i32 %1045, 1
  store i32 %1046, ptr %23, align 4, !tbaa !9
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %1047, align 8, !tbaa !11
  %1048 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %1048, align 8, !tbaa !14
  %1049 = load ptr, ptr %12, align 8, !tbaa !5
  %1050 = load ptr, ptr %13, align 8, !tbaa !5
  %1051 = load i32, ptr %30, align 4, !tbaa !9
  %1052 = add nsw i32 %1051, 2
  %1053 = load i32, ptr %30, align 4, !tbaa !9
  %1054 = add nsw i32 %1053, 1
  %1055 = load i32, ptr %19, align 4, !tbaa !9
  %1056 = mul nsw i32 %1054, %1055
  %1057 = add nsw i32 %1052, %1056
  %1058 = sext i32 %1057 to i64
  %1059 = getelementptr inbounds %struct.doublecomplex, ptr %1050, i64 %1058
  %1060 = load ptr, ptr %16, align 8, !tbaa !5
  %1061 = load i32, ptr %30, align 4, !tbaa !9
  %1062 = add nsw i32 %1061, 1
  %1063 = load i32, ptr %21, align 4, !tbaa !9
  %1064 = add nsw i32 %1062, %1063
  %1065 = sext i32 %1064 to i64
  %1066 = getelementptr inbounds %struct.doublecomplex, ptr %1060, i64 %1065
  %1067 = load ptr, ptr %17, align 8, !tbaa !5
  %1068 = load ptr, ptr %16, align 8, !tbaa !5
  %1069 = load i32, ptr %30, align 4, !tbaa !9
  %1070 = add nsw i32 %1069, 2
  %1071 = load i32, ptr %21, align 4, !tbaa !9
  %1072 = add nsw i32 %1070, %1071
  %1073 = sext i32 %1072 to i64
  %1074 = getelementptr inbounds %struct.doublecomplex, ptr %1068, i64 %1073
  %1075 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgeru_(ptr noundef %23, ptr noundef %1049, ptr noundef %25, ptr noundef %1059, ptr noundef @c__1, ptr noundef %1066, ptr noundef %1067, ptr noundef %1074, ptr noundef %1075)
  br label %1076

1076:                                             ; preds = %1009, %1003
  %1077 = load i32, ptr %30, align 4, !tbaa !9
  %1078 = add nsw i32 %1077, 1
  %1079 = load i32, ptr %30, align 4, !tbaa !9
  %1080 = load i32, ptr %19, align 4, !tbaa !9
  %1081 = mul nsw i32 %1079, %1080
  %1082 = add nsw i32 %1078, %1081
  store i32 %1082, ptr %23, align 4, !tbaa !9
  %1083 = load ptr, ptr %13, align 8, !tbaa !5
  %1084 = load i32, ptr %23, 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 0
  %1088 = load double, ptr %1087, align 8, !tbaa !11
  %1089 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %1088, ptr %1089, align 8, !tbaa !11
  %1090 = load ptr, ptr %13, align 8, !tbaa !5
  %1091 = load i32, ptr %23, align 4, !tbaa !9
  %1092 = sext i32 %1091 to i64
  %1093 = getelementptr inbounds %struct.doublecomplex, ptr %1090, i64 %1092
  %1094 = getelementptr inbounds %struct.doublecomplex, ptr %1093, i32 0, i32 1
  %1095 = load double, ptr %1094, align 8, !tbaa !14
  %1096 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %1095, ptr %1096, align 8, !tbaa !14
  %1097 = load ptr, ptr %13, align 8, !tbaa !5
  %1098 = load i32, ptr %30, align 4, !tbaa !9
  %1099 = load i32, ptr %30, align 4, !tbaa !9
  %1100 = load i32, ptr %19, align 4, !tbaa !9
  %1101 = mul nsw i32 %1099, %1100
  %1102 = add nsw i32 %1098, %1101
  %1103 = sext i32 %1102 to i64
  %1104 = getelementptr inbounds %struct.doublecomplex, ptr %1097, i64 %1103
  %1105 = call { double, double } @Cd(ptr noundef %1104)
  %1106 = extractvalue { double, double } %1105, 0
  %1107 = extractvalue { double, double } %1105, 1
  %1108 = call { double, double } @Cd(ptr noundef %28)
  %1109 = extractvalue { double, double } %1108, 0
  %1110 = extractvalue { double, double } %1108, 1
  %1111 = call { double, double } @__divdc3(double noundef %1106, double noundef %1107, double noundef %1109, double noundef %1110) #5
  %1112 = extractvalue { double, double } %1111, 0
  %1113 = extractvalue { double, double } %1111, 1
  %1114 = call ptr @_pCd(ptr noundef %25)
  %1115 = getelementptr inbounds { double, double }, ptr %1114, i32 0, i32 0
  %1116 = getelementptr inbounds { double, double }, ptr %1114, i32 0, i32 1
  store double %1112, ptr %1115, align 8
  store double %1113, ptr %1116, align 8
  %1117 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1118 = load double, ptr %1117, align 8, !tbaa !11
  %1119 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  store double %1118, ptr %1119, align 8, !tbaa !11
  %1120 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1121 = load double, ptr %1120, align 8, !tbaa !14
  %1122 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  store double %1121, ptr %1122, align 8, !tbaa !14
  %1123 = load ptr, ptr %13, align 8, !tbaa !5
  %1124 = load i32, ptr %30, align 4, !tbaa !9
  %1125 = add nsw i32 %1124, 1
  %1126 = load i32, ptr %30, align 4, !tbaa !9
  %1127 = add nsw i32 %1126, 1
  %1128 = load i32, ptr %19, align 4, !tbaa !9
  %1129 = mul nsw i32 %1127, %1128
  %1130 = add nsw i32 %1125, %1129
  %1131 = sext i32 %1130 to i64
  %1132 = getelementptr inbounds %struct.doublecomplex, ptr %1123, i64 %1131
  %1133 = call { double, double } @Cd(ptr noundef %1132)
  %1134 = extractvalue { double, double } %1133, 0
  %1135 = extractvalue { double, double } %1133, 1
  %1136 = call { double, double } @Cd(ptr noundef %28)
  %1137 = extractvalue { double, double } %1136, 0
  %1138 = extractvalue { double, double } %1136, 1
  %1139 = call { double, double } @__divdc3(double noundef %1134, double noundef %1135, double noundef %1137, double noundef %1138) #5
  %1140 = extractvalue { double, double } %1139, 0
  %1141 = extractvalue { double, double } %1139, 1
  %1142 = call ptr @_pCd(ptr noundef %25)
  %1143 = getelementptr inbounds { double, double }, ptr %1142, i32 0, i32 0
  %1144 = getelementptr inbounds { double, double }, ptr %1142, i32 0, i32 1
  store double %1140, ptr %1143, align 8
  store double %1141, ptr %1144, align 8
  %1145 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1146 = load double, ptr %1145, align 8, !tbaa !11
  %1147 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1146, ptr %1147, align 8, !tbaa !11
  %1148 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1149 = load double, ptr %1148, align 8, !tbaa !14
  %1150 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %1149, ptr %1150, align 8, !tbaa !14
  %1151 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %1152 = load double, ptr %1151, align 8, !tbaa !11
  %1153 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1154 = load double, ptr %1153, align 8, !tbaa !11
  %1155 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %1156 = load double, ptr %1155, align 8, !tbaa !14
  %1157 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1158 = load double, ptr %1157, align 8, !tbaa !14
  %1159 = fmul double %1156, %1158
  %1160 = fneg double %1159
  %1161 = call double @llvm.fmuladd.f64(double %1152, double %1154, double %1160)
  %1162 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %1161, ptr %1162, align 8, !tbaa !11
  %1163 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %1164 = load double, ptr %1163, align 8, !tbaa !11
  %1165 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1166 = load double, ptr %1165, align 8, !tbaa !14
  %1167 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %1168 = load double, ptr %1167, align 8, !tbaa !14
  %1169 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1170 = load double, ptr %1169, align 8, !tbaa !11
  %1171 = fmul double %1168, %1170
  %1172 = call double @llvm.fmuladd.f64(double %1164, double %1166, double %1171)
  %1173 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %1172, ptr %1173, align 8, !tbaa !14
  %1174 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %1175 = load double, ptr %1174, align 8, !tbaa !11
  %1176 = fsub double %1175, 1.000000e+00
  %1177 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %1176, ptr %1177, align 8, !tbaa !11
  %1178 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %1179 = load double, ptr %1178, align 8, !tbaa !14
  %1180 = fadd double %1179, 0.000000e+00
  %1181 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %1180, ptr %1181, align 8, !tbaa !14
  %1182 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1183 = load double, ptr %1182, align 8, !tbaa !11
  %1184 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1183, ptr %1184, align 8, !tbaa !11
  %1185 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1186 = load double, ptr %1185, align 8, !tbaa !14
  %1187 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1186, ptr %1187, align 8, !tbaa !14
  %1188 = load ptr, ptr %12, align 8, !tbaa !5
  %1189 = load i32, ptr %1188, align 4, !tbaa !9
  store i32 %1189, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %29, align 4, !tbaa !9
  br label %1190

1190:                                             ; preds = %1381, %1076
  %1191 = load i32, ptr %29, align 4, !tbaa !9
  %1192 = load i32, ptr %23, align 4, !tbaa !9
  %1193 = icmp sle i32 %1191, %1192
  br i1 %1193, label %1194, label %1384

1194:                                             ; preds = %1190
  %1195 = load ptr, ptr %16, align 8, !tbaa !5
  %1196 = load i32, ptr %30, align 4, !tbaa !9
  %1197 = load i32, ptr %29, align 4, !tbaa !9
  %1198 = load i32, ptr %21, align 4, !tbaa !9
  %1199 = mul nsw i32 %1197, %1198
  %1200 = add nsw i32 %1196, %1199
  %1201 = sext i32 %1200 to i64
  %1202 = getelementptr inbounds %struct.doublecomplex, ptr %1195, i64 %1201
  %1203 = call { double, double } @Cd(ptr noundef %1202)
  %1204 = extractvalue { double, double } %1203, 0
  %1205 = extractvalue { double, double } %1203, 1
  %1206 = call { double, double } @Cd(ptr noundef %28)
  %1207 = extractvalue { double, double } %1206, 0
  %1208 = extractvalue { double, double } %1206, 1
  %1209 = call { double, double } @__divdc3(double noundef %1204, double noundef %1205, double noundef %1207, double noundef %1208) #5
  %1210 = extractvalue { double, double } %1209, 0
  %1211 = extractvalue { double, double } %1209, 1
  %1212 = call ptr @_pCd(ptr noundef %25)
  %1213 = getelementptr inbounds { double, double }, ptr %1212, i32 0, i32 0
  %1214 = getelementptr inbounds { double, double }, ptr %1212, i32 0, i32 1
  store double %1210, ptr %1213, align 8
  store double %1211, ptr %1214, align 8
  %1215 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1216 = load double, ptr %1215, align 8, !tbaa !11
  %1217 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  store double %1216, ptr %1217, align 8, !tbaa !11
  %1218 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1219 = load double, ptr %1218, align 8, !tbaa !14
  %1220 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  store double %1219, ptr %1220, align 8, !tbaa !14
  %1221 = load ptr, ptr %16, align 8, !tbaa !5
  %1222 = load i32, ptr %30, align 4, !tbaa !9
  %1223 = add nsw i32 %1222, 1
  %1224 = load i32, ptr %29, align 4, !tbaa !9
  %1225 = load i32, ptr %21, align 4, !tbaa !9
  %1226 = mul nsw i32 %1224, %1225
  %1227 = add nsw i32 %1223, %1226
  %1228 = sext i32 %1227 to i64
  %1229 = getelementptr inbounds %struct.doublecomplex, ptr %1221, i64 %1228
  %1230 = call { double, double } @Cd(ptr noundef %1229)
  %1231 = extractvalue { double, double } %1230, 0
  %1232 = extractvalue { double, double } %1230, 1
  %1233 = call { double, double } @Cd(ptr noundef %28)
  %1234 = extractvalue { double, double } %1233, 0
  %1235 = extractvalue { double, double } %1233, 1
  %1236 = call { double, double } @__divdc3(double noundef %1231, double noundef %1232, double noundef %1234, double noundef %1235) #5
  %1237 = extractvalue { double, double } %1236, 0
  %1238 = extractvalue { double, double } %1236, 1
  %1239 = call ptr @_pCd(ptr noundef %25)
  %1240 = getelementptr inbounds { double, double }, ptr %1239, i32 0, i32 0
  %1241 = getelementptr inbounds { double, double }, ptr %1239, i32 0, i32 1
  store double %1237, ptr %1240, align 8
  store double %1238, ptr %1241, align 8
  %1242 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1243 = load double, ptr %1242, align 8, !tbaa !11
  %1244 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %1243, ptr %1244, align 8, !tbaa !11
  %1245 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1246 = load double, ptr %1245, align 8, !tbaa !14
  %1247 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %1246, ptr %1247, align 8, !tbaa !14
  %1248 = load i32, ptr %30, align 4, !tbaa !9
  %1249 = load i32, ptr %29, align 4, !tbaa !9
  %1250 = load i32, ptr %21, align 4, !tbaa !9
  %1251 = mul nsw i32 %1249, %1250
  %1252 = add nsw i32 %1248, %1251
  store i32 %1252, ptr %24, align 4, !tbaa !9
  %1253 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1254 = load double, ptr %1253, align 8, !tbaa !11
  %1255 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %1256 = load double, ptr %1255, align 8, !tbaa !11
  %1257 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1258 = load double, ptr %1257, align 8, !tbaa !14
  %1259 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %1260 = load double, ptr %1259, align 8, !tbaa !14
  %1261 = fmul double %1258, %1260
  %1262 = fneg double %1261
  %1263 = call double @llvm.fmuladd.f64(double %1254, double %1256, double %1262)
  %1264 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1263, ptr %1264, align 8, !tbaa !11
  %1265 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1266 = load double, ptr %1265, align 8, !tbaa !11
  %1267 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %1268 = load double, ptr %1267, align 8, !tbaa !14
  %1269 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1270 = load double, ptr %1269, align 8, !tbaa !14
  %1271 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %1272 = load double, ptr %1271, align 8, !tbaa !11
  %1273 = fmul double %1270, %1272
  %1274 = call double @llvm.fmuladd.f64(double %1266, double %1268, double %1273)
  %1275 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1274, ptr %1275, align 8, !tbaa !14
  %1276 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1277 = load double, ptr %1276, align 8, !tbaa !11
  %1278 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1279 = load double, ptr %1278, align 8, !tbaa !11
  %1280 = fsub double %1277, %1279
  %1281 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %1280, ptr %1281, align 8, !tbaa !11
  %1282 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1283 = load double, ptr %1282, align 8, !tbaa !14
  %1284 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1285 = load double, ptr %1284, align 8, !tbaa !14
  %1286 = fsub double %1283, %1285
  %1287 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %1286, ptr %1287, align 8, !tbaa !14
  %1288 = call { double, double } @Cd(ptr noundef %26)
  %1289 = extractvalue { double, double } %1288, 0
  %1290 = extractvalue { double, double } %1288, 1
  %1291 = call { double, double } @Cd(ptr noundef %31)
  %1292 = extractvalue { double, double } %1291, 0
  %1293 = extractvalue { double, double } %1291, 1
  %1294 = call { double, double } @__divdc3(double noundef %1289, double noundef %1290, double noundef %1292, double noundef %1293) #5
  %1295 = extractvalue { double, double } %1294, 0
  %1296 = extractvalue { double, double } %1294, 1
  %1297 = call ptr @_pCd(ptr noundef %25)
  %1298 = getelementptr inbounds { double, double }, ptr %1297, i32 0, i32 0
  %1299 = getelementptr inbounds { double, double }, ptr %1297, i32 0, i32 1
  store double %1295, ptr %1298, align 8
  store double %1296, ptr %1299, align 8
  %1300 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1301 = load double, ptr %1300, align 8, !tbaa !11
  %1302 = load ptr, ptr %16, align 8, !tbaa !5
  %1303 = load i32, ptr %24, align 4, !tbaa !9
  %1304 = sext i32 %1303 to i64
  %1305 = getelementptr inbounds %struct.doublecomplex, ptr %1302, i64 %1304
  %1306 = getelementptr inbounds %struct.doublecomplex, ptr %1305, i32 0, i32 0
  store double %1301, ptr %1306, align 8, !tbaa !11
  %1307 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1308 = load double, ptr %1307, align 8, !tbaa !14
  %1309 = load ptr, ptr %16, align 8, !tbaa !5
  %1310 = load i32, ptr %24, align 4, !tbaa !9
  %1311 = sext i32 %1310 to i64
  %1312 = getelementptr inbounds %struct.doublecomplex, ptr %1309, i64 %1311
  %1313 = getelementptr inbounds %struct.doublecomplex, ptr %1312, i32 0, i32 1
  store double %1308, ptr %1313, align 8, !tbaa !14
  %1314 = load i32, ptr %30, align 4, !tbaa !9
  %1315 = add nsw i32 %1314, 1
  %1316 = load i32, ptr %29, align 4, !tbaa !9
  %1317 = load i32, ptr %21, align 4, !tbaa !9
  %1318 = mul nsw i32 %1316, %1317
  %1319 = add nsw i32 %1315, %1318
  store i32 %1319, ptr %24, align 4, !tbaa !9
  %1320 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %1321 = load double, ptr %1320, align 8, !tbaa !11
  %1322 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1323 = load double, ptr %1322, align 8, !tbaa !11
  %1324 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %1325 = load double, ptr %1324, align 8, !tbaa !14
  %1326 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1327 = load double, ptr %1326, align 8, !tbaa !14
  %1328 = fmul double %1325, %1327
  %1329 = fneg double %1328
  %1330 = call double @llvm.fmuladd.f64(double %1321, double %1323, double %1329)
  %1331 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1330, ptr %1331, align 8, !tbaa !11
  %1332 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %1333 = load double, ptr %1332, align 8, !tbaa !11
  %1334 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1335 = load double, ptr %1334, align 8, !tbaa !14
  %1336 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %1337 = load double, ptr %1336, align 8, !tbaa !14
  %1338 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1339 = load double, ptr %1338, align 8, !tbaa !11
  %1340 = fmul double %1337, %1339
  %1341 = call double @llvm.fmuladd.f64(double %1333, double %1335, double %1340)
  %1342 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1341, ptr %1342, align 8, !tbaa !14
  %1343 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1344 = load double, ptr %1343, align 8, !tbaa !11
  %1345 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %1346 = load double, ptr %1345, align 8, !tbaa !11
  %1347 = fsub double %1344, %1346
  %1348 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %1347, ptr %1348, align 8, !tbaa !11
  %1349 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1350 = load double, ptr %1349, align 8, !tbaa !14
  %1351 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %1352 = load double, ptr %1351, align 8, !tbaa !14
  %1353 = fsub double %1350, %1352
  %1354 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %1353, ptr %1354, align 8, !tbaa !14
  %1355 = call { double, double } @Cd(ptr noundef %26)
  %1356 = extractvalue { double, double } %1355, 0
  %1357 = extractvalue { double, double } %1355, 1
  %1358 = call { double, double } @Cd(ptr noundef %31)
  %1359 = extractvalue { double, double } %1358, 0
  %1360 = extractvalue { double, double } %1358, 1
  %1361 = call { double, double } @__divdc3(double noundef %1356, double noundef %1357, double noundef %1359, double noundef %1360) #5
  %1362 = extractvalue { double, double } %1361, 0
  %1363 = extractvalue { double, double } %1361, 1
  %1364 = call ptr @_pCd(ptr noundef %25)
  %1365 = getelementptr inbounds { double, double }, ptr %1364, i32 0, i32 0
  %1366 = getelementptr inbounds { double, double }, ptr %1364, i32 0, i32 1
  store double %1362, ptr %1365, align 8
  store double %1363, ptr %1366, align 8
  %1367 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1368 = load double, ptr %1367, align 8, !tbaa !11
  %1369 = load ptr, ptr %16, align 8, !tbaa !5
  %1370 = load i32, ptr %24, align 4, !tbaa !9
  %1371 = sext i32 %1370 to i64
  %1372 = getelementptr inbounds %struct.doublecomplex, ptr %1369, i64 %1371
  %1373 = getelementptr inbounds %struct.doublecomplex, ptr %1372, i32 0, i32 0
  store double %1368, ptr %1373, align 8, !tbaa !11
  %1374 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1375 = load double, ptr %1374, align 8, !tbaa !14
  %1376 = load ptr, ptr %16, align 8, !tbaa !5
  %1377 = load i32, ptr %24, align 4, !tbaa !9
  %1378 = sext i32 %1377 to i64
  %1379 = getelementptr inbounds %struct.doublecomplex, ptr %1376, i64 %1378
  %1380 = getelementptr inbounds %struct.doublecomplex, ptr %1379, i32 0, i32 1
  store double %1375, ptr %1380, align 8, !tbaa !14
  br label %1381

1381:                                             ; preds = %1194
  %1382 = load i32, ptr %29, align 4, !tbaa !9
  %1383 = add nsw i32 %1382, 1
  store i32 %1383, ptr %29, align 4, !tbaa !9
  br label %1190, !llvm.loop !17

1384:                                             ; preds = %1190
  %1385 = load i32, ptr %30, align 4, !tbaa !9
  %1386 = add nsw i32 %1385, 2
  store i32 %1386, ptr %30, align 4, !tbaa !9
  br label %1387

1387:                                             ; preds = %1384, %917
  br label %842

1388:                                             ; preds = %847
  %1389 = load ptr, ptr %11, align 8, !tbaa !5
  %1390 = load i32, ptr %1389, align 4, !tbaa !9
  store i32 %1390, ptr %30, align 4, !tbaa !9
  br label %1391

1391:                                             ; preds = %1595, %1388
  %1392 = load i32, ptr %30, align 4, !tbaa !9
  %1393 = icmp slt i32 %1392, 1
  br i1 %1393, label %1394, label %1395

1394:                                             ; preds = %1391
  br label %1596

1395:                                             ; preds = %1391
  %1396 = load ptr, ptr %15, align 8, !tbaa !5
  %1397 = load i32, ptr %30, align 4, !tbaa !9
  %1398 = sext i32 %1397 to i64
  %1399 = getelementptr inbounds i32, ptr %1396, i64 %1398
  %1400 = load i32, ptr %1399, align 4, !tbaa !9
  %1401 = icmp sgt i32 %1400, 0
  br i1 %1401, label %1402, label %1467

1402:                                             ; preds = %1395
  %1403 = load i32, ptr %30, align 4, !tbaa !9
  %1404 = load ptr, ptr %11, align 8, !tbaa !5
  %1405 = load i32, ptr %1404, align 4, !tbaa !9
  %1406 = icmp slt i32 %1403, %1405
  br i1 %1406, label %1407, label %1439

1407:                                             ; preds = %1402
  %1408 = load ptr, ptr %11, align 8, !tbaa !5
  %1409 = load i32, ptr %1408, align 4, !tbaa !9
  %1410 = load i32, ptr %30, align 4, !tbaa !9
  %1411 = sub nsw i32 %1409, %1410
  store i32 %1411, ptr %23, align 4, !tbaa !9
  %1412 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %1412, align 8, !tbaa !11
  %1413 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %1413, align 8, !tbaa !14
  %1414 = load ptr, ptr %12, align 8, !tbaa !5
  %1415 = load ptr, ptr %16, align 8, !tbaa !5
  %1416 = load i32, ptr %30, align 4, !tbaa !9
  %1417 = add nsw i32 %1416, 1
  %1418 = load i32, ptr %21, align 4, !tbaa !9
  %1419 = add nsw i32 %1417, %1418
  %1420 = sext i32 %1419 to i64
  %1421 = getelementptr inbounds %struct.doublecomplex, ptr %1415, i64 %1420
  %1422 = load ptr, ptr %17, align 8, !tbaa !5
  %1423 = load ptr, ptr %13, align 8, !tbaa !5
  %1424 = load i32, ptr %30, align 4, !tbaa !9
  %1425 = add nsw i32 %1424, 1
  %1426 = load i32, ptr %30, align 4, !tbaa !9
  %1427 = load i32, ptr %19, align 4, !tbaa !9
  %1428 = mul nsw i32 %1426, %1427
  %1429 = add nsw i32 %1425, %1428
  %1430 = sext i32 %1429 to i64
  %1431 = getelementptr inbounds %struct.doublecomplex, ptr %1423, i64 %1430
  %1432 = load ptr, ptr %16, align 8, !tbaa !5
  %1433 = load i32, ptr %30, align 4, !tbaa !9
  %1434 = load i32, ptr %21, align 4, !tbaa !9
  %1435 = add nsw i32 %1433, %1434
  %1436 = sext i32 %1435 to i64
  %1437 = getelementptr inbounds %struct.doublecomplex, ptr %1432, i64 %1436
  %1438 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1414, ptr noundef %25, ptr noundef %1421, ptr noundef %1422, ptr noundef %1431, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1437, ptr noundef %1438)
  br label %1439

1439:                                             ; preds = %1407, %1402
  %1440 = load ptr, ptr %15, align 8, !tbaa !5
  %1441 = load i32, ptr %30, align 4, !tbaa !9
  %1442 = sext i32 %1441 to i64
  %1443 = getelementptr inbounds i32, ptr %1440, i64 %1442
  %1444 = load i32, ptr %1443, align 4, !tbaa !9
  store i32 %1444, ptr %35, align 4, !tbaa !9
  %1445 = load i32, ptr %35, align 4, !tbaa !9
  %1446 = load i32, ptr %30, align 4, !tbaa !9
  %1447 = icmp ne i32 %1445, %1446
  br i1 %1447, label %1448, label %1464

1448:                                             ; preds = %1439
  %1449 = load ptr, ptr %12, align 8, !tbaa !5
  %1450 = load ptr, ptr %16, align 8, !tbaa !5
  %1451 = load i32, ptr %30, align 4, !tbaa !9
  %1452 = load i32, ptr %21, align 4, !tbaa !9
  %1453 = add nsw i32 %1451, %1452
  %1454 = sext i32 %1453 to i64
  %1455 = getelementptr inbounds %struct.doublecomplex, ptr %1450, i64 %1454
  %1456 = load ptr, ptr %17, align 8, !tbaa !5
  %1457 = load ptr, ptr %16, align 8, !tbaa !5
  %1458 = load i32, ptr %35, align 4, !tbaa !9
  %1459 = load i32, ptr %21, align 4, !tbaa !9
  %1460 = add nsw i32 %1458, %1459
  %1461 = sext i32 %1460 to i64
  %1462 = getelementptr inbounds %struct.doublecomplex, ptr %1457, i64 %1461
  %1463 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %1449, ptr noundef %1455, ptr noundef %1456, ptr noundef %1462, ptr noundef %1463)
  br label %1464

1464:                                             ; preds = %1448, %1439
  %1465 = load i32, ptr %30, align 4, !tbaa !9
  %1466 = add nsw i32 %1465, -1
  store i32 %1466, ptr %30, align 4, !tbaa !9
  br label %1595

1467:                                             ; preds = %1395
  %1468 = load i32, ptr %30, align 4, !tbaa !9
  %1469 = load ptr, ptr %11, align 8, !tbaa !5
  %1470 = load i32, ptr %1469, align 4, !tbaa !9
  %1471 = icmp slt i32 %1468, %1470
  br i1 %1471, label %1472, label %1537

1472:                                             ; preds = %1467
  %1473 = load ptr, ptr %11, align 8, !tbaa !5
  %1474 = load i32, ptr %1473, align 4, !tbaa !9
  %1475 = load i32, ptr %30, align 4, !tbaa !9
  %1476 = sub nsw i32 %1474, %1475
  store i32 %1476, ptr %23, align 4, !tbaa !9
  %1477 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %1477, align 8, !tbaa !11
  %1478 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %1478, align 8, !tbaa !14
  %1479 = load ptr, ptr %12, align 8, !tbaa !5
  %1480 = load ptr, ptr %16, align 8, !tbaa !5
  %1481 = load i32, ptr %30, align 4, !tbaa !9
  %1482 = add nsw i32 %1481, 1
  %1483 = load i32, ptr %21, align 4, !tbaa !9
  %1484 = add nsw i32 %1482, %1483
  %1485 = sext i32 %1484 to i64
  %1486 = getelementptr inbounds %struct.doublecomplex, ptr %1480, i64 %1485
  %1487 = load ptr, ptr %17, align 8, !tbaa !5
  %1488 = load ptr, ptr %13, align 8, !tbaa !5
  %1489 = load i32, ptr %30, align 4, !tbaa !9
  %1490 = add nsw i32 %1489, 1
  %1491 = load i32, ptr %30, align 4, !tbaa !9
  %1492 = load i32, ptr %19, align 4, !tbaa !9
  %1493 = mul nsw i32 %1491, %1492
  %1494 = add nsw i32 %1490, %1493
  %1495 = sext i32 %1494 to i64
  %1496 = getelementptr inbounds %struct.doublecomplex, ptr %1488, i64 %1495
  %1497 = load ptr, ptr %16, align 8, !tbaa !5
  %1498 = load i32, ptr %30, align 4, !tbaa !9
  %1499 = load i32, ptr %21, align 4, !tbaa !9
  %1500 = add nsw i32 %1498, %1499
  %1501 = sext i32 %1500 to i64
  %1502 = getelementptr inbounds %struct.doublecomplex, ptr %1497, i64 %1501
  %1503 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1479, ptr noundef %25, ptr noundef %1486, ptr noundef %1487, ptr noundef %1496, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1502, ptr noundef %1503)
  %1504 = load ptr, ptr %11, align 8, !tbaa !5
  %1505 = load i32, ptr %1504, align 4, !tbaa !9
  %1506 = load i32, ptr %30, align 4, !tbaa !9
  %1507 = sub nsw i32 %1505, %1506
  store i32 %1507, ptr %23, align 4, !tbaa !9
  %1508 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double -1.000000e+00, ptr %1508, align 8, !tbaa !11
  %1509 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double 0.000000e+00, ptr %1509, align 8, !tbaa !14
  %1510 = load ptr, ptr %12, align 8, !tbaa !5
  %1511 = load ptr, ptr %16, align 8, !tbaa !5
  %1512 = load i32, ptr %30, align 4, !tbaa !9
  %1513 = add nsw i32 %1512, 1
  %1514 = load i32, ptr %21, align 4, !tbaa !9
  %1515 = add nsw i32 %1513, %1514
  %1516 = sext i32 %1515 to i64
  %1517 = getelementptr inbounds %struct.doublecomplex, ptr %1511, i64 %1516
  %1518 = load ptr, ptr %17, align 8, !tbaa !5
  %1519 = load ptr, ptr %13, align 8, !tbaa !5
  %1520 = load i32, ptr %30, align 4, !tbaa !9
  %1521 = add nsw i32 %1520, 1
  %1522 = load i32, ptr %30, align 4, !tbaa !9
  %1523 = sub nsw i32 %1522, 1
  %1524 = load i32, ptr %19, align 4, !tbaa !9
  %1525 = mul nsw i32 %1523, %1524
  %1526 = add nsw i32 %1521, %1525
  %1527 = sext i32 %1526 to i64
  %1528 = getelementptr inbounds %struct.doublecomplex, ptr %1519, i64 %1527
  %1529 = load ptr, ptr %16, align 8, !tbaa !5
  %1530 = load i32, ptr %30, align 4, !tbaa !9
  %1531 = sub nsw i32 %1530, 1
  %1532 = load i32, ptr %21, align 4, !tbaa !9
  %1533 = add nsw i32 %1531, %1532
  %1534 = sext i32 %1533 to i64
  %1535 = getelementptr inbounds %struct.doublecomplex, ptr %1529, i64 %1534
  %1536 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1510, ptr noundef %25, ptr noundef %1517, ptr noundef %1518, ptr noundef %1528, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1535, ptr noundef %1536)
  br label %1537

1537:                                             ; preds = %1472, %1467
  %1538 = load ptr, ptr %15, align 8, !tbaa !5
  %1539 = load i32, ptr %30, align 4, !tbaa !9
  %1540 = sext i32 %1539 to i64
  %1541 = getelementptr inbounds i32, ptr %1538, i64 %1540
  %1542 = load i32, ptr %1541, align 4, !tbaa !9
  %1543 = sub nsw i32 0, %1542
  store i32 %1543, ptr %35, align 4, !tbaa !9
  %1544 = load i32, ptr %35, align 4, !tbaa !9
  %1545 = load i32, ptr %30, align 4, !tbaa !9
  %1546 = icmp ne i32 %1544, %1545
  br i1 %1546, label %1547, label %1563

1547:                                             ; preds = %1537
  %1548 = load ptr, ptr %12, align 8, !tbaa !5
  %1549 = load ptr, ptr %16, align 8, !tbaa !5
  %1550 = load i32, ptr %30, align 4, !tbaa !9
  %1551 = load i32, ptr %21, align 4, !tbaa !9
  %1552 = add nsw i32 %1550, %1551
  %1553 = sext i32 %1552 to i64
  %1554 = getelementptr inbounds %struct.doublecomplex, ptr %1549, i64 %1553
  %1555 = load ptr, ptr %17, align 8, !tbaa !5
  %1556 = load ptr, ptr %16, align 8, !tbaa !5
  %1557 = load i32, ptr %35, align 4, !tbaa !9
  %1558 = load i32, ptr %21, align 4, !tbaa !9
  %1559 = add nsw i32 %1557, %1558
  %1560 = sext i32 %1559 to i64
  %1561 = getelementptr inbounds %struct.doublecomplex, ptr %1556, i64 %1560
  %1562 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %1548, ptr noundef %1554, ptr noundef %1555, ptr noundef %1561, ptr noundef %1562)
  br label %1563

1563:                                             ; preds = %1547, %1537
  %1564 = load ptr, ptr %15, align 8, !tbaa !5
  %1565 = load i32, ptr %30, align 4, !tbaa !9
  %1566 = sub nsw i32 %1565, 1
  %1567 = sext i32 %1566 to i64
  %1568 = getelementptr inbounds i32, ptr %1564, i64 %1567
  %1569 = load i32, ptr %1568, align 4, !tbaa !9
  %1570 = sub nsw i32 0, %1569
  store i32 %1570, ptr %35, align 4, !tbaa !9
  %1571 = load i32, ptr %35, align 4, !tbaa !9
  %1572 = load i32, ptr %30, align 4, !tbaa !9
  %1573 = sub nsw i32 %1572, 1
  %1574 = icmp ne i32 %1571, %1573
  br i1 %1574, label %1575, label %1592

1575:                                             ; preds = %1563
  %1576 = load ptr, ptr %12, align 8, !tbaa !5
  %1577 = load ptr, ptr %16, align 8, !tbaa !5
  %1578 = load i32, ptr %30, align 4, !tbaa !9
  %1579 = sub nsw i32 %1578, 1
  %1580 = load i32, ptr %21, align 4, !tbaa !9
  %1581 = add nsw i32 %1579, %1580
  %1582 = sext i32 %1581 to i64
  %1583 = getelementptr inbounds %struct.doublecomplex, ptr %1577, i64 %1582
  %1584 = load ptr, ptr %17, align 8, !tbaa !5
  %1585 = load ptr, ptr %16, align 8, !tbaa !5
  %1586 = load i32, ptr %35, align 4, !tbaa !9
  %1587 = load i32, ptr %21, align 4, !tbaa !9
  %1588 = add nsw i32 %1586, %1587
  %1589 = sext i32 %1588 to i64
  %1590 = getelementptr inbounds %struct.doublecomplex, ptr %1585, i64 %1589
  %1591 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zswap_(ptr noundef %1576, ptr noundef %1583, ptr noundef %1584, ptr noundef %1590, ptr noundef %1591)
  br label %1592

1592:                                             ; preds = %1575, %1563
  %1593 = load i32, ptr %30, align 4, !tbaa !9
  %1594 = add nsw i32 %1593, -2
  store i32 %1594, ptr %30, align 4, !tbaa !9
  br label %1595

1595:                                             ; preds = %1592, %1464
  br label %1391

1596:                                             ; preds = %1394
  br label %1597

1597:                                             ; preds = %1596, %840
  store i32 1, ptr %38, align 4
  br label %1598

1598:                                             ; preds = %1597, %135, %122
  call void @llvm.lifetime.end.p0(i64 16, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %36) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 4, 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 16, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 16, 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
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #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 @zswap_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

declare void @zgeru_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, 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

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

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

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

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

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 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 8}
!13 = !{!"double", !7, i64 0}
!14 = !{!12, !13, i64 8}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = distinct !{!17, !16}


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

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

23:                                               ; preds = %9
  %24 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #5
  %.not566 = icmp eq i32 %24, 0
  br i1 %.not566, label %.thread.sink.split, label %25

25:                                               ; preds = %23, %9
  %26 = load i32, ptr %1, align 4, !tbaa !5
  %27 = icmp slt i32 %26, 0
  br i1 %27, label %.thread.sink.split, label %28

28:                                               ; preds = %25
  %29 = load i32, ptr %2, align 4, !tbaa !5
  %30 = icmp slt i32 %29, 0
  br i1 %30, label %.thread.sink.split, label %31

31:                                               ; preds = %28
  %32 = load i32, ptr %4, align 4, !tbaa !5
  %spec.select = tail call i32 @llvm.umax.i32(i32 %26, i32 1)
  %33 = icmp slt i32 %32, %spec.select
  br i1 %33, label %.thread.sink.split, label %34

34:                                               ; preds = %31
  %35 = load i32, ptr %7, align 4, !tbaa !5
  %36 = icmp slt i32 %35, %spec.select
  br i1 %36, label %.thread.sink.split, label %37

37:                                               ; preds = %34
  %.pr = load i32, ptr %8, align 4, !tbaa !5
  %.not567 = icmp eq i32 %.pr, 0
  br i1 %.not567, label %41, label %.thread

.thread.sink.split:                               ; preds = %34, %31, %28, %25, %23
  %.sink = phi i32 [ -1, %23 ], [ -2, %25 ], [ -3, %28 ], [ -5, %31 ], [ -8, %34 ]
  store i32 %.sink, ptr %8, align 4, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %.thread.sink.split, %37
  %38 = phi i32 [ %.pr, %37 ], [ %.sink, %.thread.sink.split ]
  %39 = sub nsw i32 0, %38
  store i32 %39, ptr %10, align 4, !tbaa !5
  %40 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %10, i32 noundef 11) #5
  br label %.loopexit

41:                                               ; preds = %37
  %42 = icmp eq i32 %26, 0
  %43 = icmp eq i32 %29, 0
  %or.cond = or i1 %42, %43
  br i1 %or.cond, label %.loopexit, label %44

44:                                               ; preds = %41
  br i1 %.not, label %.lr.ph611, label %.lr.ph596

.lr.ph596:                                        ; preds = %44
  %invariant.gep = getelementptr i8, ptr %17, i64 16
  %45 = getelementptr inbounds i8, ptr %11, i64 8
  %46 = add i32 %15, 1
  %47 = sext i32 %19 to i64
  br label %52

.lr.ph611:                                        ; preds = %44
  %48 = getelementptr inbounds i8, ptr %11, i64 8
  %49 = add i32 %15, 1
  %50 = sext i32 %19 to i64
  br label %287

.preheader586:                                    ; preds = %229
  %.pre = load i32, ptr %1, align 4, !tbaa !5
  %51 = icmp slt i32 %.pre, 1
  br i1 %51, label %.loopexit, label %.lr.ph604

52:                                               ; preds = %.lr.ph596, %229
  %.0595 = phi i32 [ %26, %.lr.ph596 ], [ %.1, %229 ]
  %53 = zext nneg i32 %.0595 to i64
  %54 = getelementptr inbounds i32, ptr %18, i64 %53
  %55 = load i32, ptr %54, align 4, !tbaa !5
  %56 = icmp sgt i32 %55, 0
  br i1 %56, label %57, label %81

57:                                               ; preds = %52
  %.not578 = icmp eq i32 %55, %.0595
  %.pre636 = add nsw i32 %.0595, %19
  %.pre638 = sext i32 %.pre636 to i64
  br i1 %.not578, label %._crit_edge626, label %58

58:                                               ; preds = %57
  %59 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %.pre638
  %60 = add nsw i32 %55, %19
  %61 = sext i32 %60 to i64
  %62 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %61
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %59, ptr noundef nonnull %7, ptr noundef %62, ptr noundef nonnull %7) #5
  br label %._crit_edge626

._crit_edge626:                                   ; preds = %57, %58
  %63 = add nsw i32 %.0595, -1
  store i32 %63, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %64 = mul nsw i32 %.0595, %15
  %65 = sext i32 %64 to i64
  %gep594 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %65
  %66 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %.pre638
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep594, ptr noundef nonnull @c__1, ptr noundef %66, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #5
  %67 = call { double, double } @Cd(ptr noundef nonnull @c_b1)
  %68 = extractvalue { double, double } %67, 0
  %69 = extractvalue { double, double } %67, 1
  %70 = add nsw i32 %64, %.0595
  %71 = sext i32 %70 to i64
  %72 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %71
  %73 = call { double, double } @Cd(ptr noundef %72)
  %74 = extractvalue { double, double } %73, 0
  %75 = extractvalue { double, double } %73, 1
  %76 = call { double, double } @__divdc3(double noundef %68, double noundef %69, double noundef %74, double noundef %75) #5
  %77 = extractvalue { double, double } %76, 0
  %78 = extractvalue { double, double } %76, 1
  %79 = call ptr @_pCd(ptr noundef nonnull %11)
  %80 = getelementptr inbounds i8, ptr %79, i64 8
  store double %77, ptr %79, align 8
  store double %78, ptr %80, align 8
  call void @zscal_(ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %66, ptr noundef nonnull %7) #5
  br label %229

81:                                               ; preds = %52
  %82 = sub nsw i32 0, %55
  %.not575 = icmp eq i32 %.0595, %82
  br i1 %.not575, label %90, label %83

83:                                               ; preds = %81
  %84 = add nsw i32 %.0595, %19
  %85 = sext i32 %84 to i64
  %86 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %85
  %87 = sub i32 %19, %55
  %88 = sext i32 %87 to i64
  %89 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %88
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %86, ptr noundef nonnull %7, ptr noundef %89, ptr noundef nonnull %7) #5
  br label %90

90:                                               ; preds = %83, %81
  %91 = add nsw i32 %.0595, -1
  %92 = zext nneg i32 %91 to i64
  %93 = getelementptr inbounds i32, ptr %18, i64 %92
  %94 = load i32, ptr %93, align 4, !tbaa !5
  %95 = sub nsw i32 0, %94
  %.not576 = icmp eq i32 %91, %95
  br i1 %.not576, label %103, label %96

96:                                               ; preds = %90
  %97 = add nsw i32 %91, %19
  %98 = sext i32 %97 to i64
  %99 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %98
  %100 = sub i32 %19, %94
  %101 = sext i32 %100 to i64
  %102 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %101
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %99, ptr noundef nonnull %7, ptr noundef %102, ptr noundef nonnull %7) #5
  br label %103

103:                                              ; preds = %96, %90
  %104 = icmp ugt i32 %.0595, 2
  br i1 %104, label %105, label %._crit_edge625

._crit_edge625:                                   ; preds = %103
  %.pre640 = mul nsw i32 %.0595, %15
  br label %117

105:                                              ; preds = %103
  %106 = add nsw i32 %.0595, -2
  store i32 %106, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %107 = mul nsw i32 %.0595, %15
  %108 = sext i32 %107 to i64
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %108
  %109 = add nsw i32 %.0595, %19
  %110 = sext i32 %109 to i64
  %111 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %110
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep, ptr noundef nonnull @c__1, ptr noundef %111, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #5
  store i32 %106, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %112 = mul nsw i32 %91, %15
  %113 = sext i32 %112 to i64
  %gep592 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %113
  %114 = add nsw i32 %91, %19
  %115 = sext i32 %114 to i64
  %116 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %115
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep592, ptr noundef nonnull @c__1, ptr noundef %116, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #5
  br label %117

117:                                              ; preds = %._crit_edge625, %105
  %.pre-phi641 = phi i32 [ %.pre640, %._crit_edge625 ], [ %107, %105 ]
  %118 = add nsw i32 %91, %.pre-phi641
  store i32 %118, ptr %10, align 4, !tbaa !5
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %119
  %121 = load <2 x double>, ptr %120, align 8, !tbaa !9
  store <2 x double> %121, ptr %13, align 16, !tbaa !9
  %122 = mul i32 %91, %46
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %123
  %125 = call { double, double } @Cd(ptr noundef %124)
  %126 = extractvalue { double, double } %125, 0
  %127 = extractvalue { double, double } %125, 1
  %128 = call { double, double } @Cd(ptr noundef nonnull %13)
  %129 = extractvalue { double, double } %128, 0
  %130 = extractvalue { double, double } %128, 1
  %131 = call { double, double } @__divdc3(double noundef %126, double noundef %127, double noundef %129, double noundef %130) #5
  %132 = extractvalue { double, double } %131, 0
  %133 = extractvalue { double, double } %131, 1
  %134 = call ptr @_pCd(ptr noundef nonnull %11)
  %135 = getelementptr inbounds i8, ptr %134, i64 8
  store double %132, ptr %134, align 8
  store double %133, ptr %135, align 8
  %136 = load <2 x double>, ptr %11, align 16
  %137 = load double, ptr %45, align 8, !tbaa !11
  %138 = add nsw i32 %.pre-phi641, %.0595
  %139 = sext i32 %138 to i64
  %140 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %139
  %141 = call { double, double } @Cd(ptr noundef %140)
  %142 = extractvalue { double, double } %141, 0
  %143 = extractvalue { double, double } %141, 1
  %144 = call { double, double } @Cd(ptr noundef nonnull %13)
  %145 = extractvalue { double, double } %144, 0
  %146 = extractvalue { double, double } %144, 1
  %147 = call { double, double } @__divdc3(double noundef %142, double noundef %143, double noundef %145, double noundef %146) #5
  %148 = extractvalue { double, double } %147, 0
  %149 = extractvalue { double, double } %147, 1
  %150 = call ptr @_pCd(ptr noundef nonnull %11)
  %151 = getelementptr inbounds i8, ptr %150, i64 8
  store double %148, ptr %150, align 8
  store double %149, ptr %151, align 8
  %152 = fneg double %137
  %153 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %154 = insertelement <2 x double> poison, double %137, i64 0
  %155 = insertelement <2 x double> %154, double %152, i64 1
  %156 = fmul <2 x double> %153, %155
  %157 = shufflevector <2 x double> %156, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %158 = shufflevector <2 x double> %136, <2 x double> poison, <2 x i32> zeroinitializer
  %159 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %158, <2 x double> %153, <2 x double> %157)
  store <2 x double> %159, ptr %12, align 16, !tbaa !9
  %160 = fadd <2 x double> %159, <double -1.000000e+00, double 0.000000e+00>
  store <2 x double> %160, ptr %11, align 16, !tbaa !9
  store <2 x double> %160, ptr %14, align 16, !tbaa !9
  %161 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %161, ptr %10, align 4, !tbaa !5
  %.not577589 = icmp slt i32 %161, 1
  br i1 %.not577589, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %117
  %162 = zext nneg i32 %91 to i64
  %163 = zext nneg i32 %.0595 to i64
  %invariant.gep643 = getelementptr %struct.doublecomplex, ptr %21, i64 %162
  %invariant.gep645 = getelementptr %struct.doublecomplex, ptr %21, i64 %163
  %164 = shufflevector <2 x double> %153, <2 x double> poison, <2 x i32> zeroinitializer
  %165 = shufflevector <2 x double> %153, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %166 = fneg <2 x double> %153
  %167 = shufflevector <2 x double> %165, <2 x double> %166, <2 x i32> <i32 0, i32 3>
  br label %168

168:                                              ; preds = %.lr.ph, %168
  %indvars.iv = phi i64 [ 1, %.lr.ph ], [ %indvars.iv.next, %168 ]
  %169 = mul nsw i64 %indvars.iv, %47
  %gep644 = getelementptr %struct.doublecomplex, ptr %invariant.gep643, i64 %169
  %170 = call { double, double } @Cd(ptr noundef %gep644)
  %171 = extractvalue { double, double } %170, 0
  %172 = extractvalue { double, double } %170, 1
  %173 = call { double, double } @Cd(ptr noundef nonnull %13)
  %174 = extractvalue { double, double } %173, 0
  %175 = extractvalue { double, double } %173, 1
  %176 = call { double, double } @__divdc3(double noundef %171, double noundef %172, double noundef %174, double noundef %175) #5
  %177 = extractvalue { double, double } %176, 0
  %178 = extractvalue { double, double } %176, 1
  %179 = call ptr @_pCd(ptr noundef nonnull %11)
  %180 = getelementptr inbounds i8, ptr %179, i64 8
  store double %177, ptr %179, align 8
  store double %178, ptr %180, align 8
  %gep646 = getelementptr %struct.doublecomplex, ptr %invariant.gep645, i64 %169
  %181 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %182 = call { double, double } @Cd(ptr noundef %gep646)
  %183 = extractvalue { double, double } %182, 0
  %184 = extractvalue { double, double } %182, 1
  %185 = call { double, double } @Cd(ptr noundef nonnull %13)
  %186 = extractvalue { double, double } %185, 0
  %187 = extractvalue { double, double } %185, 1
  %188 = call { double, double } @__divdc3(double noundef %183, double noundef %184, double noundef %186, double noundef %187) #5
  %189 = extractvalue { double, double } %188, 0
  %190 = extractvalue { double, double } %188, 1
  %191 = call ptr @_pCd(ptr noundef nonnull %11)
  %192 = getelementptr inbounds i8, ptr %191, i64 8
  store double %189, ptr %191, align 8
  store double %190, ptr %192, align 8
  %193 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %194 = fmul <2 x double> %181, %167
  %195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> %181, <2 x double> %195)
  %197 = fsub <2 x double> %196, %193
  store <2 x double> %197, ptr %12, align 16, !tbaa !9
  %198 = call { double, double } @Cd(ptr noundef nonnull %12)
  %199 = extractvalue { double, double } %198, 0
  %200 = extractvalue { double, double } %198, 1
  %201 = call { double, double } @Cd(ptr noundef nonnull %14)
  %202 = extractvalue { double, double } %201, 0
  %203 = extractvalue { double, double } %201, 1
  %204 = call { double, double } @__divdc3(double noundef %199, double noundef %200, double noundef %202, double noundef %203) #5
  %205 = extractvalue { double, double } %204, 0
  %206 = extractvalue { double, double } %204, 1
  %207 = call ptr @_pCd(ptr noundef nonnull %11)
  %208 = getelementptr inbounds i8, ptr %207, i64 8
  store double %205, ptr %207, align 8
  store double %206, ptr %208, align 8
  %209 = load <2 x double>, ptr %11, align 16, !tbaa !9
  store <2 x double> %209, ptr %gep644, align 8, !tbaa !9
  %210 = fmul <2 x double> %193, %155
  %211 = shufflevector <2 x double> %210, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %212 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %158, <2 x double> %193, <2 x double> %211)
  %213 = fsub <2 x double> %212, %181
  store <2 x double> %213, ptr %12, align 16, !tbaa !9
  %214 = call { double, double } @Cd(ptr noundef nonnull %12)
  %215 = extractvalue { double, double } %214, 0
  %216 = extractvalue { double, double } %214, 1
  %217 = call { double, double } @Cd(ptr noundef nonnull %14)
  %218 = extractvalue { double, double } %217, 0
  %219 = extractvalue { double, double } %217, 1
  %220 = call { double, double } @__divdc3(double noundef %215, double noundef %216, double noundef %218, double noundef %219) #5
  %221 = extractvalue { double, double } %220, 0
  %222 = extractvalue { double, double } %220, 1
  %223 = call ptr @_pCd(ptr noundef nonnull %11)
  %224 = getelementptr inbounds i8, ptr %223, i64 8
  store double %221, ptr %223, align 8
  store double %222, ptr %224, align 8
  %225 = load <2 x double>, ptr %11, align 16, !tbaa !9
  store <2 x double> %225, ptr %gep646, align 8, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %226 = load i32, ptr %10, align 4, !tbaa !5
  %227 = sext i32 %226 to i64
  %.not577.not = icmp slt i64 %indvars.iv, %227
  br i1 %.not577.not, label %168, label %._crit_edge, !llvm.loop !13

._crit_edge:                                      ; preds = %168, %117
  %228 = add nsw i32 %.0595, -2
  br label %229

229:                                              ; preds = %._crit_edge, %._crit_edge626
  %.1 = phi i32 [ %63, %._crit_edge626 ], [ %228, %._crit_edge ]
  %230 = icmp slt i32 %.1, 1
  br i1 %230, label %.preheader586, label %52

.lr.ph604:                                        ; preds = %.preheader586, %282
  %.2603 = phi i32 [ %283, %282 ], [ 1, %.preheader586 ]
  %231 = sext i32 %.2603 to i64
  %232 = getelementptr inbounds i32, ptr %18, i64 %231
  %233 = load i32, ptr %232, align 4, !tbaa !5
  %234 = icmp sgt i32 %233, 0
  %235 = icmp sgt i32 %.2603, 1
  br i1 %234, label %236, label %248

236:                                              ; preds = %.lr.ph604
  br i1 %235, label %237, label %244

237:                                              ; preds = %236
  %238 = add nsw i32 %.2603, -1
  store i32 %238, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %239 = mul nsw i32 %.2603, %15
  %240 = sext i32 %239 to i64
  %gep602 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %240
  %241 = add nsw i32 %.2603, %19
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %242
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %6, ptr noundef nonnull %7, ptr noundef %gep602, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %243, ptr noundef nonnull %7) #5
  %.pre621 = load i32, ptr %232, align 4, !tbaa !5
  br label %244

244:                                              ; preds = %237, %236
  %245 = phi i32 [ %.pre621, %237 ], [ %233, %236 ]
  %.not582 = icmp eq i32 %245, %.2603
  br i1 %.not582, label %282, label %246

246:                                              ; preds = %244
  %247 = add nsw i32 %245, %19
  br label %.sink.split

248:                                              ; preds = %.lr.ph604
  br i1 %235, label %249, label %262

249:                                              ; preds = %248
  %250 = add nsw i32 %.2603, -1
  store i32 %250, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %251 = mul nsw i32 %.2603, %15
  %252 = sext i32 %251 to i64
  %gep598 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %252
  %253 = add nsw i32 %.2603, %19
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %254
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %6, ptr noundef nonnull %7, ptr noundef %gep598, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %255, ptr noundef nonnull %7) #5
  store i32 %250, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %256 = add nuw nsw i32 %.2603, 1
  %257 = mul nsw i32 %256, %15
  %258 = sext i32 %257 to i64
  %gep600 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %258
  %259 = add nsw i32 %256, %19
  %260 = sext i32 %259 to i64
  %261 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %260
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %6, ptr noundef nonnull %7, ptr noundef %gep600, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %261, ptr noundef nonnull %7) #5
  %.pre620 = load i32, ptr %232, align 4, !tbaa !5
  br label %262

262:                                              ; preds = %249, %248
  %263 = phi i32 [ %.pre620, %249 ], [ %233, %248 ]
  %264 = sub nsw i32 0, %263
  %.not579 = icmp eq i32 %.2603, %264
  br i1 %.not579, label %272, label %265

265:                                              ; preds = %262
  %266 = add nsw i32 %.2603, %19
  %267 = sext i32 %266 to i64
  %268 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %267
  %269 = sub i32 %19, %263
  %270 = sext i32 %269 to i64
  %271 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %270
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %268, ptr noundef nonnull %7, ptr noundef %271, ptr noundef nonnull %7) #5
  br label %272

272:                                              ; preds = %265, %262
  %273 = add nsw i32 %.2603, 1
  %274 = sext i32 %273 to i64
  %275 = getelementptr inbounds i32, ptr %18, i64 %274
  %276 = load i32, ptr %275, align 4, !tbaa !5
  %277 = sub nsw i32 0, %276
  %.not580 = icmp eq i32 %273, %277
  br i1 %.not580, label %282, label %278

278:                                              ; preds = %272
  %279 = sub i32 %19, %276
  br label %.sink.split

.sink.split:                                      ; preds = %246, %278
  %.sink656 = phi i32 [ %279, %278 ], [ %247, %246 ]
  %.pn662 = phi i32 [ %273, %278 ], [ %.2603, %246 ]
  %.sink651.ph = phi i32 [ 2, %278 ], [ 1, %246 ]
  %.pn.in = add nsw i32 %.pn662, %19
  %.pn = sext i32 %.pn.in to i64
  %.sink653 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %.pn
  %280 = sext i32 %.sink656 to i64
  %281 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %280
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink653, ptr noundef nonnull %7, ptr noundef %281, ptr noundef nonnull %7) #5
  br label %282

282:                                              ; preds = %.sink.split, %272, %244
  %.sink651 = phi i32 [ 1, %244 ], [ 2, %272 ], [ %.sink651.ph, %.sink.split ]
  %283 = add nsw i32 %.2603, %.sink651
  %284 = load i32, ptr %1, align 4, !tbaa !5
  %285 = icmp sgt i32 %283, %284
  br i1 %285, label %.loopexit, label %.lr.ph604

.preheader:                                       ; preds = %492
  %286 = icmp slt i32 %493, 1
  br i1 %286, label %.loopexit, label %.lr.ph613

287:                                              ; preds = %.lr.ph611, %492
  %288 = phi i32 [ %26, %.lr.ph611 ], [ %493, %492 ]
  %.4610 = phi i32 [ 1, %.lr.ph611 ], [ %.5, %492 ]
  %289 = sext i32 %.4610 to i64
  %290 = getelementptr inbounds i32, ptr %18, i64 %289
  %291 = load i32, ptr %290, align 4, !tbaa !5
  %292 = icmp sgt i32 %291, 0
  br i1 %292, label %293, label %333

293:                                              ; preds = %287
  %.not571 = icmp eq i32 %291, %.4610
  br i1 %.not571, label %301, label %294

294:                                              ; preds = %293
  %295 = add nsw i32 %.4610, %19
  %296 = sext i32 %295 to i64
  %297 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %296
  %298 = add nsw i32 %291, %19
  %299 = sext i32 %298 to i64
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %299
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %297, ptr noundef nonnull %7, ptr noundef %300, ptr noundef nonnull %7) #5
  %.pre622 = load i32, ptr %1, align 4, !tbaa !5
  br label %301

301:                                              ; preds = %294, %293
  %302 = phi i32 [ %.pre622, %294 ], [ %288, %293 ]
  %303 = icmp slt i32 %.4610, %302
  br i1 %303, label %304, label %._crit_edge628

._crit_edge628:                                   ; preds = %301
  %.pre629 = add nsw i32 %.4610, %19
  %.pre630 = sext i32 %.pre629 to i64
  %.pre632 = add nsw i32 %.4610, 1
  br label %317

304:                                              ; preds = %301
  %305 = sub nsw i32 %302, %.4610
  store i32 %305, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %306 = add nsw i32 %.4610, 1
  %307 = mul nsw i32 %.4610, %15
  %308 = add nsw i32 %306, %307
  %309 = sext i32 %308 to i64
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %309
  %311 = add nsw i32 %.4610, %19
  %312 = sext i32 %311 to i64
  %313 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %312
  %314 = add nsw i32 %306, %19
  %315 = sext i32 %314 to i64
  %316 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %315
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %310, ptr noundef nonnull @c__1, ptr noundef %313, ptr noundef nonnull %7, ptr noundef %316, ptr noundef nonnull %7) #5
  br label %317

317:                                              ; preds = %._crit_edge628, %304
  %.pre-phi633 = phi i32 [ %.pre632, %._crit_edge628 ], [ %306, %304 ]
  %.pre-phi631 = phi i64 [ %.pre630, %._crit_edge628 ], [ %312, %304 ]
  %318 = call { double, double } @Cd(ptr noundef nonnull @c_b1)
  %319 = extractvalue { double, double } %318, 0
  %320 = extractvalue { double, double } %318, 1
  %321 = mul i32 %.4610, %49
  %322 = sext i32 %321 to i64
  %323 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %322
  %324 = call { double, double } @Cd(ptr noundef %323)
  %325 = extractvalue { double, double } %324, 0
  %326 = extractvalue { double, double } %324, 1
  %327 = call { double, double } @__divdc3(double noundef %319, double noundef %320, double noundef %325, double noundef %326) #5
  %328 = extractvalue { double, double } %327, 0
  %329 = extractvalue { double, double } %327, 1
  %330 = call ptr @_pCd(ptr noundef nonnull %11)
  %331 = getelementptr inbounds i8, ptr %330, i64 8
  store double %328, ptr %330, align 8
  store double %329, ptr %331, align 8
  %332 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %.pre-phi631
  call void @zscal_(ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %332, ptr noundef nonnull %7) #5
  br label %492

333:                                              ; preds = %287
  %334 = sub nsw i32 0, %291
  %.not568 = icmp eq i32 %.4610, %334
  br i1 %.not568, label %342, label %335

335:                                              ; preds = %333
  %336 = add nsw i32 %.4610, %19
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %337
  %339 = sub i32 %19, %291
  %340 = sext i32 %339 to i64
  %341 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %340
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %338, ptr noundef nonnull %7, ptr noundef %341, ptr noundef nonnull %7) #5
  br label %342

342:                                              ; preds = %335, %333
  %343 = add nsw i32 %.4610, 1
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds i32, ptr %18, i64 %344
  %346 = load i32, ptr %345, align 4, !tbaa !5
  %347 = sub nsw i32 0, %346
  %.not569 = icmp eq i32 %343, %347
  br i1 %.not569, label %355, label %348

348:                                              ; preds = %342
  %349 = add nsw i32 %343, %19
  %350 = sext i32 %349 to i64
  %351 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %350
  %352 = sub i32 %19, %346
  %353 = sext i32 %352 to i64
  %354 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %353
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %351, ptr noundef nonnull %7, ptr noundef %354, ptr noundef nonnull %7) #5
  br label %355

355:                                              ; preds = %348, %342
  %356 = load i32, ptr %1, align 4, !tbaa !5
  %357 = add nsw i32 %356, -1
  %358 = icmp slt i32 %.4610, %357
  br i1 %358, label %359, label %._crit_edge627

._crit_edge627:                                   ; preds = %355
  %.pre634 = mul nsw i32 %.4610, %15
  br label %382

359:                                              ; preds = %355
  %360 = xor i32 %.4610, -1
  %361 = add i32 %356, %360
  store i32 %361, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %362 = add nsw i32 %.4610, 2
  %363 = mul nsw i32 %.4610, %15
  %364 = add nsw i32 %362, %363
  %365 = sext i32 %364 to i64
  %366 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %365
  %367 = add nsw i32 %.4610, %19
  %368 = sext i32 %367 to i64
  %369 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %368
  %370 = add nsw i32 %362, %19
  %371 = sext i32 %370 to i64
  %372 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %371
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %366, ptr noundef nonnull @c__1, ptr noundef %369, ptr noundef nonnull %7, ptr noundef %372, ptr noundef nonnull %7) #5
  %373 = load i32, ptr %1, align 4, !tbaa !5
  %374 = add i32 %373, %360
  store i32 %374, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %375 = mul nsw i32 %343, %15
  %376 = add nsw i32 %375, %362
  %377 = sext i32 %376 to i64
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %377
  %379 = add nsw i32 %343, %19
  %380 = sext i32 %379 to i64
  %381 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %380
  call void @zgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %378, ptr noundef nonnull @c__1, ptr noundef %381, ptr noundef nonnull %7, ptr noundef %372, ptr noundef nonnull %7) #5
  br label %382

382:                                              ; preds = %._crit_edge627, %359
  %.pre-phi635 = phi i32 [ %.pre634, %._crit_edge627 ], [ %363, %359 ]
  %383 = add nsw i32 %343, %.pre-phi635
  store i32 %383, ptr %10, align 4, !tbaa !5
  %384 = sext i32 %383 to i64
  %385 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %384
  %386 = load <2 x double>, ptr %385, align 8, !tbaa !9
  store <2 x double> %386, ptr %13, align 16, !tbaa !9
  %387 = add nsw i32 %.pre-phi635, %.4610
  %388 = sext i32 %387 to i64
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %388
  %390 = call { double, double } @Cd(ptr noundef %389)
  %391 = extractvalue { double, double } %390, 0
  %392 = extractvalue { double, double } %390, 1
  %393 = call { double, double } @Cd(ptr noundef nonnull %13)
  %394 = extractvalue { double, double } %393, 0
  %395 = extractvalue { double, double } %393, 1
  %396 = call { double, double } @__divdc3(double noundef %391, double noundef %392, double noundef %394, double noundef %395) #5
  %397 = extractvalue { double, double } %396, 0
  %398 = extractvalue { double, double } %396, 1
  %399 = call ptr @_pCd(ptr noundef nonnull %11)
  %400 = getelementptr inbounds i8, ptr %399, i64 8
  store double %397, ptr %399, align 8
  store double %398, ptr %400, align 8
  %401 = load <2 x double>, ptr %11, align 16
  %402 = load double, ptr %48, align 8, !tbaa !11
  %403 = mul i32 %343, %49
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %404
  %406 = call { double, double } @Cd(ptr noundef %405)
  %407 = extractvalue { double, double } %406, 0
  %408 = extractvalue { double, double } %406, 1
  %409 = call { double, double } @Cd(ptr noundef nonnull %13)
  %410 = extractvalue { double, double } %409, 0
  %411 = extractvalue { double, double } %409, 1
  %412 = call { double, double } @__divdc3(double noundef %407, double noundef %408, double noundef %410, double noundef %411) #5
  %413 = extractvalue { double, double } %412, 0
  %414 = extractvalue { double, double } %412, 1
  %415 = call ptr @_pCd(ptr noundef nonnull %11)
  %416 = getelementptr inbounds i8, ptr %415, i64 8
  store double %413, ptr %415, align 8
  store double %414, ptr %416, align 8
  %417 = fneg double %402
  %418 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %419 = insertelement <2 x double> poison, double %402, i64 0
  %420 = insertelement <2 x double> %419, double %417, i64 1
  %421 = fmul <2 x double> %418, %420
  %422 = shufflevector <2 x double> %421, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %423 = shufflevector <2 x double> %401, <2 x double> poison, <2 x i32> zeroinitializer
  %424 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %423, <2 x double> %418, <2 x double> %422)
  store <2 x double> %424, ptr %12, align 16, !tbaa !9
  %425 = fadd <2 x double> %424, <double -1.000000e+00, double 0.000000e+00>
  store <2 x double> %425, ptr %11, align 16, !tbaa !9
  store <2 x double> %425, ptr %14, align 16, !tbaa !9
  %426 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %426, ptr %10, align 4, !tbaa !5
  %.not570605 = icmp slt i32 %426, 1
  br i1 %.not570605, label %._crit_edge609, label %.lr.ph608

.lr.ph608:                                        ; preds = %382
  %invariant.gep647 = getelementptr %struct.doublecomplex, ptr %21, i64 %289
  %invariant.gep649 = getelementptr %struct.doublecomplex, ptr %21, i64 %344
  %427 = shufflevector <2 x double> %418, <2 x double> poison, <2 x i32> zeroinitializer
  %428 = shufflevector <2 x double> %418, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %429 = fneg <2 x double> %418
  %430 = shufflevector <2 x double> %428, <2 x double> %429, <2 x i32> <i32 0, i32 3>
  br label %431

431:                                              ; preds = %.lr.ph608, %431
  %indvars.iv617 = phi i64 [ 1, %.lr.ph608 ], [ %indvars.iv.next618, %431 ]
  %432 = mul nsw i64 %indvars.iv617, %50
  %gep648 = getelementptr %struct.doublecomplex, ptr %invariant.gep647, i64 %432
  %433 = call { double, double } @Cd(ptr noundef %gep648)
  %434 = extractvalue { double, double } %433, 0
  %435 = extractvalue { double, double } %433, 1
  %436 = call { double, double } @Cd(ptr noundef nonnull %13)
  %437 = extractvalue { double, double } %436, 0
  %438 = extractvalue { double, double } %436, 1
  %439 = call { double, double } @__divdc3(double noundef %434, double noundef %435, double noundef %437, double noundef %438) #5
  %440 = extractvalue { double, double } %439, 0
  %441 = extractvalue { double, double } %439, 1
  %442 = call ptr @_pCd(ptr noundef nonnull %11)
  %443 = getelementptr inbounds i8, ptr %442, i64 8
  store double %440, ptr %442, align 8
  store double %441, ptr %443, align 8
  %gep650 = getelementptr %struct.doublecomplex, ptr %invariant.gep649, i64 %432
  %444 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %445 = call { double, double } @Cd(ptr noundef %gep650)
  %446 = extractvalue { double, double } %445, 0
  %447 = extractvalue { double, double } %445, 1
  %448 = call { double, double } @Cd(ptr noundef nonnull %13)
  %449 = extractvalue { double, double } %448, 0
  %450 = extractvalue { double, double } %448, 1
  %451 = call { double, double } @__divdc3(double noundef %446, double noundef %447, double noundef %449, double noundef %450) #5
  %452 = extractvalue { double, double } %451, 0
  %453 = extractvalue { double, double } %451, 1
  %454 = call ptr @_pCd(ptr noundef nonnull %11)
  %455 = getelementptr inbounds i8, ptr %454, i64 8
  store double %452, ptr %454, align 8
  store double %453, ptr %455, align 8
  %456 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %457 = fmul <2 x double> %444, %430
  %458 = shufflevector <2 x double> %457, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %459 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %427, <2 x double> %444, <2 x double> %458)
  %460 = fsub <2 x double> %459, %456
  store <2 x double> %460, ptr %12, align 16, !tbaa !9
  %461 = call { double, double } @Cd(ptr noundef nonnull %12)
  %462 = extractvalue { double, double } %461, 0
  %463 = extractvalue { double, double } %461, 1
  %464 = call { double, double } @Cd(ptr noundef nonnull %14)
  %465 = extractvalue { double, double } %464, 0
  %466 = extractvalue { double, double } %464, 1
  %467 = call { double, double } @__divdc3(double noundef %462, double noundef %463, double noundef %465, double noundef %466) #5
  %468 = extractvalue { double, double } %467, 0
  %469 = extractvalue { double, double } %467, 1
  %470 = call ptr @_pCd(ptr noundef nonnull %11)
  %471 = getelementptr inbounds i8, ptr %470, i64 8
  store double %468, ptr %470, align 8
  store double %469, ptr %471, align 8
  %472 = load <2 x double>, ptr %11, align 16, !tbaa !9
  store <2 x double> %472, ptr %gep648, align 8, !tbaa !9
  %473 = fmul <2 x double> %456, %420
  %474 = shufflevector <2 x double> %473, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %475 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %423, <2 x double> %456, <2 x double> %474)
  %476 = fsub <2 x double> %475, %444
  store <2 x double> %476, ptr %12, align 16, !tbaa !9
  %477 = call { double, double } @Cd(ptr noundef nonnull %12)
  %478 = extractvalue { double, double } %477, 0
  %479 = extractvalue { double, double } %477, 1
  %480 = call { double, double } @Cd(ptr noundef nonnull %14)
  %481 = extractvalue { double, double } %480, 0
  %482 = extractvalue { double, double } %480, 1
  %483 = call { double, double } @__divdc3(double noundef %478, double noundef %479, double noundef %481, double noundef %482) #5
  %484 = extractvalue { double, double } %483, 0
  %485 = extractvalue { double, double } %483, 1
  %486 = call ptr @_pCd(ptr noundef nonnull %11)
  %487 = getelementptr inbounds i8, ptr %486, i64 8
  store double %484, ptr %486, align 8
  store double %485, ptr %487, align 8
  %488 = load <2 x double>, ptr %11, align 16, !tbaa !9
  store <2 x double> %488, ptr %gep650, align 8, !tbaa !9
  %indvars.iv.next618 = add nuw nsw i64 %indvars.iv617, 1
  %489 = load i32, ptr %10, align 4, !tbaa !5
  %490 = sext i32 %489 to i64
  %.not570.not = icmp slt i64 %indvars.iv617, %490
  br i1 %.not570.not, label %431, label %._crit_edge609, !llvm.loop !15

._crit_edge609:                                   ; preds = %431, %382
  %491 = add nsw i32 %.4610, 2
  br label %492

492:                                              ; preds = %._crit_edge609, %317
  %.5 = phi i32 [ %.pre-phi633, %317 ], [ %491, %._crit_edge609 ]
  %493 = load i32, ptr %1, align 4, !tbaa !5
  %494 = icmp sgt i32 %.5, %493
  br i1 %494, label %.preheader, label %287

.lr.ph613:                                        ; preds = %.preheader, %563
  %.6612 = phi i32 [ %564, %563 ], [ %493, %.preheader ]
  %495 = zext nneg i32 %.6612 to i64
  %496 = getelementptr inbounds i32, ptr %18, i64 %495
  %497 = load i32, ptr %496, align 4, !tbaa !5
  %498 = icmp sgt i32 %497, 0
  %499 = load i32, ptr %1, align 4, !tbaa !5
  %500 = icmp slt i32 %.6612, %499
  br i1 %498, label %501, label %519

501:                                              ; preds = %.lr.ph613
  br i1 %500, label %502, label %515

502:                                              ; preds = %501
  %503 = sub nsw i32 %499, %.6612
  store i32 %503, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %504 = add nuw nsw i32 %.6612, 1
  %505 = add nsw i32 %504, %19
  %506 = sext i32 %505 to i64
  %507 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %506
  %508 = mul nsw i32 %.6612, %15
  %509 = add nsw i32 %504, %508
  %510 = sext i32 %509 to i64
  %511 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %510
  %512 = add nsw i32 %.6612, %19
  %513 = sext i32 %512 to i64
  %514 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %513
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %507, ptr noundef nonnull %7, ptr noundef %511, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %514, ptr noundef nonnull %7) #5
  %.pre624 = load i32, ptr %496, align 4, !tbaa !5
  br label %515

515:                                              ; preds = %502, %501
  %516 = phi i32 [ %.pre624, %502 ], [ %497, %501 ]
  %.not574 = icmp eq i32 %516, %.6612
  br i1 %.not574, label %563, label %517

517:                                              ; preds = %515
  %518 = add nsw i32 %516, %19
  br label %.sink.split657

519:                                              ; preds = %.lr.ph613
  br i1 %500, label %520, label %543

520:                                              ; preds = %519
  %521 = sub nsw i32 %499, %.6612
  store i32 %521, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %522 = add nuw nsw i32 %.6612, 1
  %523 = add nsw i32 %522, %19
  %524 = sext i32 %523 to i64
  %525 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %524
  %526 = mul nsw i32 %.6612, %15
  %527 = add nsw i32 %522, %526
  %528 = sext i32 %527 to i64
  %529 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %528
  %530 = add nsw i32 %.6612, %19
  %531 = sext i32 %530 to i64
  %532 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %531
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %525, ptr noundef nonnull %7, ptr noundef %529, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %532, ptr noundef nonnull %7) #5
  %533 = load i32, ptr %1, align 4, !tbaa !5
  %534 = sub nsw i32 %533, %.6612
  store i32 %534, ptr %10, align 4, !tbaa !5
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %11, align 16, !tbaa !9
  %535 = add nsw i32 %.6612, -1
  %536 = mul nsw i32 %535, %15
  %537 = add nsw i32 %536, %522
  %538 = sext i32 %537 to i64
  %539 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %538
  %540 = add nsw i32 %535, %19
  %541 = sext i32 %540 to i64
  %542 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %541
  call void @zgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %525, ptr noundef nonnull %7, ptr noundef %539, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %542, ptr noundef nonnull %7) #5
  %.pre623 = load i32, ptr %496, align 4, !tbaa !5
  br label %543

543:                                              ; preds = %520, %519
  %544 = phi i32 [ %.pre623, %520 ], [ %497, %519 ]
  %545 = sub nsw i32 0, %544
  %.not572 = icmp eq i32 %.6612, %545
  br i1 %.not572, label %553, label %546

546:                                              ; preds = %543
  %547 = add nsw i32 %.6612, %19
  %548 = sext i32 %547 to i64
  %549 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %548
  %550 = sub i32 %19, %544
  %551 = sext i32 %550 to i64
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %551
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %549, ptr noundef nonnull %7, ptr noundef %552, ptr noundef nonnull %7) #5
  br label %553

553:                                              ; preds = %546, %543
  %554 = add nsw i32 %.6612, -1
  %555 = zext nneg i32 %554 to i64
  %556 = getelementptr inbounds i32, ptr %18, i64 %555
  %557 = load i32, ptr %556, align 4, !tbaa !5
  %558 = sub nsw i32 0, %557
  %.not573 = icmp eq i32 %554, %558
  br i1 %.not573, label %563, label %559

559:                                              ; preds = %553
  %560 = sub i32 %19, %557
  br label %.sink.split657

.sink.split657:                                   ; preds = %517, %559
  %.sink661 = phi i32 [ %560, %559 ], [ %518, %517 ]
  %.pn664 = phi i32 [ %554, %559 ], [ %.6612, %517 ]
  %.sink652.ph = phi i32 [ -2, %559 ], [ -1, %517 ]
  %.pn663.in = add nsw i32 %.pn664, %19
  %.pn663 = sext i32 %.pn663.in to i64
  %.sink658 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %.pn663
  %561 = sext i32 %.sink661 to i64
  %562 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %561
  call void @zswap_(ptr noundef nonnull %2, ptr noundef %.sink658, ptr noundef nonnull %7, ptr noundef %562, ptr noundef nonnull %7) #5
  br label %563

563:                                              ; preds = %.sink.split657, %553, %515
  %.sink652 = phi i32 [ -1, %515 ], [ -2, %553 ], [ %.sink652.ph, %.sink.split657 ]
  %564 = add nsw i32 %.6612, %.sink652
  %565 = icmp slt i32 %564, 1
  br i1 %565, label %.loopexit, label %.lr.ph613

.loopexit:                                        ; preds = %282, %563, %.preheader586, %.preheader, %41, %.thread
  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 16, ptr nonnull %11) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #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 @zswap_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @zgeru_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, 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

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

declare void @zgemv_(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

; 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 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!12, !10, i64 8}
!12 = !{!"", !10, i64 0, !10, i64 8}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}


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