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

; 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.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1
@c__1 = external hidden global i32, align 4
@c_b1 = external hidden global %struct.complex, align 4
@.str.3 = external hidden unnamed_addr constant [10 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @csytrs_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8) #0 {
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca %struct.complex, align 4
  %26 = alloca %struct.complex, align 4
  %27 = alloca %struct.complex, align 4
  %28 = alloca %struct.complex, align 4
  %29 = alloca i32, align 4
  %30 = alloca i32, align 4
  %31 = alloca %struct.complex, align 4
  %32 = alloca i32, align 4
  %33 = alloca %struct.complex, align 4
  %34 = alloca %struct.complex, align 4
  %35 = alloca i32, align 4
  %36 = alloca %struct.complex, align 4
  %37 = alloca %struct.complex, align 4
  %38 = alloca i32, align 4
  %39 = alloca { float, float }, align 4
  %40 = alloca { float, float }, align 4
  %41 = alloca { float, float }, align 4
  %42 = alloca { float, float }, align 4
  %43 = alloca { float, float }, align 4
  %44 = alloca { float, float }, align 4
  %45 = alloca { float, float }, align 4
  %46 = alloca { float, float }, align 4
  %47 = alloca { float, float }, align 4
  %48 = alloca { float, float }, align 4
  %49 = alloca { float, float }, align 4
  %50 = alloca { float, float }, align 4
  %51 = alloca { float, float }, align 4
  %52 = alloca { float, float }, align 4
  %53 = alloca { float, float }, align 4
  %54 = alloca { float, float }, align 4
  %55 = alloca { float, float }, align 4
  %56 = alloca { float, float }, align 4
  %57 = alloca { float, float }, align 4
  %58 = alloca { float, float }, align 4
  %59 = alloca { float, float }, align 4
  %60 = alloca { float, float }, align 4
  %61 = alloca { float, float }, align 4
  %62 = alloca { float, float }, align 4
  %63 = alloca { float, float }, align 4
  %64 = alloca { float, float }, align 4
  %65 = alloca { float, float }, align 4
  %66 = alloca { float, float }, align 4
  %67 = alloca { float, float }, align 4
  %68 = alloca { float, float }, align 4
  %69 = alloca { float, float }, align 4
  %70 = alloca { float, float }, align 4
  %71 = alloca { float, float }, align 4
  %72 = alloca { float, float }, align 4
  %73 = alloca { float, float }, align 4
  %74 = alloca { float, float }, align 4
  %75 = alloca { float, float }, align 4
  %76 = alloca { float, float }, align 4
  %77 = alloca { float, float }, align 4
  %78 = alloca { float, float }, align 4
  %79 = alloca { float, float }, align 4
  %80 = alloca { float, float }, align 4
  store ptr %0, ptr %10, align 8, !tbaa !5
  store ptr %1, ptr %11, align 8, !tbaa !5
  store ptr %2, ptr %12, align 8, !tbaa !5
  store ptr %3, ptr %13, align 8, !tbaa !5
  store ptr %4, ptr %14, align 8, !tbaa !5
  store ptr %5, ptr %15, align 8, !tbaa !5
  store ptr %6, ptr %16, align 8, !tbaa !5
  store ptr %7, ptr %17, align 8, !tbaa !5
  store ptr %8, ptr %18, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %81 = load ptr, ptr %14, align 8, !tbaa !5
  %82 = load i32, ptr %81, align 4, !tbaa !9
  store i32 %82, ptr %19, align 4, !tbaa !9
  %83 = load i32, ptr %19, align 4, !tbaa !9
  %84 = mul nsw i32 %83, 1
  %85 = add nsw i32 1, %84
  store i32 %85, ptr %20, align 4, !tbaa !9
  %86 = load i32, ptr %20, align 4, !tbaa !9
  %87 = load ptr, ptr %13, align 8, !tbaa !5
  %88 = sext i32 %86 to i64
  %89 = sub i64 0, %88
  %90 = getelementptr inbounds %struct.complex, ptr %87, i64 %89
  store ptr %90, ptr %13, align 8, !tbaa !5
  %91 = load ptr, ptr %15, align 8, !tbaa !5
  %92 = getelementptr inbounds i32, ptr %91, i32 -1
  store ptr %92, ptr %15, align 8, !tbaa !5
  %93 = load ptr, ptr %17, align 8, !tbaa !5
  %94 = load i32, ptr %93, align 4, !tbaa !9
  store i32 %94, ptr %21, align 4, !tbaa !9
  %95 = load i32, ptr %21, align 4, !tbaa !9
  %96 = mul nsw i32 %95, 1
  %97 = add nsw i32 1, %96
  store i32 %97, ptr %22, align 4, !tbaa !9
  %98 = load i32, ptr %22, align 4, !tbaa !9
  %99 = load ptr, ptr %16, align 8, !tbaa !5
  %100 = sext i32 %98 to i64
  %101 = sub i64 0, %100
  %102 = getelementptr inbounds %struct.complex, ptr %99, i64 %101
  store ptr %102, ptr %16, align 8, !tbaa !5
  %103 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 0, ptr %103, align 4, !tbaa !9
  %104 = load ptr, ptr %10, align 8, !tbaa !5
  %105 = call i32 @lsame_(ptr noundef %104, ptr noundef @.str)
  store i32 %105, ptr %32, align 4, !tbaa !9
  %106 = load i32, ptr %32, align 4, !tbaa !9
  %107 = icmp ne i32 %106, 0
  br i1 %107, label %114, label %108

108:                                              ; preds = %9
  %109 = load ptr, ptr %10, align 8, !tbaa !5
  %110 = call i32 @lsame_(ptr noundef %109, ptr noundef @.str.1)
  %111 = icmp ne i32 %110, 0
  br i1 %111, label %114, label %112

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

114:                                              ; preds = %108, %9
  %115 = load ptr, ptr %11, 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 %120

118:                                              ; preds = %114
  %119 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -2, ptr %119, align 4, !tbaa !9
  br label %159

120:                                              ; preds = %114
  %121 = load ptr, ptr %12, align 8, !tbaa !5
  %122 = load i32, ptr %121, align 4, !tbaa !9
  %123 = icmp slt i32 %122, 0
  br i1 %123, label %124, label %126

124:                                              ; preds = %120
  %125 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -3, ptr %125, align 4, !tbaa !9
  br label %158

126:                                              ; preds = %120
  %127 = load ptr, ptr %14, align 8, !tbaa !5
  %128 = load i32, ptr %127, align 4, !tbaa !9
  %129 = load ptr, ptr %11, align 8, !tbaa !5
  %130 = load i32, ptr %129, align 4, !tbaa !9
  %131 = icmp sge i32 1, %130
  br i1 %131, label %132, label %133

132:                                              ; preds = %126
  br label %136

133:                                              ; preds = %126
  %134 = load ptr, ptr %11, align 8, !tbaa !5
  %135 = load i32, ptr %134, align 4, !tbaa !9
  br label %136

136:                                              ; preds = %133, %132
  %137 = phi i32 [ 1, %132 ], [ %135, %133 ]
  %138 = icmp slt i32 %128, %137
  br i1 %138, label %139, label %141

139:                                              ; preds = %136
  %140 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -5, ptr %140, align 4, !tbaa !9
  br label %157

141:                                              ; preds = %136
  %142 = load ptr, ptr %17, align 8, !tbaa !5
  %143 = load i32, ptr %142, align 4, !tbaa !9
  %144 = load ptr, ptr %11, align 8, !tbaa !5
  %145 = load i32, ptr %144, align 4, !tbaa !9
  %146 = icmp sge i32 1, %145
  br i1 %146, label %147, label %148

147:                                              ; preds = %141
  br label %151

148:                                              ; preds = %141
  %149 = load ptr, ptr %11, align 8, !tbaa !5
  %150 = load i32, ptr %149, align 4, !tbaa !9
  br label %151

151:                                              ; preds = %148, %147
  %152 = phi i32 [ 1, %147 ], [ %150, %148 ]
  %153 = icmp slt i32 %143, %152
  br i1 %153, label %154, label %156

154:                                              ; preds = %151
  %155 = load ptr, ptr %18, align 8, !tbaa !5
  store i32 -8, ptr %155, align 4, !tbaa !9
  br label %156

156:                                              ; preds = %154, %151
  br label %157

157:                                              ; preds = %156, %139
  br label %158

158:                                              ; preds = %157, %124
  br label %159

159:                                              ; preds = %158, %118
  br label %160

160:                                              ; preds = %159, %112
  %161 = load ptr, ptr %18, align 8, !tbaa !5
  %162 = load i32, ptr %161, align 4, !tbaa !9
  %163 = icmp ne i32 %162, 0
  br i1 %163, label %164, label %169

164:                                              ; preds = %160
  %165 = load ptr, ptr %18, align 8, !tbaa !5
  %166 = load i32, ptr %165, align 4, !tbaa !9
  %167 = sub nsw i32 0, %166
  store i32 %167, ptr %23, align 4, !tbaa !9
  %168 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %23, i32 noundef 6)
  store i32 1, ptr %38, align 4
  br label %1600

169:                                              ; preds = %160
  %170 = load ptr, ptr %11, align 8, !tbaa !5
  %171 = load i32, ptr %170, align 4, !tbaa !9
  %172 = icmp eq i32 %171, 0
  br i1 %172, label %177, label %173

173:                                              ; preds = %169
  %174 = load ptr, ptr %12, align 8, !tbaa !5
  %175 = load i32, ptr %174, align 4, !tbaa !9
  %176 = icmp eq i32 %175, 0
  br i1 %176, label %177, label %178

177:                                              ; preds = %173, %169
  store i32 1, ptr %38, align 4
  br label %1600

178:                                              ; preds = %173
  %179 = load i32, ptr %32, align 4, !tbaa !9
  %180 = icmp ne i32 %179, 0
  br i1 %180, label %181, label %857

181:                                              ; preds = %178
  %182 = load ptr, ptr %11, align 8, !tbaa !5
  %183 = load i32, ptr %182, align 4, !tbaa !9
  store i32 %183, ptr %30, align 4, !tbaa !9
  br label %184

184:                                              ; preds = %709, %181
  %185 = load i32, ptr %30, align 4, !tbaa !9
  %186 = icmp slt i32 %185, 1
  br i1 %186, label %187, label %188

187:                                              ; preds = %184
  br label %710

188:                                              ; preds = %184
  %189 = load ptr, ptr %15, align 8, !tbaa !5
  %190 = load i32, ptr %30, align 4, !tbaa !9
  %191 = sext i32 %190 to i64
  %192 = getelementptr inbounds i32, ptr %189, i64 %191
  %193 = load i32, ptr %192, align 4, !tbaa !9
  %194 = icmp sgt i32 %193, 0
  br i1 %194, label %195, label %282

195:                                              ; preds = %188
  %196 = load ptr, ptr %15, align 8, !tbaa !5
  %197 = load i32, ptr %30, align 4, !tbaa !9
  %198 = sext i32 %197 to i64
  %199 = getelementptr inbounds i32, ptr %196, i64 %198
  %200 = load i32, ptr %199, align 4, !tbaa !9
  store i32 %200, ptr %35, align 4, !tbaa !9
  %201 = load i32, ptr %35, align 4, !tbaa !9
  %202 = load i32, ptr %30, align 4, !tbaa !9
  %203 = icmp ne i32 %201, %202
  br i1 %203, label %204, label %220

204:                                              ; preds = %195
  %205 = load ptr, ptr %12, align 8, !tbaa !5
  %206 = load ptr, ptr %16, align 8, !tbaa !5
  %207 = load i32, ptr %30, align 4, !tbaa !9
  %208 = load i32, ptr %21, align 4, !tbaa !9
  %209 = add nsw i32 %207, %208
  %210 = sext i32 %209 to i64
  %211 = getelementptr inbounds %struct.complex, ptr %206, i64 %210
  %212 = load ptr, ptr %17, align 8, !tbaa !5
  %213 = load ptr, ptr %16, align 8, !tbaa !5
  %214 = load i32, ptr %35, align 4, !tbaa !9
  %215 = load i32, ptr %21, align 4, !tbaa !9
  %216 = add nsw i32 %214, %215
  %217 = sext i32 %216 to i64
  %218 = getelementptr inbounds %struct.complex, ptr %213, i64 %217
  %219 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %205, ptr noundef %211, ptr noundef %212, ptr noundef %218, ptr noundef %219)
  br label %220

220:                                              ; preds = %204, %195
  %221 = load i32, ptr %30, align 4, !tbaa !9
  %222 = sub nsw i32 %221, 1
  store i32 %222, ptr %23, align 4, !tbaa !9
  %223 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %223, align 4, !tbaa !11
  %224 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %224, align 4, !tbaa !14
  %225 = load ptr, ptr %12, align 8, !tbaa !5
  %226 = load ptr, ptr %13, align 8, !tbaa !5
  %227 = load i32, ptr %30, align 4, !tbaa !9
  %228 = load i32, ptr %19, align 4, !tbaa !9
  %229 = mul nsw i32 %227, %228
  %230 = add nsw i32 %229, 1
  %231 = sext i32 %230 to i64
  %232 = getelementptr inbounds %struct.complex, ptr %226, i64 %231
  %233 = load ptr, ptr %16, align 8, !tbaa !5
  %234 = load i32, ptr %30, align 4, !tbaa !9
  %235 = load i32, ptr %21, align 4, !tbaa !9
  %236 = add nsw i32 %234, %235
  %237 = sext i32 %236 to i64
  %238 = getelementptr inbounds %struct.complex, ptr %233, i64 %237
  %239 = load ptr, ptr %17, align 8, !tbaa !5
  %240 = load ptr, ptr %16, align 8, !tbaa !5
  %241 = load i32, ptr %21, align 4, !tbaa !9
  %242 = add nsw i32 %241, 1
  %243 = sext i32 %242 to i64
  %244 = getelementptr inbounds %struct.complex, ptr %240, i64 %243
  %245 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgeru_(ptr noundef %23, ptr noundef %225, ptr noundef %25, ptr noundef %232, ptr noundef @c__1, ptr noundef %238, ptr noundef %239, ptr noundef %244, ptr noundef %245)
  %246 = call <2 x float> @Cf(ptr noundef @c_b1)
  store <2 x float> %246, ptr %39, align 4
  %247 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 0
  %248 = load float, ptr %247, align 4
  %249 = getelementptr inbounds { float, float }, ptr %39, i32 0, i32 1
  %250 = load float, ptr %249, align 4
  %251 = load ptr, ptr %13, align 8, !tbaa !5
  %252 = load i32, ptr %30, align 4, !tbaa !9
  %253 = load i32, ptr %30, align 4, !tbaa !9
  %254 = load i32, ptr %19, align 4, !tbaa !9
  %255 = mul nsw i32 %253, %254
  %256 = add nsw i32 %252, %255
  %257 = sext i32 %256 to i64
  %258 = getelementptr inbounds %struct.complex, ptr %251, i64 %257
  %259 = call <2 x float> @Cf(ptr noundef %258)
  store <2 x float> %259, ptr %40, align 4
  %260 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 0
  %261 = load float, ptr %260, align 4
  %262 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 1
  %263 = load float, ptr %262, align 4
  %264 = call <2 x float> @__divsc3(float noundef %248, float noundef %250, float noundef %261, float noundef %263) #6
  store <2 x float> %264, ptr %41, align 4
  %265 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 0
  %266 = load float, ptr %265, align 4
  %267 = getelementptr inbounds { float, float }, ptr %41, i32 0, i32 1
  %268 = load float, ptr %267, align 4
  %269 = call ptr @_pCf(ptr noundef %25)
  %270 = getelementptr inbounds { float, float }, ptr %269, i32 0, i32 0
  %271 = getelementptr inbounds { float, float }, ptr %269, i32 0, i32 1
  store float %266, ptr %270, align 4
  store float %268, ptr %271, align 4
  %272 = load ptr, ptr %12, align 8, !tbaa !5
  %273 = load ptr, ptr %16, align 8, !tbaa !5
  %274 = load i32, ptr %30, align 4, !tbaa !9
  %275 = load i32, ptr %21, align 4, !tbaa !9
  %276 = add nsw i32 %274, %275
  %277 = sext i32 %276 to i64
  %278 = getelementptr inbounds %struct.complex, ptr %273, i64 %277
  %279 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cscal_(ptr noundef %272, ptr noundef %25, ptr noundef %278, ptr noundef %279)
  %280 = load i32, ptr %30, align 4, !tbaa !9
  %281 = add nsw i32 %280, -1
  store i32 %281, ptr %30, align 4, !tbaa !9
  br label %709

282:                                              ; preds = %188
  %283 = load ptr, ptr %15, align 8, !tbaa !5
  %284 = load i32, ptr %30, align 4, !tbaa !9
  %285 = sext i32 %284 to i64
  %286 = getelementptr inbounds i32, ptr %283, i64 %285
  %287 = load i32, ptr %286, align 4, !tbaa !9
  %288 = sub nsw i32 0, %287
  store i32 %288, ptr %35, align 4, !tbaa !9
  %289 = load i32, ptr %35, align 4, !tbaa !9
  %290 = load i32, ptr %30, align 4, !tbaa !9
  %291 = sub nsw i32 %290, 1
  %292 = icmp ne i32 %289, %291
  br i1 %292, label %293, label %310

293:                                              ; preds = %282
  %294 = load ptr, ptr %12, align 8, !tbaa !5
  %295 = load ptr, ptr %16, align 8, !tbaa !5
  %296 = load i32, ptr %30, align 4, !tbaa !9
  %297 = sub nsw i32 %296, 1
  %298 = load i32, ptr %21, align 4, !tbaa !9
  %299 = add nsw i32 %297, %298
  %300 = sext i32 %299 to i64
  %301 = getelementptr inbounds %struct.complex, ptr %295, i64 %300
  %302 = load ptr, ptr %17, align 8, !tbaa !5
  %303 = load ptr, ptr %16, align 8, !tbaa !5
  %304 = load i32, ptr %35, align 4, !tbaa !9
  %305 = load i32, ptr %21, align 4, !tbaa !9
  %306 = add nsw i32 %304, %305
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds %struct.complex, ptr %303, i64 %307
  %309 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %294, ptr noundef %301, ptr noundef %302, ptr noundef %308, ptr noundef %309)
  br label %310

310:                                              ; preds = %293, %282
  %311 = load i32, ptr %30, align 4, !tbaa !9
  %312 = sub nsw i32 %311, 2
  store i32 %312, ptr %23, align 4, !tbaa !9
  %313 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %313, align 4, !tbaa !11
  %314 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %314, align 4, !tbaa !14
  %315 = load ptr, ptr %12, align 8, !tbaa !5
  %316 = load ptr, ptr %13, align 8, !tbaa !5
  %317 = load i32, ptr %30, align 4, !tbaa !9
  %318 = load i32, ptr %19, align 4, !tbaa !9
  %319 = mul nsw i32 %317, %318
  %320 = add nsw i32 %319, 1
  %321 = sext i32 %320 to i64
  %322 = getelementptr inbounds %struct.complex, ptr %316, i64 %321
  %323 = load ptr, ptr %16, align 8, !tbaa !5
  %324 = load i32, ptr %30, align 4, !tbaa !9
  %325 = load i32, ptr %21, align 4, !tbaa !9
  %326 = add nsw i32 %324, %325
  %327 = sext i32 %326 to i64
  %328 = getelementptr inbounds %struct.complex, ptr %323, i64 %327
  %329 = load ptr, ptr %17, align 8, !tbaa !5
  %330 = load ptr, ptr %16, align 8, !tbaa !5
  %331 = load i32, ptr %21, align 4, !tbaa !9
  %332 = add nsw i32 %331, 1
  %333 = sext i32 %332 to i64
  %334 = getelementptr inbounds %struct.complex, ptr %330, i64 %333
  %335 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgeru_(ptr noundef %23, ptr noundef %315, ptr noundef %25, ptr noundef %322, ptr noundef @c__1, ptr noundef %328, ptr noundef %329, ptr noundef %334, ptr noundef %335)
  %336 = load i32, ptr %30, align 4, !tbaa !9
  %337 = sub nsw i32 %336, 2
  store i32 %337, ptr %23, align 4, !tbaa !9
  %338 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %338, align 4, !tbaa !11
  %339 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %339, align 4, !tbaa !14
  %340 = load ptr, ptr %12, align 8, !tbaa !5
  %341 = load ptr, ptr %13, align 8, !tbaa !5
  %342 = load i32, ptr %30, align 4, !tbaa !9
  %343 = sub nsw i32 %342, 1
  %344 = load i32, ptr %19, align 4, !tbaa !9
  %345 = mul nsw i32 %343, %344
  %346 = add nsw i32 %345, 1
  %347 = sext i32 %346 to i64
  %348 = getelementptr inbounds %struct.complex, ptr %341, i64 %347
  %349 = load ptr, ptr %16, align 8, !tbaa !5
  %350 = load i32, ptr %30, align 4, !tbaa !9
  %351 = sub nsw i32 %350, 1
  %352 = load i32, ptr %21, align 4, !tbaa !9
  %353 = add nsw i32 %351, %352
  %354 = sext i32 %353 to i64
  %355 = getelementptr inbounds %struct.complex, ptr %349, i64 %354
  %356 = load ptr, ptr %17, align 8, !tbaa !5
  %357 = load ptr, ptr %16, align 8, !tbaa !5
  %358 = load i32, ptr %21, align 4, !tbaa !9
  %359 = add nsw i32 %358, 1
  %360 = sext i32 %359 to i64
  %361 = getelementptr inbounds %struct.complex, ptr %357, i64 %360
  %362 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgeru_(ptr noundef %23, ptr noundef %340, ptr noundef %25, ptr noundef %348, ptr noundef @c__1, ptr noundef %355, ptr noundef %356, ptr noundef %361, ptr noundef %362)
  %363 = load i32, ptr %30, align 4, !tbaa !9
  %364 = sub nsw i32 %363, 1
  %365 = load i32, ptr %30, align 4, !tbaa !9
  %366 = load i32, ptr %19, align 4, !tbaa !9
  %367 = mul nsw i32 %365, %366
  %368 = add nsw i32 %364, %367
  store i32 %368, ptr %23, align 4, !tbaa !9
  %369 = load ptr, ptr %13, align 8, !tbaa !5
  %370 = load i32, ptr %23, align 4, !tbaa !9
  %371 = sext i32 %370 to i64
  %372 = getelementptr inbounds %struct.complex, ptr %369, i64 %371
  %373 = getelementptr inbounds %struct.complex, ptr %372, i32 0, i32 0
  %374 = load float, ptr %373, align 4, !tbaa !11
  %375 = getelementptr inbounds %struct.complex, ptr %28, i32 0, i32 0
  store float %374, ptr %375, align 4, !tbaa !11
  %376 = load ptr, ptr %13, align 8, !tbaa !5
  %377 = load i32, ptr %23, align 4, !tbaa !9
  %378 = sext i32 %377 to i64
  %379 = getelementptr inbounds %struct.complex, ptr %376, i64 %378
  %380 = getelementptr inbounds %struct.complex, ptr %379, i32 0, i32 1
  %381 = load float, ptr %380, align 4, !tbaa !14
  %382 = getelementptr inbounds %struct.complex, ptr %28, i32 0, i32 1
  store float %381, ptr %382, align 4, !tbaa !14
  %383 = load ptr, ptr %13, align 8, !tbaa !5
  %384 = load i32, ptr %30, align 4, !tbaa !9
  %385 = sub nsw i32 %384, 1
  %386 = load i32, ptr %30, align 4, !tbaa !9
  %387 = sub nsw i32 %386, 1
  %388 = load i32, ptr %19, align 4, !tbaa !9
  %389 = mul nsw i32 %387, %388
  %390 = add nsw i32 %385, %389
  %391 = sext i32 %390 to i64
  %392 = getelementptr inbounds %struct.complex, ptr %383, i64 %391
  %393 = call <2 x float> @Cf(ptr noundef %392)
  store <2 x float> %393, ptr %42, align 4
  %394 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 0
  %395 = load float, ptr %394, align 4
  %396 = getelementptr inbounds { float, float }, ptr %42, i32 0, i32 1
  %397 = load float, ptr %396, align 4
  %398 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %398, ptr %43, align 4
  %399 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 0
  %400 = load float, ptr %399, align 4
  %401 = getelementptr inbounds { float, float }, ptr %43, i32 0, i32 1
  %402 = load float, ptr %401, align 4
  %403 = call <2 x float> @__divsc3(float noundef %395, float noundef %397, float noundef %400, float noundef %402) #6
  store <2 x float> %403, ptr %44, align 4
  %404 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 0
  %405 = load float, ptr %404, align 4
  %406 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 1
  %407 = load float, ptr %406, align 4
  %408 = call ptr @_pCf(ptr noundef %25)
  %409 = getelementptr inbounds { float, float }, ptr %408, i32 0, i32 0
  %410 = getelementptr inbounds { float, float }, ptr %408, i32 0, i32 1
  store float %405, ptr %409, align 4
  store float %407, ptr %410, align 4
  %411 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %412 = load float, ptr %411, align 4, !tbaa !11
  %413 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %412, ptr %413, align 4, !tbaa !11
  %414 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %415 = load float, ptr %414, align 4, !tbaa !14
  %416 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %415, ptr %416, align 4, !tbaa !14
  %417 = load ptr, ptr %13, align 8, !tbaa !5
  %418 = load i32, ptr %30, align 4, !tbaa !9
  %419 = load i32, ptr %30, align 4, !tbaa !9
  %420 = load i32, ptr %19, align 4, !tbaa !9
  %421 = mul nsw i32 %419, %420
  %422 = add nsw i32 %418, %421
  %423 = sext i32 %422 to i64
  %424 = getelementptr inbounds %struct.complex, ptr %417, i64 %423
  %425 = call <2 x float> @Cf(ptr noundef %424)
  store <2 x float> %425, ptr %45, align 4
  %426 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 0
  %427 = load float, ptr %426, align 4
  %428 = getelementptr inbounds { float, float }, ptr %45, i32 0, i32 1
  %429 = load float, ptr %428, align 4
  %430 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %430, ptr %46, align 4
  %431 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 0
  %432 = load float, ptr %431, align 4
  %433 = getelementptr inbounds { float, float }, ptr %46, i32 0, i32 1
  %434 = load float, ptr %433, align 4
  %435 = call <2 x float> @__divsc3(float noundef %427, float noundef %429, float noundef %432, float noundef %434) #6
  store <2 x float> %435, ptr %47, align 4
  %436 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 0
  %437 = load float, ptr %436, align 4
  %438 = getelementptr inbounds { float, float }, ptr %47, i32 0, i32 1
  %439 = load float, ptr %438, align 4
  %440 = call ptr @_pCf(ptr noundef %25)
  %441 = getelementptr inbounds { float, float }, ptr %440, i32 0, i32 0
  %442 = getelementptr inbounds { float, float }, ptr %440, i32 0, i32 1
  store float %437, ptr %441, align 4
  store float %439, ptr %442, align 4
  %443 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %444 = load float, ptr %443, align 4, !tbaa !11
  %445 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %444, ptr %445, align 4, !tbaa !11
  %446 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %447 = load float, ptr %446, align 4, !tbaa !14
  %448 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %447, ptr %448, align 4, !tbaa !14
  %449 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %450 = load float, ptr %449, align 4, !tbaa !11
  %451 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %452 = load float, ptr %451, align 4, !tbaa !11
  %453 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %454 = load float, ptr %453, align 4, !tbaa !14
  %455 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %456 = load float, ptr %455, align 4, !tbaa !14
  %457 = fmul float %454, %456
  %458 = fneg float %457
  %459 = call float @llvm.fmuladd.f32(float %450, float %452, float %458)
  %460 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %459, ptr %460, align 4, !tbaa !11
  %461 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %462 = load float, ptr %461, align 4, !tbaa !11
  %463 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %464 = load float, ptr %463, align 4, !tbaa !14
  %465 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %466 = load float, ptr %465, align 4, !tbaa !14
  %467 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %468 = load float, ptr %467, align 4, !tbaa !11
  %469 = fmul float %466, %468
  %470 = call float @llvm.fmuladd.f32(float %462, float %464, float %469)
  %471 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %470, ptr %471, align 4, !tbaa !14
  %472 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %473 = load float, ptr %472, align 4, !tbaa !11
  %474 = fsub float %473, 1.000000e+00
  %475 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float %474, ptr %475, align 4, !tbaa !11
  %476 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %477 = load float, ptr %476, align 4, !tbaa !14
  %478 = fadd float %477, 0.000000e+00
  %479 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float %478, ptr %479, align 4, !tbaa !14
  %480 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %481 = load float, ptr %480, align 4, !tbaa !11
  %482 = getelementptr inbounds %struct.complex, ptr %31, i32 0, i32 0
  store float %481, ptr %482, align 4, !tbaa !11
  %483 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %484 = load float, ptr %483, align 4, !tbaa !14
  %485 = getelementptr inbounds %struct.complex, ptr %31, i32 0, i32 1
  store float %484, ptr %485, align 4, !tbaa !14
  %486 = load ptr, ptr %12, align 8, !tbaa !5
  %487 = load i32, ptr %486, align 4, !tbaa !9
  store i32 %487, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %29, align 4, !tbaa !9
  br label %488

488:                                              ; preds = %703, %310
  %489 = load i32, ptr %29, align 4, !tbaa !9
  %490 = load i32, ptr %23, align 4, !tbaa !9
  %491 = icmp sle i32 %489, %490
  br i1 %491, label %492, label %706

492:                                              ; preds = %488
  %493 = load ptr, ptr %16, align 8, !tbaa !5
  %494 = load i32, ptr %30, align 4, !tbaa !9
  %495 = sub nsw i32 %494, 1
  %496 = load i32, ptr %29, align 4, !tbaa !9
  %497 = load i32, ptr %21, align 4, !tbaa !9
  %498 = mul nsw i32 %496, %497
  %499 = add nsw i32 %495, %498
  %500 = sext i32 %499 to i64
  %501 = getelementptr inbounds %struct.complex, ptr %493, i64 %500
  %502 = call <2 x float> @Cf(ptr noundef %501)
  store <2 x float> %502, ptr %48, align 4
  %503 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 0
  %504 = load float, ptr %503, align 4
  %505 = getelementptr inbounds { float, float }, ptr %48, i32 0, i32 1
  %506 = load float, ptr %505, align 4
  %507 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %507, ptr %49, align 4
  %508 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 0
  %509 = load float, ptr %508, align 4
  %510 = getelementptr inbounds { float, float }, ptr %49, i32 0, i32 1
  %511 = load float, ptr %510, align 4
  %512 = call <2 x float> @__divsc3(float noundef %504, float noundef %506, float noundef %509, float noundef %511) #6
  store <2 x float> %512, ptr %50, align 4
  %513 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 0
  %514 = load float, ptr %513, align 4
  %515 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 1
  %516 = load float, ptr %515, align 4
  %517 = call ptr @_pCf(ptr noundef %25)
  %518 = getelementptr inbounds { float, float }, ptr %517, i32 0, i32 0
  %519 = getelementptr inbounds { float, float }, ptr %517, i32 0, i32 1
  store float %514, ptr %518, align 4
  store float %516, ptr %519, align 4
  %520 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %521 = load float, ptr %520, align 4, !tbaa !11
  %522 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  store float %521, ptr %522, align 4, !tbaa !11
  %523 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %524 = load float, ptr %523, align 4, !tbaa !14
  %525 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  store float %524, ptr %525, align 4, !tbaa !14
  %526 = load ptr, ptr %16, align 8, !tbaa !5
  %527 = load i32, ptr %30, align 4, !tbaa !9
  %528 = load i32, ptr %29, align 4, !tbaa !9
  %529 = load i32, ptr %21, align 4, !tbaa !9
  %530 = mul nsw i32 %528, %529
  %531 = add nsw i32 %527, %530
  %532 = sext i32 %531 to i64
  %533 = getelementptr inbounds %struct.complex, ptr %526, i64 %532
  %534 = call <2 x float> @Cf(ptr noundef %533)
  store <2 x float> %534, ptr %51, align 4
  %535 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 0
  %536 = load float, ptr %535, align 4
  %537 = getelementptr inbounds { float, float }, ptr %51, i32 0, i32 1
  %538 = load float, ptr %537, align 4
  %539 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %539, ptr %52, align 4
  %540 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 0
  %541 = load float, ptr %540, align 4
  %542 = getelementptr inbounds { float, float }, ptr %52, i32 0, i32 1
  %543 = load float, ptr %542, align 4
  %544 = call <2 x float> @__divsc3(float noundef %536, float noundef %538, float noundef %541, float noundef %543) #6
  store <2 x float> %544, ptr %53, align 4
  %545 = getelementptr inbounds { float, float }, ptr %53, i32 0, i32 0
  %546 = load float, ptr %545, align 4
  %547 = getelementptr inbounds { float, float }, ptr %53, i32 0, i32 1
  %548 = load float, ptr %547, align 4
  %549 = call ptr @_pCf(ptr noundef %25)
  %550 = getelementptr inbounds { float, float }, ptr %549, i32 0, i32 0
  %551 = getelementptr inbounds { float, float }, ptr %549, i32 0, i32 1
  store float %546, ptr %550, align 4
  store float %548, ptr %551, align 4
  %552 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %553 = load float, ptr %552, align 4, !tbaa !11
  %554 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %553, ptr %554, align 4, !tbaa !11
  %555 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %556 = load float, ptr %555, align 4, !tbaa !14
  %557 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %556, ptr %557, align 4, !tbaa !14
  %558 = load i32, ptr %30, align 4, !tbaa !9
  %559 = sub nsw i32 %558, 1
  %560 = load i32, ptr %29, align 4, !tbaa !9
  %561 = load i32, ptr %21, align 4, !tbaa !9
  %562 = mul nsw i32 %560, %561
  %563 = add nsw i32 %559, %562
  store i32 %563, ptr %24, align 4, !tbaa !9
  %564 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %565 = load float, ptr %564, align 4, !tbaa !11
  %566 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %567 = load float, ptr %566, align 4, !tbaa !11
  %568 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %569 = load float, ptr %568, align 4, !tbaa !14
  %570 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %571 = load float, ptr %570, align 4, !tbaa !14
  %572 = fmul float %569, %571
  %573 = fneg float %572
  %574 = call float @llvm.fmuladd.f32(float %565, float %567, float %573)
  %575 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  store float %574, ptr %575, align 4, !tbaa !11
  %576 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %577 = load float, ptr %576, align 4, !tbaa !11
  %578 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %579 = load float, ptr %578, align 4, !tbaa !14
  %580 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %581 = load float, ptr %580, align 4, !tbaa !14
  %582 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %583 = load float, ptr %582, align 4, !tbaa !11
  %584 = fmul float %581, %583
  %585 = call float @llvm.fmuladd.f32(float %577, float %579, float %584)
  %586 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  store float %585, ptr %586, align 4, !tbaa !14
  %587 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %588 = load float, ptr %587, align 4, !tbaa !11
  %589 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %590 = load float, ptr %589, align 4, !tbaa !11
  %591 = fsub float %588, %590
  %592 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %591, ptr %592, align 4, !tbaa !11
  %593 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %594 = load float, ptr %593, align 4, !tbaa !14
  %595 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %596 = load float, ptr %595, align 4, !tbaa !14
  %597 = fsub float %594, %596
  %598 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %597, ptr %598, align 4, !tbaa !14
  %599 = call <2 x float> @Cf(ptr noundef %26)
  store <2 x float> %599, ptr %54, align 4
  %600 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 0
  %601 = load float, ptr %600, align 4
  %602 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 1
  %603 = load float, ptr %602, align 4
  %604 = call <2 x float> @Cf(ptr noundef %31)
  store <2 x float> %604, ptr %55, align 4
  %605 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 0
  %606 = load float, ptr %605, align 4
  %607 = getelementptr inbounds { float, float }, ptr %55, i32 0, i32 1
  %608 = load float, ptr %607, align 4
  %609 = call <2 x float> @__divsc3(float noundef %601, float noundef %603, float noundef %606, float noundef %608) #6
  store <2 x float> %609, ptr %56, align 4
  %610 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 0
  %611 = load float, ptr %610, align 4
  %612 = getelementptr inbounds { float, float }, ptr %56, i32 0, i32 1
  %613 = load float, ptr %612, align 4
  %614 = call ptr @_pCf(ptr noundef %25)
  %615 = getelementptr inbounds { float, float }, ptr %614, i32 0, i32 0
  %616 = getelementptr inbounds { float, float }, ptr %614, i32 0, i32 1
  store float %611, ptr %615, align 4
  store float %613, ptr %616, align 4
  %617 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %618 = load float, ptr %617, align 4, !tbaa !11
  %619 = load ptr, ptr %16, align 8, !tbaa !5
  %620 = load i32, ptr %24, align 4, !tbaa !9
  %621 = sext i32 %620 to i64
  %622 = getelementptr inbounds %struct.complex, ptr %619, i64 %621
  %623 = getelementptr inbounds %struct.complex, ptr %622, i32 0, i32 0
  store float %618, ptr %623, align 4, !tbaa !11
  %624 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %625 = load float, ptr %624, align 4, !tbaa !14
  %626 = load ptr, ptr %16, align 8, !tbaa !5
  %627 = load i32, ptr %24, align 4, !tbaa !9
  %628 = sext i32 %627 to i64
  %629 = getelementptr inbounds %struct.complex, ptr %626, i64 %628
  %630 = getelementptr inbounds %struct.complex, ptr %629, i32 0, i32 1
  store float %625, ptr %630, align 4, !tbaa !14
  %631 = load i32, ptr %30, align 4, !tbaa !9
  %632 = load i32, ptr %29, align 4, !tbaa !9
  %633 = load i32, ptr %21, align 4, !tbaa !9
  %634 = mul nsw i32 %632, %633
  %635 = add nsw i32 %631, %634
  store i32 %635, ptr %24, align 4, !tbaa !9
  %636 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %637 = load float, ptr %636, align 4, !tbaa !11
  %638 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %639 = load float, ptr %638, align 4, !tbaa !11
  %640 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %641 = load float, ptr %640, align 4, !tbaa !14
  %642 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %643 = load float, ptr %642, align 4, !tbaa !14
  %644 = fmul float %641, %643
  %645 = fneg float %644
  %646 = call float @llvm.fmuladd.f32(float %637, float %639, float %645)
  %647 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  store float %646, ptr %647, align 4, !tbaa !11
  %648 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %649 = load float, ptr %648, align 4, !tbaa !11
  %650 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %651 = load float, ptr %650, align 4, !tbaa !14
  %652 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %653 = load float, ptr %652, align 4, !tbaa !14
  %654 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %655 = load float, ptr %654, align 4, !tbaa !11
  %656 = fmul float %653, %655
  %657 = call float @llvm.fmuladd.f32(float %649, float %651, float %656)
  %658 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  store float %657, ptr %658, align 4, !tbaa !14
  %659 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %660 = load float, ptr %659, align 4, !tbaa !11
  %661 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %662 = load float, ptr %661, align 4, !tbaa !11
  %663 = fsub float %660, %662
  %664 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %663, ptr %664, align 4, !tbaa !11
  %665 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %666 = load float, ptr %665, align 4, !tbaa !14
  %667 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %668 = load float, ptr %667, align 4, !tbaa !14
  %669 = fsub float %666, %668
  %670 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %669, ptr %670, align 4, !tbaa !14
  %671 = call <2 x float> @Cf(ptr noundef %26)
  store <2 x float> %671, ptr %57, align 4
  %672 = getelementptr inbounds { float, float }, ptr %57, i32 0, i32 0
  %673 = load float, ptr %672, align 4
  %674 = getelementptr inbounds { float, float }, ptr %57, i32 0, i32 1
  %675 = load float, ptr %674, align 4
  %676 = call <2 x float> @Cf(ptr noundef %31)
  store <2 x float> %676, ptr %58, align 4
  %677 = getelementptr inbounds { float, float }, ptr %58, i32 0, i32 0
  %678 = load float, ptr %677, align 4
  %679 = getelementptr inbounds { float, float }, ptr %58, i32 0, i32 1
  %680 = load float, ptr %679, align 4
  %681 = call <2 x float> @__divsc3(float noundef %673, float noundef %675, float noundef %678, float noundef %680) #6
  store <2 x float> %681, ptr %59, align 4
  %682 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 0
  %683 = load float, ptr %682, align 4
  %684 = getelementptr inbounds { float, float }, ptr %59, i32 0, i32 1
  %685 = load float, ptr %684, align 4
  %686 = call ptr @_pCf(ptr noundef %25)
  %687 = getelementptr inbounds { float, float }, ptr %686, i32 0, i32 0
  %688 = getelementptr inbounds { float, float }, ptr %686, i32 0, i32 1
  store float %683, ptr %687, align 4
  store float %685, ptr %688, align 4
  %689 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %690 = load float, ptr %689, align 4, !tbaa !11
  %691 = load ptr, ptr %16, align 8, !tbaa !5
  %692 = load i32, ptr %24, align 4, !tbaa !9
  %693 = sext i32 %692 to i64
  %694 = getelementptr inbounds %struct.complex, ptr %691, i64 %693
  %695 = getelementptr inbounds %struct.complex, ptr %694, i32 0, i32 0
  store float %690, ptr %695, align 4, !tbaa !11
  %696 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %697 = load float, ptr %696, align 4, !tbaa !14
  %698 = load ptr, ptr %16, align 8, !tbaa !5
  %699 = load i32, ptr %24, align 4, !tbaa !9
  %700 = sext i32 %699 to i64
  %701 = getelementptr inbounds %struct.complex, ptr %698, i64 %700
  %702 = getelementptr inbounds %struct.complex, ptr %701, i32 0, i32 1
  store float %697, ptr %702, align 4, !tbaa !14
  br label %703

703:                                              ; preds = %492
  %704 = load i32, ptr %29, align 4, !tbaa !9
  %705 = add nsw i32 %704, 1
  store i32 %705, ptr %29, align 4, !tbaa !9
  br label %488, !llvm.loop !15

706:                                              ; preds = %488
  %707 = load i32, ptr %30, align 4, !tbaa !9
  %708 = add nsw i32 %707, -2
  store i32 %708, ptr %30, align 4, !tbaa !9
  br label %709

709:                                              ; preds = %706, %220
  br label %184

710:                                              ; preds = %187
  store i32 1, ptr %30, align 4, !tbaa !9
  br label %711

711:                                              ; preds = %855, %710
  %712 = load i32, ptr %30, align 4, !tbaa !9
  %713 = load ptr, ptr %11, align 8, !tbaa !5
  %714 = load i32, ptr %713, align 4, !tbaa !9
  %715 = icmp sgt i32 %712, %714
  br i1 %715, label %716, label %717

716:                                              ; preds = %711
  br label %856

717:                                              ; preds = %711
  %718 = load ptr, ptr %15, align 8, !tbaa !5
  %719 = load i32, ptr %30, align 4, !tbaa !9
  %720 = sext i32 %719 to i64
  %721 = getelementptr inbounds i32, ptr %718, i64 %720
  %722 = load i32, ptr %721, align 4, !tbaa !9
  %723 = icmp sgt i32 %722, 0
  br i1 %723, label %724, label %776

724:                                              ; preds = %717
  %725 = load i32, ptr %30, align 4, !tbaa !9
  %726 = sub nsw i32 %725, 1
  store i32 %726, ptr %23, align 4, !tbaa !9
  %727 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %727, align 4, !tbaa !11
  %728 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %728, align 4, !tbaa !14
  %729 = load ptr, ptr %12, align 8, !tbaa !5
  %730 = load ptr, ptr %16, align 8, !tbaa !5
  %731 = load i32, ptr %22, align 4, !tbaa !9
  %732 = sext i32 %731 to i64
  %733 = getelementptr inbounds %struct.complex, ptr %730, i64 %732
  %734 = load ptr, ptr %17, align 8, !tbaa !5
  %735 = load ptr, ptr %13, align 8, !tbaa !5
  %736 = load i32, ptr %30, align 4, !tbaa !9
  %737 = load i32, ptr %19, align 4, !tbaa !9
  %738 = mul nsw i32 %736, %737
  %739 = add nsw i32 %738, 1
  %740 = sext i32 %739 to i64
  %741 = getelementptr inbounds %struct.complex, ptr %735, i64 %740
  %742 = load ptr, ptr %16, align 8, !tbaa !5
  %743 = load i32, ptr %30, align 4, !tbaa !9
  %744 = load i32, ptr %21, align 4, !tbaa !9
  %745 = add nsw i32 %743, %744
  %746 = sext i32 %745 to i64
  %747 = getelementptr inbounds %struct.complex, ptr %742, i64 %746
  %748 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %729, ptr noundef %25, ptr noundef %733, ptr noundef %734, ptr noundef %741, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %747, ptr noundef %748)
  %749 = load ptr, ptr %15, align 8, !tbaa !5
  %750 = load i32, ptr %30, align 4, !tbaa !9
  %751 = sext i32 %750 to i64
  %752 = getelementptr inbounds i32, ptr %749, i64 %751
  %753 = load i32, ptr %752, align 4, !tbaa !9
  store i32 %753, ptr %35, align 4, !tbaa !9
  %754 = load i32, ptr %35, align 4, !tbaa !9
  %755 = load i32, ptr %30, align 4, !tbaa !9
  %756 = icmp ne i32 %754, %755
  br i1 %756, label %757, label %773

757:                                              ; preds = %724
  %758 = load ptr, ptr %12, align 8, !tbaa !5
  %759 = load ptr, ptr %16, align 8, !tbaa !5
  %760 = load i32, ptr %30, align 4, !tbaa !9
  %761 = load i32, ptr %21, align 4, !tbaa !9
  %762 = add nsw i32 %760, %761
  %763 = sext i32 %762 to i64
  %764 = getelementptr inbounds %struct.complex, ptr %759, i64 %763
  %765 = load ptr, ptr %17, align 8, !tbaa !5
  %766 = load ptr, ptr %16, align 8, !tbaa !5
  %767 = load i32, ptr %35, align 4, !tbaa !9
  %768 = load i32, ptr %21, align 4, !tbaa !9
  %769 = add nsw i32 %767, %768
  %770 = sext i32 %769 to i64
  %771 = getelementptr inbounds %struct.complex, ptr %766, i64 %770
  %772 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %758, ptr noundef %764, ptr noundef %765, ptr noundef %771, ptr noundef %772)
  br label %773

773:                                              ; preds = %757, %724
  %774 = load i32, ptr %30, align 4, !tbaa !9
  %775 = add nsw i32 %774, 1
  store i32 %775, ptr %30, align 4, !tbaa !9
  br label %855

776:                                              ; preds = %717
  %777 = load i32, ptr %30, align 4, !tbaa !9
  %778 = sub nsw i32 %777, 1
  store i32 %778, ptr %23, align 4, !tbaa !9
  %779 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %779, align 4, !tbaa !11
  %780 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %780, align 4, !tbaa !14
  %781 = load ptr, ptr %12, align 8, !tbaa !5
  %782 = load ptr, ptr %16, align 8, !tbaa !5
  %783 = load i32, ptr %22, align 4, !tbaa !9
  %784 = sext i32 %783 to i64
  %785 = getelementptr inbounds %struct.complex, ptr %782, i64 %784
  %786 = load ptr, ptr %17, align 8, !tbaa !5
  %787 = load ptr, ptr %13, align 8, !tbaa !5
  %788 = load i32, ptr %30, align 4, !tbaa !9
  %789 = load i32, ptr %19, align 4, !tbaa !9
  %790 = mul nsw i32 %788, %789
  %791 = add nsw i32 %790, 1
  %792 = sext i32 %791 to i64
  %793 = getelementptr inbounds %struct.complex, ptr %787, i64 %792
  %794 = load ptr, ptr %16, align 8, !tbaa !5
  %795 = load i32, ptr %30, align 4, !tbaa !9
  %796 = load i32, ptr %21, align 4, !tbaa !9
  %797 = add nsw i32 %795, %796
  %798 = sext i32 %797 to i64
  %799 = getelementptr inbounds %struct.complex, ptr %794, i64 %798
  %800 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %781, ptr noundef %25, ptr noundef %785, ptr noundef %786, ptr noundef %793, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %799, ptr noundef %800)
  %801 = load i32, ptr %30, align 4, !tbaa !9
  %802 = sub nsw i32 %801, 1
  store i32 %802, ptr %23, align 4, !tbaa !9
  %803 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %803, align 4, !tbaa !11
  %804 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %804, align 4, !tbaa !14
  %805 = load ptr, ptr %12, align 8, !tbaa !5
  %806 = load ptr, ptr %16, align 8, !tbaa !5
  %807 = load i32, ptr %22, align 4, !tbaa !9
  %808 = sext i32 %807 to i64
  %809 = getelementptr inbounds %struct.complex, ptr %806, i64 %808
  %810 = load ptr, ptr %17, align 8, !tbaa !5
  %811 = load ptr, ptr %13, align 8, !tbaa !5
  %812 = load i32, ptr %30, align 4, !tbaa !9
  %813 = add nsw i32 %812, 1
  %814 = load i32, ptr %19, align 4, !tbaa !9
  %815 = mul nsw i32 %813, %814
  %816 = add nsw i32 %815, 1
  %817 = sext i32 %816 to i64
  %818 = getelementptr inbounds %struct.complex, ptr %811, i64 %817
  %819 = load ptr, ptr %16, align 8, !tbaa !5
  %820 = load i32, ptr %30, align 4, !tbaa !9
  %821 = add nsw i32 %820, 1
  %822 = load i32, ptr %21, align 4, !tbaa !9
  %823 = add nsw i32 %821, %822
  %824 = sext i32 %823 to i64
  %825 = getelementptr inbounds %struct.complex, ptr %819, i64 %824
  %826 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %805, ptr noundef %25, ptr noundef %809, ptr noundef %810, ptr noundef %818, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %825, ptr noundef %826)
  %827 = load ptr, ptr %15, align 8, !tbaa !5
  %828 = load i32, ptr %30, align 4, !tbaa !9
  %829 = sext i32 %828 to i64
  %830 = getelementptr inbounds i32, ptr %827, i64 %829
  %831 = load i32, ptr %830, align 4, !tbaa !9
  %832 = sub nsw i32 0, %831
  store i32 %832, ptr %35, align 4, !tbaa !9
  %833 = load i32, ptr %35, align 4, !tbaa !9
  %834 = load i32, ptr %30, align 4, !tbaa !9
  %835 = icmp ne i32 %833, %834
  br i1 %835, label %836, label %852

836:                                              ; preds = %776
  %837 = load ptr, ptr %12, align 8, !tbaa !5
  %838 = load ptr, ptr %16, align 8, !tbaa !5
  %839 = load i32, ptr %30, align 4, !tbaa !9
  %840 = load i32, ptr %21, align 4, !tbaa !9
  %841 = add nsw i32 %839, %840
  %842 = sext i32 %841 to i64
  %843 = getelementptr inbounds %struct.complex, ptr %838, i64 %842
  %844 = load ptr, ptr %17, align 8, !tbaa !5
  %845 = load ptr, ptr %16, align 8, !tbaa !5
  %846 = load i32, ptr %35, align 4, !tbaa !9
  %847 = load i32, ptr %21, align 4, !tbaa !9
  %848 = add nsw i32 %846, %847
  %849 = sext i32 %848 to i64
  %850 = getelementptr inbounds %struct.complex, ptr %845, i64 %849
  %851 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %837, ptr noundef %843, ptr noundef %844, ptr noundef %850, ptr noundef %851)
  br label %852

852:                                              ; preds = %836, %776
  %853 = load i32, ptr %30, align 4, !tbaa !9
  %854 = add nsw i32 %853, 2
  store i32 %854, ptr %30, align 4, !tbaa !9
  br label %855

855:                                              ; preds = %852, %773
  br label %711

856:                                              ; preds = %716
  br label %1599

857:                                              ; preds = %178
  store i32 1, ptr %30, align 4, !tbaa !9
  br label %858

858:                                              ; preds = %1418, %857
  %859 = load i32, ptr %30, align 4, !tbaa !9
  %860 = load ptr, ptr %11, align 8, !tbaa !5
  %861 = load i32, ptr %860, align 4, !tbaa !9
  %862 = icmp sgt i32 %859, %861
  br i1 %862, label %863, label %864

863:                                              ; preds = %858
  br label %1419

864:                                              ; preds = %858
  %865 = load ptr, ptr %15, align 8, !tbaa !5
  %866 = load i32, ptr %30, align 4, !tbaa !9
  %867 = sext i32 %866 to i64
  %868 = getelementptr inbounds i32, ptr %865, i64 %867
  %869 = load i32, ptr %868, align 4, !tbaa !9
  %870 = icmp sgt i32 %869, 0
  br i1 %870, label %871, label %970

871:                                              ; preds = %864
  %872 = load ptr, ptr %15, align 8, !tbaa !5
  %873 = load i32, ptr %30, align 4, !tbaa !9
  %874 = sext i32 %873 to i64
  %875 = getelementptr inbounds i32, ptr %872, i64 %874
  %876 = load i32, ptr %875, align 4, !tbaa !9
  store i32 %876, ptr %35, align 4, !tbaa !9
  %877 = load i32, ptr %35, align 4, !tbaa !9
  %878 = load i32, ptr %30, align 4, !tbaa !9
  %879 = icmp ne i32 %877, %878
  br i1 %879, label %880, label %896

880:                                              ; preds = %871
  %881 = load ptr, ptr %12, align 8, !tbaa !5
  %882 = load ptr, ptr %16, align 8, !tbaa !5
  %883 = load i32, ptr %30, align 4, !tbaa !9
  %884 = load i32, ptr %21, align 4, !tbaa !9
  %885 = add nsw i32 %883, %884
  %886 = sext i32 %885 to i64
  %887 = getelementptr inbounds %struct.complex, ptr %882, i64 %886
  %888 = load ptr, ptr %17, align 8, !tbaa !5
  %889 = load ptr, ptr %16, align 8, !tbaa !5
  %890 = load i32, ptr %35, align 4, !tbaa !9
  %891 = load i32, ptr %21, align 4, !tbaa !9
  %892 = add nsw i32 %890, %891
  %893 = sext i32 %892 to i64
  %894 = getelementptr inbounds %struct.complex, ptr %889, i64 %893
  %895 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %881, ptr noundef %887, ptr noundef %888, ptr noundef %894, ptr noundef %895)
  br label %896

896:                                              ; preds = %880, %871
  %897 = load i32, ptr %30, align 4, !tbaa !9
  %898 = load ptr, ptr %11, align 8, !tbaa !5
  %899 = load i32, ptr %898, align 4, !tbaa !9
  %900 = icmp slt i32 %897, %899
  br i1 %900, label %901, label %933

901:                                              ; preds = %896
  %902 = load ptr, ptr %11, align 8, !tbaa !5
  %903 = load i32, ptr %902, align 4, !tbaa !9
  %904 = load i32, ptr %30, align 4, !tbaa !9
  %905 = sub nsw i32 %903, %904
  store i32 %905, ptr %23, align 4, !tbaa !9
  %906 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %906, align 4, !tbaa !11
  %907 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %907, align 4, !tbaa !14
  %908 = load ptr, ptr %12, align 8, !tbaa !5
  %909 = load ptr, ptr %13, align 8, !tbaa !5
  %910 = load i32, ptr %30, align 4, !tbaa !9
  %911 = add nsw i32 %910, 1
  %912 = load i32, ptr %30, align 4, !tbaa !9
  %913 = load i32, ptr %19, align 4, !tbaa !9
  %914 = mul nsw i32 %912, %913
  %915 = add nsw i32 %911, %914
  %916 = sext i32 %915 to i64
  %917 = getelementptr inbounds %struct.complex, ptr %909, i64 %916
  %918 = load ptr, ptr %16, align 8, !tbaa !5
  %919 = load i32, ptr %30, align 4, !tbaa !9
  %920 = load i32, ptr %21, align 4, !tbaa !9
  %921 = add nsw i32 %919, %920
  %922 = sext i32 %921 to i64
  %923 = getelementptr inbounds %struct.complex, ptr %918, i64 %922
  %924 = load ptr, ptr %17, align 8, !tbaa !5
  %925 = load ptr, ptr %16, align 8, !tbaa !5
  %926 = load i32, ptr %30, align 4, !tbaa !9
  %927 = add nsw i32 %926, 1
  %928 = load i32, ptr %21, align 4, !tbaa !9
  %929 = add nsw i32 %927, %928
  %930 = sext i32 %929 to i64
  %931 = getelementptr inbounds %struct.complex, ptr %925, i64 %930
  %932 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgeru_(ptr noundef %23, ptr noundef %908, ptr noundef %25, ptr noundef %917, ptr noundef @c__1, ptr noundef %923, ptr noundef %924, ptr noundef %931, ptr noundef %932)
  br label %933

933:                                              ; preds = %901, %896
  %934 = call <2 x float> @Cf(ptr noundef @c_b1)
  store <2 x float> %934, ptr %60, align 4
  %935 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 0
  %936 = load float, ptr %935, align 4
  %937 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 1
  %938 = load float, ptr %937, align 4
  %939 = load ptr, ptr %13, align 8, !tbaa !5
  %940 = load i32, ptr %30, align 4, !tbaa !9
  %941 = load i32, ptr %30, align 4, !tbaa !9
  %942 = load i32, ptr %19, align 4, !tbaa !9
  %943 = mul nsw i32 %941, %942
  %944 = add nsw i32 %940, %943
  %945 = sext i32 %944 to i64
  %946 = getelementptr inbounds %struct.complex, ptr %939, i64 %945
  %947 = call <2 x float> @Cf(ptr noundef %946)
  store <2 x float> %947, ptr %61, align 4
  %948 = getelementptr inbounds { float, float }, ptr %61, i32 0, i32 0
  %949 = load float, ptr %948, align 4
  %950 = getelementptr inbounds { float, float }, ptr %61, i32 0, i32 1
  %951 = load float, ptr %950, align 4
  %952 = call <2 x float> @__divsc3(float noundef %936, float noundef %938, float noundef %949, float noundef %951) #6
  store <2 x float> %952, ptr %62, align 4
  %953 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 0
  %954 = load float, ptr %953, align 4
  %955 = getelementptr inbounds { float, float }, ptr %62, i32 0, i32 1
  %956 = load float, ptr %955, align 4
  %957 = call ptr @_pCf(ptr noundef %25)
  %958 = getelementptr inbounds { float, float }, ptr %957, i32 0, i32 0
  %959 = getelementptr inbounds { float, float }, ptr %957, i32 0, i32 1
  store float %954, ptr %958, align 4
  store float %956, ptr %959, align 4
  %960 = load ptr, ptr %12, align 8, !tbaa !5
  %961 = load ptr, ptr %16, align 8, !tbaa !5
  %962 = load i32, ptr %30, align 4, !tbaa !9
  %963 = load i32, ptr %21, align 4, !tbaa !9
  %964 = add nsw i32 %962, %963
  %965 = sext i32 %964 to i64
  %966 = getelementptr inbounds %struct.complex, ptr %961, i64 %965
  %967 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cscal_(ptr noundef %960, ptr noundef %25, ptr noundef %966, ptr noundef %967)
  %968 = load i32, ptr %30, align 4, !tbaa !9
  %969 = add nsw i32 %968, 1
  store i32 %969, ptr %30, align 4, !tbaa !9
  br label %1418

970:                                              ; preds = %864
  %971 = load ptr, ptr %15, align 8, !tbaa !5
  %972 = load i32, ptr %30, align 4, !tbaa !9
  %973 = sext i32 %972 to i64
  %974 = getelementptr inbounds i32, ptr %971, i64 %973
  %975 = load i32, ptr %974, align 4, !tbaa !9
  %976 = sub nsw i32 0, %975
  store i32 %976, ptr %35, align 4, !tbaa !9
  %977 = load i32, ptr %35, align 4, !tbaa !9
  %978 = load i32, ptr %30, align 4, !tbaa !9
  %979 = add nsw i32 %978, 1
  %980 = icmp ne i32 %977, %979
  br i1 %980, label %981, label %998

981:                                              ; preds = %970
  %982 = load ptr, ptr %12, align 8, !tbaa !5
  %983 = load ptr, ptr %16, align 8, !tbaa !5
  %984 = load i32, ptr %30, align 4, !tbaa !9
  %985 = add nsw i32 %984, 1
  %986 = load i32, ptr %21, align 4, !tbaa !9
  %987 = add nsw i32 %985, %986
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds %struct.complex, ptr %983, i64 %988
  %990 = load ptr, ptr %17, align 8, !tbaa !5
  %991 = load ptr, ptr %16, align 8, !tbaa !5
  %992 = load i32, ptr %35, align 4, !tbaa !9
  %993 = load i32, ptr %21, align 4, !tbaa !9
  %994 = add nsw i32 %992, %993
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds %struct.complex, ptr %991, i64 %995
  %997 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %982, ptr noundef %989, ptr noundef %990, ptr noundef %996, ptr noundef %997)
  br label %998

998:                                              ; preds = %981, %970
  %999 = load i32, ptr %30, align 4, !tbaa !9
  %1000 = load ptr, ptr %11, align 8, !tbaa !5
  %1001 = load i32, ptr %1000, align 4, !tbaa !9
  %1002 = sub nsw i32 %1001, 1
  %1003 = icmp slt i32 %999, %1002
  br i1 %1003, label %1004, label %1071

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

1071:                                             ; preds = %1004, %998
  %1072 = load i32, ptr %30, align 4, !tbaa !9
  %1073 = add nsw i32 %1072, 1
  %1074 = load i32, ptr %30, align 4, !tbaa !9
  %1075 = load i32, ptr %19, align 4, !tbaa !9
  %1076 = mul nsw i32 %1074, %1075
  %1077 = add nsw i32 %1073, %1076
  store i32 %1077, ptr %23, align 4, !tbaa !9
  %1078 = load ptr, ptr %13, align 8, !tbaa !5
  %1079 = load i32, ptr %23, align 4, !tbaa !9
  %1080 = sext i32 %1079 to i64
  %1081 = getelementptr inbounds %struct.complex, ptr %1078, i64 %1080
  %1082 = getelementptr inbounds %struct.complex, ptr %1081, i32 0, i32 0
  %1083 = load float, ptr %1082, align 4, !tbaa !11
  %1084 = getelementptr inbounds %struct.complex, ptr %28, i32 0, i32 0
  store float %1083, ptr %1084, align 4, !tbaa !11
  %1085 = load ptr, ptr %13, align 8, !tbaa !5
  %1086 = load i32, ptr %23, align 4, !tbaa !9
  %1087 = sext i32 %1086 to i64
  %1088 = getelementptr inbounds %struct.complex, ptr %1085, i64 %1087
  %1089 = getelementptr inbounds %struct.complex, ptr %1088, i32 0, i32 1
  %1090 = load float, ptr %1089, align 4, !tbaa !14
  %1091 = getelementptr inbounds %struct.complex, ptr %28, i32 0, i32 1
  store float %1090, ptr %1091, align 4, !tbaa !14
  %1092 = load ptr, ptr %13, align 8, !tbaa !5
  %1093 = load i32, ptr %30, align 4, !tbaa !9
  %1094 = load i32, ptr %30, align 4, !tbaa !9
  %1095 = load i32, ptr %19, align 4, !tbaa !9
  %1096 = mul nsw i32 %1094, %1095
  %1097 = add nsw i32 %1093, %1096
  %1098 = sext i32 %1097 to i64
  %1099 = getelementptr inbounds %struct.complex, ptr %1092, i64 %1098
  %1100 = call <2 x float> @Cf(ptr noundef %1099)
  store <2 x float> %1100, ptr %63, align 4
  %1101 = getelementptr inbounds { float, float }, ptr %63, i32 0, i32 0
  %1102 = load float, ptr %1101, align 4
  %1103 = getelementptr inbounds { float, float }, ptr %63, i32 0, i32 1
  %1104 = load float, ptr %1103, align 4
  %1105 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %1105, ptr %64, align 4
  %1106 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 0
  %1107 = load float, ptr %1106, align 4
  %1108 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 1
  %1109 = load float, ptr %1108, align 4
  %1110 = call <2 x float> @__divsc3(float noundef %1102, float noundef %1104, float noundef %1107, float noundef %1109) #6
  store <2 x float> %1110, ptr %65, align 4
  %1111 = getelementptr inbounds { float, float }, ptr %65, i32 0, i32 0
  %1112 = load float, ptr %1111, align 4
  %1113 = getelementptr inbounds { float, float }, ptr %65, i32 0, i32 1
  %1114 = load float, ptr %1113, align 4
  %1115 = call ptr @_pCf(ptr noundef %25)
  %1116 = getelementptr inbounds { float, float }, ptr %1115, i32 0, i32 0
  %1117 = getelementptr inbounds { float, float }, ptr %1115, i32 0, i32 1
  store float %1112, ptr %1116, align 4
  store float %1114, ptr %1117, align 4
  %1118 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1119 = load float, ptr %1118, align 4, !tbaa !11
  %1120 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %1119, ptr %1120, align 4, !tbaa !11
  %1121 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1122 = load float, ptr %1121, align 4, !tbaa !14
  %1123 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %1122, ptr %1123, align 4, !tbaa !14
  %1124 = load ptr, ptr %13, align 8, !tbaa !5
  %1125 = load i32, ptr %30, align 4, !tbaa !9
  %1126 = add nsw i32 %1125, 1
  %1127 = load i32, ptr %30, align 4, !tbaa !9
  %1128 = add nsw i32 %1127, 1
  %1129 = load i32, ptr %19, align 4, !tbaa !9
  %1130 = mul nsw i32 %1128, %1129
  %1131 = add nsw i32 %1126, %1130
  %1132 = sext i32 %1131 to i64
  %1133 = getelementptr inbounds %struct.complex, ptr %1124, i64 %1132
  %1134 = call <2 x float> @Cf(ptr noundef %1133)
  store <2 x float> %1134, ptr %66, align 4
  %1135 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 0
  %1136 = load float, ptr %1135, align 4
  %1137 = getelementptr inbounds { float, float }, ptr %66, i32 0, i32 1
  %1138 = load float, ptr %1137, align 4
  %1139 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %1139, ptr %67, align 4
  %1140 = getelementptr inbounds { float, float }, ptr %67, i32 0, i32 0
  %1141 = load float, ptr %1140, align 4
  %1142 = getelementptr inbounds { float, float }, ptr %67, i32 0, i32 1
  %1143 = load float, ptr %1142, align 4
  %1144 = call <2 x float> @__divsc3(float noundef %1136, float noundef %1138, float noundef %1141, float noundef %1143) #6
  store <2 x float> %1144, ptr %68, align 4
  %1145 = getelementptr inbounds { float, float }, ptr %68, i32 0, i32 0
  %1146 = load float, ptr %1145, align 4
  %1147 = getelementptr inbounds { float, float }, ptr %68, i32 0, i32 1
  %1148 = load float, ptr %1147, align 4
  %1149 = call ptr @_pCf(ptr noundef %25)
  %1150 = getelementptr inbounds { float, float }, ptr %1149, i32 0, i32 0
  %1151 = getelementptr inbounds { float, float }, ptr %1149, i32 0, i32 1
  store float %1146, ptr %1150, align 4
  store float %1148, ptr %1151, align 4
  %1152 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1153 = load float, ptr %1152, align 4, !tbaa !11
  %1154 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1153, ptr %1154, align 4, !tbaa !11
  %1155 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1156 = load float, ptr %1155, align 4, !tbaa !14
  %1157 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1156, ptr %1157, align 4, !tbaa !14
  %1158 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1159 = load float, ptr %1158, align 4, !tbaa !11
  %1160 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1161 = load float, ptr %1160, align 4, !tbaa !11
  %1162 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1163 = load float, ptr %1162, align 4, !tbaa !14
  %1164 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1165 = load float, ptr %1164, align 4, !tbaa !14
  %1166 = fmul float %1163, %1165
  %1167 = fneg float %1166
  %1168 = call float @llvm.fmuladd.f32(float %1159, float %1161, float %1167)
  %1169 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %1168, ptr %1169, align 4, !tbaa !11
  %1170 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1171 = load float, ptr %1170, align 4, !tbaa !11
  %1172 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1173 = load float, ptr %1172, align 4, !tbaa !14
  %1174 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1175 = load float, ptr %1174, align 4, !tbaa !14
  %1176 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1177 = load float, ptr %1176, align 4, !tbaa !11
  %1178 = fmul float %1175, %1177
  %1179 = call float @llvm.fmuladd.f32(float %1171, float %1173, float %1178)
  %1180 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %1179, ptr %1180, align 4, !tbaa !14
  %1181 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %1182 = load float, ptr %1181, align 4, !tbaa !11
  %1183 = fsub float %1182, 1.000000e+00
  %1184 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float %1183, ptr %1184, align 4, !tbaa !11
  %1185 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %1186 = load float, ptr %1185, align 4, !tbaa !14
  %1187 = fadd float %1186, 0.000000e+00
  %1188 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float %1187, ptr %1188, align 4, !tbaa !14
  %1189 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1190 = load float, ptr %1189, align 4, !tbaa !11
  %1191 = getelementptr inbounds %struct.complex, ptr %31, i32 0, i32 0
  store float %1190, ptr %1191, align 4, !tbaa !11
  %1192 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1193 = load float, ptr %1192, align 4, !tbaa !14
  %1194 = getelementptr inbounds %struct.complex, ptr %31, i32 0, i32 1
  store float %1193, ptr %1194, align 4, !tbaa !14
  %1195 = load ptr, ptr %12, align 8, !tbaa !5
  %1196 = load i32, ptr %1195, align 4, !tbaa !9
  store i32 %1196, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %29, align 4, !tbaa !9
  br label %1197

1197:                                             ; preds = %1412, %1071
  %1198 = load i32, ptr %29, align 4, !tbaa !9
  %1199 = load i32, ptr %23, align 4, !tbaa !9
  %1200 = icmp sle i32 %1198, %1199
  br i1 %1200, label %1201, label %1415

1201:                                             ; preds = %1197
  %1202 = load ptr, ptr %16, align 8, !tbaa !5
  %1203 = load i32, ptr %30, align 4, !tbaa !9
  %1204 = load i32, ptr %29, align 4, !tbaa !9
  %1205 = load i32, ptr %21, align 4, !tbaa !9
  %1206 = mul nsw i32 %1204, %1205
  %1207 = add nsw i32 %1203, %1206
  %1208 = sext i32 %1207 to i64
  %1209 = getelementptr inbounds %struct.complex, ptr %1202, i64 %1208
  %1210 = call <2 x float> @Cf(ptr noundef %1209)
  store <2 x float> %1210, ptr %69, align 4
  %1211 = getelementptr inbounds { float, float }, ptr %69, i32 0, i32 0
  %1212 = load float, ptr %1211, align 4
  %1213 = getelementptr inbounds { float, float }, ptr %69, i32 0, i32 1
  %1214 = load float, ptr %1213, align 4
  %1215 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %1215, ptr %70, align 4
  %1216 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 0
  %1217 = load float, ptr %1216, align 4
  %1218 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 1
  %1219 = load float, ptr %1218, align 4
  %1220 = call <2 x float> @__divsc3(float noundef %1212, float noundef %1214, float noundef %1217, float noundef %1219) #6
  store <2 x float> %1220, ptr %71, align 4
  %1221 = getelementptr inbounds { float, float }, ptr %71, i32 0, i32 0
  %1222 = load float, ptr %1221, align 4
  %1223 = getelementptr inbounds { float, float }, ptr %71, i32 0, i32 1
  %1224 = load float, ptr %1223, align 4
  %1225 = call ptr @_pCf(ptr noundef %25)
  %1226 = getelementptr inbounds { float, float }, ptr %1225, i32 0, i32 0
  %1227 = getelementptr inbounds { float, float }, ptr %1225, i32 0, i32 1
  store float %1222, ptr %1226, align 4
  store float %1224, ptr %1227, align 4
  %1228 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1229 = load float, ptr %1228, align 4, !tbaa !11
  %1230 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  store float %1229, ptr %1230, align 4, !tbaa !11
  %1231 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1232 = load float, ptr %1231, align 4, !tbaa !14
  %1233 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  store float %1232, ptr %1233, align 4, !tbaa !14
  %1234 = load ptr, ptr %16, align 8, !tbaa !5
  %1235 = load i32, ptr %30, align 4, !tbaa !9
  %1236 = add nsw i32 %1235, 1
  %1237 = load i32, ptr %29, align 4, !tbaa !9
  %1238 = load i32, ptr %21, align 4, !tbaa !9
  %1239 = mul nsw i32 %1237, %1238
  %1240 = add nsw i32 %1236, %1239
  %1241 = sext i32 %1240 to i64
  %1242 = getelementptr inbounds %struct.complex, ptr %1234, i64 %1241
  %1243 = call <2 x float> @Cf(ptr noundef %1242)
  store <2 x float> %1243, ptr %72, align 4
  %1244 = getelementptr inbounds { float, float }, ptr %72, i32 0, i32 0
  %1245 = load float, ptr %1244, align 4
  %1246 = getelementptr inbounds { float, float }, ptr %72, i32 0, i32 1
  %1247 = load float, ptr %1246, align 4
  %1248 = call <2 x float> @Cf(ptr noundef %28)
  store <2 x float> %1248, ptr %73, align 4
  %1249 = getelementptr inbounds { float, float }, ptr %73, i32 0, i32 0
  %1250 = load float, ptr %1249, align 4
  %1251 = getelementptr inbounds { float, float }, ptr %73, i32 0, i32 1
  %1252 = load float, ptr %1251, align 4
  %1253 = call <2 x float> @__divsc3(float noundef %1245, float noundef %1247, float noundef %1250, float noundef %1252) #6
  store <2 x float> %1253, ptr %74, align 4
  %1254 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 0
  %1255 = load float, ptr %1254, align 4
  %1256 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 1
  %1257 = load float, ptr %1256, align 4
  %1258 = call ptr @_pCf(ptr noundef %25)
  %1259 = getelementptr inbounds { float, float }, ptr %1258, i32 0, i32 0
  %1260 = getelementptr inbounds { float, float }, ptr %1258, i32 0, i32 1
  store float %1255, ptr %1259, align 4
  store float %1257, ptr %1260, align 4
  %1261 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1262 = load float, ptr %1261, align 4, !tbaa !11
  %1263 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1262, ptr %1263, align 4, !tbaa !11
  %1264 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1265 = load float, ptr %1264, align 4, !tbaa !14
  %1266 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1265, ptr %1266, align 4, !tbaa !14
  %1267 = load i32, ptr %30, align 4, !tbaa !9
  %1268 = load i32, ptr %29, align 4, !tbaa !9
  %1269 = load i32, ptr %21, align 4, !tbaa !9
  %1270 = mul nsw i32 %1268, %1269
  %1271 = add nsw i32 %1267, %1270
  store i32 %1271, ptr %24, align 4, !tbaa !9
  %1272 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1273 = load float, ptr %1272, align 4, !tbaa !11
  %1274 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %1275 = load float, ptr %1274, align 4, !tbaa !11
  %1276 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1277 = load float, ptr %1276, align 4, !tbaa !14
  %1278 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %1279 = load float, ptr %1278, align 4, !tbaa !14
  %1280 = fmul float %1277, %1279
  %1281 = fneg float %1280
  %1282 = call float @llvm.fmuladd.f32(float %1273, float %1275, float %1281)
  %1283 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  store float %1282, ptr %1283, align 4, !tbaa !11
  %1284 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1285 = load float, ptr %1284, align 4, !tbaa !11
  %1286 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %1287 = load float, ptr %1286, align 4, !tbaa !14
  %1288 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1289 = load float, ptr %1288, align 4, !tbaa !14
  %1290 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %1291 = load float, ptr %1290, align 4, !tbaa !11
  %1292 = fmul float %1289, %1291
  %1293 = call float @llvm.fmuladd.f32(float %1285, float %1287, float %1292)
  %1294 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  store float %1293, ptr %1294, align 4, !tbaa !14
  %1295 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %1296 = load float, ptr %1295, align 4, !tbaa !11
  %1297 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1298 = load float, ptr %1297, align 4, !tbaa !11
  %1299 = fsub float %1296, %1298
  %1300 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %1299, ptr %1300, align 4, !tbaa !11
  %1301 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %1302 = load float, ptr %1301, align 4, !tbaa !14
  %1303 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1304 = load float, ptr %1303, align 4, !tbaa !14
  %1305 = fsub float %1302, %1304
  %1306 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %1305, ptr %1306, align 4, !tbaa !14
  %1307 = call <2 x float> @Cf(ptr noundef %26)
  store <2 x float> %1307, ptr %75, align 4
  %1308 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 0
  %1309 = load float, ptr %1308, align 4
  %1310 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 1
  %1311 = load float, ptr %1310, align 4
  %1312 = call <2 x float> @Cf(ptr noundef %31)
  store <2 x float> %1312, ptr %76, align 4
  %1313 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 0
  %1314 = load float, ptr %1313, align 4
  %1315 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 1
  %1316 = load float, ptr %1315, align 4
  %1317 = call <2 x float> @__divsc3(float noundef %1309, float noundef %1311, float noundef %1314, float noundef %1316) #6
  store <2 x float> %1317, ptr %77, align 4
  %1318 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 0
  %1319 = load float, ptr %1318, align 4
  %1320 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 1
  %1321 = load float, ptr %1320, align 4
  %1322 = call ptr @_pCf(ptr noundef %25)
  %1323 = getelementptr inbounds { float, float }, ptr %1322, i32 0, i32 0
  %1324 = getelementptr inbounds { float, float }, ptr %1322, i32 0, i32 1
  store float %1319, ptr %1323, align 4
  store float %1321, ptr %1324, align 4
  %1325 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1326 = load float, ptr %1325, align 4, !tbaa !11
  %1327 = load ptr, ptr %16, align 8, !tbaa !5
  %1328 = load i32, ptr %24, align 4, !tbaa !9
  %1329 = sext i32 %1328 to i64
  %1330 = getelementptr inbounds %struct.complex, ptr %1327, i64 %1329
  %1331 = getelementptr inbounds %struct.complex, ptr %1330, i32 0, i32 0
  store float %1326, ptr %1331, align 4, !tbaa !11
  %1332 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1333 = load float, ptr %1332, align 4, !tbaa !14
  %1334 = load ptr, ptr %16, align 8, !tbaa !5
  %1335 = load i32, ptr %24, align 4, !tbaa !9
  %1336 = sext i32 %1335 to i64
  %1337 = getelementptr inbounds %struct.complex, ptr %1334, i64 %1336
  %1338 = getelementptr inbounds %struct.complex, ptr %1337, i32 0, i32 1
  store float %1333, ptr %1338, align 4, !tbaa !14
  %1339 = load i32, ptr %30, align 4, !tbaa !9
  %1340 = add nsw i32 %1339, 1
  %1341 = load i32, ptr %29, align 4, !tbaa !9
  %1342 = load i32, ptr %21, align 4, !tbaa !9
  %1343 = mul nsw i32 %1341, %1342
  %1344 = add nsw i32 %1340, %1343
  store i32 %1344, ptr %24, align 4, !tbaa !9
  %1345 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1346 = load float, ptr %1345, align 4, !tbaa !11
  %1347 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1348 = load float, ptr %1347, align 4, !tbaa !11
  %1349 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1350 = load float, ptr %1349, align 4, !tbaa !14
  %1351 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1352 = load float, ptr %1351, align 4, !tbaa !14
  %1353 = fmul float %1350, %1352
  %1354 = fneg float %1353
  %1355 = call float @llvm.fmuladd.f32(float %1346, float %1348, float %1354)
  %1356 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  store float %1355, ptr %1356, align 4, !tbaa !11
  %1357 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1358 = load float, ptr %1357, align 4, !tbaa !11
  %1359 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1360 = load float, ptr %1359, align 4, !tbaa !14
  %1361 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1362 = load float, ptr %1361, align 4, !tbaa !14
  %1363 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1364 = load float, ptr %1363, align 4, !tbaa !11
  %1365 = fmul float %1362, %1364
  %1366 = call float @llvm.fmuladd.f32(float %1358, float %1360, float %1365)
  %1367 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  store float %1366, ptr %1367, align 4, !tbaa !14
  %1368 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %1369 = load float, ptr %1368, align 4, !tbaa !11
  %1370 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %1371 = load float, ptr %1370, align 4, !tbaa !11
  %1372 = fsub float %1369, %1371
  %1373 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float %1372, ptr %1373, align 4, !tbaa !11
  %1374 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %1375 = load float, ptr %1374, align 4, !tbaa !14
  %1376 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %1377 = load float, ptr %1376, align 4, !tbaa !14
  %1378 = fsub float %1375, %1377
  %1379 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float %1378, ptr %1379, align 4, !tbaa !14
  %1380 = call <2 x float> @Cf(ptr noundef %26)
  store <2 x float> %1380, ptr %78, align 4
  %1381 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 0
  %1382 = load float, ptr %1381, align 4
  %1383 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 1
  %1384 = load float, ptr %1383, align 4
  %1385 = call <2 x float> @Cf(ptr noundef %31)
  store <2 x float> %1385, ptr %79, align 4
  %1386 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 0
  %1387 = load float, ptr %1386, align 4
  %1388 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 1
  %1389 = load float, ptr %1388, align 4
  %1390 = call <2 x float> @__divsc3(float noundef %1382, float noundef %1384, float noundef %1387, float noundef %1389) #6
  store <2 x float> %1390, ptr %80, align 4
  %1391 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 0
  %1392 = load float, ptr %1391, align 4
  %1393 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 1
  %1394 = load float, ptr %1393, align 4
  %1395 = call ptr @_pCf(ptr noundef %25)
  %1396 = getelementptr inbounds { float, float }, ptr %1395, i32 0, i32 0
  %1397 = getelementptr inbounds { float, float }, ptr %1395, i32 0, i32 1
  store float %1392, ptr %1396, align 4
  store float %1394, ptr %1397, align 4
  %1398 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %1399 = load float, ptr %1398, align 4, !tbaa !11
  %1400 = load ptr, ptr %16, align 8, !tbaa !5
  %1401 = load i32, ptr %24, align 4, !tbaa !9
  %1402 = sext i32 %1401 to i64
  %1403 = getelementptr inbounds %struct.complex, ptr %1400, i64 %1402
  %1404 = getelementptr inbounds %struct.complex, ptr %1403, i32 0, i32 0
  store float %1399, ptr %1404, align 4, !tbaa !11
  %1405 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %1406 = load float, ptr %1405, align 4, !tbaa !14
  %1407 = load ptr, ptr %16, align 8, !tbaa !5
  %1408 = load i32, ptr %24, align 4, !tbaa !9
  %1409 = sext i32 %1408 to i64
  %1410 = getelementptr inbounds %struct.complex, ptr %1407, i64 %1409
  %1411 = getelementptr inbounds %struct.complex, ptr %1410, i32 0, i32 1
  store float %1406, ptr %1411, align 4, !tbaa !14
  br label %1412

1412:                                             ; preds = %1201
  %1413 = load i32, ptr %29, align 4, !tbaa !9
  %1414 = add nsw i32 %1413, 1
  store i32 %1414, ptr %29, align 4, !tbaa !9
  br label %1197, !llvm.loop !17

1415:                                             ; preds = %1197
  %1416 = load i32, ptr %30, align 4, !tbaa !9
  %1417 = add nsw i32 %1416, 2
  store i32 %1417, ptr %30, align 4, !tbaa !9
  br label %1418

1418:                                             ; preds = %1415, %933
  br label %858

1419:                                             ; preds = %863
  %1420 = load ptr, ptr %11, align 8, !tbaa !5
  %1421 = load i32, ptr %1420, align 4, !tbaa !9
  store i32 %1421, ptr %30, align 4, !tbaa !9
  br label %1422

1422:                                             ; preds = %1597, %1419
  %1423 = load i32, ptr %30, align 4, !tbaa !9
  %1424 = icmp slt i32 %1423, 1
  br i1 %1424, label %1425, label %1426

1425:                                             ; preds = %1422
  br label %1598

1426:                                             ; preds = %1422
  %1427 = load ptr, ptr %15, align 8, !tbaa !5
  %1428 = load i32, ptr %30, align 4, !tbaa !9
  %1429 = sext i32 %1428 to i64
  %1430 = getelementptr inbounds i32, ptr %1427, i64 %1429
  %1431 = load i32, ptr %1430, align 4, !tbaa !9
  %1432 = icmp sgt i32 %1431, 0
  br i1 %1432, label %1433, label %1498

1433:                                             ; preds = %1426
  %1434 = load i32, ptr %30, align 4, !tbaa !9
  %1435 = load ptr, ptr %11, align 8, !tbaa !5
  %1436 = load i32, ptr %1435, align 4, !tbaa !9
  %1437 = icmp slt i32 %1434, %1436
  br i1 %1437, label %1438, label %1470

1438:                                             ; preds = %1433
  %1439 = load ptr, ptr %11, align 8, !tbaa !5
  %1440 = load i32, ptr %1439, align 4, !tbaa !9
  %1441 = load i32, ptr %30, align 4, !tbaa !9
  %1442 = sub nsw i32 %1440, %1441
  store i32 %1442, ptr %23, align 4, !tbaa !9
  %1443 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %1443, align 4, !tbaa !11
  %1444 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %1444, align 4, !tbaa !14
  %1445 = load ptr, ptr %12, align 8, !tbaa !5
  %1446 = load ptr, ptr %16, align 8, !tbaa !5
  %1447 = load i32, ptr %30, align 4, !tbaa !9
  %1448 = add nsw i32 %1447, 1
  %1449 = load i32, ptr %21, align 4, !tbaa !9
  %1450 = add nsw i32 %1448, %1449
  %1451 = sext i32 %1450 to i64
  %1452 = getelementptr inbounds %struct.complex, ptr %1446, i64 %1451
  %1453 = load ptr, ptr %17, align 8, !tbaa !5
  %1454 = load ptr, ptr %13, align 8, !tbaa !5
  %1455 = load i32, ptr %30, align 4, !tbaa !9
  %1456 = add nsw i32 %1455, 1
  %1457 = load i32, ptr %30, align 4, !tbaa !9
  %1458 = load i32, ptr %19, align 4, !tbaa !9
  %1459 = mul nsw i32 %1457, %1458
  %1460 = add nsw i32 %1456, %1459
  %1461 = sext i32 %1460 to i64
  %1462 = getelementptr inbounds %struct.complex, ptr %1454, i64 %1461
  %1463 = load ptr, ptr %16, align 8, !tbaa !5
  %1464 = load i32, ptr %30, align 4, !tbaa !9
  %1465 = load i32, ptr %21, align 4, !tbaa !9
  %1466 = add nsw i32 %1464, %1465
  %1467 = sext i32 %1466 to i64
  %1468 = getelementptr inbounds %struct.complex, ptr %1463, i64 %1467
  %1469 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1445, ptr noundef %25, ptr noundef %1452, ptr noundef %1453, ptr noundef %1462, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1468, ptr noundef %1469)
  br label %1470

1470:                                             ; preds = %1438, %1433
  %1471 = load ptr, ptr %15, align 8, !tbaa !5
  %1472 = load i32, ptr %30, align 4, !tbaa !9
  %1473 = sext i32 %1472 to i64
  %1474 = getelementptr inbounds i32, ptr %1471, i64 %1473
  %1475 = load i32, ptr %1474, align 4, !tbaa !9
  store i32 %1475, ptr %35, align 4, !tbaa !9
  %1476 = load i32, ptr %35, align 4, !tbaa !9
  %1477 = load i32, ptr %30, align 4, !tbaa !9
  %1478 = icmp ne i32 %1476, %1477
  br i1 %1478, label %1479, label %1495

1479:                                             ; preds = %1470
  %1480 = load ptr, ptr %12, align 8, !tbaa !5
  %1481 = load ptr, ptr %16, align 8, !tbaa !5
  %1482 = load i32, ptr %30, align 4, !tbaa !9
  %1483 = load i32, ptr %21, align 4, !tbaa !9
  %1484 = add nsw i32 %1482, %1483
  %1485 = sext i32 %1484 to i64
  %1486 = getelementptr inbounds %struct.complex, ptr %1481, i64 %1485
  %1487 = load ptr, ptr %17, align 8, !tbaa !5
  %1488 = load ptr, ptr %16, align 8, !tbaa !5
  %1489 = load i32, ptr %35, align 4, !tbaa !9
  %1490 = load i32, ptr %21, align 4, !tbaa !9
  %1491 = add nsw i32 %1489, %1490
  %1492 = sext i32 %1491 to i64
  %1493 = getelementptr inbounds %struct.complex, ptr %1488, i64 %1492
  %1494 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cswap_(ptr noundef %1480, ptr noundef %1486, ptr noundef %1487, ptr noundef %1493, ptr noundef %1494)
  br label %1495

1495:                                             ; preds = %1479, %1470
  %1496 = load i32, ptr %30, align 4, !tbaa !9
  %1497 = add nsw i32 %1496, -1
  store i32 %1497, ptr %30, align 4, !tbaa !9
  br label %1597

1498:                                             ; preds = %1426
  %1499 = load i32, ptr %30, align 4, !tbaa !9
  %1500 = load ptr, ptr %11, align 8, !tbaa !5
  %1501 = load i32, ptr %1500, align 4, !tbaa !9
  %1502 = icmp slt i32 %1499, %1501
  br i1 %1502, label %1503, label %1568

1503:                                             ; preds = %1498
  %1504 = load ptr, ptr %11, align 8, !tbaa !5
  %1505 = load i32, ptr %1504, align 4, !tbaa !9
  %1506 = load i32, ptr %30, align 4, !tbaa !9
  %1507 = sub nsw i32 %1505, %1506
  store i32 %1507, ptr %23, align 4, !tbaa !9
  %1508 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %1508, align 4, !tbaa !11
  %1509 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %1509, align 4, !tbaa !14
  %1510 = load ptr, ptr %12, align 8, !tbaa !5
  %1511 = load ptr, ptr %16, align 8, !tbaa !5
  %1512 = load i32, ptr %30, align 4, !tbaa !9
  %1513 = add nsw i32 %1512, 1
  %1514 = load i32, ptr %21, align 4, !tbaa !9
  %1515 = add nsw i32 %1513, %1514
  %1516 = sext i32 %1515 to i64
  %1517 = getelementptr inbounds %struct.complex, ptr %1511, i64 %1516
  %1518 = load ptr, ptr %17, align 8, !tbaa !5
  %1519 = load ptr, ptr %13, align 8, !tbaa !5
  %1520 = load i32, ptr %30, align 4, !tbaa !9
  %1521 = add nsw i32 %1520, 1
  %1522 = load i32, ptr %30, align 4, !tbaa !9
  %1523 = load i32, ptr %19, align 4, !tbaa !9
  %1524 = mul nsw i32 %1522, %1523
  %1525 = add nsw i32 %1521, %1524
  %1526 = sext i32 %1525 to i64
  %1527 = getelementptr inbounds %struct.complex, ptr %1519, i64 %1526
  %1528 = load ptr, ptr %16, align 8, !tbaa !5
  %1529 = load i32, ptr %30, align 4, !tbaa !9
  %1530 = load i32, ptr %21, align 4, !tbaa !9
  %1531 = add nsw i32 %1529, %1530
  %1532 = sext i32 %1531 to i64
  %1533 = getelementptr inbounds %struct.complex, ptr %1528, i64 %1532
  %1534 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1510, ptr noundef %25, ptr noundef %1517, ptr noundef %1518, ptr noundef %1527, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1533, ptr noundef %1534)
  %1535 = load ptr, ptr %11, align 8, !tbaa !5
  %1536 = load i32, ptr %1535, align 4, !tbaa !9
  %1537 = load i32, ptr %30, align 4, !tbaa !9
  %1538 = sub nsw i32 %1536, %1537
  store i32 %1538, ptr %23, align 4, !tbaa !9
  %1539 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float -1.000000e+00, ptr %1539, align 4, !tbaa !11
  %1540 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float 0.000000e+00, ptr %1540, align 4, !tbaa !14
  %1541 = load ptr, ptr %12, align 8, !tbaa !5
  %1542 = load ptr, ptr %16, align 8, !tbaa !5
  %1543 = load i32, ptr %30, align 4, !tbaa !9
  %1544 = add nsw i32 %1543, 1
  %1545 = load i32, ptr %21, align 4, !tbaa !9
  %1546 = add nsw i32 %1544, %1545
  %1547 = sext i32 %1546 to i64
  %1548 = getelementptr inbounds %struct.complex, ptr %1542, i64 %1547
  %1549 = load ptr, ptr %17, align 8, !tbaa !5
  %1550 = load ptr, ptr %13, align 8, !tbaa !5
  %1551 = load i32, ptr %30, align 4, !tbaa !9
  %1552 = add nsw i32 %1551, 1
  %1553 = load i32, ptr %30, align 4, !tbaa !9
  %1554 = sub nsw i32 %1553, 1
  %1555 = load i32, ptr %19, align 4, !tbaa !9
  %1556 = mul nsw i32 %1554, %1555
  %1557 = add nsw i32 %1552, %1556
  %1558 = sext i32 %1557 to i64
  %1559 = getelementptr inbounds %struct.complex, ptr %1550, i64 %1558
  %1560 = load ptr, ptr %16, align 8, !tbaa !5
  %1561 = load i32, ptr %30, align 4, !tbaa !9
  %1562 = sub nsw i32 %1561, 1
  %1563 = load i32, ptr %21, align 4, !tbaa !9
  %1564 = add nsw i32 %1562, %1563
  %1565 = sext i32 %1564 to i64
  %1566 = getelementptr inbounds %struct.complex, ptr %1560, i64 %1565
  %1567 = load ptr, ptr %17, align 8, !tbaa !5
  call void @cgemv_(ptr noundef @.str.3, ptr noundef %23, ptr noundef %1541, ptr noundef %25, ptr noundef %1548, ptr noundef %1549, ptr noundef %1559, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %1566, ptr noundef %1567)
  br label %1568

1568:                                             ; preds = %1503, %1498
  %1569 = load ptr, ptr %15, align 8, !tbaa !5
  %1570 = load i32, ptr %30, align 4, !tbaa !9
  %1571 = sext i32 %1570 to i64
  %1572 = getelementptr inbounds i32, ptr %1569, i64 %1571
  %1573 = load i32, ptr %1572, align 4, !tbaa !9
  %1574 = sub nsw i32 0, %1573
  store i32 %1574, ptr %35, align 4, !tbaa !9
  %1575 = load i32, ptr %35, align 4, !tbaa !9
  %1576 = load i32, ptr %30, align 4, !tbaa !9
  %1577 = icmp ne i32 %1575, %1576
  br i1 %1577, label %1578, label %1594

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

1594:                                             ; preds = %1578, %1568
  %1595 = load i32, ptr %30, align 4, !tbaa !9
  %1596 = add nsw i32 %1595, -2
  store i32 %1596, ptr %30, align 4, !tbaa !9
  br label %1597

1597:                                             ; preds = %1594, %1495
  br label %1422

1598:                                             ; preds = %1425
  br label %1599

1599:                                             ; preds = %1598, %856
  store i32 1, ptr %38, align 4
  br label %1600

1600:                                             ; preds = %1599, %177, %164
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  ret void
}

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

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @Cf(ptr noundef) #3

declare <2 x float> @__divsc3(float, float, float, float)

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

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

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

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

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

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


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

%struct.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1
@c__1 = external hidden global i32, align 4
@c_b1 = external hidden global %struct.complex, align 4
@.str.3 = external hidden unnamed_addr constant [10 x i8], align 1

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

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

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

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

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

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

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

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

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

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

44:                                               ; preds = %41
  %45 = sext i32 %19 to i64
  br i1 %.not, label %.lr.ph587, label %.lr.ph574

.lr.ph574:                                        ; preds = %44
  %invariant.gep = getelementptr i8, ptr %17, i64 8
  %46 = getelementptr inbounds i8, ptr %11, i64 4
  br label %50

.lr.ph587:                                        ; preds = %44
  %47 = getelementptr inbounds i8, ptr %11, i64 4
  %48 = add i32 %15, 1
  br label %191

.preheader563:                                    ; preds = %.loopexit565
  %.pre = load i32, ptr %1, align 4, !tbaa !5
  %49 = icmp slt i32 %.pre, 1
  br i1 %49, label %.loopexit, label %.lr.ph582

50:                                               ; preds = %.lr.ph574, %.loopexit565
  %.0525573 = phi i32 [ %26, %.lr.ph574 ], [ %.1526, %.loopexit565 ]
  %51 = zext nneg i32 %.0525573 to i64
  %52 = getelementptr inbounds i32, ptr %18, i64 %51
  %53 = load i32, ptr %52, align 4, !tbaa !5
  %54 = icmp sgt i32 %53, 0
  br i1 %54, label %55, label %72

55:                                               ; preds = %50
  %.not556 = icmp eq i32 %53, %.0525573
  %.pre611 = add nsw i32 %.0525573, %19
  %.pre613 = sext i32 %.pre611 to i64
  br i1 %.not556, label %._crit_edge601, label %56

56:                                               ; preds = %55
  %57 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pre613
  %58 = add nsw i32 %53, %19
  %59 = sext i32 %58 to i64
  %60 = getelementptr inbounds %struct.complex, ptr %21, i64 %59
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %57, ptr noundef nonnull %7, ptr noundef %60, ptr noundef nonnull %7) #6
  br label %._crit_edge601

._crit_edge601:                                   ; preds = %55, %56
  %61 = add nsw i32 %.0525573, -1
  store i32 %61, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %62 = mul nsw i32 %.0525573, %15
  %63 = sext i32 %62 to i64
  %gep572 = getelementptr %struct.complex, ptr %invariant.gep, i64 %63
  %64 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pre613
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep572, ptr noundef nonnull @c__1, ptr noundef %64, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #6
  %65 = call <2 x float> @Cf(ptr noundef nonnull @c_b1)
  %.sroa.041.0.vec.extract = extractelement <2 x float> %65, i64 0
  %.sroa.041.4.vec.extract = extractelement <2 x float> %65, i64 1
  %66 = add nsw i32 %62, %.0525573
  %67 = sext i32 %66 to i64
  %68 = getelementptr inbounds %struct.complex, ptr %17, i64 %67
  %69 = call <2 x float> @Cf(ptr noundef %68)
  %.sroa.040.0.vec.extract = extractelement <2 x float> %69, i64 0
  %.sroa.040.4.vec.extract = extractelement <2 x float> %69, i64 1
  %70 = call <2 x float> @__divsc3(float noundef %.sroa.041.0.vec.extract, float noundef %.sroa.041.4.vec.extract, float noundef %.sroa.040.0.vec.extract, float noundef %.sroa.040.4.vec.extract) #6
  %71 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %70, ptr %71, align 4
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %64, ptr noundef nonnull %7) #6
  br label %.loopexit565

72:                                               ; preds = %50
  %73 = sub nsw i32 0, %53
  %74 = add nsw i32 %.0525573, -1
  %.not554 = icmp eq i32 %74, %73
  %.pre615 = add nsw i32 %74, %19
  %.pre617 = sext i32 %.pre615 to i64
  br i1 %.not554, label %._crit_edge600, label %75

75:                                               ; preds = %72
  %76 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pre617
  %77 = sub i32 %19, %53
  %78 = sext i32 %77 to i64
  %79 = getelementptr inbounds %struct.complex, ptr %21, i64 %78
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %76, ptr noundef nonnull %7, ptr noundef %79, ptr noundef nonnull %7) #6
  br label %._crit_edge600

._crit_edge600:                                   ; preds = %72, %75
  %80 = add nsw i32 %.0525573, -2
  store i32 %80, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %81 = mul nsw i32 %.0525573, %15
  %82 = sext i32 %81 to i64
  %gep = getelementptr %struct.complex, ptr %invariant.gep, i64 %82
  %83 = add nsw i32 %.0525573, %19
  %84 = sext i32 %83 to i64
  %85 = getelementptr inbounds %struct.complex, ptr %21, i64 %84
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep, ptr noundef nonnull @c__1, ptr noundef %85, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #6
  store i32 %80, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %86 = mul nsw i32 %74, %15
  %87 = sext i32 %86 to i64
  %gep570 = getelementptr %struct.complex, ptr %invariant.gep, i64 %87
  %88 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pre617
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %gep570, ptr noundef nonnull @c__1, ptr noundef %88, ptr noundef nonnull %7, ptr noundef %6, ptr noundef nonnull %7) #6
  %89 = add nsw i32 %74, %81
  store i32 %89, ptr %10, align 4, !tbaa !5
  %90 = sext i32 %89 to i64
  %91 = getelementptr inbounds %struct.complex, ptr %17, i64 %90
  %92 = load <2 x float>, ptr %91, align 4, !tbaa !9
  store <2 x float> %92, ptr %13, align 8, !tbaa !9
  %93 = add nsw i32 %86, %74
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds %struct.complex, ptr %17, i64 %94
  %96 = call <2 x float> @Cf(ptr noundef %95)
  %.sroa.038.0.vec.extract = extractelement <2 x float> %96, i64 0
  %.sroa.038.4.vec.extract = extractelement <2 x float> %96, i64 1
  %97 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.037.0.vec.extract = extractelement <2 x float> %97, i64 0
  %.sroa.037.4.vec.extract = extractelement <2 x float> %97, i64 1
  %98 = call <2 x float> @__divsc3(float noundef %.sroa.038.0.vec.extract, float noundef %.sroa.038.4.vec.extract, float noundef %.sroa.037.0.vec.extract, float noundef %.sroa.037.4.vec.extract) #6
  %99 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %98, ptr %99, align 4
  %100 = load float, ptr %11, align 8, !tbaa !11
  %101 = load float, ptr %46, align 4, !tbaa !13
  %102 = add nsw i32 %81, %.0525573
  %103 = sext i32 %102 to i64
  %104 = getelementptr inbounds %struct.complex, ptr %17, i64 %103
  %105 = call <2 x float> @Cf(ptr noundef %104)
  %.sroa.035.0.vec.extract = extractelement <2 x float> %105, i64 0
  %.sroa.035.4.vec.extract = extractelement <2 x float> %105, i64 1
  %106 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.034.0.vec.extract = extractelement <2 x float> %106, i64 0
  %.sroa.034.4.vec.extract = extractelement <2 x float> %106, i64 1
  %107 = call <2 x float> @__divsc3(float noundef %.sroa.035.0.vec.extract, float noundef %.sroa.035.4.vec.extract, float noundef %.sroa.034.0.vec.extract, float noundef %.sroa.034.4.vec.extract) #6
  %108 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %107, ptr %108, align 4
  %109 = fneg float %101
  %110 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %111 = insertelement <2 x float> poison, float %101, i64 0
  %112 = insertelement <2 x float> %111, float %109, i64 1
  %113 = fmul <2 x float> %110, %112
  %114 = shufflevector <2 x float> %113, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %115 = insertelement <2 x float> poison, float %100, i64 0
  %116 = shufflevector <2 x float> %115, <2 x float> poison, <2 x i32> zeroinitializer
  %117 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %110, <2 x float> %114)
  store <2 x float> %117, ptr %12, align 8, !tbaa !9
  %118 = fadd <2 x float> %117, <float -1.000000e+00, float 0.000000e+00>
  store <2 x float> %118, ptr %11, align 8, !tbaa !9
  store <2 x float> %118, ptr %14, align 8, !tbaa !9
  %119 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %119, ptr %10, align 4, !tbaa !5
  %.not555567 = icmp slt i32 %119, 1
  br i1 %.not555567, label %.loopexit565, label %.lr.ph

.lr.ph:                                           ; preds = %._crit_edge600
  %120 = zext nneg i32 %74 to i64
  %121 = zext nneg i32 %.0525573 to i64
  %invariant.gep620 = getelementptr %struct.complex, ptr %21, i64 %120
  %invariant.gep622 = getelementptr %struct.complex, ptr %21, i64 %121
  %122 = shufflevector <2 x float> %110, <2 x float> poison, <2 x i32> zeroinitializer
  %123 = shufflevector <2 x float> %110, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %124 = fneg <2 x float> %110
  %125 = shufflevector <2 x float> %123, <2 x float> %124, <2 x i32> <i32 0, i32 3>
  br label %126

126:                                              ; preds = %.lr.ph, %126
  %indvars.iv = phi i64 [ 1, %.lr.ph ], [ %indvars.iv.next, %126 ]
  %127 = mul nsw i64 %indvars.iv, %45
  %gep621 = getelementptr %struct.complex, ptr %invariant.gep620, i64 %127
  %128 = call <2 x float> @Cf(ptr noundef %gep621)
  %.sroa.032.0.vec.extract = extractelement <2 x float> %128, i64 0
  %.sroa.032.4.vec.extract = extractelement <2 x float> %128, i64 1
  %129 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.031.0.vec.extract = extractelement <2 x float> %129, i64 0
  %.sroa.031.4.vec.extract = extractelement <2 x float> %129, i64 1
  %130 = call <2 x float> @__divsc3(float noundef %.sroa.032.0.vec.extract, float noundef %.sroa.032.4.vec.extract, float noundef %.sroa.031.0.vec.extract, float noundef %.sroa.031.4.vec.extract) #6
  %131 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %130, ptr %131, align 4
  %gep623 = getelementptr %struct.complex, ptr %invariant.gep622, i64 %127
  %132 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %133 = call <2 x float> @Cf(ptr noundef %gep623)
  %.sroa.029.0.vec.extract = extractelement <2 x float> %133, i64 0
  %.sroa.029.4.vec.extract = extractelement <2 x float> %133, i64 1
  %134 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.028.0.vec.extract = extractelement <2 x float> %134, i64 0
  %.sroa.028.4.vec.extract = extractelement <2 x float> %134, i64 1
  %135 = call <2 x float> @__divsc3(float noundef %.sroa.029.0.vec.extract, float noundef %.sroa.029.4.vec.extract, float noundef %.sroa.028.0.vec.extract, float noundef %.sroa.028.4.vec.extract) #6
  %136 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %135, ptr %136, align 4
  %137 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %138 = fmul <2 x float> %132, %125
  %139 = shufflevector <2 x float> %138, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %140 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %122, <2 x float> %132, <2 x float> %139)
  %141 = fsub <2 x float> %140, %137
  store <2 x float> %141, ptr %12, align 8, !tbaa !9
  %142 = call <2 x float> @Cf(ptr noundef nonnull %12)
  %.sroa.026.0.vec.extract = extractelement <2 x float> %142, i64 0
  %.sroa.026.4.vec.extract = extractelement <2 x float> %142, i64 1
  %143 = call <2 x float> @Cf(ptr noundef nonnull %14)
  %.sroa.025.0.vec.extract = extractelement <2 x float> %143, i64 0
  %.sroa.025.4.vec.extract = extractelement <2 x float> %143, i64 1
  %144 = call <2 x float> @__divsc3(float noundef %.sroa.026.0.vec.extract, float noundef %.sroa.026.4.vec.extract, float noundef %.sroa.025.0.vec.extract, float noundef %.sroa.025.4.vec.extract) #6
  %145 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %144, ptr %145, align 4
  %146 = load <2 x float>, ptr %11, align 8, !tbaa !9
  store <2 x float> %146, ptr %gep621, align 4, !tbaa !9
  %147 = fmul <2 x float> %137, %112
  %148 = shufflevector <2 x float> %147, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %149 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %116, <2 x float> %137, <2 x float> %148)
  %150 = fsub <2 x float> %149, %132
  store <2 x float> %150, ptr %12, align 8, !tbaa !9
  %151 = call <2 x float> @Cf(ptr noundef nonnull %12)
  %.sroa.023.0.vec.extract = extractelement <2 x float> %151, i64 0
  %.sroa.023.4.vec.extract = extractelement <2 x float> %151, i64 1
  %152 = call <2 x float> @Cf(ptr noundef nonnull %14)
  %.sroa.022.0.vec.extract = extractelement <2 x float> %152, i64 0
  %.sroa.022.4.vec.extract = extractelement <2 x float> %152, i64 1
  %153 = call <2 x float> @__divsc3(float noundef %.sroa.023.0.vec.extract, float noundef %.sroa.023.4.vec.extract, float noundef %.sroa.022.0.vec.extract, float noundef %.sroa.022.4.vec.extract) #6
  %154 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %153, ptr %154, align 4
  %155 = load <2 x float>, ptr %11, align 8, !tbaa !9
  store <2 x float> %155, ptr %gep623, align 4, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %156 = load i32, ptr %10, align 4, !tbaa !5
  %157 = sext i32 %156 to i64
  %.not555.not = icmp slt i64 %indvars.iv, %157
  br i1 %.not555.not, label %126, label %.loopexit565, !llvm.loop !14

.loopexit565:                                     ; preds = %126, %._crit_edge600, %._crit_edge601
  %.1526 = phi i32 [ %61, %._crit_edge601 ], [ %80, %._crit_edge600 ], [ %80, %126 ]
  %158 = icmp slt i32 %.1526, 1
  br i1 %158, label %.preheader563, label %50

.lr.ph582:                                        ; preds = %.preheader563, %186
  %.2581 = phi i32 [ %187, %186 ], [ 1, %.preheader563 ]
  %159 = sext i32 %.2581 to i64
  %160 = getelementptr inbounds i32, ptr %18, i64 %159
  %161 = load i32, ptr %160, align 4, !tbaa !5
  %162 = icmp sgt i32 %161, 0
  %163 = add nsw i32 %.2581, -1
  store i32 %163, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %164 = mul nsw i32 %.2581, %15
  %165 = sext i32 %164 to i64
  %gep580 = getelementptr %struct.complex, ptr %invariant.gep, i64 %165
  %166 = add nsw i32 %.2581, %19
  %167 = sext i32 %166 to i64
  %168 = getelementptr inbounds %struct.complex, ptr %21, i64 %167
  call void @cgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %6, ptr noundef nonnull %7, ptr noundef %gep580, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %168, ptr noundef nonnull %7) #6
  br i1 %162, label %169, label %173

169:                                              ; preds = %.lr.ph582
  %170 = load i32, ptr %160, align 4, !tbaa !5
  %.not559 = icmp eq i32 %170, %.2581
  br i1 %.not559, label %186, label %171

171:                                              ; preds = %169
  %172 = add nsw i32 %170, %19
  br label %.sink.split

173:                                              ; preds = %.lr.ph582
  store i32 %163, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %174 = add nsw i32 %.2581, 1
  %175 = mul nsw i32 %174, %15
  %176 = sext i32 %175 to i64
  %gep578 = getelementptr %struct.complex, ptr %invariant.gep, i64 %176
  %177 = add nsw i32 %174, %19
  %178 = sext i32 %177 to i64
  %179 = getelementptr inbounds %struct.complex, ptr %21, i64 %178
  call void @cgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %6, ptr noundef nonnull %7, ptr noundef %gep578, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %179, ptr noundef nonnull %7) #6
  %180 = load i32, ptr %160, align 4, !tbaa !5
  %181 = sub nsw i32 0, %180
  %.not557 = icmp eq i32 %.2581, %181
  br i1 %.not557, label %186, label %182

182:                                              ; preds = %173
  %183 = sub i32 %19, %180
  br label %.sink.split

.sink.split:                                      ; preds = %171, %182
  %.sink632 = phi i32 [ %183, %182 ], [ %172, %171 ]
  %.sink628.ph = phi i32 [ 2, %182 ], [ 1, %171 ]
  %184 = sext i32 %.sink632 to i64
  %185 = getelementptr inbounds %struct.complex, ptr %21, i64 %184
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %168, ptr noundef nonnull %7, ptr noundef %185, ptr noundef nonnull %7) #6
  br label %186

186:                                              ; preds = %.sink.split, %173, %169
  %.sink628 = phi i32 [ 1, %169 ], [ 2, %173 ], [ %.sink628.ph, %.sink.split ]
  %187 = add nsw i32 %.2581, %.sink628
  %188 = load i32, ptr %1, align 4, !tbaa !5
  %189 = icmp sgt i32 %187, %188
  br i1 %189, label %.loopexit, label %.lr.ph582

.preheader:                                       ; preds = %337
  %190 = icmp slt i32 %338, 1
  br i1 %190, label %.loopexit, label %.lr.ph589

191:                                              ; preds = %.lr.ph587, %337
  %192 = phi i32 [ %26, %.lr.ph587 ], [ %338, %337 ]
  %.4586 = phi i32 [ 1, %.lr.ph587 ], [ %.5, %337 ]
  %193 = sext i32 %.4586 to i64
  %194 = getelementptr inbounds i32, ptr %18, i64 %193
  %195 = load i32, ptr %194, align 4, !tbaa !5
  %196 = icmp sgt i32 %195, 0
  br i1 %196, label %197, label %230

197:                                              ; preds = %191
  %.not551 = icmp eq i32 %195, %.4586
  br i1 %.not551, label %205, label %198

198:                                              ; preds = %197
  %199 = add nsw i32 %.4586, %19
  %200 = sext i32 %199 to i64
  %201 = getelementptr inbounds %struct.complex, ptr %21, i64 %200
  %202 = add nsw i32 %195, %19
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds %struct.complex, ptr %21, i64 %203
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %201, ptr noundef nonnull %7, ptr noundef %204, ptr noundef nonnull %7) #6
  %.pre597 = load i32, ptr %1, align 4, !tbaa !5
  br label %205

205:                                              ; preds = %198, %197
  %206 = phi i32 [ %.pre597, %198 ], [ %192, %197 ]
  %207 = icmp slt i32 %.4586, %206
  br i1 %207, label %208, label %._crit_edge603

._crit_edge603:                                   ; preds = %205
  %.pre604 = add nsw i32 %.4586, %19
  %.pre605 = sext i32 %.pre604 to i64
  %.pre607 = add nsw i32 %.4586, 1
  br label %221

208:                                              ; preds = %205
  %209 = sub nsw i32 %206, %.4586
  store i32 %209, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %210 = add nsw i32 %.4586, 1
  %211 = mul nsw i32 %.4586, %15
  %212 = add nsw i32 %210, %211
  %213 = sext i32 %212 to i64
  %214 = getelementptr inbounds %struct.complex, ptr %17, i64 %213
  %215 = add nsw i32 %.4586, %19
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds %struct.complex, ptr %21, i64 %216
  %218 = add nsw i32 %210, %19
  %219 = sext i32 %218 to i64
  %220 = getelementptr inbounds %struct.complex, ptr %21, i64 %219
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %214, ptr noundef nonnull @c__1, ptr noundef %217, ptr noundef nonnull %7, ptr noundef %220, ptr noundef nonnull %7) #6
  br label %221

221:                                              ; preds = %._crit_edge603, %208
  %.pre-phi608 = phi i32 [ %.pre607, %._crit_edge603 ], [ %210, %208 ]
  %.pre-phi606 = phi i64 [ %.pre605, %._crit_edge603 ], [ %216, %208 ]
  %222 = call <2 x float> @Cf(ptr noundef nonnull @c_b1)
  %.sroa.020.0.vec.extract = extractelement <2 x float> %222, i64 0
  %.sroa.020.4.vec.extract = extractelement <2 x float> %222, i64 1
  %223 = mul i32 %.4586, %48
  %224 = sext i32 %223 to i64
  %225 = getelementptr inbounds %struct.complex, ptr %17, i64 %224
  %226 = call <2 x float> @Cf(ptr noundef %225)
  %.sroa.019.0.vec.extract = extractelement <2 x float> %226, i64 0
  %.sroa.019.4.vec.extract = extractelement <2 x float> %226, i64 1
  %227 = call <2 x float> @__divsc3(float noundef %.sroa.020.0.vec.extract, float noundef %.sroa.020.4.vec.extract, float noundef %.sroa.019.0.vec.extract, float noundef %.sroa.019.4.vec.extract) #6
  %228 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %227, ptr %228, align 4
  %229 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pre-phi606
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %229, ptr noundef nonnull %7) #6
  br label %337

230:                                              ; preds = %191
  %231 = sub nsw i32 0, %195
  %232 = add nsw i32 %.4586, 1
  %.not549 = icmp eq i32 %232, %231
  br i1 %.not549, label %240, label %233

233:                                              ; preds = %230
  %234 = add nsw i32 %232, %19
  %235 = sext i32 %234 to i64
  %236 = getelementptr inbounds %struct.complex, ptr %21, i64 %235
  %237 = sub i32 %19, %195
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds %struct.complex, ptr %21, i64 %238
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %236, ptr noundef nonnull %7, ptr noundef %239, ptr noundef nonnull %7) #6
  %.pre596 = load i32, ptr %1, align 4, !tbaa !5
  br label %240

240:                                              ; preds = %233, %230
  %241 = phi i32 [ %.pre596, %233 ], [ %192, %230 ]
  %242 = add nsw i32 %241, -1
  %243 = icmp slt i32 %.4586, %242
  br i1 %243, label %244, label %._crit_edge602

._crit_edge602:                                   ; preds = %240
  %.pre609 = mul nsw i32 %.4586, %15
  br label %267

244:                                              ; preds = %240
  %245 = xor i32 %.4586, -1
  %246 = add i32 %241, %245
  store i32 %246, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %247 = add nsw i32 %.4586, 2
  %248 = mul nsw i32 %.4586, %15
  %249 = add nsw i32 %247, %248
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds %struct.complex, ptr %17, i64 %250
  %252 = add nsw i32 %.4586, %19
  %253 = sext i32 %252 to i64
  %254 = getelementptr inbounds %struct.complex, ptr %21, i64 %253
  %255 = add nsw i32 %247, %19
  %256 = sext i32 %255 to i64
  %257 = getelementptr inbounds %struct.complex, ptr %21, i64 %256
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %251, ptr noundef nonnull @c__1, ptr noundef %254, ptr noundef nonnull %7, ptr noundef %257, ptr noundef nonnull %7) #6
  %258 = load i32, ptr %1, align 4, !tbaa !5
  %259 = add i32 %258, %245
  store i32 %259, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %260 = mul nsw i32 %232, %15
  %261 = add nsw i32 %260, %247
  %262 = sext i32 %261 to i64
  %263 = getelementptr inbounds %struct.complex, ptr %17, i64 %262
  %264 = add nsw i32 %232, %19
  %265 = sext i32 %264 to i64
  %266 = getelementptr inbounds %struct.complex, ptr %21, i64 %265
  call void @cgeru_(ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %263, ptr noundef nonnull @c__1, ptr noundef %266, ptr noundef nonnull %7, ptr noundef %257, ptr noundef nonnull %7) #6
  br label %267

267:                                              ; preds = %._crit_edge602, %244
  %.pre-phi610 = phi i32 [ %.pre609, %._crit_edge602 ], [ %248, %244 ]
  %268 = add nsw i32 %232, %.pre-phi610
  store i32 %268, ptr %10, align 4, !tbaa !5
  %269 = sext i32 %268 to i64
  %270 = getelementptr inbounds %struct.complex, ptr %17, i64 %269
  %271 = load <2 x float>, ptr %270, align 4, !tbaa !9
  store <2 x float> %271, ptr %13, align 8, !tbaa !9
  %272 = add nsw i32 %.pre-phi610, %.4586
  %273 = sext i32 %272 to i64
  %274 = getelementptr inbounds %struct.complex, ptr %17, i64 %273
  %275 = call <2 x float> @Cf(ptr noundef %274)
  %.sroa.017.0.vec.extract = extractelement <2 x float> %275, i64 0
  %.sroa.017.4.vec.extract = extractelement <2 x float> %275, i64 1
  %276 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.016.0.vec.extract = extractelement <2 x float> %276, i64 0
  %.sroa.016.4.vec.extract = extractelement <2 x float> %276, i64 1
  %277 = call <2 x float> @__divsc3(float noundef %.sroa.017.0.vec.extract, float noundef %.sroa.017.4.vec.extract, float noundef %.sroa.016.0.vec.extract, float noundef %.sroa.016.4.vec.extract) #6
  %278 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %277, ptr %278, align 4
  %279 = load float, ptr %11, align 8, !tbaa !11
  %280 = load float, ptr %47, align 4, !tbaa !13
  %281 = mul i32 %232, %48
  %282 = sext i32 %281 to i64
  %283 = getelementptr inbounds %struct.complex, ptr %17, i64 %282
  %284 = call <2 x float> @Cf(ptr noundef %283)
  %.sroa.014.0.vec.extract = extractelement <2 x float> %284, i64 0
  %.sroa.014.4.vec.extract = extractelement <2 x float> %284, i64 1
  %285 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.013.0.vec.extract = extractelement <2 x float> %285, i64 0
  %.sroa.013.4.vec.extract = extractelement <2 x float> %285, i64 1
  %286 = call <2 x float> @__divsc3(float noundef %.sroa.014.0.vec.extract, float noundef %.sroa.014.4.vec.extract, float noundef %.sroa.013.0.vec.extract, float noundef %.sroa.013.4.vec.extract) #6
  %287 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %286, ptr %287, align 4
  %288 = fneg float %280
  %289 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %290 = insertelement <2 x float> poison, float %280, i64 0
  %291 = insertelement <2 x float> %290, float %288, i64 1
  %292 = fmul <2 x float> %289, %291
  %293 = shufflevector <2 x float> %292, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %294 = insertelement <2 x float> poison, float %279, i64 0
  %295 = shufflevector <2 x float> %294, <2 x float> poison, <2 x i32> zeroinitializer
  %296 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %295, <2 x float> %289, <2 x float> %293)
  store <2 x float> %296, ptr %12, align 8, !tbaa !9
  %297 = fadd <2 x float> %296, <float -1.000000e+00, float 0.000000e+00>
  store <2 x float> %297, ptr %11, align 8, !tbaa !9
  store <2 x float> %297, ptr %14, align 8, !tbaa !9
  %298 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %298, ptr %10, align 4, !tbaa !5
  %.not550583 = icmp slt i32 %298, 1
  br i1 %.not550583, label %._crit_edge, label %.lr.ph585

.lr.ph585:                                        ; preds = %267
  %299 = sext i32 %232 to i64
  %invariant.gep624 = getelementptr %struct.complex, ptr %21, i64 %193
  %invariant.gep626 = getelementptr %struct.complex, ptr %21, i64 %299
  %300 = shufflevector <2 x float> %289, <2 x float> poison, <2 x i32> zeroinitializer
  %301 = shufflevector <2 x float> %289, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %302 = fneg <2 x float> %289
  %303 = shufflevector <2 x float> %301, <2 x float> %302, <2 x i32> <i32 0, i32 3>
  br label %304

304:                                              ; preds = %.lr.ph585, %304
  %indvars.iv593 = phi i64 [ 1, %.lr.ph585 ], [ %indvars.iv.next594, %304 ]
  %305 = mul nsw i64 %indvars.iv593, %45
  %gep625 = getelementptr %struct.complex, ptr %invariant.gep624, i64 %305
  %306 = call <2 x float> @Cf(ptr noundef %gep625)
  %.sroa.011.0.vec.extract = extractelement <2 x float> %306, i64 0
  %.sroa.011.4.vec.extract = extractelement <2 x float> %306, i64 1
  %307 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.010.0.vec.extract = extractelement <2 x float> %307, i64 0
  %.sroa.010.4.vec.extract = extractelement <2 x float> %307, i64 1
  %308 = call <2 x float> @__divsc3(float noundef %.sroa.011.0.vec.extract, float noundef %.sroa.011.4.vec.extract, float noundef %.sroa.010.0.vec.extract, float noundef %.sroa.010.4.vec.extract) #6
  %309 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %308, ptr %309, align 4
  %gep627 = getelementptr %struct.complex, ptr %invariant.gep626, i64 %305
  %310 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %311 = call <2 x float> @Cf(ptr noundef %gep627)
  %.sroa.08.0.vec.extract = extractelement <2 x float> %311, i64 0
  %.sroa.08.4.vec.extract = extractelement <2 x float> %311, i64 1
  %312 = call <2 x float> @Cf(ptr noundef nonnull %13)
  %.sroa.07.0.vec.extract = extractelement <2 x float> %312, i64 0
  %.sroa.07.4.vec.extract = extractelement <2 x float> %312, i64 1
  %313 = call <2 x float> @__divsc3(float noundef %.sroa.08.0.vec.extract, float noundef %.sroa.08.4.vec.extract, float noundef %.sroa.07.0.vec.extract, float noundef %.sroa.07.4.vec.extract) #6
  %314 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %313, ptr %314, align 4
  %315 = load <2 x float>, ptr %11, align 8, !tbaa !9
  %316 = fmul <2 x float> %310, %303
  %317 = shufflevector <2 x float> %316, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %318 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %300, <2 x float> %310, <2 x float> %317)
  %319 = fsub <2 x float> %318, %315
  store <2 x float> %319, ptr %12, align 8, !tbaa !9
  %320 = call <2 x float> @Cf(ptr noundef nonnull %12)
  %.sroa.05.0.vec.extract = extractelement <2 x float> %320, i64 0
  %.sroa.05.4.vec.extract = extractelement <2 x float> %320, i64 1
  %321 = call <2 x float> @Cf(ptr noundef nonnull %14)
  %.sroa.04.0.vec.extract = extractelement <2 x float> %321, i64 0
  %.sroa.04.4.vec.extract = extractelement <2 x float> %321, i64 1
  %322 = call <2 x float> @__divsc3(float noundef %.sroa.05.0.vec.extract, float noundef %.sroa.05.4.vec.extract, float noundef %.sroa.04.0.vec.extract, float noundef %.sroa.04.4.vec.extract) #6
  %323 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %322, ptr %323, align 4
  %324 = load <2 x float>, ptr %11, align 8, !tbaa !9
  store <2 x float> %324, ptr %gep625, align 4, !tbaa !9
  %325 = fmul <2 x float> %315, %291
  %326 = shufflevector <2 x float> %325, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %327 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %295, <2 x float> %315, <2 x float> %326)
  %328 = fsub <2 x float> %327, %310
  store <2 x float> %328, ptr %12, align 8, !tbaa !9
  %329 = call <2 x float> @Cf(ptr noundef nonnull %12)
  %.sroa.02.0.vec.extract = extractelement <2 x float> %329, i64 0
  %.sroa.02.4.vec.extract = extractelement <2 x float> %329, i64 1
  %330 = call <2 x float> @Cf(ptr noundef nonnull %14)
  %.sroa.01.0.vec.extract = extractelement <2 x float> %330, i64 0
  %.sroa.01.4.vec.extract = extractelement <2 x float> %330, i64 1
  %331 = call <2 x float> @__divsc3(float noundef %.sroa.02.0.vec.extract, float noundef %.sroa.02.4.vec.extract, float noundef %.sroa.01.0.vec.extract, float noundef %.sroa.01.4.vec.extract) #6
  %332 = call ptr @_pCf(ptr noundef nonnull %11)
  store <2 x float> %331, ptr %332, align 4
  %333 = load <2 x float>, ptr %11, align 8, !tbaa !9
  store <2 x float> %333, ptr %gep627, align 4, !tbaa !9
  %indvars.iv.next594 = add nuw nsw i64 %indvars.iv593, 1
  %334 = load i32, ptr %10, align 4, !tbaa !5
  %335 = sext i32 %334 to i64
  %.not550.not = icmp slt i64 %indvars.iv593, %335
  br i1 %.not550.not, label %304, label %._crit_edge, !llvm.loop !16

._crit_edge:                                      ; preds = %304, %267
  %336 = add nsw i32 %.4586, 2
  br label %337

337:                                              ; preds = %._crit_edge, %221
  %.5 = phi i32 [ %.pre-phi608, %221 ], [ %336, %._crit_edge ]
  %338 = load i32, ptr %1, align 4, !tbaa !5
  %339 = icmp sgt i32 %.5, %338
  br i1 %339, label %.preheader, label %191

.lr.ph589:                                        ; preds = %.preheader, %395
  %.6588 = phi i32 [ %396, %395 ], [ %338, %.preheader ]
  %340 = zext nneg i32 %.6588 to i64
  %341 = getelementptr inbounds i32, ptr %18, i64 %340
  %342 = load i32, ptr %341, align 4, !tbaa !5
  %343 = icmp sgt i32 %342, 0
  %344 = load i32, ptr %1, align 4, !tbaa !5
  %345 = icmp slt i32 %.6588, %344
  br i1 %343, label %346, label %364

346:                                              ; preds = %.lr.ph589
  br i1 %345, label %347, label %360

347:                                              ; preds = %346
  %348 = sub nsw i32 %344, %.6588
  store i32 %348, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %349 = add nuw nsw i32 %.6588, 1
  %350 = add nsw i32 %349, %19
  %351 = sext i32 %350 to i64
  %352 = getelementptr inbounds %struct.complex, ptr %21, i64 %351
  %353 = mul nsw i32 %.6588, %15
  %354 = add nsw i32 %349, %353
  %355 = sext i32 %354 to i64
  %356 = getelementptr inbounds %struct.complex, ptr %17, i64 %355
  %357 = add nsw i32 %.6588, %19
  %358 = sext i32 %357 to i64
  %359 = getelementptr inbounds %struct.complex, ptr %21, i64 %358
  call void @cgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %352, ptr noundef nonnull %7, ptr noundef %356, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %359, ptr noundef nonnull %7) #6
  %.pre599 = load i32, ptr %341, align 4, !tbaa !5
  br label %360

360:                                              ; preds = %347, %346
  %361 = phi i32 [ %.pre599, %347 ], [ %342, %346 ]
  %.not553 = icmp eq i32 %361, %.6588
  br i1 %.not553, label %395, label %362

362:                                              ; preds = %360
  %363 = add nsw i32 %361, %19
  br label %.sink.split633

364:                                              ; preds = %.lr.ph589
  br i1 %345, label %365, label %388

365:                                              ; preds = %364
  %366 = sub nsw i32 %344, %.6588
  store i32 %366, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %367 = add nuw nsw i32 %.6588, 1
  %368 = add nsw i32 %367, %19
  %369 = sext i32 %368 to i64
  %370 = getelementptr inbounds %struct.complex, ptr %21, i64 %369
  %371 = mul nsw i32 %.6588, %15
  %372 = add nsw i32 %367, %371
  %373 = sext i32 %372 to i64
  %374 = getelementptr inbounds %struct.complex, ptr %17, i64 %373
  %375 = add nsw i32 %.6588, %19
  %376 = sext i32 %375 to i64
  %377 = getelementptr inbounds %struct.complex, ptr %21, i64 %376
  call void @cgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %370, ptr noundef nonnull %7, ptr noundef %374, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %377, ptr noundef nonnull %7) #6
  %378 = load i32, ptr %1, align 4, !tbaa !5
  %379 = sub nsw i32 %378, %.6588
  store i32 %379, ptr %10, align 4, !tbaa !5
  store <2 x float> <float -1.000000e+00, float 0.000000e+00>, ptr %11, align 8, !tbaa !9
  %380 = add nsw i32 %.6588, -1
  %381 = mul nsw i32 %380, %15
  %382 = add nsw i32 %381, %367
  %383 = sext i32 %382 to i64
  %384 = getelementptr inbounds %struct.complex, ptr %17, i64 %383
  %385 = add nsw i32 %380, %19
  %386 = sext i32 %385 to i64
  %387 = getelementptr inbounds %struct.complex, ptr %21, i64 %386
  call void @cgemv_(ptr noundef nonnull @.str.3, ptr noundef nonnull %10, ptr noundef nonnull %2, ptr noundef nonnull %11, ptr noundef %370, ptr noundef nonnull %7, ptr noundef %384, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %387, ptr noundef nonnull %7) #6
  %.pre598 = load i32, ptr %341, align 4, !tbaa !5
  br label %388

388:                                              ; preds = %365, %364
  %389 = phi i32 [ %.pre598, %365 ], [ %342, %364 ]
  %390 = sub nsw i32 0, %389
  %.not552 = icmp eq i32 %.6588, %390
  br i1 %.not552, label %395, label %391

391:                                              ; preds = %388
  %392 = sub i32 %19, %389
  br label %.sink.split633

.sink.split633:                                   ; preds = %362, %391
  %.sink637 = phi i32 [ %392, %391 ], [ %363, %362 ]
  %.sink629.ph = phi i32 [ -2, %391 ], [ -1, %362 ]
  %.pn.in = add nsw i32 %.6588, %19
  %.pn = sext i32 %.pn.in to i64
  %.sink634 = getelementptr inbounds %struct.complex, ptr %21, i64 %.pn
  %393 = sext i32 %.sink637 to i64
  %394 = getelementptr inbounds %struct.complex, ptr %21, i64 %393
  call void @cswap_(ptr noundef nonnull %2, ptr noundef %.sink634, ptr noundef nonnull %7, ptr noundef %394, ptr noundef nonnull %7) #6
  br label %395

395:                                              ; preds = %.sink.split633, %388, %360
  %.sink629 = phi i32 [ -1, %360 ], [ -2, %388 ], [ %.sink629.ph, %.sink.split633 ]
  %396 = add nsw i32 %.6588, %.sink629
  %397 = icmp slt i32 %396, 1
  br i1 %397, label %.loopexit, label %.lr.ph589

.loopexit:                                        ; preds = %186, %395, %.preheader563, %.preheader, %41, %.thread
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #6
  ret void
}

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

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @Cf(ptr noundef) local_unnamed_addr #3

declare <2 x float> @__divsc3(float, float, float, float) local_unnamed_addr

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

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

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

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

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

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

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


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