; LLVM IR from OpenMathLib/OpenBLAS :: lapack-netlib/TESTING/MATGEN (zlagge)

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

%struct.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [7 x i8], align 1
@c__3 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c_b2 = external hidden global %struct.doublecomplex, align 8
@.str.1 = external hidden unnamed_addr constant [20 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.2 = external hidden unnamed_addr constant [13 x i8], align 1

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

61:                                               ; preds = %10
  %62 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -1, ptr %62, align 4, !tbaa !9
  br label %114

63:                                               ; preds = %10
  %64 = load ptr, ptr %12, align 8, !tbaa !5
  %65 = load i32, ptr %64, align 4, !tbaa !9
  %66 = icmp slt i32 %65, 0
  br i1 %66, label %67, label %69

67:                                               ; preds = %63
  %68 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -2, ptr %68, align 4, !tbaa !9
  br label %113

69:                                               ; preds = %63
  %70 = load ptr, ptr %13, align 8, !tbaa !5
  %71 = load i32, ptr %70, align 4, !tbaa !9
  %72 = icmp slt i32 %71, 0
  br i1 %72, label %80, label %73

73:                                               ; preds = %69
  %74 = load ptr, ptr %13, align 8, !tbaa !5
  %75 = load i32, ptr %74, align 4, !tbaa !9
  %76 = load ptr, ptr %11, align 8, !tbaa !5
  %77 = load i32, ptr %76, align 4, !tbaa !9
  %78 = sub nsw i32 %77, 1
  %79 = icmp sgt i32 %75, %78
  br i1 %79, label %80, label %82

80:                                               ; preds = %73, %69
  %81 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -3, ptr %81, align 4, !tbaa !9
  br label %112

82:                                               ; preds = %73
  %83 = load ptr, ptr %14, align 8, !tbaa !5
  %84 = load i32, ptr %83, align 4, !tbaa !9
  %85 = icmp slt i32 %84, 0
  br i1 %85, label %93, label %86

86:                                               ; preds = %82
  %87 = load ptr, ptr %14, align 8, !tbaa !5
  %88 = load i32, ptr %87, align 4, !tbaa !9
  %89 = load ptr, ptr %12, align 8, !tbaa !5
  %90 = load i32, ptr %89, align 4, !tbaa !9
  %91 = sub nsw i32 %90, 1
  %92 = icmp sgt i32 %88, %91
  br i1 %92, label %93, label %95

93:                                               ; preds = %86, %82
  %94 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -4, ptr %94, align 4, !tbaa !9
  br label %111

95:                                               ; preds = %86
  %96 = load ptr, ptr %17, align 8, !tbaa !5
  %97 = load i32, ptr %96, align 4, !tbaa !9
  %98 = load ptr, ptr %11, align 8, !tbaa !5
  %99 = load i32, ptr %98, align 4, !tbaa !9
  %100 = icmp sge i32 1, %99
  br i1 %100, label %101, label %102

101:                                              ; preds = %95
  br label %105

102:                                              ; preds = %95
  %103 = load ptr, ptr %11, align 8, !tbaa !5
  %104 = load i32, ptr %103, align 4, !tbaa !9
  br label %105

105:                                              ; preds = %102, %101
  %106 = phi i32 [ 1, %101 ], [ %104, %102 ]
  %107 = icmp slt i32 %97, %106
  br i1 %107, label %108, label %110

108:                                              ; preds = %105
  %109 = load ptr, ptr %20, align 8, !tbaa !5
  store i32 -7, ptr %109, align 4, !tbaa !9
  br label %110

110:                                              ; preds = %108, %105
  br label %111

111:                                              ; preds = %110, %93
  br label %112

112:                                              ; preds = %111, %80
  br label %113

113:                                              ; preds = %112, %67
  br label %114

114:                                              ; preds = %113, %61
  %115 = load ptr, ptr %20, align 8, !tbaa !5
  %116 = load i32, ptr %115, align 4, !tbaa !9
  %117 = icmp slt i32 %116, 0
  br i1 %117, label %118, label %123

118:                                              ; preds = %114
  %119 = load ptr, ptr %20, align 8, !tbaa !5
  %120 = load i32, ptr %119, align 4, !tbaa !9
  %121 = sub nsw i32 0, %120
  store i32 %121, ptr %23, align 4, !tbaa !9
  %122 = call i32 @xerbla_(ptr noundef @.str, ptr noundef %23, i32 noundef 6)
  store i32 1, ptr %34, align 4
  br label %2040

123:                                              ; preds = %114
  %124 = load ptr, ptr %12, align 8, !tbaa !5
  %125 = load i32, ptr %124, align 4, !tbaa !9
  store i32 %125, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %29, align 4, !tbaa !9
  br label %126

126:                                              ; preds = %157, %123
  %127 = load i32, ptr %29, align 4, !tbaa !9
  %128 = load i32, ptr %23, align 4, !tbaa !9
  %129 = icmp sle i32 %127, %128
  br i1 %129, label %130, label %160

130:                                              ; preds = %126
  %131 = load ptr, ptr %11, align 8, !tbaa !5
  %132 = load i32, ptr %131, align 4, !tbaa !9
  store i32 %132, ptr %24, align 4, !tbaa !9
  store i32 1, ptr %28, align 4, !tbaa !9
  br label %133

133:                                              ; preds = %153, %130
  %134 = load i32, ptr %28, align 4, !tbaa !9
  %135 = load i32, ptr %24, align 4, !tbaa !9
  %136 = icmp sle i32 %134, %135
  br i1 %136, label %137, label %156

137:                                              ; preds = %133
  %138 = load i32, ptr %28, align 4, !tbaa !9
  %139 = load i32, ptr %29, align 4, !tbaa !9
  %140 = load i32, ptr %21, align 4, !tbaa !9
  %141 = mul nsw i32 %139, %140
  %142 = add nsw i32 %138, %141
  store i32 %142, ptr %25, align 4, !tbaa !9
  %143 = load ptr, ptr %16, align 8, !tbaa !5
  %144 = load i32, ptr %25, align 4, !tbaa !9
  %145 = sext i32 %144 to i64
  %146 = getelementptr inbounds %struct.doublecomplex, ptr %143, i64 %145
  %147 = getelementptr inbounds %struct.doublecomplex, ptr %146, i32 0, i32 0
  store double 0.000000e+00, ptr %147, align 8, !tbaa !11
  %148 = load ptr, ptr %16, align 8, !tbaa !5
  %149 = load i32, ptr %25, align 4, !tbaa !9
  %150 = sext i32 %149 to i64
  %151 = getelementptr inbounds %struct.doublecomplex, ptr %148, i64 %150
  %152 = getelementptr inbounds %struct.doublecomplex, ptr %151, i32 0, i32 1
  store double 0.000000e+00, ptr %152, align 8, !tbaa !14
  br label %153

153:                                              ; preds = %137
  %154 = load i32, ptr %28, align 4, !tbaa !9
  %155 = add nsw i32 %154, 1
  store i32 %155, ptr %28, align 4, !tbaa !9
  br label %133, !llvm.loop !15

156:                                              ; preds = %133
  br label %157

157:                                              ; preds = %156
  %158 = load i32, ptr %29, align 4, !tbaa !9
  %159 = add nsw i32 %158, 1
  store i32 %159, ptr %29, align 4, !tbaa !9
  br label %126, !llvm.loop !17

160:                                              ; preds = %126
  %161 = load ptr, ptr %11, align 8, !tbaa !5
  %162 = load i32, ptr %161, align 4, !tbaa !9
  %163 = load ptr, ptr %12, align 8, !tbaa !5
  %164 = load i32, ptr %163, align 4, !tbaa !9
  %165 = icmp sle i32 %162, %164
  br i1 %165, label %166, label %169

166:                                              ; preds = %160
  %167 = load ptr, ptr %11, align 8, !tbaa !5
  %168 = load i32, ptr %167, align 4, !tbaa !9
  br label %172

169:                                              ; preds = %160
  %170 = load ptr, ptr %12, align 8, !tbaa !5
  %171 = load i32, ptr %170, align 4, !tbaa !9
  br label %172

172:                                              ; preds = %169, %166
  %173 = phi i32 [ %168, %166 ], [ %171, %169 ]
  store i32 %173, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %28, align 4, !tbaa !9
  br label %174

174:                                              ; preds = %200, %172
  %175 = load i32, ptr %28, align 4, !tbaa !9
  %176 = load i32, ptr %23, align 4, !tbaa !9
  %177 = icmp sle i32 %175, %176
  br i1 %177, label %178, label %203

178:                                              ; preds = %174
  %179 = load i32, ptr %28, align 4, !tbaa !9
  %180 = load i32, ptr %28, align 4, !tbaa !9
  %181 = load i32, ptr %21, align 4, !tbaa !9
  %182 = mul nsw i32 %180, %181
  %183 = add nsw i32 %179, %182
  store i32 %183, ptr %24, align 4, !tbaa !9
  %184 = load i32, ptr %28, align 4, !tbaa !9
  store i32 %184, ptr %25, align 4, !tbaa !9
  %185 = load ptr, ptr %15, align 8, !tbaa !5
  %186 = load i32, ptr %25, align 4, !tbaa !9
  %187 = sext i32 %186 to i64
  %188 = getelementptr inbounds double, ptr %185, i64 %187
  %189 = load double, ptr %188, align 8, !tbaa !18
  %190 = load ptr, ptr %16, align 8, !tbaa !5
  %191 = load i32, ptr %24, align 4, !tbaa !9
  %192 = sext i32 %191 to i64
  %193 = getelementptr inbounds %struct.doublecomplex, ptr %190, i64 %192
  %194 = getelementptr inbounds %struct.doublecomplex, ptr %193, i32 0, i32 0
  store double %189, ptr %194, align 8, !tbaa !11
  %195 = load ptr, ptr %16, align 8, !tbaa !5
  %196 = load i32, ptr %24, align 4, !tbaa !9
  %197 = sext i32 %196 to i64
  %198 = getelementptr inbounds %struct.doublecomplex, ptr %195, i64 %197
  %199 = getelementptr inbounds %struct.doublecomplex, ptr %198, i32 0, i32 1
  store double 0.000000e+00, ptr %199, align 8, !tbaa !14
  br label %200

200:                                              ; preds = %178
  %201 = load i32, ptr %28, align 4, !tbaa !9
  %202 = add nsw i32 %201, 1
  store i32 %202, ptr %28, align 4, !tbaa !9
  br label %174, !llvm.loop !19

203:                                              ; preds = %174
  %204 = load ptr, ptr %13, align 8, !tbaa !5
  %205 = load i32, ptr %204, align 4, !tbaa !9
  %206 = icmp eq i32 %205, 0
  br i1 %206, label %207, label %212

207:                                              ; preds = %203
  %208 = load ptr, ptr %14, align 8, !tbaa !5
  %209 = load i32, ptr %208, align 4, !tbaa !9
  %210 = icmp eq i32 %209, 0
  br i1 %210, label %211, label %212

211:                                              ; preds = %207
  store i32 1, ptr %34, align 4
  br label %2040

212:                                              ; preds = %207, %203
  %213 = load ptr, ptr %11, align 8, !tbaa !5
  %214 = load i32, ptr %213, align 4, !tbaa !9
  %215 = load ptr, ptr %12, align 8, !tbaa !5
  %216 = load i32, ptr %215, align 4, !tbaa !9
  %217 = icmp sle i32 %214, %216
  br i1 %217, label %218, label %221

218:                                              ; preds = %212
  %219 = load ptr, ptr %11, align 8, !tbaa !5
  %220 = load i32, ptr %219, align 4, !tbaa !9
  br label %224

221:                                              ; preds = %212
  %222 = load ptr, ptr %12, align 8, !tbaa !5
  %223 = load i32, ptr %222, align 4, !tbaa !9
  br label %224

224:                                              ; preds = %221, %218
  %225 = phi i32 [ %220, %218 ], [ %223, %221 ]
  store i32 %225, ptr %28, align 4, !tbaa !9
  br label %226

226:                                              ; preds = %608, %224
  %227 = load i32, ptr %28, align 4, !tbaa !9
  %228 = icmp sge i32 %227, 1
  br i1 %228, label %229, label %611

229:                                              ; preds = %226
  %230 = load i32, ptr %28, align 4, !tbaa !9
  %231 = load ptr, ptr %11, align 8, !tbaa !5
  %232 = load i32, ptr %231, align 4, !tbaa !9
  %233 = icmp slt i32 %230, %232
  br i1 %233, label %234, label %418

234:                                              ; preds = %229
  %235 = load ptr, ptr %11, align 8, !tbaa !5
  %236 = load i32, ptr %235, align 4, !tbaa !9
  %237 = load i32, ptr %28, align 4, !tbaa !9
  %238 = sub nsw i32 %236, %237
  %239 = add nsw i32 %238, 1
  store i32 %239, ptr %23, align 4, !tbaa !9
  %240 = load ptr, ptr %18, align 8, !tbaa !5
  %241 = getelementptr inbounds i32, ptr %240, i64 1
  %242 = load ptr, ptr %19, align 8, !tbaa !5
  %243 = getelementptr inbounds %struct.doublecomplex, ptr %242, i64 1
  call void @zlarnv_(ptr noundef @c__3, ptr noundef %241, ptr noundef %23, ptr noundef %243)
  %244 = load ptr, ptr %11, align 8, !tbaa !5
  %245 = load i32, ptr %244, align 4, !tbaa !9
  %246 = load i32, ptr %28, align 4, !tbaa !9
  %247 = sub nsw i32 %245, %246
  %248 = add nsw i32 %247, 1
  store i32 %248, ptr %23, align 4, !tbaa !9
  %249 = load ptr, ptr %19, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %249, i64 1
  %251 = call double @dznrm2_(ptr noundef %23, ptr noundef %250, ptr noundef @c__1)
  store double %251, ptr %32, align 8, !tbaa !18
  %252 = load double, ptr %32, align 8, !tbaa !18
  %253 = load ptr, ptr %19, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.doublecomplex, ptr %253, i64 1
  %255 = call { double, double } @Cd(ptr noundef %254)
  %256 = extractvalue { double, double } %255, 0
  %257 = extractvalue { double, double } %255, 1
  %258 = getelementptr inbounds { double, double }, ptr %35, i32 0, i32 0
  %259 = getelementptr inbounds { double, double }, ptr %35, i32 0, i32 1
  store double %256, ptr %258, align 8
  store double %257, ptr %259, align 8
  %260 = getelementptr inbounds { double, double }, ptr %35, i32 0, i32 0
  %261 = load double, ptr %260, align 8
  %262 = getelementptr inbounds { double, double }, ptr %35, i32 0, i32 1
  %263 = load double, ptr %262, align 8
  %264 = call double @cabs(double noundef %261, double noundef %263) #5
  %265 = fdiv double %252, %264
  store double %265, ptr %26, align 8, !tbaa !18
  %266 = load double, ptr %26, align 8, !tbaa !18
  %267 = load ptr, ptr %19, align 8, !tbaa !5
  %268 = getelementptr inbounds %struct.doublecomplex, ptr %267, i64 1
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %268, i32 0, i32 0
  %270 = load double, ptr %269, align 8, !tbaa !11
  %271 = fmul double %266, %270
  %272 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %271, ptr %272, align 8, !tbaa !11
  %273 = load double, ptr %26, align 8, !tbaa !18
  %274 = load ptr, ptr %19, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.doublecomplex, ptr %274, i64 1
  %276 = getelementptr inbounds %struct.doublecomplex, ptr %275, i32 0, i32 1
  %277 = load double, ptr %276, align 8, !tbaa !14
  %278 = fmul double %273, %277
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %278, ptr %279, align 8, !tbaa !14
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %281 = load double, ptr %280, align 8, !tbaa !11
  %282 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %281, ptr %282, align 8, !tbaa !11
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %284 = load double, ptr %283, align 8, !tbaa !14
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %284, ptr %285, align 8, !tbaa !14
  %286 = load double, ptr %32, align 8, !tbaa !18
  %287 = fcmp oeq double %286, 0.000000e+00
  br i1 %287, label %288, label %291

288:                                              ; preds = %234
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %289, align 8, !tbaa !11
  %290 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %290, align 8, !tbaa !14
  br label %355

291:                                              ; preds = %234
  %292 = load ptr, ptr %19, align 8, !tbaa !5
  %293 = getelementptr inbounds %struct.doublecomplex, ptr %292, i64 1
  %294 = getelementptr inbounds %struct.doublecomplex, ptr %293, i32 0, i32 0
  %295 = load double, ptr %294, align 8, !tbaa !11
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %297 = load double, ptr %296, align 8, !tbaa !11
  %298 = fadd double %295, %297
  %299 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %298, ptr %299, align 8, !tbaa !11
  %300 = load ptr, ptr %19, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.doublecomplex, ptr %300, i64 1
  %302 = getelementptr inbounds %struct.doublecomplex, ptr %301, i32 0, i32 1
  %303 = load double, ptr %302, align 8, !tbaa !14
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %305 = load double, ptr %304, align 8, !tbaa !14
  %306 = fadd double %303, %305
  %307 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %306, ptr %307, align 8, !tbaa !14
  %308 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %309 = load double, ptr %308, align 8, !tbaa !11
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %309, ptr %310, align 8, !tbaa !11
  %311 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %312 = load double, ptr %311, align 8, !tbaa !14
  %313 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %312, ptr %313, align 8, !tbaa !14
  %314 = load ptr, ptr %11, align 8, !tbaa !5
  %315 = load i32, ptr %314, align 4, !tbaa !9
  %316 = load i32, ptr %28, align 4, !tbaa !9
  %317 = sub nsw i32 %315, %316
  store i32 %317, ptr %23, align 4, !tbaa !9
  %318 = call { double, double } @Cd(ptr noundef @c_b2)
  %319 = extractvalue { double, double } %318, 0
  %320 = extractvalue { double, double } %318, 1
  %321 = call { double, double } @Cd(ptr noundef %31)
  %322 = extractvalue { double, double } %321, 0
  %323 = extractvalue { double, double } %321, 1
  %324 = call { double, double } @__divdc3(double noundef %319, double noundef %320, double noundef %322, double noundef %323) #5
  %325 = extractvalue { double, double } %324, 0
  %326 = extractvalue { double, double } %324, 1
  %327 = call ptr @_pCd(ptr noundef %27)
  %328 = getelementptr inbounds { double, double }, ptr %327, i32 0, i32 0
  %329 = getelementptr inbounds { double, double }, ptr %327, i32 0, i32 1
  store double %325, ptr %328, align 8
  store double %326, ptr %329, align 8
  %330 = load ptr, ptr %19, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.doublecomplex, ptr %330, i64 2
  call void @zscal_(ptr noundef %23, ptr noundef %27, ptr noundef %331, ptr noundef @c__1)
  %332 = load ptr, ptr %19, align 8, !tbaa !5
  %333 = getelementptr inbounds %struct.doublecomplex, ptr %332, i64 1
  %334 = getelementptr inbounds %struct.doublecomplex, ptr %333, i32 0, i32 0
  store double 1.000000e+00, ptr %334, align 8, !tbaa !11
  %335 = load ptr, ptr %19, align 8, !tbaa !5
  %336 = getelementptr inbounds %struct.doublecomplex, ptr %335, i64 1
  %337 = getelementptr inbounds %struct.doublecomplex, ptr %336, i32 0, i32 1
  store double 0.000000e+00, ptr %337, align 8, !tbaa !14
  %338 = call { double, double } @Cd(ptr noundef %31)
  %339 = extractvalue { double, double } %338, 0
  %340 = extractvalue { double, double } %338, 1
  %341 = call { double, double } @Cd(ptr noundef %30)
  %342 = extractvalue { double, double } %341, 0
  %343 = extractvalue { double, double } %341, 1
  %344 = call { double, double } @__divdc3(double noundef %339, double noundef %340, double noundef %342, double noundef %343) #5
  %345 = extractvalue { double, double } %344, 0
  %346 = extractvalue { double, double } %344, 1
  %347 = call ptr @_pCd(ptr noundef %27)
  %348 = getelementptr inbounds { double, double }, ptr %347, i32 0, i32 0
  %349 = getelementptr inbounds { double, double }, ptr %347, i32 0, i32 1
  store double %345, ptr %348, align 8
  store double %346, ptr %349, align 8
  %350 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %351 = load double, ptr %350, align 8, !tbaa !11
  store double %351, ptr %26, align 8, !tbaa !18
  %352 = load double, ptr %26, align 8, !tbaa !18
  %353 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %352, ptr %353, align 8, !tbaa !11
  %354 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %354, align 8, !tbaa !14
  br label %355

355:                                              ; preds = %291, %288
  %356 = load ptr, ptr %11, align 8, !tbaa !5
  %357 = load i32, ptr %356, align 4, !tbaa !9
  %358 = load i32, ptr %28, align 4, !tbaa !9
  %359 = sub nsw i32 %357, %358
  %360 = add nsw i32 %359, 1
  store i32 %360, ptr %23, align 4, !tbaa !9
  %361 = load ptr, ptr %12, align 8, !tbaa !5
  %362 = load i32, ptr %361, align 4, !tbaa !9
  %363 = load i32, ptr %28, align 4, !tbaa !9
  %364 = sub nsw i32 %362, %363
  %365 = add nsw i32 %364, 1
  store i32 %365, ptr %24, align 4, !tbaa !9
  %366 = load ptr, ptr %16, align 8, !tbaa !5
  %367 = load i32, ptr %28, align 4, !tbaa !9
  %368 = load i32, ptr %28, align 4, !tbaa !9
  %369 = load i32, ptr %21, align 4, !tbaa !9
  %370 = mul nsw i32 %368, %369
  %371 = add nsw i32 %367, %370
  %372 = sext i32 %371 to i64
  %373 = getelementptr inbounds %struct.doublecomplex, ptr %366, i64 %372
  %374 = load ptr, ptr %17, align 8, !tbaa !5
  %375 = load ptr, ptr %19, align 8, !tbaa !5
  %376 = getelementptr inbounds %struct.doublecomplex, ptr %375, i64 1
  %377 = load ptr, ptr %19, align 8, !tbaa !5
  %378 = load ptr, ptr %11, align 8, !tbaa !5
  %379 = load i32, ptr %378, align 4, !tbaa !9
  %380 = add nsw i32 %379, 1
  %381 = sext i32 %380 to i64
  %382 = getelementptr inbounds %struct.doublecomplex, ptr %377, i64 %381
  call void @zgemv_(ptr noundef @.str.1, ptr noundef %23, ptr noundef %24, ptr noundef @c_b2, ptr noundef %373, ptr noundef %374, ptr noundef %376, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %382, ptr noundef @c__1)
  %383 = load ptr, ptr %11, align 8, !tbaa !5
  %384 = load i32, ptr %383, align 4, !tbaa !9
  %385 = load i32, ptr %28, align 4, !tbaa !9
  %386 = sub nsw i32 %384, %385
  %387 = add nsw i32 %386, 1
  store i32 %387, ptr %23, align 4, !tbaa !9
  %388 = load ptr, ptr %12, align 8, !tbaa !5
  %389 = load i32, ptr %388, align 4, !tbaa !9
  %390 = load i32, ptr %28, align 4, !tbaa !9
  %391 = sub nsw i32 %389, %390
  %392 = add nsw i32 %391, 1
  store i32 %392, ptr %24, align 4, !tbaa !9
  %393 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %394 = load double, ptr %393, align 8, !tbaa !11
  %395 = fneg double %394
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %395, ptr %396, align 8, !tbaa !11
  %397 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %398 = load double, ptr %397, align 8, !tbaa !14
  %399 = fneg double %398
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %399, ptr %400, align 8, !tbaa !14
  %401 = load ptr, ptr %19, align 8, !tbaa !5
  %402 = getelementptr inbounds %struct.doublecomplex, ptr %401, i64 1
  %403 = load ptr, ptr %19, align 8, !tbaa !5
  %404 = load ptr, ptr %11, align 8, !tbaa !5
  %405 = load i32, ptr %404, align 4, !tbaa !9
  %406 = add nsw i32 %405, 1
  %407 = sext i32 %406 to i64
  %408 = getelementptr inbounds %struct.doublecomplex, ptr %403, i64 %407
  %409 = load ptr, ptr %16, align 8, !tbaa !5
  %410 = load i32, ptr %28, align 4, !tbaa !9
  %411 = load i32, ptr %28, align 4, !tbaa !9
  %412 = load i32, ptr %21, align 4, !tbaa !9
  %413 = mul nsw i32 %411, %412
  %414 = add nsw i32 %410, %413
  %415 = sext i32 %414 to i64
  %416 = getelementptr inbounds %struct.doublecomplex, ptr %409, i64 %415
  %417 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %23, ptr noundef %24, ptr noundef %27, ptr noundef %402, ptr noundef @c__1, ptr noundef %408, ptr noundef @c__1, ptr noundef %416, ptr noundef %417)
  br label %418

418:                                              ; preds = %355, %229
  %419 = load i32, ptr %28, align 4, !tbaa !9
  %420 = load ptr, ptr %12, align 8, !tbaa !5
  %421 = load i32, ptr %420, align 4, !tbaa !9
  %422 = icmp slt i32 %419, %421
  br i1 %422, label %423, label %607

423:                                              ; preds = %418
  %424 = load ptr, ptr %12, align 8, !tbaa !5
  %425 = load i32, ptr %424, align 4, !tbaa !9
  %426 = load i32, ptr %28, align 4, !tbaa !9
  %427 = sub nsw i32 %425, %426
  %428 = add nsw i32 %427, 1
  store i32 %428, ptr %23, align 4, !tbaa !9
  %429 = load ptr, ptr %18, align 8, !tbaa !5
  %430 = getelementptr inbounds i32, ptr %429, i64 1
  %431 = load ptr, ptr %19, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %431, i64 1
  call void @zlarnv_(ptr noundef @c__3, ptr noundef %430, ptr noundef %23, ptr noundef %432)
  %433 = load ptr, ptr %12, align 8, !tbaa !5
  %434 = load i32, ptr %433, align 4, !tbaa !9
  %435 = load i32, ptr %28, align 4, !tbaa !9
  %436 = sub nsw i32 %434, %435
  %437 = add nsw i32 %436, 1
  store i32 %437, ptr %23, align 4, !tbaa !9
  %438 = load ptr, ptr %19, align 8, !tbaa !5
  %439 = getelementptr inbounds %struct.doublecomplex, ptr %438, i64 1
  %440 = call double @dznrm2_(ptr noundef %23, ptr noundef %439, ptr noundef @c__1)
  store double %440, ptr %32, align 8, !tbaa !18
  %441 = load double, ptr %32, align 8, !tbaa !18
  %442 = load ptr, ptr %19, align 8, !tbaa !5
  %443 = getelementptr inbounds %struct.doublecomplex, ptr %442, i64 1
  %444 = call { double, double } @Cd(ptr noundef %443)
  %445 = extractvalue { double, double } %444, 0
  %446 = extractvalue { double, double } %444, 1
  %447 = getelementptr inbounds { double, double }, ptr %36, i32 0, i32 0
  %448 = getelementptr inbounds { double, double }, ptr %36, i32 0, i32 1
  store double %445, ptr %447, align 8
  store double %446, ptr %448, align 8
  %449 = getelementptr inbounds { double, double }, ptr %36, i32 0, i32 0
  %450 = load double, ptr %449, align 8
  %451 = getelementptr inbounds { double, double }, ptr %36, i32 0, i32 1
  %452 = load double, ptr %451, align 8
  %453 = call double @cabs(double noundef %450, double noundef %452) #5
  %454 = fdiv double %441, %453
  store double %454, ptr %26, align 8, !tbaa !18
  %455 = load double, ptr %26, align 8, !tbaa !18
  %456 = load ptr, ptr %19, align 8, !tbaa !5
  %457 = getelementptr inbounds %struct.doublecomplex, ptr %456, i64 1
  %458 = getelementptr inbounds %struct.doublecomplex, ptr %457, i32 0, i32 0
  %459 = load double, ptr %458, align 8, !tbaa !11
  %460 = fmul double %455, %459
  %461 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %460, ptr %461, align 8, !tbaa !11
  %462 = load double, ptr %26, align 8, !tbaa !18
  %463 = load ptr, ptr %19, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.doublecomplex, ptr %463, i64 1
  %465 = getelementptr inbounds %struct.doublecomplex, ptr %464, i32 0, i32 1
  %466 = load double, ptr %465, align 8, !tbaa !14
  %467 = fmul double %462, %466
  %468 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %467, ptr %468, align 8, !tbaa !14
  %469 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %470 = load double, ptr %469, align 8, !tbaa !11
  %471 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %470, ptr %471, align 8, !tbaa !11
  %472 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %473 = load double, ptr %472, align 8, !tbaa !14
  %474 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %473, ptr %474, align 8, !tbaa !14
  %475 = load double, ptr %32, align 8, !tbaa !18
  %476 = fcmp oeq double %475, 0.000000e+00
  br i1 %476, label %477, label %480

477:                                              ; preds = %423
  %478 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %478, align 8, !tbaa !11
  %479 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %479, align 8, !tbaa !14
  br label %544

480:                                              ; preds = %423
  %481 = load ptr, ptr %19, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.doublecomplex, ptr %481, i64 1
  %483 = getelementptr inbounds %struct.doublecomplex, ptr %482, i32 0, i32 0
  %484 = load double, ptr %483, align 8, !tbaa !11
  %485 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %486 = load double, ptr %485, align 8, !tbaa !11
  %487 = fadd double %484, %486
  %488 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %487, ptr %488, align 8, !tbaa !11
  %489 = load ptr, ptr %19, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %489, i64 1
  %491 = getelementptr inbounds %struct.doublecomplex, ptr %490, i32 0, i32 1
  %492 = load double, ptr %491, align 8, !tbaa !14
  %493 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %494 = load double, ptr %493, align 8, !tbaa !14
  %495 = fadd double %492, %494
  %496 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %495, ptr %496, align 8, !tbaa !14
  %497 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %498 = load double, ptr %497, align 8, !tbaa !11
  %499 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %498, ptr %499, align 8, !tbaa !11
  %500 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %501 = load double, ptr %500, align 8, !tbaa !14
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %501, ptr %502, align 8, !tbaa !14
  %503 = load ptr, ptr %12, align 8, !tbaa !5
  %504 = load i32, ptr %503, align 4, !tbaa !9
  %505 = load i32, ptr %28, align 4, !tbaa !9
  %506 = sub nsw i32 %504, %505
  store i32 %506, ptr %23, align 4, !tbaa !9
  %507 = call { double, double } @Cd(ptr noundef @c_b2)
  %508 = extractvalue { double, double } %507, 0
  %509 = extractvalue { double, double } %507, 1
  %510 = call { double, double } @Cd(ptr noundef %31)
  %511 = extractvalue { double, double } %510, 0
  %512 = extractvalue { double, double } %510, 1
  %513 = call { double, double } @__divdc3(double noundef %508, double noundef %509, double noundef %511, double noundef %512) #5
  %514 = extractvalue { double, double } %513, 0
  %515 = extractvalue { double, double } %513, 1
  %516 = call ptr @_pCd(ptr noundef %27)
  %517 = getelementptr inbounds { double, double }, ptr %516, i32 0, i32 0
  %518 = getelementptr inbounds { double, double }, ptr %516, i32 0, i32 1
  store double %514, ptr %517, align 8
  store double %515, ptr %518, align 8
  %519 = load ptr, ptr %19, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.doublecomplex, ptr %519, i64 2
  call void @zscal_(ptr noundef %23, ptr noundef %27, ptr noundef %520, ptr noundef @c__1)
  %521 = load ptr, ptr %19, align 8, !tbaa !5
  %522 = getelementptr inbounds %struct.doublecomplex, ptr %521, i64 1
  %523 = getelementptr inbounds %struct.doublecomplex, ptr %522, i32 0, i32 0
  store double 1.000000e+00, ptr %523, align 8, !tbaa !11
  %524 = load ptr, ptr %19, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.doublecomplex, ptr %524, i64 1
  %526 = getelementptr inbounds %struct.doublecomplex, ptr %525, i32 0, i32 1
  store double 0.000000e+00, ptr %526, align 8, !tbaa !14
  %527 = call { double, double } @Cd(ptr noundef %31)
  %528 = extractvalue { double, double } %527, 0
  %529 = extractvalue { double, double } %527, 1
  %530 = call { double, double } @Cd(ptr noundef %30)
  %531 = extractvalue { double, double } %530, 0
  %532 = extractvalue { double, double } %530, 1
  %533 = call { double, double } @__divdc3(double noundef %528, double noundef %529, double noundef %531, double noundef %532) #5
  %534 = extractvalue { double, double } %533, 0
  %535 = extractvalue { double, double } %533, 1
  %536 = call ptr @_pCd(ptr noundef %27)
  %537 = getelementptr inbounds { double, double }, ptr %536, i32 0, i32 0
  %538 = getelementptr inbounds { double, double }, ptr %536, i32 0, i32 1
  store double %534, ptr %537, align 8
  store double %535, ptr %538, align 8
  %539 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %540 = load double, ptr %539, align 8, !tbaa !11
  store double %540, ptr %26, align 8, !tbaa !18
  %541 = load double, ptr %26, align 8, !tbaa !18
  %542 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %541, ptr %542, align 8, !tbaa !11
  %543 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %543, align 8, !tbaa !14
  br label %544

544:                                              ; preds = %480, %477
  %545 = load ptr, ptr %11, align 8, !tbaa !5
  %546 = load i32, ptr %545, align 4, !tbaa !9
  %547 = load i32, ptr %28, align 4, !tbaa !9
  %548 = sub nsw i32 %546, %547
  %549 = add nsw i32 %548, 1
  store i32 %549, ptr %23, align 4, !tbaa !9
  %550 = load ptr, ptr %12, align 8, !tbaa !5
  %551 = load i32, ptr %550, align 4, !tbaa !9
  %552 = load i32, ptr %28, align 4, !tbaa !9
  %553 = sub nsw i32 %551, %552
  %554 = add nsw i32 %553, 1
  store i32 %554, ptr %24, align 4, !tbaa !9
  %555 = load ptr, ptr %16, align 8, !tbaa !5
  %556 = load i32, ptr %28, align 4, !tbaa !9
  %557 = load i32, ptr %28, align 4, !tbaa !9
  %558 = load i32, ptr %21, align 4, !tbaa !9
  %559 = mul nsw i32 %557, %558
  %560 = add nsw i32 %556, %559
  %561 = sext i32 %560 to i64
  %562 = getelementptr inbounds %struct.doublecomplex, ptr %555, i64 %561
  %563 = load ptr, ptr %17, align 8, !tbaa !5
  %564 = load ptr, ptr %19, align 8, !tbaa !5
  %565 = getelementptr inbounds %struct.doublecomplex, ptr %564, i64 1
  %566 = load ptr, ptr %19, align 8, !tbaa !5
  %567 = load ptr, ptr %12, align 8, !tbaa !5
  %568 = load i32, ptr %567, align 4, !tbaa !9
  %569 = add nsw i32 %568, 1
  %570 = sext i32 %569 to i64
  %571 = getelementptr inbounds %struct.doublecomplex, ptr %566, i64 %570
  call void @zgemv_(ptr noundef @.str.2, ptr noundef %23, ptr noundef %24, ptr noundef @c_b2, ptr noundef %562, ptr noundef %563, ptr noundef %565, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %571, ptr noundef @c__1)
  %572 = load ptr, ptr %11, align 8, !tbaa !5
  %573 = load i32, ptr %572, align 4, !tbaa !9
  %574 = load i32, ptr %28, align 4, !tbaa !9
  %575 = sub nsw i32 %573, %574
  %576 = add nsw i32 %575, 1
  store i32 %576, ptr %23, align 4, !tbaa !9
  %577 = load ptr, ptr %12, align 8, !tbaa !5
  %578 = load i32, ptr %577, align 4, !tbaa !9
  %579 = load i32, ptr %28, align 4, !tbaa !9
  %580 = sub nsw i32 %578, %579
  %581 = add nsw i32 %580, 1
  store i32 %581, ptr %24, align 4, !tbaa !9
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %583 = load double, ptr %582, align 8, !tbaa !11
  %584 = fneg double %583
  %585 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %584, ptr %585, align 8, !tbaa !11
  %586 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %587 = load double, ptr %586, align 8, !tbaa !14
  %588 = fneg double %587
  %589 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %588, ptr %589, align 8, !tbaa !14
  %590 = load ptr, ptr %19, align 8, !tbaa !5
  %591 = load ptr, ptr %12, align 8, !tbaa !5
  %592 = load i32, ptr %591, align 4, !tbaa !9
  %593 = add nsw i32 %592, 1
  %594 = sext i32 %593 to i64
  %595 = getelementptr inbounds %struct.doublecomplex, ptr %590, i64 %594
  %596 = load ptr, ptr %19, align 8, !tbaa !5
  %597 = getelementptr inbounds %struct.doublecomplex, ptr %596, i64 1
  %598 = load ptr, ptr %16, align 8, !tbaa !5
  %599 = load i32, ptr %28, align 4, !tbaa !9
  %600 = load i32, ptr %28, align 4, !tbaa !9
  %601 = load i32, ptr %21, align 4, !tbaa !9
  %602 = mul nsw i32 %600, %601
  %603 = add nsw i32 %599, %602
  %604 = sext i32 %603 to i64
  %605 = getelementptr inbounds %struct.doublecomplex, ptr %598, i64 %604
  %606 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %23, ptr noundef %24, ptr noundef %27, ptr noundef %595, ptr noundef @c__1, ptr noundef %597, ptr noundef @c__1, ptr noundef %605, ptr noundef %606)
  br label %607

607:                                              ; preds = %544, %418
  br label %608

608:                                              ; preds = %607
  %609 = load i32, ptr %28, align 4, !tbaa !9
  %610 = add nsw i32 %609, -1
  store i32 %610, ptr %28, align 4, !tbaa !9
  br label %226, !llvm.loop !20

611:                                              ; preds = %226
  %612 = load ptr, ptr %11, align 8, !tbaa !5
  %613 = load i32, ptr %612, align 4, !tbaa !9
  %614 = sub nsw i32 %613, 1
  %615 = load ptr, ptr %13, align 8, !tbaa !5
  %616 = load i32, ptr %615, align 4, !tbaa !9
  %617 = sub nsw i32 %614, %616
  store i32 %617, ptr %24, align 4, !tbaa !9
  %618 = load ptr, ptr %12, align 8, !tbaa !5
  %619 = load i32, ptr %618, align 4, !tbaa !9
  %620 = sub nsw i32 %619, 1
  %621 = load ptr, ptr %14, align 8, !tbaa !5
  %622 = load i32, ptr %621, align 4, !tbaa !9
  %623 = sub nsw i32 %620, %622
  store i32 %623, ptr %25, align 4, !tbaa !9
  %624 = load i32, ptr %24, align 4, !tbaa !9
  %625 = load i32, ptr %25, align 4, !tbaa !9
  %626 = icmp sge i32 %624, %625
  br i1 %626, label %627, label %629

627:                                              ; preds = %611
  %628 = load i32, ptr %24, align 4, !tbaa !9
  br label %631

629:                                              ; preds = %611
  %630 = load i32, ptr %25, align 4, !tbaa !9
  br label %631

631:                                              ; preds = %629, %627
  %632 = phi i32 [ %628, %627 ], [ %630, %629 ]
  store i32 %632, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %28, align 4, !tbaa !9
  br label %633

633:                                              ; preds = %2036, %631
  %634 = load i32, ptr %28, align 4, !tbaa !9
  %635 = load i32, ptr %23, align 4, !tbaa !9
  %636 = icmp sle i32 %634, %635
  br i1 %636, label %637, label %2039

637:                                              ; preds = %633
  %638 = load ptr, ptr %13, align 8, !tbaa !5
  %639 = load i32, ptr %638, align 4, !tbaa !9
  %640 = load ptr, ptr %14, align 8, !tbaa !5
  %641 = load i32, ptr %640, align 4, !tbaa !9
  %642 = icmp sle i32 %639, %641
  br i1 %642, label %643, label %1302

643:                                              ; preds = %637
  %644 = load ptr, ptr %11, align 8, !tbaa !5
  %645 = load i32, ptr %644, align 4, !tbaa !9
  %646 = sub nsw i32 %645, 1
  %647 = load ptr, ptr %13, align 8, !tbaa !5
  %648 = load i32, ptr %647, align 4, !tbaa !9
  %649 = sub nsw i32 %646, %648
  store i32 %649, ptr %24, align 4, !tbaa !9
  %650 = load i32, ptr %28, align 4, !tbaa !9
  %651 = load i32, ptr %24, align 4, !tbaa !9
  %652 = load ptr, ptr %12, align 8, !tbaa !5
  %653 = load i32, ptr %652, align 4, !tbaa !9
  %654 = icmp sle i32 %651, %653
  br i1 %654, label %655, label %657

655:                                              ; preds = %643
  %656 = load i32, ptr %24, align 4, !tbaa !9
  br label %660

657:                                              ; preds = %643
  %658 = load ptr, ptr %12, align 8, !tbaa !5
  %659 = load i32, ptr %658, align 4, !tbaa !9
  br label %660

660:                                              ; preds = %657, %655
  %661 = phi i32 [ %656, %655 ], [ %659, %657 ]
  %662 = icmp sle i32 %650, %661
  br i1 %662, label %663, label %960

663:                                              ; preds = %660
  %664 = load ptr, ptr %11, align 8, !tbaa !5
  %665 = load i32, ptr %664, align 4, !tbaa !9
  %666 = load ptr, ptr %13, align 8, !tbaa !5
  %667 = load i32, ptr %666, align 4, !tbaa !9
  %668 = sub nsw i32 %665, %667
  %669 = load i32, ptr %28, align 4, !tbaa !9
  %670 = sub nsw i32 %668, %669
  %671 = add nsw i32 %670, 1
  store i32 %671, ptr %24, align 4, !tbaa !9
  %672 = load ptr, ptr %16, align 8, !tbaa !5
  %673 = load ptr, ptr %13, align 8, !tbaa !5
  %674 = load i32, ptr %673, align 4, !tbaa !9
  %675 = load i32, ptr %28, align 4, !tbaa !9
  %676 = add nsw i32 %674, %675
  %677 = load i32, ptr %28, align 4, !tbaa !9
  %678 = load i32, ptr %21, align 4, !tbaa !9
  %679 = mul nsw i32 %677, %678
  %680 = add nsw i32 %676, %679
  %681 = sext i32 %680 to i64
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %672, i64 %681
  %683 = call double @dznrm2_(ptr noundef %24, ptr noundef %682, ptr noundef @c__1)
  store double %683, ptr %32, align 8, !tbaa !18
  %684 = load double, ptr %32, align 8, !tbaa !18
  %685 = load ptr, ptr %16, align 8, !tbaa !5
  %686 = load ptr, ptr %13, align 8, !tbaa !5
  %687 = load i32, ptr %686, align 4, !tbaa !9
  %688 = load i32, ptr %28, align 4, !tbaa !9
  %689 = add nsw i32 %687, %688
  %690 = load i32, ptr %28, align 4, !tbaa !9
  %691 = load i32, ptr %21, align 4, !tbaa !9
  %692 = mul nsw i32 %690, %691
  %693 = add nsw i32 %689, %692
  %694 = sext i32 %693 to i64
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %685, i64 %694
  %696 = call { double, double } @Cd(ptr noundef %695)
  %697 = extractvalue { double, double } %696, 0
  %698 = extractvalue { double, double } %696, 1
  %699 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 0
  %700 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 1
  store double %697, ptr %699, align 8
  store double %698, ptr %700, align 8
  %701 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 0
  %702 = load double, ptr %701, align 8
  %703 = getelementptr inbounds { double, double }, ptr %37, i32 0, i32 1
  %704 = load double, ptr %703, align 8
  %705 = call double @cabs(double noundef %702, double noundef %704) #5
  %706 = fdiv double %684, %705
  store double %706, ptr %26, align 8, !tbaa !18
  %707 = load ptr, ptr %13, align 8, !tbaa !5
  %708 = load i32, ptr %707, align 4, !tbaa !9
  %709 = load i32, ptr %28, align 4, !tbaa !9
  %710 = add nsw i32 %708, %709
  %711 = load i32, ptr %28, align 4, !tbaa !9
  %712 = load i32, ptr %21, align 4, !tbaa !9
  %713 = mul nsw i32 %711, %712
  %714 = add nsw i32 %710, %713
  store i32 %714, ptr %24, align 4, !tbaa !9
  %715 = load double, ptr %26, align 8, !tbaa !18
  %716 = load ptr, ptr %16, align 8, !tbaa !5
  %717 = load i32, ptr %24, align 4, !tbaa !9
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds %struct.doublecomplex, ptr %716, i64 %718
  %720 = getelementptr inbounds %struct.doublecomplex, ptr %719, i32 0, i32 0
  %721 = load double, ptr %720, align 8, !tbaa !11
  %722 = fmul double %715, %721
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %722, ptr %723, align 8, !tbaa !11
  %724 = load double, ptr %26, align 8, !tbaa !18
  %725 = load ptr, ptr %16, align 8, !tbaa !5
  %726 = load i32, ptr %24, align 4, !tbaa !9
  %727 = sext i32 %726 to i64
  %728 = getelementptr inbounds %struct.doublecomplex, ptr %725, i64 %727
  %729 = getelementptr inbounds %struct.doublecomplex, ptr %728, i32 0, i32 1
  %730 = load double, ptr %729, align 8, !tbaa !14
  %731 = fmul double %724, %730
  %732 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %731, ptr %732, align 8, !tbaa !14
  %733 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %734 = load double, ptr %733, align 8, !tbaa !11
  %735 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %734, ptr %735, align 8, !tbaa !11
  %736 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %737 = load double, ptr %736, align 8, !tbaa !14
  %738 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %737, ptr %738, align 8, !tbaa !14
  %739 = load double, ptr %32, align 8, !tbaa !18
  %740 = fcmp oeq double %739, 0.000000e+00
  br i1 %740, label %741, label %744

741:                                              ; preds = %663
  %742 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %742, align 8, !tbaa !11
  %743 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %743, align 8, !tbaa !14
  br label %845

744:                                              ; preds = %663
  %745 = load ptr, ptr %13, align 8, !tbaa !5
  %746 = load i32, ptr %745, align 4, !tbaa !9
  %747 = load i32, ptr %28, align 4, !tbaa !9
  %748 = add nsw i32 %746, %747
  %749 = load i32, ptr %28, align 4, !tbaa !9
  %750 = load i32, ptr %21, align 4, !tbaa !9
  %751 = mul nsw i32 %749, %750
  %752 = add nsw i32 %748, %751
  store i32 %752, ptr %24, align 4, !tbaa !9
  %753 = load ptr, ptr %16, align 8, !tbaa !5
  %754 = load i32, ptr %24, align 4, !tbaa !9
  %755 = sext i32 %754 to i64
  %756 = getelementptr inbounds %struct.doublecomplex, ptr %753, i64 %755
  %757 = getelementptr inbounds %struct.doublecomplex, ptr %756, i32 0, i32 0
  %758 = load double, ptr %757, align 8, !tbaa !11
  %759 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %760 = load double, ptr %759, align 8, !tbaa !11
  %761 = fadd double %758, %760
  %762 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %761, ptr %762, align 8, !tbaa !11
  %763 = load ptr, ptr %16, align 8, !tbaa !5
  %764 = load i32, ptr %24, align 4, !tbaa !9
  %765 = sext i32 %764 to i64
  %766 = getelementptr inbounds %struct.doublecomplex, ptr %763, i64 %765
  %767 = getelementptr inbounds %struct.doublecomplex, ptr %766, i32 0, i32 1
  %768 = load double, ptr %767, align 8, !tbaa !14
  %769 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %770 = load double, ptr %769, align 8, !tbaa !14
  %771 = fadd double %768, %770
  %772 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %771, ptr %772, align 8, !tbaa !14
  %773 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %774 = load double, ptr %773, align 8, !tbaa !11
  %775 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %774, ptr %775, align 8, !tbaa !11
  %776 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %777 = load double, ptr %776, align 8, !tbaa !14
  %778 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %777, ptr %778, align 8, !tbaa !14
  %779 = load ptr, ptr %11, align 8, !tbaa !5
  %780 = load i32, ptr %779, align 4, !tbaa !9
  %781 = load ptr, ptr %13, align 8, !tbaa !5
  %782 = load i32, ptr %781, align 4, !tbaa !9
  %783 = sub nsw i32 %780, %782
  %784 = load i32, ptr %28, align 4, !tbaa !9
  %785 = sub nsw i32 %783, %784
  store i32 %785, ptr %24, align 4, !tbaa !9
  %786 = call { double, double } @Cd(ptr noundef @c_b2)
  %787 = extractvalue { double, double } %786, 0
  %788 = extractvalue { double, double } %786, 1
  %789 = call { double, double } @Cd(ptr noundef %31)
  %790 = extractvalue { double, double } %789, 0
  %791 = extractvalue { double, double } %789, 1
  %792 = call { double, double } @__divdc3(double noundef %787, double noundef %788, double noundef %790, double noundef %791) #5
  %793 = extractvalue { double, double } %792, 0
  %794 = extractvalue { double, double } %792, 1
  %795 = call ptr @_pCd(ptr noundef %27)
  %796 = getelementptr inbounds { double, double }, ptr %795, i32 0, i32 0
  %797 = getelementptr inbounds { double, double }, ptr %795, i32 0, i32 1
  store double %793, ptr %796, align 8
  store double %794, ptr %797, align 8
  %798 = load ptr, ptr %16, align 8, !tbaa !5
  %799 = load ptr, ptr %13, align 8, !tbaa !5
  %800 = load i32, ptr %799, align 4, !tbaa !9
  %801 = load i32, ptr %28, align 4, !tbaa !9
  %802 = add nsw i32 %800, %801
  %803 = add nsw i32 %802, 1
  %804 = load i32, ptr %28, align 4, !tbaa !9
  %805 = load i32, ptr %21, align 4, !tbaa !9
  %806 = mul nsw i32 %804, %805
  %807 = add nsw i32 %803, %806
  %808 = sext i32 %807 to i64
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %798, i64 %808
  call void @zscal_(ptr noundef %24, ptr noundef %27, ptr noundef %809, ptr noundef @c__1)
  %810 = load ptr, ptr %13, align 8, !tbaa !5
  %811 = load i32, ptr %810, align 4, !tbaa !9
  %812 = load i32, ptr %28, align 4, !tbaa !9
  %813 = add nsw i32 %811, %812
  %814 = load i32, ptr %28, align 4, !tbaa !9
  %815 = load i32, ptr %21, align 4, !tbaa !9
  %816 = mul nsw i32 %814, %815
  %817 = add nsw i32 %813, %816
  store i32 %817, ptr %24, align 4, !tbaa !9
  %818 = load ptr, ptr %16, align 8, !tbaa !5
  %819 = load i32, ptr %24, align 4, !tbaa !9
  %820 = sext i32 %819 to i64
  %821 = getelementptr inbounds %struct.doublecomplex, ptr %818, i64 %820
  %822 = getelementptr inbounds %struct.doublecomplex, ptr %821, i32 0, i32 0
  store double 1.000000e+00, ptr %822, align 8, !tbaa !11
  %823 = load ptr, ptr %16, align 8, !tbaa !5
  %824 = load i32, ptr %24, align 4, !tbaa !9
  %825 = sext i32 %824 to i64
  %826 = getelementptr inbounds %struct.doublecomplex, ptr %823, i64 %825
  %827 = getelementptr inbounds %struct.doublecomplex, ptr %826, i32 0, i32 1
  store double 0.000000e+00, ptr %827, align 8, !tbaa !14
  %828 = call { double, double } @Cd(ptr noundef %31)
  %829 = extractvalue { double, double } %828, 0
  %830 = extractvalue { double, double } %828, 1
  %831 = call { double, double } @Cd(ptr noundef %30)
  %832 = extractvalue { double, double } %831, 0
  %833 = extractvalue { double, double } %831, 1
  %834 = call { double, double } @__divdc3(double noundef %829, double noundef %830, double noundef %832, double noundef %833) #5
  %835 = extractvalue { double, double } %834, 0
  %836 = extractvalue { double, double } %834, 1
  %837 = call ptr @_pCd(ptr noundef %27)
  %838 = getelementptr inbounds { double, double }, ptr %837, i32 0, i32 0
  %839 = getelementptr inbounds { double, double }, ptr %837, i32 0, i32 1
  store double %835, ptr %838, align 8
  store double %836, ptr %839, align 8
  %840 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %841 = load double, ptr %840, align 8, !tbaa !11
  store double %841, ptr %26, align 8, !tbaa !18
  %842 = load double, ptr %26, align 8, !tbaa !18
  %843 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %842, ptr %843, align 8, !tbaa !11
  %844 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %844, align 8, !tbaa !14
  br label %845

845:                                              ; preds = %744, %741
  %846 = load ptr, ptr %11, align 8, !tbaa !5
  %847 = load i32, ptr %846, align 4, !tbaa !9
  %848 = load ptr, ptr %13, align 8, !tbaa !5
  %849 = load i32, ptr %848, align 4, !tbaa !9
  %850 = sub nsw i32 %847, %849
  %851 = load i32, ptr %28, align 4, !tbaa !9
  %852 = sub nsw i32 %850, %851
  %853 = add nsw i32 %852, 1
  store i32 %853, ptr %24, align 4, !tbaa !9
  %854 = load ptr, ptr %12, align 8, !tbaa !5
  %855 = load i32, ptr %854, align 4, !tbaa !9
  %856 = load i32, ptr %28, align 4, !tbaa !9
  %857 = sub nsw i32 %855, %856
  store i32 %857, ptr %25, align 4, !tbaa !9
  %858 = load ptr, ptr %16, align 8, !tbaa !5
  %859 = load ptr, ptr %13, align 8, !tbaa !5
  %860 = load i32, ptr %859, align 4, !tbaa !9
  %861 = load i32, ptr %28, align 4, !tbaa !9
  %862 = add nsw i32 %860, %861
  %863 = load i32, ptr %28, align 4, !tbaa !9
  %864 = add nsw i32 %863, 1
  %865 = load i32, ptr %21, align 4, !tbaa !9
  %866 = mul nsw i32 %864, %865
  %867 = add nsw i32 %862, %866
  %868 = sext i32 %867 to i64
  %869 = getelementptr inbounds %struct.doublecomplex, ptr %858, i64 %868
  %870 = load ptr, ptr %17, align 8, !tbaa !5
  %871 = load ptr, ptr %16, align 8, !tbaa !5
  %872 = load ptr, ptr %13, align 8, !tbaa !5
  %873 = load i32, ptr %872, align 4, !tbaa !9
  %874 = load i32, ptr %28, align 4, !tbaa !9
  %875 = add nsw i32 %873, %874
  %876 = load i32, ptr %28, align 4, !tbaa !9
  %877 = load i32, ptr %21, align 4, !tbaa !9
  %878 = mul nsw i32 %876, %877
  %879 = add nsw i32 %875, %878
  %880 = sext i32 %879 to i64
  %881 = getelementptr inbounds %struct.doublecomplex, ptr %871, i64 %880
  %882 = load ptr, ptr %19, align 8, !tbaa !5
  %883 = getelementptr inbounds %struct.doublecomplex, ptr %882, i64 1
  call void @zgemv_(ptr noundef @.str.1, ptr noundef %24, ptr noundef %25, ptr noundef @c_b2, ptr noundef %869, ptr noundef %870, ptr noundef %881, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %883, ptr noundef @c__1)
  %884 = load ptr, ptr %11, align 8, !tbaa !5
  %885 = load i32, ptr %884, align 4, !tbaa !9
  %886 = load ptr, ptr %13, align 8, !tbaa !5
  %887 = load i32, ptr %886, align 4, !tbaa !9
  %888 = sub nsw i32 %885, %887
  %889 = load i32, ptr %28, align 4, !tbaa !9
  %890 = sub nsw i32 %888, %889
  %891 = add nsw i32 %890, 1
  store i32 %891, ptr %24, align 4, !tbaa !9
  %892 = load ptr, ptr %12, align 8, !tbaa !5
  %893 = load i32, ptr %892, align 4, !tbaa !9
  %894 = load i32, ptr %28, align 4, !tbaa !9
  %895 = sub nsw i32 %893, %894
  store i32 %895, ptr %25, align 4, !tbaa !9
  %896 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %897 = load double, ptr %896, align 8, !tbaa !11
  %898 = fneg double %897
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %898, ptr %899, align 8, !tbaa !11
  %900 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %901 = load double, ptr %900, align 8, !tbaa !14
  %902 = fneg double %901
  %903 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %902, ptr %903, align 8, !tbaa !14
  %904 = load ptr, ptr %16, align 8, !tbaa !5
  %905 = load ptr, ptr %13, align 8, !tbaa !5
  %906 = load i32, ptr %905, align 4, !tbaa !9
  %907 = load i32, ptr %28, align 4, !tbaa !9
  %908 = add nsw i32 %906, %907
  %909 = load i32, ptr %28, align 4, !tbaa !9
  %910 = load i32, ptr %21, align 4, !tbaa !9
  %911 = mul nsw i32 %909, %910
  %912 = add nsw i32 %908, %911
  %913 = sext i32 %912 to i64
  %914 = getelementptr inbounds %struct.doublecomplex, ptr %904, i64 %913
  %915 = load ptr, ptr %19, align 8, !tbaa !5
  %916 = getelementptr inbounds %struct.doublecomplex, ptr %915, i64 1
  %917 = load ptr, ptr %16, align 8, !tbaa !5
  %918 = load ptr, ptr %13, align 8, !tbaa !5
  %919 = load i32, ptr %918, align 4, !tbaa !9
  %920 = load i32, ptr %28, align 4, !tbaa !9
  %921 = add nsw i32 %919, %920
  %922 = load i32, ptr %28, align 4, !tbaa !9
  %923 = add nsw i32 %922, 1
  %924 = load i32, ptr %21, align 4, !tbaa !9
  %925 = mul nsw i32 %923, %924
  %926 = add nsw i32 %921, %925
  %927 = sext i32 %926 to i64
  %928 = getelementptr inbounds %struct.doublecomplex, ptr %917, i64 %927
  %929 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %24, ptr noundef %25, ptr noundef %27, ptr noundef %914, ptr noundef @c__1, ptr noundef %916, ptr noundef @c__1, ptr noundef %928, ptr noundef %929)
  %930 = load ptr, ptr %13, align 8, !tbaa !5
  %931 = load i32, ptr %930, align 4, !tbaa !9
  %932 = load i32, ptr %28, align 4, !tbaa !9
  %933 = add nsw i32 %931, %932
  %934 = load i32, ptr %28, align 4, !tbaa !9
  %935 = load i32, ptr %21, align 4, !tbaa !9
  %936 = mul nsw i32 %934, %935
  %937 = add nsw i32 %933, %936
  store i32 %937, ptr %24, align 4, !tbaa !9
  %938 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %939 = load double, ptr %938, align 8, !tbaa !11
  %940 = fneg double %939
  %941 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %940, ptr %941, align 8, !tbaa !11
  %942 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %943 = load double, ptr %942, align 8, !tbaa !14
  %944 = fneg double %943
  %945 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %944, ptr %945, align 8, !tbaa !14
  %946 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %947 = load double, ptr %946, align 8, !tbaa !11
  %948 = load ptr, ptr %16, align 8, !tbaa !5
  %949 = load i32, ptr %24, align 4, !tbaa !9
  %950 = sext i32 %949 to i64
  %951 = getelementptr inbounds %struct.doublecomplex, ptr %948, i64 %950
  %952 = getelementptr inbounds %struct.doublecomplex, ptr %951, i32 0, i32 0
  store double %947, ptr %952, align 8, !tbaa !11
  %953 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %954 = load double, ptr %953, align 8, !tbaa !14
  %955 = load ptr, ptr %16, align 8, !tbaa !5
  %956 = load i32, ptr %24, align 4, !tbaa !9
  %957 = sext i32 %956 to i64
  %958 = getelementptr inbounds %struct.doublecomplex, ptr %955, i64 %957
  %959 = getelementptr inbounds %struct.doublecomplex, ptr %958, i32 0, i32 1
  store double %954, ptr %959, align 8, !tbaa !14
  br label %960

960:                                              ; preds = %845, %660
  %961 = load ptr, ptr %12, align 8, !tbaa !5
  %962 = load i32, ptr %961, align 4, !tbaa !9
  %963 = sub nsw i32 %962, 1
  %964 = load ptr, ptr %14, align 8, !tbaa !5
  %965 = load i32, ptr %964, align 4, !tbaa !9
  %966 = sub nsw i32 %963, %965
  store i32 %966, ptr %24, align 4, !tbaa !9
  %967 = load i32, ptr %28, align 4, !tbaa !9
  %968 = load i32, ptr %24, align 4, !tbaa !9
  %969 = load ptr, ptr %11, align 8, !tbaa !5
  %970 = load i32, ptr %969, align 4, !tbaa !9
  %971 = icmp sle i32 %968, %970
  br i1 %971, label %972, label %974

972:                                              ; preds = %960
  %973 = load i32, ptr %24, align 4, !tbaa !9
  br label %977

974:                                              ; preds = %960
  %975 = load ptr, ptr %11, align 8, !tbaa !5
  %976 = load i32, ptr %975, align 4, !tbaa !9
  br label %977

977:                                              ; preds = %974, %972
  %978 = phi i32 [ %973, %972 ], [ %976, %974 ]
  %979 = icmp sle i32 %967, %978
  br i1 %979, label %980, label %1301

980:                                              ; preds = %977
  %981 = load ptr, ptr %12, align 8, !tbaa !5
  %982 = load i32, ptr %981, align 4, !tbaa !9
  %983 = load ptr, ptr %14, align 8, !tbaa !5
  %984 = load i32, ptr %983, align 4, !tbaa !9
  %985 = sub nsw i32 %982, %984
  %986 = load i32, ptr %28, align 4, !tbaa !9
  %987 = sub nsw i32 %985, %986
  %988 = add nsw i32 %987, 1
  store i32 %988, ptr %24, align 4, !tbaa !9
  %989 = load ptr, ptr %16, align 8, !tbaa !5
  %990 = load i32, ptr %28, align 4, !tbaa !9
  %991 = load ptr, ptr %14, align 8, !tbaa !5
  %992 = load i32, ptr %991, align 4, !tbaa !9
  %993 = load i32, ptr %28, align 4, !tbaa !9
  %994 = add nsw i32 %992, %993
  %995 = load i32, ptr %21, align 4, !tbaa !9
  %996 = mul nsw i32 %994, %995
  %997 = add nsw i32 %990, %996
  %998 = sext i32 %997 to i64
  %999 = getelementptr inbounds %struct.doublecomplex, ptr %989, i64 %998
  %1000 = load ptr, ptr %17, align 8, !tbaa !5
  %1001 = call double @dznrm2_(ptr noundef %24, ptr noundef %999, ptr noundef %1000)
  store double %1001, ptr %32, align 8, !tbaa !18
  %1002 = load double, ptr %32, align 8, !tbaa !18
  %1003 = load ptr, ptr %16, align 8, !tbaa !5
  %1004 = load i32, ptr %28, align 4, !tbaa !9
  %1005 = load ptr, ptr %14, align 8, !tbaa !5
  %1006 = load i32, ptr %1005, align 4, !tbaa !9
  %1007 = load i32, ptr %28, align 4, !tbaa !9
  %1008 = add nsw i32 %1006, %1007
  %1009 = load i32, ptr %21, align 4, !tbaa !9
  %1010 = mul nsw i32 %1008, %1009
  %1011 = add nsw i32 %1004, %1010
  %1012 = sext i32 %1011 to i64
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %1003, i64 %1012
  %1014 = call { double, double } @Cd(ptr noundef %1013)
  %1015 = extractvalue { double, double } %1014, 0
  %1016 = extractvalue { double, double } %1014, 1
  %1017 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 0
  %1018 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 1
  store double %1015, ptr %1017, align 8
  store double %1016, ptr %1018, align 8
  %1019 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 0
  %1020 = load double, ptr %1019, align 8
  %1021 = getelementptr inbounds { double, double }, ptr %38, i32 0, i32 1
  %1022 = load double, ptr %1021, align 8
  %1023 = call double @cabs(double noundef %1020, double noundef %1022) #5
  %1024 = fdiv double %1002, %1023
  store double %1024, ptr %26, align 8, !tbaa !18
  %1025 = load i32, ptr %28, align 4, !tbaa !9
  %1026 = load ptr, ptr %14, align 8, !tbaa !5
  %1027 = load i32, ptr %1026, align 4, !tbaa !9
  %1028 = load i32, ptr %28, align 4, !tbaa !9
  %1029 = add nsw i32 %1027, %1028
  %1030 = load i32, ptr %21, align 4, !tbaa !9
  %1031 = mul nsw i32 %1029, %1030
  %1032 = add nsw i32 %1025, %1031
  store i32 %1032, ptr %24, align 4, !tbaa !9
  %1033 = load double, ptr %26, align 8, !tbaa !18
  %1034 = load ptr, ptr %16, align 8, !tbaa !5
  %1035 = load i32, ptr %24, align 4, !tbaa !9
  %1036 = sext i32 %1035 to i64
  %1037 = getelementptr inbounds %struct.doublecomplex, ptr %1034, i64 %1036
  %1038 = getelementptr inbounds %struct.doublecomplex, ptr %1037, i32 0, i32 0
  %1039 = load double, ptr %1038, align 8, !tbaa !11
  %1040 = fmul double %1033, %1039
  %1041 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1040, ptr %1041, align 8, !tbaa !11
  %1042 = load double, ptr %26, align 8, !tbaa !18
  %1043 = load ptr, ptr %16, align 8, !tbaa !5
  %1044 = load i32, ptr %24, align 4, !tbaa !9
  %1045 = sext i32 %1044 to i64
  %1046 = getelementptr inbounds %struct.doublecomplex, ptr %1043, i64 %1045
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %1046, i32 0, i32 1
  %1048 = load double, ptr %1047, align 8, !tbaa !14
  %1049 = fmul double %1042, %1048
  %1050 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1049, ptr %1050, align 8, !tbaa !14
  %1051 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1052 = load double, ptr %1051, align 8, !tbaa !11
  %1053 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %1052, ptr %1053, align 8, !tbaa !11
  %1054 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1055 = load double, ptr %1054, align 8, !tbaa !14
  %1056 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1055, ptr %1056, align 8, !tbaa !14
  %1057 = load double, ptr %32, align 8, !tbaa !18
  %1058 = fcmp oeq double %1057, 0.000000e+00
  br i1 %1058, label %1059, label %1062

1059:                                             ; preds = %980
  %1060 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %1060, align 8, !tbaa !11
  %1061 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1061, align 8, !tbaa !14
  br label %1164

1062:                                             ; preds = %980
  %1063 = load i32, ptr %28, align 4, !tbaa !9
  %1064 = load ptr, ptr %14, align 8, !tbaa !5
  %1065 = load i32, ptr %1064, align 4, !tbaa !9
  %1066 = load i32, ptr %28, align 4, !tbaa !9
  %1067 = add nsw i32 %1065, %1066
  %1068 = load i32, ptr %21, align 4, !tbaa !9
  %1069 = mul nsw i32 %1067, %1068
  %1070 = add nsw i32 %1063, %1069
  store i32 %1070, ptr %24, align 4, !tbaa !9
  %1071 = load ptr, ptr %16, align 8, !tbaa !5
  %1072 = load i32, ptr %24, align 4, !tbaa !9
  %1073 = sext i32 %1072 to i64
  %1074 = getelementptr inbounds %struct.doublecomplex, ptr %1071, i64 %1073
  %1075 = getelementptr inbounds %struct.doublecomplex, ptr %1074, i32 0, i32 0
  %1076 = load double, ptr %1075, align 8, !tbaa !11
  %1077 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1078 = load double, ptr %1077, align 8, !tbaa !11
  %1079 = fadd double %1076, %1078
  %1080 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1079, ptr %1080, align 8, !tbaa !11
  %1081 = load ptr, ptr %16, align 8, !tbaa !5
  %1082 = load i32, ptr %24, align 4, !tbaa !9
  %1083 = sext i32 %1082 to i64
  %1084 = getelementptr inbounds %struct.doublecomplex, ptr %1081, i64 %1083
  %1085 = getelementptr inbounds %struct.doublecomplex, ptr %1084, i32 0, i32 1
  %1086 = load double, ptr %1085, align 8, !tbaa !14
  %1087 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1088 = load double, ptr %1087, align 8, !tbaa !14
  %1089 = fadd double %1086, %1088
  %1090 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1089, ptr %1090, align 8, !tbaa !14
  %1091 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1092 = load double, ptr %1091, align 8, !tbaa !11
  %1093 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1092, ptr %1093, align 8, !tbaa !11
  %1094 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1095 = load double, ptr %1094, align 8, !tbaa !14
  %1096 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1095, ptr %1096, align 8, !tbaa !14
  %1097 = load ptr, ptr %12, align 8, !tbaa !5
  %1098 = load i32, ptr %1097, align 4, !tbaa !9
  %1099 = load ptr, ptr %14, align 8, !tbaa !5
  %1100 = load i32, ptr %1099, align 4, !tbaa !9
  %1101 = sub nsw i32 %1098, %1100
  %1102 = load i32, ptr %28, align 4, !tbaa !9
  %1103 = sub nsw i32 %1101, %1102
  store i32 %1103, ptr %24, align 4, !tbaa !9
  %1104 = call { double, double } @Cd(ptr noundef @c_b2)
  %1105 = extractvalue { double, double } %1104, 0
  %1106 = extractvalue { double, double } %1104, 1
  %1107 = call { double, double } @Cd(ptr noundef %31)
  %1108 = extractvalue { double, double } %1107, 0
  %1109 = extractvalue { double, double } %1107, 1
  %1110 = call { double, double } @__divdc3(double noundef %1105, double noundef %1106, double noundef %1108, double noundef %1109) #5
  %1111 = extractvalue { double, double } %1110, 0
  %1112 = extractvalue { double, double } %1110, 1
  %1113 = call ptr @_pCd(ptr noundef %27)
  %1114 = getelementptr inbounds { double, double }, ptr %1113, i32 0, i32 0
  %1115 = getelementptr inbounds { double, double }, ptr %1113, i32 0, i32 1
  store double %1111, ptr %1114, align 8
  store double %1112, ptr %1115, align 8
  %1116 = load ptr, ptr %16, align 8, !tbaa !5
  %1117 = load i32, ptr %28, align 4, !tbaa !9
  %1118 = load ptr, ptr %14, align 8, !tbaa !5
  %1119 = load i32, ptr %1118, align 4, !tbaa !9
  %1120 = load i32, ptr %28, align 4, !tbaa !9
  %1121 = add nsw i32 %1119, %1120
  %1122 = add nsw i32 %1121, 1
  %1123 = load i32, ptr %21, align 4, !tbaa !9
  %1124 = mul nsw i32 %1122, %1123
  %1125 = add nsw i32 %1117, %1124
  %1126 = sext i32 %1125 to i64
  %1127 = getelementptr inbounds %struct.doublecomplex, ptr %1116, i64 %1126
  %1128 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zscal_(ptr noundef %24, ptr noundef %27, ptr noundef %1127, ptr noundef %1128)
  %1129 = load i32, ptr %28, align 4, !tbaa !9
  %1130 = load ptr, ptr %14, align 8, !tbaa !5
  %1131 = load i32, ptr %1130, align 4, !tbaa !9
  %1132 = load i32, ptr %28, align 4, !tbaa !9
  %1133 = add nsw i32 %1131, %1132
  %1134 = load i32, ptr %21, align 4, !tbaa !9
  %1135 = mul nsw i32 %1133, %1134
  %1136 = add nsw i32 %1129, %1135
  store i32 %1136, ptr %24, align 4, !tbaa !9
  %1137 = load ptr, ptr %16, align 8, !tbaa !5
  %1138 = load i32, ptr %24, align 4, !tbaa !9
  %1139 = sext i32 %1138 to i64
  %1140 = getelementptr inbounds %struct.doublecomplex, ptr %1137, i64 %1139
  %1141 = getelementptr inbounds %struct.doublecomplex, ptr %1140, i32 0, i32 0
  store double 1.000000e+00, ptr %1141, align 8, !tbaa !11
  %1142 = load ptr, ptr %16, align 8, !tbaa !5
  %1143 = load i32, ptr %24, align 4, !tbaa !9
  %1144 = sext i32 %1143 to i64
  %1145 = getelementptr inbounds %struct.doublecomplex, ptr %1142, i64 %1144
  %1146 = getelementptr inbounds %struct.doublecomplex, ptr %1145, i32 0, i32 1
  store double 0.000000e+00, ptr %1146, align 8, !tbaa !14
  %1147 = call { double, double } @Cd(ptr noundef %31)
  %1148 = extractvalue { double, double } %1147, 0
  %1149 = extractvalue { double, double } %1147, 1
  %1150 = call { double, double } @Cd(ptr noundef %30)
  %1151 = extractvalue { double, double } %1150, 0
  %1152 = extractvalue { double, double } %1150, 1
  %1153 = call { double, double } @__divdc3(double noundef %1148, double noundef %1149, double noundef %1151, double noundef %1152) #5
  %1154 = extractvalue { double, double } %1153, 0
  %1155 = extractvalue { double, double } %1153, 1
  %1156 = call ptr @_pCd(ptr noundef %27)
  %1157 = getelementptr inbounds { double, double }, ptr %1156, i32 0, i32 0
  %1158 = getelementptr inbounds { double, double }, ptr %1156, i32 0, i32 1
  store double %1154, ptr %1157, align 8
  store double %1155, ptr %1158, align 8
  %1159 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1160 = load double, ptr %1159, align 8, !tbaa !11
  store double %1160, ptr %26, align 8, !tbaa !18
  %1161 = load double, ptr %26, align 8, !tbaa !18
  %1162 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1161, ptr %1162, align 8, !tbaa !11
  %1163 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1163, align 8, !tbaa !14
  br label %1164

1164:                                             ; preds = %1062, %1059
  %1165 = load ptr, ptr %12, align 8, !tbaa !5
  %1166 = load i32, ptr %1165, align 4, !tbaa !9
  %1167 = load ptr, ptr %14, align 8, !tbaa !5
  %1168 = load i32, ptr %1167, align 4, !tbaa !9
  %1169 = sub nsw i32 %1166, %1168
  %1170 = load i32, ptr %28, align 4, !tbaa !9
  %1171 = sub nsw i32 %1169, %1170
  %1172 = add nsw i32 %1171, 1
  store i32 %1172, ptr %24, align 4, !tbaa !9
  %1173 = load ptr, ptr %16, align 8, !tbaa !5
  %1174 = load i32, ptr %28, align 4, !tbaa !9
  %1175 = load ptr, ptr %14, align 8, !tbaa !5
  %1176 = load i32, ptr %1175, align 4, !tbaa !9
  %1177 = load i32, ptr %28, align 4, !tbaa !9
  %1178 = add nsw i32 %1176, %1177
  %1179 = load i32, ptr %21, align 4, !tbaa !9
  %1180 = mul nsw i32 %1178, %1179
  %1181 = add nsw i32 %1174, %1180
  %1182 = sext i32 %1181 to i64
  %1183 = getelementptr inbounds %struct.doublecomplex, ptr %1173, i64 %1182
  %1184 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zlacgv_(ptr noundef %24, ptr noundef %1183, ptr noundef %1184)
  %1185 = load ptr, ptr %11, align 8, !tbaa !5
  %1186 = load i32, ptr %1185, align 4, !tbaa !9
  %1187 = load i32, ptr %28, align 4, !tbaa !9
  %1188 = sub nsw i32 %1186, %1187
  store i32 %1188, ptr %24, align 4, !tbaa !9
  %1189 = load ptr, ptr %12, align 8, !tbaa !5
  %1190 = load i32, ptr %1189, align 4, !tbaa !9
  %1191 = load ptr, ptr %14, align 8, !tbaa !5
  %1192 = load i32, ptr %1191, align 4, !tbaa !9
  %1193 = sub nsw i32 %1190, %1192
  %1194 = load i32, ptr %28, align 4, !tbaa !9
  %1195 = sub nsw i32 %1193, %1194
  %1196 = add nsw i32 %1195, 1
  store i32 %1196, ptr %25, align 4, !tbaa !9
  %1197 = load ptr, ptr %16, align 8, !tbaa !5
  %1198 = load i32, ptr %28, align 4, !tbaa !9
  %1199 = add nsw i32 %1198, 1
  %1200 = load ptr, ptr %14, align 8, !tbaa !5
  %1201 = load i32, ptr %1200, align 4, !tbaa !9
  %1202 = load i32, ptr %28, align 4, !tbaa !9
  %1203 = add nsw i32 %1201, %1202
  %1204 = load i32, ptr %21, align 4, !tbaa !9
  %1205 = mul nsw i32 %1203, %1204
  %1206 = add nsw i32 %1199, %1205
  %1207 = sext i32 %1206 to i64
  %1208 = getelementptr inbounds %struct.doublecomplex, ptr %1197, i64 %1207
  %1209 = load ptr, ptr %17, align 8, !tbaa !5
  %1210 = load ptr, ptr %16, align 8, !tbaa !5
  %1211 = load i32, ptr %28, align 4, !tbaa !9
  %1212 = load ptr, ptr %14, align 8, !tbaa !5
  %1213 = load i32, ptr %1212, align 4, !tbaa !9
  %1214 = load i32, ptr %28, align 4, !tbaa !9
  %1215 = add nsw i32 %1213, %1214
  %1216 = load i32, ptr %21, align 4, !tbaa !9
  %1217 = mul nsw i32 %1215, %1216
  %1218 = add nsw i32 %1211, %1217
  %1219 = sext i32 %1218 to i64
  %1220 = getelementptr inbounds %struct.doublecomplex, ptr %1210, i64 %1219
  %1221 = load ptr, ptr %17, align 8, !tbaa !5
  %1222 = load ptr, ptr %19, align 8, !tbaa !5
  %1223 = getelementptr inbounds %struct.doublecomplex, ptr %1222, i64 1
  call void @zgemv_(ptr noundef @.str.2, ptr noundef %24, ptr noundef %25, ptr noundef @c_b2, ptr noundef %1208, ptr noundef %1209, ptr noundef %1220, ptr noundef %1221, ptr noundef @c_b1, ptr noundef %1223, ptr noundef @c__1)
  %1224 = load ptr, ptr %11, align 8, !tbaa !5
  %1225 = load i32, ptr %1224, align 4, !tbaa !9
  %1226 = load i32, ptr %28, align 4, !tbaa !9
  %1227 = sub nsw i32 %1225, %1226
  store i32 %1227, ptr %24, align 4, !tbaa !9
  %1228 = load ptr, ptr %12, align 8, !tbaa !5
  %1229 = load i32, ptr %1228, align 4, !tbaa !9
  %1230 = load ptr, ptr %14, align 8, !tbaa !5
  %1231 = load i32, ptr %1230, align 4, !tbaa !9
  %1232 = sub nsw i32 %1229, %1231
  %1233 = load i32, ptr %28, align 4, !tbaa !9
  %1234 = sub nsw i32 %1232, %1233
  %1235 = add nsw i32 %1234, 1
  store i32 %1235, ptr %25, align 4, !tbaa !9
  %1236 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1237 = load double, ptr %1236, align 8, !tbaa !11
  %1238 = fneg double %1237
  %1239 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1238, ptr %1239, align 8, !tbaa !11
  %1240 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1241 = load double, ptr %1240, align 8, !tbaa !14
  %1242 = fneg double %1241
  %1243 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1242, ptr %1243, align 8, !tbaa !14
  %1244 = load ptr, ptr %19, align 8, !tbaa !5
  %1245 = getelementptr inbounds %struct.doublecomplex, ptr %1244, i64 1
  %1246 = load ptr, ptr %16, align 8, !tbaa !5
  %1247 = load i32, ptr %28, align 4, !tbaa !9
  %1248 = load ptr, ptr %14, align 8, !tbaa !5
  %1249 = load i32, ptr %1248, align 4, !tbaa !9
  %1250 = load i32, ptr %28, align 4, !tbaa !9
  %1251 = add nsw i32 %1249, %1250
  %1252 = load i32, ptr %21, align 4, !tbaa !9
  %1253 = mul nsw i32 %1251, %1252
  %1254 = add nsw i32 %1247, %1253
  %1255 = sext i32 %1254 to i64
  %1256 = getelementptr inbounds %struct.doublecomplex, ptr %1246, i64 %1255
  %1257 = load ptr, ptr %17, align 8, !tbaa !5
  %1258 = load ptr, ptr %16, align 8, !tbaa !5
  %1259 = load i32, ptr %28, align 4, !tbaa !9
  %1260 = add nsw i32 %1259, 1
  %1261 = load ptr, ptr %14, align 8, !tbaa !5
  %1262 = load i32, ptr %1261, align 4, !tbaa !9
  %1263 = load i32, ptr %28, align 4, !tbaa !9
  %1264 = add nsw i32 %1262, %1263
  %1265 = load i32, ptr %21, align 4, !tbaa !9
  %1266 = mul nsw i32 %1264, %1265
  %1267 = add nsw i32 %1260, %1266
  %1268 = sext i32 %1267 to i64
  %1269 = getelementptr inbounds %struct.doublecomplex, ptr %1258, i64 %1268
  %1270 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %24, ptr noundef %25, ptr noundef %27, ptr noundef %1245, ptr noundef @c__1, ptr noundef %1256, ptr noundef %1257, ptr noundef %1269, ptr noundef %1270)
  %1271 = load i32, ptr %28, align 4, !tbaa !9
  %1272 = load ptr, ptr %14, align 8, !tbaa !5
  %1273 = load i32, ptr %1272, align 4, !tbaa !9
  %1274 = load i32, ptr %28, align 4, !tbaa !9
  %1275 = add nsw i32 %1273, %1274
  %1276 = load i32, ptr %21, align 4, !tbaa !9
  %1277 = mul nsw i32 %1275, %1276
  %1278 = add nsw i32 %1271, %1277
  store i32 %1278, ptr %24, align 4, !tbaa !9
  %1279 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1280 = load double, ptr %1279, align 8, !tbaa !11
  %1281 = fneg double %1280
  %1282 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1281, ptr %1282, align 8, !tbaa !11
  %1283 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1284 = load double, ptr %1283, align 8, !tbaa !14
  %1285 = fneg double %1284
  %1286 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1285, ptr %1286, align 8, !tbaa !14
  %1287 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1288 = load double, ptr %1287, align 8, !tbaa !11
  %1289 = load ptr, ptr %16, align 8, !tbaa !5
  %1290 = load i32, ptr %24, align 4, !tbaa !9
  %1291 = sext i32 %1290 to i64
  %1292 = getelementptr inbounds %struct.doublecomplex, ptr %1289, i64 %1291
  %1293 = getelementptr inbounds %struct.doublecomplex, ptr %1292, i32 0, i32 0
  store double %1288, ptr %1293, align 8, !tbaa !11
  %1294 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1295 = load double, ptr %1294, align 8, !tbaa !14
  %1296 = load ptr, ptr %16, align 8, !tbaa !5
  %1297 = load i32, ptr %24, align 4, !tbaa !9
  %1298 = sext i32 %1297 to i64
  %1299 = getelementptr inbounds %struct.doublecomplex, ptr %1296, i64 %1298
  %1300 = getelementptr inbounds %struct.doublecomplex, ptr %1299, i32 0, i32 1
  store double %1295, ptr %1300, align 8, !tbaa !14
  br label %1301

1301:                                             ; preds = %1164, %977
  br label %1961

1302:                                             ; preds = %637
  %1303 = load ptr, ptr %12, align 8, !tbaa !5
  %1304 = load i32, ptr %1303, align 4, !tbaa !9
  %1305 = sub nsw i32 %1304, 1
  %1306 = load ptr, ptr %14, align 8, !tbaa !5
  %1307 = load i32, ptr %1306, align 4, !tbaa !9
  %1308 = sub nsw i32 %1305, %1307
  store i32 %1308, ptr %24, align 4, !tbaa !9
  %1309 = load i32, ptr %28, align 4, !tbaa !9
  %1310 = load i32, ptr %24, align 4, !tbaa !9
  %1311 = load ptr, ptr %11, align 8, !tbaa !5
  %1312 = load i32, ptr %1311, align 4, !tbaa !9
  %1313 = icmp sle i32 %1310, %1312
  br i1 %1313, label %1314, label %1316

1314:                                             ; preds = %1302
  %1315 = load i32, ptr %24, align 4, !tbaa !9
  br label %1319

1316:                                             ; preds = %1302
  %1317 = load ptr, ptr %11, align 8, !tbaa !5
  %1318 = load i32, ptr %1317, align 4, !tbaa !9
  br label %1319

1319:                                             ; preds = %1316, %1314
  %1320 = phi i32 [ %1315, %1314 ], [ %1318, %1316 ]
  %1321 = icmp sle i32 %1309, %1320
  br i1 %1321, label %1322, label %1643

1322:                                             ; preds = %1319
  %1323 = load ptr, ptr %12, align 8, !tbaa !5
  %1324 = load i32, ptr %1323, align 4, !tbaa !9
  %1325 = load ptr, ptr %14, align 8, !tbaa !5
  %1326 = load i32, ptr %1325, align 4, !tbaa !9
  %1327 = sub nsw i32 %1324, %1326
  %1328 = load i32, ptr %28, align 4, !tbaa !9
  %1329 = sub nsw i32 %1327, %1328
  %1330 = add nsw i32 %1329, 1
  store i32 %1330, ptr %24, align 4, !tbaa !9
  %1331 = load ptr, ptr %16, align 8, !tbaa !5
  %1332 = load i32, ptr %28, align 4, !tbaa !9
  %1333 = load ptr, ptr %14, align 8, !tbaa !5
  %1334 = load i32, ptr %1333, align 4, !tbaa !9
  %1335 = load i32, ptr %28, align 4, !tbaa !9
  %1336 = add nsw i32 %1334, %1335
  %1337 = load i32, ptr %21, align 4, !tbaa !9
  %1338 = mul nsw i32 %1336, %1337
  %1339 = add nsw i32 %1332, %1338
  %1340 = sext i32 %1339 to i64
  %1341 = getelementptr inbounds %struct.doublecomplex, ptr %1331, i64 %1340
  %1342 = load ptr, ptr %17, align 8, !tbaa !5
  %1343 = call double @dznrm2_(ptr noundef %24, ptr noundef %1341, ptr noundef %1342)
  store double %1343, ptr %32, align 8, !tbaa !18
  %1344 = load double, ptr %32, align 8, !tbaa !18
  %1345 = load ptr, ptr %16, align 8, !tbaa !5
  %1346 = load i32, ptr %28, align 4, !tbaa !9
  %1347 = load ptr, ptr %14, align 8, !tbaa !5
  %1348 = load i32, ptr %1347, align 4, !tbaa !9
  %1349 = load i32, ptr %28, align 4, !tbaa !9
  %1350 = add nsw i32 %1348, %1349
  %1351 = load i32, ptr %21, align 4, !tbaa !9
  %1352 = mul nsw i32 %1350, %1351
  %1353 = add nsw i32 %1346, %1352
  %1354 = sext i32 %1353 to i64
  %1355 = getelementptr inbounds %struct.doublecomplex, ptr %1345, i64 %1354
  %1356 = call { double, double } @Cd(ptr noundef %1355)
  %1357 = extractvalue { double, double } %1356, 0
  %1358 = extractvalue { double, double } %1356, 1
  %1359 = getelementptr inbounds { double, double }, ptr %39, i32 0, i32 0
  %1360 = getelementptr inbounds { double, double }, ptr %39, i32 0, i32 1
  store double %1357, ptr %1359, align 8
  store double %1358, ptr %1360, align 8
  %1361 = getelementptr inbounds { double, double }, ptr %39, i32 0, i32 0
  %1362 = load double, ptr %1361, align 8
  %1363 = getelementptr inbounds { double, double }, ptr %39, i32 0, i32 1
  %1364 = load double, ptr %1363, align 8
  %1365 = call double @cabs(double noundef %1362, double noundef %1364) #5
  %1366 = fdiv double %1344, %1365
  store double %1366, ptr %26, align 8, !tbaa !18
  %1367 = load i32, ptr %28, align 4, !tbaa !9
  %1368 = load ptr, ptr %14, align 8, !tbaa !5
  %1369 = load i32, ptr %1368, align 4, !tbaa !9
  %1370 = load i32, ptr %28, align 4, !tbaa !9
  %1371 = add nsw i32 %1369, %1370
  %1372 = load i32, ptr %21, align 4, !tbaa !9
  %1373 = mul nsw i32 %1371, %1372
  %1374 = add nsw i32 %1367, %1373
  store i32 %1374, ptr %24, align 4, !tbaa !9
  %1375 = load double, ptr %26, align 8, !tbaa !18
  %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 0
  %1381 = load double, ptr %1380, align 8, !tbaa !11
  %1382 = fmul double %1375, %1381
  %1383 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1382, ptr %1383, align 8, !tbaa !11
  %1384 = load double, ptr %26, align 8, !tbaa !18
  %1385 = load ptr, ptr %16, align 8, !tbaa !5
  %1386 = load i32, ptr %24, align 4, !tbaa !9
  %1387 = sext i32 %1386 to i64
  %1388 = getelementptr inbounds %struct.doublecomplex, ptr %1385, i64 %1387
  %1389 = getelementptr inbounds %struct.doublecomplex, ptr %1388, i32 0, i32 1
  %1390 = load double, ptr %1389, align 8, !tbaa !14
  %1391 = fmul double %1384, %1390
  %1392 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1391, ptr %1392, align 8, !tbaa !14
  %1393 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1394 = load double, ptr %1393, align 8, !tbaa !11
  %1395 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %1394, ptr %1395, align 8, !tbaa !11
  %1396 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1397 = load double, ptr %1396, align 8, !tbaa !14
  %1398 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1397, ptr %1398, align 8, !tbaa !14
  %1399 = load double, ptr %32, align 8, !tbaa !18
  %1400 = fcmp oeq double %1399, 0.000000e+00
  br i1 %1400, label %1401, label %1404

1401:                                             ; preds = %1322
  %1402 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %1402, align 8, !tbaa !11
  %1403 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1403, align 8, !tbaa !14
  br label %1506

1404:                                             ; preds = %1322
  %1405 = load i32, ptr %28, align 4, !tbaa !9
  %1406 = load ptr, ptr %14, align 8, !tbaa !5
  %1407 = load i32, ptr %1406, align 4, !tbaa !9
  %1408 = load i32, ptr %28, align 4, !tbaa !9
  %1409 = add nsw i32 %1407, %1408
  %1410 = load i32, ptr %21, align 4, !tbaa !9
  %1411 = mul nsw i32 %1409, %1410
  %1412 = add nsw i32 %1405, %1411
  store i32 %1412, ptr %24, align 4, !tbaa !9
  %1413 = load ptr, ptr %16, align 8, !tbaa !5
  %1414 = load i32, ptr %24, align 4, !tbaa !9
  %1415 = sext i32 %1414 to i64
  %1416 = getelementptr inbounds %struct.doublecomplex, ptr %1413, i64 %1415
  %1417 = getelementptr inbounds %struct.doublecomplex, ptr %1416, i32 0, i32 0
  %1418 = load double, ptr %1417, align 8, !tbaa !11
  %1419 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1420 = load double, ptr %1419, align 8, !tbaa !11
  %1421 = fadd double %1418, %1420
  %1422 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1421, ptr %1422, align 8, !tbaa !11
  %1423 = load ptr, ptr %16, align 8, !tbaa !5
  %1424 = load i32, ptr %24, align 4, !tbaa !9
  %1425 = sext i32 %1424 to i64
  %1426 = getelementptr inbounds %struct.doublecomplex, ptr %1423, i64 %1425
  %1427 = getelementptr inbounds %struct.doublecomplex, ptr %1426, i32 0, i32 1
  %1428 = load double, ptr %1427, align 8, !tbaa !14
  %1429 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1430 = load double, ptr %1429, align 8, !tbaa !14
  %1431 = fadd double %1428, %1430
  %1432 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1431, ptr %1432, align 8, !tbaa !14
  %1433 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1434 = load double, ptr %1433, align 8, !tbaa !11
  %1435 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1434, ptr %1435, align 8, !tbaa !11
  %1436 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1437 = load double, ptr %1436, align 8, !tbaa !14
  %1438 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1437, ptr %1438, align 8, !tbaa !14
  %1439 = load ptr, ptr %12, align 8, !tbaa !5
  %1440 = load i32, ptr %1439, align 4, !tbaa !9
  %1441 = load ptr, ptr %14, align 8, !tbaa !5
  %1442 = load i32, ptr %1441, align 4, !tbaa !9
  %1443 = sub nsw i32 %1440, %1442
  %1444 = load i32, ptr %28, align 4, !tbaa !9
  %1445 = sub nsw i32 %1443, %1444
  store i32 %1445, ptr %24, align 4, !tbaa !9
  %1446 = call { double, double } @Cd(ptr noundef @c_b2)
  %1447 = extractvalue { double, double } %1446, 0
  %1448 = extractvalue { double, double } %1446, 1
  %1449 = call { double, double } @Cd(ptr noundef %31)
  %1450 = extractvalue { double, double } %1449, 0
  %1451 = extractvalue { double, double } %1449, 1
  %1452 = call { double, double } @__divdc3(double noundef %1447, double noundef %1448, double noundef %1450, double noundef %1451) #5
  %1453 = extractvalue { double, double } %1452, 0
  %1454 = extractvalue { double, double } %1452, 1
  %1455 = call ptr @_pCd(ptr noundef %27)
  %1456 = getelementptr inbounds { double, double }, ptr %1455, i32 0, i32 0
  %1457 = getelementptr inbounds { double, double }, ptr %1455, i32 0, i32 1
  store double %1453, ptr %1456, align 8
  store double %1454, ptr %1457, align 8
  %1458 = load ptr, ptr %16, align 8, !tbaa !5
  %1459 = load i32, ptr %28, align 4, !tbaa !9
  %1460 = load ptr, ptr %14, align 8, !tbaa !5
  %1461 = load i32, ptr %1460, align 4, !tbaa !9
  %1462 = load i32, ptr %28, align 4, !tbaa !9
  %1463 = add nsw i32 %1461, %1462
  %1464 = add nsw i32 %1463, 1
  %1465 = load i32, ptr %21, align 4, !tbaa !9
  %1466 = mul nsw i32 %1464, %1465
  %1467 = add nsw i32 %1459, %1466
  %1468 = sext i32 %1467 to i64
  %1469 = getelementptr inbounds %struct.doublecomplex, ptr %1458, i64 %1468
  %1470 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zscal_(ptr noundef %24, ptr noundef %27, ptr noundef %1469, ptr noundef %1470)
  %1471 = load i32, ptr %28, align 4, !tbaa !9
  %1472 = load ptr, ptr %14, align 8, !tbaa !5
  %1473 = load i32, ptr %1472, align 4, !tbaa !9
  %1474 = load i32, ptr %28, align 4, !tbaa !9
  %1475 = add nsw i32 %1473, %1474
  %1476 = load i32, ptr %21, align 4, !tbaa !9
  %1477 = mul nsw i32 %1475, %1476
  %1478 = add nsw i32 %1471, %1477
  store i32 %1478, ptr %24, align 4, !tbaa !9
  %1479 = load ptr, ptr %16, align 8, !tbaa !5
  %1480 = load i32, ptr %24, align 4, !tbaa !9
  %1481 = sext i32 %1480 to i64
  %1482 = getelementptr inbounds %struct.doublecomplex, ptr %1479, i64 %1481
  %1483 = getelementptr inbounds %struct.doublecomplex, ptr %1482, i32 0, i32 0
  store double 1.000000e+00, ptr %1483, align 8, !tbaa !11
  %1484 = load ptr, ptr %16, align 8, !tbaa !5
  %1485 = load i32, ptr %24, align 4, !tbaa !9
  %1486 = sext i32 %1485 to i64
  %1487 = getelementptr inbounds %struct.doublecomplex, ptr %1484, i64 %1486
  %1488 = getelementptr inbounds %struct.doublecomplex, ptr %1487, i32 0, i32 1
  store double 0.000000e+00, ptr %1488, align 8, !tbaa !14
  %1489 = call { double, double } @Cd(ptr noundef %31)
  %1490 = extractvalue { double, double } %1489, 0
  %1491 = extractvalue { double, double } %1489, 1
  %1492 = call { double, double } @Cd(ptr noundef %30)
  %1493 = extractvalue { double, double } %1492, 0
  %1494 = extractvalue { double, double } %1492, 1
  %1495 = call { double, double } @__divdc3(double noundef %1490, double noundef %1491, double noundef %1493, double noundef %1494) #5
  %1496 = extractvalue { double, double } %1495, 0
  %1497 = extractvalue { double, double } %1495, 1
  %1498 = call ptr @_pCd(ptr noundef %27)
  %1499 = getelementptr inbounds { double, double }, ptr %1498, i32 0, i32 0
  %1500 = getelementptr inbounds { double, double }, ptr %1498, i32 0, i32 1
  store double %1496, ptr %1499, align 8
  store double %1497, ptr %1500, align 8
  %1501 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1502 = load double, ptr %1501, align 8, !tbaa !11
  store double %1502, ptr %26, align 8, !tbaa !18
  %1503 = load double, ptr %26, align 8, !tbaa !18
  %1504 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1503, ptr %1504, align 8, !tbaa !11
  %1505 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1505, align 8, !tbaa !14
  br label %1506

1506:                                             ; preds = %1404, %1401
  %1507 = load ptr, ptr %12, align 8, !tbaa !5
  %1508 = load i32, ptr %1507, align 4, !tbaa !9
  %1509 = load ptr, ptr %14, align 8, !tbaa !5
  %1510 = load i32, ptr %1509, align 4, !tbaa !9
  %1511 = sub nsw i32 %1508, %1510
  %1512 = load i32, ptr %28, align 4, !tbaa !9
  %1513 = sub nsw i32 %1511, %1512
  %1514 = add nsw i32 %1513, 1
  store i32 %1514, ptr %24, align 4, !tbaa !9
  %1515 = load ptr, ptr %16, align 8, !tbaa !5
  %1516 = load i32, ptr %28, align 4, !tbaa !9
  %1517 = load ptr, ptr %14, align 8, !tbaa !5
  %1518 = load i32, ptr %1517, align 4, !tbaa !9
  %1519 = load i32, ptr %28, align 4, !tbaa !9
  %1520 = add nsw i32 %1518, %1519
  %1521 = load i32, ptr %21, align 4, !tbaa !9
  %1522 = mul nsw i32 %1520, %1521
  %1523 = add nsw i32 %1516, %1522
  %1524 = sext i32 %1523 to i64
  %1525 = getelementptr inbounds %struct.doublecomplex, ptr %1515, i64 %1524
  %1526 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zlacgv_(ptr noundef %24, ptr noundef %1525, ptr noundef %1526)
  %1527 = load ptr, ptr %11, align 8, !tbaa !5
  %1528 = load i32, ptr %1527, align 4, !tbaa !9
  %1529 = load i32, ptr %28, align 4, !tbaa !9
  %1530 = sub nsw i32 %1528, %1529
  store i32 %1530, ptr %24, align 4, !tbaa !9
  %1531 = load ptr, ptr %12, align 8, !tbaa !5
  %1532 = load i32, ptr %1531, align 4, !tbaa !9
  %1533 = load ptr, ptr %14, align 8, !tbaa !5
  %1534 = load i32, ptr %1533, align 4, !tbaa !9
  %1535 = sub nsw i32 %1532, %1534
  %1536 = load i32, ptr %28, align 4, !tbaa !9
  %1537 = sub nsw i32 %1535, %1536
  %1538 = add nsw i32 %1537, 1
  store i32 %1538, ptr %25, align 4, !tbaa !9
  %1539 = load ptr, ptr %16, align 8, !tbaa !5
  %1540 = load i32, ptr %28, align 4, !tbaa !9
  %1541 = add nsw i32 %1540, 1
  %1542 = load ptr, ptr %14, align 8, !tbaa !5
  %1543 = load i32, ptr %1542, align 4, !tbaa !9
  %1544 = load i32, ptr %28, align 4, !tbaa !9
  %1545 = add nsw i32 %1543, %1544
  %1546 = load i32, ptr %21, align 4, !tbaa !9
  %1547 = mul nsw i32 %1545, %1546
  %1548 = add nsw i32 %1541, %1547
  %1549 = sext i32 %1548 to i64
  %1550 = getelementptr inbounds %struct.doublecomplex, ptr %1539, i64 %1549
  %1551 = load ptr, ptr %17, align 8, !tbaa !5
  %1552 = load ptr, ptr %16, align 8, !tbaa !5
  %1553 = load i32, ptr %28, align 4, !tbaa !9
  %1554 = load ptr, ptr %14, align 8, !tbaa !5
  %1555 = load i32, ptr %1554, align 4, !tbaa !9
  %1556 = load i32, ptr %28, align 4, !tbaa !9
  %1557 = add nsw i32 %1555, %1556
  %1558 = load i32, ptr %21, align 4, !tbaa !9
  %1559 = mul nsw i32 %1557, %1558
  %1560 = add nsw i32 %1553, %1559
  %1561 = sext i32 %1560 to i64
  %1562 = getelementptr inbounds %struct.doublecomplex, ptr %1552, i64 %1561
  %1563 = load ptr, ptr %17, align 8, !tbaa !5
  %1564 = load ptr, ptr %19, align 8, !tbaa !5
  %1565 = getelementptr inbounds %struct.doublecomplex, ptr %1564, i64 1
  call void @zgemv_(ptr noundef @.str.2, ptr noundef %24, ptr noundef %25, ptr noundef @c_b2, ptr noundef %1550, ptr noundef %1551, ptr noundef %1562, ptr noundef %1563, ptr noundef @c_b1, ptr noundef %1565, ptr noundef @c__1)
  %1566 = load ptr, ptr %11, align 8, !tbaa !5
  %1567 = load i32, ptr %1566, align 4, !tbaa !9
  %1568 = load i32, ptr %28, align 4, !tbaa !9
  %1569 = sub nsw i32 %1567, %1568
  store i32 %1569, ptr %24, align 4, !tbaa !9
  %1570 = load ptr, ptr %12, align 8, !tbaa !5
  %1571 = load i32, ptr %1570, align 4, !tbaa !9
  %1572 = load ptr, ptr %14, align 8, !tbaa !5
  %1573 = load i32, ptr %1572, align 4, !tbaa !9
  %1574 = sub nsw i32 %1571, %1573
  %1575 = load i32, ptr %28, align 4, !tbaa !9
  %1576 = sub nsw i32 %1574, %1575
  %1577 = add nsw i32 %1576, 1
  store i32 %1577, ptr %25, align 4, !tbaa !9
  %1578 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1579 = load double, ptr %1578, align 8, !tbaa !11
  %1580 = fneg double %1579
  %1581 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1580, ptr %1581, align 8, !tbaa !11
  %1582 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1583 = load double, ptr %1582, align 8, !tbaa !14
  %1584 = fneg double %1583
  %1585 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1584, ptr %1585, align 8, !tbaa !14
  %1586 = load ptr, ptr %19, align 8, !tbaa !5
  %1587 = getelementptr inbounds %struct.doublecomplex, ptr %1586, i64 1
  %1588 = load ptr, ptr %16, align 8, !tbaa !5
  %1589 = load i32, ptr %28, align 4, !tbaa !9
  %1590 = load ptr, ptr %14, align 8, !tbaa !5
  %1591 = load i32, ptr %1590, align 4, !tbaa !9
  %1592 = load i32, ptr %28, align 4, !tbaa !9
  %1593 = add nsw i32 %1591, %1592
  %1594 = load i32, ptr %21, align 4, !tbaa !9
  %1595 = mul nsw i32 %1593, %1594
  %1596 = add nsw i32 %1589, %1595
  %1597 = sext i32 %1596 to i64
  %1598 = getelementptr inbounds %struct.doublecomplex, ptr %1588, i64 %1597
  %1599 = load ptr, ptr %17, align 8, !tbaa !5
  %1600 = load ptr, ptr %16, align 8, !tbaa !5
  %1601 = load i32, ptr %28, align 4, !tbaa !9
  %1602 = add nsw i32 %1601, 1
  %1603 = load ptr, ptr %14, align 8, !tbaa !5
  %1604 = load i32, ptr %1603, align 4, !tbaa !9
  %1605 = load i32, ptr %28, align 4, !tbaa !9
  %1606 = add nsw i32 %1604, %1605
  %1607 = load i32, ptr %21, align 4, !tbaa !9
  %1608 = mul nsw i32 %1606, %1607
  %1609 = add nsw i32 %1602, %1608
  %1610 = sext i32 %1609 to i64
  %1611 = getelementptr inbounds %struct.doublecomplex, ptr %1600, i64 %1610
  %1612 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %24, ptr noundef %25, ptr noundef %27, ptr noundef %1587, ptr noundef @c__1, ptr noundef %1598, ptr noundef %1599, ptr noundef %1611, ptr noundef %1612)
  %1613 = load i32, ptr %28, align 4, !tbaa !9
  %1614 = load ptr, ptr %14, align 8, !tbaa !5
  %1615 = load i32, ptr %1614, align 4, !tbaa !9
  %1616 = load i32, ptr %28, align 4, !tbaa !9
  %1617 = add nsw i32 %1615, %1616
  %1618 = load i32, ptr %21, align 4, !tbaa !9
  %1619 = mul nsw i32 %1617, %1618
  %1620 = add nsw i32 %1613, %1619
  store i32 %1620, ptr %24, align 4, !tbaa !9
  %1621 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1622 = load double, ptr %1621, align 8, !tbaa !11
  %1623 = fneg double %1622
  %1624 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1623, ptr %1624, align 8, !tbaa !11
  %1625 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1626 = load double, ptr %1625, align 8, !tbaa !14
  %1627 = fneg double %1626
  %1628 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1627, ptr %1628, align 8, !tbaa !14
  %1629 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1630 = load double, ptr %1629, align 8, !tbaa !11
  %1631 = load ptr, ptr %16, align 8, !tbaa !5
  %1632 = load i32, ptr %24, align 4, !tbaa !9
  %1633 = sext i32 %1632 to i64
  %1634 = getelementptr inbounds %struct.doublecomplex, ptr %1631, i64 %1633
  %1635 = getelementptr inbounds %struct.doublecomplex, ptr %1634, i32 0, i32 0
  store double %1630, ptr %1635, align 8, !tbaa !11
  %1636 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1637 = load double, ptr %1636, align 8, !tbaa !14
  %1638 = load ptr, ptr %16, align 8, !tbaa !5
  %1639 = load i32, ptr %24, align 4, !tbaa !9
  %1640 = sext i32 %1639 to i64
  %1641 = getelementptr inbounds %struct.doublecomplex, ptr %1638, i64 %1640
  %1642 = getelementptr inbounds %struct.doublecomplex, ptr %1641, i32 0, i32 1
  store double %1637, ptr %1642, align 8, !tbaa !14
  br label %1643

1643:                                             ; preds = %1506, %1319
  %1644 = load ptr, ptr %11, align 8, !tbaa !5
  %1645 = load i32, ptr %1644, align 4, !tbaa !9
  %1646 = sub nsw i32 %1645, 1
  %1647 = load ptr, ptr %13, align 8, !tbaa !5
  %1648 = load i32, ptr %1647, align 4, !tbaa !9
  %1649 = sub nsw i32 %1646, %1648
  store i32 %1649, ptr %24, align 4, !tbaa !9
  %1650 = load i32, ptr %28, align 4, !tbaa !9
  %1651 = load i32, ptr %24, align 4, !tbaa !9
  %1652 = load ptr, ptr %12, align 8, !tbaa !5
  %1653 = load i32, ptr %1652, align 4, !tbaa !9
  %1654 = icmp sle i32 %1651, %1653
  br i1 %1654, label %1655, label %1657

1655:                                             ; preds = %1643
  %1656 = load i32, ptr %24, align 4, !tbaa !9
  br label %1660

1657:                                             ; preds = %1643
  %1658 = load ptr, ptr %12, align 8, !tbaa !5
  %1659 = load i32, ptr %1658, align 4, !tbaa !9
  br label %1660

1660:                                             ; preds = %1657, %1655
  %1661 = phi i32 [ %1656, %1655 ], [ %1659, %1657 ]
  %1662 = icmp sle i32 %1650, %1661
  br i1 %1662, label %1663, label %1960

1663:                                             ; preds = %1660
  %1664 = load ptr, ptr %11, align 8, !tbaa !5
  %1665 = load i32, ptr %1664, align 4, !tbaa !9
  %1666 = load ptr, ptr %13, align 8, !tbaa !5
  %1667 = load i32, ptr %1666, align 4, !tbaa !9
  %1668 = sub nsw i32 %1665, %1667
  %1669 = load i32, ptr %28, align 4, !tbaa !9
  %1670 = sub nsw i32 %1668, %1669
  %1671 = add nsw i32 %1670, 1
  store i32 %1671, ptr %24, align 4, !tbaa !9
  %1672 = load ptr, ptr %16, align 8, !tbaa !5
  %1673 = load ptr, ptr %13, align 8, !tbaa !5
  %1674 = load i32, ptr %1673, align 4, !tbaa !9
  %1675 = load i32, ptr %28, align 4, !tbaa !9
  %1676 = add nsw i32 %1674, %1675
  %1677 = load i32, ptr %28, align 4, !tbaa !9
  %1678 = load i32, ptr %21, align 4, !tbaa !9
  %1679 = mul nsw i32 %1677, %1678
  %1680 = add nsw i32 %1676, %1679
  %1681 = sext i32 %1680 to i64
  %1682 = getelementptr inbounds %struct.doublecomplex, ptr %1672, i64 %1681
  %1683 = call double @dznrm2_(ptr noundef %24, ptr noundef %1682, ptr noundef @c__1)
  store double %1683, ptr %32, align 8, !tbaa !18
  %1684 = load double, ptr %32, align 8, !tbaa !18
  %1685 = load ptr, ptr %16, align 8, !tbaa !5
  %1686 = load ptr, ptr %13, align 8, !tbaa !5
  %1687 = load i32, ptr %1686, align 4, !tbaa !9
  %1688 = load i32, ptr %28, align 4, !tbaa !9
  %1689 = add nsw i32 %1687, %1688
  %1690 = load i32, ptr %28, align 4, !tbaa !9
  %1691 = load i32, ptr %21, align 4, !tbaa !9
  %1692 = mul nsw i32 %1690, %1691
  %1693 = add nsw i32 %1689, %1692
  %1694 = sext i32 %1693 to i64
  %1695 = getelementptr inbounds %struct.doublecomplex, ptr %1685, i64 %1694
  %1696 = call { double, double } @Cd(ptr noundef %1695)
  %1697 = extractvalue { double, double } %1696, 0
  %1698 = extractvalue { double, double } %1696, 1
  %1699 = getelementptr inbounds { double, double }, ptr %40, i32 0, i32 0
  %1700 = getelementptr inbounds { double, double }, ptr %40, i32 0, i32 1
  store double %1697, ptr %1699, align 8
  store double %1698, ptr %1700, align 8
  %1701 = getelementptr inbounds { double, double }, ptr %40, i32 0, i32 0
  %1702 = load double, ptr %1701, align 8
  %1703 = getelementptr inbounds { double, double }, ptr %40, i32 0, i32 1
  %1704 = load double, ptr %1703, align 8
  %1705 = call double @cabs(double noundef %1702, double noundef %1704) #5
  %1706 = fdiv double %1684, %1705
  store double %1706, ptr %26, align 8, !tbaa !18
  %1707 = load ptr, ptr %13, align 8, !tbaa !5
  %1708 = load i32, ptr %1707, align 4, !tbaa !9
  %1709 = load i32, ptr %28, align 4, !tbaa !9
  %1710 = add nsw i32 %1708, %1709
  %1711 = load i32, ptr %28, align 4, !tbaa !9
  %1712 = load i32, ptr %21, align 4, !tbaa !9
  %1713 = mul nsw i32 %1711, %1712
  %1714 = add nsw i32 %1710, %1713
  store i32 %1714, ptr %24, align 4, !tbaa !9
  %1715 = load double, ptr %26, align 8, !tbaa !18
  %1716 = load ptr, ptr %16, align 8, !tbaa !5
  %1717 = load i32, ptr %24, align 4, !tbaa !9
  %1718 = sext i32 %1717 to i64
  %1719 = getelementptr inbounds %struct.doublecomplex, ptr %1716, i64 %1718
  %1720 = getelementptr inbounds %struct.doublecomplex, ptr %1719, i32 0, i32 0
  %1721 = load double, ptr %1720, align 8, !tbaa !11
  %1722 = fmul double %1715, %1721
  %1723 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1722, ptr %1723, align 8, !tbaa !11
  %1724 = load double, ptr %26, align 8, !tbaa !18
  %1725 = load ptr, ptr %16, align 8, !tbaa !5
  %1726 = load i32, ptr %24, align 4, !tbaa !9
  %1727 = sext i32 %1726 to i64
  %1728 = getelementptr inbounds %struct.doublecomplex, ptr %1725, i64 %1727
  %1729 = getelementptr inbounds %struct.doublecomplex, ptr %1728, i32 0, i32 1
  %1730 = load double, ptr %1729, align 8, !tbaa !14
  %1731 = fmul double %1724, %1730
  %1732 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1731, ptr %1732, align 8, !tbaa !14
  %1733 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1734 = load double, ptr %1733, align 8, !tbaa !11
  %1735 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %1734, ptr %1735, align 8, !tbaa !11
  %1736 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1737 = load double, ptr %1736, align 8, !tbaa !14
  %1738 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1737, ptr %1738, align 8, !tbaa !14
  %1739 = load double, ptr %32, align 8, !tbaa !18
  %1740 = fcmp oeq double %1739, 0.000000e+00
  br i1 %1740, label %1741, label %1744

1741:                                             ; preds = %1663
  %1742 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double 0.000000e+00, ptr %1742, align 8, !tbaa !11
  %1743 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1743, align 8, !tbaa !14
  br label %1845

1744:                                             ; preds = %1663
  %1745 = load ptr, ptr %13, align 8, !tbaa !5
  %1746 = load i32, ptr %1745, align 4, !tbaa !9
  %1747 = load i32, ptr %28, align 4, !tbaa !9
  %1748 = add nsw i32 %1746, %1747
  %1749 = load i32, ptr %28, align 4, !tbaa !9
  %1750 = load i32, ptr %21, align 4, !tbaa !9
  %1751 = mul nsw i32 %1749, %1750
  %1752 = add nsw i32 %1748, %1751
  store i32 %1752, ptr %24, align 4, !tbaa !9
  %1753 = load ptr, ptr %16, align 8, !tbaa !5
  %1754 = load i32, ptr %24, align 4, !tbaa !9
  %1755 = sext i32 %1754 to i64
  %1756 = getelementptr inbounds %struct.doublecomplex, ptr %1753, i64 %1755
  %1757 = getelementptr inbounds %struct.doublecomplex, ptr %1756, i32 0, i32 0
  %1758 = load double, ptr %1757, align 8, !tbaa !11
  %1759 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1760 = load double, ptr %1759, align 8, !tbaa !11
  %1761 = fadd double %1758, %1760
  %1762 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1761, ptr %1762, align 8, !tbaa !11
  %1763 = load ptr, ptr %16, align 8, !tbaa !5
  %1764 = load i32, ptr %24, align 4, !tbaa !9
  %1765 = sext i32 %1764 to i64
  %1766 = getelementptr inbounds %struct.doublecomplex, ptr %1763, i64 %1765
  %1767 = getelementptr inbounds %struct.doublecomplex, ptr %1766, i32 0, i32 1
  %1768 = load double, ptr %1767, align 8, !tbaa !14
  %1769 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1770 = load double, ptr %1769, align 8, !tbaa !14
  %1771 = fadd double %1768, %1770
  %1772 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1771, ptr %1772, align 8, !tbaa !14
  %1773 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1774 = load double, ptr %1773, align 8, !tbaa !11
  %1775 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1774, ptr %1775, align 8, !tbaa !11
  %1776 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1777 = load double, ptr %1776, align 8, !tbaa !14
  %1778 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1777, ptr %1778, align 8, !tbaa !14
  %1779 = load ptr, ptr %11, align 8, !tbaa !5
  %1780 = load i32, ptr %1779, align 4, !tbaa !9
  %1781 = load ptr, ptr %13, align 8, !tbaa !5
  %1782 = load i32, ptr %1781, align 4, !tbaa !9
  %1783 = sub nsw i32 %1780, %1782
  %1784 = load i32, ptr %28, align 4, !tbaa !9
  %1785 = sub nsw i32 %1783, %1784
  store i32 %1785, ptr %24, align 4, !tbaa !9
  %1786 = call { double, double } @Cd(ptr noundef @c_b2)
  %1787 = extractvalue { double, double } %1786, 0
  %1788 = extractvalue { double, double } %1786, 1
  %1789 = call { double, double } @Cd(ptr noundef %31)
  %1790 = extractvalue { double, double } %1789, 0
  %1791 = extractvalue { double, double } %1789, 1
  %1792 = call { double, double } @__divdc3(double noundef %1787, double noundef %1788, double noundef %1790, double noundef %1791) #5
  %1793 = extractvalue { double, double } %1792, 0
  %1794 = extractvalue { double, double } %1792, 1
  %1795 = call ptr @_pCd(ptr noundef %27)
  %1796 = getelementptr inbounds { double, double }, ptr %1795, i32 0, i32 0
  %1797 = getelementptr inbounds { double, double }, ptr %1795, i32 0, i32 1
  store double %1793, ptr %1796, align 8
  store double %1794, ptr %1797, align 8
  %1798 = load ptr, ptr %16, align 8, !tbaa !5
  %1799 = load ptr, ptr %13, align 8, !tbaa !5
  %1800 = load i32, ptr %1799, align 4, !tbaa !9
  %1801 = load i32, ptr %28, align 4, !tbaa !9
  %1802 = add nsw i32 %1800, %1801
  %1803 = add nsw i32 %1802, 1
  %1804 = load i32, ptr %28, align 4, !tbaa !9
  %1805 = load i32, ptr %21, align 4, !tbaa !9
  %1806 = mul nsw i32 %1804, %1805
  %1807 = add nsw i32 %1803, %1806
  %1808 = sext i32 %1807 to i64
  %1809 = getelementptr inbounds %struct.doublecomplex, ptr %1798, i64 %1808
  call void @zscal_(ptr noundef %24, ptr noundef %27, ptr noundef %1809, ptr noundef @c__1)
  %1810 = load ptr, ptr %13, align 8, !tbaa !5
  %1811 = load i32, ptr %1810, align 4, !tbaa !9
  %1812 = load i32, ptr %28, align 4, !tbaa !9
  %1813 = add nsw i32 %1811, %1812
  %1814 = load i32, ptr %28, align 4, !tbaa !9
  %1815 = load i32, ptr %21, align 4, !tbaa !9
  %1816 = mul nsw i32 %1814, %1815
  %1817 = add nsw i32 %1813, %1816
  store i32 %1817, ptr %24, align 4, !tbaa !9
  %1818 = load ptr, ptr %16, align 8, !tbaa !5
  %1819 = load i32, ptr %24, align 4, !tbaa !9
  %1820 = sext i32 %1819 to i64
  %1821 = getelementptr inbounds %struct.doublecomplex, ptr %1818, i64 %1820
  %1822 = getelementptr inbounds %struct.doublecomplex, ptr %1821, i32 0, i32 0
  store double 1.000000e+00, ptr %1822, align 8, !tbaa !11
  %1823 = load ptr, ptr %16, align 8, !tbaa !5
  %1824 = load i32, ptr %24, align 4, !tbaa !9
  %1825 = sext i32 %1824 to i64
  %1826 = getelementptr inbounds %struct.doublecomplex, ptr %1823, i64 %1825
  %1827 = getelementptr inbounds %struct.doublecomplex, ptr %1826, i32 0, i32 1
  store double 0.000000e+00, ptr %1827, align 8, !tbaa !14
  %1828 = call { double, double } @Cd(ptr noundef %31)
  %1829 = extractvalue { double, double } %1828, 0
  %1830 = extractvalue { double, double } %1828, 1
  %1831 = call { double, double } @Cd(ptr noundef %30)
  %1832 = extractvalue { double, double } %1831, 0
  %1833 = extractvalue { double, double } %1831, 1
  %1834 = call { double, double } @__divdc3(double noundef %1829, double noundef %1830, double noundef %1832, double noundef %1833) #5
  %1835 = extractvalue { double, double } %1834, 0
  %1836 = extractvalue { double, double } %1834, 1
  %1837 = call ptr @_pCd(ptr noundef %27)
  %1838 = getelementptr inbounds { double, double }, ptr %1837, i32 0, i32 0
  %1839 = getelementptr inbounds { double, double }, ptr %1837, i32 0, i32 1
  store double %1835, ptr %1838, align 8
  store double %1836, ptr %1839, align 8
  %1840 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1841 = load double, ptr %1840, align 8, !tbaa !11
  store double %1841, ptr %26, align 8, !tbaa !18
  %1842 = load double, ptr %26, align 8, !tbaa !18
  %1843 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1842, ptr %1843, align 8, !tbaa !11
  %1844 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double 0.000000e+00, ptr %1844, align 8, !tbaa !14
  br label %1845

1845:                                             ; preds = %1744, %1741
  %1846 = load ptr, ptr %11, align 8, !tbaa !5
  %1847 = load i32, ptr %1846, align 4, !tbaa !9
  %1848 = load ptr, ptr %13, align 8, !tbaa !5
  %1849 = load i32, ptr %1848, align 4, !tbaa !9
  %1850 = sub nsw i32 %1847, %1849
  %1851 = load i32, ptr %28, align 4, !tbaa !9
  %1852 = sub nsw i32 %1850, %1851
  %1853 = add nsw i32 %1852, 1
  store i32 %1853, ptr %24, align 4, !tbaa !9
  %1854 = load ptr, ptr %12, align 8, !tbaa !5
  %1855 = load i32, ptr %1854, align 4, !tbaa !9
  %1856 = load i32, ptr %28, align 4, !tbaa !9
  %1857 = sub nsw i32 %1855, %1856
  store i32 %1857, ptr %25, align 4, !tbaa !9
  %1858 = load ptr, ptr %16, align 8, !tbaa !5
  %1859 = load ptr, ptr %13, align 8, !tbaa !5
  %1860 = load i32, ptr %1859, align 4, !tbaa !9
  %1861 = load i32, ptr %28, align 4, !tbaa !9
  %1862 = add nsw i32 %1860, %1861
  %1863 = load i32, ptr %28, align 4, !tbaa !9
  %1864 = add nsw i32 %1863, 1
  %1865 = load i32, ptr %21, align 4, !tbaa !9
  %1866 = mul nsw i32 %1864, %1865
  %1867 = add nsw i32 %1862, %1866
  %1868 = sext i32 %1867 to i64
  %1869 = getelementptr inbounds %struct.doublecomplex, ptr %1858, i64 %1868
  %1870 = load ptr, ptr %17, align 8, !tbaa !5
  %1871 = load ptr, ptr %16, align 8, !tbaa !5
  %1872 = load ptr, ptr %13, align 8, !tbaa !5
  %1873 = load i32, ptr %1872, align 4, !tbaa !9
  %1874 = load i32, ptr %28, align 4, !tbaa !9
  %1875 = add nsw i32 %1873, %1874
  %1876 = load i32, ptr %28, align 4, !tbaa !9
  %1877 = load i32, ptr %21, align 4, !tbaa !9
  %1878 = mul nsw i32 %1876, %1877
  %1879 = add nsw i32 %1875, %1878
  %1880 = sext i32 %1879 to i64
  %1881 = getelementptr inbounds %struct.doublecomplex, ptr %1871, i64 %1880
  %1882 = load ptr, ptr %19, align 8, !tbaa !5
  %1883 = getelementptr inbounds %struct.doublecomplex, ptr %1882, i64 1
  call void @zgemv_(ptr noundef @.str.1, ptr noundef %24, ptr noundef %25, ptr noundef @c_b2, ptr noundef %1869, ptr noundef %1870, ptr noundef %1881, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1883, ptr noundef @c__1)
  %1884 = load ptr, ptr %11, align 8, !tbaa !5
  %1885 = load i32, ptr %1884, align 4, !tbaa !9
  %1886 = load ptr, ptr %13, align 8, !tbaa !5
  %1887 = load i32, ptr %1886, align 4, !tbaa !9
  %1888 = sub nsw i32 %1885, %1887
  %1889 = load i32, ptr %28, align 4, !tbaa !9
  %1890 = sub nsw i32 %1888, %1889
  %1891 = add nsw i32 %1890, 1
  store i32 %1891, ptr %24, align 4, !tbaa !9
  %1892 = load ptr, ptr %12, align 8, !tbaa !5
  %1893 = load i32, ptr %1892, align 4, !tbaa !9
  %1894 = load i32, ptr %28, align 4, !tbaa !9
  %1895 = sub nsw i32 %1893, %1894
  store i32 %1895, ptr %25, align 4, !tbaa !9
  %1896 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1897 = load double, ptr %1896, align 8, !tbaa !11
  %1898 = fneg double %1897
  %1899 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1898, ptr %1899, align 8, !tbaa !11
  %1900 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1901 = load double, ptr %1900, align 8, !tbaa !14
  %1902 = fneg double %1901
  %1903 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1902, ptr %1903, align 8, !tbaa !14
  %1904 = load ptr, ptr %16, align 8, !tbaa !5
  %1905 = load ptr, ptr %13, align 8, !tbaa !5
  %1906 = load i32, ptr %1905, align 4, !tbaa !9
  %1907 = load i32, ptr %28, align 4, !tbaa !9
  %1908 = add nsw i32 %1906, %1907
  %1909 = load i32, ptr %28, align 4, !tbaa !9
  %1910 = load i32, ptr %21, align 4, !tbaa !9
  %1911 = mul nsw i32 %1909, %1910
  %1912 = add nsw i32 %1908, %1911
  %1913 = sext i32 %1912 to i64
  %1914 = getelementptr inbounds %struct.doublecomplex, ptr %1904, i64 %1913
  %1915 = load ptr, ptr %19, align 8, !tbaa !5
  %1916 = getelementptr inbounds %struct.doublecomplex, ptr %1915, i64 1
  %1917 = load ptr, ptr %16, align 8, !tbaa !5
  %1918 = load ptr, ptr %13, align 8, !tbaa !5
  %1919 = load i32, ptr %1918, align 4, !tbaa !9
  %1920 = load i32, ptr %28, align 4, !tbaa !9
  %1921 = add nsw i32 %1919, %1920
  %1922 = load i32, ptr %28, align 4, !tbaa !9
  %1923 = add nsw i32 %1922, 1
  %1924 = load i32, ptr %21, align 4, !tbaa !9
  %1925 = mul nsw i32 %1923, %1924
  %1926 = add nsw i32 %1921, %1925
  %1927 = sext i32 %1926 to i64
  %1928 = getelementptr inbounds %struct.doublecomplex, ptr %1917, i64 %1927
  %1929 = load ptr, ptr %17, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %24, ptr noundef %25, ptr noundef %27, ptr noundef %1914, ptr noundef @c__1, ptr noundef %1916, ptr noundef @c__1, ptr noundef %1928, ptr noundef %1929)
  %1930 = load ptr, ptr %13, align 8, !tbaa !5
  %1931 = load i32, ptr %1930, align 4, !tbaa !9
  %1932 = load i32, ptr %28, align 4, !tbaa !9
  %1933 = add nsw i32 %1931, %1932
  %1934 = load i32, ptr %28, align 4, !tbaa !9
  %1935 = load i32, ptr %21, align 4, !tbaa !9
  %1936 = mul nsw i32 %1934, %1935
  %1937 = add nsw i32 %1933, %1936
  store i32 %1937, ptr %24, align 4, !tbaa !9
  %1938 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1939 = load double, ptr %1938, align 8, !tbaa !11
  %1940 = fneg double %1939
  %1941 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1940, ptr %1941, align 8, !tbaa !11
  %1942 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1943 = load double, ptr %1942, align 8, !tbaa !14
  %1944 = fneg double %1943
  %1945 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1944, ptr %1945, align 8, !tbaa !14
  %1946 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1947 = load double, ptr %1946, align 8, !tbaa !11
  %1948 = load ptr, ptr %16, align 8, !tbaa !5
  %1949 = load i32, ptr %24, align 4, !tbaa !9
  %1950 = sext i32 %1949 to i64
  %1951 = getelementptr inbounds %struct.doublecomplex, ptr %1948, i64 %1950
  %1952 = getelementptr inbounds %struct.doublecomplex, ptr %1951, i32 0, i32 0
  store double %1947, ptr %1952, align 8, !tbaa !11
  %1953 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1954 = load double, ptr %1953, align 8, !tbaa !14
  %1955 = load ptr, ptr %16, align 8, !tbaa !5
  %1956 = load i32, ptr %24, align 4, !tbaa !9
  %1957 = sext i32 %1956 to i64
  %1958 = getelementptr inbounds %struct.doublecomplex, ptr %1955, i64 %1957
  %1959 = getelementptr inbounds %struct.doublecomplex, ptr %1958, i32 0, i32 1
  store double %1954, ptr %1959, align 8, !tbaa !14
  br label %1960

1960:                                             ; preds = %1845, %1660
  br label %1961

1961:                                             ; preds = %1960, %1301
  %1962 = load i32, ptr %28, align 4, !tbaa !9
  %1963 = load ptr, ptr %12, align 8, !tbaa !5
  %1964 = load i32, ptr %1963, align 4, !tbaa !9
  %1965 = icmp sle i32 %1962, %1964
  br i1 %1965, label %1966, label %1998

1966:                                             ; preds = %1961
  %1967 = load ptr, ptr %11, align 8, !tbaa !5
  %1968 = load i32, ptr %1967, align 4, !tbaa !9
  store i32 %1968, ptr %24, align 4, !tbaa !9
  %1969 = load ptr, ptr %13, align 8, !tbaa !5
  %1970 = load i32, ptr %1969, align 4, !tbaa !9
  %1971 = load i32, ptr %28, align 4, !tbaa !9
  %1972 = add nsw i32 %1970, %1971
  %1973 = add nsw i32 %1972, 1
  store i32 %1973, ptr %29, align 4, !tbaa !9
  br label %1974

1974:                                             ; preds = %1994, %1966
  %1975 = load i32, ptr %29, align 4, !tbaa !9
  %1976 = load i32, ptr %24, align 4, !tbaa !9
  %1977 = icmp sle i32 %1975, %1976
  br i1 %1977, label %1978, label %1997

1978:                                             ; preds = %1974
  %1979 = load i32, ptr %29, align 4, !tbaa !9
  %1980 = load i32, ptr %28, align 4, !tbaa !9
  %1981 = load i32, ptr %21, align 4, !tbaa !9
  %1982 = mul nsw i32 %1980, %1981
  %1983 = add nsw i32 %1979, %1982
  store i32 %1983, ptr %25, align 4, !tbaa !9
  %1984 = load ptr, ptr %16, align 8, !tbaa !5
  %1985 = load i32, ptr %25, align 4, !tbaa !9
  %1986 = sext i32 %1985 to i64
  %1987 = getelementptr inbounds %struct.doublecomplex, ptr %1984, i64 %1986
  %1988 = getelementptr inbounds %struct.doublecomplex, ptr %1987, i32 0, i32 0
  store double 0.000000e+00, ptr %1988, align 8, !tbaa !11
  %1989 = load ptr, ptr %16, align 8, !tbaa !5
  %1990 = load i32, ptr %25, align 4, !tbaa !9
  %1991 = sext i32 %1990 to i64
  %1992 = getelementptr inbounds %struct.doublecomplex, ptr %1989, i64 %1991
  %1993 = getelementptr inbounds %struct.doublecomplex, ptr %1992, i32 0, i32 1
  store double 0.000000e+00, ptr %1993, align 8, !tbaa !14
  br label %1994

1994:                                             ; preds = %1978
  %1995 = load i32, ptr %29, align 4, !tbaa !9
  %1996 = add nsw i32 %1995, 1
  store i32 %1996, ptr %29, align 4, !tbaa !9
  br label %1974, !llvm.loop !21

1997:                                             ; preds = %1974
  br label %1998

1998:                                             ; preds = %1997, %1961
  %1999 = load i32, ptr %28, align 4, !tbaa !9
  %2000 = load ptr, ptr %11, align 8, !tbaa !5
  %2001 = load i32, ptr %2000, align 4, !tbaa !9
  %2002 = icmp sle i32 %1999, %2001
  br i1 %2002, label %2003, label %2035

2003:                                             ; preds = %1998
  %2004 = load ptr, ptr %12, align 8, !tbaa !5
  %2005 = load i32, ptr %2004, align 4, !tbaa !9
  store i32 %2005, ptr %24, align 4, !tbaa !9
  %2006 = load ptr, ptr %14, align 8, !tbaa !5
  %2007 = load i32, ptr %2006, align 4, !tbaa !9
  %2008 = load i32, ptr %28, align 4, !tbaa !9
  %2009 = add nsw i32 %2007, %2008
  %2010 = add nsw i32 %2009, 1
  store i32 %2010, ptr %29, align 4, !tbaa !9
  br label %2011

2011:                                             ; preds = %2031, %2003
  %2012 = load i32, ptr %29, align 4, !tbaa !9
  %2013 = load i32, ptr %24, align 4, !tbaa !9
  %2014 = icmp sle i32 %2012, %2013
  br i1 %2014, label %2015, label %2034

2015:                                             ; preds = %2011
  %2016 = load i32, ptr %28, align 4, !tbaa !9
  %2017 = load i32, ptr %29, align 4, !tbaa !9
  %2018 = load i32, ptr %21, align 4, !tbaa !9
  %2019 = mul nsw i32 %2017, %2018
  %2020 = add nsw i32 %2016, %2019
  store i32 %2020, ptr %25, align 4, !tbaa !9
  %2021 = load ptr, ptr %16, align 8, !tbaa !5
  %2022 = load i32, ptr %25, align 4, !tbaa !9
  %2023 = sext i32 %2022 to i64
  %2024 = getelementptr inbounds %struct.doublecomplex, ptr %2021, i64 %2023
  %2025 = getelementptr inbounds %struct.doublecomplex, ptr %2024, i32 0, i32 0
  store double 0.000000e+00, ptr %2025, align 8, !tbaa !11
  %2026 = load ptr, ptr %16, align 8, !tbaa !5
  %2027 = load i32, ptr %25, align 4, !tbaa !9
  %2028 = sext i32 %2027 to i64
  %2029 = getelementptr inbounds %struct.doublecomplex, ptr %2026, i64 %2028
  %2030 = getelementptr inbounds %struct.doublecomplex, ptr %2029, i32 0, i32 1
  store double 0.000000e+00, ptr %2030, align 8, !tbaa !14
  br label %2031

2031:                                             ; preds = %2015
  %2032 = load i32, ptr %29, align 4, !tbaa !9
  %2033 = add nsw i32 %2032, 1
  store i32 %2033, ptr %29, align 4, !tbaa !9
  br label %2011, !llvm.loop !22

2034:                                             ; preds = %2011
  br label %2035

2035:                                             ; preds = %2034, %1998
  br label %2036

2036:                                             ; preds = %2035
  %2037 = load i32, ptr %28, align 4, !tbaa !9
  %2038 = add nsw i32 %2037, 1
  store i32 %2038, ptr %28, align 4, !tbaa !9
  br label %633, !llvm.loop !23

2039:                                             ; preds = %633
  store i32 1, ptr %34, align 4
  br label %2040

2040:                                             ; preds = %2039, %211, %118
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #5
  ret void
}

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

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

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

declare double @dznrm2_(ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: nounwind
declare double @cabs(double noundef, double noundef) #3

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

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

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

declare void @zscal_(ptr noundef, ptr noundef, ptr noundef, ptr noundef) #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) #2

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

declare void @zlacgv_(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 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 #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}
!18 = !{!13, !13, i64 0}
!19 = distinct !{!19, !16}
!20 = distinct !{!20, !16}
!21 = distinct !{!21, !16}
!22 = distinct !{!22, !16}
!23 = distinct !{!23, !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 [7 x i8], align 1
@c__3 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c_b2 = external hidden global %struct.doublecomplex, align 8
@.str.1 = external hidden unnamed_addr constant [20 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.2 = external hidden unnamed_addr constant [13 x i8], align 1

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

23:                                               ; preds = %10
  %24 = load i32, ptr %1, align 4, !tbaa !5
  %25 = icmp slt i32 %24, 0
  br i1 %25, label %.thread, label %26

26:                                               ; preds = %23
  %27 = load i32, ptr %2, align 4, !tbaa !5
  %or.cond = icmp ult i32 %27, %21
  br i1 %or.cond, label %28, label %.thread

28:                                               ; preds = %26
  %29 = load i32, ptr %3, align 4, !tbaa !5
  %or.cond633 = icmp ult i32 %29, %24
  br i1 %or.cond633, label %30, label %.thread

30:                                               ; preds = %28
  %31 = load i32, ptr %6, align 4, !tbaa !5
  %32 = icmp slt i32 %31, %21
  br i1 %32, label %.thread, label %.lr.ph.preheader

.thread:                                          ; preds = %30, %28, %26, %23, %10
  %.sink = phi i32 [ -1, %10 ], [ -2, %23 ], [ -3, %26 ], [ -4, %28 ], [ -7, %30 ]
  %.neg = phi i32 [ 1, %10 ], [ 2, %23 ], [ 3, %26 ], [ 4, %28 ], [ 7, %30 ]
  store i32 %.sink, ptr %9, align 4, !tbaa !5
  store i32 %.neg, ptr %11, align 4, !tbaa !5
  %33 = call i32 @xerbla_(ptr noundef nonnull @.str, ptr noundef nonnull %11, i32 noundef 6) #7
  br label %.loopexit653

.lr.ph.preheader:                                 ; preds = %30
  store i32 %21, ptr %12, align 4, !tbaa !5
  %34 = add i32 %18, 1
  %35 = sext i32 %34 to i64
  %36 = add nsw i64 %19, %35
  %37 = shl nsw i64 %36, 4
  %38 = sext i32 %18 to i64
  %39 = shl nsw i64 %38, 4
  %40 = zext nneg i32 %21 to i64
  %41 = shl nuw nsw i64 %40, 4
  %42 = mul i32 %18, %24
  %wide.trip.count720 = zext nneg i32 %24 to i64
  %43 = getelementptr i8, ptr %5, i64 %37
  %xtraiter = and i64 %wide.trip.count720, 7
  %44 = icmp ult i32 %24, 8
  br i1 %44, label %._crit_edge663.unr-lcssa, label %.lr.ph.preheader.new

.lr.ph.preheader.new:                             ; preds = %.lr.ph.preheader
  %unroll_iter = and i64 %wide.trip.count720, 2147483640
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph, %.lr.ph.preheader.new
  %indvar = phi i64 [ 0, %.lr.ph.preheader.new ], [ %indvar.next.7, %.lr.ph ]
  %niter = phi i64 [ 0, %.lr.ph.preheader.new ], [ %niter.next.7, %.lr.ph ]
  %45 = mul i64 %39, %indvar
  %scevgep = getelementptr i8, ptr %43, i64 %45
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next = or disjoint i64 %indvar, 1
  %46 = mul i64 %39, %indvar.next
  %scevgep.1 = getelementptr i8, ptr %43, i64 %46
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.1, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.1 = or disjoint i64 %indvar, 2
  %47 = mul i64 %39, %indvar.next.1
  %scevgep.2 = getelementptr i8, ptr %43, i64 %47
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.2, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.2 = or disjoint i64 %indvar, 3
  %48 = mul i64 %39, %indvar.next.2
  %scevgep.3 = getelementptr i8, ptr %43, i64 %48
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.3, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.3 = or disjoint i64 %indvar, 4
  %49 = mul i64 %39, %indvar.next.3
  %scevgep.4 = getelementptr i8, ptr %43, i64 %49
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.4, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.4 = or disjoint i64 %indvar, 5
  %50 = mul i64 %39, %indvar.next.4
  %scevgep.5 = getelementptr i8, ptr %43, i64 %50
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.5, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.5 = or disjoint i64 %indvar, 6
  %51 = mul i64 %39, %indvar.next.5
  %scevgep.6 = getelementptr i8, ptr %43, i64 %51
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.6, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.6 = or disjoint i64 %indvar, 7
  %52 = mul i64 %39, %indvar.next.6
  %scevgep.7 = getelementptr i8, ptr %43, i64 %52
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.7, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.7 = add nuw nsw i64 %indvar, 8
  %niter.next.7 = add i64 %niter, 8
  %niter.ncmp.7 = icmp eq i64 %niter.next.7, %unroll_iter
  br i1 %niter.ncmp.7, label %._crit_edge663.unr-lcssa, label %.lr.ph, !llvm.loop !11

._crit_edge663.unr-lcssa:                         ; preds = %.lr.ph, %.lr.ph.preheader
  %indvar.unr = phi i64 [ 0, %.lr.ph.preheader ], [ %indvar.next.7, %.lr.ph ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %._crit_edge663, label %.lr.ph.epil

.lr.ph.epil:                                      ; preds = %._crit_edge663.unr-lcssa, %.lr.ph.epil
  %indvar.epil = phi i64 [ %indvar.next.epil, %.lr.ph.epil ], [ %indvar.unr, %._crit_edge663.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.lr.ph.epil ], [ 0, %._crit_edge663.unr-lcssa ]
  %53 = mul i64 %39, %indvar.epil
  %scevgep.epil = getelementptr i8, ptr %43, i64 %53
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.epil, i8 0, i64 %41, i1 false), !tbaa !9
  %indvar.next.epil = add nuw nsw i64 %indvar.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %._crit_edge663, label %.lr.ph.epil, !llvm.loop !13

._crit_edge663:                                   ; preds = %.lr.ph.epil, %._crit_edge663.unr-lcssa
  %54 = add i32 %21, %42
  store i32 %54, ptr %13, align 4, !tbaa !5
  %. = tail call i32 @llvm.smin.i32(i32 %21, i32 %24)
  %.not615666 = icmp slt i32 %., 1
  br i1 %.not615666, label %81, label %.lr.ph669

.lr.ph669:                                        ; preds = %._crit_edge663
  %55 = add i32 %18, 1
  %56 = zext nneg i32 %. to i64
  %xtraiter788 = and i64 %56, 1
  %57 = icmp eq i32 %., 1
  br i1 %57, label %._crit_edge670.unr-lcssa, label %.lr.ph669.new

.lr.ph669.new:                                    ; preds = %.lr.ph669
  %unroll_iter792 = and i64 %56, 2147483646
  br label %58

58:                                               ; preds = %58, %.lr.ph669.new
  %indvars.iv722 = phi i64 [ 1, %.lr.ph669.new ], [ %indvars.iv.next723.1, %58 ]
  %niter793 = phi i64 [ 0, %.lr.ph669.new ], [ %niter793.next.1, %58 ]
  %59 = trunc nuw nsw i64 %indvars.iv722 to i32
  %60 = mul i32 %55, %59
  %61 = getelementptr inbounds double, ptr %17, i64 %indvars.iv722
  %62 = load double, ptr %61, align 8, !tbaa !9
  %63 = sext i32 %60 to i64
  %64 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %63
  store double %62, ptr %64, align 8, !tbaa !15
  %65 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %63, i32 1
  store double 0.000000e+00, ptr %65, align 8, !tbaa !17
  %66 = trunc i64 %indvars.iv722 to i32
  %67 = add i32 %66, 1
  %68 = mul i32 %55, %67
  %69 = getelementptr double, ptr %4, i64 %indvars.iv722
  %70 = load double, ptr %69, align 8, !tbaa !9
  %71 = sext i32 %68 to i64
  %72 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %71
  store double %70, ptr %72, align 8, !tbaa !15
  %73 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %71, i32 1
  store double 0.000000e+00, ptr %73, align 8, !tbaa !17
  %indvars.iv.next723.1 = add nuw nsw i64 %indvars.iv722, 2
  %niter793.next.1 = add i64 %niter793, 2
  %niter793.ncmp.1 = icmp eq i64 %niter793.next.1, %unroll_iter792
  br i1 %niter793.ncmp.1, label %._crit_edge670.unr-lcssa, label %58, !llvm.loop !18

._crit_edge670.unr-lcssa:                         ; preds = %58, %.lr.ph669
  %.lcssa787.ph = phi i32 [ poison, %.lr.ph669 ], [ %68, %58 ]
  %indvars.iv722.unr = phi i64 [ 1, %.lr.ph669 ], [ %indvars.iv.next723.1, %58 ]
  %lcmp.mod790.not = icmp eq i64 %xtraiter788, 0
  br i1 %lcmp.mod790.not, label %._crit_edge670, label %._crit_edge670.epilog-lcssa

._crit_edge670.epilog-lcssa:                      ; preds = %._crit_edge670.unr-lcssa
  %74 = trunc nuw nsw i64 %indvars.iv722.unr to i32
  %75 = mul i32 %55, %74
  %76 = getelementptr inbounds double, ptr %17, i64 %indvars.iv722.unr
  %77 = load double, ptr %76, align 8, !tbaa !9
  %78 = sext i32 %75 to i64
  %79 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %78
  store double %77, ptr %79, align 8, !tbaa !15
  %80 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %78, i32 1
  store double 0.000000e+00, ptr %80, align 8, !tbaa !17
  br label %._crit_edge670

._crit_edge670:                                   ; preds = %._crit_edge670.unr-lcssa, %._crit_edge670.epilog-lcssa
  %.lcssa787 = phi i32 [ %.lcssa787.ph, %._crit_edge670.unr-lcssa ], [ %75, %._crit_edge670.epilog-lcssa ]
  store i32 %.lcssa787, ptr %12, align 4, !tbaa !5
  br label %81

81:                                               ; preds = %._crit_edge670, %._crit_edge663
  %82 = or i32 %27, %29
  %or.cond775 = icmp eq i32 %82, 0
  br i1 %or.cond775, label %.loopexit653, label %.lr.ph682

.lr.ph682:                                        ; preds = %81
  %83 = getelementptr inbounds i8, ptr %14, i64 8
  %84 = getelementptr inbounds i8, ptr %8, i64 16
  %85 = add i32 %18, 1
  %86 = tail call i32 @llvm.umin.i32(i32 %24, i32 %21)
  %87 = zext nneg i32 %86 to i64
  br label %88

88:                                               ; preds = %.lr.ph682, %212
  %indvars.iv727 = phi i64 [ %87, %.lr.ph682 ], [ %indvars.iv.next728, %212 ]
  %89 = load i32, ptr %0, align 4, !tbaa !5
  %90 = sext i32 %89 to i64
  %91 = icmp slt i64 %indvars.iv727, %90
  br i1 %91, label %92, label %150

92:                                               ; preds = %88
  %93 = trunc nuw nsw i64 %indvars.iv727 to i32
  %reass.sub = sub i32 %89, %93
  %94 = add i32 %reass.sub, 1
  store i32 %94, ptr %11, align 4, !tbaa !5
  call void @zlarnv_(ptr noundef nonnull @c__3, ptr noundef %7, ptr noundef nonnull %11, ptr noundef %8) #7
  %95 = load i32, ptr %0, align 4, !tbaa !5
  %reass.sub699 = sub i32 %95, %93
  %96 = add i32 %reass.sub699, 1
  store i32 %96, ptr %11, align 4, !tbaa !5
  %97 = call double @dznrm2_(ptr noundef nonnull %11, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %98 = call { double, double } @Cd(ptr noundef %8)
  %99 = extractvalue { double, double } %98, 0
  %100 = extractvalue { double, double } %98, 1
  %101 = call double @cabs(double noundef %99, double noundef %100) #7
  %102 = fdiv double %97, %101
  %103 = load <2 x double>, ptr %8, align 8, !tbaa !9
  %104 = insertelement <2 x double> poison, double %102, i64 0
  %105 = shufflevector <2 x double> %104, <2 x double> poison, <2 x i32> zeroinitializer
  %106 = fmul <2 x double> %105, %103
  store <2 x double> %106, ptr %14, align 16, !tbaa !9
  store <2 x double> %106, ptr %15, align 16, !tbaa !9
  %107 = fcmp oeq double %97, 0.000000e+00
  br i1 %107, label %135, label %108

108:                                              ; preds = %92
  %109 = fadd <2 x double> %103, %106
  store <2 x double> %109, ptr %14, align 16, !tbaa !9
  store <2 x double> %109, ptr %16, align 16, !tbaa !9
  %110 = load i32, ptr %0, align 4, !tbaa !5
  %111 = sub nsw i32 %110, %93
  store i32 %111, ptr %11, align 4, !tbaa !5
  %112 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %113 = extractvalue { double, double } %112, 0
  %114 = extractvalue { double, double } %112, 1
  %115 = call { double, double } @Cd(ptr noundef nonnull %16)
  %116 = extractvalue { double, double } %115, 0
  %117 = extractvalue { double, double } %115, 1
  %118 = call { double, double } @__divdc3(double noundef %113, double noundef %114, double noundef %116, double noundef %117) #7
  %119 = extractvalue { double, double } %118, 0
  %120 = extractvalue { double, double } %118, 1
  %121 = call ptr @_pCd(ptr noundef nonnull %14)
  %122 = getelementptr inbounds i8, ptr %121, i64 8
  store double %119, ptr %121, align 8
  store double %120, ptr %122, align 8
  call void @zscal_(ptr noundef nonnull %11, ptr noundef nonnull %14, ptr noundef nonnull %84, ptr noundef nonnull @c__1) #7
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %8, align 8, !tbaa !9
  %123 = call { double, double } @Cd(ptr noundef nonnull %16)
  %124 = extractvalue { double, double } %123, 0
  %125 = extractvalue { double, double } %123, 1
  %126 = call { double, double } @Cd(ptr noundef nonnull %15)
  %127 = extractvalue { double, double } %126, 0
  %128 = extractvalue { double, double } %126, 1
  %129 = call { double, double } @__divdc3(double noundef %124, double noundef %125, double noundef %127, double noundef %128) #7
  %130 = extractvalue { double, double } %129, 0
  %131 = extractvalue { double, double } %129, 1
  %132 = call ptr @_pCd(ptr noundef nonnull %14)
  %133 = getelementptr inbounds i8, ptr %132, i64 8
  store double %130, ptr %132, align 8
  store double %131, ptr %133, align 8
  %134 = load double, ptr %14, align 16, !tbaa !15
  br label %135

135:                                              ; preds = %92, %108
  %.sroa.011.0 = phi double [ %134, %108 ], [ 0.000000e+00, %92 ]
  %136 = load i32, ptr %0, align 4, !tbaa !5
  %reass.sub700 = sub i32 %136, %93
  %137 = add i32 %reass.sub700, 1
  store i32 %137, ptr %11, align 4, !tbaa !5
  %138 = load i32, ptr %1, align 4, !tbaa !5
  %reass.sub701 = sub i32 %138, %93
  %139 = add i32 %reass.sub701, 1
  store i32 %139, ptr %12, align 4, !tbaa !5
  %140 = mul i32 %85, %93
  %141 = sext i32 %140 to i64
  %142 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %141
  %143 = sext i32 %136 to i64
  %gep = getelementptr %struct.doublecomplex, ptr %8, i64 %143
  call void @zgemv_(ptr noundef nonnull @.str.1, ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull @c_b2, ptr noundef %142, ptr noundef nonnull %6, ptr noundef nonnull %8, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %gep, ptr noundef nonnull @c__1) #7
  %144 = load i32, ptr %0, align 4, !tbaa !5
  %reass.sub702 = sub i32 %144, %93
  %145 = add i32 %reass.sub702, 1
  store i32 %145, ptr %11, align 4, !tbaa !5
  %146 = load i32, ptr %1, align 4, !tbaa !5
  %reass.sub703 = sub i32 %146, %93
  %147 = add i32 %reass.sub703, 1
  store i32 %147, ptr %12, align 4, !tbaa !5
  %148 = fneg double %.sroa.011.0
  store double %148, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %83, align 8, !tbaa !17
  %149 = sext i32 %144 to i64
  %gep673 = getelementptr %struct.doublecomplex, ptr %8, i64 %149
  call void @zgerc_(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef nonnull %8, ptr noundef nonnull @c__1, ptr noundef %gep673, ptr noundef nonnull @c__1, ptr noundef %142, ptr noundef nonnull %6) #7
  br label %150

150:                                              ; preds = %135, %88
  %151 = load i32, ptr %1, align 4, !tbaa !5
  %152 = sext i32 %151 to i64
  %153 = icmp slt i64 %indvars.iv727, %152
  br i1 %153, label %154, label %212

154:                                              ; preds = %150
  %155 = trunc nuw nsw i64 %indvars.iv727 to i32
  %reass.sub704 = sub i32 %151, %155
  %156 = add i32 %reass.sub704, 1
  store i32 %156, ptr %11, align 4, !tbaa !5
  call void @zlarnv_(ptr noundef nonnull @c__3, ptr noundef %7, ptr noundef nonnull %11, ptr noundef %8) #7
  %157 = load i32, ptr %1, align 4, !tbaa !5
  %reass.sub705 = sub i32 %157, %155
  %158 = add i32 %reass.sub705, 1
  store i32 %158, ptr %11, align 4, !tbaa !5
  %159 = call double @dznrm2_(ptr noundef nonnull %11, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %160 = call { double, double } @Cd(ptr noundef %8)
  %161 = extractvalue { double, double } %160, 0
  %162 = extractvalue { double, double } %160, 1
  %163 = call double @cabs(double noundef %161, double noundef %162) #7
  %164 = fdiv double %159, %163
  %165 = load <2 x double>, ptr %8, align 8, !tbaa !9
  %166 = insertelement <2 x double> poison, double %164, i64 0
  %167 = shufflevector <2 x double> %166, <2 x double> poison, <2 x i32> zeroinitializer
  %168 = fmul <2 x double> %167, %165
  store <2 x double> %168, ptr %14, align 16, !tbaa !9
  store <2 x double> %168, ptr %15, align 16, !tbaa !9
  %169 = fcmp oeq double %159, 0.000000e+00
  br i1 %169, label %197, label %170

170:                                              ; preds = %154
  %171 = fadd <2 x double> %165, %168
  store <2 x double> %171, ptr %14, align 16, !tbaa !9
  store <2 x double> %171, ptr %16, align 16, !tbaa !9
  %172 = load i32, ptr %1, align 4, !tbaa !5
  %173 = sub nsw i32 %172, %155
  store i32 %173, ptr %11, align 4, !tbaa !5
  %174 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %175 = extractvalue { double, double } %174, 0
  %176 = extractvalue { double, double } %174, 1
  %177 = call { double, double } @Cd(ptr noundef nonnull %16)
  %178 = extractvalue { double, double } %177, 0
  %179 = extractvalue { double, double } %177, 1
  %180 = call { double, double } @__divdc3(double noundef %175, double noundef %176, double noundef %178, double noundef %179) #7
  %181 = extractvalue { double, double } %180, 0
  %182 = extractvalue { double, double } %180, 1
  %183 = call ptr @_pCd(ptr noundef nonnull %14)
  %184 = getelementptr inbounds i8, ptr %183, i64 8
  store double %181, ptr %183, align 8
  store double %182, ptr %184, align 8
  call void @zscal_(ptr noundef nonnull %11, ptr noundef nonnull %14, ptr noundef nonnull %84, ptr noundef nonnull @c__1) #7
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %8, align 8, !tbaa !9
  %185 = call { double, double } @Cd(ptr noundef nonnull %16)
  %186 = extractvalue { double, double } %185, 0
  %187 = extractvalue { double, double } %185, 1
  %188 = call { double, double } @Cd(ptr noundef nonnull %15)
  %189 = extractvalue { double, double } %188, 0
  %190 = extractvalue { double, double } %188, 1
  %191 = call { double, double } @__divdc3(double noundef %186, double noundef %187, double noundef %189, double noundef %190) #7
  %192 = extractvalue { double, double } %191, 0
  %193 = extractvalue { double, double } %191, 1
  %194 = call ptr @_pCd(ptr noundef nonnull %14)
  %195 = getelementptr inbounds i8, ptr %194, i64 8
  store double %192, ptr %194, align 8
  store double %193, ptr %195, align 8
  %196 = load double, ptr %14, align 16, !tbaa !15
  br label %197

197:                                              ; preds = %154, %170
  %.sroa.011.1 = phi double [ %196, %170 ], [ 0.000000e+00, %154 ]
  %198 = load i32, ptr %0, align 4, !tbaa !5
  %reass.sub706 = sub i32 %198, %155
  %199 = add i32 %reass.sub706, 1
  store i32 %199, ptr %11, align 4, !tbaa !5
  %200 = load i32, ptr %1, align 4, !tbaa !5
  %reass.sub707 = sub i32 %200, %155
  %201 = add i32 %reass.sub707, 1
  store i32 %201, ptr %12, align 4, !tbaa !5
  %202 = mul i32 %85, %155
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %203
  %205 = sext i32 %200 to i64
  %gep675 = getelementptr %struct.doublecomplex, ptr %8, i64 %205
  call void @zgemv_(ptr noundef nonnull @.str.2, ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull @c_b2, ptr noundef %204, ptr noundef nonnull %6, ptr noundef nonnull %8, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %gep675, ptr noundef nonnull @c__1) #7
  %206 = load i32, ptr %0, align 4, !tbaa !5
  %reass.sub708 = sub i32 %206, %155
  %207 = add i32 %reass.sub708, 1
  store i32 %207, ptr %11, align 4, !tbaa !5
  %208 = load i32, ptr %1, align 4, !tbaa !5
  %reass.sub709 = sub i32 %208, %155
  %209 = add i32 %reass.sub709, 1
  store i32 %209, ptr %12, align 4, !tbaa !5
  %210 = fneg double %.sroa.011.1
  store double %210, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %83, align 8, !tbaa !17
  %211 = sext i32 %208 to i64
  %gep677 = getelementptr %struct.doublecomplex, ptr %8, i64 %211
  call void @zgerc_(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef %gep677, ptr noundef nonnull @c__1, ptr noundef nonnull %8, ptr noundef nonnull @c__1, ptr noundef %204, ptr noundef nonnull %6) #7
  br label %212

212:                                              ; preds = %150, %197
  %indvars.iv.next728 = add nsw i64 %indvars.iv727, -1
  %213 = icmp sgt i64 %indvars.iv727, 1
  br i1 %213, label %88, label %._crit_edge683, !llvm.loop !19

._crit_edge683:                                   ; preds = %212
  %.pre = load i32, ptr %0, align 4, !tbaa !5
  %.pre742 = load i32, ptr %2, align 4, !tbaa !5
  %.pre743 = load i32, ptr %1, align 4, !tbaa !5
  %.pre744 = load i32, ptr %3, align 4, !tbaa !5
  %214 = xor i32 %.pre742, -1
  %215 = add i32 %.pre, %214
  %216 = xor i32 %.pre744, -1
  %217 = add i32 %.pre743, %216
  store i32 %217, ptr %13, align 4, !tbaa !5
  %218 = call i32 @llvm.smax.i32(i32 %215, i32 %217)
  store i32 %218, ptr %11, align 4, !tbaa !5
  %.not618694 = icmp slt i32 %218, 1
  br i1 %.not618694, label %.loopexit653, label %.lr.ph698

.lr.ph698:                                        ; preds = %._crit_edge683
  %219 = getelementptr inbounds i8, ptr %14, i64 8
  %220 = getelementptr inbounds i8, ptr %15, i64 8
  %221 = shl nsw i64 %19, 4
  %scevgep729 = getelementptr i8, ptr %5, i64 %221
  %222 = add i32 %18, 2
  %223 = add i32 %18, 1
  %224 = sext i32 %18 to i64
  %225 = add i32 %18, 1
  %226 = add i32 %18, 1
  br label %227

227:                                              ; preds = %.lr.ph698, %.loopexit
  %228 = phi i32 [ %.pre743, %.lr.ph698 ], [ %679, %.loopexit ]
  %229 = phi i32 [ %.pre, %.lr.ph698 ], [ %.pre755, %.loopexit ]
  %indvars.iv733 = phi i64 [ 1, %.lr.ph698 ], [ %indvars.iv.next734, %.loopexit ]
  %indvar730 = phi i32 [ 0, %.lr.ph698 ], [ %indvar.next731, %.loopexit ]
  %indvars741 = trunc i64 %indvars.iv733 to i32
  %230 = mul i32 %223, %indvar730
  %231 = add i32 %222, %230
  %232 = load i32, ptr %2, align 4, !tbaa !5
  %233 = load i32, ptr %3, align 4, !tbaa !5
  %.not619 = icmp sgt i32 %232, %233
  br i1 %.not619, label %453, label %234

234:                                              ; preds = %227
  %235 = xor i32 %232, -1
  %236 = add i32 %229, %235
  %.635 = call i32 @llvm.smin.i32(i32 %236, i32 %228)
  %237 = sext i32 %.635 to i64
  %.not625 = icmp sgt i64 %indvars.iv733, %237
  br i1 %.not625, label %336, label %238

238:                                              ; preds = %234
  %239 = add i32 %232, %indvars741
  %reass.sub710 = sub i32 %229, %239
  %240 = add i32 %reass.sub710, 1
  store i32 %240, ptr %12, align 4, !tbaa !5
  %241 = mul nsw i64 %indvars.iv733, %224
  %242 = sext i32 %239 to i64
  %243 = getelementptr %struct.doublecomplex, ptr %20, i64 %241
  %244 = getelementptr %struct.doublecomplex, ptr %243, i64 %242
  %245 = call double @dznrm2_(ptr noundef nonnull %12, ptr noundef %244, ptr noundef nonnull @c__1) #7
  %246 = load i32, ptr %2, align 4, !tbaa !5
  %247 = mul i32 %225, %indvars741
  %248 = add i32 %247, %246
  %249 = sext i32 %248 to i64
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %249
  %251 = call { double, double } @Cd(ptr noundef %250)
  %252 = extractvalue { double, double } %251, 0
  %253 = extractvalue { double, double } %251, 1
  %254 = call double @cabs(double noundef %252, double noundef %253) #7
  %255 = fdiv double %245, %254
  %256 = load i32, ptr %2, align 4, !tbaa !5
  %257 = add i32 %256, %indvars741
  %258 = trunc nsw i64 %241 to i32
  %259 = add nsw i32 %257, %258
  %260 = sext i32 %259 to i64
  %261 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %260
  %262 = load <2 x double>, ptr %261, align 8, !tbaa !9
  %263 = insertelement <2 x double> poison, double %255, i64 0
  %264 = shufflevector <2 x double> %263, <2 x double> poison, <2 x i32> zeroinitializer
  %265 = fmul <2 x double> %264, %262
  store <2 x double> %265, ptr %14, align 16, !tbaa !9
  store <2 x double> %265, ptr %15, align 16, !tbaa !9
  %266 = fcmp oeq double %245, 0.000000e+00
  br i1 %266, label %304, label %267

267:                                              ; preds = %238
  %268 = fadd <2 x double> %262, %265
  store <2 x double> %268, ptr %14, align 16, !tbaa !9
  store <2 x double> %268, ptr %16, align 16, !tbaa !9
  %269 = load i32, ptr %0, align 4, !tbaa !5
  %270 = sub i32 %269, %257
  store i32 %270, ptr %12, align 4, !tbaa !5
  %271 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %272 = extractvalue { double, double } %271, 0
  %273 = extractvalue { double, double } %271, 1
  %274 = call { double, double } @Cd(ptr noundef nonnull %16)
  %275 = extractvalue { double, double } %274, 0
  %276 = extractvalue { double, double } %274, 1
  %277 = call { double, double } @__divdc3(double noundef %272, double noundef %273, double noundef %275, double noundef %276) #7
  %278 = extractvalue { double, double } %277, 0
  %279 = extractvalue { double, double } %277, 1
  %280 = call ptr @_pCd(ptr noundef nonnull %14)
  %281 = getelementptr inbounds i8, ptr %280, i64 8
  store double %278, ptr %280, align 8
  store double %279, ptr %281, align 8
  %282 = load i32, ptr %2, align 4, !tbaa !5
  %283 = add nuw i32 %indvars741, 1
  %284 = add i32 %283, %258
  %285 = add i32 %284, %282
  %286 = sext i32 %285 to i64
  %287 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %286
  call void @zscal_(ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef %287, ptr noundef nonnull @c__1) #7
  %288 = load i32, ptr %2, align 4, !tbaa !5
  %289 = add i32 %247, %288
  store i32 %289, ptr %12, align 4, !tbaa !5
  %290 = sext i32 %289 to i64
  %291 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %290
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %291, align 8, !tbaa !9
  %292 = call { double, double } @Cd(ptr noundef nonnull %16)
  %293 = extractvalue { double, double } %292, 0
  %294 = extractvalue { double, double } %292, 1
  %295 = call { double, double } @Cd(ptr noundef nonnull %15)
  %296 = extractvalue { double, double } %295, 0
  %297 = extractvalue { double, double } %295, 1
  %298 = call { double, double } @__divdc3(double noundef %293, double noundef %294, double noundef %296, double noundef %297) #7
  %299 = extractvalue { double, double } %298, 0
  %300 = extractvalue { double, double } %298, 1
  %301 = call ptr @_pCd(ptr noundef nonnull %14)
  %302 = getelementptr inbounds i8, ptr %301, i64 8
  store double %299, ptr %301, align 8
  store double %300, ptr %302, align 8
  %303 = load double, ptr %14, align 16, !tbaa !15
  %.pre745 = load i32, ptr %2, align 4, !tbaa !5
  %.pre765 = add i32 %.pre745, %indvars741
  br label %304

304:                                              ; preds = %238, %267
  %.pre-phi766 = phi i32 [ %257, %238 ], [ %.pre765, %267 ]
  %.sroa.011.2 = phi double [ 0.000000e+00, %238 ], [ %303, %267 ]
  %305 = load i32, ptr %0, align 4, !tbaa !5
  %306 = add i32 %305, 1
  %307 = sub i32 %306, %.pre-phi766
  store i32 %307, ptr %12, align 4, !tbaa !5
  %308 = load i32, ptr %1, align 4, !tbaa !5
  %309 = sub nsw i32 %308, %indvars741
  store i32 %309, ptr %13, align 4, !tbaa !5
  %310 = add nuw nsw i64 %indvars.iv733, 1
  %311 = mul nsw i64 %310, %224
  %312 = sext i32 %.pre-phi766 to i64
  %313 = getelementptr %struct.doublecomplex, ptr %20, i64 %311
  %314 = getelementptr %struct.doublecomplex, ptr %313, i64 %312
  %315 = getelementptr %struct.doublecomplex, ptr %20, i64 %241
  %316 = getelementptr %struct.doublecomplex, ptr %315, i64 %312
  call void @zgemv_(ptr noundef nonnull @.str.1, ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull @c_b2, ptr noundef %314, ptr noundef nonnull %6, ptr noundef %316, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %317 = load i32, ptr %0, align 4, !tbaa !5
  %318 = load i32, ptr %2, align 4, !tbaa !5
  %319 = add i32 %318, %indvars741
  %320 = add i32 %317, 1
  %321 = sub i32 %320, %319
  store i32 %321, ptr %12, align 4, !tbaa !5
  %322 = load i32, ptr %1, align 4, !tbaa !5
  %323 = sub nsw i32 %322, %indvars741
  store i32 %323, ptr %13, align 4, !tbaa !5
  %324 = fneg double %.sroa.011.2
  store double %324, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %219, align 8, !tbaa !17
  %325 = sext i32 %319 to i64
  %326 = getelementptr %struct.doublecomplex, ptr %20, i64 %241
  %327 = getelementptr %struct.doublecomplex, ptr %326, i64 %325
  %328 = getelementptr %struct.doublecomplex, ptr %20, i64 %311
  %329 = getelementptr %struct.doublecomplex, ptr %328, i64 %325
  call void @zgerc_(ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef %327, ptr noundef nonnull @c__1, ptr noundef %8, ptr noundef nonnull @c__1, ptr noundef %329, ptr noundef nonnull %6) #7
  %330 = load i32, ptr %2, align 4, !tbaa !5
  %331 = add i32 %247, %330
  %332 = load <2 x double>, ptr %15, align 16, !tbaa !9
  %333 = fneg <2 x double> %332
  store <2 x double> %333, ptr %14, align 16, !tbaa !9
  %334 = sext i32 %331 to i64
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %334
  store <2 x double> %333, ptr %335, align 8, !tbaa !9
  %.pre746 = load i32, ptr %1, align 4, !tbaa !5
  %.pre747 = load i32, ptr %3, align 4, !tbaa !5
  %.pre748 = load i32, ptr %0, align 4, !tbaa !5
  br label %336

336:                                              ; preds = %304, %234
  %337 = phi i32 [ %.pre748, %304 ], [ %229, %234 ]
  %338 = phi i32 [ %.pre747, %304 ], [ %233, %234 ]
  %339 = phi i32 [ %.pre746, %304 ], [ %228, %234 ]
  %340 = xor i32 %338, -1
  %341 = add i32 %339, %340
  store i32 %341, ptr %12, align 4, !tbaa !5
  %.636 = call i32 @llvm.smin.i32(i32 %341, i32 %337)
  %342 = sext i32 %.636 to i64
  %.not627 = icmp sgt i64 %indvars.iv733, %342
  br i1 %.not627, label %678, label %343

343:                                              ; preds = %336
  %344 = add i32 %338, %indvars741
  %345 = add i32 %339, 1
  %346 = sub i32 %345, %344
  store i32 %346, ptr %12, align 4, !tbaa !5
  %347 = mul nsw i32 %344, %18
  %348 = sext i32 %347 to i64
  %349 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %350 = getelementptr %struct.doublecomplex, ptr %349, i64 %348
  %351 = call double @dznrm2_(ptr noundef nonnull %12, ptr noundef %350, ptr noundef nonnull %6) #7
  %352 = load i32, ptr %3, align 4, !tbaa !5
  %353 = add nsw i32 %352, %indvars741
  %354 = mul nsw i32 %353, %18
  %355 = sext i32 %354 to i64
  %356 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %357 = getelementptr %struct.doublecomplex, ptr %356, i64 %355
  %358 = call { double, double } @Cd(ptr noundef %357)
  %359 = extractvalue { double, double } %358, 0
  %360 = extractvalue { double, double } %358, 1
  %361 = call double @cabs(double noundef %359, double noundef %360) #7
  %362 = fdiv double %351, %361
  %363 = load i32, ptr %3, align 4, !tbaa !5
  %364 = add i32 %363, %indvars741
  %365 = mul nsw i32 %364, %18
  %366 = add nsw i32 %365, %indvars741
  %367 = sext i32 %366 to i64
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %367
  %369 = load <2 x double>, ptr %368, align 8, !tbaa !9
  %370 = insertelement <2 x double> poison, double %362, i64 0
  %371 = shufflevector <2 x double> %370, <2 x double> poison, <2 x i32> zeroinitializer
  %372 = fmul <2 x double> %371, %369
  store <2 x double> %372, ptr %14, align 16, !tbaa !9
  store <2 x double> %372, ptr %15, align 16, !tbaa !9
  %373 = fcmp oeq double %351, 0.000000e+00
  br i1 %373, label %._crit_edge767, label %374

._crit_edge767:                                   ; preds = %343
  %.pre771 = add nuw nsw i64 %indvars.iv733, 1
  br label %415

374:                                              ; preds = %343
  %375 = fadd <2 x double> %369, %372
  store <2 x double> %375, ptr %14, align 16, !tbaa !9
  store <2 x double> %375, ptr %16, align 16, !tbaa !9
  %376 = load i32, ptr %1, align 4, !tbaa !5
  %377 = sub i32 %376, %364
  store i32 %377, ptr %12, align 4, !tbaa !5
  %378 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %379 = extractvalue { double, double } %378, 0
  %380 = extractvalue { double, double } %378, 1
  %381 = call { double, double } @Cd(ptr noundef nonnull %16)
  %382 = extractvalue { double, double } %381, 0
  %383 = extractvalue { double, double } %381, 1
  %384 = call { double, double } @__divdc3(double noundef %379, double noundef %380, double noundef %382, double noundef %383) #7
  %385 = extractvalue { double, double } %384, 0
  %386 = extractvalue { double, double } %384, 1
  %387 = call ptr @_pCd(ptr noundef nonnull %14)
  %388 = getelementptr inbounds i8, ptr %387, i64 8
  store double %385, ptr %387, align 8
  store double %386, ptr %388, align 8
  %389 = load i32, ptr %3, align 4, !tbaa !5
  %390 = add nuw nsw i64 %indvars.iv733, 1
  %391 = trunc nuw i64 %390 to i32
  %392 = add i32 %389, %391
  %393 = mul nsw i32 %392, %18
  %394 = sext i32 %393 to i64
  %395 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %396 = getelementptr %struct.doublecomplex, ptr %395, i64 %394
  call void @zscal_(ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef %396, ptr noundef nonnull %6) #7
  %397 = load i32, ptr %3, align 4, !tbaa !5
  %398 = add nsw i32 %397, %indvars741
  %399 = mul nsw i32 %398, %18
  %400 = add nsw i32 %399, %indvars741
  store i32 %400, ptr %12, align 4, !tbaa !5
  %401 = sext i32 %400 to i64
  %402 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %401
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %402, align 8, !tbaa !9
  %403 = call { double, double } @Cd(ptr noundef nonnull %16)
  %404 = extractvalue { double, double } %403, 0
  %405 = extractvalue { double, double } %403, 1
  %406 = call { double, double } @Cd(ptr noundef nonnull %15)
  %407 = extractvalue { double, double } %406, 0
  %408 = extractvalue { double, double } %406, 1
  %409 = call { double, double } @__divdc3(double noundef %404, double noundef %405, double noundef %407, double noundef %408) #7
  %410 = extractvalue { double, double } %409, 0
  %411 = extractvalue { double, double } %409, 1
  %412 = call ptr @_pCd(ptr noundef nonnull %14)
  %413 = getelementptr inbounds i8, ptr %412, i64 8
  store double %410, ptr %412, align 8
  store double %411, ptr %413, align 8
  %414 = load double, ptr %14, align 16, !tbaa !15
  %.pre749 = load i32, ptr %3, align 4, !tbaa !5
  %.pre761 = add i32 %.pre749, %indvars741
  %.pre763 = mul nsw i32 %.pre761, %18
  br label %415

415:                                              ; preds = %._crit_edge767, %374
  %.pre-phi772 = phi i64 [ %.pre771, %._crit_edge767 ], [ %390, %374 ]
  %.pre-phi764 = phi i32 [ %365, %._crit_edge767 ], [ %.pre763, %374 ]
  %.pre-phi762 = phi i32 [ %364, %._crit_edge767 ], [ %.pre761, %374 ]
  %.sroa.011.3 = phi double [ 0.000000e+00, %._crit_edge767 ], [ %414, %374 ]
  %416 = load i32, ptr %1, align 4, !tbaa !5
  %417 = add i32 %416, 1
  %418 = sub i32 %417, %.pre-phi762
  store i32 %418, ptr %12, align 4, !tbaa !5
  %419 = sext i32 %.pre-phi764 to i64
  %420 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %421 = getelementptr %struct.doublecomplex, ptr %420, i64 %419
  call void @zlacgv_(ptr noundef nonnull %12, ptr noundef %421, ptr noundef nonnull %6) #7
  %422 = load i32, ptr %0, align 4, !tbaa !5
  %423 = sub nsw i32 %422, %indvars741
  store i32 %423, ptr %12, align 4, !tbaa !5
  %424 = load i32, ptr %1, align 4, !tbaa !5
  %425 = load i32, ptr %3, align 4, !tbaa !5
  %426 = add i32 %425, %indvars741
  %427 = add i32 %424, 1
  %428 = sub i32 %427, %426
  store i32 %428, ptr %13, align 4, !tbaa !5
  %429 = mul nsw i32 %426, %18
  %430 = sext i32 %429 to i64
  %431 = getelementptr %struct.doublecomplex, ptr %20, i64 %.pre-phi772
  %432 = getelementptr %struct.doublecomplex, ptr %431, i64 %430
  %433 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %434 = getelementptr %struct.doublecomplex, ptr %433, i64 %430
  call void @zgemv_(ptr noundef nonnull @.str.2, ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull @c_b2, ptr noundef %432, ptr noundef nonnull %6, ptr noundef %434, ptr noundef nonnull %6, ptr noundef nonnull @c_b1, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %435 = load i32, ptr %0, align 4, !tbaa !5
  %436 = sub nsw i32 %435, %indvars741
  store i32 %436, ptr %12, align 4, !tbaa !5
  %437 = load i32, ptr %1, align 4, !tbaa !5
  %438 = load i32, ptr %3, align 4, !tbaa !5
  %439 = add i32 %438, %indvars741
  %440 = add i32 %437, 1
  %441 = sub i32 %440, %439
  store i32 %441, ptr %13, align 4, !tbaa !5
  %442 = fneg double %.sroa.011.3
  store double %442, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %219, align 8, !tbaa !17
  %443 = mul nsw i32 %439, %18
  %444 = sext i32 %443 to i64
  %445 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %446 = getelementptr %struct.doublecomplex, ptr %445, i64 %444
  %447 = getelementptr %struct.doublecomplex, ptr %20, i64 %.pre-phi772
  %448 = getelementptr %struct.doublecomplex, ptr %447, i64 %444
  call void @zgerc_(ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef %8, ptr noundef nonnull @c__1, ptr noundef %446, ptr noundef nonnull %6, ptr noundef %448, ptr noundef nonnull %6) #7
  %449 = load i32, ptr %3, align 4, !tbaa !5
  %450 = add nsw i32 %449, %indvars741
  %451 = mul nsw i32 %450, %18
  %452 = add nsw i32 %451, %indvars741
  br label %.sink.split

453:                                              ; preds = %227
  %454 = xor i32 %233, -1
  %455 = add i32 %228, %454
  %.637 = call i32 @llvm.smin.i32(i32 %455, i32 %229)
  %456 = sext i32 %.637 to i64
  %.not621 = icmp sgt i64 %indvars.iv733, %456
  br i1 %.not621, label %570, label %457

457:                                              ; preds = %453
  %458 = add i32 %233, %indvars741
  %reass.sub711 = sub i32 %228, %458
  %459 = add i32 %reass.sub711, 1
  store i32 %459, ptr %12, align 4, !tbaa !5
  %460 = mul nsw i32 %458, %18
  %461 = sext i32 %460 to i64
  %462 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %463 = getelementptr %struct.doublecomplex, ptr %462, i64 %461
  %464 = call double @dznrm2_(ptr noundef nonnull %12, ptr noundef %463, ptr noundef nonnull %6) #7
  %465 = load i32, ptr %3, align 4, !tbaa !5
  %466 = add nsw i32 %465, %indvars741
  %467 = mul nsw i32 %466, %18
  %468 = sext i32 %467 to i64
  %469 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %470 = getelementptr %struct.doublecomplex, ptr %469, i64 %468
  %471 = call { double, double } @Cd(ptr noundef %470)
  %472 = extractvalue { double, double } %471, 0
  %473 = extractvalue { double, double } %471, 1
  %474 = call double @cabs(double noundef %472, double noundef %473) #7
  %475 = fdiv double %464, %474
  %476 = load i32, ptr %3, align 4, !tbaa !5
  %477 = add i32 %476, %indvars741
  %478 = mul nsw i32 %477, %18
  %479 = add nsw i32 %478, %indvars741
  %480 = sext i32 %479 to i64
  %481 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %480
  %482 = load <2 x double>, ptr %481, align 8, !tbaa !9
  %483 = insertelement <2 x double> poison, double %475, i64 0
  %484 = shufflevector <2 x double> %483, <2 x double> poison, <2 x i32> zeroinitializer
  %485 = fmul <2 x double> %484, %482
  store <2 x double> %485, ptr %14, align 16, !tbaa !9
  store <2 x double> %485, ptr %15, align 16, !tbaa !9
  %486 = fcmp oeq double %464, 0.000000e+00
  br i1 %486, label %._crit_edge768, label %487

._crit_edge768:                                   ; preds = %457
  %.pre769 = add nuw nsw i64 %indvars.iv733, 1
  br label %528

487:                                              ; preds = %457
  %488 = fadd <2 x double> %482, %485
  store <2 x double> %488, ptr %14, align 16, !tbaa !9
  store <2 x double> %488, ptr %16, align 16, !tbaa !9
  %489 = load i32, ptr %1, align 4, !tbaa !5
  %490 = sub i32 %489, %477
  store i32 %490, ptr %12, align 4, !tbaa !5
  %491 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %492 = extractvalue { double, double } %491, 0
  %493 = extractvalue { double, double } %491, 1
  %494 = call { double, double } @Cd(ptr noundef nonnull %16)
  %495 = extractvalue { double, double } %494, 0
  %496 = extractvalue { double, double } %494, 1
  %497 = call { double, double } @__divdc3(double noundef %492, double noundef %493, double noundef %495, double noundef %496) #7
  %498 = extractvalue { double, double } %497, 0
  %499 = extractvalue { double, double } %497, 1
  %500 = call ptr @_pCd(ptr noundef nonnull %14)
  %501 = getelementptr inbounds i8, ptr %500, i64 8
  store double %498, ptr %500, align 8
  store double %499, ptr %501, align 8
  %502 = load i32, ptr %3, align 4, !tbaa !5
  %503 = add nuw nsw i64 %indvars.iv733, 1
  %504 = trunc nuw i64 %503 to i32
  %505 = add i32 %502, %504
  %506 = mul nsw i32 %505, %18
  %507 = sext i32 %506 to i64
  %508 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %509 = getelementptr %struct.doublecomplex, ptr %508, i64 %507
  call void @zscal_(ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef %509, ptr noundef nonnull %6) #7
  %510 = load i32, ptr %3, align 4, !tbaa !5
  %511 = add nsw i32 %510, %indvars741
  %512 = mul nsw i32 %511, %18
  %513 = add nsw i32 %512, %indvars741
  store i32 %513, ptr %12, align 4, !tbaa !5
  %514 = sext i32 %513 to i64
  %515 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %514
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %515, align 8, !tbaa !9
  %516 = call { double, double } @Cd(ptr noundef nonnull %16)
  %517 = extractvalue { double, double } %516, 0
  %518 = extractvalue { double, double } %516, 1
  %519 = call { double, double } @Cd(ptr noundef nonnull %15)
  %520 = extractvalue { double, double } %519, 0
  %521 = extractvalue { double, double } %519, 1
  %522 = call { double, double } @__divdc3(double noundef %517, double noundef %518, double noundef %520, double noundef %521) #7
  %523 = extractvalue { double, double } %522, 0
  %524 = extractvalue { double, double } %522, 1
  %525 = call ptr @_pCd(ptr noundef nonnull %14)
  %526 = getelementptr inbounds i8, ptr %525, i64 8
  store double %523, ptr %525, align 8
  store double %524, ptr %526, align 8
  %527 = load double, ptr %14, align 16, !tbaa !15
  %.pre750 = load i32, ptr %3, align 4, !tbaa !5
  %.pre757 = add i32 %.pre750, %indvars741
  %.pre759 = mul nsw i32 %.pre757, %18
  br label %528

528:                                              ; preds = %._crit_edge768, %487
  %.pre-phi770 = phi i64 [ %.pre769, %._crit_edge768 ], [ %503, %487 ]
  %.pre-phi760 = phi i32 [ %478, %._crit_edge768 ], [ %.pre759, %487 ]
  %.pre-phi758 = phi i32 [ %477, %._crit_edge768 ], [ %.pre757, %487 ]
  %.sroa.011.4 = phi double [ 0.000000e+00, %._crit_edge768 ], [ %527, %487 ]
  %529 = load i32, ptr %1, align 4, !tbaa !5
  %530 = add i32 %529, 1
  %531 = sub i32 %530, %.pre-phi758
  store i32 %531, ptr %12, align 4, !tbaa !5
  %532 = sext i32 %.pre-phi760 to i64
  %533 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %534 = getelementptr %struct.doublecomplex, ptr %533, i64 %532
  call void @zlacgv_(ptr noundef nonnull %12, ptr noundef %534, ptr noundef nonnull %6) #7
  %535 = load i32, ptr %0, align 4, !tbaa !5
  %536 = sub nsw i32 %535, %indvars741
  store i32 %536, ptr %12, align 4, !tbaa !5
  %537 = load i32, ptr %1, align 4, !tbaa !5
  %538 = load i32, ptr %3, align 4, !tbaa !5
  %539 = add i32 %538, %indvars741
  %540 = add i32 %537, 1
  %541 = sub i32 %540, %539
  store i32 %541, ptr %13, align 4, !tbaa !5
  %542 = mul nsw i32 %539, %18
  %543 = sext i32 %542 to i64
  %544 = getelementptr %struct.doublecomplex, ptr %20, i64 %.pre-phi770
  %545 = getelementptr %struct.doublecomplex, ptr %544, i64 %543
  %546 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %547 = getelementptr %struct.doublecomplex, ptr %546, i64 %543
  call void @zgemv_(ptr noundef nonnull @.str.2, ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull @c_b2, ptr noundef %545, ptr noundef nonnull %6, ptr noundef %547, ptr noundef nonnull %6, ptr noundef nonnull @c_b1, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %548 = load i32, ptr %0, align 4, !tbaa !5
  %549 = sub nsw i32 %548, %indvars741
  store i32 %549, ptr %12, align 4, !tbaa !5
  %550 = load i32, ptr %1, align 4, !tbaa !5
  %551 = load i32, ptr %3, align 4, !tbaa !5
  %552 = add i32 %551, %indvars741
  %553 = add i32 %550, 1
  %554 = sub i32 %553, %552
  store i32 %554, ptr %13, align 4, !tbaa !5
  %555 = fneg double %.sroa.011.4
  store double %555, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %219, align 8, !tbaa !17
  %556 = mul nsw i32 %552, %18
  %557 = sext i32 %556 to i64
  %558 = getelementptr %struct.doublecomplex, ptr %20, i64 %indvars.iv733
  %559 = getelementptr %struct.doublecomplex, ptr %558, i64 %557
  %560 = getelementptr %struct.doublecomplex, ptr %20, i64 %.pre-phi770
  %561 = getelementptr %struct.doublecomplex, ptr %560, i64 %557
  call void @zgerc_(ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef %8, ptr noundef nonnull @c__1, ptr noundef %559, ptr noundef nonnull %6, ptr noundef %561, ptr noundef nonnull %6) #7
  %562 = load i32, ptr %3, align 4, !tbaa !5
  %563 = add nsw i32 %562, %indvars741
  %564 = mul nsw i32 %563, %18
  %565 = add nsw i32 %564, %indvars741
  %566 = load <2 x double>, ptr %15, align 16, !tbaa !9
  %567 = fneg <2 x double> %566
  store <2 x double> %567, ptr %14, align 16, !tbaa !9
  %568 = sext i32 %565 to i64
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %568
  store <2 x double> %567, ptr %569, align 8, !tbaa !9
  %.pre751 = load i32, ptr %0, align 4, !tbaa !5
  %.pre752 = load i32, ptr %2, align 4, !tbaa !5
  %.pre753 = load i32, ptr %1, align 4, !tbaa !5
  br label %570

570:                                              ; preds = %528, %453
  %571 = phi i32 [ %.pre753, %528 ], [ %228, %453 ]
  %572 = phi i32 [ %.pre752, %528 ], [ %232, %453 ]
  %573 = phi i32 [ %.pre751, %528 ], [ %229, %453 ]
  %574 = xor i32 %572, -1
  %575 = add i32 %573, %574
  store i32 %575, ptr %12, align 4, !tbaa !5
  %.638 = call i32 @llvm.smin.i32(i32 %575, i32 %571)
  %576 = sext i32 %.638 to i64
  %.not623 = icmp sgt i64 %indvars.iv733, %576
  br i1 %.not623, label %678, label %577

577:                                              ; preds = %570
  %578 = add i32 %572, %indvars741
  %579 = add i32 %573, 1
  %580 = sub i32 %579, %578
  store i32 %580, ptr %12, align 4, !tbaa !5
  %581 = mul nsw i64 %indvars.iv733, %224
  %582 = sext i32 %578 to i64
  %583 = getelementptr %struct.doublecomplex, ptr %20, i64 %581
  %584 = getelementptr %struct.doublecomplex, ptr %583, i64 %582
  %585 = call double @dznrm2_(ptr noundef nonnull %12, ptr noundef %584, ptr noundef nonnull @c__1) #7
  %586 = load i32, ptr %2, align 4, !tbaa !5
  %587 = mul i32 %226, %indvars741
  %588 = add i32 %587, %586
  %589 = sext i32 %588 to i64
  %590 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %589
  %591 = call { double, double } @Cd(ptr noundef %590)
  %592 = extractvalue { double, double } %591, 0
  %593 = extractvalue { double, double } %591, 1
  %594 = call double @cabs(double noundef %592, double noundef %593) #7
  %595 = fdiv double %585, %594
  %596 = load i32, ptr %2, align 4, !tbaa !5
  %597 = add i32 %596, %indvars741
  %598 = trunc nsw i64 %581 to i32
  %599 = add nsw i32 %597, %598
  %600 = sext i32 %599 to i64
  %601 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %600
  %602 = load <2 x double>, ptr %601, align 8, !tbaa !9
  %603 = insertelement <2 x double> poison, double %595, i64 0
  %604 = shufflevector <2 x double> %603, <2 x double> poison, <2 x i32> zeroinitializer
  %605 = fmul <2 x double> %604, %602
  store <2 x double> %605, ptr %14, align 16, !tbaa !9
  store <2 x double> %605, ptr %15, align 16, !tbaa !9
  %606 = fcmp oeq double %585, 0.000000e+00
  br i1 %606, label %644, label %607

607:                                              ; preds = %577
  %608 = fadd <2 x double> %602, %605
  store <2 x double> %608, ptr %14, align 16, !tbaa !9
  store <2 x double> %608, ptr %16, align 16, !tbaa !9
  %609 = load i32, ptr %0, align 4, !tbaa !5
  %610 = sub i32 %609, %597
  store i32 %610, ptr %12, align 4, !tbaa !5
  %611 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %612 = extractvalue { double, double } %611, 0
  %613 = extractvalue { double, double } %611, 1
  %614 = call { double, double } @Cd(ptr noundef nonnull %16)
  %615 = extractvalue { double, double } %614, 0
  %616 = extractvalue { double, double } %614, 1
  %617 = call { double, double } @__divdc3(double noundef %612, double noundef %613, double noundef %615, double noundef %616) #7
  %618 = extractvalue { double, double } %617, 0
  %619 = extractvalue { double, double } %617, 1
  %620 = call ptr @_pCd(ptr noundef nonnull %14)
  %621 = getelementptr inbounds i8, ptr %620, i64 8
  store double %618, ptr %620, align 8
  store double %619, ptr %621, align 8
  %622 = load i32, ptr %2, align 4, !tbaa !5
  %623 = add nuw i32 %indvars741, 1
  %624 = add i32 %623, %598
  %625 = add i32 %624, %622
  %626 = sext i32 %625 to i64
  %627 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %626
  call void @zscal_(ptr noundef nonnull %12, ptr noundef nonnull %14, ptr noundef %627, ptr noundef nonnull @c__1) #7
  %628 = load i32, ptr %2, align 4, !tbaa !5
  %629 = add i32 %587, %628
  store i32 %629, ptr %12, align 4, !tbaa !5
  %630 = sext i32 %629 to i64
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %630
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %631, align 8, !tbaa !9
  %632 = call { double, double } @Cd(ptr noundef nonnull %16)
  %633 = extractvalue { double, double } %632, 0
  %634 = extractvalue { double, double } %632, 1
  %635 = call { double, double } @Cd(ptr noundef nonnull %15)
  %636 = extractvalue { double, double } %635, 0
  %637 = extractvalue { double, double } %635, 1
  %638 = call { double, double } @__divdc3(double noundef %633, double noundef %634, double noundef %636, double noundef %637) #7
  %639 = extractvalue { double, double } %638, 0
  %640 = extractvalue { double, double } %638, 1
  %641 = call ptr @_pCd(ptr noundef nonnull %14)
  %642 = getelementptr inbounds i8, ptr %641, i64 8
  store double %639, ptr %641, align 8
  store double %640, ptr %642, align 8
  %643 = load double, ptr %14, align 16, !tbaa !15
  %.pre754 = load i32, ptr %2, align 4, !tbaa !5
  %.pre756 = add i32 %.pre754, %indvars741
  br label %644

644:                                              ; preds = %577, %607
  %.pre-phi = phi i32 [ %597, %577 ], [ %.pre756, %607 ]
  %.sroa.011.5 = phi double [ 0.000000e+00, %577 ], [ %643, %607 ]
  %645 = load i32, ptr %0, align 4, !tbaa !5
  %646 = add i32 %645, 1
  %647 = sub i32 %646, %.pre-phi
  store i32 %647, ptr %12, align 4, !tbaa !5
  %648 = load i32, ptr %1, align 4, !tbaa !5
  %649 = sub nsw i32 %648, %indvars741
  store i32 %649, ptr %13, align 4, !tbaa !5
  %650 = add nuw nsw i64 %indvars.iv733, 1
  %651 = mul nsw i64 %650, %224
  %652 = sext i32 %.pre-phi to i64
  %653 = getelementptr %struct.doublecomplex, ptr %20, i64 %651
  %654 = getelementptr %struct.doublecomplex, ptr %653, i64 %652
  %655 = getelementptr %struct.doublecomplex, ptr %20, i64 %581
  %656 = getelementptr %struct.doublecomplex, ptr %655, i64 %652
  call void @zgemv_(ptr noundef nonnull @.str.1, ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull @c_b2, ptr noundef %654, ptr noundef nonnull %6, ptr noundef %656, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %8, ptr noundef nonnull @c__1) #7
  %657 = load i32, ptr %0, align 4, !tbaa !5
  %658 = load i32, ptr %2, align 4, !tbaa !5
  %659 = add i32 %658, %indvars741
  %660 = add i32 %657, 1
  %661 = sub i32 %660, %659
  store i32 %661, ptr %12, align 4, !tbaa !5
  %662 = load i32, ptr %1, align 4, !tbaa !5
  %663 = sub nsw i32 %662, %indvars741
  store i32 %663, ptr %13, align 4, !tbaa !5
  %664 = fneg double %.sroa.011.5
  store double %664, ptr %14, align 16, !tbaa !15
  store double -0.000000e+00, ptr %219, align 8, !tbaa !17
  %665 = sext i32 %659 to i64
  %666 = getelementptr %struct.doublecomplex, ptr %20, i64 %581
  %667 = getelementptr %struct.doublecomplex, ptr %666, i64 %665
  %668 = getelementptr %struct.doublecomplex, ptr %20, i64 %651
  %669 = getelementptr %struct.doublecomplex, ptr %668, i64 %665
  call void @zgerc_(ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef %667, ptr noundef nonnull @c__1, ptr noundef %8, ptr noundef nonnull @c__1, ptr noundef %669, ptr noundef nonnull %6) #7
  %670 = load i32, ptr %2, align 4, !tbaa !5
  %671 = add i32 %587, %670
  br label %.sink.split

.sink.split:                                      ; preds = %415, %644
  %.sink782 = phi i32 [ %452, %415 ], [ %671, %644 ]
  store i32 %.sink782, ptr %12, align 4, !tbaa !5
  %.sink786 = load double, ptr %15, align 16, !tbaa !15
  %672 = fneg double %.sink786
  store double %672, ptr %14, align 16, !tbaa !15
  %673 = load double, ptr %220, align 8, !tbaa !17
  %674 = fneg double %673
  store double %674, ptr %219, align 8, !tbaa !17
  %675 = sext i32 %.sink782 to i64
  %676 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %675
  store double %672, ptr %676, align 8, !tbaa !15
  %677 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %675, i32 1
  store double %674, ptr %677, align 8, !tbaa !17
  br label %678

678:                                              ; preds = %.sink.split, %570, %336
  %679 = load i32, ptr %1, align 4, !tbaa !5
  %680 = sext i32 %679 to i64
  %.not628 = icmp sgt i64 %indvars.iv733, %680
  %.pre755 = load i32, ptr %0, align 4, !tbaa !5
  br i1 %.not628, label %.loopexit652, label %681

681:                                              ; preds = %678
  store i32 %.pre755, ptr %12, align 4, !tbaa !5
  %682 = load i32, ptr %2, align 4, !tbaa !5
  %683 = add nsw i32 %682, %indvars741
  %.not629.not684 = icmp slt i32 %683, %.pre755
  br i1 %.not629.not684, label %.lr.ph687, label %.loopexit652

.lr.ph687:                                        ; preds = %681
  %684 = mul nsw i64 %indvars.iv733, %224
  %685 = add i32 %682, %231
  %686 = sext i32 %685 to i64
  %687 = shl nsw i64 %686, 4
  %scevgep732 = getelementptr i8, ptr %scevgep729, i64 %687
  %688 = add i32 %.pre755, -2
  %689 = add i32 %indvar730, %682
  %690 = sub i32 %688, %689
  %691 = zext i32 %690 to i64
  %692 = shl nuw nsw i64 %691, 4
  %693 = add nuw nsw i64 %692, 16
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(1) %scevgep732, i8 0, i64 %693, i1 false), !tbaa !9
  %694 = sext i32 %682 to i64
  %695 = add nsw i64 %indvars.iv733, %694
  %696 = sext i32 %.pre755 to i64
  br label %697

697:                                              ; preds = %.lr.ph687, %697
  %indvars.iv735 = phi i64 [ %695, %.lr.ph687 ], [ %indvars.iv.next736, %697 ]
  %indvars.iv.next736 = add nsw i64 %indvars.iv735, 1
  %.not629.not = icmp slt i64 %indvars.iv.next736, %696
  br i1 %.not629.not, label %697, label %..loopexit652_crit_edge, !llvm.loop !20

..loopexit652_crit_edge:                          ; preds = %697
  %698 = add nsw i64 %indvars.iv.next736, %684
  %699 = trunc nsw i64 %698 to i32
  store i32 %699, ptr %13, align 4, !tbaa !5
  br label %.loopexit652

.loopexit652:                                     ; preds = %681, %..loopexit652_crit_edge, %678
  %700 = sext i32 %.pre755 to i64
  %.not630 = icmp sgt i64 %indvars.iv733, %700
  br i1 %.not630, label %.loopexit, label %701

701:                                              ; preds = %.loopexit652
  store i32 %679, ptr %12, align 4, !tbaa !5
  %702 = load i32, ptr %3, align 4, !tbaa !5
  %703 = add nsw i32 %702, %indvars741
  %.not631.not689 = icmp slt i32 %703, %679
  br i1 %.not631.not689, label %.lr.ph692.preheader, label %.loopexit

.lr.ph692.preheader:                              ; preds = %701
  %704 = sext i32 %702 to i64
  %705 = add nsw i64 %indvars.iv733, %704
  br label %.lr.ph692

.lr.ph692:                                        ; preds = %.lr.ph692.preheader, %.lr.ph692
  %indvars.iv738 = phi i64 [ %705, %.lr.ph692.preheader ], [ %indvars.iv.next739, %.lr.ph692 ]
  %indvars.iv.next739 = add nsw i64 %indvars.iv738, 1
  %706 = mul nsw i64 %indvars.iv.next739, %224
  %707 = add nsw i64 %706, %indvars.iv733
  %708 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %707
  %.not631.not = icmp slt i64 %indvars.iv.next739, %680
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %708, i8 0, i64 16, i1 false)
  br i1 %.not631.not, label %.lr.ph692, label %..loopexit_crit_edge, !llvm.loop !21

..loopexit_crit_edge:                             ; preds = %.lr.ph692
  %709 = trunc nsw i64 %707 to i32
  store i32 %709, ptr %13, align 4, !tbaa !5
  br label %.loopexit

.loopexit:                                        ; preds = %701, %..loopexit_crit_edge, %.loopexit652
  %indvars.iv.next734 = add nuw nsw i64 %indvars.iv733, 1
  %710 = load i32, ptr %11, align 4, !tbaa !5
  %711 = sext i32 %710 to i64
  %.not618.not = icmp slt i64 %indvars.iv733, %711
  %indvar.next731 = add nuw nsw i32 %indvar730, 1
  br i1 %.not618.not, label %227, label %.loopexit653, !llvm.loop !22

.loopexit653:                                     ; preds = %.loopexit, %81, %._crit_edge683, %.thread
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %15) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %13) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %12) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %11) #7
  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 @xerbla_(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #2

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

declare double @dznrm2_(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nofree nounwind
declare double @cabs(double noundef, double noundef) local_unnamed_addr #3

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

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 #4

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

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

declare void @zlacgv_(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.smax.i32(i32, i32) #5

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.smin.i32(i32, i32) #5

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #6

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.umin.i32(i32, i32) #5

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #7 = { 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 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.unroll.disable"}
!15 = !{!16, !10, i64 0}
!16 = !{!"", !10, i64 0, !10, i64 8}
!17 = !{!16, !10, i64 8}
!18 = distinct !{!18, !12}
!19 = distinct !{!19, !12}
!20 = distinct !{!20, !12}
!21 = distinct !{!21, !12}
!22 = distinct !{!22, !12}


; Effective O3 passes: BDCEPass,ConstraintEliminationPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass