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

; 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__2 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4

; Function Attrs: nounwind uwtable
define dso_local void @ctgsy2_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9, ptr noundef %10, ptr noundef %11, ptr noundef %12, ptr noundef %13, ptr noundef %14, ptr noundef %15, ptr noundef %16, ptr noundef %17, ptr noundef %18, ptr noundef %19) #0 {
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, align 8
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca i32, align 4
  %42 = alloca i32, align 4
  %43 = alloca i32, align 4
  %44 = alloca i32, align 4
  %45 = alloca i32, align 4
  %46 = alloca i32, align 4
  %47 = alloca i32, align 4
  %48 = alloca i32, align 4
  %49 = alloca i32, align 4
  %50 = alloca i32, align 4
  %51 = alloca i32, align 4
  %52 = alloca i32, align 4
  %53 = alloca i32, align 4
  %54 = alloca i32, align 4
  %55 = alloca i32, align 4
  %56 = alloca i32, align 4
  %57 = alloca %struct.complex, align 4
  %58 = alloca %struct.complex, align 4
  %59 = alloca %struct.complex, align 4
  %60 = alloca %struct.complex, align 4
  %61 = alloca %struct.complex, align 4
  %62 = alloca %struct.complex, align 4
  %63 = alloca i32, align 4
  %64 = alloca [2 x i32], align 4
  %65 = alloca [2 x i32], align 4
  %66 = alloca i32, align 4
  %67 = alloca i32, align 4
  %68 = alloca i32, align 4
  %69 = alloca %struct.complex, align 4
  %70 = alloca [4 x %struct.complex], align 16
  %71 = alloca float, align 4
  %72 = alloca i32, align 4
  %73 = alloca [2 x %struct.complex], align 16
  %74 = alloca i32, 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
  %81 = alloca { float, float }, align 4
  %82 = alloca { float, float }, align 4
  store ptr %0, ptr %21, align 8, !tbaa !5
  store ptr %1, ptr %22, align 8, !tbaa !5
  store ptr %2, ptr %23, align 8, !tbaa !5
  store ptr %3, ptr %24, align 8, !tbaa !5
  store ptr %4, ptr %25, align 8, !tbaa !5
  store ptr %5, ptr %26, align 8, !tbaa !5
  store ptr %6, ptr %27, align 8, !tbaa !5
  store ptr %7, ptr %28, align 8, !tbaa !5
  store ptr %8, ptr %29, align 8, !tbaa !5
  store ptr %9, ptr %30, align 8, !tbaa !5
  store ptr %10, ptr %31, align 8, !tbaa !5
  store ptr %11, ptr %32, align 8, !tbaa !5
  store ptr %12, ptr %33, align 8, !tbaa !5
  store ptr %13, ptr %34, align 8, !tbaa !5
  store ptr %14, ptr %35, align 8, !tbaa !5
  store ptr %15, ptr %36, align 8, !tbaa !5
  store ptr %16, ptr %37, align 8, !tbaa !5
  store ptr %17, ptr %38, align 8, !tbaa !5
  store ptr %18, ptr %39, align 8, !tbaa !5
  store ptr %19, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %62) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %64) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %69) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %70) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %73) #6
  %83 = load ptr, ptr %26, align 8, !tbaa !5
  %84 = load i32, ptr %83, align 4, !tbaa !9
  store i32 %84, ptr %41, align 4, !tbaa !9
  %85 = load i32, ptr %41, align 4, !tbaa !9
  %86 = mul nsw i32 %85, 1
  %87 = add nsw i32 1, %86
  store i32 %87, ptr %42, align 4, !tbaa !9
  %88 = load i32, ptr %42, align 4, !tbaa !9
  %89 = load ptr, ptr %25, align 8, !tbaa !5
  %90 = sext i32 %88 to i64
  %91 = sub i64 0, %90
  %92 = getelementptr inbounds %struct.complex, ptr %89, i64 %91
  store ptr %92, ptr %25, align 8, !tbaa !5
  %93 = load ptr, ptr %28, align 8, !tbaa !5
  %94 = load i32, ptr %93, align 4, !tbaa !9
  store i32 %94, ptr %43, align 4, !tbaa !9
  %95 = load i32, ptr %43, align 4, !tbaa !9
  %96 = mul nsw i32 %95, 1
  %97 = add nsw i32 1, %96
  store i32 %97, ptr %44, align 4, !tbaa !9
  %98 = load i32, ptr %44, align 4, !tbaa !9
  %99 = load ptr, ptr %27, 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 %27, align 8, !tbaa !5
  %103 = load ptr, ptr %30, align 8, !tbaa !5
  %104 = load i32, ptr %103, align 4, !tbaa !9
  store i32 %104, ptr %45, align 4, !tbaa !9
  %105 = load i32, ptr %45, align 4, !tbaa !9
  %106 = mul nsw i32 %105, 1
  %107 = add nsw i32 1, %106
  store i32 %107, ptr %46, align 4, !tbaa !9
  %108 = load i32, ptr %46, align 4, !tbaa !9
  %109 = load ptr, ptr %29, align 8, !tbaa !5
  %110 = sext i32 %108 to i64
  %111 = sub i64 0, %110
  %112 = getelementptr inbounds %struct.complex, ptr %109, i64 %111
  store ptr %112, ptr %29, align 8, !tbaa !5
  %113 = load ptr, ptr %32, align 8, !tbaa !5
  %114 = load i32, ptr %113, align 4, !tbaa !9
  store i32 %114, ptr %47, align 4, !tbaa !9
  %115 = load i32, ptr %47, align 4, !tbaa !9
  %116 = mul nsw i32 %115, 1
  %117 = add nsw i32 1, %116
  store i32 %117, ptr %48, align 4, !tbaa !9
  %118 = load i32, ptr %48, align 4, !tbaa !9
  %119 = load ptr, ptr %31, align 8, !tbaa !5
  %120 = sext i32 %118 to i64
  %121 = sub i64 0, %120
  %122 = getelementptr inbounds %struct.complex, ptr %119, i64 %121
  store ptr %122, ptr %31, align 8, !tbaa !5
  %123 = load ptr, ptr %34, align 8, !tbaa !5
  %124 = load i32, ptr %123, align 4, !tbaa !9
  store i32 %124, ptr %49, align 4, !tbaa !9
  %125 = load i32, ptr %49, align 4, !tbaa !9
  %126 = mul nsw i32 %125, 1
  %127 = add nsw i32 1, %126
  store i32 %127, ptr %50, align 4, !tbaa !9
  %128 = load i32, ptr %50, align 4, !tbaa !9
  %129 = load ptr, ptr %33, align 8, !tbaa !5
  %130 = sext i32 %128 to i64
  %131 = sub i64 0, %130
  %132 = getelementptr inbounds %struct.complex, ptr %129, i64 %131
  store ptr %132, ptr %33, align 8, !tbaa !5
  %133 = load ptr, ptr %36, align 8, !tbaa !5
  %134 = load i32, ptr %133, align 4, !tbaa !9
  store i32 %134, ptr %51, align 4, !tbaa !9
  %135 = load i32, ptr %51, align 4, !tbaa !9
  %136 = mul nsw i32 %135, 1
  %137 = add nsw i32 1, %136
  store i32 %137, ptr %52, align 4, !tbaa !9
  %138 = load i32, ptr %52, align 4, !tbaa !9
  %139 = load ptr, ptr %35, align 8, !tbaa !5
  %140 = sext i32 %138 to i64
  %141 = sub i64 0, %140
  %142 = getelementptr inbounds %struct.complex, ptr %139, i64 %141
  store ptr %142, ptr %35, align 8, !tbaa !5
  %143 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 0, ptr %143, align 4, !tbaa !9
  store i32 0, ptr %63, align 4, !tbaa !9
  %144 = load ptr, ptr %21, align 8, !tbaa !5
  %145 = call i32 @lsame_(ptr noundef %144, ptr noundef @.str)
  store i32 %145, ptr %72, align 4, !tbaa !9
  %146 = load i32, ptr %72, align 4, !tbaa !9
  %147 = icmp ne i32 %146, 0
  br i1 %147, label %154, label %148

148:                                              ; preds = %20
  %149 = load ptr, ptr %21, align 8, !tbaa !5
  %150 = call i32 @lsame_(ptr noundef %149, ptr noundef @.str.1)
  %151 = icmp ne i32 %150, 0
  br i1 %151, label %154, label %152

152:                                              ; preds = %148
  %153 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -1, ptr %153, align 4, !tbaa !9
  br label %169

154:                                              ; preds = %148, %20
  %155 = load i32, ptr %72, align 4, !tbaa !9
  %156 = icmp ne i32 %155, 0
  br i1 %156, label %157, label %168

157:                                              ; preds = %154
  %158 = load ptr, ptr %22, align 8, !tbaa !5
  %159 = load i32, ptr %158, align 4, !tbaa !9
  %160 = icmp slt i32 %159, 0
  br i1 %160, label %165, label %161

161:                                              ; preds = %157
  %162 = load ptr, ptr %22, align 8, !tbaa !5
  %163 = load i32, ptr %162, align 4, !tbaa !9
  %164 = icmp sgt i32 %163, 2
  br i1 %164, label %165, label %167

165:                                              ; preds = %161, %157
  %166 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -2, ptr %166, align 4, !tbaa !9
  br label %167

167:                                              ; preds = %165, %161
  br label %168

168:                                              ; preds = %167, %154
  br label %169

169:                                              ; preds = %168, %152
  %170 = load ptr, ptr %40, align 8, !tbaa !5
  %171 = load i32, ptr %170, align 4, !tbaa !9
  %172 = icmp eq i32 %171, 0
  br i1 %172, label %173, label %283

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

177:                                              ; preds = %173
  %178 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -3, ptr %178, align 4, !tbaa !9
  br label %282

179:                                              ; preds = %173
  %180 = load ptr, ptr %24, align 8, !tbaa !5
  %181 = load i32, ptr %180, align 4, !tbaa !9
  %182 = icmp sle i32 %181, 0
  br i1 %182, label %183, label %185

183:                                              ; preds = %179
  %184 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -4, ptr %184, align 4, !tbaa !9
  br label %281

185:                                              ; preds = %179
  %186 = load ptr, ptr %26, align 8, !tbaa !5
  %187 = load i32, ptr %186, align 4, !tbaa !9
  %188 = load ptr, ptr %23, align 8, !tbaa !5
  %189 = load i32, ptr %188, align 4, !tbaa !9
  %190 = icmp sge i32 1, %189
  br i1 %190, label %191, label %192

191:                                              ; preds = %185
  br label %195

192:                                              ; preds = %185
  %193 = load ptr, ptr %23, align 8, !tbaa !5
  %194 = load i32, ptr %193, align 4, !tbaa !9
  br label %195

195:                                              ; preds = %192, %191
  %196 = phi i32 [ 1, %191 ], [ %194, %192 ]
  %197 = icmp slt i32 %187, %196
  br i1 %197, label %198, label %200

198:                                              ; preds = %195
  %199 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -6, ptr %199, align 4, !tbaa !9
  br label %280

200:                                              ; preds = %195
  %201 = load ptr, ptr %28, align 8, !tbaa !5
  %202 = load i32, ptr %201, align 4, !tbaa !9
  %203 = load ptr, ptr %24, align 8, !tbaa !5
  %204 = load i32, ptr %203, align 4, !tbaa !9
  %205 = icmp sge i32 1, %204
  br i1 %205, label %206, label %207

206:                                              ; preds = %200
  br label %210

207:                                              ; preds = %200
  %208 = load ptr, ptr %24, align 8, !tbaa !5
  %209 = load i32, ptr %208, align 4, !tbaa !9
  br label %210

210:                                              ; preds = %207, %206
  %211 = phi i32 [ 1, %206 ], [ %209, %207 ]
  %212 = icmp slt i32 %202, %211
  br i1 %212, label %213, label %215

213:                                              ; preds = %210
  %214 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -8, ptr %214, align 4, !tbaa !9
  br label %279

215:                                              ; preds = %210
  %216 = load ptr, ptr %30, align 8, !tbaa !5
  %217 = load i32, ptr %216, align 4, !tbaa !9
  %218 = load ptr, ptr %23, align 8, !tbaa !5
  %219 = load i32, ptr %218, align 4, !tbaa !9
  %220 = icmp sge i32 1, %219
  br i1 %220, label %221, label %222

221:                                              ; preds = %215
  br label %225

222:                                              ; preds = %215
  %223 = load ptr, ptr %23, align 8, !tbaa !5
  %224 = load i32, ptr %223, align 4, !tbaa !9
  br label %225

225:                                              ; preds = %222, %221
  %226 = phi i32 [ 1, %221 ], [ %224, %222 ]
  %227 = icmp slt i32 %217, %226
  br i1 %227, label %228, label %230

228:                                              ; preds = %225
  %229 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -10, ptr %229, align 4, !tbaa !9
  br label %278

230:                                              ; preds = %225
  %231 = load ptr, ptr %32, align 8, !tbaa !5
  %232 = load i32, ptr %231, align 4, !tbaa !9
  %233 = load ptr, ptr %23, align 8, !tbaa !5
  %234 = load i32, ptr %233, align 4, !tbaa !9
  %235 = icmp sge i32 1, %234
  br i1 %235, label %236, label %237

236:                                              ; preds = %230
  br label %240

237:                                              ; preds = %230
  %238 = load ptr, ptr %23, align 8, !tbaa !5
  %239 = load i32, ptr %238, align 4, !tbaa !9
  br label %240

240:                                              ; preds = %237, %236
  %241 = phi i32 [ 1, %236 ], [ %239, %237 ]
  %242 = icmp slt i32 %232, %241
  br i1 %242, label %243, label %245

243:                                              ; preds = %240
  %244 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -12, ptr %244, align 4, !tbaa !9
  br label %277

245:                                              ; preds = %240
  %246 = load ptr, ptr %34, align 8, !tbaa !5
  %247 = load i32, ptr %246, align 4, !tbaa !9
  %248 = load ptr, ptr %24, align 8, !tbaa !5
  %249 = load i32, ptr %248, align 4, !tbaa !9
  %250 = icmp sge i32 1, %249
  br i1 %250, label %251, label %252

251:                                              ; preds = %245
  br label %255

252:                                              ; preds = %245
  %253 = load ptr, ptr %24, align 8, !tbaa !5
  %254 = load i32, ptr %253, align 4, !tbaa !9
  br label %255

255:                                              ; preds = %252, %251
  %256 = phi i32 [ 1, %251 ], [ %254, %252 ]
  %257 = icmp slt i32 %247, %256
  br i1 %257, label %258, label %260

258:                                              ; preds = %255
  %259 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -14, ptr %259, align 4, !tbaa !9
  br label %276

260:                                              ; preds = %255
  %261 = load ptr, ptr %36, align 8, !tbaa !5
  %262 = load i32, ptr %261, align 4, !tbaa !9
  %263 = load ptr, ptr %23, align 8, !tbaa !5
  %264 = load i32, ptr %263, align 4, !tbaa !9
  %265 = icmp sge i32 1, %264
  br i1 %265, label %266, label %267

266:                                              ; preds = %260
  br label %270

267:                                              ; preds = %260
  %268 = load ptr, ptr %23, align 8, !tbaa !5
  %269 = load i32, ptr %268, align 4, !tbaa !9
  br label %270

270:                                              ; preds = %267, %266
  %271 = phi i32 [ 1, %266 ], [ %269, %267 ]
  %272 = icmp slt i32 %262, %271
  br i1 %272, label %273, label %275

273:                                              ; preds = %270
  %274 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 -16, ptr %274, align 4, !tbaa !9
  br label %275

275:                                              ; preds = %273, %270
  br label %276

276:                                              ; preds = %275, %258
  br label %277

277:                                              ; preds = %276, %243
  br label %278

278:                                              ; preds = %277, %228
  br label %279

279:                                              ; preds = %278, %213
  br label %280

280:                                              ; preds = %279, %198
  br label %281

281:                                              ; preds = %280, %183
  br label %282

282:                                              ; preds = %281, %177
  br label %283

283:                                              ; preds = %282, %169
  %284 = load ptr, ptr %40, align 8, !tbaa !5
  %285 = load i32, ptr %284, align 4, !tbaa !9
  %286 = icmp ne i32 %285, 0
  br i1 %286, label %287, label %292

287:                                              ; preds = %283
  %288 = load ptr, ptr %40, align 8, !tbaa !5
  %289 = load i32, ptr %288, align 4, !tbaa !9
  %290 = sub nsw i32 0, %289
  store i32 %290, ptr %53, align 4, !tbaa !9
  %291 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %53, i32 noundef 6)
  store i32 1, ptr %74, align 4
  br label %1267

292:                                              ; preds = %283
  %293 = load i32, ptr %72, align 4, !tbaa !9
  %294 = icmp ne i32 %293, 0
  br i1 %294, label %295, label %677

295:                                              ; preds = %292
  %296 = load ptr, ptr %37, align 8, !tbaa !5
  store float 1.000000e+00, ptr %296, align 4, !tbaa !11
  store float 1.000000e+00, ptr %71, align 4, !tbaa !11
  %297 = load ptr, ptr %24, align 8, !tbaa !5
  %298 = load i32, ptr %297, align 4, !tbaa !9
  store i32 %298, ptr %53, align 4, !tbaa !9
  store i32 1, ptr %67, align 4, !tbaa !9
  br label %299

299:                                              ; preds = %673, %295
  %300 = load i32, ptr %67, align 4, !tbaa !9
  %301 = load i32, ptr %53, align 4, !tbaa !9
  %302 = icmp sle i32 %300, %301
  br i1 %302, label %303, label %676

303:                                              ; preds = %299
  %304 = load ptr, ptr %23, align 8, !tbaa !5
  %305 = load i32, ptr %304, align 4, !tbaa !9
  store i32 %305, ptr %66, align 4, !tbaa !9
  br label %306

306:                                              ; preds = %669, %303
  %307 = load i32, ptr %66, align 4, !tbaa !9
  %308 = icmp sge i32 %307, 1
  br i1 %308, label %309, label %672

309:                                              ; preds = %306
  %310 = load i32, ptr %66, align 4, !tbaa !9
  %311 = load i32, ptr %66, align 4, !tbaa !9
  %312 = load i32, ptr %41, align 4, !tbaa !9
  %313 = mul nsw i32 %311, %312
  %314 = add nsw i32 %310, %313
  store i32 %314, ptr %54, align 4, !tbaa !9
  %315 = load ptr, ptr %25, align 8, !tbaa !5
  %316 = load i32, ptr %54, align 4, !tbaa !9
  %317 = sext i32 %316 to i64
  %318 = getelementptr inbounds %struct.complex, ptr %315, i64 %317
  %319 = getelementptr inbounds %struct.complex, ptr %318, i32 0, i32 0
  %320 = load float, ptr %319, align 4, !tbaa !13
  %321 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %322 = getelementptr inbounds %struct.complex, ptr %321, i32 0, i32 0
  store float %320, ptr %322, align 16, !tbaa !13
  %323 = load ptr, ptr %25, align 8, !tbaa !5
  %324 = load i32, ptr %54, align 4, !tbaa !9
  %325 = sext i32 %324 to i64
  %326 = getelementptr inbounds %struct.complex, ptr %323, i64 %325
  %327 = getelementptr inbounds %struct.complex, ptr %326, i32 0, i32 1
  %328 = load float, ptr %327, align 4, !tbaa !15
  %329 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %330 = getelementptr inbounds %struct.complex, ptr %329, i32 0, i32 1
  store float %328, ptr %330, align 4, !tbaa !15
  %331 = load i32, ptr %66, align 4, !tbaa !9
  %332 = load i32, ptr %66, align 4, !tbaa !9
  %333 = load i32, ptr %47, align 4, !tbaa !9
  %334 = mul nsw i32 %332, %333
  %335 = add nsw i32 %331, %334
  store i32 %335, ptr %54, align 4, !tbaa !9
  %336 = load ptr, ptr %31, align 8, !tbaa !5
  %337 = load i32, ptr %54, align 4, !tbaa !9
  %338 = sext i32 %337 to i64
  %339 = getelementptr inbounds %struct.complex, ptr %336, i64 %338
  %340 = getelementptr inbounds %struct.complex, ptr %339, i32 0, i32 0
  %341 = load float, ptr %340, align 4, !tbaa !13
  %342 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 1
  %343 = getelementptr inbounds %struct.complex, ptr %342, i32 0, i32 0
  store float %341, ptr %343, align 8, !tbaa !13
  %344 = load ptr, ptr %31, align 8, !tbaa !5
  %345 = load i32, ptr %54, align 4, !tbaa !9
  %346 = sext i32 %345 to i64
  %347 = getelementptr inbounds %struct.complex, ptr %344, i64 %346
  %348 = getelementptr inbounds %struct.complex, ptr %347, i32 0, i32 1
  %349 = load float, ptr %348, align 4, !tbaa !15
  %350 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 1
  %351 = getelementptr inbounds %struct.complex, ptr %350, i32 0, i32 1
  store float %349, ptr %351, align 4, !tbaa !15
  %352 = load i32, ptr %67, align 4, !tbaa !9
  %353 = load i32, ptr %67, align 4, !tbaa !9
  %354 = load i32, ptr %43, align 4, !tbaa !9
  %355 = mul nsw i32 %353, %354
  %356 = add nsw i32 %352, %355
  store i32 %356, ptr %54, align 4, !tbaa !9
  %357 = load ptr, ptr %27, align 8, !tbaa !5
  %358 = load i32, ptr %54, align 4, !tbaa !9
  %359 = sext i32 %358 to i64
  %360 = getelementptr inbounds %struct.complex, ptr %357, i64 %359
  %361 = getelementptr inbounds %struct.complex, ptr %360, i32 0, i32 0
  %362 = load float, ptr %361, align 4, !tbaa !13
  %363 = fneg float %362
  %364 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %363, ptr %364, align 4, !tbaa !13
  %365 = load ptr, ptr %27, align 8, !tbaa !5
  %366 = load i32, ptr %54, align 4, !tbaa !9
  %367 = sext i32 %366 to i64
  %368 = getelementptr inbounds %struct.complex, ptr %365, i64 %367
  %369 = getelementptr inbounds %struct.complex, ptr %368, i32 0, i32 1
  %370 = load float, ptr %369, align 4, !tbaa !15
  %371 = fneg float %370
  %372 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %371, ptr %372, align 4, !tbaa !15
  %373 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %374 = load float, ptr %373, align 4, !tbaa !13
  %375 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 2
  %376 = getelementptr inbounds %struct.complex, ptr %375, i32 0, i32 0
  store float %374, ptr %376, align 16, !tbaa !13
  %377 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %378 = load float, ptr %377, align 4, !tbaa !15
  %379 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 2
  %380 = getelementptr inbounds %struct.complex, ptr %379, i32 0, i32 1
  store float %378, ptr %380, align 4, !tbaa !15
  %381 = load i32, ptr %67, align 4, !tbaa !9
  %382 = load i32, ptr %67, align 4, !tbaa !9
  %383 = load i32, ptr %49, align 4, !tbaa !9
  %384 = mul nsw i32 %382, %383
  %385 = add nsw i32 %381, %384
  store i32 %385, ptr %54, align 4, !tbaa !9
  %386 = load ptr, ptr %33, align 8, !tbaa !5
  %387 = load i32, ptr %54, align 4, !tbaa !9
  %388 = sext i32 %387 to i64
  %389 = getelementptr inbounds %struct.complex, ptr %386, i64 %388
  %390 = getelementptr inbounds %struct.complex, ptr %389, i32 0, i32 0
  %391 = load float, ptr %390, align 4, !tbaa !13
  %392 = fneg float %391
  %393 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %392, ptr %393, align 4, !tbaa !13
  %394 = load ptr, ptr %33, align 8, !tbaa !5
  %395 = load i32, ptr %54, align 4, !tbaa !9
  %396 = sext i32 %395 to i64
  %397 = getelementptr inbounds %struct.complex, ptr %394, i64 %396
  %398 = getelementptr inbounds %struct.complex, ptr %397, i32 0, i32 1
  %399 = load float, ptr %398, align 4, !tbaa !15
  %400 = fneg float %399
  %401 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %400, ptr %401, align 4, !tbaa !15
  %402 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %403 = load float, ptr %402, align 4, !tbaa !13
  %404 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 3
  %405 = getelementptr inbounds %struct.complex, ptr %404, i32 0, i32 0
  store float %403, ptr %405, align 8, !tbaa !13
  %406 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %407 = load float, ptr %406, align 4, !tbaa !15
  %408 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 3
  %409 = getelementptr inbounds %struct.complex, ptr %408, i32 0, i32 1
  store float %407, ptr %409, align 4, !tbaa !15
  %410 = load i32, ptr %66, align 4, !tbaa !9
  %411 = load i32, ptr %67, align 4, !tbaa !9
  %412 = load i32, ptr %45, align 4, !tbaa !9
  %413 = mul nsw i32 %411, %412
  %414 = add nsw i32 %410, %413
  store i32 %414, ptr %54, align 4, !tbaa !9
  %415 = load ptr, ptr %29, align 8, !tbaa !5
  %416 = load i32, ptr %54, align 4, !tbaa !9
  %417 = sext i32 %416 to i64
  %418 = getelementptr inbounds %struct.complex, ptr %415, i64 %417
  %419 = getelementptr inbounds %struct.complex, ptr %418, i32 0, i32 0
  %420 = load float, ptr %419, align 4, !tbaa !13
  %421 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %422 = getelementptr inbounds %struct.complex, ptr %421, i32 0, i32 0
  store float %420, ptr %422, align 16, !tbaa !13
  %423 = load ptr, ptr %29, align 8, !tbaa !5
  %424 = load i32, ptr %54, align 4, !tbaa !9
  %425 = sext i32 %424 to i64
  %426 = getelementptr inbounds %struct.complex, ptr %423, i64 %425
  %427 = getelementptr inbounds %struct.complex, ptr %426, i32 0, i32 1
  %428 = load float, ptr %427, align 4, !tbaa !15
  %429 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %430 = getelementptr inbounds %struct.complex, ptr %429, i32 0, i32 1
  store float %428, ptr %430, align 4, !tbaa !15
  %431 = load i32, ptr %66, align 4, !tbaa !9
  %432 = load i32, ptr %67, align 4, !tbaa !9
  %433 = load i32, ptr %51, align 4, !tbaa !9
  %434 = mul nsw i32 %432, %433
  %435 = add nsw i32 %431, %434
  store i32 %435, ptr %54, align 4, !tbaa !9
  %436 = load ptr, ptr %35, align 8, !tbaa !5
  %437 = load i32, ptr %54, align 4, !tbaa !9
  %438 = sext i32 %437 to i64
  %439 = getelementptr inbounds %struct.complex, ptr %436, i64 %438
  %440 = getelementptr inbounds %struct.complex, ptr %439, i32 0, i32 0
  %441 = load float, ptr %440, align 4, !tbaa !13
  %442 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %443 = getelementptr inbounds %struct.complex, ptr %442, i32 0, i32 0
  store float %441, ptr %443, align 8, !tbaa !13
  %444 = load ptr, ptr %35, align 8, !tbaa !5
  %445 = load i32, ptr %54, align 4, !tbaa !9
  %446 = sext i32 %445 to i64
  %447 = getelementptr inbounds %struct.complex, ptr %444, i64 %446
  %448 = getelementptr inbounds %struct.complex, ptr %447, i32 0, i32 1
  %449 = load float, ptr %448, align 4, !tbaa !15
  %450 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %451 = getelementptr inbounds %struct.complex, ptr %450, i32 0, i32 1
  store float %449, ptr %451, align 4, !tbaa !15
  %452 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %453 = getelementptr inbounds [2 x i32], ptr %64, i64 0, i64 0
  %454 = getelementptr inbounds [2 x i32], ptr %65, i64 0, i64 0
  call void @cgetc2_(ptr noundef @c__2, ptr noundef %452, ptr noundef @c__2, ptr noundef %453, ptr noundef %454, ptr noundef %63)
  %455 = load i32, ptr %63, align 4, !tbaa !9
  %456 = icmp sgt i32 %455, 0
  br i1 %456, label %457, label %460

457:                                              ; preds = %309
  %458 = load i32, ptr %63, align 4, !tbaa !9
  %459 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 %458, ptr %459, align 4, !tbaa !9
  br label %460

460:                                              ; preds = %457, %309
  %461 = load ptr, ptr %22, align 8, !tbaa !5
  %462 = load i32, ptr %461, align 4, !tbaa !9
  %463 = icmp eq i32 %462, 0
  br i1 %463, label %464, label %510

464:                                              ; preds = %460
  %465 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %466 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %467 = getelementptr inbounds [2 x i32], ptr %64, i64 0, i64 0
  %468 = getelementptr inbounds [2 x i32], ptr %65, i64 0, i64 0
  call void @cgesc2_(ptr noundef @c__2, ptr noundef %465, ptr noundef @c__2, ptr noundef %466, ptr noundef %467, ptr noundef %468, ptr noundef %71)
  %469 = load float, ptr %71, align 4, !tbaa !11
  %470 = fcmp une float %469, 1.000000e+00
  br i1 %470, label %471, label %509

471:                                              ; preds = %464
  %472 = load ptr, ptr %24, align 8, !tbaa !5
  %473 = load i32, ptr %472, align 4, !tbaa !9
  store i32 %473, ptr %54, align 4, !tbaa !9
  store i32 1, ptr %68, align 4, !tbaa !9
  br label %474

474:                                              ; preds = %501, %471
  %475 = load i32, ptr %68, align 4, !tbaa !9
  %476 = load i32, ptr %54, align 4, !tbaa !9
  %477 = icmp sle i32 %475, %476
  br i1 %477, label %478, label %504

478:                                              ; preds = %474
  %479 = load float, ptr %71, align 4, !tbaa !11
  %480 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %479, ptr %480, align 4, !tbaa !13
  %481 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float 0.000000e+00, ptr %481, align 4, !tbaa !15
  %482 = load ptr, ptr %23, align 8, !tbaa !5
  %483 = load ptr, ptr %29, align 8, !tbaa !5
  %484 = load i32, ptr %68, align 4, !tbaa !9
  %485 = load i32, ptr %45, align 4, !tbaa !9
  %486 = mul nsw i32 %484, %485
  %487 = add nsw i32 %486, 1
  %488 = sext i32 %487 to i64
  %489 = getelementptr inbounds %struct.complex, ptr %483, i64 %488
  call void @cscal_(ptr noundef %482, ptr noundef %57, ptr noundef %489, ptr noundef @c__1)
  %490 = load float, ptr %71, align 4, !tbaa !11
  %491 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %490, ptr %491, align 4, !tbaa !13
  %492 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float 0.000000e+00, ptr %492, align 4, !tbaa !15
  %493 = load ptr, ptr %23, align 8, !tbaa !5
  %494 = load ptr, ptr %35, align 8, !tbaa !5
  %495 = load i32, ptr %68, align 4, !tbaa !9
  %496 = load i32, ptr %51, align 4, !tbaa !9
  %497 = mul nsw i32 %495, %496
  %498 = add nsw i32 %497, 1
  %499 = sext i32 %498 to i64
  %500 = getelementptr inbounds %struct.complex, ptr %494, i64 %499
  call void @cscal_(ptr noundef %493, ptr noundef %57, ptr noundef %500, ptr noundef @c__1)
  br label %501

501:                                              ; preds = %478
  %502 = load i32, ptr %68, align 4, !tbaa !9
  %503 = add nsw i32 %502, 1
  store i32 %503, ptr %68, align 4, !tbaa !9
  br label %474, !llvm.loop !16

504:                                              ; preds = %474
  %505 = load float, ptr %71, align 4, !tbaa !11
  %506 = load ptr, ptr %37, align 8, !tbaa !5
  %507 = load float, ptr %506, align 4, !tbaa !11
  %508 = fmul float %507, %505
  store float %508, ptr %506, align 4, !tbaa !11
  br label %509

509:                                              ; preds = %504, %464
  br label %518

510:                                              ; preds = %460
  %511 = load ptr, ptr %22, align 8, !tbaa !5
  %512 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %513 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %514 = load ptr, ptr %38, align 8, !tbaa !5
  %515 = load ptr, ptr %39, align 8, !tbaa !5
  %516 = getelementptr inbounds [2 x i32], ptr %64, i64 0, i64 0
  %517 = getelementptr inbounds [2 x i32], ptr %65, i64 0, i64 0
  call void @clatdf_(ptr noundef %511, ptr noundef @c__2, ptr noundef %512, ptr noundef @c__2, ptr noundef %513, ptr noundef %514, ptr noundef %515, ptr noundef %516, ptr noundef %517)
  br label %518

518:                                              ; preds = %510, %509
  %519 = load i32, ptr %66, align 4, !tbaa !9
  %520 = load i32, ptr %67, align 4, !tbaa !9
  %521 = load i32, ptr %45, align 4, !tbaa !9
  %522 = mul nsw i32 %520, %521
  %523 = add nsw i32 %519, %522
  store i32 %523, ptr %54, align 4, !tbaa !9
  %524 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %525 = getelementptr inbounds %struct.complex, ptr %524, i32 0, i32 0
  %526 = load float, ptr %525, align 16, !tbaa !13
  %527 = load ptr, ptr %29, align 8, !tbaa !5
  %528 = load i32, ptr %54, align 4, !tbaa !9
  %529 = sext i32 %528 to i64
  %530 = getelementptr inbounds %struct.complex, ptr %527, i64 %529
  %531 = getelementptr inbounds %struct.complex, ptr %530, i32 0, i32 0
  store float %526, ptr %531, align 4, !tbaa !13
  %532 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %533 = getelementptr inbounds %struct.complex, ptr %532, i32 0, i32 1
  %534 = load float, ptr %533, align 4, !tbaa !15
  %535 = load ptr, ptr %29, align 8, !tbaa !5
  %536 = load i32, ptr %54, align 4, !tbaa !9
  %537 = sext i32 %536 to i64
  %538 = getelementptr inbounds %struct.complex, ptr %535, i64 %537
  %539 = getelementptr inbounds %struct.complex, ptr %538, i32 0, i32 1
  store float %534, ptr %539, align 4, !tbaa !15
  %540 = load i32, ptr %66, align 4, !tbaa !9
  %541 = load i32, ptr %67, align 4, !tbaa !9
  %542 = load i32, ptr %51, align 4, !tbaa !9
  %543 = mul nsw i32 %541, %542
  %544 = add nsw i32 %540, %543
  store i32 %544, ptr %54, align 4, !tbaa !9
  %545 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %546 = getelementptr inbounds %struct.complex, ptr %545, i32 0, i32 0
  %547 = load float, ptr %546, align 8, !tbaa !13
  %548 = load ptr, ptr %35, align 8, !tbaa !5
  %549 = load i32, ptr %54, align 4, !tbaa !9
  %550 = sext i32 %549 to i64
  %551 = getelementptr inbounds %struct.complex, ptr %548, i64 %550
  %552 = getelementptr inbounds %struct.complex, ptr %551, i32 0, i32 0
  store float %547, ptr %552, align 4, !tbaa !13
  %553 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %554 = getelementptr inbounds %struct.complex, ptr %553, i32 0, i32 1
  %555 = load float, ptr %554, align 4, !tbaa !15
  %556 = load ptr, ptr %35, align 8, !tbaa !5
  %557 = load i32, ptr %54, align 4, !tbaa !9
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds %struct.complex, ptr %556, i64 %558
  %560 = getelementptr inbounds %struct.complex, ptr %559, i32 0, i32 1
  store float %555, ptr %560, align 4, !tbaa !15
  %561 = load i32, ptr %66, align 4, !tbaa !9
  %562 = icmp sgt i32 %561, 1
  br i1 %562, label %563, label %612

563:                                              ; preds = %518
  %564 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %565 = getelementptr inbounds %struct.complex, ptr %564, i32 0, i32 0
  %566 = load float, ptr %565, align 16, !tbaa !13
  %567 = fneg float %566
  %568 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %567, ptr %568, align 4, !tbaa !13
  %569 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %570 = getelementptr inbounds %struct.complex, ptr %569, i32 0, i32 1
  %571 = load float, ptr %570, align 4, !tbaa !15
  %572 = fneg float %571
  %573 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %572, ptr %573, align 4, !tbaa !15
  %574 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %575 = load float, ptr %574, align 4, !tbaa !13
  %576 = getelementptr inbounds %struct.complex, ptr %69, i32 0, i32 0
  store float %575, ptr %576, align 4, !tbaa !13
  %577 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %578 = load float, ptr %577, align 4, !tbaa !15
  %579 = getelementptr inbounds %struct.complex, ptr %69, i32 0, i32 1
  store float %578, ptr %579, align 4, !tbaa !15
  %580 = load i32, ptr %66, align 4, !tbaa !9
  %581 = sub nsw i32 %580, 1
  store i32 %581, ptr %54, align 4, !tbaa !9
  %582 = load ptr, ptr %25, align 8, !tbaa !5
  %583 = load i32, ptr %66, align 4, !tbaa !9
  %584 = load i32, ptr %41, align 4, !tbaa !9
  %585 = mul nsw i32 %583, %584
  %586 = add nsw i32 %585, 1
  %587 = sext i32 %586 to i64
  %588 = getelementptr inbounds %struct.complex, ptr %582, i64 %587
  %589 = load ptr, ptr %29, align 8, !tbaa !5
  %590 = load i32, ptr %67, align 4, !tbaa !9
  %591 = load i32, ptr %45, align 4, !tbaa !9
  %592 = mul nsw i32 %590, %591
  %593 = add nsw i32 %592, 1
  %594 = sext i32 %593 to i64
  %595 = getelementptr inbounds %struct.complex, ptr %589, i64 %594
  call void @caxpy_(ptr noundef %54, ptr noundef %69, ptr noundef %588, ptr noundef @c__1, ptr noundef %595, ptr noundef @c__1)
  %596 = load i32, ptr %66, align 4, !tbaa !9
  %597 = sub nsw i32 %596, 1
  store i32 %597, ptr %54, align 4, !tbaa !9
  %598 = load ptr, ptr %31, align 8, !tbaa !5
  %599 = load i32, ptr %66, align 4, !tbaa !9
  %600 = load i32, ptr %47, align 4, !tbaa !9
  %601 = mul nsw i32 %599, %600
  %602 = add nsw i32 %601, 1
  %603 = sext i32 %602 to i64
  %604 = getelementptr inbounds %struct.complex, ptr %598, i64 %603
  %605 = load ptr, ptr %35, align 8, !tbaa !5
  %606 = load i32, ptr %67, align 4, !tbaa !9
  %607 = load i32, ptr %51, align 4, !tbaa !9
  %608 = mul nsw i32 %606, %607
  %609 = add nsw i32 %608, 1
  %610 = sext i32 %609 to i64
  %611 = getelementptr inbounds %struct.complex, ptr %605, i64 %610
  call void @caxpy_(ptr noundef %54, ptr noundef %69, ptr noundef %604, ptr noundef @c__1, ptr noundef %611, ptr noundef @c__1)
  br label %612

612:                                              ; preds = %563, %518
  %613 = load i32, ptr %67, align 4, !tbaa !9
  %614 = load ptr, ptr %24, align 8, !tbaa !5
  %615 = load i32, ptr %614, align 4, !tbaa !9
  %616 = icmp slt i32 %613, %615
  br i1 %616, label %617, label %668

617:                                              ; preds = %612
  %618 = load ptr, ptr %24, align 8, !tbaa !5
  %619 = load i32, ptr %618, align 4, !tbaa !9
  %620 = load i32, ptr %67, align 4, !tbaa !9
  %621 = sub nsw i32 %619, %620
  store i32 %621, ptr %54, align 4, !tbaa !9
  %622 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %623 = load ptr, ptr %27, align 8, !tbaa !5
  %624 = load i32, ptr %67, align 4, !tbaa !9
  %625 = load i32, ptr %67, align 4, !tbaa !9
  %626 = add nsw i32 %625, 1
  %627 = load i32, ptr %43, align 4, !tbaa !9
  %628 = mul nsw i32 %626, %627
  %629 = add nsw i32 %624, %628
  %630 = sext i32 %629 to i64
  %631 = getelementptr inbounds %struct.complex, ptr %623, i64 %630
  %632 = load ptr, ptr %28, align 8, !tbaa !5
  %633 = load ptr, ptr %29, align 8, !tbaa !5
  %634 = load i32, ptr %66, align 4, !tbaa !9
  %635 = load i32, ptr %67, align 4, !tbaa !9
  %636 = add nsw i32 %635, 1
  %637 = load i32, ptr %45, align 4, !tbaa !9
  %638 = mul nsw i32 %636, %637
  %639 = add nsw i32 %634, %638
  %640 = sext i32 %639 to i64
  %641 = getelementptr inbounds %struct.complex, ptr %633, i64 %640
  %642 = load ptr, ptr %30, align 8, !tbaa !5
  call void @caxpy_(ptr noundef %54, ptr noundef %622, ptr noundef %631, ptr noundef %632, ptr noundef %641, ptr noundef %642)
  %643 = load ptr, ptr %24, align 8, !tbaa !5
  %644 = load i32, ptr %643, align 4, !tbaa !9
  %645 = load i32, ptr %67, align 4, !tbaa !9
  %646 = sub nsw i32 %644, %645
  store i32 %646, ptr %54, align 4, !tbaa !9
  %647 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %648 = load ptr, ptr %33, align 8, !tbaa !5
  %649 = load i32, ptr %67, align 4, !tbaa !9
  %650 = load i32, ptr %67, align 4, !tbaa !9
  %651 = add nsw i32 %650, 1
  %652 = load i32, ptr %49, align 4, !tbaa !9
  %653 = mul nsw i32 %651, %652
  %654 = add nsw i32 %649, %653
  %655 = sext i32 %654 to i64
  %656 = getelementptr inbounds %struct.complex, ptr %648, i64 %655
  %657 = load ptr, ptr %34, align 8, !tbaa !5
  %658 = load ptr, ptr %35, align 8, !tbaa !5
  %659 = load i32, ptr %66, align 4, !tbaa !9
  %660 = load i32, ptr %67, align 4, !tbaa !9
  %661 = add nsw i32 %660, 1
  %662 = load i32, ptr %51, align 4, !tbaa !9
  %663 = mul nsw i32 %661, %662
  %664 = add nsw i32 %659, %663
  %665 = sext i32 %664 to i64
  %666 = getelementptr inbounds %struct.complex, ptr %658, i64 %665
  %667 = load ptr, ptr %36, align 8, !tbaa !5
  call void @caxpy_(ptr noundef %54, ptr noundef %647, ptr noundef %656, ptr noundef %657, ptr noundef %666, ptr noundef %667)
  br label %668

668:                                              ; preds = %617, %612
  br label %669

669:                                              ; preds = %668
  %670 = load i32, ptr %66, align 4, !tbaa !9
  %671 = add nsw i32 %670, -1
  store i32 %671, ptr %66, align 4, !tbaa !9
  br label %306, !llvm.loop !18

672:                                              ; preds = %306
  br label %673

673:                                              ; preds = %672
  %674 = load i32, ptr %67, align 4, !tbaa !9
  %675 = add nsw i32 %674, 1
  store i32 %675, ptr %67, align 4, !tbaa !9
  br label %299, !llvm.loop !19

676:                                              ; preds = %299
  br label %1266

677:                                              ; preds = %292
  %678 = load ptr, ptr %37, align 8, !tbaa !5
  store float 1.000000e+00, ptr %678, align 4, !tbaa !11
  store float 1.000000e+00, ptr %71, align 4, !tbaa !11
  %679 = load ptr, ptr %23, align 8, !tbaa !5
  %680 = load i32, ptr %679, align 4, !tbaa !9
  store i32 %680, ptr %53, align 4, !tbaa !9
  store i32 1, ptr %66, align 4, !tbaa !9
  br label %681

681:                                              ; preds = %1262, %677
  %682 = load i32, ptr %66, align 4, !tbaa !9
  %683 = load i32, ptr %53, align 4, !tbaa !9
  %684 = icmp sle i32 %682, %683
  br i1 %684, label %685, label %1265

685:                                              ; preds = %681
  %686 = load ptr, ptr %24, align 8, !tbaa !5
  %687 = load i32, ptr %686, align 4, !tbaa !9
  store i32 %687, ptr %67, align 4, !tbaa !9
  br label %688

688:                                              ; preds = %1258, %685
  %689 = load i32, ptr %67, align 4, !tbaa !9
  %690 = icmp sge i32 %689, 1
  br i1 %690, label %691, label %1261

691:                                              ; preds = %688
  %692 = load ptr, ptr %25, align 8, !tbaa !5
  %693 = load i32, ptr %66, align 4, !tbaa !9
  %694 = load i32, ptr %66, align 4, !tbaa !9
  %695 = load i32, ptr %41, align 4, !tbaa !9
  %696 = mul nsw i32 %694, %695
  %697 = add nsw i32 %693, %696
  %698 = sext i32 %697 to i64
  %699 = getelementptr inbounds %struct.complex, ptr %692, i64 %698
  %700 = call <2 x float> @Cf(ptr noundef %699)
  store <2 x float> %700, ptr %75, align 4
  %701 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 0
  %702 = load float, ptr %701, align 4
  %703 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 1
  %704 = load float, ptr %703, align 4
  %705 = fneg float %704
  %706 = call ptr @_pCf(ptr noundef %57)
  %707 = getelementptr inbounds { float, float }, ptr %706, i32 0, i32 0
  %708 = getelementptr inbounds { float, float }, ptr %706, i32 0, i32 1
  store float %702, ptr %707, align 4
  store float %705, ptr %708, align 4
  %709 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %710 = load float, ptr %709, align 4, !tbaa !13
  %711 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %712 = getelementptr inbounds %struct.complex, ptr %711, i32 0, i32 0
  store float %710, ptr %712, align 16, !tbaa !13
  %713 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %714 = load float, ptr %713, align 4, !tbaa !15
  %715 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %716 = getelementptr inbounds %struct.complex, ptr %715, i32 0, i32 1
  store float %714, ptr %716, align 4, !tbaa !15
  %717 = load ptr, ptr %27, align 8, !tbaa !5
  %718 = load i32, ptr %67, align 4, !tbaa !9
  %719 = load i32, ptr %67, align 4, !tbaa !9
  %720 = load i32, ptr %43, align 4, !tbaa !9
  %721 = mul nsw i32 %719, %720
  %722 = add nsw i32 %718, %721
  %723 = sext i32 %722 to i64
  %724 = getelementptr inbounds %struct.complex, ptr %717, i64 %723
  %725 = call <2 x float> @Cf(ptr noundef %724)
  store <2 x float> %725, ptr %76, align 4
  %726 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 0
  %727 = load float, ptr %726, align 4
  %728 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 1
  %729 = load float, ptr %728, align 4
  %730 = fneg float %729
  %731 = call ptr @_pCf(ptr noundef %58)
  %732 = getelementptr inbounds { float, float }, ptr %731, i32 0, i32 0
  %733 = getelementptr inbounds { float, float }, ptr %731, i32 0, i32 1
  store float %727, ptr %732, align 4
  store float %730, ptr %733, align 4
  %734 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  %735 = load float, ptr %734, align 4, !tbaa !13
  %736 = fneg float %735
  %737 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %736, ptr %737, align 4, !tbaa !13
  %738 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  %739 = load float, ptr %738, align 4, !tbaa !15
  %740 = fneg float %739
  %741 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %740, ptr %741, align 4, !tbaa !15
  %742 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %743 = load float, ptr %742, align 4, !tbaa !13
  %744 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 1
  %745 = getelementptr inbounds %struct.complex, ptr %744, i32 0, i32 0
  store float %743, ptr %745, align 8, !tbaa !13
  %746 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %747 = load float, ptr %746, align 4, !tbaa !15
  %748 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 1
  %749 = getelementptr inbounds %struct.complex, ptr %748, i32 0, i32 1
  store float %747, ptr %749, align 4, !tbaa !15
  %750 = load ptr, ptr %31, align 8, !tbaa !5
  %751 = load i32, ptr %66, align 4, !tbaa !9
  %752 = load i32, ptr %66, align 4, !tbaa !9
  %753 = load i32, ptr %47, align 4, !tbaa !9
  %754 = mul nsw i32 %752, %753
  %755 = add nsw i32 %751, %754
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds %struct.complex, ptr %750, i64 %756
  %758 = call <2 x float> @Cf(ptr noundef %757)
  store <2 x float> %758, ptr %77, align 4
  %759 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 0
  %760 = load float, ptr %759, align 4
  %761 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 1
  %762 = load float, ptr %761, align 4
  %763 = fneg float %762
  %764 = call ptr @_pCf(ptr noundef %57)
  %765 = getelementptr inbounds { float, float }, ptr %764, i32 0, i32 0
  %766 = getelementptr inbounds { float, float }, ptr %764, i32 0, i32 1
  store float %760, ptr %765, align 4
  store float %763, ptr %766, align 4
  %767 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %768 = load float, ptr %767, align 4, !tbaa !13
  %769 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 2
  %770 = getelementptr inbounds %struct.complex, ptr %769, i32 0, i32 0
  store float %768, ptr %770, align 16, !tbaa !13
  %771 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %772 = load float, ptr %771, align 4, !tbaa !15
  %773 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 2
  %774 = getelementptr inbounds %struct.complex, ptr %773, i32 0, i32 1
  store float %772, ptr %774, align 4, !tbaa !15
  %775 = load ptr, ptr %33, align 8, !tbaa !5
  %776 = load i32, ptr %67, align 4, !tbaa !9
  %777 = load i32, ptr %67, align 4, !tbaa !9
  %778 = load i32, ptr %49, align 4, !tbaa !9
  %779 = mul nsw i32 %777, %778
  %780 = add nsw i32 %776, %779
  %781 = sext i32 %780 to i64
  %782 = getelementptr inbounds %struct.complex, ptr %775, i64 %781
  %783 = call <2 x float> @Cf(ptr noundef %782)
  store <2 x float> %783, ptr %78, align 4
  %784 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 0
  %785 = load float, ptr %784, align 4
  %786 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 1
  %787 = load float, ptr %786, align 4
  %788 = fneg float %787
  %789 = call ptr @_pCf(ptr noundef %58)
  %790 = getelementptr inbounds { float, float }, ptr %789, i32 0, i32 0
  %791 = getelementptr inbounds { float, float }, ptr %789, i32 0, i32 1
  store float %785, ptr %790, align 4
  store float %788, ptr %791, align 4
  %792 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  %793 = load float, ptr %792, align 4, !tbaa !13
  %794 = fneg float %793
  %795 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %794, ptr %795, align 4, !tbaa !13
  %796 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  %797 = load float, ptr %796, align 4, !tbaa !15
  %798 = fneg float %797
  %799 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %798, ptr %799, align 4, !tbaa !15
  %800 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %801 = load float, ptr %800, align 4, !tbaa !13
  %802 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 3
  %803 = getelementptr inbounds %struct.complex, ptr %802, i32 0, i32 0
  store float %801, ptr %803, align 8, !tbaa !13
  %804 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %805 = load float, ptr %804, align 4, !tbaa !15
  %806 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 3
  %807 = getelementptr inbounds %struct.complex, ptr %806, i32 0, i32 1
  store float %805, ptr %807, align 4, !tbaa !15
  %808 = load i32, ptr %66, align 4, !tbaa !9
  %809 = load i32, ptr %67, align 4, !tbaa !9
  %810 = load i32, ptr %45, align 4, !tbaa !9
  %811 = mul nsw i32 %809, %810
  %812 = add nsw i32 %808, %811
  store i32 %812, ptr %54, align 4, !tbaa !9
  %813 = load ptr, ptr %29, align 8, !tbaa !5
  %814 = load i32, ptr %54, align 4, !tbaa !9
  %815 = sext i32 %814 to i64
  %816 = getelementptr inbounds %struct.complex, ptr %813, i64 %815
  %817 = getelementptr inbounds %struct.complex, ptr %816, i32 0, i32 0
  %818 = load float, ptr %817, align 4, !tbaa !13
  %819 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %820 = getelementptr inbounds %struct.complex, ptr %819, i32 0, i32 0
  store float %818, ptr %820, align 16, !tbaa !13
  %821 = load ptr, ptr %29, align 8, !tbaa !5
  %822 = load i32, ptr %54, align 4, !tbaa !9
  %823 = sext i32 %822 to i64
  %824 = getelementptr inbounds %struct.complex, ptr %821, i64 %823
  %825 = getelementptr inbounds %struct.complex, ptr %824, i32 0, i32 1
  %826 = load float, ptr %825, align 4, !tbaa !15
  %827 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %828 = getelementptr inbounds %struct.complex, ptr %827, i32 0, i32 1
  store float %826, ptr %828, align 4, !tbaa !15
  %829 = load i32, ptr %66, align 4, !tbaa !9
  %830 = load i32, ptr %67, align 4, !tbaa !9
  %831 = load i32, ptr %51, align 4, !tbaa !9
  %832 = mul nsw i32 %830, %831
  %833 = add nsw i32 %829, %832
  store i32 %833, ptr %54, align 4, !tbaa !9
  %834 = load ptr, ptr %35, align 8, !tbaa !5
  %835 = load i32, ptr %54, align 4, !tbaa !9
  %836 = sext i32 %835 to i64
  %837 = getelementptr inbounds %struct.complex, ptr %834, i64 %836
  %838 = getelementptr inbounds %struct.complex, ptr %837, i32 0, i32 0
  %839 = load float, ptr %838, align 4, !tbaa !13
  %840 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %841 = getelementptr inbounds %struct.complex, ptr %840, i32 0, i32 0
  store float %839, ptr %841, align 8, !tbaa !13
  %842 = load ptr, ptr %35, align 8, !tbaa !5
  %843 = load i32, ptr %54, align 4, !tbaa !9
  %844 = sext i32 %843 to i64
  %845 = getelementptr inbounds %struct.complex, ptr %842, i64 %844
  %846 = getelementptr inbounds %struct.complex, ptr %845, i32 0, i32 1
  %847 = load float, ptr %846, align 4, !tbaa !15
  %848 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %849 = getelementptr inbounds %struct.complex, ptr %848, i32 0, i32 1
  store float %847, ptr %849, align 4, !tbaa !15
  %850 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %851 = getelementptr inbounds [2 x i32], ptr %64, i64 0, i64 0
  %852 = getelementptr inbounds [2 x i32], ptr %65, i64 0, i64 0
  call void @cgetc2_(ptr noundef @c__2, ptr noundef %850, ptr noundef @c__2, ptr noundef %851, ptr noundef %852, ptr noundef %63)
  %853 = load i32, ptr %63, align 4, !tbaa !9
  %854 = icmp sgt i32 %853, 0
  br i1 %854, label %855, label %858

855:                                              ; preds = %691
  %856 = load i32, ptr %63, align 4, !tbaa !9
  %857 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 %856, ptr %857, align 4, !tbaa !9
  br label %858

858:                                              ; preds = %855, %691
  %859 = getelementptr inbounds [4 x %struct.complex], ptr %70, i64 0, i64 0
  %860 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %861 = getelementptr inbounds [2 x i32], ptr %64, i64 0, i64 0
  %862 = getelementptr inbounds [2 x i32], ptr %65, i64 0, i64 0
  call void @cgesc2_(ptr noundef @c__2, ptr noundef %859, ptr noundef @c__2, ptr noundef %860, ptr noundef %861, ptr noundef %862, ptr noundef %71)
  %863 = load float, ptr %71, align 4, !tbaa !11
  %864 = fcmp une float %863, 1.000000e+00
  br i1 %864, label %865, label %903

865:                                              ; preds = %858
  %866 = load ptr, ptr %24, align 8, !tbaa !5
  %867 = load i32, ptr %866, align 4, !tbaa !9
  store i32 %867, ptr %54, align 4, !tbaa !9
  store i32 1, ptr %68, align 4, !tbaa !9
  br label %868

868:                                              ; preds = %895, %865
  %869 = load i32, ptr %68, align 4, !tbaa !9
  %870 = load i32, ptr %54, align 4, !tbaa !9
  %871 = icmp sle i32 %869, %870
  br i1 %871, label %872, label %898

872:                                              ; preds = %868
  %873 = load float, ptr %71, align 4, !tbaa !11
  %874 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %873, ptr %874, align 4, !tbaa !13
  %875 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float 0.000000e+00, ptr %875, align 4, !tbaa !15
  %876 = load ptr, ptr %23, align 8, !tbaa !5
  %877 = load ptr, ptr %29, align 8, !tbaa !5
  %878 = load i32, ptr %68, align 4, !tbaa !9
  %879 = load i32, ptr %45, align 4, !tbaa !9
  %880 = mul nsw i32 %878, %879
  %881 = add nsw i32 %880, 1
  %882 = sext i32 %881 to i64
  %883 = getelementptr inbounds %struct.complex, ptr %877, i64 %882
  call void @cscal_(ptr noundef %876, ptr noundef %57, ptr noundef %883, ptr noundef @c__1)
  %884 = load float, ptr %71, align 4, !tbaa !11
  %885 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %884, ptr %885, align 4, !tbaa !13
  %886 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float 0.000000e+00, ptr %886, align 4, !tbaa !15
  %887 = load ptr, ptr %23, align 8, !tbaa !5
  %888 = load ptr, ptr %35, align 8, !tbaa !5
  %889 = load i32, ptr %68, align 4, !tbaa !9
  %890 = load i32, ptr %51, align 4, !tbaa !9
  %891 = mul nsw i32 %889, %890
  %892 = add nsw i32 %891, 1
  %893 = sext i32 %892 to i64
  %894 = getelementptr inbounds %struct.complex, ptr %888, i64 %893
  call void @cscal_(ptr noundef %887, ptr noundef %57, ptr noundef %894, ptr noundef @c__1)
  br label %895

895:                                              ; preds = %872
  %896 = load i32, ptr %68, align 4, !tbaa !9
  %897 = add nsw i32 %896, 1
  store i32 %897, ptr %68, align 4, !tbaa !9
  br label %868, !llvm.loop !20

898:                                              ; preds = %868
  %899 = load float, ptr %71, align 4, !tbaa !11
  %900 = load ptr, ptr %37, align 8, !tbaa !5
  %901 = load float, ptr %900, align 4, !tbaa !11
  %902 = fmul float %901, %899
  store float %902, ptr %900, align 4, !tbaa !11
  br label %903

903:                                              ; preds = %898, %858
  %904 = load i32, ptr %66, align 4, !tbaa !9
  %905 = load i32, ptr %67, align 4, !tbaa !9
  %906 = load i32, ptr %45, align 4, !tbaa !9
  %907 = mul nsw i32 %905, %906
  %908 = add nsw i32 %904, %907
  store i32 %908, ptr %54, align 4, !tbaa !9
  %909 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %910 = getelementptr inbounds %struct.complex, ptr %909, i32 0, i32 0
  %911 = load float, ptr %910, align 16, !tbaa !13
  %912 = load ptr, ptr %29, align 8, !tbaa !5
  %913 = load i32, ptr %54, align 4, !tbaa !9
  %914 = sext i32 %913 to i64
  %915 = getelementptr inbounds %struct.complex, ptr %912, i64 %914
  %916 = getelementptr inbounds %struct.complex, ptr %915, i32 0, i32 0
  store float %911, ptr %916, align 4, !tbaa !13
  %917 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %918 = getelementptr inbounds %struct.complex, ptr %917, i32 0, i32 1
  %919 = load float, ptr %918, align 4, !tbaa !15
  %920 = load ptr, ptr %29, align 8, !tbaa !5
  %921 = load i32, ptr %54, align 4, !tbaa !9
  %922 = sext i32 %921 to i64
  %923 = getelementptr inbounds %struct.complex, ptr %920, i64 %922
  %924 = getelementptr inbounds %struct.complex, ptr %923, i32 0, i32 1
  store float %919, ptr %924, align 4, !tbaa !15
  %925 = load i32, ptr %66, align 4, !tbaa !9
  %926 = load i32, ptr %67, align 4, !tbaa !9
  %927 = load i32, ptr %51, align 4, !tbaa !9
  %928 = mul nsw i32 %926, %927
  %929 = add nsw i32 %925, %928
  store i32 %929, ptr %54, align 4, !tbaa !9
  %930 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %931 = getelementptr inbounds %struct.complex, ptr %930, i32 0, i32 0
  %932 = load float, ptr %931, align 8, !tbaa !13
  %933 = load ptr, ptr %35, align 8, !tbaa !5
  %934 = load i32, ptr %54, align 4, !tbaa !9
  %935 = sext i32 %934 to i64
  %936 = getelementptr inbounds %struct.complex, ptr %933, i64 %935
  %937 = getelementptr inbounds %struct.complex, ptr %936, i32 0, i32 0
  store float %932, ptr %937, align 4, !tbaa !13
  %938 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %939 = getelementptr inbounds %struct.complex, ptr %938, i32 0, i32 1
  %940 = load float, ptr %939, align 4, !tbaa !15
  %941 = load ptr, ptr %35, align 8, !tbaa !5
  %942 = load i32, ptr %54, align 4, !tbaa !9
  %943 = sext i32 %942 to i64
  %944 = getelementptr inbounds %struct.complex, ptr %941, i64 %943
  %945 = getelementptr inbounds %struct.complex, ptr %944, i32 0, i32 1
  store float %940, ptr %945, align 4, !tbaa !15
  %946 = load i32, ptr %67, align 4, !tbaa !9
  %947 = sub nsw i32 %946, 1
  store i32 %947, ptr %54, align 4, !tbaa !9
  store i32 1, ptr %68, align 4, !tbaa !9
  br label %948

948:                                              ; preds = %1097, %903
  %949 = load i32, ptr %68, align 4, !tbaa !9
  %950 = load i32, ptr %54, align 4, !tbaa !9
  %951 = icmp sle i32 %949, %950
  br i1 %951, label %952, label %1100

952:                                              ; preds = %948
  %953 = load i32, ptr %66, align 4, !tbaa !9
  %954 = load i32, ptr %68, align 4, !tbaa !9
  %955 = load i32, ptr %51, align 4, !tbaa !9
  %956 = mul nsw i32 %954, %955
  %957 = add nsw i32 %953, %956
  store i32 %957, ptr %55, align 4, !tbaa !9
  %958 = load i32, ptr %66, align 4, !tbaa !9
  %959 = load i32, ptr %68, align 4, !tbaa !9
  %960 = load i32, ptr %51, align 4, !tbaa !9
  %961 = mul nsw i32 %959, %960
  %962 = add nsw i32 %958, %961
  store i32 %962, ptr %56, align 4, !tbaa !9
  %963 = load ptr, ptr %27, align 8, !tbaa !5
  %964 = load i32, ptr %68, align 4, !tbaa !9
  %965 = load i32, ptr %67, align 4, !tbaa !9
  %966 = load i32, ptr %43, align 4, !tbaa !9
  %967 = mul nsw i32 %965, %966
  %968 = add nsw i32 %964, %967
  %969 = sext i32 %968 to i64
  %970 = getelementptr inbounds %struct.complex, ptr %963, i64 %969
  %971 = call <2 x float> @Cf(ptr noundef %970)
  store <2 x float> %971, ptr %79, align 4
  %972 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 0
  %973 = load float, ptr %972, align 4
  %974 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 1
  %975 = load float, ptr %974, align 4
  %976 = fneg float %975
  %977 = call ptr @_pCf(ptr noundef %60)
  %978 = getelementptr inbounds { float, float }, ptr %977, i32 0, i32 0
  %979 = getelementptr inbounds { float, float }, ptr %977, i32 0, i32 1
  store float %973, ptr %978, align 4
  store float %976, ptr %979, align 4
  %980 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %981 = getelementptr inbounds %struct.complex, ptr %980, i32 0, i32 0
  %982 = load float, ptr %981, align 16, !tbaa !13
  %983 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 0
  %984 = load float, ptr %983, align 4, !tbaa !13
  %985 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %986 = getelementptr inbounds %struct.complex, ptr %985, i32 0, i32 1
  %987 = load float, ptr %986, align 4, !tbaa !15
  %988 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 1
  %989 = load float, ptr %988, align 4, !tbaa !15
  %990 = fmul float %987, %989
  %991 = fneg float %990
  %992 = call float @llvm.fmuladd.f32(float %982, float %984, float %991)
  %993 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 0
  store float %992, ptr %993, align 4, !tbaa !13
  %994 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %995 = getelementptr inbounds %struct.complex, ptr %994, i32 0, i32 0
  %996 = load float, ptr %995, align 16, !tbaa !13
  %997 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 1
  %998 = load float, ptr %997, align 4, !tbaa !15
  %999 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %1000 = getelementptr inbounds %struct.complex, ptr %999, i32 0, i32 1
  %1001 = load float, ptr %1000, align 4, !tbaa !15
  %1002 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 0
  %1003 = load float, ptr %1002, align 4, !tbaa !13
  %1004 = fmul float %1001, %1003
  %1005 = call float @llvm.fmuladd.f32(float %996, float %998, float %1004)
  %1006 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 1
  store float %1005, ptr %1006, align 4, !tbaa !15
  %1007 = load ptr, ptr %35, align 8, !tbaa !5
  %1008 = load i32, ptr %56, align 4, !tbaa !9
  %1009 = sext i32 %1008 to i64
  %1010 = getelementptr inbounds %struct.complex, ptr %1007, i64 %1009
  %1011 = getelementptr inbounds %struct.complex, ptr %1010, i32 0, i32 0
  %1012 = load float, ptr %1011, align 4, !tbaa !13
  %1013 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 0
  %1014 = load float, ptr %1013, align 4, !tbaa !13
  %1015 = fadd float %1012, %1014
  %1016 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  store float %1015, ptr %1016, align 4, !tbaa !13
  %1017 = load ptr, ptr %35, align 8, !tbaa !5
  %1018 = load i32, ptr %56, align 4, !tbaa !9
  %1019 = sext i32 %1018 to i64
  %1020 = getelementptr inbounds %struct.complex, ptr %1017, i64 %1019
  %1021 = getelementptr inbounds %struct.complex, ptr %1020, i32 0, i32 1
  %1022 = load float, ptr %1021, align 4, !tbaa !15
  %1023 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 1
  %1024 = load float, ptr %1023, align 4, !tbaa !15
  %1025 = fadd float %1022, %1024
  %1026 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  store float %1025, ptr %1026, align 4, !tbaa !15
  %1027 = load ptr, ptr %33, align 8, !tbaa !5
  %1028 = load i32, ptr %68, align 4, !tbaa !9
  %1029 = load i32, ptr %67, align 4, !tbaa !9
  %1030 = load i32, ptr %49, align 4, !tbaa !9
  %1031 = mul nsw i32 %1029, %1030
  %1032 = add nsw i32 %1028, %1031
  %1033 = sext i32 %1032 to i64
  %1034 = getelementptr inbounds %struct.complex, ptr %1027, i64 %1033
  %1035 = call <2 x float> @Cf(ptr noundef %1034)
  store <2 x float> %1035, ptr %80, align 4
  %1036 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 0
  %1037 = load float, ptr %1036, align 4
  %1038 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 1
  %1039 = load float, ptr %1038, align 4
  %1040 = fneg float %1039
  %1041 = call ptr @_pCf(ptr noundef %62)
  %1042 = getelementptr inbounds { float, float }, ptr %1041, i32 0, i32 0
  %1043 = getelementptr inbounds { float, float }, ptr %1041, i32 0, i32 1
  store float %1037, ptr %1042, align 4
  store float %1040, ptr %1043, align 4
  %1044 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1045 = getelementptr inbounds %struct.complex, ptr %1044, i32 0, i32 0
  %1046 = load float, ptr %1045, align 8, !tbaa !13
  %1047 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 0
  %1048 = load float, ptr %1047, align 4, !tbaa !13
  %1049 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1050 = getelementptr inbounds %struct.complex, ptr %1049, i32 0, i32 1
  %1051 = load float, ptr %1050, align 4, !tbaa !15
  %1052 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 1
  %1053 = load float, ptr %1052, align 4, !tbaa !15
  %1054 = fmul float %1051, %1053
  %1055 = fneg float %1054
  %1056 = call float @llvm.fmuladd.f32(float %1046, float %1048, float %1055)
  %1057 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 0
  store float %1056, ptr %1057, align 4, !tbaa !13
  %1058 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1059 = getelementptr inbounds %struct.complex, ptr %1058, i32 0, i32 0
  %1060 = load float, ptr %1059, align 8, !tbaa !13
  %1061 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 1
  %1062 = load float, ptr %1061, align 4, !tbaa !15
  %1063 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1064 = getelementptr inbounds %struct.complex, ptr %1063, i32 0, i32 1
  %1065 = load float, ptr %1064, align 4, !tbaa !15
  %1066 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 0
  %1067 = load float, ptr %1066, align 4, !tbaa !13
  %1068 = fmul float %1065, %1067
  %1069 = call float @llvm.fmuladd.f32(float %1060, float %1062, float %1068)
  %1070 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 1
  store float %1069, ptr %1070, align 4, !tbaa !15
  %1071 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  %1072 = load float, ptr %1071, align 4, !tbaa !13
  %1073 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 0
  %1074 = load float, ptr %1073, align 4, !tbaa !13
  %1075 = fadd float %1072, %1074
  %1076 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %1075, ptr %1076, align 4, !tbaa !13
  %1077 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  %1078 = load float, ptr %1077, align 4, !tbaa !15
  %1079 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 1
  %1080 = load float, ptr %1079, align 4, !tbaa !15
  %1081 = fadd float %1078, %1080
  %1082 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %1081, ptr %1082, align 4, !tbaa !15
  %1083 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %1084 = load float, ptr %1083, align 4, !tbaa !13
  %1085 = load ptr, ptr %35, align 8, !tbaa !5
  %1086 = load i32, ptr %55, 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 0
  store float %1084, ptr %1089, align 4, !tbaa !13
  %1090 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %1091 = load float, ptr %1090, align 4, !tbaa !15
  %1092 = load ptr, ptr %35, align 8, !tbaa !5
  %1093 = load i32, ptr %55, align 4, !tbaa !9
  %1094 = sext i32 %1093 to i64
  %1095 = getelementptr inbounds %struct.complex, ptr %1092, i64 %1094
  %1096 = getelementptr inbounds %struct.complex, ptr %1095, i32 0, i32 1
  store float %1091, ptr %1096, align 4, !tbaa !15
  br label %1097

1097:                                             ; preds = %952
  %1098 = load i32, ptr %68, align 4, !tbaa !9
  %1099 = add nsw i32 %1098, 1
  store i32 %1099, ptr %68, align 4, !tbaa !9
  br label %948, !llvm.loop !21

1100:                                             ; preds = %948
  %1101 = load ptr, ptr %23, align 8, !tbaa !5
  %1102 = load i32, ptr %1101, align 4, !tbaa !9
  store i32 %1102, ptr %54, align 4, !tbaa !9
  %1103 = load i32, ptr %66, align 4, !tbaa !9
  %1104 = add nsw i32 %1103, 1
  store i32 %1104, ptr %68, align 4, !tbaa !9
  br label %1105

1105:                                             ; preds = %1254, %1100
  %1106 = load i32, ptr %68, align 4, !tbaa !9
  %1107 = load i32, ptr %54, align 4, !tbaa !9
  %1108 = icmp sle i32 %1106, %1107
  br i1 %1108, label %1109, label %1257

1109:                                             ; preds = %1105
  %1110 = load i32, ptr %68, align 4, !tbaa !9
  %1111 = load i32, ptr %67, align 4, !tbaa !9
  %1112 = load i32, ptr %45, align 4, !tbaa !9
  %1113 = mul nsw i32 %1111, %1112
  %1114 = add nsw i32 %1110, %1113
  store i32 %1114, ptr %55, align 4, !tbaa !9
  %1115 = load i32, ptr %68, align 4, !tbaa !9
  %1116 = load i32, ptr %67, align 4, !tbaa !9
  %1117 = load i32, ptr %45, align 4, !tbaa !9
  %1118 = mul nsw i32 %1116, %1117
  %1119 = add nsw i32 %1115, %1118
  store i32 %1119, ptr %56, align 4, !tbaa !9
  %1120 = load ptr, ptr %25, align 8, !tbaa !5
  %1121 = load i32, ptr %66, align 4, !tbaa !9
  %1122 = load i32, ptr %68, align 4, !tbaa !9
  %1123 = load i32, ptr %41, align 4, !tbaa !9
  %1124 = mul nsw i32 %1122, %1123
  %1125 = add nsw i32 %1121, %1124
  %1126 = sext i32 %1125 to i64
  %1127 = getelementptr inbounds %struct.complex, ptr %1120, i64 %1126
  %1128 = call <2 x float> @Cf(ptr noundef %1127)
  store <2 x float> %1128, ptr %81, align 4
  %1129 = getelementptr inbounds { float, float }, ptr %81, i32 0, i32 0
  %1130 = load float, ptr %1129, align 4
  %1131 = getelementptr inbounds { float, float }, ptr %81, i32 0, i32 1
  %1132 = load float, ptr %1131, align 4
  %1133 = fneg float %1132
  %1134 = call ptr @_pCf(ptr noundef %60)
  %1135 = getelementptr inbounds { float, float }, ptr %1134, i32 0, i32 0
  %1136 = getelementptr inbounds { float, float }, ptr %1134, i32 0, i32 1
  store float %1130, ptr %1135, align 4
  store float %1133, ptr %1136, align 4
  %1137 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 0
  %1138 = load float, ptr %1137, align 4, !tbaa !13
  %1139 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %1140 = getelementptr inbounds %struct.complex, ptr %1139, i32 0, i32 0
  %1141 = load float, ptr %1140, align 16, !tbaa !13
  %1142 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 1
  %1143 = load float, ptr %1142, align 4, !tbaa !15
  %1144 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %1145 = getelementptr inbounds %struct.complex, ptr %1144, i32 0, i32 1
  %1146 = load float, ptr %1145, align 4, !tbaa !15
  %1147 = fmul float %1143, %1146
  %1148 = fneg float %1147
  %1149 = call float @llvm.fmuladd.f32(float %1138, float %1141, float %1148)
  %1150 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 0
  store float %1149, ptr %1150, align 4, !tbaa !13
  %1151 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 0
  %1152 = load float, ptr %1151, align 4, !tbaa !13
  %1153 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %1154 = getelementptr inbounds %struct.complex, ptr %1153, i32 0, i32 1
  %1155 = load float, ptr %1154, align 4, !tbaa !15
  %1156 = getelementptr inbounds %struct.complex, ptr %60, i32 0, i32 1
  %1157 = load float, ptr %1156, align 4, !tbaa !15
  %1158 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 0
  %1159 = getelementptr inbounds %struct.complex, ptr %1158, i32 0, i32 0
  %1160 = load float, ptr %1159, align 16, !tbaa !13
  %1161 = fmul float %1157, %1160
  %1162 = call float @llvm.fmuladd.f32(float %1152, float %1155, float %1161)
  %1163 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 1
  store float %1162, ptr %1163, align 4, !tbaa !15
  %1164 = load ptr, ptr %29, align 8, !tbaa !5
  %1165 = load i32, ptr %56, align 4, !tbaa !9
  %1166 = sext i32 %1165 to i64
  %1167 = getelementptr inbounds %struct.complex, ptr %1164, i64 %1166
  %1168 = getelementptr inbounds %struct.complex, ptr %1167, i32 0, i32 0
  %1169 = load float, ptr %1168, align 4, !tbaa !13
  %1170 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 0
  %1171 = load float, ptr %1170, align 4, !tbaa !13
  %1172 = fsub float %1169, %1171
  %1173 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  store float %1172, ptr %1173, align 4, !tbaa !13
  %1174 = load ptr, ptr %29, align 8, !tbaa !5
  %1175 = load i32, ptr %56, align 4, !tbaa !9
  %1176 = sext i32 %1175 to i64
  %1177 = getelementptr inbounds %struct.complex, ptr %1174, i64 %1176
  %1178 = getelementptr inbounds %struct.complex, ptr %1177, i32 0, i32 1
  %1179 = load float, ptr %1178, align 4, !tbaa !15
  %1180 = getelementptr inbounds %struct.complex, ptr %59, i32 0, i32 1
  %1181 = load float, ptr %1180, align 4, !tbaa !15
  %1182 = fsub float %1179, %1181
  %1183 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  store float %1182, ptr %1183, align 4, !tbaa !15
  %1184 = load ptr, ptr %31, align 8, !tbaa !5
  %1185 = load i32, ptr %66, align 4, !tbaa !9
  %1186 = load i32, ptr %68, align 4, !tbaa !9
  %1187 = load i32, ptr %47, align 4, !tbaa !9
  %1188 = mul nsw i32 %1186, %1187
  %1189 = add nsw i32 %1185, %1188
  %1190 = sext i32 %1189 to i64
  %1191 = getelementptr inbounds %struct.complex, ptr %1184, i64 %1190
  %1192 = call <2 x float> @Cf(ptr noundef %1191)
  store <2 x float> %1192, ptr %82, align 4
  %1193 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 0
  %1194 = load float, ptr %1193, align 4
  %1195 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 1
  %1196 = load float, ptr %1195, align 4
  %1197 = fneg float %1196
  %1198 = call ptr @_pCf(ptr noundef %62)
  %1199 = getelementptr inbounds { float, float }, ptr %1198, i32 0, i32 0
  %1200 = getelementptr inbounds { float, float }, ptr %1198, i32 0, i32 1
  store float %1194, ptr %1199, align 4
  store float %1197, ptr %1200, align 4
  %1201 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 0
  %1202 = load float, ptr %1201, align 4, !tbaa !13
  %1203 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1204 = getelementptr inbounds %struct.complex, ptr %1203, i32 0, i32 0
  %1205 = load float, ptr %1204, align 8, !tbaa !13
  %1206 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 1
  %1207 = load float, ptr %1206, align 4, !tbaa !15
  %1208 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1209 = getelementptr inbounds %struct.complex, ptr %1208, i32 0, i32 1
  %1210 = load float, ptr %1209, align 4, !tbaa !15
  %1211 = fmul float %1207, %1210
  %1212 = fneg float %1211
  %1213 = call float @llvm.fmuladd.f32(float %1202, float %1205, float %1212)
  %1214 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 0
  store float %1213, ptr %1214, align 4, !tbaa !13
  %1215 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 0
  %1216 = load float, ptr %1215, align 4, !tbaa !13
  %1217 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1218 = getelementptr inbounds %struct.complex, ptr %1217, i32 0, i32 1
  %1219 = load float, ptr %1218, align 4, !tbaa !15
  %1220 = getelementptr inbounds %struct.complex, ptr %62, i32 0, i32 1
  %1221 = load float, ptr %1220, align 4, !tbaa !15
  %1222 = getelementptr inbounds [2 x %struct.complex], ptr %73, i64 0, i64 1
  %1223 = getelementptr inbounds %struct.complex, ptr %1222, i32 0, i32 0
  %1224 = load float, ptr %1223, align 8, !tbaa !13
  %1225 = fmul float %1221, %1224
  %1226 = call float @llvm.fmuladd.f32(float %1216, float %1219, float %1225)
  %1227 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 1
  store float %1226, ptr %1227, align 4, !tbaa !15
  %1228 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 0
  %1229 = load float, ptr %1228, align 4, !tbaa !13
  %1230 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 0
  %1231 = load float, ptr %1230, align 4, !tbaa !13
  %1232 = fsub float %1229, %1231
  %1233 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %1232, ptr %1233, align 4, !tbaa !13
  %1234 = getelementptr inbounds %struct.complex, ptr %58, i32 0, i32 1
  %1235 = load float, ptr %1234, align 4, !tbaa !15
  %1236 = getelementptr inbounds %struct.complex, ptr %61, i32 0, i32 1
  %1237 = load float, ptr %1236, align 4, !tbaa !15
  %1238 = fsub float %1235, %1237
  %1239 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %1238, ptr %1239, align 4, !tbaa !15
  %1240 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %1241 = load float, ptr %1240, align 4, !tbaa !13
  %1242 = load ptr, ptr %29, align 8, !tbaa !5
  %1243 = load i32, ptr %55, align 4, !tbaa !9
  %1244 = sext i32 %1243 to i64
  %1245 = getelementptr inbounds %struct.complex, ptr %1242, i64 %1244
  %1246 = getelementptr inbounds %struct.complex, ptr %1245, i32 0, i32 0
  store float %1241, ptr %1246, align 4, !tbaa !13
  %1247 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %1248 = load float, ptr %1247, align 4, !tbaa !15
  %1249 = load ptr, ptr %29, align 8, !tbaa !5
  %1250 = load i32, ptr %55, align 4, !tbaa !9
  %1251 = sext i32 %1250 to i64
  %1252 = getelementptr inbounds %struct.complex, ptr %1249, i64 %1251
  %1253 = getelementptr inbounds %struct.complex, ptr %1252, i32 0, i32 1
  store float %1248, ptr %1253, align 4, !tbaa !15
  br label %1254

1254:                                             ; preds = %1109
  %1255 = load i32, ptr %68, align 4, !tbaa !9
  %1256 = add nsw i32 %1255, 1
  store i32 %1256, ptr %68, align 4, !tbaa !9
  br label %1105, !llvm.loop !22

1257:                                             ; preds = %1105
  br label %1258

1258:                                             ; preds = %1257
  %1259 = load i32, ptr %67, align 4, !tbaa !9
  %1260 = add nsw i32 %1259, -1
  store i32 %1260, ptr %67, align 4, !tbaa !9
  br label %688, !llvm.loop !23

1261:                                             ; preds = %688
  br label %1262

1262:                                             ; preds = %1261
  %1263 = load i32, ptr %66, align 4, !tbaa !9
  %1264 = add nsw i32 %1263, 1
  store i32 %1264, ptr %66, align 4, !tbaa !9
  br label %681, !llvm.loop !24

1265:                                             ; preds = %681
  br label %1266

1266:                                             ; preds = %1265, %676
  store i32 1, ptr %74, align 4
  br label %1267

1267:                                             ; preds = %1266, %287
  call void @llvm.lifetime.end.p0(i64 16, ptr %73) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %69) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #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 @cgetc2_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

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

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

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

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

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

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

; 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, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!14, !12, i64 0}
!14 = !{!"", !12, i64 0, !12, i64 4}
!15 = !{!14, !12, i64 4}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}
!18 = distinct !{!18, !17}
!19 = distinct !{!19, !17}
!20 = distinct !{!20, !17}
!21 = distinct !{!21, !17}
!22 = distinct !{!22, !17}
!23 = distinct !{!23, !17}
!24 = distinct !{!24, !17}


; 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__2 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4

; Function Attrs: nounwind uwtable
define dso_local void @ctgsy2_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr nocapture noundef readonly %3, ptr noundef %4, ptr nocapture noundef readonly %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9, ptr noundef %10, ptr nocapture noundef readonly %11, ptr noundef %12, ptr noundef %13, ptr noundef %14, ptr noundef %15, ptr nocapture noundef %16, ptr noundef %17, ptr noundef %18, ptr nocapture noundef %19) local_unnamed_addr #0 {
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca %struct.complex, align 8
  %24 = alloca %struct.complex, align 8
  %25 = alloca %struct.complex, align 8
  %26 = alloca %struct.complex, align 8
  %27 = alloca i32, align 4
  %28 = alloca [2 x i32], align 4
  %29 = alloca [2 x i32], align 4
  %30 = alloca %struct.complex, align 8
  %31 = alloca [4 x %struct.complex], align 16
  %32 = alloca float, align 4
  %33 = alloca [2 x %struct.complex], align 16
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %21) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %22) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %23) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %24) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %25) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %26) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %27) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %28) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %29) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %30) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %31) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %32) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %33) #6
  %34 = load i32, ptr %5, align 4, !tbaa !5
  %narrow = xor i32 %34, -1
  %35 = sext i32 %narrow to i64
  %36 = getelementptr inbounds %struct.complex, ptr %4, i64 %35
  %37 = load i32, ptr %7, align 4, !tbaa !5
  %narrow305 = xor i32 %37, -1
  %38 = sext i32 %narrow305 to i64
  %39 = getelementptr inbounds %struct.complex, ptr %6, i64 %38
  %40 = load i32, ptr %9, align 4, !tbaa !5
  %narrow306 = xor i32 %40, -1
  %41 = sext i32 %narrow306 to i64
  %42 = getelementptr inbounds %struct.complex, ptr %8, i64 %41
  %43 = load i32, ptr %11, align 4, !tbaa !5
  %narrow307 = xor i32 %43, -1
  %44 = sext i32 %narrow307 to i64
  %45 = getelementptr inbounds %struct.complex, ptr %10, i64 %44
  %46 = load i32, ptr %13, align 4, !tbaa !5
  %narrow308 = xor i32 %46, -1
  %47 = sext i32 %narrow308 to i64
  %48 = getelementptr inbounds %struct.complex, ptr %12, i64 %47
  %49 = load i32, ptr %15, align 4, !tbaa !5
  %narrow309 = xor i32 %49, -1
  %50 = sext i32 %narrow309 to i64
  %51 = getelementptr inbounds %struct.complex, ptr %14, i64 %50
  store i32 0, ptr %19, align 4, !tbaa !5
  store i32 0, ptr %27, align 4, !tbaa !5
  %52 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #6
  %.not = icmp eq i32 %52, 0
  br i1 %.not, label %53, label %.critedge

53:                                               ; preds = %20
  %54 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #6
  %.not310 = icmp eq i32 %54, 0
  br i1 %.not310, label %.thread327.sink.split, label %56

.critedge:                                        ; preds = %20
  %55 = load i32, ptr %1, align 4, !tbaa !5
  %or.cond = icmp ugt i32 %55, 2
  br i1 %or.cond, label %.thread327.sink.split, label %56

56:                                               ; preds = %53, %.critedge
  %.pr = load i32, ptr %19, align 4, !tbaa !5
  %57 = icmp eq i32 %.pr, 0
  br i1 %57, label %58, label %.thread327

58:                                               ; preds = %56
  %59 = load i32, ptr %2, align 4, !tbaa !5
  %60 = icmp slt i32 %59, 1
  br i1 %60, label %.thread327.sink.split, label %61

61:                                               ; preds = %58
  %62 = load i32, ptr %3, align 4, !tbaa !5
  %63 = icmp slt i32 %62, 1
  br i1 %63, label %.thread327.sink.split, label %64

64:                                               ; preds = %61
  %65 = load i32, ptr %5, align 4, !tbaa !5
  %66 = icmp slt i32 %65, %59
  br i1 %66, label %.thread327.sink.split, label %67

67:                                               ; preds = %64
  %68 = load i32, ptr %7, align 4, !tbaa !5
  %69 = icmp slt i32 %68, %62
  br i1 %69, label %.thread327.sink.split, label %70

70:                                               ; preds = %67
  %71 = load i32, ptr %9, align 4, !tbaa !5
  %72 = icmp slt i32 %71, %59
  br i1 %72, label %.thread327.sink.split, label %73

73:                                               ; preds = %70
  %74 = load i32, ptr %11, align 4, !tbaa !5
  %75 = icmp slt i32 %74, %59
  br i1 %75, label %.thread327.sink.split, label %76

76:                                               ; preds = %73
  %77 = load i32, ptr %13, align 4, !tbaa !5
  %78 = icmp slt i32 %77, %62
  br i1 %78, label %.thread327.sink.split, label %79

79:                                               ; preds = %76
  %80 = load i32, ptr %15, align 4, !tbaa !5
  %81 = icmp slt i32 %80, %59
  br i1 %81, label %.thread327.sink.split, label %.thread

.thread327.sink.split:                            ; preds = %79, %76, %73, %70, %67, %64, %61, %58, %.critedge, %53
  %.sink = phi i32 [ -1, %53 ], [ -2, %.critedge ], [ -3, %58 ], [ -4, %61 ], [ -6, %64 ], [ -8, %67 ], [ -10, %70 ], [ -12, %73 ], [ -14, %76 ], [ -16, %79 ]
  store i32 %.sink, ptr %19, align 4, !tbaa !5
  br label %.thread327

.thread327:                                       ; preds = %.thread327.sink.split, %56
  %82 = phi i32 [ %.pr, %56 ], [ %.sink, %.thread327.sink.split ]
  %83 = sub nsw i32 0, %82
  store i32 %83, ptr %21, align 4, !tbaa !5
  %84 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %21, i32 noundef 6) #6
  br label %.loopexit331

.thread:                                          ; preds = %79
  store float 1.000000e+00, ptr %16, align 4, !tbaa !9
  store float 1.000000e+00, ptr %32, align 4, !tbaa !9
  %85 = getelementptr inbounds i8, ptr %31, i64 8
  br i1 %.not, label %.lr.ph378.split.preheader, label %.lr.ph352.split.preheader

.lr.ph352.split.preheader:                        ; preds = %.thread
  %invariant.gep337 = getelementptr i8, ptr %36, i64 8
  %invariant.gep339 = getelementptr i8, ptr %42, i64 8
  %invariant.gep341 = getelementptr i8, ptr %45, i64 8
  %invariant.gep343 = getelementptr i8, ptr %51, i64 8
  %86 = add i32 %37, 1
  %87 = getelementptr inbounds i8, ptr %23, i64 4
  %88 = getelementptr inbounds i8, ptr %31, i64 16
  %89 = add i32 %46, 1
  %90 = getelementptr inbounds i8, ptr %33, i64 8
  %91 = sext i32 %40 to i64
  %92 = sext i32 %49 to i64
  %93 = sext i32 %34 to i64
  %94 = sext i32 %43 to i64
  %95 = add i32 %34, 1
  %96 = add i32 %43, 1
  %97 = zext nneg i32 %62 to i64
  br label %.lr.ph352.split

.lr.ph352.split:                                  ; preds = %.lr.ph352.split.preheader, %._crit_edge348
  %indvars.iv386 = phi i64 [ 1, %.lr.ph352.split.preheader ], [ %indvars.iv.next387.pre-phi, %._crit_edge348 ]
  %indvars388 = trunc i64 %indvars.iv386 to i32
  %98 = load i32, ptr %2, align 4, !tbaa !5
  %99 = icmp sgt i32 %98, 0
  br i1 %99, label %.lr.ph347, label %.lr.ph352.split.._crit_edge348_crit_edge

.lr.ph352.split.._crit_edge348_crit_edge:         ; preds = %.lr.ph352.split
  %.pre406 = add nuw nsw i64 %indvars.iv386, 1
  br label %._crit_edge348

.lr.ph347:                                        ; preds = %.lr.ph352.split
  %100 = mul i32 %86, %indvars388
  %101 = sext i32 %100 to i64
  %102 = getelementptr inbounds %struct.complex, ptr %39, i64 %101
  %103 = mul i32 %89, %indvars388
  %104 = sext i32 %103 to i64
  %105 = getelementptr inbounds %struct.complex, ptr %48, i64 %104
  %106 = mul nsw i64 %indvars.iv386, %91
  %107 = mul nsw i64 %indvars.iv386, %92
  %gep340 = getelementptr %struct.complex, ptr %invariant.gep339, i64 %106
  %gep344 = getelementptr %struct.complex, ptr %invariant.gep343, i64 %107
  %108 = add nuw nsw i64 %indvars.iv386, 1
  %109 = add nuw nsw i32 %indvars388, 1
  %110 = mul nsw i32 %109, %37
  %111 = sext i32 %110 to i64
  %112 = getelementptr %struct.complex, ptr %39, i64 %indvars.iv386
  %113 = getelementptr %struct.complex, ptr %112, i64 %111
  %114 = mul nsw i64 %108, %91
  %115 = mul nsw i32 %109, %46
  %116 = sext i32 %115 to i64
  %117 = getelementptr %struct.complex, ptr %48, i64 %indvars.iv386
  %118 = getelementptr %struct.complex, ptr %117, i64 %116
  %119 = mul nsw i64 %108, %92
  %120 = zext nneg i32 %98 to i64
  %invariant.gep = getelementptr %struct.complex, ptr %42, i64 %114
  %invariant.gep409 = getelementptr %struct.complex, ptr %51, i64 %119
  %invariant.gep425 = getelementptr %struct.complex, ptr %42, i64 %106
  br label %121

121:                                              ; preds = %.lr.ph347, %180
  %indvars.iv383 = phi i64 [ %120, %.lr.ph347 ], [ %indvars.iv.next384, %180 ]
  %indvars385 = trunc i64 %indvars.iv383 to i32
  %122 = mul nsw i64 %indvars.iv383, %93
  %123 = mul i32 %95, %indvars385
  %124 = sext i32 %123 to i64
  %125 = getelementptr inbounds %struct.complex, ptr %36, i64 %124
  %126 = load <2 x float>, ptr %125, align 4, !tbaa !9
  %127 = mul nsw i64 %indvars.iv383, %94
  %128 = mul i32 %96, %indvars385
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds %struct.complex, ptr %45, i64 %129
  %131 = load <2 x float>, ptr %130, align 4, !tbaa !9
  %132 = shufflevector <2 x float> %126, <2 x float> %131, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  store <4 x float> %132, ptr %31, align 16, !tbaa !9
  %133 = load <2 x float>, ptr %102, align 4, !tbaa !9
  %134 = load <2 x float>, ptr %105, align 4, !tbaa !9
  %135 = shufflevector <2 x float> %133, <2 x float> %134, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %136 = fneg <4 x float> %135
  %137 = shufflevector <4 x float> %136, <4 x float> poison, <2 x i32> <i32 2, i32 3>
  store <2 x float> %137, ptr %23, align 8, !tbaa !9
  store <4 x float> %136, ptr %88, align 16, !tbaa !9
  %gep426 = getelementptr %struct.complex, ptr %invariant.gep425, i64 %indvars.iv383
  %138 = load <2 x float>, ptr %gep426, align 4, !tbaa !9
  %139 = add nsw i64 %indvars.iv383, %107
  %140 = trunc nsw i64 %139 to i32
  store i32 %140, ptr %22, align 4, !tbaa !5
  %141 = getelementptr inbounds %struct.complex, ptr %51, i64 %139
  %142 = load <2 x float>, ptr %141, align 4, !tbaa !9
  %143 = shufflevector <2 x float> %138, <2 x float> %142, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  store <4 x float> %143, ptr %33, align 16, !tbaa !9
  call void @cgetc2_(ptr noundef nonnull @c__2, ptr noundef nonnull %31, ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull %29, ptr noundef nonnull %27) #6
  %144 = load i32, ptr %27, align 4, !tbaa !5
  %145 = icmp sgt i32 %144, 0
  br i1 %145, label %146, label %147

146:                                              ; preds = %121
  store i32 %144, ptr %19, align 4, !tbaa !5
  br label %147

147:                                              ; preds = %146, %121
  %148 = load i32, ptr %1, align 4, !tbaa !5
  %149 = icmp eq i32 %148, 0
  br i1 %149, label %150, label %164

150:                                              ; preds = %147
  call void @cgesc2_(ptr noundef nonnull @c__2, ptr noundef nonnull %31, ptr noundef nonnull @c__2, ptr noundef nonnull %33, ptr noundef nonnull %28, ptr noundef nonnull %29, ptr noundef nonnull %32) #6
  %151 = load float, ptr %32, align 4, !tbaa !9
  %152 = fcmp une float %151, 1.000000e+00
  br i1 %152, label %153, label %165

153:                                              ; preds = %150
  %154 = load i32, ptr %3, align 4, !tbaa !5
  store i32 %154, ptr %22, align 4, !tbaa !5
  %.not317335 = icmp slt i32 %154, 1
  br i1 %.not317335, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %153, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ 1, %153 ]
  %155 = load float, ptr %32, align 4, !tbaa !9
  store float %155, ptr %23, align 8, !tbaa !11
  store float 0.000000e+00, ptr %87, align 4, !tbaa !13
  %156 = mul nsw i64 %indvars.iv, %91
  %gep = getelementptr %struct.complex, ptr %invariant.gep339, i64 %156
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %23, ptr noundef %gep, ptr noundef nonnull @c__1) #6
  %157 = load float, ptr %32, align 4, !tbaa !9
  store float %157, ptr %23, align 8, !tbaa !11
  store float 0.000000e+00, ptr %87, align 4, !tbaa !13
  %158 = mul nsw i64 %indvars.iv, %92
  %gep334 = getelementptr %struct.complex, ptr %invariant.gep343, i64 %158
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %23, ptr noundef %gep334, ptr noundef nonnull @c__1) #6
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %159 = load i32, ptr %22, align 4, !tbaa !5
  %160 = sext i32 %159 to i64
  %.not317.not = icmp slt i64 %indvars.iv, %160
  br i1 %.not317.not, label %.lr.ph, label %._crit_edge.loopexit, !llvm.loop !14

._crit_edge.loopexit:                             ; preds = %.lr.ph
  %.pre = load float, ptr %32, align 4, !tbaa !9
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %153
  %161 = phi float [ %.pre, %._crit_edge.loopexit ], [ %151, %153 ]
  %162 = load float, ptr %16, align 4, !tbaa !9
  %163 = fmul float %161, %162
  store float %163, ptr %16, align 4, !tbaa !9
  br label %165

164:                                              ; preds = %147
  call void @clatdf_(ptr noundef nonnull %1, ptr noundef nonnull @c__2, ptr noundef nonnull %31, ptr noundef nonnull @c__2, ptr noundef nonnull %33, ptr noundef %17, ptr noundef %18, ptr noundef nonnull %28, ptr noundef nonnull %29) #6
  br label %165

165:                                              ; preds = %150, %._crit_edge, %164
  %166 = load <2 x float>, ptr %33, align 16, !tbaa !9
  store <2 x float> %166, ptr %gep426, align 4, !tbaa !9
  store i32 %140, ptr %22, align 4, !tbaa !5
  %167 = load <2 x float>, ptr %90, align 8, !tbaa !9
  store <2 x float> %167, ptr %141, align 4, !tbaa !9
  %.not318 = icmp eq i64 %indvars.iv383, 1
  br i1 %.not318, label %172, label %168

168:                                              ; preds = %165
  %169 = fneg <2 x float> %166
  store <2 x float> %169, ptr %23, align 8, !tbaa !9
  store <2 x float> %169, ptr %30, align 8, !tbaa !9
  %170 = trunc i64 %indvars.iv383 to i32
  %171 = add i32 %170, -1
  store i32 %171, ptr %22, align 4, !tbaa !5
  %gep338 = getelementptr %struct.complex, ptr %invariant.gep337, i64 %122
  call void @caxpy_(ptr noundef nonnull %22, ptr noundef nonnull %30, ptr noundef %gep338, ptr noundef nonnull @c__1, ptr noundef %gep340, ptr noundef nonnull @c__1) #6
  store i32 %171, ptr %22, align 4, !tbaa !5
  %gep342 = getelementptr %struct.complex, ptr %invariant.gep341, i64 %127
  call void @caxpy_(ptr noundef nonnull %22, ptr noundef nonnull %30, ptr noundef %gep342, ptr noundef nonnull @c__1, ptr noundef %gep344, ptr noundef nonnull @c__1) #6
  br label %172

172:                                              ; preds = %168, %165
  %173 = load i32, ptr %3, align 4, !tbaa !5
  %174 = sext i32 %173 to i64
  %175 = icmp slt i64 %indvars.iv386, %174
  br i1 %175, label %176, label %180

176:                                              ; preds = %172
  %177 = sub nsw i32 %173, %indvars388
  store i32 %177, ptr %22, align 4, !tbaa !5
  %gep408 = getelementptr %struct.complex, ptr %invariant.gep, i64 %indvars.iv383
  call void @caxpy_(ptr noundef nonnull %22, ptr noundef nonnull %90, ptr noundef %113, ptr noundef nonnull %7, ptr noundef %gep408, ptr noundef nonnull %9) #6
  %178 = load i32, ptr %3, align 4, !tbaa !5
  %179 = sub nsw i32 %178, %indvars388
  store i32 %179, ptr %22, align 4, !tbaa !5
  %gep410 = getelementptr %struct.complex, ptr %invariant.gep409, i64 %indvars.iv383
  call void @caxpy_(ptr noundef nonnull %22, ptr noundef nonnull %90, ptr noundef %118, ptr noundef nonnull %13, ptr noundef %gep410, ptr noundef nonnull %15) #6
  br label %180

180:                                              ; preds = %172, %176
  %indvars.iv.next384 = add nsw i64 %indvars.iv383, -1
  %181 = icmp sgt i64 %indvars.iv383, 1
  br i1 %181, label %121, label %._crit_edge348, !llvm.loop !16

._crit_edge348:                                   ; preds = %180, %.lr.ph352.split.._crit_edge348_crit_edge
  %indvars.iv.next387.pre-phi = phi i64 [ %.pre406, %.lr.ph352.split.._crit_edge348_crit_edge ], [ %108, %180 ]
  %.not316.not = icmp slt i64 %indvars.iv386, %97
  br i1 %.not316.not, label %.lr.ph352.split, label %.loopexit331, !llvm.loop !17

.lr.ph378.split.preheader:                        ; preds = %.thread
  store i32 %59, ptr %21, align 4, !tbaa !5
  %182 = add i32 %34, 1
  %183 = getelementptr inbounds i8, ptr %23, i64 4
  %184 = add i32 %43, 1
  %185 = getelementptr inbounds i8, ptr %31, i64 16
  %186 = getelementptr inbounds i8, ptr %31, i64 24
  %187 = getelementptr inbounds i8, ptr %33, i64 4
  %188 = getelementptr inbounds i8, ptr %33, i64 8
  %189 = getelementptr inbounds i8, ptr %33, i64 12
  %invariant.gep353 = getelementptr i8, ptr %42, i64 8
  %invariant.gep355 = getelementptr i8, ptr %51, i64 8
  %190 = getelementptr inbounds i8, ptr %25, i64 4
  %191 = getelementptr inbounds i8, ptr %26, i64 4
  %192 = sext i32 %40 to i64
  %193 = sext i32 %49 to i64
  %194 = sext i32 %34 to i64
  %195 = sext i32 %43 to i64
  %196 = sext i32 %37 to i64
  %197 = sext i32 %46 to i64
  %198 = zext nneg i32 %59 to i64
  br label %.lr.ph378.split

.lr.ph378.split:                                  ; preds = %.lr.ph378.split.preheader, %._crit_edge374
  %indvars.iv395 = phi i64 [ 1, %.lr.ph378.split.preheader ], [ %indvars.iv.next396, %._crit_edge374 ]
  %199 = load i32, ptr %3, align 4, !tbaa !5
  %200 = icmp sgt i32 %199, 0
  br i1 %200, label %.lr.ph373, label %._crit_edge374

.lr.ph373:                                        ; preds = %.lr.ph378.split
  %201 = trunc nuw nsw i64 %indvars.iv395 to i32
  %202 = mul i32 %182, %201
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds %struct.complex, ptr %36, i64 %203
  %205 = mul i32 %184, %201
  %206 = sext i32 %205 to i64
  %207 = getelementptr inbounds %struct.complex, ptr %45, i64 %206
  %208 = zext nneg i32 %199 to i64
  %invariant.gep413 = getelementptr %struct.complex, ptr %51, i64 %indvars.iv395
  %invariant.gep417 = getelementptr %struct.complex, ptr %36, i64 %indvars.iv395
  %invariant.gep421 = getelementptr %struct.complex, ptr %45, i64 %indvars.iv395
  %invariant.gep427 = getelementptr %struct.complex, ptr %42, i64 %indvars.iv395
  br label %210

.loopexit:                                        ; preds = %.lr.ph370, %._crit_edge366
  %209 = icmp sgt i64 %indvars.iv400, 1
  br i1 %209, label %210, label %._crit_edge374, !llvm.loop !19

210:                                              ; preds = %.lr.ph373, %.loopexit
  %indvars.iv400 = phi i64 [ %208, %.lr.ph373 ], [ %indvars.iv.next401, %.loopexit ]
  %indvars402 = trunc i64 %indvars.iv400 to i32
  %211 = call <2 x float> @Cf(ptr noundef %204)
  %.sroa.07.0.vec.extract = extractelement <2 x float> %211, i64 0
  %.sroa.07.4.vec.extract = extractelement <2 x float> %211, i64 1
  %212 = fneg float %.sroa.07.4.vec.extract
  %213 = call ptr @_pCf(ptr noundef nonnull %23)
  %214 = getelementptr inbounds i8, ptr %213, i64 4
  store float %.sroa.07.0.vec.extract, ptr %213, align 4
  store float %212, ptr %214, align 4
  %215 = load <2 x float>, ptr %23, align 8, !tbaa !9
  store <2 x float> %215, ptr %31, align 16, !tbaa !9
  %216 = mul nsw i64 %indvars.iv400, %196
  %217 = mul nsw i32 %37, %indvars402
  %218 = sext i32 %217 to i64
  %219 = getelementptr %struct.complex, ptr %39, i64 %indvars.iv400
  %220 = getelementptr %struct.complex, ptr %219, i64 %218
  %221 = call <2 x float> @Cf(ptr noundef %220)
  %.sroa.06.0.vec.extract = extractelement <2 x float> %221, i64 0
  %.sroa.06.4.vec.extract = extractelement <2 x float> %221, i64 1
  %222 = fneg float %.sroa.06.4.vec.extract
  %223 = call ptr @_pCf(ptr noundef nonnull %24)
  %224 = getelementptr inbounds i8, ptr %223, i64 4
  store float %.sroa.06.0.vec.extract, ptr %223, align 4
  store float %222, ptr %224, align 4
  %225 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %226 = fneg <2 x float> %225
  store <2 x float> %226, ptr %23, align 8, !tbaa !9
  store <2 x float> %226, ptr %85, align 8, !tbaa !9
  %227 = call <2 x float> @Cf(ptr noundef %207)
  %.sroa.05.0.vec.extract = extractelement <2 x float> %227, i64 0
  %.sroa.05.4.vec.extract = extractelement <2 x float> %227, i64 1
  %228 = fneg float %.sroa.05.4.vec.extract
  %229 = call ptr @_pCf(ptr noundef nonnull %23)
  %230 = getelementptr inbounds i8, ptr %229, i64 4
  store float %.sroa.05.0.vec.extract, ptr %229, align 4
  store float %228, ptr %230, align 4
  %231 = load <2 x float>, ptr %23, align 8, !tbaa !9
  store <2 x float> %231, ptr %185, align 16, !tbaa !9
  %232 = mul nsw i64 %indvars.iv400, %197
  %233 = mul nsw i32 %46, %indvars402
  %234 = sext i32 %233 to i64
  %235 = getelementptr %struct.complex, ptr %48, i64 %indvars.iv400
  %236 = getelementptr %struct.complex, ptr %235, i64 %234
  %237 = call <2 x float> @Cf(ptr noundef %236)
  %.sroa.04.0.vec.extract = extractelement <2 x float> %237, i64 0
  %.sroa.04.4.vec.extract = extractelement <2 x float> %237, i64 1
  %238 = fneg float %.sroa.04.4.vec.extract
  %239 = call ptr @_pCf(ptr noundef nonnull %24)
  %240 = getelementptr inbounds i8, ptr %239, i64 4
  store float %.sroa.04.0.vec.extract, ptr %239, align 4
  store float %238, ptr %240, align 4
  %241 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %242 = fneg <2 x float> %241
  store <2 x float> %242, ptr %23, align 8, !tbaa !9
  store <2 x float> %242, ptr %186, align 8, !tbaa !9
  %243 = mul nsw i64 %indvars.iv400, %192
  %gep428 = getelementptr %struct.complex, ptr %invariant.gep427, i64 %243
  %244 = load <2 x float>, ptr %gep428, align 4, !tbaa !9
  %245 = mul nsw i64 %indvars.iv400, %193
  %246 = add nsw i64 %245, %indvars.iv395
  %247 = trunc nsw i64 %246 to i32
  %248 = getelementptr inbounds %struct.complex, ptr %51, i64 %246
  %249 = load <2 x float>, ptr %248, align 4, !tbaa !9
  %250 = shufflevector <2 x float> %244, <2 x float> %249, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  store <4 x float> %250, ptr %33, align 16, !tbaa !9
  call void @cgetc2_(ptr noundef nonnull @c__2, ptr noundef nonnull %31, ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull %29, ptr noundef nonnull %27) #6
  %251 = load i32, ptr %27, align 4, !tbaa !5
  %252 = icmp sgt i32 %251, 0
  br i1 %252, label %253, label %254

253:                                              ; preds = %210
  store i32 %251, ptr %19, align 4, !tbaa !5
  br label %254

254:                                              ; preds = %253, %210
  call void @cgesc2_(ptr noundef nonnull @c__2, ptr noundef nonnull %31, ptr noundef nonnull @c__2, ptr noundef nonnull %33, ptr noundef nonnull %28, ptr noundef nonnull %29, ptr noundef nonnull %32) #6
  %255 = load float, ptr %32, align 4, !tbaa !9
  %256 = fcmp une float %255, 1.000000e+00
  br i1 %256, label %257, label %267

257:                                              ; preds = %254
  %258 = load i32, ptr %3, align 4, !tbaa !5
  %.not313357 = icmp slt i32 %258, 1
  br i1 %.not313357, label %._crit_edge361, label %.lr.ph360.preheader

.lr.ph360.preheader:                              ; preds = %257
  %259 = zext nneg i32 %258 to i64
  br label %.lr.ph360

.lr.ph360:                                        ; preds = %.lr.ph360.preheader, %.lr.ph360
  %indvars.iv389 = phi i64 [ 1, %.lr.ph360.preheader ], [ %indvars.iv.next390, %.lr.ph360 ]
  %260 = load float, ptr %32, align 4, !tbaa !9
  store float %260, ptr %23, align 8, !tbaa !11
  store float 0.000000e+00, ptr %183, align 4, !tbaa !13
  %261 = mul nsw i64 %indvars.iv389, %192
  %gep354 = getelementptr %struct.complex, ptr %invariant.gep353, i64 %261
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %23, ptr noundef %gep354, ptr noundef nonnull @c__1) #6
  %262 = load float, ptr %32, align 4, !tbaa !9
  store float %262, ptr %23, align 8, !tbaa !11
  store float 0.000000e+00, ptr %183, align 4, !tbaa !13
  %263 = mul nsw i64 %indvars.iv389, %193
  %gep356 = getelementptr %struct.complex, ptr %invariant.gep355, i64 %263
  call void @cscal_(ptr noundef nonnull %2, ptr noundef nonnull %23, ptr noundef %gep356, ptr noundef nonnull @c__1) #6
  %indvars.iv.next390 = add nuw nsw i64 %indvars.iv389, 1
  %.not313.not = icmp ult i64 %indvars.iv389, %259
  br i1 %.not313.not, label %.lr.ph360, label %._crit_edge361.loopexit, !llvm.loop !20

._crit_edge361.loopexit:                          ; preds = %.lr.ph360
  %.pre405 = load float, ptr %32, align 4, !tbaa !9
  br label %._crit_edge361

._crit_edge361:                                   ; preds = %._crit_edge361.loopexit, %257
  %264 = phi float [ %.pre405, %._crit_edge361.loopexit ], [ %255, %257 ]
  %265 = load float, ptr %16, align 4, !tbaa !9
  %266 = fmul float %264, %265
  store float %266, ptr %16, align 4, !tbaa !9
  br label %267

267:                                              ; preds = %._crit_edge361, %254
  %268 = load <2 x float>, ptr %33, align 16, !tbaa !9
  store <2 x float> %268, ptr %gep428, align 4, !tbaa !9
  store i32 %247, ptr %22, align 4, !tbaa !5
  %269 = load <2 x float>, ptr %188, align 8, !tbaa !9
  store <2 x float> %269, ptr %248, align 4, !tbaa !9
  %indvars.iv.next401 = add nsw i64 %indvars.iv400, -1
  %.not314362 = icmp slt i64 %indvars.iv400, 2
  br i1 %.not314362, label %._crit_edge366, label %.lr.ph365.preheader

.lr.ph365.preheader:                              ; preds = %267
  %invariant.gep411 = getelementptr %struct.complex, ptr %39, i64 %216
  %invariant.gep415 = getelementptr %struct.complex, ptr %48, i64 %232
  %sext = shl i64 %indvars.iv.next401, 32
  %270 = ashr exact i64 %sext, 32
  br label %.lr.ph365

.lr.ph365:                                        ; preds = %.lr.ph365.preheader, %.lr.ph365
  %indvars.iv392 = phi i64 [ 1, %.lr.ph365.preheader ], [ %indvars.iv.next393, %.lr.ph365 ]
  %271 = mul nsw i64 %indvars.iv392, %193
  %gep412 = getelementptr %struct.complex, ptr %invariant.gep411, i64 %indvars.iv392
  %272 = call <2 x float> @Cf(ptr noundef %gep412)
  %.sroa.03.0.vec.extract = extractelement <2 x float> %272, i64 0
  %.sroa.03.4.vec.extract = extractelement <2 x float> %272, i64 1
  %273 = fneg float %.sroa.03.4.vec.extract
  %274 = call ptr @_pCf(ptr noundef nonnull %25)
  %275 = getelementptr inbounds i8, ptr %274, i64 4
  store float %.sroa.03.0.vec.extract, ptr %274, align 4
  store float %273, ptr %275, align 4
  %276 = load <4 x float>, ptr %33, align 16
  %277 = load float, ptr %187, align 4, !tbaa !13
  %278 = fneg float %277
  %gep414 = getelementptr %struct.complex, ptr %invariant.gep413, i64 %271
  %279 = load <2 x float>, ptr %25, align 8, !tbaa !9
  %280 = insertelement <2 x float> poison, float %277, i64 0
  %281 = insertelement <2 x float> %280, float %278, i64 1
  %282 = fmul <2 x float> %279, %281
  %283 = shufflevector <2 x float> %282, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %284 = shufflevector <4 x float> %276, <4 x float> poison, <2 x i32> zeroinitializer
  %285 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %284, <2 x float> %279, <2 x float> %283)
  %286 = load <2 x float>, ptr %gep414, align 4, !tbaa !9
  %287 = fadd <2 x float> %286, %285
  store <2 x float> %287, ptr %24, align 8, !tbaa !9
  %gep416 = getelementptr %struct.complex, ptr %invariant.gep415, i64 %indvars.iv392
  %288 = call <2 x float> @Cf(ptr noundef %gep416)
  %.sroa.02.0.vec.extract = extractelement <2 x float> %288, i64 0
  %.sroa.02.4.vec.extract = extractelement <2 x float> %288, i64 1
  %289 = fneg float %.sroa.02.4.vec.extract
  %290 = call ptr @_pCf(ptr noundef nonnull %26)
  %291 = getelementptr inbounds i8, ptr %290, i64 4
  store float %.sroa.02.0.vec.extract, ptr %290, align 4
  store float %289, ptr %291, align 4
  %292 = load <4 x float>, ptr %33, align 16
  %293 = load float, ptr %189, align 4, !tbaa !13
  %294 = fneg float %293
  %295 = load <2 x float>, ptr %26, align 8, !tbaa !9
  %296 = insertelement <2 x float> poison, float %293, i64 0
  %297 = insertelement <2 x float> %296, float %294, i64 1
  %298 = fmul <2 x float> %295, %297
  %299 = shufflevector <2 x float> %298, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %300 = shufflevector <4 x float> %292, <4 x float> poison, <2 x i32> <i32 2, i32 2>
  %301 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %300, <2 x float> %295, <2 x float> %299)
  %302 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %303 = fadd <2 x float> %302, %301
  store <2 x float> %303, ptr %23, align 8, !tbaa !9
  store <2 x float> %303, ptr %gep414, align 4, !tbaa !9
  %indvars.iv.next393 = add nuw nsw i64 %indvars.iv392, 1
  %.not314.not = icmp slt i64 %indvars.iv392, %270
  br i1 %.not314.not, label %.lr.ph365, label %._crit_edge366, !llvm.loop !21

._crit_edge366:                                   ; preds = %.lr.ph365, %267
  %304 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %304, ptr %22, align 4, !tbaa !5
  %305 = sext i32 %304 to i64
  %.not315.not367 = icmp slt i64 %indvars.iv395, %305
  br i1 %.not315.not367, label %.lr.ph370.preheader, label %.loopexit

.lr.ph370.preheader:                              ; preds = %._crit_edge366
  %invariant.gep419 = getelementptr %struct.complex, ptr %42, i64 %243
  br label %.lr.ph370

.lr.ph370:                                        ; preds = %.lr.ph370.preheader, %.lr.ph370
  %indvars.iv397 = phi i64 [ %indvars.iv395, %.lr.ph370.preheader ], [ %indvars.iv.next398, %.lr.ph370 ]
  %indvars.iv.next398 = add nuw nsw i64 %indvars.iv397, 1
  %306 = mul nsw i64 %indvars.iv.next398, %194
  %gep418 = getelementptr %struct.complex, ptr %invariant.gep417, i64 %306
  %307 = call <2 x float> @Cf(ptr noundef %gep418)
  %.sroa.01.0.vec.extract = extractelement <2 x float> %307, i64 0
  %.sroa.01.4.vec.extract = extractelement <2 x float> %307, i64 1
  %308 = fneg float %.sroa.01.4.vec.extract
  %309 = call ptr @_pCf(ptr noundef nonnull %25)
  %310 = getelementptr inbounds i8, ptr %309, i64 4
  store float %.sroa.01.0.vec.extract, ptr %309, align 4
  store float %308, ptr %310, align 4
  %311 = load float, ptr %25, align 8, !tbaa !11
  %312 = load float, ptr %190, align 4, !tbaa !13
  %313 = fneg float %312
  %gep420 = getelementptr %struct.complex, ptr %invariant.gep419, i64 %indvars.iv.next398
  %314 = load <2 x float>, ptr %33, align 16, !tbaa !9
  %315 = insertelement <2 x float> poison, float %312, i64 0
  %316 = insertelement <2 x float> %315, float %313, i64 1
  %317 = fmul <2 x float> %314, %316
  %318 = shufflevector <2 x float> %317, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %319 = insertelement <2 x float> poison, float %311, i64 0
  %320 = shufflevector <2 x float> %319, <2 x float> poison, <2 x i32> zeroinitializer
  %321 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %320, <2 x float> %314, <2 x float> %318)
  %322 = load <2 x float>, ptr %gep420, align 4, !tbaa !9
  %323 = fsub <2 x float> %322, %321
  store <2 x float> %323, ptr %24, align 8, !tbaa !9
  %324 = mul nsw i64 %indvars.iv.next398, %195
  %gep422 = getelementptr %struct.complex, ptr %invariant.gep421, i64 %324
  %325 = call <2 x float> @Cf(ptr noundef %gep422)
  %.sroa.0.0.vec.extract = extractelement <2 x float> %325, i64 0
  %.sroa.0.4.vec.extract = extractelement <2 x float> %325, i64 1
  %326 = fneg float %.sroa.0.4.vec.extract
  %327 = call ptr @_pCf(ptr noundef nonnull %26)
  %328 = getelementptr inbounds i8, ptr %327, i64 4
  store float %.sroa.0.0.vec.extract, ptr %327, align 4
  store float %326, ptr %328, align 4
  %329 = load float, ptr %26, align 8, !tbaa !11
  %330 = load float, ptr %191, align 4, !tbaa !13
  %331 = fneg float %330
  %332 = load <2 x float>, ptr %188, align 8, !tbaa !9
  %333 = insertelement <2 x float> poison, float %330, i64 0
  %334 = insertelement <2 x float> %333, float %331, i64 1
  %335 = fmul <2 x float> %332, %334
  %336 = shufflevector <2 x float> %335, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %337 = insertelement <2 x float> poison, float %329, i64 0
  %338 = shufflevector <2 x float> %337, <2 x float> poison, <2 x i32> zeroinitializer
  %339 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %338, <2 x float> %332, <2 x float> %336)
  %340 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %341 = fsub <2 x float> %340, %339
  store <2 x float> %341, ptr %23, align 8, !tbaa !9
  store <2 x float> %341, ptr %gep420, align 4, !tbaa !9
  %.not315.not = icmp slt i64 %indvars.iv.next398, %305
  br i1 %.not315.not, label %.lr.ph370, label %.loopexit, !llvm.loop !22

._crit_edge374:                                   ; preds = %.loopexit, %.lr.ph378.split
  %indvars.iv.next396 = add nuw nsw i64 %indvars.iv395, 1
  %.not312.not = icmp ult i64 %indvars.iv395, %198
  br i1 %.not312.not, label %.lr.ph378.split, label %.loopexit331, !llvm.loop !23

.loopexit331:                                     ; preds = %._crit_edge348, %._crit_edge374, %.thread327
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %33) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %32) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %31) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %24) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %21) #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 @cgetc2_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

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

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

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

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

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

; 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 <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}
!17 = distinct !{!17, !15, !18}
!18 = !{!"llvm.loop.unswitch.partial.disable"}
!19 = distinct !{!19, !15}
!20 = distinct !{!20, !15}
!21 = distinct !{!21, !15}
!22 = distinct !{!22, !15}
!23 = distinct !{!23, !15, !18}


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