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

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

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

162:                                              ; preds = %16
  %163 = load ptr, ptr %17, align 8, !tbaa !5
  %164 = call i32 @lsame_(ptr noundef %163, ptr noundef @.str.1)
  %165 = icmp ne i32 %164, 0
  br i1 %165, label %168, label %166

166:                                              ; preds = %162
  %167 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -1, ptr %167, align 4, !tbaa !9
  br label %214

168:                                              ; preds = %162, %16
  %169 = load ptr, ptr %18, align 8, !tbaa !5
  %170 = load i32, ptr %169, align 4, !tbaa !9
  %171 = icmp slt i32 %170, 0
  br i1 %171, label %172, label %174

172:                                              ; preds = %168
  %173 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -2, ptr %173, align 4, !tbaa !9
  br label %213

174:                                              ; preds = %168
  %175 = load ptr, ptr %19, align 8, !tbaa !5
  %176 = load i32, ptr %175, align 4, !tbaa !9
  %177 = icmp slt i32 %176, 0
  br i1 %177, label %178, label %180

178:                                              ; preds = %174
  %179 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -3, ptr %179, align 4, !tbaa !9
  br label %212

180:                                              ; preds = %174
  %181 = load ptr, ptr %25, align 8, !tbaa !5
  %182 = load i32, ptr %181, align 4, !tbaa !9
  %183 = load ptr, ptr %18, align 8, !tbaa !5
  %184 = load i32, ptr %183, align 4, !tbaa !9
  %185 = icmp sge i32 1, %184
  br i1 %185, label %186, label %187

186:                                              ; preds = %180
  br label %190

187:                                              ; preds = %180
  %188 = load ptr, ptr %18, align 8, !tbaa !5
  %189 = load i32, ptr %188, align 4, !tbaa !9
  br label %190

190:                                              ; preds = %187, %186
  %191 = phi i32 [ 1, %186 ], [ %189, %187 ]
  %192 = icmp slt i32 %182, %191
  br i1 %192, label %193, label %195

193:                                              ; preds = %190
  %194 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -9, ptr %194, align 4, !tbaa !9
  br label %211

195:                                              ; preds = %190
  %196 = load ptr, ptr %27, align 8, !tbaa !5
  %197 = load i32, ptr %196, align 4, !tbaa !9
  %198 = load ptr, ptr %18, align 8, !tbaa !5
  %199 = load i32, ptr %198, align 4, !tbaa !9
  %200 = icmp sge i32 1, %199
  br i1 %200, label %201, label %202

201:                                              ; preds = %195
  br label %205

202:                                              ; preds = %195
  %203 = load ptr, ptr %18, align 8, !tbaa !5
  %204 = load i32, ptr %203, align 4, !tbaa !9
  br label %205

205:                                              ; preds = %202, %201
  %206 = phi i32 [ 1, %201 ], [ %204, %202 ]
  %207 = icmp slt i32 %197, %206
  br i1 %207, label %208, label %210

208:                                              ; preds = %205
  %209 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -11, ptr %209, align 4, !tbaa !9
  br label %210

210:                                              ; preds = %208, %205
  br label %211

211:                                              ; preds = %210, %193
  br label %212

212:                                              ; preds = %211, %178
  br label %213

213:                                              ; preds = %212, %172
  br label %214

214:                                              ; preds = %213, %166
  %215 = load ptr, ptr %32, align 8, !tbaa !5
  %216 = load i32, ptr %215, align 4, !tbaa !9
  %217 = icmp ne i32 %216, 0
  br i1 %217, label %218, label %223

218:                                              ; preds = %214
  %219 = load ptr, ptr %32, align 8, !tbaa !5
  %220 = load i32, ptr %219, align 4, !tbaa !9
  %221 = sub nsw i32 0, %220
  store i32 %221, ptr %37, align 4, !tbaa !9
  %222 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %37, i32 noundef 6)
  store i32 1, ptr %74, align 4
  br label %3143

223:                                              ; preds = %214
  %224 = load ptr, ptr %18, align 8, !tbaa !5
  %225 = load i32, ptr %224, align 4, !tbaa !9
  %226 = icmp eq i32 %225, 0
  br i1 %226, label %231, label %227

227:                                              ; preds = %223
  %228 = load ptr, ptr %19, align 8, !tbaa !5
  %229 = load i32, ptr %228, align 4, !tbaa !9
  %230 = icmp eq i32 %229, 0
  br i1 %230, label %231, label %251

231:                                              ; preds = %227, %223
  %232 = load ptr, ptr %19, align 8, !tbaa !5
  %233 = load i32, ptr %232, align 4, !tbaa !9
  store i32 %233, ptr %37, align 4, !tbaa !9
  store i32 1, ptr %61, align 4, !tbaa !9
  br label %234

234:                                              ; preds = %247, %231
  %235 = load i32, ptr %61, align 4, !tbaa !9
  %236 = load i32, ptr %37, align 4, !tbaa !9
  %237 = icmp sle i32 %235, %236
  br i1 %237, label %238, label %250

238:                                              ; preds = %234
  %239 = load ptr, ptr %28, align 8, !tbaa !5
  %240 = load i32, ptr %61, align 4, !tbaa !9
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds float, ptr %239, i64 %241
  store float 0.000000e+00, ptr %242, align 4, !tbaa !11
  %243 = load ptr, ptr %29, align 8, !tbaa !5
  %244 = load i32, ptr %61, align 4, !tbaa !9
  %245 = sext i32 %244 to i64
  %246 = getelementptr inbounds float, ptr %243, i64 %245
  store float 0.000000e+00, ptr %246, align 4, !tbaa !11
  br label %247

247:                                              ; preds = %238
  %248 = load i32, ptr %61, align 4, !tbaa !9
  %249 = add nsw i32 %248, 1
  store i32 %249, ptr %61, align 4, !tbaa !9
  br label %234, !llvm.loop !13

250:                                              ; preds = %234
  store i32 1, ptr %74, align 4
  br label %3143

251:                                              ; preds = %227
  store i32 4, ptr %70, align 4, !tbaa !9
  %252 = call float @slamch_(ptr noundef @.str.3)
  store float %252, ptr %73, align 4, !tbaa !11
  %253 = call float @slamch_(ptr noundef @.str.4)
  store float %253, ptr %71, align 4, !tbaa !11
  %254 = load i32, ptr %70, align 4, !tbaa !9
  %255 = sitofp i32 %254 to float
  %256 = load float, ptr %71, align 4, !tbaa !11
  %257 = fmul float %255, %256
  store float %257, ptr %58, align 4, !tbaa !11
  %258 = load float, ptr %58, align 4, !tbaa !11
  %259 = load float, ptr %73, align 4, !tbaa !11
  %260 = fdiv float %258, %259
  store float %260, ptr %59, align 4, !tbaa !11
  %261 = load ptr, ptr %19, align 8, !tbaa !5
  %262 = load i32, ptr %261, align 4, !tbaa !9
  store i32 %262, ptr %37, align 4, !tbaa !9
  store i32 1, ptr %61, align 4, !tbaa !9
  br label %263

263:                                              ; preds = %3139, %251
  %264 = load i32, ptr %61, align 4, !tbaa !9
  %265 = load i32, ptr %37, align 4, !tbaa !9
  %266 = icmp sle i32 %264, %265
  br i1 %266, label %267, label %3142

267:                                              ; preds = %263
  store i32 1, ptr %63, align 4, !tbaa !9
  store float 3.000000e+00, ptr %72, align 4, !tbaa !11
  br label %268

268:                                              ; preds = %2806, %267
  %269 = load i32, ptr %64, align 4, !tbaa !9
  %270 = icmp ne i32 %269, 0
  br i1 %270, label %271, label %1459

271:                                              ; preds = %268
  %272 = load ptr, ptr %18, align 8, !tbaa !5
  %273 = load i32, ptr %272, align 4, !tbaa !9
  %274 = icmp eq i32 %273, 1
  br i1 %274, label %275, label %403

275:                                              ; preds = %271
  %276 = load i32, ptr %61, align 4, !tbaa !9
  %277 = load i32, ptr %33, align 4, !tbaa !9
  %278 = mul nsw i32 %276, %277
  %279 = add nsw i32 %278, 1
  store i32 %279, ptr %38, align 4, !tbaa !9
  %280 = load ptr, ptr %24, align 8, !tbaa !5
  %281 = load i32, ptr %38, align 4, !tbaa !9
  %282 = sext i32 %281 to i64
  %283 = getelementptr inbounds %struct.complex, ptr %280, i64 %282
  %284 = getelementptr inbounds %struct.complex, ptr %283, i32 0, i32 0
  %285 = load float, ptr %284, align 4, !tbaa !15
  %286 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %285, ptr %286, align 4, !tbaa !15
  %287 = load ptr, ptr %24, align 8, !tbaa !5
  %288 = load i32, ptr %38, align 4, !tbaa !9
  %289 = sext i32 %288 to i64
  %290 = getelementptr inbounds %struct.complex, ptr %287, i64 %289
  %291 = getelementptr inbounds %struct.complex, ptr %290, i32 0, i32 1
  %292 = load float, ptr %291, align 4, !tbaa !17
  %293 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %292, ptr %293, align 4, !tbaa !17
  %294 = load i32, ptr %61, align 4, !tbaa !9
  %295 = load i32, ptr %35, align 4, !tbaa !9
  %296 = mul nsw i32 %294, %295
  %297 = add nsw i32 %296, 1
  store i32 %297, ptr %38, align 4, !tbaa !9
  %298 = load ptr, ptr %20, align 8, !tbaa !5
  %299 = getelementptr inbounds float, ptr %298, i64 1
  %300 = load float, ptr %299, align 4, !tbaa !11
  %301 = load ptr, ptr %26, align 8, !tbaa !5
  %302 = load i32, ptr %38, align 4, !tbaa !9
  %303 = sext i32 %302 to i64
  %304 = getelementptr inbounds %struct.complex, ptr %301, i64 %303
  %305 = getelementptr inbounds %struct.complex, ptr %304, i32 0, i32 0
  %306 = load float, ptr %305, align 4, !tbaa !15
  %307 = fmul float %300, %306
  %308 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %307, ptr %308, align 4, !tbaa !15
  %309 = load ptr, ptr %20, align 8, !tbaa !5
  %310 = getelementptr inbounds float, ptr %309, i64 1
  %311 = load float, ptr %310, align 4, !tbaa !11
  %312 = load ptr, ptr %26, align 8, !tbaa !5
  %313 = load i32, ptr %38, align 4, !tbaa !9
  %314 = sext i32 %313 to i64
  %315 = getelementptr inbounds %struct.complex, ptr %312, i64 %314
  %316 = getelementptr inbounds %struct.complex, ptr %315, i32 0, i32 1
  %317 = load float, ptr %316, align 4, !tbaa !17
  %318 = fmul float %311, %317
  %319 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %318, ptr %319, align 4, !tbaa !17
  %320 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %321 = load float, ptr %320, align 4, !tbaa !15
  %322 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %321, ptr %322, align 4, !tbaa !15
  %323 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %324 = load float, ptr %323, align 4, !tbaa !17
  %325 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %324, ptr %325, align 4, !tbaa !17
  %326 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %327 = load float, ptr %326, align 4, !tbaa !15
  %328 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %329 = load float, ptr %328, align 4, !tbaa !15
  %330 = fsub float %327, %329
  %331 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %330, ptr %331, align 4, !tbaa !15
  %332 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %333 = load float, ptr %332, align 4, !tbaa !17
  %334 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %335 = load float, ptr %334, align 4, !tbaa !17
  %336 = fsub float %333, %335
  %337 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %336, ptr %337, align 4, !tbaa !17
  %338 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %339 = load float, ptr %338, align 4, !tbaa !15
  %340 = load ptr, ptr %30, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.complex, ptr %340, i64 1
  %342 = getelementptr inbounds %struct.complex, ptr %341, i32 0, i32 0
  store float %339, ptr %342, align 4, !tbaa !15
  %343 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %344 = load float, ptr %343, align 4, !tbaa !17
  %345 = load ptr, ptr %30, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.complex, ptr %345, i64 1
  %347 = getelementptr inbounds %struct.complex, ptr %346, i32 0, i32 1
  store float %344, ptr %347, align 4, !tbaa !17
  %348 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %349 = load float, ptr %348, align 4, !tbaa !15
  store float %349, ptr %43, align 4, !tbaa !11
  %350 = load float, ptr %43, align 4, !tbaa !11
  %351 = fcmp oge float %350, 0.000000e+00
  br i1 %351, label %352, label %354

352:                                              ; preds = %275
  %353 = load float, ptr %43, align 4, !tbaa !11
  br label %357

354:                                              ; preds = %275
  %355 = load float, ptr %43, align 4, !tbaa !11
  %356 = fneg float %355
  br label %357

357:                                              ; preds = %354, %352
  %358 = phi float [ %353, %352 ], [ %356, %354 ]
  %359 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %359, ptr %75, align 4
  %360 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 0
  %361 = load float, ptr %360, align 4
  %362 = getelementptr inbounds { float, float }, ptr %75, i32 0, i32 1
  %363 = load float, ptr %362, align 4
  store float %363, ptr %44, align 4, !tbaa !11
  %364 = load float, ptr %44, align 4, !tbaa !11
  %365 = fcmp oge float %364, 0.000000e+00
  br i1 %365, label %366, label %368

366:                                              ; preds = %357
  %367 = load float, ptr %44, align 4, !tbaa !11
  br label %371

368:                                              ; preds = %357
  %369 = load float, ptr %44, align 4, !tbaa !11
  %370 = fneg float %369
  br label %371

371:                                              ; preds = %368, %366
  %372 = phi float [ %367, %366 ], [ %370, %368 ]
  %373 = fadd float %358, %372
  %374 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %375 = load float, ptr %374, align 4, !tbaa !15
  store float %375, ptr %45, align 4, !tbaa !11
  %376 = load float, ptr %45, align 4, !tbaa !11
  %377 = fcmp oge float %376, 0.000000e+00
  br i1 %377, label %378, label %380

378:                                              ; preds = %371
  %379 = load float, ptr %45, align 4, !tbaa !11
  br label %383

380:                                              ; preds = %371
  %381 = load float, ptr %45, align 4, !tbaa !11
  %382 = fneg float %381
  br label %383

383:                                              ; preds = %380, %378
  %384 = phi float [ %379, %378 ], [ %382, %380 ]
  %385 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %385, ptr %76, align 4
  %386 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 0
  %387 = load float, ptr %386, align 4
  %388 = getelementptr inbounds { float, float }, ptr %76, i32 0, i32 1
  %389 = load float, ptr %388, align 4
  store float %389, ptr %46, align 4, !tbaa !11
  %390 = load float, ptr %46, align 4, !tbaa !11
  %391 = fcmp oge float %390, 0.000000e+00
  br i1 %391, label %392, label %394

392:                                              ; preds = %383
  %393 = load float, ptr %46, align 4, !tbaa !11
  br label %397

394:                                              ; preds = %383
  %395 = load float, ptr %46, align 4, !tbaa !11
  %396 = fneg float %395
  br label %397

397:                                              ; preds = %394, %392
  %398 = phi float [ %393, %392 ], [ %396, %394 ]
  %399 = fadd float %384, %398
  %400 = fadd float %373, %399
  %401 = load ptr, ptr %31, align 8, !tbaa !5
  %402 = getelementptr inbounds float, ptr %401, i64 1
  store float %400, ptr %402, align 4, !tbaa !11
  br label %1458

403:                                              ; preds = %271
  %404 = load i32, ptr %61, align 4, !tbaa !9
  %405 = load i32, ptr %33, align 4, !tbaa !9
  %406 = mul nsw i32 %404, %405
  %407 = add nsw i32 %406, 1
  store i32 %407, ptr %38, align 4, !tbaa !9
  %408 = load ptr, ptr %24, align 8, !tbaa !5
  %409 = load i32, ptr %38, align 4, !tbaa !9
  %410 = sext i32 %409 to i64
  %411 = getelementptr inbounds %struct.complex, ptr %408, i64 %410
  %412 = getelementptr inbounds %struct.complex, ptr %411, i32 0, i32 0
  %413 = load float, ptr %412, align 4, !tbaa !15
  %414 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %413, ptr %414, align 4, !tbaa !15
  %415 = load ptr, ptr %24, align 8, !tbaa !5
  %416 = load i32, ptr %38, 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 1
  %420 = load float, ptr %419, align 4, !tbaa !17
  %421 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %420, ptr %421, align 4, !tbaa !17
  %422 = load i32, ptr %61, align 4, !tbaa !9
  %423 = load i32, ptr %35, align 4, !tbaa !9
  %424 = mul nsw i32 %422, %423
  %425 = add nsw i32 %424, 1
  store i32 %425, ptr %38, align 4, !tbaa !9
  %426 = load ptr, ptr %20, align 8, !tbaa !5
  %427 = getelementptr inbounds float, ptr %426, i64 1
  %428 = load float, ptr %427, align 4, !tbaa !11
  %429 = load ptr, ptr %26, align 8, !tbaa !5
  %430 = load i32, ptr %38, align 4, !tbaa !9
  %431 = sext i32 %430 to i64
  %432 = getelementptr inbounds %struct.complex, ptr %429, i64 %431
  %433 = getelementptr inbounds %struct.complex, ptr %432, i32 0, i32 0
  %434 = load float, ptr %433, align 4, !tbaa !15
  %435 = fmul float %428, %434
  %436 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %435, ptr %436, align 4, !tbaa !15
  %437 = load ptr, ptr %20, align 8, !tbaa !5
  %438 = getelementptr inbounds float, ptr %437, i64 1
  %439 = load float, ptr %438, align 4, !tbaa !11
  %440 = load ptr, ptr %26, align 8, !tbaa !5
  %441 = load i32, ptr %38, align 4, !tbaa !9
  %442 = sext i32 %441 to i64
  %443 = getelementptr inbounds %struct.complex, ptr %440, i64 %442
  %444 = getelementptr inbounds %struct.complex, ptr %443, i32 0, i32 1
  %445 = load float, ptr %444, align 4, !tbaa !17
  %446 = fmul float %439, %445
  %447 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %446, ptr %447, align 4, !tbaa !17
  %448 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %449 = load float, ptr %448, align 4, !tbaa !15
  %450 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %449, ptr %450, align 4, !tbaa !15
  %451 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %452 = load float, ptr %451, align 4, !tbaa !17
  %453 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %452, ptr %453, align 4, !tbaa !17
  %454 = load i32, ptr %61, align 4, !tbaa !9
  %455 = load i32, ptr %35, align 4, !tbaa !9
  %456 = mul nsw i32 %454, %455
  %457 = add nsw i32 %456, 2
  store i32 %457, ptr %38, align 4, !tbaa !9
  %458 = load ptr, ptr %21, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.complex, ptr %458, i64 1
  %460 = getelementptr inbounds %struct.complex, ptr %459, i32 0, i32 0
  %461 = load float, ptr %460, align 4, !tbaa !15
  %462 = load ptr, ptr %26, align 8, !tbaa !5
  %463 = load i32, ptr %38, align 4, !tbaa !9
  %464 = sext i32 %463 to i64
  %465 = getelementptr inbounds %struct.complex, ptr %462, i64 %464
  %466 = getelementptr inbounds %struct.complex, ptr %465, i32 0, i32 0
  %467 = load float, ptr %466, align 4, !tbaa !15
  %468 = load ptr, ptr %21, align 8, !tbaa !5
  %469 = getelementptr inbounds %struct.complex, ptr %468, i64 1
  %470 = getelementptr inbounds %struct.complex, ptr %469, i32 0, i32 1
  %471 = load float, ptr %470, align 4, !tbaa !17
  %472 = load ptr, ptr %26, align 8, !tbaa !5
  %473 = load i32, ptr %38, align 4, !tbaa !9
  %474 = sext i32 %473 to i64
  %475 = getelementptr inbounds %struct.complex, ptr %472, i64 %474
  %476 = getelementptr inbounds %struct.complex, ptr %475, i32 0, i32 1
  %477 = load float, ptr %476, align 4, !tbaa !17
  %478 = fmul float %471, %477
  %479 = fneg float %478
  %480 = call float @llvm.fmuladd.f32(float %461, float %467, float %479)
  %481 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %480, ptr %481, align 4, !tbaa !15
  %482 = load ptr, ptr %21, align 8, !tbaa !5
  %483 = getelementptr inbounds %struct.complex, ptr %482, i64 1
  %484 = getelementptr inbounds %struct.complex, ptr %483, i32 0, i32 0
  %485 = load float, ptr %484, align 4, !tbaa !15
  %486 = load ptr, ptr %26, align 8, !tbaa !5
  %487 = load i32, ptr %38, align 4, !tbaa !9
  %488 = sext i32 %487 to i64
  %489 = getelementptr inbounds %struct.complex, ptr %486, i64 %488
  %490 = getelementptr inbounds %struct.complex, ptr %489, i32 0, i32 1
  %491 = load float, ptr %490, align 4, !tbaa !17
  %492 = load ptr, ptr %21, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.complex, ptr %492, i64 1
  %494 = getelementptr inbounds %struct.complex, ptr %493, i32 0, i32 1
  %495 = load float, ptr %494, align 4, !tbaa !17
  %496 = load ptr, ptr %26, align 8, !tbaa !5
  %497 = load i32, ptr %38, align 4, !tbaa !9
  %498 = sext i32 %497 to i64
  %499 = getelementptr inbounds %struct.complex, ptr %496, i64 %498
  %500 = getelementptr inbounds %struct.complex, ptr %499, i32 0, i32 0
  %501 = load float, ptr %500, align 4, !tbaa !15
  %502 = fmul float %495, %501
  %503 = call float @llvm.fmuladd.f32(float %485, float %491, float %502)
  %504 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %503, ptr %504, align 4, !tbaa !17
  %505 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %506 = load float, ptr %505, align 4, !tbaa !15
  %507 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  store float %506, ptr %507, align 4, !tbaa !15
  %508 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %509 = load float, ptr %508, align 4, !tbaa !17
  %510 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  store float %509, ptr %510, align 4, !tbaa !17
  %511 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %512 = load float, ptr %511, align 4, !tbaa !15
  %513 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %514 = load float, ptr %513, align 4, !tbaa !15
  %515 = fsub float %512, %514
  %516 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %515, ptr %516, align 4, !tbaa !15
  %517 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %518 = load float, ptr %517, align 4, !tbaa !17
  %519 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %520 = load float, ptr %519, align 4, !tbaa !17
  %521 = fsub float %518, %520
  %522 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %521, ptr %522, align 4, !tbaa !17
  %523 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %524 = load float, ptr %523, align 4, !tbaa !15
  %525 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  %526 = load float, ptr %525, align 4, !tbaa !15
  %527 = fsub float %524, %526
  %528 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %527, ptr %528, align 4, !tbaa !15
  %529 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %530 = load float, ptr %529, align 4, !tbaa !17
  %531 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  %532 = load float, ptr %531, align 4, !tbaa !17
  %533 = fsub float %530, %532
  %534 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %533, ptr %534, align 4, !tbaa !17
  %535 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %536 = load float, ptr %535, align 4, !tbaa !15
  %537 = load ptr, ptr %30, align 8, !tbaa !5
  %538 = getelementptr inbounds %struct.complex, ptr %537, i64 1
  %539 = getelementptr inbounds %struct.complex, ptr %538, i32 0, i32 0
  store float %536, ptr %539, align 4, !tbaa !15
  %540 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %541 = load float, ptr %540, align 4, !tbaa !17
  %542 = load ptr, ptr %30, align 8, !tbaa !5
  %543 = getelementptr inbounds %struct.complex, ptr %542, i64 1
  %544 = getelementptr inbounds %struct.complex, ptr %543, i32 0, i32 1
  store float %541, ptr %544, align 4, !tbaa !17
  %545 = load i32, ptr %61, align 4, !tbaa !9
  %546 = load i32, ptr %35, align 4, !tbaa !9
  %547 = mul nsw i32 %545, %546
  %548 = add nsw i32 %547, 2
  store i32 %548, ptr %38, align 4, !tbaa !9
  %549 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %550 = load float, ptr %549, align 4, !tbaa !15
  store float %550, ptr %43, align 4, !tbaa !11
  %551 = load float, ptr %43, align 4, !tbaa !11
  %552 = fcmp oge float %551, 0.000000e+00
  br i1 %552, label %553, label %555

553:                                              ; preds = %403
  %554 = load float, ptr %43, align 4, !tbaa !11
  br label %558

555:                                              ; preds = %403
  %556 = load float, ptr %43, align 4, !tbaa !11
  %557 = fneg float %556
  br label %558

558:                                              ; preds = %555, %553
  %559 = phi float [ %554, %553 ], [ %557, %555 ]
  %560 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %560, ptr %77, align 4
  %561 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 0
  %562 = load float, ptr %561, align 4
  %563 = getelementptr inbounds { float, float }, ptr %77, i32 0, i32 1
  %564 = load float, ptr %563, align 4
  store float %564, ptr %44, align 4, !tbaa !11
  %565 = load float, ptr %44, align 4, !tbaa !11
  %566 = fcmp oge float %565, 0.000000e+00
  br i1 %566, label %567, label %569

567:                                              ; preds = %558
  %568 = load float, ptr %44, align 4, !tbaa !11
  br label %572

569:                                              ; preds = %558
  %570 = load float, ptr %44, align 4, !tbaa !11
  %571 = fneg float %570
  br label %572

572:                                              ; preds = %569, %567
  %573 = phi float [ %568, %567 ], [ %571, %569 ]
  %574 = fadd float %559, %573
  %575 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %576 = load float, ptr %575, align 4, !tbaa !15
  store float %576, ptr %45, align 4, !tbaa !11
  %577 = load float, ptr %45, align 4, !tbaa !11
  %578 = fcmp oge float %577, 0.000000e+00
  br i1 %578, label %579, label %581

579:                                              ; preds = %572
  %580 = load float, ptr %45, align 4, !tbaa !11
  br label %584

581:                                              ; preds = %572
  %582 = load float, ptr %45, align 4, !tbaa !11
  %583 = fneg float %582
  br label %584

584:                                              ; preds = %581, %579
  %585 = phi float [ %580, %579 ], [ %583, %581 ]
  %586 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %586, ptr %78, align 4
  %587 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 0
  %588 = load float, ptr %587, align 4
  %589 = getelementptr inbounds { float, float }, ptr %78, i32 0, i32 1
  %590 = load float, ptr %589, align 4
  store float %590, ptr %46, align 4, !tbaa !11
  %591 = load float, ptr %46, align 4, !tbaa !11
  %592 = fcmp oge float %591, 0.000000e+00
  br i1 %592, label %593, label %595

593:                                              ; preds = %584
  %594 = load float, ptr %46, align 4, !tbaa !11
  br label %598

595:                                              ; preds = %584
  %596 = load float, ptr %46, align 4, !tbaa !11
  %597 = fneg float %596
  br label %598

598:                                              ; preds = %595, %593
  %599 = phi float [ %594, %593 ], [ %597, %595 ]
  %600 = fadd float %585, %599
  %601 = fadd float %574, %600
  %602 = load ptr, ptr %21, align 8, !tbaa !5
  %603 = getelementptr inbounds %struct.complex, ptr %602, i64 1
  %604 = getelementptr inbounds %struct.complex, ptr %603, i32 0, i32 0
  %605 = load float, ptr %604, align 4, !tbaa !15
  store float %605, ptr %47, align 4, !tbaa !11
  %606 = load float, ptr %47, align 4, !tbaa !11
  %607 = fcmp oge float %606, 0.000000e+00
  br i1 %607, label %608, label %610

608:                                              ; preds = %598
  %609 = load float, ptr %47, align 4, !tbaa !11
  br label %613

610:                                              ; preds = %598
  %611 = load float, ptr %47, align 4, !tbaa !11
  %612 = fneg float %611
  br label %613

613:                                              ; preds = %610, %608
  %614 = phi float [ %609, %608 ], [ %612, %610 ]
  %615 = load ptr, ptr %21, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.complex, ptr %615, i64 1
  %617 = call <2 x float> @Cf(ptr noundef %616)
  store <2 x float> %617, ptr %79, align 4
  %618 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 0
  %619 = load float, ptr %618, align 4
  %620 = getelementptr inbounds { float, float }, ptr %79, i32 0, i32 1
  %621 = load float, ptr %620, align 4
  store float %621, ptr %48, align 4, !tbaa !11
  %622 = load float, ptr %48, align 4, !tbaa !11
  %623 = fcmp oge float %622, 0.000000e+00
  br i1 %623, label %624, label %626

624:                                              ; preds = %613
  %625 = load float, ptr %48, align 4, !tbaa !11
  br label %629

626:                                              ; preds = %613
  %627 = load float, ptr %48, align 4, !tbaa !11
  %628 = fneg float %627
  br label %629

629:                                              ; preds = %626, %624
  %630 = phi float [ %625, %624 ], [ %628, %626 ]
  %631 = fadd float %614, %630
  %632 = load ptr, ptr %26, align 8, !tbaa !5
  %633 = load i32, ptr %38, align 4, !tbaa !9
  %634 = sext i32 %633 to i64
  %635 = getelementptr inbounds %struct.complex, ptr %632, i64 %634
  %636 = getelementptr inbounds %struct.complex, ptr %635, i32 0, i32 0
  %637 = load float, ptr %636, align 4, !tbaa !15
  store float %637, ptr %49, align 4, !tbaa !11
  %638 = load float, ptr %49, align 4, !tbaa !11
  %639 = fcmp oge float %638, 0.000000e+00
  br i1 %639, label %640, label %642

640:                                              ; preds = %629
  %641 = load float, ptr %49, align 4, !tbaa !11
  br label %645

642:                                              ; preds = %629
  %643 = load float, ptr %49, align 4, !tbaa !11
  %644 = fneg float %643
  br label %645

645:                                              ; preds = %642, %640
  %646 = phi float [ %641, %640 ], [ %644, %642 ]
  %647 = load ptr, ptr %26, align 8, !tbaa !5
  %648 = load i32, ptr %61, align 4, !tbaa !9
  %649 = load i32, ptr %35, align 4, !tbaa !9
  %650 = mul nsw i32 %648, %649
  %651 = add nsw i32 %650, 2
  %652 = sext i32 %651 to i64
  %653 = getelementptr inbounds %struct.complex, ptr %647, i64 %652
  %654 = call <2 x float> @Cf(ptr noundef %653)
  store <2 x float> %654, ptr %80, align 4
  %655 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 0
  %656 = load float, ptr %655, align 4
  %657 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 1
  %658 = load float, ptr %657, align 4
  store float %658, ptr %50, align 4, !tbaa !11
  %659 = load float, ptr %50, align 4, !tbaa !11
  %660 = fcmp oge float %659, 0.000000e+00
  br i1 %660, label %661, label %663

661:                                              ; preds = %645
  %662 = load float, ptr %50, align 4, !tbaa !11
  br label %666

663:                                              ; preds = %645
  %664 = load float, ptr %50, align 4, !tbaa !11
  %665 = fneg float %664
  br label %666

666:                                              ; preds = %663, %661
  %667 = phi float [ %662, %661 ], [ %665, %663 ]
  %668 = fadd float %646, %667
  %669 = call float @llvm.fmuladd.f32(float %631, float %668, float %601)
  %670 = load ptr, ptr %31, align 8, !tbaa !5
  %671 = getelementptr inbounds float, ptr %670, i64 1
  store float %669, ptr %671, align 4, !tbaa !11
  %672 = load ptr, ptr %18, align 8, !tbaa !5
  %673 = load i32, ptr %672, align 4, !tbaa !9
  %674 = sub nsw i32 %673, 1
  store i32 %674, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %675

675:                                              ; preds = %1142, %666
  %676 = load i32, ptr %60, align 4, !tbaa !9
  %677 = load i32, ptr %38, align 4, !tbaa !9
  %678 = icmp sle i32 %676, %677
  br i1 %678, label %679, label %1145

679:                                              ; preds = %675
  %680 = load i32, ptr %60, align 4, !tbaa !9
  %681 = load i32, ptr %61, align 4, !tbaa !9
  %682 = load i32, ptr %33, align 4, !tbaa !9
  %683 = mul nsw i32 %681, %682
  %684 = add nsw i32 %680, %683
  store i32 %684, ptr %39, align 4, !tbaa !9
  %685 = load ptr, ptr %24, align 8, !tbaa !5
  %686 = load i32, ptr %39, align 4, !tbaa !9
  %687 = sext i32 %686 to i64
  %688 = getelementptr inbounds %struct.complex, ptr %685, i64 %687
  %689 = getelementptr inbounds %struct.complex, ptr %688, i32 0, i32 0
  %690 = load float, ptr %689, align 4, !tbaa !15
  %691 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %690, ptr %691, align 4, !tbaa !15
  %692 = load ptr, ptr %24, align 8, !tbaa !5
  %693 = load i32, ptr %39, align 4, !tbaa !9
  %694 = sext i32 %693 to i64
  %695 = getelementptr inbounds %struct.complex, ptr %692, i64 %694
  %696 = getelementptr inbounds %struct.complex, ptr %695, i32 0, i32 1
  %697 = load float, ptr %696, align 4, !tbaa !17
  %698 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %697, ptr %698, align 4, !tbaa !17
  %699 = load ptr, ptr %21, align 8, !tbaa !5
  %700 = load i32, ptr %60, align 4, !tbaa !9
  %701 = sub nsw i32 %700, 1
  %702 = sext i32 %701 to i64
  %703 = getelementptr inbounds %struct.complex, ptr %699, i64 %702
  %704 = call <2 x float> @Cf(ptr noundef %703)
  store <2 x float> %704, ptr %81, align 4
  %705 = getelementptr inbounds { float, float }, ptr %81, i32 0, i32 0
  %706 = load float, ptr %705, align 4
  %707 = getelementptr inbounds { float, float }, ptr %81, i32 0, i32 1
  %708 = load float, ptr %707, align 4
  %709 = fneg float %708
  %710 = call ptr @_pCf(ptr noundef %56)
  %711 = getelementptr inbounds { float, float }, ptr %710, i32 0, i32 0
  %712 = getelementptr inbounds { float, float }, ptr %710, i32 0, i32 1
  store float %706, ptr %711, align 4
  store float %709, ptr %712, align 4
  %713 = load i32, ptr %60, align 4, !tbaa !9
  %714 = sub nsw i32 %713, 1
  %715 = load i32, ptr %61, align 4, !tbaa !9
  %716 = load i32, ptr %35, align 4, !tbaa !9
  %717 = mul nsw i32 %715, %716
  %718 = add nsw i32 %714, %717
  store i32 %718, ptr %39, align 4, !tbaa !9
  %719 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %720 = load float, ptr %719, align 4, !tbaa !15
  %721 = load ptr, ptr %26, align 8, !tbaa !5
  %722 = load i32, ptr %39, align 4, !tbaa !9
  %723 = sext i32 %722 to i64
  %724 = getelementptr inbounds %struct.complex, ptr %721, i64 %723
  %725 = getelementptr inbounds %struct.complex, ptr %724, i32 0, i32 0
  %726 = load float, ptr %725, align 4, !tbaa !15
  %727 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %728 = load float, ptr %727, align 4, !tbaa !17
  %729 = load ptr, ptr %26, align 8, !tbaa !5
  %730 = load i32, ptr %39, align 4, !tbaa !9
  %731 = sext i32 %730 to i64
  %732 = getelementptr inbounds %struct.complex, ptr %729, i64 %731
  %733 = getelementptr inbounds %struct.complex, ptr %732, i32 0, i32 1
  %734 = load float, ptr %733, align 4, !tbaa !17
  %735 = fmul float %728, %734
  %736 = fneg float %735
  %737 = call float @llvm.fmuladd.f32(float %720, float %726, float %736)
  %738 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %737, ptr %738, align 4, !tbaa !15
  %739 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %740 = load float, ptr %739, align 4, !tbaa !15
  %741 = load ptr, ptr %26, align 8, !tbaa !5
  %742 = load i32, ptr %39, align 4, !tbaa !9
  %743 = sext i32 %742 to i64
  %744 = getelementptr inbounds %struct.complex, ptr %741, i64 %743
  %745 = getelementptr inbounds %struct.complex, ptr %744, i32 0, i32 1
  %746 = load float, ptr %745, align 4, !tbaa !17
  %747 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %748 = load float, ptr %747, align 4, !tbaa !17
  %749 = load ptr, ptr %26, align 8, !tbaa !5
  %750 = load i32, ptr %39, align 4, !tbaa !9
  %751 = sext i32 %750 to i64
  %752 = getelementptr inbounds %struct.complex, ptr %749, i64 %751
  %753 = getelementptr inbounds %struct.complex, ptr %752, i32 0, i32 0
  %754 = load float, ptr %753, align 4, !tbaa !15
  %755 = fmul float %748, %754
  %756 = call float @llvm.fmuladd.f32(float %740, float %746, float %755)
  %757 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %756, ptr %757, align 4, !tbaa !17
  %758 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %759 = load float, ptr %758, align 4, !tbaa !15
  %760 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  store float %759, ptr %760, align 4, !tbaa !15
  %761 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %762 = load float, ptr %761, align 4, !tbaa !17
  %763 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  store float %762, ptr %763, align 4, !tbaa !17
  %764 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %764, ptr %39, align 4, !tbaa !9
  %765 = load i32, ptr %60, align 4, !tbaa !9
  %766 = load i32, ptr %61, align 4, !tbaa !9
  %767 = load i32, ptr %35, align 4, !tbaa !9
  %768 = mul nsw i32 %766, %767
  %769 = add nsw i32 %765, %768
  store i32 %769, ptr %40, align 4, !tbaa !9
  %770 = load ptr, ptr %20, align 8, !tbaa !5
  %771 = load i32, ptr %39, align 4, !tbaa !9
  %772 = sext i32 %771 to i64
  %773 = getelementptr inbounds float, ptr %770, i64 %772
  %774 = load float, ptr %773, align 4, !tbaa !11
  %775 = load ptr, ptr %26, align 8, !tbaa !5
  %776 = load i32, ptr %40, align 4, !tbaa !9
  %777 = sext i32 %776 to i64
  %778 = getelementptr inbounds %struct.complex, ptr %775, i64 %777
  %779 = getelementptr inbounds %struct.complex, ptr %778, i32 0, i32 0
  %780 = load float, ptr %779, align 4, !tbaa !15
  %781 = fmul float %774, %780
  %782 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %781, ptr %782, align 4, !tbaa !15
  %783 = load ptr, ptr %20, align 8, !tbaa !5
  %784 = load i32, ptr %39, align 4, !tbaa !9
  %785 = sext i32 %784 to i64
  %786 = getelementptr inbounds float, ptr %783, i64 %785
  %787 = load float, ptr %786, align 4, !tbaa !11
  %788 = load ptr, ptr %26, align 8, !tbaa !5
  %789 = load i32, ptr %40, align 4, !tbaa !9
  %790 = sext i32 %789 to i64
  %791 = getelementptr inbounds %struct.complex, ptr %788, i64 %790
  %792 = getelementptr inbounds %struct.complex, ptr %791, i32 0, i32 1
  %793 = load float, ptr %792, align 4, !tbaa !17
  %794 = fmul float %787, %793
  %795 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %794, ptr %795, align 4, !tbaa !17
  %796 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %797 = load float, ptr %796, align 4, !tbaa !15
  %798 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %797, ptr %798, align 4, !tbaa !15
  %799 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %800 = load float, ptr %799, align 4, !tbaa !17
  %801 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %800, ptr %801, align 4, !tbaa !17
  %802 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %802, ptr %39, align 4, !tbaa !9
  %803 = load i32, ptr %60, align 4, !tbaa !9
  %804 = add nsw i32 %803, 1
  %805 = load i32, ptr %61, align 4, !tbaa !9
  %806 = load i32, ptr %35, align 4, !tbaa !9
  %807 = mul nsw i32 %805, %806
  %808 = add nsw i32 %804, %807
  store i32 %808, ptr %40, align 4, !tbaa !9
  %809 = load ptr, ptr %21, align 8, !tbaa !5
  %810 = load i32, ptr %39, align 4, !tbaa !9
  %811 = sext i32 %810 to i64
  %812 = getelementptr inbounds %struct.complex, ptr %809, i64 %811
  %813 = getelementptr inbounds %struct.complex, ptr %812, i32 0, i32 0
  %814 = load float, ptr %813, align 4, !tbaa !15
  %815 = load ptr, ptr %26, align 8, !tbaa !5
  %816 = load i32, ptr %40, align 4, !tbaa !9
  %817 = sext i32 %816 to i64
  %818 = getelementptr inbounds %struct.complex, ptr %815, i64 %817
  %819 = getelementptr inbounds %struct.complex, ptr %818, i32 0, i32 0
  %820 = load float, ptr %819, align 4, !tbaa !15
  %821 = load ptr, ptr %21, align 8, !tbaa !5
  %822 = load i32, ptr %39, 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 !17
  %827 = load ptr, ptr %26, align 8, !tbaa !5
  %828 = load i32, ptr %40, align 4, !tbaa !9
  %829 = sext i32 %828 to i64
  %830 = getelementptr inbounds %struct.complex, ptr %827, i64 %829
  %831 = getelementptr inbounds %struct.complex, ptr %830, i32 0, i32 1
  %832 = load float, ptr %831, align 4, !tbaa !17
  %833 = fmul float %826, %832
  %834 = fneg float %833
  %835 = call float @llvm.fmuladd.f32(float %814, float %820, float %834)
  %836 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %835, ptr %836, align 4, !tbaa !15
  %837 = load ptr, ptr %21, align 8, !tbaa !5
  %838 = load i32, ptr %39, align 4, !tbaa !9
  %839 = sext i32 %838 to i64
  %840 = getelementptr inbounds %struct.complex, ptr %837, i64 %839
  %841 = getelementptr inbounds %struct.complex, ptr %840, i32 0, i32 0
  %842 = load float, ptr %841, align 4, !tbaa !15
  %843 = load ptr, ptr %26, align 8, !tbaa !5
  %844 = load i32, ptr %40, align 4, !tbaa !9
  %845 = sext i32 %844 to i64
  %846 = getelementptr inbounds %struct.complex, ptr %843, i64 %845
  %847 = getelementptr inbounds %struct.complex, ptr %846, i32 0, i32 1
  %848 = load float, ptr %847, align 4, !tbaa !17
  %849 = load ptr, ptr %21, align 8, !tbaa !5
  %850 = load i32, ptr %39, align 4, !tbaa !9
  %851 = sext i32 %850 to i64
  %852 = getelementptr inbounds %struct.complex, ptr %849, i64 %851
  %853 = getelementptr inbounds %struct.complex, ptr %852, i32 0, i32 1
  %854 = load float, ptr %853, align 4, !tbaa !17
  %855 = load ptr, ptr %26, align 8, !tbaa !5
  %856 = load i32, ptr %40, align 4, !tbaa !9
  %857 = sext i32 %856 to i64
  %858 = getelementptr inbounds %struct.complex, ptr %855, i64 %857
  %859 = getelementptr inbounds %struct.complex, ptr %858, i32 0, i32 0
  %860 = load float, ptr %859, align 4, !tbaa !15
  %861 = fmul float %854, %860
  %862 = call float @llvm.fmuladd.f32(float %842, float %848, float %861)
  %863 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %862, ptr %863, align 4, !tbaa !17
  %864 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %865 = load float, ptr %864, align 4, !tbaa !15
  %866 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  store float %865, ptr %866, align 4, !tbaa !15
  %867 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %868 = load float, ptr %867, align 4, !tbaa !17
  %869 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  store float %868, ptr %869, align 4, !tbaa !17
  %870 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %870, ptr %39, align 4, !tbaa !9
  %871 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %872 = load float, ptr %871, align 4, !tbaa !15
  %873 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  %874 = load float, ptr %873, align 4, !tbaa !15
  %875 = fsub float %872, %874
  %876 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %875, ptr %876, align 4, !tbaa !15
  %877 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %878 = load float, ptr %877, align 4, !tbaa !17
  %879 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  %880 = load float, ptr %879, align 4, !tbaa !17
  %881 = fsub float %878, %880
  %882 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %881, ptr %882, align 4, !tbaa !17
  %883 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %884 = load float, ptr %883, align 4, !tbaa !15
  %885 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %886 = load float, ptr %885, align 4, !tbaa !15
  %887 = fsub float %884, %886
  %888 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %887, ptr %888, align 4, !tbaa !15
  %889 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %890 = load float, ptr %889, align 4, !tbaa !17
  %891 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %892 = load float, ptr %891, align 4, !tbaa !17
  %893 = fsub float %890, %892
  %894 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %893, ptr %894, align 4, !tbaa !17
  %895 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %896 = load float, ptr %895, align 4, !tbaa !15
  %897 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  %898 = load float, ptr %897, align 4, !tbaa !15
  %899 = fsub float %896, %898
  %900 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %899, ptr %900, align 4, !tbaa !15
  %901 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %902 = load float, ptr %901, align 4, !tbaa !17
  %903 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  %904 = load float, ptr %903, align 4, !tbaa !17
  %905 = fsub float %902, %904
  %906 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %905, ptr %906, align 4, !tbaa !17
  %907 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %908 = load float, ptr %907, align 4, !tbaa !15
  %909 = load ptr, ptr %30, align 8, !tbaa !5
  %910 = load i32, ptr %39, align 4, !tbaa !9
  %911 = sext i32 %910 to i64
  %912 = getelementptr inbounds %struct.complex, ptr %909, i64 %911
  %913 = getelementptr inbounds %struct.complex, ptr %912, i32 0, i32 0
  store float %908, ptr %913, align 4, !tbaa !15
  %914 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %915 = load float, ptr %914, align 4, !tbaa !17
  %916 = load ptr, ptr %30, align 8, !tbaa !5
  %917 = load i32, ptr %39, align 4, !tbaa !9
  %918 = sext i32 %917 to i64
  %919 = getelementptr inbounds %struct.complex, ptr %916, i64 %918
  %920 = getelementptr inbounds %struct.complex, ptr %919, i32 0, i32 1
  store float %915, ptr %920, align 4, !tbaa !17
  %921 = load i32, ptr %60, align 4, !tbaa !9
  %922 = sub nsw i32 %921, 1
  store i32 %922, ptr %39, align 4, !tbaa !9
  %923 = load i32, ptr %60, align 4, !tbaa !9
  %924 = sub nsw i32 %923, 1
  %925 = load i32, ptr %61, align 4, !tbaa !9
  %926 = load i32, ptr %35, align 4, !tbaa !9
  %927 = mul nsw i32 %925, %926
  %928 = add nsw i32 %924, %927
  store i32 %928, ptr %40, align 4, !tbaa !9
  %929 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %929, ptr %41, align 4, !tbaa !9
  %930 = load i32, ptr %60, align 4, !tbaa !9
  %931 = add nsw i32 %930, 1
  %932 = load i32, ptr %61, align 4, !tbaa !9
  %933 = load i32, ptr %35, align 4, !tbaa !9
  %934 = mul nsw i32 %932, %933
  %935 = add nsw i32 %931, %934
  store i32 %935, ptr %42, align 4, !tbaa !9
  %936 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %937 = load float, ptr %936, align 4, !tbaa !15
  store float %937, ptr %43, align 4, !tbaa !11
  %938 = load float, ptr %43, align 4, !tbaa !11
  %939 = fcmp oge float %938, 0.000000e+00
  br i1 %939, label %940, label %942

940:                                              ; preds = %679
  %941 = load float, ptr %43, align 4, !tbaa !11
  br label %945

942:                                              ; preds = %679
  %943 = load float, ptr %43, align 4, !tbaa !11
  %944 = fneg float %943
  br label %945

945:                                              ; preds = %942, %940
  %946 = phi float [ %941, %940 ], [ %944, %942 ]
  %947 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %947, ptr %82, align 4
  %948 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 0
  %949 = load float, ptr %948, align 4
  %950 = getelementptr inbounds { float, float }, ptr %82, i32 0, i32 1
  %951 = load float, ptr %950, align 4
  store float %951, ptr %44, align 4, !tbaa !11
  %952 = load float, ptr %44, align 4, !tbaa !11
  %953 = fcmp oge float %952, 0.000000e+00
  br i1 %953, label %954, label %956

954:                                              ; preds = %945
  %955 = load float, ptr %44, align 4, !tbaa !11
  br label %959

956:                                              ; preds = %945
  %957 = load float, ptr %44, align 4, !tbaa !11
  %958 = fneg float %957
  br label %959

959:                                              ; preds = %956, %954
  %960 = phi float [ %955, %954 ], [ %958, %956 ]
  %961 = fadd float %946, %960
  %962 = load ptr, ptr %21, align 8, !tbaa !5
  %963 = load i32, ptr %39, align 4, !tbaa !9
  %964 = sext i32 %963 to i64
  %965 = getelementptr inbounds %struct.complex, ptr %962, i64 %964
  %966 = getelementptr inbounds %struct.complex, ptr %965, i32 0, i32 0
  %967 = load float, ptr %966, align 4, !tbaa !15
  store float %967, ptr %45, align 4, !tbaa !11
  %968 = load float, ptr %45, align 4, !tbaa !11
  %969 = fcmp oge float %968, 0.000000e+00
  br i1 %969, label %970, label %972

970:                                              ; preds = %959
  %971 = load float, ptr %45, align 4, !tbaa !11
  br label %975

972:                                              ; preds = %959
  %973 = load float, ptr %45, align 4, !tbaa !11
  %974 = fneg float %973
  br label %975

975:                                              ; preds = %972, %970
  %976 = phi float [ %971, %970 ], [ %974, %972 ]
  %977 = load ptr, ptr %21, align 8, !tbaa !5
  %978 = load i32, ptr %60, align 4, !tbaa !9
  %979 = sub nsw i32 %978, 1
  %980 = sext i32 %979 to i64
  %981 = getelementptr inbounds %struct.complex, ptr %977, i64 %980
  %982 = call <2 x float> @Cf(ptr noundef %981)
  store <2 x float> %982, ptr %83, align 4
  %983 = getelementptr inbounds { float, float }, ptr %83, i32 0, i32 0
  %984 = load float, ptr %983, align 4
  %985 = getelementptr inbounds { float, float }, ptr %83, i32 0, i32 1
  %986 = load float, ptr %985, align 4
  store float %986, ptr %46, align 4, !tbaa !11
  %987 = load float, ptr %46, align 4, !tbaa !11
  %988 = fcmp oge float %987, 0.000000e+00
  br i1 %988, label %989, label %991

989:                                              ; preds = %975
  %990 = load float, ptr %46, align 4, !tbaa !11
  br label %994

991:                                              ; preds = %975
  %992 = load float, ptr %46, align 4, !tbaa !11
  %993 = fneg float %992
  br label %994

994:                                              ; preds = %991, %989
  %995 = phi float [ %990, %989 ], [ %993, %991 ]
  %996 = fadd float %976, %995
  %997 = load ptr, ptr %26, align 8, !tbaa !5
  %998 = load i32, ptr %40, align 4, !tbaa !9
  %999 = sext i32 %998 to i64
  %1000 = getelementptr inbounds %struct.complex, ptr %997, i64 %999
  %1001 = getelementptr inbounds %struct.complex, ptr %1000, i32 0, i32 0
  %1002 = load float, ptr %1001, align 4, !tbaa !15
  store float %1002, ptr %47, align 4, !tbaa !11
  %1003 = load float, ptr %47, align 4, !tbaa !11
  %1004 = fcmp oge float %1003, 0.000000e+00
  br i1 %1004, label %1005, label %1007

1005:                                             ; preds = %994
  %1006 = load float, ptr %47, align 4, !tbaa !11
  br label %1010

1007:                                             ; preds = %994
  %1008 = load float, ptr %47, align 4, !tbaa !11
  %1009 = fneg float %1008
  br label %1010

1010:                                             ; preds = %1007, %1005
  %1011 = phi float [ %1006, %1005 ], [ %1009, %1007 ]
  %1012 = load ptr, ptr %26, align 8, !tbaa !5
  %1013 = load i32, ptr %60, align 4, !tbaa !9
  %1014 = sub nsw i32 %1013, 1
  %1015 = load i32, ptr %61, align 4, !tbaa !9
  %1016 = load i32, ptr %35, align 4, !tbaa !9
  %1017 = mul nsw i32 %1015, %1016
  %1018 = add nsw i32 %1014, %1017
  %1019 = sext i32 %1018 to i64
  %1020 = getelementptr inbounds %struct.complex, ptr %1012, i64 %1019
  %1021 = call <2 x float> @Cf(ptr noundef %1020)
  store <2 x float> %1021, ptr %84, align 4
  %1022 = getelementptr inbounds { float, float }, ptr %84, i32 0, i32 0
  %1023 = load float, ptr %1022, align 4
  %1024 = getelementptr inbounds { float, float }, ptr %84, i32 0, i32 1
  %1025 = load float, ptr %1024, align 4
  store float %1025, ptr %48, align 4, !tbaa !11
  %1026 = load float, ptr %48, align 4, !tbaa !11
  %1027 = fcmp oge float %1026, 0.000000e+00
  br i1 %1027, label %1028, label %1030

1028:                                             ; preds = %1010
  %1029 = load float, ptr %48, align 4, !tbaa !11
  br label %1033

1030:                                             ; preds = %1010
  %1031 = load float, ptr %48, align 4, !tbaa !11
  %1032 = fneg float %1031
  br label %1033

1033:                                             ; preds = %1030, %1028
  %1034 = phi float [ %1029, %1028 ], [ %1032, %1030 ]
  %1035 = fadd float %1011, %1034
  %1036 = call float @llvm.fmuladd.f32(float %996, float %1035, float %961)
  %1037 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1038 = load float, ptr %1037, align 4, !tbaa !15
  store float %1038, ptr %49, align 4, !tbaa !11
  %1039 = load float, ptr %49, align 4, !tbaa !11
  %1040 = fcmp oge float %1039, 0.000000e+00
  br i1 %1040, label %1041, label %1043

1041:                                             ; preds = %1033
  %1042 = load float, ptr %49, align 4, !tbaa !11
  br label %1046

1043:                                             ; preds = %1033
  %1044 = load float, ptr %49, align 4, !tbaa !11
  %1045 = fneg float %1044
  br label %1046

1046:                                             ; preds = %1043, %1041
  %1047 = phi float [ %1042, %1041 ], [ %1045, %1043 ]
  %1048 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %1048, ptr %85, align 4
  %1049 = getelementptr inbounds { float, float }, ptr %85, i32 0, i32 0
  %1050 = load float, ptr %1049, align 4
  %1051 = getelementptr inbounds { float, float }, ptr %85, i32 0, i32 1
  %1052 = load float, ptr %1051, align 4
  store float %1052, ptr %50, align 4, !tbaa !11
  %1053 = load float, ptr %50, align 4, !tbaa !11
  %1054 = fcmp oge float %1053, 0.000000e+00
  br i1 %1054, label %1055, label %1057

1055:                                             ; preds = %1046
  %1056 = load float, ptr %50, align 4, !tbaa !11
  br label %1060

1057:                                             ; preds = %1046
  %1058 = load float, ptr %50, align 4, !tbaa !11
  %1059 = fneg float %1058
  br label %1060

1060:                                             ; preds = %1057, %1055
  %1061 = phi float [ %1056, %1055 ], [ %1059, %1057 ]
  %1062 = fadd float %1047, %1061
  %1063 = fadd float %1036, %1062
  %1064 = load ptr, ptr %21, align 8, !tbaa !5
  %1065 = load i32, ptr %41, align 4, !tbaa !9
  %1066 = sext i32 %1065 to i64
  %1067 = getelementptr inbounds %struct.complex, ptr %1064, i64 %1066
  %1068 = getelementptr inbounds %struct.complex, ptr %1067, i32 0, i32 0
  %1069 = load float, ptr %1068, align 4, !tbaa !15
  store float %1069, ptr %51, align 4, !tbaa !11
  %1070 = load float, ptr %51, align 4, !tbaa !11
  %1071 = fcmp oge float %1070, 0.000000e+00
  br i1 %1071, label %1072, label %1074

1072:                                             ; preds = %1060
  %1073 = load float, ptr %51, align 4, !tbaa !11
  br label %1077

1074:                                             ; preds = %1060
  %1075 = load float, ptr %51, align 4, !tbaa !11
  %1076 = fneg float %1075
  br label %1077

1077:                                             ; preds = %1074, %1072
  %1078 = phi float [ %1073, %1072 ], [ %1076, %1074 ]
  %1079 = load ptr, ptr %21, align 8, !tbaa !5
  %1080 = load i32, ptr %60, align 4, !tbaa !9
  %1081 = sext i32 %1080 to i64
  %1082 = getelementptr inbounds %struct.complex, ptr %1079, i64 %1081
  %1083 = call <2 x float> @Cf(ptr noundef %1082)
  store <2 x float> %1083, ptr %86, align 4
  %1084 = getelementptr inbounds { float, float }, ptr %86, i32 0, i32 0
  %1085 = load float, ptr %1084, align 4
  %1086 = getelementptr inbounds { float, float }, ptr %86, i32 0, i32 1
  %1087 = load float, ptr %1086, align 4
  store float %1087, ptr %52, align 4, !tbaa !11
  %1088 = load float, ptr %52, align 4, !tbaa !11
  %1089 = fcmp oge float %1088, 0.000000e+00
  br i1 %1089, label %1090, label %1092

1090:                                             ; preds = %1077
  %1091 = load float, ptr %52, align 4, !tbaa !11
  br label %1095

1092:                                             ; preds = %1077
  %1093 = load float, ptr %52, align 4, !tbaa !11
  %1094 = fneg float %1093
  br label %1095

1095:                                             ; preds = %1092, %1090
  %1096 = phi float [ %1091, %1090 ], [ %1094, %1092 ]
  %1097 = fadd float %1078, %1096
  %1098 = load ptr, ptr %26, align 8, !tbaa !5
  %1099 = load i32, ptr %42, align 4, !tbaa !9
  %1100 = sext i32 %1099 to i64
  %1101 = getelementptr inbounds %struct.complex, ptr %1098, i64 %1100
  %1102 = getelementptr inbounds %struct.complex, ptr %1101, i32 0, i32 0
  %1103 = load float, ptr %1102, align 4, !tbaa !15
  store float %1103, ptr %53, align 4, !tbaa !11
  %1104 = load float, ptr %53, align 4, !tbaa !11
  %1105 = fcmp oge float %1104, 0.000000e+00
  br i1 %1105, label %1106, label %1108

1106:                                             ; preds = %1095
  %1107 = load float, ptr %53, align 4, !tbaa !11
  br label %1111

1108:                                             ; preds = %1095
  %1109 = load float, ptr %53, align 4, !tbaa !11
  %1110 = fneg float %1109
  br label %1111

1111:                                             ; preds = %1108, %1106
  %1112 = phi float [ %1107, %1106 ], [ %1110, %1108 ]
  %1113 = load ptr, ptr %26, align 8, !tbaa !5
  %1114 = load i32, ptr %60, align 4, !tbaa !9
  %1115 = add nsw i32 %1114, 1
  %1116 = load i32, ptr %61, align 4, !tbaa !9
  %1117 = load i32, ptr %35, align 4, !tbaa !9
  %1118 = mul nsw i32 %1116, %1117
  %1119 = add nsw i32 %1115, %1118
  %1120 = sext i32 %1119 to i64
  %1121 = getelementptr inbounds %struct.complex, ptr %1113, i64 %1120
  %1122 = call <2 x float> @Cf(ptr noundef %1121)
  store <2 x float> %1122, ptr %87, align 4
  %1123 = getelementptr inbounds { float, float }, ptr %87, i32 0, i32 0
  %1124 = load float, ptr %1123, align 4
  %1125 = getelementptr inbounds { float, float }, ptr %87, i32 0, i32 1
  %1126 = load float, ptr %1125, align 4
  store float %1126, ptr %54, align 4, !tbaa !11
  %1127 = load float, ptr %54, align 4, !tbaa !11
  %1128 = fcmp oge float %1127, 0.000000e+00
  br i1 %1128, label %1129, label %1131

1129:                                             ; preds = %1111
  %1130 = load float, ptr %54, align 4, !tbaa !11
  br label %1134

1131:                                             ; preds = %1111
  %1132 = load float, ptr %54, align 4, !tbaa !11
  %1133 = fneg float %1132
  br label %1134

1134:                                             ; preds = %1131, %1129
  %1135 = phi float [ %1130, %1129 ], [ %1133, %1131 ]
  %1136 = fadd float %1112, %1135
  %1137 = call float @llvm.fmuladd.f32(float %1097, float %1136, float %1063)
  %1138 = load ptr, ptr %31, align 8, !tbaa !5
  %1139 = load i32, ptr %60, align 4, !tbaa !9
  %1140 = sext i32 %1139 to i64
  %1141 = getelementptr inbounds float, ptr %1138, i64 %1140
  store float %1137, ptr %1141, align 4, !tbaa !11
  br label %1142

1142:                                             ; preds = %1134
  %1143 = load i32, ptr %60, align 4, !tbaa !9
  %1144 = add nsw i32 %1143, 1
  store i32 %1144, ptr %60, align 4, !tbaa !9
  br label %675, !llvm.loop !18

1145:                                             ; preds = %675
  %1146 = load ptr, ptr %18, align 8, !tbaa !5
  %1147 = load i32, ptr %1146, align 4, !tbaa !9
  %1148 = load i32, ptr %61, align 4, !tbaa !9
  %1149 = load i32, ptr %33, align 4, !tbaa !9
  %1150 = mul nsw i32 %1148, %1149
  %1151 = add nsw i32 %1147, %1150
  store i32 %1151, ptr %38, align 4, !tbaa !9
  %1152 = load ptr, ptr %24, align 8, !tbaa !5
  %1153 = load i32, ptr %38, align 4, !tbaa !9
  %1154 = sext i32 %1153 to i64
  %1155 = getelementptr inbounds %struct.complex, ptr %1152, i64 %1154
  %1156 = getelementptr inbounds %struct.complex, ptr %1155, i32 0, i32 0
  %1157 = load float, ptr %1156, align 4, !tbaa !15
  %1158 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %1157, ptr %1158, align 4, !tbaa !15
  %1159 = load ptr, ptr %24, align 8, !tbaa !5
  %1160 = load i32, ptr %38, align 4, !tbaa !9
  %1161 = sext i32 %1160 to i64
  %1162 = getelementptr inbounds %struct.complex, ptr %1159, i64 %1161
  %1163 = getelementptr inbounds %struct.complex, ptr %1162, i32 0, i32 1
  %1164 = load float, ptr %1163, align 4, !tbaa !17
  %1165 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %1164, ptr %1165, align 4, !tbaa !17
  %1166 = load ptr, ptr %21, align 8, !tbaa !5
  %1167 = load ptr, ptr %18, align 8, !tbaa !5
  %1168 = load i32, ptr %1167, align 4, !tbaa !9
  %1169 = sub nsw i32 %1168, 1
  %1170 = sext i32 %1169 to i64
  %1171 = getelementptr inbounds %struct.complex, ptr %1166, i64 %1170
  %1172 = call <2 x float> @Cf(ptr noundef %1171)
  store <2 x float> %1172, ptr %88, align 4
  %1173 = getelementptr inbounds { float, float }, ptr %88, i32 0, i32 0
  %1174 = load float, ptr %1173, align 4
  %1175 = getelementptr inbounds { float, float }, ptr %88, i32 0, i32 1
  %1176 = load float, ptr %1175, align 4
  %1177 = fneg float %1176
  %1178 = call ptr @_pCf(ptr noundef %56)
  %1179 = getelementptr inbounds { float, float }, ptr %1178, i32 0, i32 0
  %1180 = getelementptr inbounds { float, float }, ptr %1178, i32 0, i32 1
  store float %1174, ptr %1179, align 4
  store float %1177, ptr %1180, align 4
  %1181 = load ptr, ptr %18, align 8, !tbaa !5
  %1182 = load i32, ptr %1181, align 4, !tbaa !9
  %1183 = sub nsw i32 %1182, 1
  %1184 = load i32, ptr %61, align 4, !tbaa !9
  %1185 = load i32, ptr %35, align 4, !tbaa !9
  %1186 = mul nsw i32 %1184, %1185
  %1187 = add nsw i32 %1183, %1186
  store i32 %1187, ptr %38, align 4, !tbaa !9
  %1188 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1189 = load float, ptr %1188, align 4, !tbaa !15
  %1190 = load ptr, ptr %26, align 8, !tbaa !5
  %1191 = load i32, ptr %38, align 4, !tbaa !9
  %1192 = sext i32 %1191 to i64
  %1193 = getelementptr inbounds %struct.complex, ptr %1190, i64 %1192
  %1194 = getelementptr inbounds %struct.complex, ptr %1193, i32 0, i32 0
  %1195 = load float, ptr %1194, align 4, !tbaa !15
  %1196 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1197 = load float, ptr %1196, align 4, !tbaa !17
  %1198 = load ptr, ptr %26, align 8, !tbaa !5
  %1199 = load i32, ptr %38, align 4, !tbaa !9
  %1200 = sext i32 %1199 to i64
  %1201 = getelementptr inbounds %struct.complex, ptr %1198, i64 %1200
  %1202 = getelementptr inbounds %struct.complex, ptr %1201, i32 0, i32 1
  %1203 = load float, ptr %1202, align 4, !tbaa !17
  %1204 = fmul float %1197, %1203
  %1205 = fneg float %1204
  %1206 = call float @llvm.fmuladd.f32(float %1189, float %1195, float %1205)
  %1207 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1206, ptr %1207, align 4, !tbaa !15
  %1208 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1209 = load float, ptr %1208, align 4, !tbaa !15
  %1210 = load ptr, ptr %26, align 8, !tbaa !5
  %1211 = load i32, ptr %38, align 4, !tbaa !9
  %1212 = sext i32 %1211 to i64
  %1213 = getelementptr inbounds %struct.complex, ptr %1210, i64 %1212
  %1214 = getelementptr inbounds %struct.complex, ptr %1213, i32 0, i32 1
  %1215 = load float, ptr %1214, align 4, !tbaa !17
  %1216 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1217 = load float, ptr %1216, align 4, !tbaa !17
  %1218 = load ptr, ptr %26, align 8, !tbaa !5
  %1219 = load i32, ptr %38, align 4, !tbaa !9
  %1220 = sext i32 %1219 to i64
  %1221 = getelementptr inbounds %struct.complex, ptr %1218, i64 %1220
  %1222 = getelementptr inbounds %struct.complex, ptr %1221, i32 0, i32 0
  %1223 = load float, ptr %1222, align 4, !tbaa !15
  %1224 = fmul float %1217, %1223
  %1225 = call float @llvm.fmuladd.f32(float %1209, float %1215, float %1224)
  %1226 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1225, ptr %1226, align 4, !tbaa !17
  %1227 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1228 = load float, ptr %1227, align 4, !tbaa !15
  %1229 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  store float %1228, ptr %1229, align 4, !tbaa !15
  %1230 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1231 = load float, ptr %1230, align 4, !tbaa !17
  %1232 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  store float %1231, ptr %1232, align 4, !tbaa !17
  %1233 = load ptr, ptr %18, align 8, !tbaa !5
  %1234 = load i32, ptr %1233, align 4, !tbaa !9
  store i32 %1234, ptr %38, align 4, !tbaa !9
  %1235 = load ptr, ptr %18, align 8, !tbaa !5
  %1236 = load i32, ptr %1235, align 4, !tbaa !9
  %1237 = load i32, ptr %61, align 4, !tbaa !9
  %1238 = load i32, ptr %35, align 4, !tbaa !9
  %1239 = mul nsw i32 %1237, %1238
  %1240 = add nsw i32 %1236, %1239
  store i32 %1240, ptr %39, align 4, !tbaa !9
  %1241 = load ptr, ptr %20, align 8, !tbaa !5
  %1242 = load i32, ptr %38, align 4, !tbaa !9
  %1243 = sext i32 %1242 to i64
  %1244 = getelementptr inbounds float, ptr %1241, i64 %1243
  %1245 = load float, ptr %1244, align 4, !tbaa !11
  %1246 = load ptr, ptr %26, align 8, !tbaa !5
  %1247 = load i32, ptr %39, align 4, !tbaa !9
  %1248 = sext i32 %1247 to i64
  %1249 = getelementptr inbounds %struct.complex, ptr %1246, i64 %1248
  %1250 = getelementptr inbounds %struct.complex, ptr %1249, i32 0, i32 0
  %1251 = load float, ptr %1250, align 4, !tbaa !15
  %1252 = fmul float %1245, %1251
  %1253 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1252, ptr %1253, align 4, !tbaa !15
  %1254 = load ptr, ptr %20, align 8, !tbaa !5
  %1255 = load i32, ptr %38, align 4, !tbaa !9
  %1256 = sext i32 %1255 to i64
  %1257 = getelementptr inbounds float, ptr %1254, i64 %1256
  %1258 = load float, ptr %1257, align 4, !tbaa !11
  %1259 = load ptr, ptr %26, align 8, !tbaa !5
  %1260 = load i32, ptr %39, align 4, !tbaa !9
  %1261 = sext i32 %1260 to i64
  %1262 = getelementptr inbounds %struct.complex, ptr %1259, i64 %1261
  %1263 = getelementptr inbounds %struct.complex, ptr %1262, i32 0, i32 1
  %1264 = load float, ptr %1263, align 4, !tbaa !17
  %1265 = fmul float %1258, %1264
  %1266 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1265, ptr %1266, align 4, !tbaa !17
  %1267 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1268 = load float, ptr %1267, align 4, !tbaa !15
  %1269 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %1268, ptr %1269, align 4, !tbaa !15
  %1270 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1271 = load float, ptr %1270, align 4, !tbaa !17
  %1272 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %1271, ptr %1272, align 4, !tbaa !17
  %1273 = load ptr, ptr %18, align 8, !tbaa !5
  %1274 = load i32, ptr %1273, align 4, !tbaa !9
  store i32 %1274, ptr %38, align 4, !tbaa !9
  %1275 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1276 = load float, ptr %1275, align 4, !tbaa !15
  %1277 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  %1278 = load float, ptr %1277, align 4, !tbaa !15
  %1279 = fsub float %1276, %1278
  %1280 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %1279, ptr %1280, align 4, !tbaa !15
  %1281 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %1282 = load float, ptr %1281, align 4, !tbaa !17
  %1283 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  %1284 = load float, ptr %1283, align 4, !tbaa !17
  %1285 = fsub float %1282, %1284
  %1286 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %1285, ptr %1286, align 4, !tbaa !17
  %1287 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1288 = load float, ptr %1287, align 4, !tbaa !15
  %1289 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1290 = load float, ptr %1289, align 4, !tbaa !15
  %1291 = fsub float %1288, %1290
  %1292 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1291, ptr %1292, align 4, !tbaa !15
  %1293 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1294 = load float, ptr %1293, align 4, !tbaa !17
  %1295 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %1296 = load float, ptr %1295, align 4, !tbaa !17
  %1297 = fsub float %1294, %1296
  %1298 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1297, ptr %1298, align 4, !tbaa !17
  %1299 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1300 = load float, ptr %1299, align 4, !tbaa !15
  %1301 = load ptr, ptr %30, align 8, !tbaa !5
  %1302 = load i32, ptr %38, align 4, !tbaa !9
  %1303 = sext i32 %1302 to i64
  %1304 = getelementptr inbounds %struct.complex, ptr %1301, i64 %1303
  %1305 = getelementptr inbounds %struct.complex, ptr %1304, i32 0, i32 0
  store float %1300, ptr %1305, align 4, !tbaa !15
  %1306 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1307 = load float, ptr %1306, align 4, !tbaa !17
  %1308 = load ptr, ptr %30, align 8, !tbaa !5
  %1309 = load i32, ptr %38, align 4, !tbaa !9
  %1310 = sext i32 %1309 to i64
  %1311 = getelementptr inbounds %struct.complex, ptr %1308, i64 %1310
  %1312 = getelementptr inbounds %struct.complex, ptr %1311, i32 0, i32 1
  store float %1307, ptr %1312, align 4, !tbaa !17
  %1313 = load ptr, ptr %18, align 8, !tbaa !5
  %1314 = load i32, ptr %1313, align 4, !tbaa !9
  %1315 = sub nsw i32 %1314, 1
  store i32 %1315, ptr %38, align 4, !tbaa !9
  %1316 = load ptr, ptr %18, align 8, !tbaa !5
  %1317 = load i32, ptr %1316, align 4, !tbaa !9
  %1318 = sub nsw i32 %1317, 1
  %1319 = load i32, ptr %61, align 4, !tbaa !9
  %1320 = load i32, ptr %35, align 4, !tbaa !9
  %1321 = mul nsw i32 %1319, %1320
  %1322 = add nsw i32 %1318, %1321
  store i32 %1322, ptr %39, align 4, !tbaa !9
  %1323 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1324 = load float, ptr %1323, align 4, !tbaa !15
  store float %1324, ptr %43, align 4, !tbaa !11
  %1325 = load float, ptr %43, align 4, !tbaa !11
  %1326 = fcmp oge float %1325, 0.000000e+00
  br i1 %1326, label %1327, label %1329

1327:                                             ; preds = %1145
  %1328 = load float, ptr %43, align 4, !tbaa !11
  br label %1332

1329:                                             ; preds = %1145
  %1330 = load float, ptr %43, align 4, !tbaa !11
  %1331 = fneg float %1330
  br label %1332

1332:                                             ; preds = %1329, %1327
  %1333 = phi float [ %1328, %1327 ], [ %1331, %1329 ]
  %1334 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %1334, ptr %89, align 4
  %1335 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 0
  %1336 = load float, ptr %1335, align 4
  %1337 = getelementptr inbounds { float, float }, ptr %89, i32 0, i32 1
  %1338 = load float, ptr %1337, align 4
  store float %1338, ptr %44, align 4, !tbaa !11
  %1339 = load float, ptr %44, align 4, !tbaa !11
  %1340 = fcmp oge float %1339, 0.000000e+00
  br i1 %1340, label %1341, label %1343

1341:                                             ; preds = %1332
  %1342 = load float, ptr %44, align 4, !tbaa !11
  br label %1346

1343:                                             ; preds = %1332
  %1344 = load float, ptr %44, align 4, !tbaa !11
  %1345 = fneg float %1344
  br label %1346

1346:                                             ; preds = %1343, %1341
  %1347 = phi float [ %1342, %1341 ], [ %1345, %1343 ]
  %1348 = fadd float %1333, %1347
  %1349 = load ptr, ptr %21, align 8, !tbaa !5
  %1350 = load i32, ptr %38, align 4, !tbaa !9
  %1351 = sext i32 %1350 to i64
  %1352 = getelementptr inbounds %struct.complex, ptr %1349, i64 %1351
  %1353 = getelementptr inbounds %struct.complex, ptr %1352, i32 0, i32 0
  %1354 = load float, ptr %1353, align 4, !tbaa !15
  store float %1354, ptr %45, align 4, !tbaa !11
  %1355 = load float, ptr %45, align 4, !tbaa !11
  %1356 = fcmp oge float %1355, 0.000000e+00
  br i1 %1356, label %1357, label %1359

1357:                                             ; preds = %1346
  %1358 = load float, ptr %45, align 4, !tbaa !11
  br label %1362

1359:                                             ; preds = %1346
  %1360 = load float, ptr %45, align 4, !tbaa !11
  %1361 = fneg float %1360
  br label %1362

1362:                                             ; preds = %1359, %1357
  %1363 = phi float [ %1358, %1357 ], [ %1361, %1359 ]
  %1364 = load ptr, ptr %21, align 8, !tbaa !5
  %1365 = load ptr, ptr %18, align 8, !tbaa !5
  %1366 = load i32, ptr %1365, align 4, !tbaa !9
  %1367 = sub nsw i32 %1366, 1
  %1368 = sext i32 %1367 to i64
  %1369 = getelementptr inbounds %struct.complex, ptr %1364, i64 %1368
  %1370 = call <2 x float> @Cf(ptr noundef %1369)
  store <2 x float> %1370, ptr %90, align 4
  %1371 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 0
  %1372 = load float, ptr %1371, align 4
  %1373 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 1
  %1374 = load float, ptr %1373, align 4
  store float %1374, ptr %46, align 4, !tbaa !11
  %1375 = load float, ptr %46, align 4, !tbaa !11
  %1376 = fcmp oge float %1375, 0.000000e+00
  br i1 %1376, label %1377, label %1379

1377:                                             ; preds = %1362
  %1378 = load float, ptr %46, align 4, !tbaa !11
  br label %1382

1379:                                             ; preds = %1362
  %1380 = load float, ptr %46, align 4, !tbaa !11
  %1381 = fneg float %1380
  br label %1382

1382:                                             ; preds = %1379, %1377
  %1383 = phi float [ %1378, %1377 ], [ %1381, %1379 ]
  %1384 = fadd float %1363, %1383
  %1385 = load ptr, ptr %26, align 8, !tbaa !5
  %1386 = load i32, ptr %39, align 4, !tbaa !9
  %1387 = sext i32 %1386 to i64
  %1388 = getelementptr inbounds %struct.complex, ptr %1385, i64 %1387
  %1389 = getelementptr inbounds %struct.complex, ptr %1388, i32 0, i32 0
  %1390 = load float, ptr %1389, align 4, !tbaa !15
  store float %1390, ptr %47, align 4, !tbaa !11
  %1391 = load float, ptr %47, align 4, !tbaa !11
  %1392 = fcmp oge float %1391, 0.000000e+00
  br i1 %1392, label %1393, label %1395

1393:                                             ; preds = %1382
  %1394 = load float, ptr %47, align 4, !tbaa !11
  br label %1398

1395:                                             ; preds = %1382
  %1396 = load float, ptr %47, align 4, !tbaa !11
  %1397 = fneg float %1396
  br label %1398

1398:                                             ; preds = %1395, %1393
  %1399 = phi float [ %1394, %1393 ], [ %1397, %1395 ]
  %1400 = load ptr, ptr %26, align 8, !tbaa !5
  %1401 = load ptr, ptr %18, align 8, !tbaa !5
  %1402 = load i32, ptr %1401, align 4, !tbaa !9
  %1403 = sub nsw i32 %1402, 1
  %1404 = load i32, ptr %61, align 4, !tbaa !9
  %1405 = load i32, ptr %35, align 4, !tbaa !9
  %1406 = mul nsw i32 %1404, %1405
  %1407 = add nsw i32 %1403, %1406
  %1408 = sext i32 %1407 to i64
  %1409 = getelementptr inbounds %struct.complex, ptr %1400, i64 %1408
  %1410 = call <2 x float> @Cf(ptr noundef %1409)
  store <2 x float> %1410, ptr %91, align 4
  %1411 = getelementptr inbounds { float, float }, ptr %91, i32 0, i32 0
  %1412 = load float, ptr %1411, align 4
  %1413 = getelementptr inbounds { float, float }, ptr %91, i32 0, i32 1
  %1414 = load float, ptr %1413, align 4
  store float %1414, ptr %48, align 4, !tbaa !11
  %1415 = load float, ptr %48, align 4, !tbaa !11
  %1416 = fcmp oge float %1415, 0.000000e+00
  br i1 %1416, label %1417, label %1419

1417:                                             ; preds = %1398
  %1418 = load float, ptr %48, align 4, !tbaa !11
  br label %1422

1419:                                             ; preds = %1398
  %1420 = load float, ptr %48, align 4, !tbaa !11
  %1421 = fneg float %1420
  br label %1422

1422:                                             ; preds = %1419, %1417
  %1423 = phi float [ %1418, %1417 ], [ %1421, %1419 ]
  %1424 = fadd float %1399, %1423
  %1425 = call float @llvm.fmuladd.f32(float %1384, float %1424, float %1348)
  %1426 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1427 = load float, ptr %1426, align 4, !tbaa !15
  store float %1427, ptr %49, align 4, !tbaa !11
  %1428 = load float, ptr %49, align 4, !tbaa !11
  %1429 = fcmp oge float %1428, 0.000000e+00
  br i1 %1429, label %1430, label %1432

1430:                                             ; preds = %1422
  %1431 = load float, ptr %49, align 4, !tbaa !11
  br label %1435

1432:                                             ; preds = %1422
  %1433 = load float, ptr %49, align 4, !tbaa !11
  %1434 = fneg float %1433
  br label %1435

1435:                                             ; preds = %1432, %1430
  %1436 = phi float [ %1431, %1430 ], [ %1434, %1432 ]
  %1437 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %1437, ptr %92, align 4
  %1438 = getelementptr inbounds { float, float }, ptr %92, i32 0, i32 0
  %1439 = load float, ptr %1438, align 4
  %1440 = getelementptr inbounds { float, float }, ptr %92, i32 0, i32 1
  %1441 = load float, ptr %1440, align 4
  store float %1441, ptr %50, align 4, !tbaa !11
  %1442 = load float, ptr %50, align 4, !tbaa !11
  %1443 = fcmp oge float %1442, 0.000000e+00
  br i1 %1443, label %1444, label %1446

1444:                                             ; preds = %1435
  %1445 = load float, ptr %50, align 4, !tbaa !11
  br label %1449

1446:                                             ; preds = %1435
  %1447 = load float, ptr %50, align 4, !tbaa !11
  %1448 = fneg float %1447
  br label %1449

1449:                                             ; preds = %1446, %1444
  %1450 = phi float [ %1445, %1444 ], [ %1448, %1446 ]
  %1451 = fadd float %1436, %1450
  %1452 = fadd float %1425, %1451
  %1453 = load ptr, ptr %31, align 8, !tbaa !5
  %1454 = load ptr, ptr %18, align 8, !tbaa !5
  %1455 = load i32, ptr %1454, align 4, !tbaa !9
  %1456 = sext i32 %1455 to i64
  %1457 = getelementptr inbounds float, ptr %1453, i64 %1456
  store float %1452, ptr %1457, align 4, !tbaa !11
  br label %1458

1458:                                             ; preds = %1449, %397
  br label %2654

1459:                                             ; preds = %268
  %1460 = load ptr, ptr %18, align 8, !tbaa !5
  %1461 = load i32, ptr %1460, align 4, !tbaa !9
  %1462 = icmp eq i32 %1461, 1
  br i1 %1462, label %1463, label %1591

1463:                                             ; preds = %1459
  %1464 = load i32, ptr %61, align 4, !tbaa !9
  %1465 = load i32, ptr %33, align 4, !tbaa !9
  %1466 = mul nsw i32 %1464, %1465
  %1467 = add nsw i32 %1466, 1
  store i32 %1467, ptr %38, align 4, !tbaa !9
  %1468 = load ptr, ptr %24, align 8, !tbaa !5
  %1469 = load i32, ptr %38, align 4, !tbaa !9
  %1470 = sext i32 %1469 to i64
  %1471 = getelementptr inbounds %struct.complex, ptr %1468, i64 %1470
  %1472 = getelementptr inbounds %struct.complex, ptr %1471, i32 0, i32 0
  %1473 = load float, ptr %1472, align 4, !tbaa !15
  %1474 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %1473, ptr %1474, align 4, !tbaa !15
  %1475 = load ptr, ptr %24, align 8, !tbaa !5
  %1476 = load i32, ptr %38, align 4, !tbaa !9
  %1477 = sext i32 %1476 to i64
  %1478 = getelementptr inbounds %struct.complex, ptr %1475, i64 %1477
  %1479 = getelementptr inbounds %struct.complex, ptr %1478, i32 0, i32 1
  %1480 = load float, ptr %1479, align 4, !tbaa !17
  %1481 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %1480, ptr %1481, align 4, !tbaa !17
  %1482 = load i32, ptr %61, align 4, !tbaa !9
  %1483 = load i32, ptr %35, align 4, !tbaa !9
  %1484 = mul nsw i32 %1482, %1483
  %1485 = add nsw i32 %1484, 1
  store i32 %1485, ptr %38, align 4, !tbaa !9
  %1486 = load ptr, ptr %20, align 8, !tbaa !5
  %1487 = getelementptr inbounds float, ptr %1486, i64 1
  %1488 = load float, ptr %1487, align 4, !tbaa !11
  %1489 = load ptr, ptr %26, align 8, !tbaa !5
  %1490 = load i32, ptr %38, align 4, !tbaa !9
  %1491 = sext i32 %1490 to i64
  %1492 = getelementptr inbounds %struct.complex, ptr %1489, i64 %1491
  %1493 = getelementptr inbounds %struct.complex, ptr %1492, i32 0, i32 0
  %1494 = load float, ptr %1493, align 4, !tbaa !15
  %1495 = fmul float %1488, %1494
  %1496 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1495, ptr %1496, align 4, !tbaa !15
  %1497 = load ptr, ptr %20, align 8, !tbaa !5
  %1498 = getelementptr inbounds float, ptr %1497, i64 1
  %1499 = load float, ptr %1498, align 4, !tbaa !11
  %1500 = load ptr, ptr %26, align 8, !tbaa !5
  %1501 = load i32, ptr %38, align 4, !tbaa !9
  %1502 = sext i32 %1501 to i64
  %1503 = getelementptr inbounds %struct.complex, ptr %1500, i64 %1502
  %1504 = getelementptr inbounds %struct.complex, ptr %1503, i32 0, i32 1
  %1505 = load float, ptr %1504, align 4, !tbaa !17
  %1506 = fmul float %1499, %1505
  %1507 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1506, ptr %1507, align 4, !tbaa !17
  %1508 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1509 = load float, ptr %1508, align 4, !tbaa !15
  %1510 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %1509, ptr %1510, align 4, !tbaa !15
  %1511 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1512 = load float, ptr %1511, align 4, !tbaa !17
  %1513 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %1512, ptr %1513, align 4, !tbaa !17
  %1514 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1515 = load float, ptr %1514, align 4, !tbaa !15
  %1516 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1517 = load float, ptr %1516, align 4, !tbaa !15
  %1518 = fsub float %1515, %1517
  %1519 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1518, ptr %1519, align 4, !tbaa !15
  %1520 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %1521 = load float, ptr %1520, align 4, !tbaa !17
  %1522 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %1523 = load float, ptr %1522, align 4, !tbaa !17
  %1524 = fsub float %1521, %1523
  %1525 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1524, ptr %1525, align 4, !tbaa !17
  %1526 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1527 = load float, ptr %1526, align 4, !tbaa !15
  %1528 = load ptr, ptr %30, align 8, !tbaa !5
  %1529 = getelementptr inbounds %struct.complex, ptr %1528, i64 1
  %1530 = getelementptr inbounds %struct.complex, ptr %1529, i32 0, i32 0
  store float %1527, ptr %1530, align 4, !tbaa !15
  %1531 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1532 = load float, ptr %1531, align 4, !tbaa !17
  %1533 = load ptr, ptr %30, align 8, !tbaa !5
  %1534 = getelementptr inbounds %struct.complex, ptr %1533, i64 1
  %1535 = getelementptr inbounds %struct.complex, ptr %1534, i32 0, i32 1
  store float %1532, ptr %1535, align 4, !tbaa !17
  %1536 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1537 = load float, ptr %1536, align 4, !tbaa !15
  store float %1537, ptr %43, align 4, !tbaa !11
  %1538 = load float, ptr %43, align 4, !tbaa !11
  %1539 = fcmp oge float %1538, 0.000000e+00
  br i1 %1539, label %1540, label %1542

1540:                                             ; preds = %1463
  %1541 = load float, ptr %43, align 4, !tbaa !11
  br label %1545

1542:                                             ; preds = %1463
  %1543 = load float, ptr %43, align 4, !tbaa !11
  %1544 = fneg float %1543
  br label %1545

1545:                                             ; preds = %1542, %1540
  %1546 = phi float [ %1541, %1540 ], [ %1544, %1542 ]
  %1547 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %1547, ptr %93, align 4
  %1548 = getelementptr inbounds { float, float }, ptr %93, i32 0, i32 0
  %1549 = load float, ptr %1548, align 4
  %1550 = getelementptr inbounds { float, float }, ptr %93, i32 0, i32 1
  %1551 = load float, ptr %1550, align 4
  store float %1551, ptr %44, align 4, !tbaa !11
  %1552 = load float, ptr %44, align 4, !tbaa !11
  %1553 = fcmp oge float %1552, 0.000000e+00
  br i1 %1553, label %1554, label %1556

1554:                                             ; preds = %1545
  %1555 = load float, ptr %44, align 4, !tbaa !11
  br label %1559

1556:                                             ; preds = %1545
  %1557 = load float, ptr %44, align 4, !tbaa !11
  %1558 = fneg float %1557
  br label %1559

1559:                                             ; preds = %1556, %1554
  %1560 = phi float [ %1555, %1554 ], [ %1558, %1556 ]
  %1561 = fadd float %1546, %1560
  %1562 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1563 = load float, ptr %1562, align 4, !tbaa !15
  store float %1563, ptr %45, align 4, !tbaa !11
  %1564 = load float, ptr %45, align 4, !tbaa !11
  %1565 = fcmp oge float %1564, 0.000000e+00
  br i1 %1565, label %1566, label %1568

1566:                                             ; preds = %1559
  %1567 = load float, ptr %45, align 4, !tbaa !11
  br label %1571

1568:                                             ; preds = %1559
  %1569 = load float, ptr %45, align 4, !tbaa !11
  %1570 = fneg float %1569
  br label %1571

1571:                                             ; preds = %1568, %1566
  %1572 = phi float [ %1567, %1566 ], [ %1570, %1568 ]
  %1573 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %1573, ptr %94, align 4
  %1574 = getelementptr inbounds { float, float }, ptr %94, i32 0, i32 0
  %1575 = load float, ptr %1574, align 4
  %1576 = getelementptr inbounds { float, float }, ptr %94, i32 0, i32 1
  %1577 = load float, ptr %1576, align 4
  store float %1577, ptr %46, align 4, !tbaa !11
  %1578 = load float, ptr %46, align 4, !tbaa !11
  %1579 = fcmp oge float %1578, 0.000000e+00
  br i1 %1579, label %1580, label %1582

1580:                                             ; preds = %1571
  %1581 = load float, ptr %46, align 4, !tbaa !11
  br label %1585

1582:                                             ; preds = %1571
  %1583 = load float, ptr %46, align 4, !tbaa !11
  %1584 = fneg float %1583
  br label %1585

1585:                                             ; preds = %1582, %1580
  %1586 = phi float [ %1581, %1580 ], [ %1584, %1582 ]
  %1587 = fadd float %1572, %1586
  %1588 = fadd float %1561, %1587
  %1589 = load ptr, ptr %31, align 8, !tbaa !5
  %1590 = getelementptr inbounds float, ptr %1589, i64 1
  store float %1588, ptr %1590, align 4, !tbaa !11
  br label %2653

1591:                                             ; preds = %1459
  %1592 = load i32, ptr %61, align 4, !tbaa !9
  %1593 = load i32, ptr %33, align 4, !tbaa !9
  %1594 = mul nsw i32 %1592, %1593
  %1595 = add nsw i32 %1594, 1
  store i32 %1595, ptr %38, align 4, !tbaa !9
  %1596 = load ptr, ptr %24, align 8, !tbaa !5
  %1597 = load i32, ptr %38, align 4, !tbaa !9
  %1598 = sext i32 %1597 to i64
  %1599 = getelementptr inbounds %struct.complex, ptr %1596, i64 %1598
  %1600 = getelementptr inbounds %struct.complex, ptr %1599, i32 0, i32 0
  %1601 = load float, ptr %1600, align 4, !tbaa !15
  %1602 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %1601, ptr %1602, align 4, !tbaa !15
  %1603 = load ptr, ptr %24, align 8, !tbaa !5
  %1604 = load i32, ptr %38, align 4, !tbaa !9
  %1605 = sext i32 %1604 to i64
  %1606 = getelementptr inbounds %struct.complex, ptr %1603, i64 %1605
  %1607 = getelementptr inbounds %struct.complex, ptr %1606, i32 0, i32 1
  %1608 = load float, ptr %1607, align 4, !tbaa !17
  %1609 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %1608, ptr %1609, align 4, !tbaa !17
  %1610 = load i32, ptr %61, align 4, !tbaa !9
  %1611 = load i32, ptr %35, align 4, !tbaa !9
  %1612 = mul nsw i32 %1610, %1611
  %1613 = add nsw i32 %1612, 1
  store i32 %1613, ptr %38, align 4, !tbaa !9
  %1614 = load ptr, ptr %20, align 8, !tbaa !5
  %1615 = getelementptr inbounds float, ptr %1614, i64 1
  %1616 = load float, ptr %1615, align 4, !tbaa !11
  %1617 = load ptr, ptr %26, align 8, !tbaa !5
  %1618 = load i32, ptr %38, align 4, !tbaa !9
  %1619 = sext i32 %1618 to i64
  %1620 = getelementptr inbounds %struct.complex, ptr %1617, i64 %1619
  %1621 = getelementptr inbounds %struct.complex, ptr %1620, i32 0, i32 0
  %1622 = load float, ptr %1621, align 4, !tbaa !15
  %1623 = fmul float %1616, %1622
  %1624 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1623, ptr %1624, align 4, !tbaa !15
  %1625 = load ptr, ptr %20, align 8, !tbaa !5
  %1626 = getelementptr inbounds float, ptr %1625, i64 1
  %1627 = load float, ptr %1626, align 4, !tbaa !11
  %1628 = load ptr, ptr %26, align 8, !tbaa !5
  %1629 = load i32, ptr %38, align 4, !tbaa !9
  %1630 = sext i32 %1629 to i64
  %1631 = getelementptr inbounds %struct.complex, ptr %1628, i64 %1630
  %1632 = getelementptr inbounds %struct.complex, ptr %1631, i32 0, i32 1
  %1633 = load float, ptr %1632, align 4, !tbaa !17
  %1634 = fmul float %1627, %1633
  %1635 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1634, ptr %1635, align 4, !tbaa !17
  %1636 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1637 = load float, ptr %1636, align 4, !tbaa !15
  %1638 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %1637, ptr %1638, align 4, !tbaa !15
  %1639 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1640 = load float, ptr %1639, align 4, !tbaa !17
  %1641 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %1640, ptr %1641, align 4, !tbaa !17
  %1642 = load ptr, ptr %21, align 8, !tbaa !5
  %1643 = getelementptr inbounds %struct.complex, ptr %1642, i64 1
  %1644 = call <2 x float> @Cf(ptr noundef %1643)
  store <2 x float> %1644, ptr %95, align 4
  %1645 = getelementptr inbounds { float, float }, ptr %95, i32 0, i32 0
  %1646 = load float, ptr %1645, align 4
  %1647 = getelementptr inbounds { float, float }, ptr %95, i32 0, i32 1
  %1648 = load float, ptr %1647, align 4
  %1649 = fneg float %1648
  %1650 = call ptr @_pCf(ptr noundef %56)
  %1651 = getelementptr inbounds { float, float }, ptr %1650, i32 0, i32 0
  %1652 = getelementptr inbounds { float, float }, ptr %1650, i32 0, i32 1
  store float %1646, ptr %1651, align 4
  store float %1649, ptr %1652, align 4
  %1653 = load i32, ptr %61, align 4, !tbaa !9
  %1654 = load i32, ptr %35, align 4, !tbaa !9
  %1655 = mul nsw i32 %1653, %1654
  %1656 = add nsw i32 %1655, 2
  store i32 %1656, ptr %38, align 4, !tbaa !9
  %1657 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1658 = load float, ptr %1657, align 4, !tbaa !15
  %1659 = load ptr, ptr %26, align 8, !tbaa !5
  %1660 = load i32, ptr %38, align 4, !tbaa !9
  %1661 = sext i32 %1660 to i64
  %1662 = getelementptr inbounds %struct.complex, ptr %1659, i64 %1661
  %1663 = getelementptr inbounds %struct.complex, ptr %1662, i32 0, i32 0
  %1664 = load float, ptr %1663, align 4, !tbaa !15
  %1665 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1666 = load float, ptr %1665, align 4, !tbaa !17
  %1667 = load ptr, ptr %26, align 8, !tbaa !5
  %1668 = load i32, ptr %38, align 4, !tbaa !9
  %1669 = sext i32 %1668 to i64
  %1670 = getelementptr inbounds %struct.complex, ptr %1667, i64 %1669
  %1671 = getelementptr inbounds %struct.complex, ptr %1670, i32 0, i32 1
  %1672 = load float, ptr %1671, align 4, !tbaa !17
  %1673 = fmul float %1666, %1672
  %1674 = fneg float %1673
  %1675 = call float @llvm.fmuladd.f32(float %1658, float %1664, float %1674)
  %1676 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1675, ptr %1676, align 4, !tbaa !15
  %1677 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1678 = load float, ptr %1677, align 4, !tbaa !15
  %1679 = load ptr, ptr %26, align 8, !tbaa !5
  %1680 = load i32, ptr %38, align 4, !tbaa !9
  %1681 = sext i32 %1680 to i64
  %1682 = getelementptr inbounds %struct.complex, ptr %1679, i64 %1681
  %1683 = getelementptr inbounds %struct.complex, ptr %1682, i32 0, i32 1
  %1684 = load float, ptr %1683, align 4, !tbaa !17
  %1685 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1686 = load float, ptr %1685, align 4, !tbaa !17
  %1687 = load ptr, ptr %26, align 8, !tbaa !5
  %1688 = load i32, ptr %38, align 4, !tbaa !9
  %1689 = sext i32 %1688 to i64
  %1690 = getelementptr inbounds %struct.complex, ptr %1687, i64 %1689
  %1691 = getelementptr inbounds %struct.complex, ptr %1690, i32 0, i32 0
  %1692 = load float, ptr %1691, align 4, !tbaa !15
  %1693 = fmul float %1686, %1692
  %1694 = call float @llvm.fmuladd.f32(float %1678, float %1684, float %1693)
  %1695 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1694, ptr %1695, align 4, !tbaa !17
  %1696 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1697 = load float, ptr %1696, align 4, !tbaa !15
  %1698 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  store float %1697, ptr %1698, align 4, !tbaa !15
  %1699 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1700 = load float, ptr %1699, align 4, !tbaa !17
  %1701 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  store float %1700, ptr %1701, align 4, !tbaa !17
  %1702 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1703 = load float, ptr %1702, align 4, !tbaa !15
  %1704 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1705 = load float, ptr %1704, align 4, !tbaa !15
  %1706 = fsub float %1703, %1705
  %1707 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %1706, ptr %1707, align 4, !tbaa !15
  %1708 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %1709 = load float, ptr %1708, align 4, !tbaa !17
  %1710 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %1711 = load float, ptr %1710, align 4, !tbaa !17
  %1712 = fsub float %1709, %1711
  %1713 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %1712, ptr %1713, align 4, !tbaa !17
  %1714 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %1715 = load float, ptr %1714, align 4, !tbaa !15
  %1716 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  %1717 = load float, ptr %1716, align 4, !tbaa !15
  %1718 = fsub float %1715, %1717
  %1719 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1718, ptr %1719, align 4, !tbaa !15
  %1720 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %1721 = load float, ptr %1720, align 4, !tbaa !17
  %1722 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  %1723 = load float, ptr %1722, align 4, !tbaa !17
  %1724 = fsub float %1721, %1723
  %1725 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1724, ptr %1725, align 4, !tbaa !17
  %1726 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1727 = load float, ptr %1726, align 4, !tbaa !15
  %1728 = load ptr, ptr %30, align 8, !tbaa !5
  %1729 = getelementptr inbounds %struct.complex, ptr %1728, i64 1
  %1730 = getelementptr inbounds %struct.complex, ptr %1729, i32 0, i32 0
  store float %1727, ptr %1730, align 4, !tbaa !15
  %1731 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1732 = load float, ptr %1731, align 4, !tbaa !17
  %1733 = load ptr, ptr %30, align 8, !tbaa !5
  %1734 = getelementptr inbounds %struct.complex, ptr %1733, i64 1
  %1735 = getelementptr inbounds %struct.complex, ptr %1734, i32 0, i32 1
  store float %1732, ptr %1735, align 4, !tbaa !17
  %1736 = load i32, ptr %61, align 4, !tbaa !9
  %1737 = load i32, ptr %35, align 4, !tbaa !9
  %1738 = mul nsw i32 %1736, %1737
  %1739 = add nsw i32 %1738, 2
  store i32 %1739, ptr %38, align 4, !tbaa !9
  %1740 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %1741 = load float, ptr %1740, align 4, !tbaa !15
  store float %1741, ptr %43, align 4, !tbaa !11
  %1742 = load float, ptr %43, align 4, !tbaa !11
  %1743 = fcmp oge float %1742, 0.000000e+00
  br i1 %1743, label %1744, label %1746

1744:                                             ; preds = %1591
  %1745 = load float, ptr %43, align 4, !tbaa !11
  br label %1749

1746:                                             ; preds = %1591
  %1747 = load float, ptr %43, align 4, !tbaa !11
  %1748 = fneg float %1747
  br label %1749

1749:                                             ; preds = %1746, %1744
  %1750 = phi float [ %1745, %1744 ], [ %1748, %1746 ]
  %1751 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %1751, ptr %96, align 4
  %1752 = getelementptr inbounds { float, float }, ptr %96, i32 0, i32 0
  %1753 = load float, ptr %1752, align 4
  %1754 = getelementptr inbounds { float, float }, ptr %96, i32 0, i32 1
  %1755 = load float, ptr %1754, align 4
  store float %1755, ptr %44, align 4, !tbaa !11
  %1756 = load float, ptr %44, align 4, !tbaa !11
  %1757 = fcmp oge float %1756, 0.000000e+00
  br i1 %1757, label %1758, label %1760

1758:                                             ; preds = %1749
  %1759 = load float, ptr %44, align 4, !tbaa !11
  br label %1763

1760:                                             ; preds = %1749
  %1761 = load float, ptr %44, align 4, !tbaa !11
  %1762 = fneg float %1761
  br label %1763

1763:                                             ; preds = %1760, %1758
  %1764 = phi float [ %1759, %1758 ], [ %1762, %1760 ]
  %1765 = fadd float %1750, %1764
  %1766 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %1767 = load float, ptr %1766, align 4, !tbaa !15
  store float %1767, ptr %45, align 4, !tbaa !11
  %1768 = load float, ptr %45, align 4, !tbaa !11
  %1769 = fcmp oge float %1768, 0.000000e+00
  br i1 %1769, label %1770, label %1772

1770:                                             ; preds = %1763
  %1771 = load float, ptr %45, align 4, !tbaa !11
  br label %1775

1772:                                             ; preds = %1763
  %1773 = load float, ptr %45, align 4, !tbaa !11
  %1774 = fneg float %1773
  br label %1775

1775:                                             ; preds = %1772, %1770
  %1776 = phi float [ %1771, %1770 ], [ %1774, %1772 ]
  %1777 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %1777, ptr %97, align 4
  %1778 = getelementptr inbounds { float, float }, ptr %97, i32 0, i32 0
  %1779 = load float, ptr %1778, align 4
  %1780 = getelementptr inbounds { float, float }, ptr %97, i32 0, i32 1
  %1781 = load float, ptr %1780, align 4
  store float %1781, ptr %46, align 4, !tbaa !11
  %1782 = load float, ptr %46, align 4, !tbaa !11
  %1783 = fcmp oge float %1782, 0.000000e+00
  br i1 %1783, label %1784, label %1786

1784:                                             ; preds = %1775
  %1785 = load float, ptr %46, align 4, !tbaa !11
  br label %1789

1786:                                             ; preds = %1775
  %1787 = load float, ptr %46, align 4, !tbaa !11
  %1788 = fneg float %1787
  br label %1789

1789:                                             ; preds = %1786, %1784
  %1790 = phi float [ %1785, %1784 ], [ %1788, %1786 ]
  %1791 = fadd float %1776, %1790
  %1792 = fadd float %1765, %1791
  %1793 = load ptr, ptr %21, align 8, !tbaa !5
  %1794 = getelementptr inbounds %struct.complex, ptr %1793, i64 1
  %1795 = getelementptr inbounds %struct.complex, ptr %1794, i32 0, i32 0
  %1796 = load float, ptr %1795, align 4, !tbaa !15
  store float %1796, ptr %47, align 4, !tbaa !11
  %1797 = load float, ptr %47, align 4, !tbaa !11
  %1798 = fcmp oge float %1797, 0.000000e+00
  br i1 %1798, label %1799, label %1801

1799:                                             ; preds = %1789
  %1800 = load float, ptr %47, align 4, !tbaa !11
  br label %1804

1801:                                             ; preds = %1789
  %1802 = load float, ptr %47, align 4, !tbaa !11
  %1803 = fneg float %1802
  br label %1804

1804:                                             ; preds = %1801, %1799
  %1805 = phi float [ %1800, %1799 ], [ %1803, %1801 ]
  %1806 = load ptr, ptr %21, align 8, !tbaa !5
  %1807 = getelementptr inbounds %struct.complex, ptr %1806, i64 1
  %1808 = call <2 x float> @Cf(ptr noundef %1807)
  store <2 x float> %1808, ptr %98, align 4
  %1809 = getelementptr inbounds { float, float }, ptr %98, i32 0, i32 0
  %1810 = load float, ptr %1809, align 4
  %1811 = getelementptr inbounds { float, float }, ptr %98, i32 0, i32 1
  %1812 = load float, ptr %1811, align 4
  store float %1812, ptr %48, align 4, !tbaa !11
  %1813 = load float, ptr %48, align 4, !tbaa !11
  %1814 = fcmp oge float %1813, 0.000000e+00
  br i1 %1814, label %1815, label %1817

1815:                                             ; preds = %1804
  %1816 = load float, ptr %48, align 4, !tbaa !11
  br label %1820

1817:                                             ; preds = %1804
  %1818 = load float, ptr %48, align 4, !tbaa !11
  %1819 = fneg float %1818
  br label %1820

1820:                                             ; preds = %1817, %1815
  %1821 = phi float [ %1816, %1815 ], [ %1819, %1817 ]
  %1822 = fadd float %1805, %1821
  %1823 = load ptr, ptr %26, align 8, !tbaa !5
  %1824 = load i32, ptr %38, align 4, !tbaa !9
  %1825 = sext i32 %1824 to i64
  %1826 = getelementptr inbounds %struct.complex, ptr %1823, i64 %1825
  %1827 = getelementptr inbounds %struct.complex, ptr %1826, i32 0, i32 0
  %1828 = load float, ptr %1827, align 4, !tbaa !15
  store float %1828, ptr %49, align 4, !tbaa !11
  %1829 = load float, ptr %49, align 4, !tbaa !11
  %1830 = fcmp oge float %1829, 0.000000e+00
  br i1 %1830, label %1831, label %1833

1831:                                             ; preds = %1820
  %1832 = load float, ptr %49, align 4, !tbaa !11
  br label %1836

1833:                                             ; preds = %1820
  %1834 = load float, ptr %49, align 4, !tbaa !11
  %1835 = fneg float %1834
  br label %1836

1836:                                             ; preds = %1833, %1831
  %1837 = phi float [ %1832, %1831 ], [ %1835, %1833 ]
  %1838 = load ptr, ptr %26, align 8, !tbaa !5
  %1839 = load i32, ptr %61, align 4, !tbaa !9
  %1840 = load i32, ptr %35, align 4, !tbaa !9
  %1841 = mul nsw i32 %1839, %1840
  %1842 = add nsw i32 %1841, 2
  %1843 = sext i32 %1842 to i64
  %1844 = getelementptr inbounds %struct.complex, ptr %1838, i64 %1843
  %1845 = call <2 x float> @Cf(ptr noundef %1844)
  store <2 x float> %1845, ptr %99, align 4
  %1846 = getelementptr inbounds { float, float }, ptr %99, i32 0, i32 0
  %1847 = load float, ptr %1846, align 4
  %1848 = getelementptr inbounds { float, float }, ptr %99, i32 0, i32 1
  %1849 = load float, ptr %1848, align 4
  store float %1849, ptr %50, align 4, !tbaa !11
  %1850 = load float, ptr %50, align 4, !tbaa !11
  %1851 = fcmp oge float %1850, 0.000000e+00
  br i1 %1851, label %1852, label %1854

1852:                                             ; preds = %1836
  %1853 = load float, ptr %50, align 4, !tbaa !11
  br label %1857

1854:                                             ; preds = %1836
  %1855 = load float, ptr %50, align 4, !tbaa !11
  %1856 = fneg float %1855
  br label %1857

1857:                                             ; preds = %1854, %1852
  %1858 = phi float [ %1853, %1852 ], [ %1856, %1854 ]
  %1859 = fadd float %1837, %1858
  %1860 = call float @llvm.fmuladd.f32(float %1822, float %1859, float %1792)
  %1861 = load ptr, ptr %31, align 8, !tbaa !5
  %1862 = getelementptr inbounds float, ptr %1861, i64 1
  store float %1860, ptr %1862, align 4, !tbaa !11
  %1863 = load ptr, ptr %18, align 8, !tbaa !5
  %1864 = load i32, ptr %1863, align 4, !tbaa !9
  %1865 = sub nsw i32 %1864, 1
  store i32 %1865, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %1866

1866:                                             ; preds = %2333, %1857
  %1867 = load i32, ptr %60, align 4, !tbaa !9
  %1868 = load i32, ptr %38, align 4, !tbaa !9
  %1869 = icmp sle i32 %1867, %1868
  br i1 %1869, label %1870, label %2336

1870:                                             ; preds = %1866
  %1871 = load i32, ptr %60, align 4, !tbaa !9
  %1872 = load i32, ptr %61, align 4, !tbaa !9
  %1873 = load i32, ptr %33, align 4, !tbaa !9
  %1874 = mul nsw i32 %1872, %1873
  %1875 = add nsw i32 %1871, %1874
  store i32 %1875, ptr %39, align 4, !tbaa !9
  %1876 = load ptr, ptr %24, align 8, !tbaa !5
  %1877 = load i32, ptr %39, align 4, !tbaa !9
  %1878 = sext i32 %1877 to i64
  %1879 = getelementptr inbounds %struct.complex, ptr %1876, i64 %1878
  %1880 = getelementptr inbounds %struct.complex, ptr %1879, i32 0, i32 0
  %1881 = load float, ptr %1880, align 4, !tbaa !15
  %1882 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %1881, ptr %1882, align 4, !tbaa !15
  %1883 = load ptr, ptr %24, align 8, !tbaa !5
  %1884 = load i32, ptr %39, align 4, !tbaa !9
  %1885 = sext i32 %1884 to i64
  %1886 = getelementptr inbounds %struct.complex, ptr %1883, i64 %1885
  %1887 = getelementptr inbounds %struct.complex, ptr %1886, i32 0, i32 1
  %1888 = load float, ptr %1887, align 4, !tbaa !17
  %1889 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %1888, ptr %1889, align 4, !tbaa !17
  %1890 = load i32, ptr %60, align 4, !tbaa !9
  %1891 = sub nsw i32 %1890, 1
  store i32 %1891, ptr %39, align 4, !tbaa !9
  %1892 = load i32, ptr %60, align 4, !tbaa !9
  %1893 = sub nsw i32 %1892, 1
  %1894 = load i32, ptr %61, align 4, !tbaa !9
  %1895 = load i32, ptr %35, align 4, !tbaa !9
  %1896 = mul nsw i32 %1894, %1895
  %1897 = add nsw i32 %1893, %1896
  store i32 %1897, ptr %40, align 4, !tbaa !9
  %1898 = load ptr, ptr %21, align 8, !tbaa !5
  %1899 = load i32, ptr %39, align 4, !tbaa !9
  %1900 = sext i32 %1899 to i64
  %1901 = getelementptr inbounds %struct.complex, ptr %1898, i64 %1900
  %1902 = getelementptr inbounds %struct.complex, ptr %1901, i32 0, i32 0
  %1903 = load float, ptr %1902, align 4, !tbaa !15
  %1904 = load ptr, ptr %26, align 8, !tbaa !5
  %1905 = load i32, ptr %40, align 4, !tbaa !9
  %1906 = sext i32 %1905 to i64
  %1907 = getelementptr inbounds %struct.complex, ptr %1904, i64 %1906
  %1908 = getelementptr inbounds %struct.complex, ptr %1907, i32 0, i32 0
  %1909 = load float, ptr %1908, align 4, !tbaa !15
  %1910 = load ptr, ptr %21, align 8, !tbaa !5
  %1911 = load i32, ptr %39, align 4, !tbaa !9
  %1912 = sext i32 %1911 to i64
  %1913 = getelementptr inbounds %struct.complex, ptr %1910, i64 %1912
  %1914 = getelementptr inbounds %struct.complex, ptr %1913, i32 0, i32 1
  %1915 = load float, ptr %1914, align 4, !tbaa !17
  %1916 = load ptr, ptr %26, align 8, !tbaa !5
  %1917 = load i32, ptr %40, align 4, !tbaa !9
  %1918 = sext i32 %1917 to i64
  %1919 = getelementptr inbounds %struct.complex, ptr %1916, i64 %1918
  %1920 = getelementptr inbounds %struct.complex, ptr %1919, i32 0, i32 1
  %1921 = load float, ptr %1920, align 4, !tbaa !17
  %1922 = fmul float %1915, %1921
  %1923 = fneg float %1922
  %1924 = call float @llvm.fmuladd.f32(float %1903, float %1909, float %1923)
  %1925 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1924, ptr %1925, align 4, !tbaa !15
  %1926 = load ptr, ptr %21, align 8, !tbaa !5
  %1927 = load i32, ptr %39, align 4, !tbaa !9
  %1928 = sext i32 %1927 to i64
  %1929 = getelementptr inbounds %struct.complex, ptr %1926, i64 %1928
  %1930 = getelementptr inbounds %struct.complex, ptr %1929, i32 0, i32 0
  %1931 = load float, ptr %1930, align 4, !tbaa !15
  %1932 = load ptr, ptr %26, align 8, !tbaa !5
  %1933 = load i32, ptr %40, align 4, !tbaa !9
  %1934 = sext i32 %1933 to i64
  %1935 = getelementptr inbounds %struct.complex, ptr %1932, i64 %1934
  %1936 = getelementptr inbounds %struct.complex, ptr %1935, i32 0, i32 1
  %1937 = load float, ptr %1936, align 4, !tbaa !17
  %1938 = load ptr, ptr %21, align 8, !tbaa !5
  %1939 = load i32, ptr %39, align 4, !tbaa !9
  %1940 = sext i32 %1939 to i64
  %1941 = getelementptr inbounds %struct.complex, ptr %1938, i64 %1940
  %1942 = getelementptr inbounds %struct.complex, ptr %1941, i32 0, i32 1
  %1943 = load float, ptr %1942, align 4, !tbaa !17
  %1944 = load ptr, ptr %26, align 8, !tbaa !5
  %1945 = load i32, ptr %40, align 4, !tbaa !9
  %1946 = sext i32 %1945 to i64
  %1947 = getelementptr inbounds %struct.complex, ptr %1944, i64 %1946
  %1948 = getelementptr inbounds %struct.complex, ptr %1947, i32 0, i32 0
  %1949 = load float, ptr %1948, align 4, !tbaa !15
  %1950 = fmul float %1943, %1949
  %1951 = call float @llvm.fmuladd.f32(float %1931, float %1937, float %1950)
  %1952 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1951, ptr %1952, align 4, !tbaa !17
  %1953 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1954 = load float, ptr %1953, align 4, !tbaa !15
  %1955 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  store float %1954, ptr %1955, align 4, !tbaa !15
  %1956 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1957 = load float, ptr %1956, align 4, !tbaa !17
  %1958 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  store float %1957, ptr %1958, align 4, !tbaa !17
  %1959 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %1959, ptr %39, align 4, !tbaa !9
  %1960 = load i32, ptr %60, align 4, !tbaa !9
  %1961 = load i32, ptr %61, align 4, !tbaa !9
  %1962 = load i32, ptr %35, align 4, !tbaa !9
  %1963 = mul nsw i32 %1961, %1962
  %1964 = add nsw i32 %1960, %1963
  store i32 %1964, ptr %40, align 4, !tbaa !9
  %1965 = load ptr, ptr %20, align 8, !tbaa !5
  %1966 = load i32, ptr %39, align 4, !tbaa !9
  %1967 = sext i32 %1966 to i64
  %1968 = getelementptr inbounds float, ptr %1965, i64 %1967
  %1969 = load float, ptr %1968, align 4, !tbaa !11
  %1970 = load ptr, ptr %26, align 8, !tbaa !5
  %1971 = load i32, ptr %40, align 4, !tbaa !9
  %1972 = sext i32 %1971 to i64
  %1973 = getelementptr inbounds %struct.complex, ptr %1970, i64 %1972
  %1974 = getelementptr inbounds %struct.complex, ptr %1973, i32 0, i32 0
  %1975 = load float, ptr %1974, align 4, !tbaa !15
  %1976 = fmul float %1969, %1975
  %1977 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %1976, ptr %1977, align 4, !tbaa !15
  %1978 = load ptr, ptr %20, align 8, !tbaa !5
  %1979 = load i32, ptr %39, align 4, !tbaa !9
  %1980 = sext i32 %1979 to i64
  %1981 = getelementptr inbounds float, ptr %1978, i64 %1980
  %1982 = load float, ptr %1981, align 4, !tbaa !11
  %1983 = load ptr, ptr %26, align 8, !tbaa !5
  %1984 = load i32, ptr %40, align 4, !tbaa !9
  %1985 = sext i32 %1984 to i64
  %1986 = getelementptr inbounds %struct.complex, ptr %1983, i64 %1985
  %1987 = getelementptr inbounds %struct.complex, ptr %1986, i32 0, i32 1
  %1988 = load float, ptr %1987, align 4, !tbaa !17
  %1989 = fmul float %1982, %1988
  %1990 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %1989, ptr %1990, align 4, !tbaa !17
  %1991 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %1992 = load float, ptr %1991, align 4, !tbaa !15
  %1993 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %1992, ptr %1993, align 4, !tbaa !15
  %1994 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %1995 = load float, ptr %1994, align 4, !tbaa !17
  %1996 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %1995, ptr %1996, align 4, !tbaa !17
  %1997 = load ptr, ptr %21, align 8, !tbaa !5
  %1998 = load i32, ptr %60, align 4, !tbaa !9
  %1999 = sext i32 %1998 to i64
  %2000 = getelementptr inbounds %struct.complex, ptr %1997, i64 %1999
  %2001 = call <2 x float> @Cf(ptr noundef %2000)
  store <2 x float> %2001, ptr %100, align 4
  %2002 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 0
  %2003 = load float, ptr %2002, align 4
  %2004 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 1
  %2005 = load float, ptr %2004, align 4
  %2006 = fneg float %2005
  %2007 = call ptr @_pCf(ptr noundef %56)
  %2008 = getelementptr inbounds { float, float }, ptr %2007, i32 0, i32 0
  %2009 = getelementptr inbounds { float, float }, ptr %2007, i32 0, i32 1
  store float %2003, ptr %2008, align 4
  store float %2006, ptr %2009, align 4
  %2010 = load i32, ptr %60, align 4, !tbaa !9
  %2011 = add nsw i32 %2010, 1
  %2012 = load i32, ptr %61, align 4, !tbaa !9
  %2013 = load i32, ptr %35, align 4, !tbaa !9
  %2014 = mul nsw i32 %2012, %2013
  %2015 = add nsw i32 %2011, %2014
  store i32 %2015, ptr %39, align 4, !tbaa !9
  %2016 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %2017 = load float, ptr %2016, align 4, !tbaa !15
  %2018 = load ptr, ptr %26, align 8, !tbaa !5
  %2019 = load i32, ptr %39, align 4, !tbaa !9
  %2020 = sext i32 %2019 to i64
  %2021 = getelementptr inbounds %struct.complex, ptr %2018, i64 %2020
  %2022 = getelementptr inbounds %struct.complex, ptr %2021, i32 0, i32 0
  %2023 = load float, ptr %2022, align 4, !tbaa !15
  %2024 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %2025 = load float, ptr %2024, align 4, !tbaa !17
  %2026 = load ptr, ptr %26, align 8, !tbaa !5
  %2027 = load i32, ptr %39, align 4, !tbaa !9
  %2028 = sext i32 %2027 to i64
  %2029 = getelementptr inbounds %struct.complex, ptr %2026, i64 %2028
  %2030 = getelementptr inbounds %struct.complex, ptr %2029, i32 0, i32 1
  %2031 = load float, ptr %2030, align 4, !tbaa !17
  %2032 = fmul float %2025, %2031
  %2033 = fneg float %2032
  %2034 = call float @llvm.fmuladd.f32(float %2017, float %2023, float %2033)
  %2035 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %2034, ptr %2035, align 4, !tbaa !15
  %2036 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %2037 = load float, ptr %2036, align 4, !tbaa !15
  %2038 = load ptr, ptr %26, align 8, !tbaa !5
  %2039 = load i32, ptr %39, align 4, !tbaa !9
  %2040 = sext i32 %2039 to i64
  %2041 = getelementptr inbounds %struct.complex, ptr %2038, i64 %2040
  %2042 = getelementptr inbounds %struct.complex, ptr %2041, i32 0, i32 1
  %2043 = load float, ptr %2042, align 4, !tbaa !17
  %2044 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %2045 = load float, ptr %2044, align 4, !tbaa !17
  %2046 = load ptr, ptr %26, align 8, !tbaa !5
  %2047 = load i32, ptr %39, align 4, !tbaa !9
  %2048 = sext i32 %2047 to i64
  %2049 = getelementptr inbounds %struct.complex, ptr %2046, i64 %2048
  %2050 = getelementptr inbounds %struct.complex, ptr %2049, i32 0, i32 0
  %2051 = load float, ptr %2050, align 4, !tbaa !15
  %2052 = fmul float %2045, %2051
  %2053 = call float @llvm.fmuladd.f32(float %2037, float %2043, float %2052)
  %2054 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %2053, ptr %2054, align 4, !tbaa !17
  %2055 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %2056 = load float, ptr %2055, align 4, !tbaa !15
  %2057 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  store float %2056, ptr %2057, align 4, !tbaa !15
  %2058 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %2059 = load float, ptr %2058, align 4, !tbaa !17
  %2060 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  store float %2059, ptr %2060, align 4, !tbaa !17
  %2061 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2061, ptr %39, align 4, !tbaa !9
  %2062 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %2063 = load float, ptr %2062, align 4, !tbaa !15
  %2064 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  %2065 = load float, ptr %2064, align 4, !tbaa !15
  %2066 = fsub float %2063, %2065
  %2067 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  store float %2066, ptr %2067, align 4, !tbaa !15
  %2068 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %2069 = load float, ptr %2068, align 4, !tbaa !17
  %2070 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  %2071 = load float, ptr %2070, align 4, !tbaa !17
  %2072 = fsub float %2069, %2071
  %2073 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  store float %2072, ptr %2073, align 4, !tbaa !17
  %2074 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 0
  %2075 = load float, ptr %2074, align 4, !tbaa !15
  %2076 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %2077 = load float, ptr %2076, align 4, !tbaa !15
  %2078 = fsub float %2075, %2077
  %2079 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %2078, ptr %2079, align 4, !tbaa !15
  %2080 = getelementptr inbounds %struct.complex, ptr %57, i32 0, i32 1
  %2081 = load float, ptr %2080, align 4, !tbaa !17
  %2082 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %2083 = load float, ptr %2082, align 4, !tbaa !17
  %2084 = fsub float %2081, %2083
  %2085 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %2084, ptr %2085, align 4, !tbaa !17
  %2086 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %2087 = load float, ptr %2086, align 4, !tbaa !15
  %2088 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 0
  %2089 = load float, ptr %2088, align 4, !tbaa !15
  %2090 = fsub float %2087, %2089
  %2091 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %2090, ptr %2091, align 4, !tbaa !15
  %2092 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %2093 = load float, ptr %2092, align 4, !tbaa !17
  %2094 = getelementptr inbounds %struct.complex, ptr %68, i32 0, i32 1
  %2095 = load float, ptr %2094, align 4, !tbaa !17
  %2096 = fsub float %2093, %2095
  %2097 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %2096, ptr %2097, align 4, !tbaa !17
  %2098 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %2099 = load float, ptr %2098, align 4, !tbaa !15
  %2100 = load ptr, ptr %30, align 8, !tbaa !5
  %2101 = load i32, ptr %39, align 4, !tbaa !9
  %2102 = sext i32 %2101 to i64
  %2103 = getelementptr inbounds %struct.complex, ptr %2100, i64 %2102
  %2104 = getelementptr inbounds %struct.complex, ptr %2103, i32 0, i32 0
  store float %2099, ptr %2104, align 4, !tbaa !15
  %2105 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %2106 = load float, ptr %2105, align 4, !tbaa !17
  %2107 = load ptr, ptr %30, align 8, !tbaa !5
  %2108 = load i32, ptr %39, align 4, !tbaa !9
  %2109 = sext i32 %2108 to i64
  %2110 = getelementptr inbounds %struct.complex, ptr %2107, i64 %2109
  %2111 = getelementptr inbounds %struct.complex, ptr %2110, i32 0, i32 1
  store float %2106, ptr %2111, align 4, !tbaa !17
  %2112 = load i32, ptr %60, align 4, !tbaa !9
  %2113 = sub nsw i32 %2112, 1
  store i32 %2113, ptr %39, align 4, !tbaa !9
  %2114 = load i32, ptr %60, align 4, !tbaa !9
  %2115 = sub nsw i32 %2114, 1
  %2116 = load i32, ptr %61, align 4, !tbaa !9
  %2117 = load i32, ptr %35, align 4, !tbaa !9
  %2118 = mul nsw i32 %2116, %2117
  %2119 = add nsw i32 %2115, %2118
  store i32 %2119, ptr %40, align 4, !tbaa !9
  %2120 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2120, ptr %41, align 4, !tbaa !9
  %2121 = load i32, ptr %60, align 4, !tbaa !9
  %2122 = add nsw i32 %2121, 1
  %2123 = load i32, ptr %61, align 4, !tbaa !9
  %2124 = load i32, ptr %35, align 4, !tbaa !9
  %2125 = mul nsw i32 %2123, %2124
  %2126 = add nsw i32 %2122, %2125
  store i32 %2126, ptr %42, align 4, !tbaa !9
  %2127 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %2128 = load float, ptr %2127, align 4, !tbaa !15
  store float %2128, ptr %43, align 4, !tbaa !11
  %2129 = load float, ptr %43, align 4, !tbaa !11
  %2130 = fcmp oge float %2129, 0.000000e+00
  br i1 %2130, label %2131, label %2133

2131:                                             ; preds = %1870
  %2132 = load float, ptr %43, align 4, !tbaa !11
  br label %2136

2133:                                             ; preds = %1870
  %2134 = load float, ptr %43, align 4, !tbaa !11
  %2135 = fneg float %2134
  br label %2136

2136:                                             ; preds = %2133, %2131
  %2137 = phi float [ %2132, %2131 ], [ %2135, %2133 ]
  %2138 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %2138, ptr %101, align 4
  %2139 = getelementptr inbounds { float, float }, ptr %101, i32 0, i32 0
  %2140 = load float, ptr %2139, align 4
  %2141 = getelementptr inbounds { float, float }, ptr %101, i32 0, i32 1
  %2142 = load float, ptr %2141, align 4
  store float %2142, ptr %44, align 4, !tbaa !11
  %2143 = load float, ptr %44, align 4, !tbaa !11
  %2144 = fcmp oge float %2143, 0.000000e+00
  br i1 %2144, label %2145, label %2147

2145:                                             ; preds = %2136
  %2146 = load float, ptr %44, align 4, !tbaa !11
  br label %2150

2147:                                             ; preds = %2136
  %2148 = load float, ptr %44, align 4, !tbaa !11
  %2149 = fneg float %2148
  br label %2150

2150:                                             ; preds = %2147, %2145
  %2151 = phi float [ %2146, %2145 ], [ %2149, %2147 ]
  %2152 = fadd float %2137, %2151
  %2153 = load ptr, ptr %21, align 8, !tbaa !5
  %2154 = load i32, ptr %39, align 4, !tbaa !9
  %2155 = sext i32 %2154 to i64
  %2156 = getelementptr inbounds %struct.complex, ptr %2153, i64 %2155
  %2157 = getelementptr inbounds %struct.complex, ptr %2156, i32 0, i32 0
  %2158 = load float, ptr %2157, align 4, !tbaa !15
  store float %2158, ptr %45, align 4, !tbaa !11
  %2159 = load float, ptr %45, align 4, !tbaa !11
  %2160 = fcmp oge float %2159, 0.000000e+00
  br i1 %2160, label %2161, label %2163

2161:                                             ; preds = %2150
  %2162 = load float, ptr %45, align 4, !tbaa !11
  br label %2166

2163:                                             ; preds = %2150
  %2164 = load float, ptr %45, align 4, !tbaa !11
  %2165 = fneg float %2164
  br label %2166

2166:                                             ; preds = %2163, %2161
  %2167 = phi float [ %2162, %2161 ], [ %2165, %2163 ]
  %2168 = load ptr, ptr %21, align 8, !tbaa !5
  %2169 = load i32, ptr %60, align 4, !tbaa !9
  %2170 = sub nsw i32 %2169, 1
  %2171 = sext i32 %2170 to i64
  %2172 = getelementptr inbounds %struct.complex, ptr %2168, i64 %2171
  %2173 = call <2 x float> @Cf(ptr noundef %2172)
  store <2 x float> %2173, ptr %102, align 4
  %2174 = getelementptr inbounds { float, float }, ptr %102, i32 0, i32 0
  %2175 = load float, ptr %2174, align 4
  %2176 = getelementptr inbounds { float, float }, ptr %102, i32 0, i32 1
  %2177 = load float, ptr %2176, align 4
  store float %2177, ptr %46, align 4, !tbaa !11
  %2178 = load float, ptr %46, align 4, !tbaa !11
  %2179 = fcmp oge float %2178, 0.000000e+00
  br i1 %2179, label %2180, label %2182

2180:                                             ; preds = %2166
  %2181 = load float, ptr %46, align 4, !tbaa !11
  br label %2185

2182:                                             ; preds = %2166
  %2183 = load float, ptr %46, align 4, !tbaa !11
  %2184 = fneg float %2183
  br label %2185

2185:                                             ; preds = %2182, %2180
  %2186 = phi float [ %2181, %2180 ], [ %2184, %2182 ]
  %2187 = fadd float %2167, %2186
  %2188 = load ptr, ptr %26, align 8, !tbaa !5
  %2189 = load i32, ptr %40, align 4, !tbaa !9
  %2190 = sext i32 %2189 to i64
  %2191 = getelementptr inbounds %struct.complex, ptr %2188, i64 %2190
  %2192 = getelementptr inbounds %struct.complex, ptr %2191, i32 0, i32 0
  %2193 = load float, ptr %2192, align 4, !tbaa !15
  store float %2193, ptr %47, align 4, !tbaa !11
  %2194 = load float, ptr %47, align 4, !tbaa !11
  %2195 = fcmp oge float %2194, 0.000000e+00
  br i1 %2195, label %2196, label %2198

2196:                                             ; preds = %2185
  %2197 = load float, ptr %47, align 4, !tbaa !11
  br label %2201

2198:                                             ; preds = %2185
  %2199 = load float, ptr %47, align 4, !tbaa !11
  %2200 = fneg float %2199
  br label %2201

2201:                                             ; preds = %2198, %2196
  %2202 = phi float [ %2197, %2196 ], [ %2200, %2198 ]
  %2203 = load ptr, ptr %26, align 8, !tbaa !5
  %2204 = load i32, ptr %60, align 4, !tbaa !9
  %2205 = sub nsw i32 %2204, 1
  %2206 = load i32, ptr %61, align 4, !tbaa !9
  %2207 = load i32, ptr %35, align 4, !tbaa !9
  %2208 = mul nsw i32 %2206, %2207
  %2209 = add nsw i32 %2205, %2208
  %2210 = sext i32 %2209 to i64
  %2211 = getelementptr inbounds %struct.complex, ptr %2203, i64 %2210
  %2212 = call <2 x float> @Cf(ptr noundef %2211)
  store <2 x float> %2212, ptr %103, align 4
  %2213 = getelementptr inbounds { float, float }, ptr %103, i32 0, i32 0
  %2214 = load float, ptr %2213, align 4
  %2215 = getelementptr inbounds { float, float }, ptr %103, i32 0, i32 1
  %2216 = load float, ptr %2215, align 4
  store float %2216, ptr %48, align 4, !tbaa !11
  %2217 = load float, ptr %48, align 4, !tbaa !11
  %2218 = fcmp oge float %2217, 0.000000e+00
  br i1 %2218, label %2219, label %2221

2219:                                             ; preds = %2201
  %2220 = load float, ptr %48, align 4, !tbaa !11
  br label %2224

2221:                                             ; preds = %2201
  %2222 = load float, ptr %48, align 4, !tbaa !11
  %2223 = fneg float %2222
  br label %2224

2224:                                             ; preds = %2221, %2219
  %2225 = phi float [ %2220, %2219 ], [ %2223, %2221 ]
  %2226 = fadd float %2202, %2225
  %2227 = call float @llvm.fmuladd.f32(float %2187, float %2226, float %2152)
  %2228 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %2229 = load float, ptr %2228, align 4, !tbaa !15
  store float %2229, ptr %49, align 4, !tbaa !11
  %2230 = load float, ptr %49, align 4, !tbaa !11
  %2231 = fcmp oge float %2230, 0.000000e+00
  br i1 %2231, label %2232, label %2234

2232:                                             ; preds = %2224
  %2233 = load float, ptr %49, align 4, !tbaa !11
  br label %2237

2234:                                             ; preds = %2224
  %2235 = load float, ptr %49, align 4, !tbaa !11
  %2236 = fneg float %2235
  br label %2237

2237:                                             ; preds = %2234, %2232
  %2238 = phi float [ %2233, %2232 ], [ %2236, %2234 ]
  %2239 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %2239, ptr %104, align 4
  %2240 = getelementptr inbounds { float, float }, ptr %104, i32 0, i32 0
  %2241 = load float, ptr %2240, align 4
  %2242 = getelementptr inbounds { float, float }, ptr %104, i32 0, i32 1
  %2243 = load float, ptr %2242, align 4
  store float %2243, ptr %50, align 4, !tbaa !11
  %2244 = load float, ptr %50, align 4, !tbaa !11
  %2245 = fcmp oge float %2244, 0.000000e+00
  br i1 %2245, label %2246, label %2248

2246:                                             ; preds = %2237
  %2247 = load float, ptr %50, align 4, !tbaa !11
  br label %2251

2248:                                             ; preds = %2237
  %2249 = load float, ptr %50, align 4, !tbaa !11
  %2250 = fneg float %2249
  br label %2251

2251:                                             ; preds = %2248, %2246
  %2252 = phi float [ %2247, %2246 ], [ %2250, %2248 ]
  %2253 = fadd float %2238, %2252
  %2254 = fadd float %2227, %2253
  %2255 = load ptr, ptr %21, align 8, !tbaa !5
  %2256 = load i32, ptr %41, align 4, !tbaa !9
  %2257 = sext i32 %2256 to i64
  %2258 = getelementptr inbounds %struct.complex, ptr %2255, i64 %2257
  %2259 = getelementptr inbounds %struct.complex, ptr %2258, i32 0, i32 0
  %2260 = load float, ptr %2259, align 4, !tbaa !15
  store float %2260, ptr %51, align 4, !tbaa !11
  %2261 = load float, ptr %51, align 4, !tbaa !11
  %2262 = fcmp oge float %2261, 0.000000e+00
  br i1 %2262, label %2263, label %2265

2263:                                             ; preds = %2251
  %2264 = load float, ptr %51, align 4, !tbaa !11
  br label %2268

2265:                                             ; preds = %2251
  %2266 = load float, ptr %51, align 4, !tbaa !11
  %2267 = fneg float %2266
  br label %2268

2268:                                             ; preds = %2265, %2263
  %2269 = phi float [ %2264, %2263 ], [ %2267, %2265 ]
  %2270 = load ptr, ptr %21, align 8, !tbaa !5
  %2271 = load i32, ptr %60, align 4, !tbaa !9
  %2272 = sext i32 %2271 to i64
  %2273 = getelementptr inbounds %struct.complex, ptr %2270, i64 %2272
  %2274 = call <2 x float> @Cf(ptr noundef %2273)
  store <2 x float> %2274, ptr %105, align 4
  %2275 = getelementptr inbounds { float, float }, ptr %105, i32 0, i32 0
  %2276 = load float, ptr %2275, align 4
  %2277 = getelementptr inbounds { float, float }, ptr %105, i32 0, i32 1
  %2278 = load float, ptr %2277, align 4
  store float %2278, ptr %52, align 4, !tbaa !11
  %2279 = load float, ptr %52, align 4, !tbaa !11
  %2280 = fcmp oge float %2279, 0.000000e+00
  br i1 %2280, label %2281, label %2283

2281:                                             ; preds = %2268
  %2282 = load float, ptr %52, align 4, !tbaa !11
  br label %2286

2283:                                             ; preds = %2268
  %2284 = load float, ptr %52, align 4, !tbaa !11
  %2285 = fneg float %2284
  br label %2286

2286:                                             ; preds = %2283, %2281
  %2287 = phi float [ %2282, %2281 ], [ %2285, %2283 ]
  %2288 = fadd float %2269, %2287
  %2289 = load ptr, ptr %26, align 8, !tbaa !5
  %2290 = load i32, ptr %42, align 4, !tbaa !9
  %2291 = sext i32 %2290 to i64
  %2292 = getelementptr inbounds %struct.complex, ptr %2289, i64 %2291
  %2293 = getelementptr inbounds %struct.complex, ptr %2292, i32 0, i32 0
  %2294 = load float, ptr %2293, align 4, !tbaa !15
  store float %2294, ptr %53, align 4, !tbaa !11
  %2295 = load float, ptr %53, align 4, !tbaa !11
  %2296 = fcmp oge float %2295, 0.000000e+00
  br i1 %2296, label %2297, label %2299

2297:                                             ; preds = %2286
  %2298 = load float, ptr %53, align 4, !tbaa !11
  br label %2302

2299:                                             ; preds = %2286
  %2300 = load float, ptr %53, align 4, !tbaa !11
  %2301 = fneg float %2300
  br label %2302

2302:                                             ; preds = %2299, %2297
  %2303 = phi float [ %2298, %2297 ], [ %2301, %2299 ]
  %2304 = load ptr, ptr %26, align 8, !tbaa !5
  %2305 = load i32, ptr %60, align 4, !tbaa !9
  %2306 = add nsw i32 %2305, 1
  %2307 = load i32, ptr %61, align 4, !tbaa !9
  %2308 = load i32, ptr %35, align 4, !tbaa !9
  %2309 = mul nsw i32 %2307, %2308
  %2310 = add nsw i32 %2306, %2309
  %2311 = sext i32 %2310 to i64
  %2312 = getelementptr inbounds %struct.complex, ptr %2304, i64 %2311
  %2313 = call <2 x float> @Cf(ptr noundef %2312)
  store <2 x float> %2313, ptr %106, align 4
  %2314 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 0
  %2315 = load float, ptr %2314, align 4
  %2316 = getelementptr inbounds { float, float }, ptr %106, i32 0, i32 1
  %2317 = load float, ptr %2316, align 4
  store float %2317, ptr %54, align 4, !tbaa !11
  %2318 = load float, ptr %54, align 4, !tbaa !11
  %2319 = fcmp oge float %2318, 0.000000e+00
  br i1 %2319, label %2320, label %2322

2320:                                             ; preds = %2302
  %2321 = load float, ptr %54, align 4, !tbaa !11
  br label %2325

2322:                                             ; preds = %2302
  %2323 = load float, ptr %54, align 4, !tbaa !11
  %2324 = fneg float %2323
  br label %2325

2325:                                             ; preds = %2322, %2320
  %2326 = phi float [ %2321, %2320 ], [ %2324, %2322 ]
  %2327 = fadd float %2303, %2326
  %2328 = call float @llvm.fmuladd.f32(float %2288, float %2327, float %2254)
  %2329 = load ptr, ptr %31, align 8, !tbaa !5
  %2330 = load i32, ptr %60, align 4, !tbaa !9
  %2331 = sext i32 %2330 to i64
  %2332 = getelementptr inbounds float, ptr %2329, i64 %2331
  store float %2328, ptr %2332, align 4, !tbaa !11
  br label %2333

2333:                                             ; preds = %2325
  %2334 = load i32, ptr %60, align 4, !tbaa !9
  %2335 = add nsw i32 %2334, 1
  store i32 %2335, ptr %60, align 4, !tbaa !9
  br label %1866, !llvm.loop !19

2336:                                             ; preds = %1866
  %2337 = load ptr, ptr %18, align 8, !tbaa !5
  %2338 = load i32, ptr %2337, align 4, !tbaa !9
  %2339 = load i32, ptr %61, align 4, !tbaa !9
  %2340 = load i32, ptr %33, align 4, !tbaa !9
  %2341 = mul nsw i32 %2339, %2340
  %2342 = add nsw i32 %2338, %2341
  store i32 %2342, ptr %38, align 4, !tbaa !9
  %2343 = load ptr, ptr %24, align 8, !tbaa !5
  %2344 = load i32, ptr %38, align 4, !tbaa !9
  %2345 = sext i32 %2344 to i64
  %2346 = getelementptr inbounds %struct.complex, ptr %2343, i64 %2345
  %2347 = getelementptr inbounds %struct.complex, ptr %2346, i32 0, i32 0
  %2348 = load float, ptr %2347, align 4, !tbaa !15
  %2349 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  store float %2348, ptr %2349, align 4, !tbaa !15
  %2350 = load ptr, ptr %24, align 8, !tbaa !5
  %2351 = load i32, ptr %38, align 4, !tbaa !9
  %2352 = sext i32 %2351 to i64
  %2353 = getelementptr inbounds %struct.complex, ptr %2350, i64 %2352
  %2354 = getelementptr inbounds %struct.complex, ptr %2353, i32 0, i32 1
  %2355 = load float, ptr %2354, align 4, !tbaa !17
  %2356 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  store float %2355, ptr %2356, align 4, !tbaa !17
  %2357 = load ptr, ptr %18, align 8, !tbaa !5
  %2358 = load i32, ptr %2357, align 4, !tbaa !9
  %2359 = sub nsw i32 %2358, 1
  store i32 %2359, ptr %38, align 4, !tbaa !9
  %2360 = load ptr, ptr %18, align 8, !tbaa !5
  %2361 = load i32, ptr %2360, align 4, !tbaa !9
  %2362 = sub nsw i32 %2361, 1
  %2363 = load i32, ptr %61, align 4, !tbaa !9
  %2364 = load i32, ptr %35, align 4, !tbaa !9
  %2365 = mul nsw i32 %2363, %2364
  %2366 = add nsw i32 %2362, %2365
  store i32 %2366, ptr %39, align 4, !tbaa !9
  %2367 = load ptr, ptr %21, align 8, !tbaa !5
  %2368 = load i32, ptr %38, align 4, !tbaa !9
  %2369 = sext i32 %2368 to i64
  %2370 = getelementptr inbounds %struct.complex, ptr %2367, i64 %2369
  %2371 = getelementptr inbounds %struct.complex, ptr %2370, i32 0, i32 0
  %2372 = load float, ptr %2371, align 4, !tbaa !15
  %2373 = load ptr, ptr %26, align 8, !tbaa !5
  %2374 = load i32, ptr %39, align 4, !tbaa !9
  %2375 = sext i32 %2374 to i64
  %2376 = getelementptr inbounds %struct.complex, ptr %2373, i64 %2375
  %2377 = getelementptr inbounds %struct.complex, ptr %2376, i32 0, i32 0
  %2378 = load float, ptr %2377, align 4, !tbaa !15
  %2379 = load ptr, ptr %21, align 8, !tbaa !5
  %2380 = load i32, ptr %38, align 4, !tbaa !9
  %2381 = sext i32 %2380 to i64
  %2382 = getelementptr inbounds %struct.complex, ptr %2379, i64 %2381
  %2383 = getelementptr inbounds %struct.complex, ptr %2382, i32 0, i32 1
  %2384 = load float, ptr %2383, align 4, !tbaa !17
  %2385 = load ptr, ptr %26, align 8, !tbaa !5
  %2386 = load i32, ptr %39, align 4, !tbaa !9
  %2387 = sext i32 %2386 to i64
  %2388 = getelementptr inbounds %struct.complex, ptr %2385, i64 %2387
  %2389 = getelementptr inbounds %struct.complex, ptr %2388, i32 0, i32 1
  %2390 = load float, ptr %2389, align 4, !tbaa !17
  %2391 = fmul float %2384, %2390
  %2392 = fneg float %2391
  %2393 = call float @llvm.fmuladd.f32(float %2372, float %2378, float %2392)
  %2394 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %2393, ptr %2394, align 4, !tbaa !15
  %2395 = load ptr, ptr %21, align 8, !tbaa !5
  %2396 = load i32, ptr %38, align 4, !tbaa !9
  %2397 = sext i32 %2396 to i64
  %2398 = getelementptr inbounds %struct.complex, ptr %2395, i64 %2397
  %2399 = getelementptr inbounds %struct.complex, ptr %2398, i32 0, i32 0
  %2400 = load float, ptr %2399, align 4, !tbaa !15
  %2401 = load ptr, ptr %26, align 8, !tbaa !5
  %2402 = load i32, ptr %39, align 4, !tbaa !9
  %2403 = sext i32 %2402 to i64
  %2404 = getelementptr inbounds %struct.complex, ptr %2401, i64 %2403
  %2405 = getelementptr inbounds %struct.complex, ptr %2404, i32 0, i32 1
  %2406 = load float, ptr %2405, align 4, !tbaa !17
  %2407 = load ptr, ptr %21, align 8, !tbaa !5
  %2408 = load i32, ptr %38, align 4, !tbaa !9
  %2409 = sext i32 %2408 to i64
  %2410 = getelementptr inbounds %struct.complex, ptr %2407, i64 %2409
  %2411 = getelementptr inbounds %struct.complex, ptr %2410, i32 0, i32 1
  %2412 = load float, ptr %2411, align 4, !tbaa !17
  %2413 = load ptr, ptr %26, align 8, !tbaa !5
  %2414 = load i32, ptr %39, align 4, !tbaa !9
  %2415 = sext i32 %2414 to i64
  %2416 = getelementptr inbounds %struct.complex, ptr %2413, i64 %2415
  %2417 = getelementptr inbounds %struct.complex, ptr %2416, i32 0, i32 0
  %2418 = load float, ptr %2417, align 4, !tbaa !15
  %2419 = fmul float %2412, %2418
  %2420 = call float @llvm.fmuladd.f32(float %2400, float %2406, float %2419)
  %2421 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %2420, ptr %2421, align 4, !tbaa !17
  %2422 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %2423 = load float, ptr %2422, align 4, !tbaa !15
  %2424 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  store float %2423, ptr %2424, align 4, !tbaa !15
  %2425 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %2426 = load float, ptr %2425, align 4, !tbaa !17
  %2427 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  store float %2426, ptr %2427, align 4, !tbaa !17
  %2428 = load ptr, ptr %18, align 8, !tbaa !5
  %2429 = load i32, ptr %2428, align 4, !tbaa !9
  store i32 %2429, ptr %38, align 4, !tbaa !9
  %2430 = load ptr, ptr %18, align 8, !tbaa !5
  %2431 = load i32, ptr %2430, align 4, !tbaa !9
  %2432 = load i32, ptr %61, align 4, !tbaa !9
  %2433 = load i32, ptr %35, align 4, !tbaa !9
  %2434 = mul nsw i32 %2432, %2433
  %2435 = add nsw i32 %2431, %2434
  store i32 %2435, ptr %39, align 4, !tbaa !9
  %2436 = load ptr, ptr %20, align 8, !tbaa !5
  %2437 = load i32, ptr %38, align 4, !tbaa !9
  %2438 = sext i32 %2437 to i64
  %2439 = getelementptr inbounds float, ptr %2436, i64 %2438
  %2440 = load float, ptr %2439, align 4, !tbaa !11
  %2441 = load ptr, ptr %26, align 8, !tbaa !5
  %2442 = load i32, ptr %39, align 4, !tbaa !9
  %2443 = sext i32 %2442 to i64
  %2444 = getelementptr inbounds %struct.complex, ptr %2441, i64 %2443
  %2445 = getelementptr inbounds %struct.complex, ptr %2444, i32 0, i32 0
  %2446 = load float, ptr %2445, align 4, !tbaa !15
  %2447 = fmul float %2440, %2446
  %2448 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %2447, ptr %2448, align 4, !tbaa !15
  %2449 = load ptr, ptr %20, align 8, !tbaa !5
  %2450 = load i32, ptr %38, align 4, !tbaa !9
  %2451 = sext i32 %2450 to i64
  %2452 = getelementptr inbounds float, ptr %2449, i64 %2451
  %2453 = load float, ptr %2452, align 4, !tbaa !11
  %2454 = load ptr, ptr %26, align 8, !tbaa !5
  %2455 = load i32, ptr %39, align 4, !tbaa !9
  %2456 = sext i32 %2455 to i64
  %2457 = getelementptr inbounds %struct.complex, ptr %2454, i64 %2456
  %2458 = getelementptr inbounds %struct.complex, ptr %2457, i32 0, i32 1
  %2459 = load float, ptr %2458, align 4, !tbaa !17
  %2460 = fmul float %2453, %2459
  %2461 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %2460, ptr %2461, align 4, !tbaa !17
  %2462 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %2463 = load float, ptr %2462, align 4, !tbaa !15
  %2464 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  store float %2463, ptr %2464, align 4, !tbaa !15
  %2465 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %2466 = load float, ptr %2465, align 4, !tbaa !17
  %2467 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  store float %2466, ptr %2467, align 4, !tbaa !17
  %2468 = load ptr, ptr %18, align 8, !tbaa !5
  %2469 = load i32, ptr %2468, align 4, !tbaa !9
  store i32 %2469, ptr %38, align 4, !tbaa !9
  %2470 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %2471 = load float, ptr %2470, align 4, !tbaa !15
  %2472 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 0
  %2473 = load float, ptr %2472, align 4, !tbaa !15
  %2474 = fsub float %2471, %2473
  %2475 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %2474, ptr %2475, align 4, !tbaa !15
  %2476 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 1
  %2477 = load float, ptr %2476, align 4, !tbaa !17
  %2478 = getelementptr inbounds %struct.complex, ptr %66, i32 0, i32 1
  %2479 = load float, ptr %2478, align 4, !tbaa !17
  %2480 = fsub float %2477, %2479
  %2481 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %2480, ptr %2481, align 4, !tbaa !17
  %2482 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %2483 = load float, ptr %2482, align 4, !tbaa !15
  %2484 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %2485 = load float, ptr %2484, align 4, !tbaa !15
  %2486 = fsub float %2483, %2485
  %2487 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  store float %2486, ptr %2487, align 4, !tbaa !15
  %2488 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %2489 = load float, ptr %2488, align 4, !tbaa !17
  %2490 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 1
  %2491 = load float, ptr %2490, align 4, !tbaa !17
  %2492 = fsub float %2489, %2491
  %2493 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  store float %2492, ptr %2493, align 4, !tbaa !17
  %2494 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 0
  %2495 = load float, ptr %2494, align 4, !tbaa !15
  %2496 = load ptr, ptr %30, align 8, !tbaa !5
  %2497 = load i32, ptr %38, align 4, !tbaa !9
  %2498 = sext i32 %2497 to i64
  %2499 = getelementptr inbounds %struct.complex, ptr %2496, i64 %2498
  %2500 = getelementptr inbounds %struct.complex, ptr %2499, i32 0, i32 0
  store float %2495, ptr %2500, align 4, !tbaa !15
  %2501 = getelementptr inbounds %struct.complex, ptr %55, i32 0, i32 1
  %2502 = load float, ptr %2501, align 4, !tbaa !17
  %2503 = load ptr, ptr %30, align 8, !tbaa !5
  %2504 = load i32, ptr %38, align 4, !tbaa !9
  %2505 = sext i32 %2504 to i64
  %2506 = getelementptr inbounds %struct.complex, ptr %2503, i64 %2505
  %2507 = getelementptr inbounds %struct.complex, ptr %2506, i32 0, i32 1
  store float %2502, ptr %2507, align 4, !tbaa !17
  %2508 = load ptr, ptr %18, align 8, !tbaa !5
  %2509 = load i32, ptr %2508, align 4, !tbaa !9
  %2510 = sub nsw i32 %2509, 1
  store i32 %2510, ptr %38, align 4, !tbaa !9
  %2511 = load ptr, ptr %18, align 8, !tbaa !5
  %2512 = load i32, ptr %2511, align 4, !tbaa !9
  %2513 = sub nsw i32 %2512, 1
  %2514 = load i32, ptr %61, align 4, !tbaa !9
  %2515 = load i32, ptr %35, align 4, !tbaa !9
  %2516 = mul nsw i32 %2514, %2515
  %2517 = add nsw i32 %2513, %2516
  store i32 %2517, ptr %39, align 4, !tbaa !9
  %2518 = getelementptr inbounds %struct.complex, ptr %65, i32 0, i32 0
  %2519 = load float, ptr %2518, align 4, !tbaa !15
  store float %2519, ptr %43, align 4, !tbaa !11
  %2520 = load float, ptr %43, align 4, !tbaa !11
  %2521 = fcmp oge float %2520, 0.000000e+00
  br i1 %2521, label %2522, label %2524

2522:                                             ; preds = %2336
  %2523 = load float, ptr %43, align 4, !tbaa !11
  br label %2527

2524:                                             ; preds = %2336
  %2525 = load float, ptr %43, align 4, !tbaa !11
  %2526 = fneg float %2525
  br label %2527

2527:                                             ; preds = %2524, %2522
  %2528 = phi float [ %2523, %2522 ], [ %2526, %2524 ]
  %2529 = call <2 x float> @Cf(ptr noundef %65)
  store <2 x float> %2529, ptr %107, align 4
  %2530 = getelementptr inbounds { float, float }, ptr %107, i32 0, i32 0
  %2531 = load float, ptr %2530, align 4
  %2532 = getelementptr inbounds { float, float }, ptr %107, i32 0, i32 1
  %2533 = load float, ptr %2532, align 4
  store float %2533, ptr %44, align 4, !tbaa !11
  %2534 = load float, ptr %44, align 4, !tbaa !11
  %2535 = fcmp oge float %2534, 0.000000e+00
  br i1 %2535, label %2536, label %2538

2536:                                             ; preds = %2527
  %2537 = load float, ptr %44, align 4, !tbaa !11
  br label %2541

2538:                                             ; preds = %2527
  %2539 = load float, ptr %44, align 4, !tbaa !11
  %2540 = fneg float %2539
  br label %2541

2541:                                             ; preds = %2538, %2536
  %2542 = phi float [ %2537, %2536 ], [ %2540, %2538 ]
  %2543 = fadd float %2528, %2542
  %2544 = load ptr, ptr %21, align 8, !tbaa !5
  %2545 = load i32, ptr %38, align 4, !tbaa !9
  %2546 = sext i32 %2545 to i64
  %2547 = getelementptr inbounds %struct.complex, ptr %2544, i64 %2546
  %2548 = getelementptr inbounds %struct.complex, ptr %2547, i32 0, i32 0
  %2549 = load float, ptr %2548, align 4, !tbaa !15
  store float %2549, ptr %45, align 4, !tbaa !11
  %2550 = load float, ptr %45, align 4, !tbaa !11
  %2551 = fcmp oge float %2550, 0.000000e+00
  br i1 %2551, label %2552, label %2554

2552:                                             ; preds = %2541
  %2553 = load float, ptr %45, align 4, !tbaa !11
  br label %2557

2554:                                             ; preds = %2541
  %2555 = load float, ptr %45, align 4, !tbaa !11
  %2556 = fneg float %2555
  br label %2557

2557:                                             ; preds = %2554, %2552
  %2558 = phi float [ %2553, %2552 ], [ %2556, %2554 ]
  %2559 = load ptr, ptr %21, align 8, !tbaa !5
  %2560 = load ptr, ptr %18, align 8, !tbaa !5
  %2561 = load i32, ptr %2560, align 4, !tbaa !9
  %2562 = sub nsw i32 %2561, 1
  %2563 = sext i32 %2562 to i64
  %2564 = getelementptr inbounds %struct.complex, ptr %2559, i64 %2563
  %2565 = call <2 x float> @Cf(ptr noundef %2564)
  store <2 x float> %2565, ptr %108, align 4
  %2566 = getelementptr inbounds { float, float }, ptr %108, i32 0, i32 0
  %2567 = load float, ptr %2566, align 4
  %2568 = getelementptr inbounds { float, float }, ptr %108, i32 0, i32 1
  %2569 = load float, ptr %2568, align 4
  store float %2569, ptr %46, align 4, !tbaa !11
  %2570 = load float, ptr %46, align 4, !tbaa !11
  %2571 = fcmp oge float %2570, 0.000000e+00
  br i1 %2571, label %2572, label %2574

2572:                                             ; preds = %2557
  %2573 = load float, ptr %46, align 4, !tbaa !11
  br label %2577

2574:                                             ; preds = %2557
  %2575 = load float, ptr %46, align 4, !tbaa !11
  %2576 = fneg float %2575
  br label %2577

2577:                                             ; preds = %2574, %2572
  %2578 = phi float [ %2573, %2572 ], [ %2576, %2574 ]
  %2579 = fadd float %2558, %2578
  %2580 = load ptr, ptr %26, align 8, !tbaa !5
  %2581 = load i32, ptr %39, align 4, !tbaa !9
  %2582 = sext i32 %2581 to i64
  %2583 = getelementptr inbounds %struct.complex, ptr %2580, i64 %2582
  %2584 = getelementptr inbounds %struct.complex, ptr %2583, i32 0, i32 0
  %2585 = load float, ptr %2584, align 4, !tbaa !15
  store float %2585, ptr %47, align 4, !tbaa !11
  %2586 = load float, ptr %47, align 4, !tbaa !11
  %2587 = fcmp oge float %2586, 0.000000e+00
  br i1 %2587, label %2588, label %2590

2588:                                             ; preds = %2577
  %2589 = load float, ptr %47, align 4, !tbaa !11
  br label %2593

2590:                                             ; preds = %2577
  %2591 = load float, ptr %47, align 4, !tbaa !11
  %2592 = fneg float %2591
  br label %2593

2593:                                             ; preds = %2590, %2588
  %2594 = phi float [ %2589, %2588 ], [ %2592, %2590 ]
  %2595 = load ptr, ptr %26, align 8, !tbaa !5
  %2596 = load ptr, ptr %18, align 8, !tbaa !5
  %2597 = load i32, ptr %2596, align 4, !tbaa !9
  %2598 = sub nsw i32 %2597, 1
  %2599 = load i32, ptr %61, align 4, !tbaa !9
  %2600 = load i32, ptr %35, align 4, !tbaa !9
  %2601 = mul nsw i32 %2599, %2600
  %2602 = add nsw i32 %2598, %2601
  %2603 = sext i32 %2602 to i64
  %2604 = getelementptr inbounds %struct.complex, ptr %2595, i64 %2603
  %2605 = call <2 x float> @Cf(ptr noundef %2604)
  store <2 x float> %2605, ptr %109, align 4
  %2606 = getelementptr inbounds { float, float }, ptr %109, i32 0, i32 0
  %2607 = load float, ptr %2606, align 4
  %2608 = getelementptr inbounds { float, float }, ptr %109, i32 0, i32 1
  %2609 = load float, ptr %2608, align 4
  store float %2609, ptr %48, align 4, !tbaa !11
  %2610 = load float, ptr %48, align 4, !tbaa !11
  %2611 = fcmp oge float %2610, 0.000000e+00
  br i1 %2611, label %2612, label %2614

2612:                                             ; preds = %2593
  %2613 = load float, ptr %48, align 4, !tbaa !11
  br label %2617

2614:                                             ; preds = %2593
  %2615 = load float, ptr %48, align 4, !tbaa !11
  %2616 = fneg float %2615
  br label %2617

2617:                                             ; preds = %2614, %2612
  %2618 = phi float [ %2613, %2612 ], [ %2616, %2614 ]
  %2619 = fadd float %2594, %2618
  %2620 = call float @llvm.fmuladd.f32(float %2579, float %2619, float %2543)
  %2621 = getelementptr inbounds %struct.complex, ptr %67, i32 0, i32 0
  %2622 = load float, ptr %2621, align 4, !tbaa !15
  store float %2622, ptr %49, align 4, !tbaa !11
  %2623 = load float, ptr %49, align 4, !tbaa !11
  %2624 = fcmp oge float %2623, 0.000000e+00
  br i1 %2624, label %2625, label %2627

2625:                                             ; preds = %2617
  %2626 = load float, ptr %49, align 4, !tbaa !11
  br label %2630

2627:                                             ; preds = %2617
  %2628 = load float, ptr %49, align 4, !tbaa !11
  %2629 = fneg float %2628
  br label %2630

2630:                                             ; preds = %2627, %2625
  %2631 = phi float [ %2626, %2625 ], [ %2629, %2627 ]
  %2632 = call <2 x float> @Cf(ptr noundef %67)
  store <2 x float> %2632, ptr %110, align 4
  %2633 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 0
  %2634 = load float, ptr %2633, align 4
  %2635 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 1
  %2636 = load float, ptr %2635, align 4
  store float %2636, ptr %50, align 4, !tbaa !11
  %2637 = load float, ptr %50, align 4, !tbaa !11
  %2638 = fcmp oge float %2637, 0.000000e+00
  br i1 %2638, label %2639, label %2641

2639:                                             ; preds = %2630
  %2640 = load float, ptr %50, align 4, !tbaa !11
  br label %2644

2641:                                             ; preds = %2630
  %2642 = load float, ptr %50, align 4, !tbaa !11
  %2643 = fneg float %2642
  br label %2644

2644:                                             ; preds = %2641, %2639
  %2645 = phi float [ %2640, %2639 ], [ %2643, %2641 ]
  %2646 = fadd float %2631, %2645
  %2647 = fadd float %2620, %2646
  %2648 = load ptr, ptr %31, align 8, !tbaa !5
  %2649 = load ptr, ptr %18, align 8, !tbaa !5
  %2650 = load i32, ptr %2649, align 4, !tbaa !9
  %2651 = sext i32 %2650 to i64
  %2652 = getelementptr inbounds float, ptr %2648, i64 %2651
  store float %2647, ptr %2652, align 4, !tbaa !11
  br label %2653

2653:                                             ; preds = %2644, %1585
  br label %2654

2654:                                             ; preds = %2653, %1458
  store float 0.000000e+00, ptr %62, align 4, !tbaa !11
  %2655 = load ptr, ptr %18, align 8, !tbaa !5
  %2656 = load i32, ptr %2655, align 4, !tbaa !9
  store i32 %2656, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %2657

2657:                                             ; preds = %2778, %2654
  %2658 = load i32, ptr %60, align 4, !tbaa !9
  %2659 = load i32, ptr %38, align 4, !tbaa !9
  %2660 = icmp sle i32 %2658, %2659
  br i1 %2660, label %2661, label %2781

2661:                                             ; preds = %2657
  %2662 = load ptr, ptr %31, align 8, !tbaa !5
  %2663 = load i32, ptr %60, align 4, !tbaa !9
  %2664 = sext i32 %2663 to i64
  %2665 = getelementptr inbounds float, ptr %2662, i64 %2664
  %2666 = load float, ptr %2665, align 4, !tbaa !11
  %2667 = load float, ptr %59, align 4, !tbaa !11
  %2668 = fcmp ogt float %2666, %2667
  br i1 %2668, label %2669, label %2721

2669:                                             ; preds = %2661
  %2670 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2670, ptr %39, align 4, !tbaa !9
  %2671 = load float, ptr %62, align 4, !tbaa !11
  store float %2671, ptr %45, align 4, !tbaa !11
  %2672 = load ptr, ptr %30, align 8, !tbaa !5
  %2673 = load i32, ptr %39, align 4, !tbaa !9
  %2674 = sext i32 %2673 to i64
  %2675 = getelementptr inbounds %struct.complex, ptr %2672, i64 %2674
  %2676 = getelementptr inbounds %struct.complex, ptr %2675, i32 0, i32 0
  %2677 = load float, ptr %2676, align 4, !tbaa !15
  store float %2677, ptr %43, align 4, !tbaa !11
  %2678 = load float, ptr %43, align 4, !tbaa !11
  %2679 = fcmp oge float %2678, 0.000000e+00
  br i1 %2679, label %2680, label %2682

2680:                                             ; preds = %2669
  %2681 = load float, ptr %43, align 4, !tbaa !11
  br label %2685

2682:                                             ; preds = %2669
  %2683 = load float, ptr %43, align 4, !tbaa !11
  %2684 = fneg float %2683
  br label %2685

2685:                                             ; preds = %2682, %2680
  %2686 = phi float [ %2681, %2680 ], [ %2684, %2682 ]
  %2687 = load ptr, ptr %30, align 8, !tbaa !5
  %2688 = load i32, ptr %60, align 4, !tbaa !9
  %2689 = sext i32 %2688 to i64
  %2690 = getelementptr inbounds %struct.complex, ptr %2687, i64 %2689
  %2691 = call <2 x float> @Cf(ptr noundef %2690)
  store <2 x float> %2691, ptr %111, align 4
  %2692 = getelementptr inbounds { float, float }, ptr %111, i32 0, i32 0
  %2693 = load float, ptr %2692, align 4
  %2694 = getelementptr inbounds { float, float }, ptr %111, i32 0, i32 1
  %2695 = load float, ptr %2694, align 4
  store float %2695, ptr %44, align 4, !tbaa !11
  %2696 = load float, ptr %44, align 4, !tbaa !11
  %2697 = fcmp oge float %2696, 0.000000e+00
  br i1 %2697, label %2698, label %2700

2698:                                             ; preds = %2685
  %2699 = load float, ptr %44, align 4, !tbaa !11
  br label %2703

2700:                                             ; preds = %2685
  %2701 = load float, ptr %44, align 4, !tbaa !11
  %2702 = fneg float %2701
  br label %2703

2703:                                             ; preds = %2700, %2698
  %2704 = phi float [ %2699, %2698 ], [ %2702, %2700 ]
  %2705 = fadd float %2686, %2704
  %2706 = load ptr, ptr %31, align 8, !tbaa !5
  %2707 = load i32, ptr %60, align 4, !tbaa !9
  %2708 = sext i32 %2707 to i64
  %2709 = getelementptr inbounds float, ptr %2706, i64 %2708
  %2710 = load float, ptr %2709, align 4, !tbaa !11
  %2711 = fdiv float %2705, %2710
  store float %2711, ptr %46, align 4, !tbaa !11
  %2712 = load float, ptr %45, align 4, !tbaa !11
  %2713 = load float, ptr %46, align 4, !tbaa !11
  %2714 = fcmp oge float %2712, %2713
  br i1 %2714, label %2715, label %2717

2715:                                             ; preds = %2703
  %2716 = load float, ptr %45, align 4, !tbaa !11
  br label %2719

2717:                                             ; preds = %2703
  %2718 = load float, ptr %46, align 4, !tbaa !11
  br label %2719

2719:                                             ; preds = %2717, %2715
  %2720 = phi float [ %2716, %2715 ], [ %2718, %2717 ]
  store float %2720, ptr %62, align 4, !tbaa !11
  br label %2777

2721:                                             ; preds = %2661
  %2722 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2722, ptr %39, align 4, !tbaa !9
  %2723 = load float, ptr %62, align 4, !tbaa !11
  store float %2723, ptr %45, align 4, !tbaa !11
  %2724 = load ptr, ptr %30, align 8, !tbaa !5
  %2725 = load i32, ptr %39, align 4, !tbaa !9
  %2726 = sext i32 %2725 to i64
  %2727 = getelementptr inbounds %struct.complex, ptr %2724, i64 %2726
  %2728 = getelementptr inbounds %struct.complex, ptr %2727, i32 0, i32 0
  %2729 = load float, ptr %2728, align 4, !tbaa !15
  store float %2729, ptr %43, align 4, !tbaa !11
  %2730 = load float, ptr %43, align 4, !tbaa !11
  %2731 = fcmp oge float %2730, 0.000000e+00
  br i1 %2731, label %2732, label %2734

2732:                                             ; preds = %2721
  %2733 = load float, ptr %43, align 4, !tbaa !11
  br label %2737

2734:                                             ; preds = %2721
  %2735 = load float, ptr %43, align 4, !tbaa !11
  %2736 = fneg float %2735
  br label %2737

2737:                                             ; preds = %2734, %2732
  %2738 = phi float [ %2733, %2732 ], [ %2736, %2734 ]
  %2739 = load ptr, ptr %30, align 8, !tbaa !5
  %2740 = load i32, ptr %60, align 4, !tbaa !9
  %2741 = sext i32 %2740 to i64
  %2742 = getelementptr inbounds %struct.complex, ptr %2739, i64 %2741
  %2743 = call <2 x float> @Cf(ptr noundef %2742)
  store <2 x float> %2743, ptr %112, align 4
  %2744 = getelementptr inbounds { float, float }, ptr %112, i32 0, i32 0
  %2745 = load float, ptr %2744, align 4
  %2746 = getelementptr inbounds { float, float }, ptr %112, i32 0, i32 1
  %2747 = load float, ptr %2746, align 4
  store float %2747, ptr %44, align 4, !tbaa !11
  %2748 = load float, ptr %44, align 4, !tbaa !11
  %2749 = fcmp oge float %2748, 0.000000e+00
  br i1 %2749, label %2750, label %2752

2750:                                             ; preds = %2737
  %2751 = load float, ptr %44, align 4, !tbaa !11
  br label %2755

2752:                                             ; preds = %2737
  %2753 = load float, ptr %44, align 4, !tbaa !11
  %2754 = fneg float %2753
  br label %2755

2755:                                             ; preds = %2752, %2750
  %2756 = phi float [ %2751, %2750 ], [ %2754, %2752 ]
  %2757 = fadd float %2738, %2756
  %2758 = load float, ptr %58, align 4, !tbaa !11
  %2759 = fadd float %2757, %2758
  %2760 = load ptr, ptr %31, align 8, !tbaa !5
  %2761 = load i32, ptr %60, align 4, !tbaa !9
  %2762 = sext i32 %2761 to i64
  %2763 = getelementptr inbounds float, ptr %2760, i64 %2762
  %2764 = load float, ptr %2763, align 4, !tbaa !11
  %2765 = load float, ptr %58, align 4, !tbaa !11
  %2766 = fadd float %2764, %2765
  %2767 = fdiv float %2759, %2766
  store float %2767, ptr %46, align 4, !tbaa !11
  %2768 = load float, ptr %45, align 4, !tbaa !11
  %2769 = load float, ptr %46, align 4, !tbaa !11
  %2770 = fcmp oge float %2768, %2769
  br i1 %2770, label %2771, label %2773

2771:                                             ; preds = %2755
  %2772 = load float, ptr %45, align 4, !tbaa !11
  br label %2775

2773:                                             ; preds = %2755
  %2774 = load float, ptr %46, align 4, !tbaa !11
  br label %2775

2775:                                             ; preds = %2773, %2771
  %2776 = phi float [ %2772, %2771 ], [ %2774, %2773 ]
  store float %2776, ptr %62, align 4, !tbaa !11
  br label %2777

2777:                                             ; preds = %2775, %2719
  br label %2778

2778:                                             ; preds = %2777
  %2779 = load i32, ptr %60, align 4, !tbaa !9
  %2780 = add nsw i32 %2779, 1
  store i32 %2780, ptr %60, align 4, !tbaa !9
  br label %2657, !llvm.loop !20

2781:                                             ; preds = %2657
  %2782 = load float, ptr %62, align 4, !tbaa !11
  %2783 = load ptr, ptr %29, align 8, !tbaa !5
  %2784 = load i32, ptr %61, align 4, !tbaa !9
  %2785 = sext i32 %2784 to i64
  %2786 = getelementptr inbounds float, ptr %2783, i64 %2785
  store float %2782, ptr %2786, align 4, !tbaa !11
  %2787 = load ptr, ptr %29, align 8, !tbaa !5
  %2788 = load i32, ptr %61, align 4, !tbaa !9
  %2789 = sext i32 %2788 to i64
  %2790 = getelementptr inbounds float, ptr %2787, i64 %2789
  %2791 = load float, ptr %2790, align 4, !tbaa !11
  %2792 = load float, ptr %73, align 4, !tbaa !11
  %2793 = fcmp ogt float %2791, %2792
  br i1 %2793, label %2794, label %2834

2794:                                             ; preds = %2781
  %2795 = load ptr, ptr %29, align 8, !tbaa !5
  %2796 = load i32, ptr %61, align 4, !tbaa !9
  %2797 = sext i32 %2796 to i64
  %2798 = getelementptr inbounds float, ptr %2795, i64 %2797
  %2799 = load float, ptr %2798, align 4, !tbaa !11
  %2800 = fmul float %2799, 2.000000e+00
  %2801 = load float, ptr %72, align 4, !tbaa !11
  %2802 = fcmp ole float %2800, %2801
  br i1 %2802, label %2803, label %2834

2803:                                             ; preds = %2794
  %2804 = load i32, ptr %63, align 4, !tbaa !9
  %2805 = icmp sle i32 %2804, 5
  br i1 %2805, label %2806, label %2834

2806:                                             ; preds = %2803
  %2807 = load ptr, ptr %17, align 8, !tbaa !5
  %2808 = load ptr, ptr %18, align 8, !tbaa !5
  %2809 = load ptr, ptr %22, align 8, !tbaa !5
  %2810 = getelementptr inbounds float, ptr %2809, i64 1
  %2811 = load ptr, ptr %23, align 8, !tbaa !5
  %2812 = getelementptr inbounds %struct.complex, ptr %2811, i64 1
  %2813 = load ptr, ptr %30, align 8, !tbaa !5
  %2814 = getelementptr inbounds %struct.complex, ptr %2813, i64 1
  %2815 = load ptr, ptr %18, align 8, !tbaa !5
  %2816 = load ptr, ptr %32, align 8, !tbaa !5
  call void @cpttrs_(ptr noundef %2807, ptr noundef %2808, ptr noundef @c__1, ptr noundef %2810, ptr noundef %2812, ptr noundef %2814, ptr noundef %2815, ptr noundef %2816)
  %2817 = load ptr, ptr %18, align 8, !tbaa !5
  %2818 = load ptr, ptr %30, align 8, !tbaa !5
  %2819 = getelementptr inbounds %struct.complex, ptr %2818, i64 1
  %2820 = load ptr, ptr %26, align 8, !tbaa !5
  %2821 = load i32, ptr %61, align 4, !tbaa !9
  %2822 = load i32, ptr %35, align 4, !tbaa !9
  %2823 = mul nsw i32 %2821, %2822
  %2824 = add nsw i32 %2823, 1
  %2825 = sext i32 %2824 to i64
  %2826 = getelementptr inbounds %struct.complex, ptr %2820, i64 %2825
  call void @caxpy_(ptr noundef %2817, ptr noundef @c_b16, ptr noundef %2819, ptr noundef @c__1, ptr noundef %2826, ptr noundef @c__1)
  %2827 = load ptr, ptr %29, align 8, !tbaa !5
  %2828 = load i32, ptr %61, align 4, !tbaa !9
  %2829 = sext i32 %2828 to i64
  %2830 = getelementptr inbounds float, ptr %2827, i64 %2829
  %2831 = load float, ptr %2830, align 4, !tbaa !11
  store float %2831, ptr %72, align 4, !tbaa !11
  %2832 = load i32, ptr %63, align 4, !tbaa !9
  %2833 = add nsw i32 %2832, 1
  store i32 %2833, ptr %63, align 4, !tbaa !9
  br label %268

2834:                                             ; preds = %2803, %2794, %2781
  %2835 = load ptr, ptr %18, align 8, !tbaa !5
  %2836 = load i32, ptr %2835, align 4, !tbaa !9
  store i32 %2836, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %2837

2837:                                             ; preds = %2952, %2834
  %2838 = load i32, ptr %60, align 4, !tbaa !9
  %2839 = load i32, ptr %38, align 4, !tbaa !9
  %2840 = icmp sle i32 %2838, %2839
  br i1 %2840, label %2841, label %2955

2841:                                             ; preds = %2837
  %2842 = load ptr, ptr %31, align 8, !tbaa !5
  %2843 = load i32, ptr %60, align 4, !tbaa !9
  %2844 = sext i32 %2843 to i64
  %2845 = getelementptr inbounds float, ptr %2842, i64 %2844
  %2846 = load float, ptr %2845, align 4, !tbaa !11
  %2847 = load float, ptr %59, align 4, !tbaa !11
  %2848 = fcmp ogt float %2846, %2847
  br i1 %2848, label %2849, label %2899

2849:                                             ; preds = %2841
  %2850 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2850, ptr %39, align 4, !tbaa !9
  %2851 = load ptr, ptr %30, align 8, !tbaa !5
  %2852 = load i32, ptr %39, align 4, !tbaa !9
  %2853 = sext i32 %2852 to i64
  %2854 = getelementptr inbounds %struct.complex, ptr %2851, i64 %2853
  %2855 = getelementptr inbounds %struct.complex, ptr %2854, i32 0, i32 0
  %2856 = load float, ptr %2855, align 4, !tbaa !15
  store float %2856, ptr %43, align 4, !tbaa !11
  %2857 = load float, ptr %43, align 4, !tbaa !11
  %2858 = fcmp oge float %2857, 0.000000e+00
  br i1 %2858, label %2859, label %2861

2859:                                             ; preds = %2849
  %2860 = load float, ptr %43, align 4, !tbaa !11
  br label %2864

2861:                                             ; preds = %2849
  %2862 = load float, ptr %43, align 4, !tbaa !11
  %2863 = fneg float %2862
  br label %2864

2864:                                             ; preds = %2861, %2859
  %2865 = phi float [ %2860, %2859 ], [ %2863, %2861 ]
  %2866 = load ptr, ptr %30, align 8, !tbaa !5
  %2867 = load i32, ptr %60, align 4, !tbaa !9
  %2868 = sext i32 %2867 to i64
  %2869 = getelementptr inbounds %struct.complex, ptr %2866, i64 %2868
  %2870 = call <2 x float> @Cf(ptr noundef %2869)
  store <2 x float> %2870, ptr %113, align 4
  %2871 = getelementptr inbounds { float, float }, ptr %113, i32 0, i32 0
  %2872 = load float, ptr %2871, align 4
  %2873 = getelementptr inbounds { float, float }, ptr %113, i32 0, i32 1
  %2874 = load float, ptr %2873, align 4
  store float %2874, ptr %44, align 4, !tbaa !11
  %2875 = load float, ptr %44, align 4, !tbaa !11
  %2876 = fcmp oge float %2875, 0.000000e+00
  br i1 %2876, label %2877, label %2879

2877:                                             ; preds = %2864
  %2878 = load float, ptr %44, align 4, !tbaa !11
  br label %2882

2879:                                             ; preds = %2864
  %2880 = load float, ptr %44, align 4, !tbaa !11
  %2881 = fneg float %2880
  br label %2882

2882:                                             ; preds = %2879, %2877
  %2883 = phi float [ %2878, %2877 ], [ %2881, %2879 ]
  %2884 = fadd float %2865, %2883
  %2885 = load i32, ptr %70, align 4, !tbaa !9
  %2886 = sitofp i32 %2885 to float
  %2887 = load float, ptr %73, align 4, !tbaa !11
  %2888 = fmul float %2886, %2887
  %2889 = load ptr, ptr %31, align 8, !tbaa !5
  %2890 = load i32, ptr %60, align 4, !tbaa !9
  %2891 = sext i32 %2890 to i64
  %2892 = getelementptr inbounds float, ptr %2889, i64 %2891
  %2893 = load float, ptr %2892, align 4, !tbaa !11
  %2894 = call float @llvm.fmuladd.f32(float %2888, float %2893, float %2884)
  %2895 = load ptr, ptr %31, align 8, !tbaa !5
  %2896 = load i32, ptr %60, align 4, !tbaa !9
  %2897 = sext i32 %2896 to i64
  %2898 = getelementptr inbounds float, ptr %2895, i64 %2897
  store float %2894, ptr %2898, align 4, !tbaa !11
  br label %2951

2899:                                             ; preds = %2841
  %2900 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2900, ptr %39, align 4, !tbaa !9
  %2901 = load ptr, ptr %30, align 8, !tbaa !5
  %2902 = load i32, ptr %39, align 4, !tbaa !9
  %2903 = sext i32 %2902 to i64
  %2904 = getelementptr inbounds %struct.complex, ptr %2901, i64 %2903
  %2905 = getelementptr inbounds %struct.complex, ptr %2904, i32 0, i32 0
  %2906 = load float, ptr %2905, align 4, !tbaa !15
  store float %2906, ptr %43, align 4, !tbaa !11
  %2907 = load float, ptr %43, align 4, !tbaa !11
  %2908 = fcmp oge float %2907, 0.000000e+00
  br i1 %2908, label %2909, label %2911

2909:                                             ; preds = %2899
  %2910 = load float, ptr %43, align 4, !tbaa !11
  br label %2914

2911:                                             ; preds = %2899
  %2912 = load float, ptr %43, align 4, !tbaa !11
  %2913 = fneg float %2912
  br label %2914

2914:                                             ; preds = %2911, %2909
  %2915 = phi float [ %2910, %2909 ], [ %2913, %2911 ]
  %2916 = load ptr, ptr %30, align 8, !tbaa !5
  %2917 = load i32, ptr %60, align 4, !tbaa !9
  %2918 = sext i32 %2917 to i64
  %2919 = getelementptr inbounds %struct.complex, ptr %2916, i64 %2918
  %2920 = call <2 x float> @Cf(ptr noundef %2919)
  store <2 x float> %2920, ptr %114, align 4
  %2921 = getelementptr inbounds { float, float }, ptr %114, i32 0, i32 0
  %2922 = load float, ptr %2921, align 4
  %2923 = getelementptr inbounds { float, float }, ptr %114, i32 0, i32 1
  %2924 = load float, ptr %2923, align 4
  store float %2924, ptr %44, align 4, !tbaa !11
  %2925 = load float, ptr %44, align 4, !tbaa !11
  %2926 = fcmp oge float %2925, 0.000000e+00
  br i1 %2926, label %2927, label %2929

2927:                                             ; preds = %2914
  %2928 = load float, ptr %44, align 4, !tbaa !11
  br label %2932

2929:                                             ; preds = %2914
  %2930 = load float, ptr %44, align 4, !tbaa !11
  %2931 = fneg float %2930
  br label %2932

2932:                                             ; preds = %2929, %2927
  %2933 = phi float [ %2928, %2927 ], [ %2931, %2929 ]
  %2934 = fadd float %2915, %2933
  %2935 = load i32, ptr %70, align 4, !tbaa !9
  %2936 = sitofp i32 %2935 to float
  %2937 = load float, ptr %73, align 4, !tbaa !11
  %2938 = fmul float %2936, %2937
  %2939 = load ptr, ptr %31, align 8, !tbaa !5
  %2940 = load i32, ptr %60, align 4, !tbaa !9
  %2941 = sext i32 %2940 to i64
  %2942 = getelementptr inbounds float, ptr %2939, i64 %2941
  %2943 = load float, ptr %2942, align 4, !tbaa !11
  %2944 = call float @llvm.fmuladd.f32(float %2938, float %2943, float %2934)
  %2945 = load float, ptr %58, align 4, !tbaa !11
  %2946 = fadd float %2944, %2945
  %2947 = load ptr, ptr %31, align 8, !tbaa !5
  %2948 = load i32, ptr %60, align 4, !tbaa !9
  %2949 = sext i32 %2948 to i64
  %2950 = getelementptr inbounds float, ptr %2947, i64 %2949
  store float %2946, ptr %2950, align 4, !tbaa !11
  br label %2951

2951:                                             ; preds = %2932, %2882
  br label %2952

2952:                                             ; preds = %2951
  %2953 = load i32, ptr %60, align 4, !tbaa !9
  %2954 = add nsw i32 %2953, 1
  store i32 %2954, ptr %60, align 4, !tbaa !9
  br label %2837, !llvm.loop !21

2955:                                             ; preds = %2837
  %2956 = load ptr, ptr %18, align 8, !tbaa !5
  %2957 = load ptr, ptr %31, align 8, !tbaa !5
  %2958 = getelementptr inbounds float, ptr %2957, i64 1
  %2959 = call i32 @isamax_(ptr noundef %2956, ptr noundef %2958, ptr noundef @c__1)
  store i32 %2959, ptr %69, align 4, !tbaa !9
  %2960 = load ptr, ptr %31, align 8, !tbaa !5
  %2961 = load i32, ptr %69, align 4, !tbaa !9
  %2962 = sext i32 %2961 to i64
  %2963 = getelementptr inbounds float, ptr %2960, i64 %2962
  %2964 = load float, ptr %2963, align 4, !tbaa !11
  %2965 = load ptr, ptr %28, align 8, !tbaa !5
  %2966 = load i32, ptr %61, align 4, !tbaa !9
  %2967 = sext i32 %2966 to i64
  %2968 = getelementptr inbounds float, ptr %2965, i64 %2967
  store float %2964, ptr %2968, align 4, !tbaa !11
  %2969 = load ptr, ptr %31, align 8, !tbaa !5
  %2970 = getelementptr inbounds float, ptr %2969, i64 1
  store float 1.000000e+00, ptr %2970, align 4, !tbaa !11
  %2971 = load ptr, ptr %18, align 8, !tbaa !5
  %2972 = load i32, ptr %2971, align 4, !tbaa !9
  store i32 %2972, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %2973

2973:                                             ; preds = %3003, %2955
  %2974 = load i32, ptr %60, align 4, !tbaa !9
  %2975 = load i32, ptr %38, align 4, !tbaa !9
  %2976 = icmp sle i32 %2974, %2975
  br i1 %2976, label %2977, label %3006

2977:                                             ; preds = %2973
  %2978 = load ptr, ptr %31, align 8, !tbaa !5
  %2979 = load i32, ptr %60, align 4, !tbaa !9
  %2980 = sub nsw i32 %2979, 1
  %2981 = sext i32 %2980 to i64
  %2982 = getelementptr inbounds float, ptr %2978, i64 %2981
  %2983 = load float, ptr %2982, align 4, !tbaa !11
  %2984 = load ptr, ptr %23, align 8, !tbaa !5
  %2985 = load i32, ptr %60, align 4, !tbaa !9
  %2986 = sub nsw i32 %2985, 1
  %2987 = sext i32 %2986 to i64
  %2988 = getelementptr inbounds %struct.complex, ptr %2984, i64 %2987
  %2989 = call <2 x float> @Cf(ptr noundef %2988)
  store <2 x float> %2989, ptr %115, align 4
  %2990 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 0
  %2991 = load float, ptr %2990, align 4
  %2992 = getelementptr inbounds { float, float }, ptr %115, i32 0, i32 1
  %2993 = load float, ptr %2992, align 4
  %2994 = getelementptr inbounds { float, float }, ptr %116, i32 0, i32 0
  %2995 = getelementptr inbounds { float, float }, ptr %116, i32 0, i32 1
  store float %2991, ptr %2994, align 4
  store float %2993, ptr %2995, align 4
  %2996 = load <2 x float>, ptr %116, align 4
  %2997 = call float @cabsf(<2 x float> noundef %2996) #7
  %2998 = call float @llvm.fmuladd.f32(float %2983, float %2997, float 1.000000e+00)
  %2999 = load ptr, ptr %31, align 8, !tbaa !5
  %3000 = load i32, ptr %60, align 4, !tbaa !9
  %3001 = sext i32 %3000 to i64
  %3002 = getelementptr inbounds float, ptr %2999, i64 %3001
  store float %2998, ptr %3002, align 4, !tbaa !11
  br label %3003

3003:                                             ; preds = %2977
  %3004 = load i32, ptr %60, align 4, !tbaa !9
  %3005 = add nsw i32 %3004, 1
  store i32 %3005, ptr %60, align 4, !tbaa !9
  br label %2973, !llvm.loop !22

3006:                                             ; preds = %2973
  %3007 = load ptr, ptr %22, align 8, !tbaa !5
  %3008 = load ptr, ptr %18, align 8, !tbaa !5
  %3009 = load i32, ptr %3008, align 4, !tbaa !9
  %3010 = sext i32 %3009 to i64
  %3011 = getelementptr inbounds float, ptr %3007, i64 %3010
  %3012 = load float, ptr %3011, align 4, !tbaa !11
  %3013 = load ptr, ptr %31, align 8, !tbaa !5
  %3014 = load ptr, ptr %18, align 8, !tbaa !5
  %3015 = load i32, ptr %3014, align 4, !tbaa !9
  %3016 = sext i32 %3015 to i64
  %3017 = getelementptr inbounds float, ptr %3013, i64 %3016
  %3018 = load float, ptr %3017, align 4, !tbaa !11
  %3019 = fdiv float %3018, %3012
  store float %3019, ptr %3017, align 4, !tbaa !11
  %3020 = load ptr, ptr %18, align 8, !tbaa !5
  %3021 = load i32, ptr %3020, align 4, !tbaa !9
  %3022 = sub nsw i32 %3021, 1
  store i32 %3022, ptr %60, align 4, !tbaa !9
  br label %3023

3023:                                             ; preds = %3062, %3006
  %3024 = load i32, ptr %60, align 4, !tbaa !9
  %3025 = icmp sge i32 %3024, 1
  br i1 %3025, label %3026, label %3065

3026:                                             ; preds = %3023
  %3027 = load ptr, ptr %31, align 8, !tbaa !5
  %3028 = load i32, ptr %60, align 4, !tbaa !9
  %3029 = sext i32 %3028 to i64
  %3030 = getelementptr inbounds float, ptr %3027, i64 %3029
  %3031 = load float, ptr %3030, align 4, !tbaa !11
  %3032 = load ptr, ptr %22, align 8, !tbaa !5
  %3033 = load i32, ptr %60, align 4, !tbaa !9
  %3034 = sext i32 %3033 to i64
  %3035 = getelementptr inbounds float, ptr %3032, i64 %3034
  %3036 = load float, ptr %3035, align 4, !tbaa !11
  %3037 = fdiv float %3031, %3036
  %3038 = load ptr, ptr %31, align 8, !tbaa !5
  %3039 = load i32, ptr %60, align 4, !tbaa !9
  %3040 = add nsw i32 %3039, 1
  %3041 = sext i32 %3040 to i64
  %3042 = getelementptr inbounds float, ptr %3038, i64 %3041
  %3043 = load float, ptr %3042, align 4, !tbaa !11
  %3044 = load ptr, ptr %23, align 8, !tbaa !5
  %3045 = load i32, ptr %60, align 4, !tbaa !9
  %3046 = sext i32 %3045 to i64
  %3047 = getelementptr inbounds %struct.complex, ptr %3044, i64 %3046
  %3048 = call <2 x float> @Cf(ptr noundef %3047)
  store <2 x float> %3048, ptr %117, align 4
  %3049 = getelementptr inbounds { float, float }, ptr %117, i32 0, i32 0
  %3050 = load float, ptr %3049, align 4
  %3051 = getelementptr inbounds { float, float }, ptr %117, i32 0, i32 1
  %3052 = load float, ptr %3051, align 4
  %3053 = getelementptr inbounds { float, float }, ptr %118, i32 0, i32 0
  %3054 = getelementptr inbounds { float, float }, ptr %118, i32 0, i32 1
  store float %3050, ptr %3053, align 4
  store float %3052, ptr %3054, align 4
  %3055 = load <2 x float>, ptr %118, align 4
  %3056 = call float @cabsf(<2 x float> noundef %3055) #7
  %3057 = call float @llvm.fmuladd.f32(float %3043, float %3056, float %3037)
  %3058 = load ptr, ptr %31, align 8, !tbaa !5
  %3059 = load i32, ptr %60, align 4, !tbaa !9
  %3060 = sext i32 %3059 to i64
  %3061 = getelementptr inbounds float, ptr %3058, i64 %3060
  store float %3057, ptr %3061, align 4, !tbaa !11
  br label %3062

3062:                                             ; preds = %3026
  %3063 = load i32, ptr %60, align 4, !tbaa !9
  %3064 = add nsw i32 %3063, -1
  store i32 %3064, ptr %60, align 4, !tbaa !9
  br label %3023, !llvm.loop !23

3065:                                             ; preds = %3023
  %3066 = load ptr, ptr %18, align 8, !tbaa !5
  %3067 = load ptr, ptr %31, align 8, !tbaa !5
  %3068 = getelementptr inbounds float, ptr %3067, i64 1
  %3069 = call i32 @isamax_(ptr noundef %3066, ptr noundef %3068, ptr noundef @c__1)
  store i32 %3069, ptr %69, align 4, !tbaa !9
  %3070 = load ptr, ptr %31, align 8, !tbaa !5
  %3071 = load i32, ptr %69, align 4, !tbaa !9
  %3072 = sext i32 %3071 to i64
  %3073 = getelementptr inbounds float, ptr %3070, i64 %3072
  %3074 = load float, ptr %3073, align 4, !tbaa !11
  store float %3074, ptr %43, align 4, !tbaa !11
  %3075 = load float, ptr %43, align 4, !tbaa !11
  %3076 = fcmp oge float %3075, 0.000000e+00
  br i1 %3076, label %3077, label %3079

3077:                                             ; preds = %3065
  %3078 = load float, ptr %43, align 4, !tbaa !11
  br label %3082

3079:                                             ; preds = %3065
  %3080 = load float, ptr %43, align 4, !tbaa !11
  %3081 = fneg float %3080
  br label %3082

3082:                                             ; preds = %3079, %3077
  %3083 = phi float [ %3078, %3077 ], [ %3081, %3079 ]
  %3084 = load ptr, ptr %28, align 8, !tbaa !5
  %3085 = load i32, ptr %61, align 4, !tbaa !9
  %3086 = sext i32 %3085 to i64
  %3087 = getelementptr inbounds float, ptr %3084, i64 %3086
  %3088 = load float, ptr %3087, align 4, !tbaa !11
  %3089 = fmul float %3088, %3083
  store float %3089, ptr %3087, align 4, !tbaa !11
  store float 0.000000e+00, ptr %72, align 4, !tbaa !11
  %3090 = load ptr, ptr %18, align 8, !tbaa !5
  %3091 = load i32, ptr %3090, align 4, !tbaa !9
  store i32 %3091, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %3092

3092:                                             ; preds = %3124, %3082
  %3093 = load i32, ptr %60, align 4, !tbaa !9
  %3094 = load i32, ptr %38, align 4, !tbaa !9
  %3095 = icmp sle i32 %3093, %3094
  br i1 %3095, label %3096, label %3127

3096:                                             ; preds = %3092
  %3097 = load float, ptr %72, align 4, !tbaa !11
  store float %3097, ptr %43, align 4, !tbaa !11
  %3098 = load ptr, ptr %26, align 8, !tbaa !5
  %3099 = load i32, ptr %60, align 4, !tbaa !9
  %3100 = load i32, ptr %61, align 4, !tbaa !9
  %3101 = load i32, ptr %35, align 4, !tbaa !9
  %3102 = mul nsw i32 %3100, %3101
  %3103 = add nsw i32 %3099, %3102
  %3104 = sext i32 %3103 to i64
  %3105 = getelementptr inbounds %struct.complex, ptr %3098, i64 %3104
  %3106 = call <2 x float> @Cf(ptr noundef %3105)
  store <2 x float> %3106, ptr %119, align 4
  %3107 = getelementptr inbounds { float, float }, ptr %119, i32 0, i32 0
  %3108 = load float, ptr %3107, align 4
  %3109 = getelementptr inbounds { float, float }, ptr %119, i32 0, i32 1
  %3110 = load float, ptr %3109, align 4
  %3111 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 0
  %3112 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 1
  store float %3108, ptr %3111, align 4
  store float %3110, ptr %3112, align 4
  %3113 = load <2 x float>, ptr %120, align 4
  %3114 = call float @cabsf(<2 x float> noundef %3113) #7
  store float %3114, ptr %44, align 4, !tbaa !11
  %3115 = load float, ptr %43, align 4, !tbaa !11
  %3116 = load float, ptr %44, align 4, !tbaa !11
  %3117 = fcmp oge float %3115, %3116
  br i1 %3117, label %3118, label %3120

3118:                                             ; preds = %3096
  %3119 = load float, ptr %43, align 4, !tbaa !11
  br label %3122

3120:                                             ; preds = %3096
  %3121 = load float, ptr %44, align 4, !tbaa !11
  br label %3122

3122:                                             ; preds = %3120, %3118
  %3123 = phi float [ %3119, %3118 ], [ %3121, %3120 ]
  store float %3123, ptr %72, align 4, !tbaa !11
  br label %3124

3124:                                             ; preds = %3122
  %3125 = load i32, ptr %60, align 4, !tbaa !9
  %3126 = add nsw i32 %3125, 1
  store i32 %3126, ptr %60, align 4, !tbaa !9
  br label %3092, !llvm.loop !24

3127:                                             ; preds = %3092
  %3128 = load float, ptr %72, align 4, !tbaa !11
  %3129 = fcmp une float %3128, 0.000000e+00
  br i1 %3129, label %3130, label %3138

3130:                                             ; preds = %3127
  %3131 = load float, ptr %72, align 4, !tbaa !11
  %3132 = load ptr, ptr %28, align 8, !tbaa !5
  %3133 = load i32, ptr %61, align 4, !tbaa !9
  %3134 = sext i32 %3133 to i64
  %3135 = getelementptr inbounds float, ptr %3132, i64 %3134
  %3136 = load float, ptr %3135, align 4, !tbaa !11
  %3137 = fdiv float %3136, %3131
  store float %3137, ptr %3135, align 4, !tbaa !11
  br label %3138

3138:                                             ; preds = %3130, %3127
  br label %3139

3139:                                             ; preds = %3138
  %3140 = load i32, ptr %61, align 4, !tbaa !9
  %3141 = add nsw i32 %3140, 1
  store i32 %3141, ptr %61, align 4, !tbaa !9
  br label %263, !llvm.loop !25

3142:                                             ; preds = %263
  store i32 1, ptr %74, align 4
  br label %3143

3143:                                             ; preds = %3142, %250, %218
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  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 float @slamch_(ptr noundef) #2

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

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

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

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

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

; Function Attrs: nounwind
declare float @cabsf(<2 x float> noundef) #6

; 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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #6 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #7 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"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 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = !{!16, !12, i64 0}
!16 = !{!"", !12, i64 0, !12, i64 4}
!17 = !{!16, !12, i64 4}
!18 = distinct !{!18, !14}
!19 = distinct !{!19, !14}
!20 = distinct !{!20, !14}
!21 = distinct !{!21, !14}
!22 = distinct !{!22, !14}
!23 = distinct !{!23, !14}
!24 = distinct !{!24, !14}
!25 = distinct !{!25, !14}


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

; Function Attrs: nounwind uwtable
define dso_local void @cptrfs_(ptr noundef %0, ptr noundef %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr nocapture noundef readonly %7, ptr nocapture noundef readonly %8, ptr noundef %9, ptr nocapture noundef readonly %10, ptr nocapture noundef %11, ptr nocapture noundef %12, ptr noundef %13, ptr noundef %14, ptr noundef %15) local_unnamed_addr #0 {
  %17 = ptrtoint ptr %11 to i64
  %18 = ptrtoint ptr %12 to i64
  %19 = alloca i32, align 4
  %20 = alloca %struct.complex, align 8
  %21 = alloca %struct.complex, align 8
  %22 = alloca %struct.complex, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %19) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %20) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %21) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %22) #8
  %23 = getelementptr inbounds i8, ptr %3, i64 -4
  %24 = getelementptr inbounds i8, ptr %4, i64 -8
  %25 = getelementptr inbounds i8, ptr %5, i64 -4
  %26 = getelementptr inbounds i8, ptr %6, i64 -8
  %27 = load i32, ptr %8, align 4, !tbaa !5
  %narrow = xor i32 %27, -1
  %28 = sext i32 %narrow to i64
  %29 = getelementptr inbounds %struct.complex, ptr %7, i64 %28
  %30 = load i32, ptr %10, align 4, !tbaa !5
  %narrow947 = xor i32 %30, -1
  %31 = sext i32 %narrow947 to i64
  %32 = getelementptr inbounds %struct.complex, ptr %9, i64 %31
  %33 = getelementptr inbounds i8, ptr %11, i64 -4
  %34 = getelementptr inbounds i8, ptr %12, i64 -4
  %35 = getelementptr inbounds i8, ptr %13, i64 -8
  %36 = getelementptr inbounds i8, ptr %14, i64 -4
  store i32 0, ptr %15, align 4, !tbaa !5
  %37 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #8
  %.not = icmp eq i32 %37, 0
  br i1 %.not, label %38, label %40

38:                                               ; preds = %16
  %39 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #8
  %.not948 = icmp eq i32 %39, 0
  br i1 %.not948, label %.thread.sink.split, label %40

40:                                               ; preds = %38, %16
  %41 = load i32, ptr %1, align 4, !tbaa !5
  %42 = icmp slt i32 %41, 0
  br i1 %42, label %.thread.sink.split, label %43

43:                                               ; preds = %40
  %44 = load i32, ptr %2, align 4, !tbaa !5
  %45 = icmp slt i32 %44, 0
  br i1 %45, label %.thread.sink.split, label %46

46:                                               ; preds = %43
  %47 = load i32, ptr %8, align 4, !tbaa !5
  %spec.select = tail call i32 @llvm.umax.i32(i32 %41, i32 1)
  %48 = icmp slt i32 %47, %spec.select
  br i1 %48, label %.thread.sink.split, label %49

49:                                               ; preds = %46
  %50 = load i32, ptr %10, align 4, !tbaa !5
  %51 = icmp slt i32 %50, %spec.select
  br i1 %51, label %.thread.sink.split, label %52

52:                                               ; preds = %49
  %.pr = load i32, ptr %15, align 4, !tbaa !5
  %.not949 = icmp eq i32 %.pr, 0
  br i1 %.not949, label %56, label %.thread

.thread.sink.split:                               ; preds = %49, %46, %43, %40, %38
  %.sink = phi i32 [ -1, %38 ], [ -2, %40 ], [ -3, %43 ], [ -9, %46 ], [ -11, %49 ]
  store i32 %.sink, ptr %15, align 4, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %.thread.sink.split, %52
  %53 = phi i32 [ %.pr, %52 ], [ %.sink, %.thread.sink.split ]
  %54 = sub nsw i32 0, %53
  store i32 %54, ptr %19, align 4, !tbaa !5
  %55 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %19, i32 noundef 6) #8
  br label %.loopexit

56:                                               ; preds = %52
  %57 = icmp eq i32 %41, 0
  %.not9571003 = icmp eq i32 %44, 0
  br i1 %57, label %59, label %58

58:                                               ; preds = %56
  br i1 %.not9571003, label %.loopexit, label %82

59:                                               ; preds = %56
  br i1 %.not9571003, label %.loopexit, label %.lr.ph1006.preheader

.lr.ph1006.preheader:                             ; preds = %59
  %60 = add nuw i32 %44, 1
  %wide.trip.count1043 = zext i32 %60 to i64
  %61 = zext nneg i32 %44 to i64
  %min.iters.check = icmp ult i32 %44, 8
  %62 = sub i64 %18, %17
  %diff.check = icmp ult i64 %62, 32
  %or.cond1095 = or i1 %min.iters.check, %diff.check
  br i1 %or.cond1095, label %.lr.ph1006.preheader1113, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph1006.preheader
  %n.vec = and i64 %61, 2147483640
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %63 = getelementptr float, ptr %11, i64 %index
  %64 = getelementptr inbounds i8, ptr %63, i64 16
  store <4 x float> zeroinitializer, ptr %63, align 4, !tbaa !9
  store <4 x float> zeroinitializer, ptr %64, align 4, !tbaa !9
  %65 = getelementptr float, ptr %12, i64 %index
  %66 = getelementptr inbounds i8, ptr %65, i64 16
  store <4 x float> zeroinitializer, ptr %65, align 4, !tbaa !9
  store <4 x float> zeroinitializer, ptr %66, align 4, !tbaa !9
  %index.next = add nuw i64 %index, 8
  %67 = icmp eq i64 %index.next, %n.vec
  br i1 %67, label %middle.block, label %vector.body, !llvm.loop !11

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %61
  br i1 %cmp.n, label %.loopexit, label %.lr.ph1006.preheader1113

.lr.ph1006.preheader1113:                         ; preds = %middle.block, %.lr.ph1006.preheader
  %indvars.iv1040.ph = phi i64 [ 1, %.lr.ph1006.preheader ], [ %ind.end, %middle.block ]
  %68 = sub nsw i64 %wide.trip.count1043, %indvars.iv1040.ph
  %69 = zext nneg i32 %44 to i64
  %70 = sub nsw i64 %69, %indvars.iv1040.ph
  %xtraiter = and i64 %68, 3
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.lr.ph1006.prol.loopexit, label %.lr.ph1006.prol

.lr.ph1006.prol:                                  ; preds = %.lr.ph1006.preheader1113, %.lr.ph1006.prol
  %indvars.iv1040.prol = phi i64 [ %indvars.iv.next1041.prol, %.lr.ph1006.prol ], [ %indvars.iv1040.ph, %.lr.ph1006.preheader1113 ]
  %prol.iter = phi i64 [ %prol.iter.next, %.lr.ph1006.prol ], [ 0, %.lr.ph1006.preheader1113 ]
  %71 = getelementptr inbounds float, ptr %33, i64 %indvars.iv1040.prol
  store float 0.000000e+00, ptr %71, align 4, !tbaa !9
  %72 = getelementptr inbounds float, ptr %34, i64 %indvars.iv1040.prol
  store float 0.000000e+00, ptr %72, align 4, !tbaa !9
  %indvars.iv.next1041.prol = add nuw nsw i64 %indvars.iv1040.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %.lr.ph1006.prol.loopexit, label %.lr.ph1006.prol, !llvm.loop !15

.lr.ph1006.prol.loopexit:                         ; preds = %.lr.ph1006.prol, %.lr.ph1006.preheader1113
  %indvars.iv1040.unr = phi i64 [ %indvars.iv1040.ph, %.lr.ph1006.preheader1113 ], [ %indvars.iv.next1041.prol, %.lr.ph1006.prol ]
  %73 = icmp ult i64 %70, 3
  br i1 %73, label %.loopexit, label %.lr.ph1006

.lr.ph1006:                                       ; preds = %.lr.ph1006.prol.loopexit, %.lr.ph1006
  %indvars.iv1040 = phi i64 [ %indvars.iv.next1041.3, %.lr.ph1006 ], [ %indvars.iv1040.unr, %.lr.ph1006.prol.loopexit ]
  %74 = getelementptr inbounds float, ptr %33, i64 %indvars.iv1040
  store float 0.000000e+00, ptr %74, align 4, !tbaa !9
  %75 = getelementptr inbounds float, ptr %34, i64 %indvars.iv1040
  store float 0.000000e+00, ptr %75, align 4, !tbaa !9
  %76 = getelementptr float, ptr %11, i64 %indvars.iv1040
  store float 0.000000e+00, ptr %76, align 4, !tbaa !9
  %77 = getelementptr float, ptr %12, i64 %indvars.iv1040
  store float 0.000000e+00, ptr %77, align 4, !tbaa !9
  %indvars.iv.next1041.1 = add nuw nsw i64 %indvars.iv1040, 2
  %78 = getelementptr inbounds float, ptr %33, i64 %indvars.iv.next1041.1
  store float 0.000000e+00, ptr %78, align 4, !tbaa !9
  %79 = getelementptr inbounds float, ptr %34, i64 %indvars.iv.next1041.1
  store float 0.000000e+00, ptr %79, align 4, !tbaa !9
  %indvars.iv.next1041.2 = add nuw nsw i64 %indvars.iv1040, 3
  %80 = getelementptr inbounds float, ptr %33, i64 %indvars.iv.next1041.2
  store float 0.000000e+00, ptr %80, align 4, !tbaa !9
  %81 = getelementptr inbounds float, ptr %34, i64 %indvars.iv.next1041.2
  store float 0.000000e+00, ptr %81, align 4, !tbaa !9
  %indvars.iv.next1041.3 = add nuw nsw i64 %indvars.iv1040, 4
  %exitcond1044.not.3 = icmp eq i64 %indvars.iv.next1041.3, %wide.trip.count1043
  br i1 %exitcond1044.not.3, label %.loopexit, label %.lr.ph1006, !llvm.loop !17

82:                                               ; preds = %58
  %83 = tail call float @slamch_(ptr noundef nonnull @.str.3) #8
  %84 = tail call float @slamch_(ptr noundef nonnull @.str.4) #8
  %85 = fmul float %84, 4.000000e+00
  %86 = fdiv float %85, %83
  %87 = load i32, ptr %2, align 4, !tbaa !5
  store i32 %87, ptr %19, align 4, !tbaa !5
  %.not9501001 = icmp slt i32 %87, 1
  br i1 %.not9501001, label %.loopexit, label %.preheader.lr.ph

.preheader.lr.ph:                                 ; preds = %82
  %invariant.gep = getelementptr i8, ptr %4, i64 -16
  %invariant.gep978 = getelementptr i8, ptr %32, i64 8
  %88 = getelementptr inbounds i8, ptr %4, i64 4
  %89 = getelementptr inbounds i8, ptr %20, i64 4
  %90 = fmul float %83, 4.000000e+00
  %91 = sext i32 %27 to i64
  %92 = sext i32 %30 to i64
  %invariant.gep1071 = getelementptr i8, ptr %6, i64 -16
  %invariant.gep1117 = getelementptr i8, ptr %29, i64 8
  br label %.preheader

.preheader:                                       ; preds = %.preheader.lr.ph, %._crit_edge999.thread
  %indvars.iv1037 = phi i64 [ 1, %.preheader.lr.ph ], [ %indvars.iv.next1038, %._crit_edge999.thread ]
  %93 = getelementptr inbounds float, ptr %34, i64 %indvars.iv1037
  %94 = mul nsw i64 %indvars.iv1037, %91
  %gep1118 = getelementptr %struct.complex, ptr %invariant.gep1117, i64 %94
  %95 = mul nsw i64 %indvars.iv1037, %92
  %96 = getelementptr %struct.complex, ptr %32, i64 %95
  %97 = getelementptr i8, ptr %96, i64 8
  %98 = getelementptr i8, ptr %96, i64 16
  %99 = trunc nsw i64 %95 to i32
  %100 = add i32 %99, -1
  %gep979 = getelementptr %struct.complex, ptr %invariant.gep978, i64 %95
  %invariant.gep1055 = getelementptr %struct.complex, ptr %29, i64 %94
  %invariant.gep1057 = getelementptr %struct.complex, ptr %32, i64 %95
  %invariant.gep1059 = getelementptr %struct.complex, ptr %32, i64 %95
  %invariant.gep1061 = getelementptr %struct.complex, ptr %32, i64 %95
  %101 = getelementptr %struct.complex, ptr %29, i64 %94
  %102 = getelementptr %struct.complex, ptr %32, i64 %95
  %103 = getelementptr %struct.complex, ptr %32, i64 %95
  %invariant.gep1063 = getelementptr %struct.complex, ptr %29, i64 %94
  %invariant.gep1065 = getelementptr %struct.complex, ptr %32, i64 %95
  %invariant.gep1067 = getelementptr %struct.complex, ptr %32, i64 %95
  %invariant.gep1069 = getelementptr %struct.complex, ptr %32, i64 %95
  %104 = getelementptr %struct.complex, ptr %29, i64 %94
  %105 = getelementptr %struct.complex, ptr %32, i64 %95
  %106 = getelementptr %struct.complex, ptr %32, i64 %95
  br label %107

107:                                              ; preds = %.preheader, %619
  %.0942 = phi float [ %620, %619 ], [ 3.000000e+00, %.preheader ]
  %.0941 = phi i32 [ %621, %619 ], [ 1, %.preheader ]
  %108 = load i32, ptr %1, align 4, !tbaa !5
  %109 = icmp eq i32 %108, 1
  %110 = load float, ptr %3, align 4, !tbaa !9
  %111 = load <2 x float>, ptr %gep1118, align 4, !tbaa !9
  store <2 x float> %111, ptr %21, align 8, !tbaa !9
  %112 = load <2 x float>, ptr %97, align 4, !tbaa !9
  %113 = insertelement <2 x float> poison, float %110, i64 0
  %114 = shufflevector <2 x float> %113, <2 x float> poison, <2 x i32> zeroinitializer
  %115 = fmul <2 x float> %114, %112
  store <2 x float> %115, ptr %22, align 8, !tbaa !9
  br i1 %.not, label %344, label %116

116:                                              ; preds = %107
  br i1 %109, label %thread-pre-split, label %117

117:                                              ; preds = %116
  %118 = load float, ptr %4, align 4, !tbaa !18
  %119 = load float, ptr %88, align 4, !tbaa !20
  %120 = fneg float %119
  %121 = fsub <2 x float> %111, %115
  store <2 x float> %121, ptr %20, align 8, !tbaa !9
  %122 = load <2 x float>, ptr %98, align 4, !tbaa !9
  %123 = insertelement <2 x float> poison, float %119, i64 0
  %124 = insertelement <2 x float> %123, float %120, i64 1
  %125 = fmul <2 x float> %122, %124
  %126 = shufflevector <2 x float> %125, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %127 = insertelement <2 x float> poison, float %118, i64 0
  %128 = shufflevector <2 x float> %127, <2 x float> poison, <2 x i32> zeroinitializer
  %129 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %128, <2 x float> %122, <2 x float> %126)
  %130 = fsub <2 x float> %121, %129
  store <2 x float> %130, ptr %13, align 4, !tbaa !9
  %131 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %132 = load float, ptr %22, align 8, !tbaa !18
  %133 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %134 = insertelement <2 x float> %111, float %132, i64 1
  %135 = fcmp oge <2 x float> %134, zeroinitializer
  %136 = fneg <2 x float> %134
  %137 = select <2 x i1> %135, <2 x float> %134, <2 x float> %136
  %138 = shufflevector <2 x float> %131, <2 x float> %133, <2 x i32> <i32 1, i32 3>
  %139 = fcmp oge <2 x float> %138, zeroinitializer
  %140 = fneg <2 x float> %138
  %141 = select <2 x i1> %139, <2 x float> %138, <2 x float> %140
  %142 = fadd <2 x float> %137, %141
  %shift = shufflevector <2 x float> %142, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %143 = fadd <2 x float> %142, %shift
  %144 = extractelement <2 x float> %143, i64 0
  %145 = load float, ptr %4, align 4, !tbaa !18
  %146 = fcmp oge float %145, 0.000000e+00
  %147 = fneg float %145
  %148 = select i1 %146, float %145, float %147
  %149 = call <2 x float> @Cf(ptr noundef nonnull %4)
  %.sroa.045.4.vec.extract = extractelement <2 x float> %149, i64 1
  %150 = fcmp oge float %.sroa.045.4.vec.extract, 0.000000e+00
  %151 = fneg float %.sroa.045.4.vec.extract
  %152 = select i1 %150, float %.sroa.045.4.vec.extract, float %151
  %153 = fadd float %148, %152
  %154 = load float, ptr %98, align 4, !tbaa !18
  %155 = fcmp oge float %154, 0.000000e+00
  %156 = fneg float %154
  %157 = select i1 %155, float %154, float %156
  %158 = call <2 x float> @Cf(ptr noundef nonnull %98)
  %.sroa.044.4.vec.extract = extractelement <2 x float> %158, i64 1
  %159 = fcmp oge float %.sroa.044.4.vec.extract, 0.000000e+00
  %160 = fneg float %.sroa.044.4.vec.extract
  %161 = select i1 %159, float %.sroa.044.4.vec.extract, float %160
  %162 = fadd float %157, %161
  %163 = call float @llvm.fmuladd.f32(float %153, float %162, float %144)
  store float %163, ptr %14, align 4, !tbaa !9
  %164 = load i32, ptr %1, align 4, !tbaa !5
  %.not952.not961 = icmp sgt i32 %164, 2
  br i1 %.not952.not961, label %.lr.ph.preheader, label %._crit_edge

.lr.ph.preheader:                                 ; preds = %117
  %wide.trip.count = zext nneg i32 %164 to i64
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv = phi i64 [ 2, %.lr.ph.preheader ], [ %indvars.iv.next, %.lr.ph ]
  %gep1056 = getelementptr %struct.complex, ptr %invariant.gep1055, i64 %indvars.iv
  %165 = load <2 x float>, ptr %gep1056, align 4, !tbaa !9
  store <2 x float> %165, ptr %21, align 8, !tbaa !9
  %166 = add nsw i64 %indvars.iv, -1
  %167 = getelementptr inbounds %struct.complex, ptr %24, i64 %166
  %168 = call <2 x float> @Cf(ptr noundef nonnull %167)
  %.sroa.043.0.vec.extract = extractelement <2 x float> %168, i64 0
  %.sroa.043.4.vec.extract = extractelement <2 x float> %168, i64 1
  %169 = fneg float %.sroa.043.4.vec.extract
  %170 = call ptr @_pCf(ptr noundef nonnull %20)
  %171 = getelementptr inbounds i8, ptr %170, i64 4
  store float %.sroa.043.0.vec.extract, ptr %170, align 4
  store float %169, ptr %171, align 4
  %172 = load float, ptr %20, align 8, !tbaa !18
  %gep1058 = getelementptr %struct.complex, ptr %invariant.gep1057, i64 %166
  %173 = load float, ptr %89, align 4, !tbaa !20
  %174 = fneg float %173
  %175 = getelementptr inbounds float, ptr %23, i64 %indvars.iv
  %176 = load float, ptr %175, align 4, !tbaa !9
  %gep1060 = getelementptr %struct.complex, ptr %invariant.gep1059, i64 %indvars.iv
  %177 = load <2 x float>, ptr %gep1060, align 4, !tbaa !9
  %178 = insertelement <2 x float> poison, float %176, i64 0
  %179 = shufflevector <2 x float> %178, <2 x float> poison, <2 x i32> zeroinitializer
  %180 = fmul <2 x float> %179, %177
  store <2 x float> %180, ptr %22, align 8, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %181 = getelementptr inbounds %struct.complex, ptr %24, i64 %indvars.iv
  %182 = load float, ptr %181, align 4, !tbaa !18
  %gep1062 = getelementptr %struct.complex, ptr %invariant.gep1061, i64 %indvars.iv.next
  %183 = getelementptr inbounds i8, ptr %181, i64 4
  %184 = load float, ptr %183, align 4, !tbaa !20
  %185 = fneg float %184
  %186 = load <2 x float>, ptr %gep1058, align 4, !tbaa !9
  %187 = insertelement <2 x float> poison, float %173, i64 0
  %188 = insertelement <2 x float> %187, float %174, i64 1
  %189 = fmul <2 x float> %186, %188
  %190 = shufflevector <2 x float> %189, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %191 = insertelement <2 x float> poison, float %172, i64 0
  %192 = shufflevector <2 x float> %191, <2 x float> poison, <2 x i32> zeroinitializer
  %193 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %192, <2 x float> %186, <2 x float> %190)
  %194 = load <2 x float>, ptr %21, align 8, !tbaa !9
  %195 = fsub <2 x float> %194, %193
  %196 = fsub <2 x float> %195, %180
  store <2 x float> %196, ptr %20, align 8, !tbaa !9
  %197 = getelementptr inbounds %struct.complex, ptr %35, i64 %indvars.iv
  %198 = load <2 x float>, ptr %gep1062, align 4, !tbaa !9
  %199 = insertelement <2 x float> poison, float %184, i64 0
  %200 = insertelement <2 x float> %199, float %185, i64 1
  %201 = fmul <2 x float> %198, %200
  %202 = shufflevector <2 x float> %201, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %203 = insertelement <2 x float> poison, float %182, i64 0
  %204 = shufflevector <2 x float> %203, <2 x float> poison, <2 x i32> zeroinitializer
  %205 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %204, <2 x float> %198, <2 x float> %202)
  %206 = fsub <2 x float> %196, %205
  store <2 x float> %206, ptr %197, align 4, !tbaa !9
  %207 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %208 = shufflevector <2 x float> %194, <2 x float> %207, <2 x i32> <i32 0, i32 3>
  %209 = fcmp oge <2 x float> %208, zeroinitializer
  %210 = fneg <2 x float> %208
  %211 = select <2 x i1> %209, <2 x float> %208, <2 x float> %210
  %shift1107 = shufflevector <2 x float> %211, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %212 = fadd <2 x float> %211, %shift1107
  %213 = extractelement <2 x float> %212, i64 0
  %214 = load float, ptr %167, align 4, !tbaa !18
  %215 = fcmp oge float %214, 0.000000e+00
  %216 = fneg float %214
  %217 = select i1 %215, float %214, float %216
  %218 = call <2 x float> @Cf(ptr noundef nonnull %167)
  %.sroa.041.4.vec.extract = extractelement <2 x float> %218, i64 1
  %219 = fcmp oge float %.sroa.041.4.vec.extract, 0.000000e+00
  %220 = fneg float %.sroa.041.4.vec.extract
  %221 = select i1 %219, float %.sroa.041.4.vec.extract, float %220
  %222 = fadd float %217, %221
  %223 = load float, ptr %gep1058, align 4, !tbaa !18
  %224 = fcmp oge float %223, 0.000000e+00
  %225 = fneg float %223
  %226 = select i1 %224, float %223, float %225
  %227 = call <2 x float> @Cf(ptr noundef nonnull %gep1058)
  %.sroa.040.4.vec.extract = extractelement <2 x float> %227, i64 1
  %228 = fcmp oge float %.sroa.040.4.vec.extract, 0.000000e+00
  %229 = fneg float %.sroa.040.4.vec.extract
  %230 = select i1 %228, float %.sroa.040.4.vec.extract, float %229
  %231 = fadd float %226, %230
  %232 = call float @llvm.fmuladd.f32(float %222, float %231, float %213)
  %233 = load float, ptr %22, align 8, !tbaa !18
  %234 = fcmp oge float %233, 0.000000e+00
  %235 = fneg float %233
  %236 = select i1 %234, float %233, float %235
  %237 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %.sroa.039.4.vec.extract = extractelement <2 x float> %237, i64 1
  %238 = fcmp oge float %.sroa.039.4.vec.extract, 0.000000e+00
  %239 = fneg float %.sroa.039.4.vec.extract
  %240 = select i1 %238, float %.sroa.039.4.vec.extract, float %239
  %241 = fadd float %236, %240
  %242 = fadd float %232, %241
  %243 = load float, ptr %181, align 4, !tbaa !18
  %244 = fcmp oge float %243, 0.000000e+00
  %245 = fneg float %243
  %246 = select i1 %244, float %243, float %245
  %247 = call <2 x float> @Cf(ptr noundef nonnull %181)
  %.sroa.038.4.vec.extract = extractelement <2 x float> %247, i64 1
  %248 = fcmp oge float %.sroa.038.4.vec.extract, 0.000000e+00
  %249 = fneg float %.sroa.038.4.vec.extract
  %250 = select i1 %248, float %.sroa.038.4.vec.extract, float %249
  %251 = fadd float %246, %250
  %252 = load float, ptr %gep1062, align 4, !tbaa !18
  %253 = fcmp oge float %252, 0.000000e+00
  %254 = fneg float %252
  %255 = select i1 %253, float %252, float %254
  %256 = call <2 x float> @Cf(ptr noundef nonnull %gep1062)
  %.sroa.037.4.vec.extract = extractelement <2 x float> %256, i64 1
  %257 = fcmp oge float %.sroa.037.4.vec.extract, 0.000000e+00
  %258 = fneg float %.sroa.037.4.vec.extract
  %259 = select i1 %257, float %.sroa.037.4.vec.extract, float %258
  %260 = fadd float %255, %259
  %261 = call float @llvm.fmuladd.f32(float %251, float %260, float %242)
  %262 = getelementptr inbounds float, ptr %36, i64 %indvars.iv
  store float %261, ptr %262, align 4, !tbaa !9
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge.loopexit, label %.lr.ph, !llvm.loop !21

._crit_edge.loopexit:                             ; preds = %.lr.ph
  %.pre = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %117
  %263 = phi i32 [ %.pre, %._crit_edge.loopexit ], [ %164, %117 ]
  %264 = sext i32 %263 to i64
  %265 = getelementptr %struct.complex, ptr %101, i64 %264
  %266 = load <2 x float>, ptr %265, align 4, !tbaa !9
  store <2 x float> %266, ptr %21, align 8, !tbaa !9
  %gep = getelementptr %struct.complex, ptr %invariant.gep, i64 %264
  %267 = call <2 x float> @Cf(ptr noundef %gep)
  %.sroa.036.0.vec.extract = extractelement <2 x float> %267, i64 0
  %.sroa.036.4.vec.extract = extractelement <2 x float> %267, i64 1
  %268 = fneg float %.sroa.036.4.vec.extract
  %269 = call ptr @_pCf(ptr noundef nonnull %20)
  %270 = getelementptr inbounds i8, ptr %269, i64 4
  store float %.sroa.036.0.vec.extract, ptr %269, align 4
  store float %268, ptr %270, align 4
  %271 = load i32, ptr %1, align 4, !tbaa !5
  %272 = add nsw i32 %271, -1
  %273 = sext i32 %272 to i64
  %274 = load float, ptr %20, align 8, !tbaa !18
  %275 = getelementptr %struct.complex, ptr %102, i64 %273
  %276 = load float, ptr %89, align 4, !tbaa !20
  %277 = fneg float %276
  %278 = sext i32 %271 to i64
  %279 = getelementptr inbounds float, ptr %23, i64 %278
  %280 = load float, ptr %279, align 4, !tbaa !9
  %281 = getelementptr %struct.complex, ptr %103, i64 %278
  %282 = load <2 x float>, ptr %281, align 4, !tbaa !9
  %283 = insertelement <2 x float> poison, float %280, i64 0
  %284 = shufflevector <2 x float> %283, <2 x float> poison, <2 x i32> zeroinitializer
  %285 = fmul <2 x float> %284, %282
  store <2 x float> %285, ptr %22, align 8, !tbaa !9
  %286 = load <2 x float>, ptr %275, align 4, !tbaa !9
  %287 = insertelement <2 x float> poison, float %276, i64 0
  %288 = insertelement <2 x float> %287, float %277, i64 1
  %289 = fmul <2 x float> %286, %288
  %290 = shufflevector <2 x float> %289, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %291 = insertelement <2 x float> poison, float %274, i64 0
  %292 = shufflevector <2 x float> %291, <2 x float> poison, <2 x i32> zeroinitializer
  %293 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %292, <2 x float> %286, <2 x float> %290)
  %294 = load <2 x float>, ptr %21, align 8, !tbaa !9
  %295 = fsub <2 x float> %294, %293
  store <2 x float> %295, ptr %20, align 8, !tbaa !9
  %296 = getelementptr inbounds %struct.complex, ptr %35, i64 %278
  %297 = fsub <2 x float> %295, %285
  store <2 x float> %297, ptr %296, align 4, !tbaa !9
  %298 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %299 = shufflevector <2 x float> %294, <2 x float> %298, <2 x i32> <i32 0, i32 3>
  %300 = fcmp oge <2 x float> %299, zeroinitializer
  %301 = fneg <2 x float> %299
  %302 = select <2 x i1> %300, <2 x float> %299, <2 x float> %301
  %shift1108 = shufflevector <2 x float> %302, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %303 = fadd <2 x float> %302, %shift1108
  %304 = extractelement <2 x float> %303, i64 0
  %305 = getelementptr inbounds %struct.complex, ptr %24, i64 %273
  %306 = load float, ptr %305, align 4, !tbaa !18
  %307 = fcmp oge float %306, 0.000000e+00
  %308 = fneg float %306
  %309 = select i1 %307, float %306, float %308
  %310 = load i32, ptr %1, align 4, !tbaa !5
  %311 = sext i32 %310 to i64
  %gep975 = getelementptr %struct.complex, ptr %invariant.gep, i64 %311
  %312 = call <2 x float> @Cf(ptr noundef %gep975)
  %.sroa.034.4.vec.extract = extractelement <2 x float> %312, i64 1
  %313 = fcmp oge float %.sroa.034.4.vec.extract, 0.000000e+00
  %314 = fneg float %.sroa.034.4.vec.extract
  %315 = select i1 %313, float %.sroa.034.4.vec.extract, float %314
  %316 = fadd float %309, %315
  %317 = load float, ptr %275, align 4, !tbaa !18
  %318 = fcmp oge float %317, 0.000000e+00
  %319 = fneg float %317
  %320 = select i1 %318, float %317, float %319
  %321 = load i32, ptr %1, align 4, !tbaa !5
  %322 = add i32 %100, %321
  %323 = sext i32 %322 to i64
  %324 = getelementptr inbounds %struct.complex, ptr %32, i64 %323
  %325 = call <2 x float> @Cf(ptr noundef %324)
  %.sroa.033.4.vec.extract = extractelement <2 x float> %325, i64 1
  %326 = fcmp oge float %.sroa.033.4.vec.extract, 0.000000e+00
  %327 = fneg float %.sroa.033.4.vec.extract
  %328 = select i1 %326, float %.sroa.033.4.vec.extract, float %327
  %329 = fadd float %320, %328
  %330 = call float @llvm.fmuladd.f32(float %316, float %329, float %304)
  %331 = load float, ptr %22, align 8, !tbaa !18
  %332 = fcmp oge float %331, 0.000000e+00
  %333 = fneg float %331
  %334 = select i1 %332, float %331, float %333
  %335 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %.sroa.032.4.vec.extract = extractelement <2 x float> %335, i64 1
  %336 = fcmp oge float %.sroa.032.4.vec.extract, 0.000000e+00
  %337 = fneg float %.sroa.032.4.vec.extract
  %338 = select i1 %336, float %.sroa.032.4.vec.extract, float %337
  %339 = fadd float %334, %338
  %340 = fadd float %330, %339
  %341 = load i32, ptr %1, align 4, !tbaa !5
  %342 = sext i32 %341 to i64
  %343 = getelementptr inbounds float, ptr %36, i64 %342
  store float %340, ptr %343, align 4, !tbaa !9
  br label %587

344:                                              ; preds = %107
  br i1 %109, label %thread-pre-split, label %345

345:                                              ; preds = %344
  %346 = call <2 x float> @Cf(ptr noundef %4)
  %.sroa.029.0.vec.extract = extractelement <2 x float> %346, i64 0
  %.sroa.029.4.vec.extract = extractelement <2 x float> %346, i64 1
  %347 = fneg float %.sroa.029.4.vec.extract
  %348 = call ptr @_pCf(ptr noundef nonnull %20)
  %349 = getelementptr inbounds i8, ptr %348, i64 4
  store float %.sroa.029.0.vec.extract, ptr %348, align 4
  store float %347, ptr %349, align 4
  %350 = load float, ptr %20, align 8, !tbaa !18
  %351 = load float, ptr %89, align 4, !tbaa !20
  %352 = fneg float %351
  %353 = load <2 x float>, ptr %21, align 8, !tbaa !9
  %354 = load <2 x float>, ptr %22, align 8, !tbaa !9
  %355 = fsub <2 x float> %353, %354
  store <2 x float> %355, ptr %20, align 8, !tbaa !9
  %356 = load <2 x float>, ptr %98, align 4, !tbaa !9
  %357 = insertelement <2 x float> poison, float %351, i64 0
  %358 = insertelement <2 x float> %357, float %352, i64 1
  %359 = fmul <2 x float> %356, %358
  %360 = shufflevector <2 x float> %359, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %361 = insertelement <2 x float> poison, float %350, i64 0
  %362 = shufflevector <2 x float> %361, <2 x float> poison, <2 x i32> zeroinitializer
  %363 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %362, <2 x float> %356, <2 x float> %360)
  %364 = fsub <2 x float> %355, %363
  store <2 x float> %364, ptr %13, align 4, !tbaa !9
  %365 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %366 = load float, ptr %22, align 8, !tbaa !18
  %367 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %368 = insertelement <2 x float> %353, float %366, i64 1
  %369 = fcmp oge <2 x float> %368, zeroinitializer
  %370 = fneg <2 x float> %368
  %371 = select <2 x i1> %369, <2 x float> %368, <2 x float> %370
  %372 = shufflevector <2 x float> %365, <2 x float> %367, <2 x i32> <i32 1, i32 3>
  %373 = fcmp oge <2 x float> %372, zeroinitializer
  %374 = fneg <2 x float> %372
  %375 = select <2 x i1> %373, <2 x float> %372, <2 x float> %374
  %376 = fadd <2 x float> %371, %375
  %shift1109 = shufflevector <2 x float> %376, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %377 = fadd <2 x float> %376, %shift1109
  %378 = extractelement <2 x float> %377, i64 0
  %379 = load float, ptr %4, align 4, !tbaa !18
  %380 = fcmp oge float %379, 0.000000e+00
  %381 = fneg float %379
  %382 = select i1 %380, float %379, float %381
  %383 = call <2 x float> @Cf(ptr noundef nonnull %4)
  %.sroa.026.4.vec.extract = extractelement <2 x float> %383, i64 1
  %384 = fcmp oge float %.sroa.026.4.vec.extract, 0.000000e+00
  %385 = fneg float %.sroa.026.4.vec.extract
  %386 = select i1 %384, float %.sroa.026.4.vec.extract, float %385
  %387 = fadd float %382, %386
  %388 = load float, ptr %98, align 4, !tbaa !18
  %389 = fcmp oge float %388, 0.000000e+00
  %390 = fneg float %388
  %391 = select i1 %389, float %388, float %390
  %392 = call <2 x float> @Cf(ptr noundef nonnull %98)
  %.sroa.025.4.vec.extract = extractelement <2 x float> %392, i64 1
  %393 = fcmp oge float %.sroa.025.4.vec.extract, 0.000000e+00
  %394 = fneg float %.sroa.025.4.vec.extract
  %395 = select i1 %393, float %.sroa.025.4.vec.extract, float %394
  %396 = fadd float %391, %395
  %397 = call float @llvm.fmuladd.f32(float %387, float %396, float %378)
  store float %397, ptr %14, align 4, !tbaa !9
  %398 = load i32, ptr %1, align 4, !tbaa !5
  %.not951.not963 = icmp sgt i32 %398, 2
  br i1 %.not951.not963, label %.lr.ph966.preheader, label %._crit_edge967

.lr.ph966.preheader:                              ; preds = %345
  %wide.trip.count1012 = zext nneg i32 %398 to i64
  br label %.lr.ph966

.lr.ph966:                                        ; preds = %.lr.ph966.preheader, %.lr.ph966
  %indvars.iv1009 = phi i64 [ 2, %.lr.ph966.preheader ], [ %indvars.iv.next1010, %.lr.ph966 ]
  %gep1064 = getelementptr %struct.complex, ptr %invariant.gep1063, i64 %indvars.iv1009
  %399 = load <2 x float>, ptr %gep1064, align 4, !tbaa !9
  store <2 x float> %399, ptr %21, align 8, !tbaa !9
  %400 = add nsw i64 %indvars.iv1009, -1
  %401 = getelementptr inbounds %struct.complex, ptr %24, i64 %400
  %402 = load float, ptr %401, align 4, !tbaa !18
  %gep1066 = getelementptr %struct.complex, ptr %invariant.gep1065, i64 %400
  %403 = getelementptr inbounds i8, ptr %401, i64 4
  %404 = load float, ptr %403, align 4, !tbaa !20
  %405 = fneg float %404
  %406 = getelementptr inbounds float, ptr %23, i64 %indvars.iv1009
  %407 = load float, ptr %406, align 4, !tbaa !9
  %gep1068 = getelementptr %struct.complex, ptr %invariant.gep1067, i64 %indvars.iv1009
  %408 = load <2 x float>, ptr %gep1068, align 4, !tbaa !9
  %409 = insertelement <2 x float> poison, float %407, i64 0
  %410 = shufflevector <2 x float> %409, <2 x float> poison, <2 x i32> zeroinitializer
  %411 = fmul <2 x float> %410, %408
  store <2 x float> %411, ptr %22, align 8, !tbaa !9
  %412 = getelementptr inbounds %struct.complex, ptr %24, i64 %indvars.iv1009
  %indvars.iv.next1010 = add nuw nsw i64 %indvars.iv1009, 1
  %gep1070 = getelementptr %struct.complex, ptr %invariant.gep1069, i64 %indvars.iv.next1010
  %413 = load <2 x float>, ptr %gep1066, align 4, !tbaa !9
  %414 = insertelement <2 x float> poison, float %404, i64 0
  %415 = insertelement <2 x float> %414, float %405, i64 1
  %416 = fmul <2 x float> %413, %415
  %417 = shufflevector <2 x float> %416, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %418 = insertelement <2 x float> poison, float %402, i64 0
  %419 = shufflevector <2 x float> %418, <2 x float> poison, <2 x i32> zeroinitializer
  %420 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %419, <2 x float> %413, <2 x float> %417)
  %421 = call <2 x float> @Cf(ptr noundef nonnull %412)
  %.sroa.024.0.vec.extract = extractelement <2 x float> %421, i64 0
  %.sroa.024.4.vec.extract = extractelement <2 x float> %421, i64 1
  %422 = fneg float %.sroa.024.4.vec.extract
  %423 = call ptr @_pCf(ptr noundef nonnull %20)
  %424 = getelementptr inbounds i8, ptr %423, i64 4
  store float %.sroa.024.0.vec.extract, ptr %423, align 4
  store float %422, ptr %424, align 4
  %425 = load float, ptr %20, align 8, !tbaa !18
  %426 = load float, ptr %89, align 4, !tbaa !20
  %427 = fneg float %426
  %428 = load <2 x float>, ptr %21, align 8, !tbaa !9
  %429 = fsub <2 x float> %428, %420
  %430 = load <2 x float>, ptr %22, align 8, !tbaa !9
  %431 = fsub <2 x float> %429, %430
  store <2 x float> %431, ptr %20, align 8, !tbaa !9
  %432 = getelementptr inbounds %struct.complex, ptr %35, i64 %indvars.iv1009
  %433 = load <2 x float>, ptr %gep1070, align 4, !tbaa !9
  %434 = insertelement <2 x float> poison, float %426, i64 0
  %435 = insertelement <2 x float> %434, float %427, i64 1
  %436 = fmul <2 x float> %433, %435
  %437 = shufflevector <2 x float> %436, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %438 = insertelement <2 x float> poison, float %425, i64 0
  %439 = shufflevector <2 x float> %438, <2 x float> poison, <2 x i32> zeroinitializer
  %440 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %439, <2 x float> %433, <2 x float> %437)
  %441 = fsub <2 x float> %431, %440
  store <2 x float> %441, ptr %432, align 4, !tbaa !9
  %442 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %443 = shufflevector <2 x float> %428, <2 x float> %442, <2 x i32> <i32 0, i32 3>
  %444 = fcmp oge <2 x float> %443, zeroinitializer
  %445 = fneg <2 x float> %443
  %446 = select <2 x i1> %444, <2 x float> %443, <2 x float> %445
  %shift1110 = shufflevector <2 x float> %446, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %447 = fadd <2 x float> %446, %shift1110
  %448 = extractelement <2 x float> %447, i64 0
  %449 = load float, ptr %401, align 4, !tbaa !18
  %450 = fcmp oge float %449, 0.000000e+00
  %451 = fneg float %449
  %452 = select i1 %450, float %449, float %451
  %453 = call <2 x float> @Cf(ptr noundef nonnull %401)
  %.sroa.022.4.vec.extract = extractelement <2 x float> %453, i64 1
  %454 = fcmp oge float %.sroa.022.4.vec.extract, 0.000000e+00
  %455 = fneg float %.sroa.022.4.vec.extract
  %456 = select i1 %454, float %.sroa.022.4.vec.extract, float %455
  %457 = fadd float %452, %456
  %458 = load float, ptr %gep1066, align 4, !tbaa !18
  %459 = fcmp oge float %458, 0.000000e+00
  %460 = fneg float %458
  %461 = select i1 %459, float %458, float %460
  %462 = call <2 x float> @Cf(ptr noundef nonnull %gep1066)
  %.sroa.021.4.vec.extract = extractelement <2 x float> %462, i64 1
  %463 = fcmp oge float %.sroa.021.4.vec.extract, 0.000000e+00
  %464 = fneg float %.sroa.021.4.vec.extract
  %465 = select i1 %463, float %.sroa.021.4.vec.extract, float %464
  %466 = fadd float %461, %465
  %467 = call float @llvm.fmuladd.f32(float %457, float %466, float %448)
  %468 = load float, ptr %22, align 8, !tbaa !18
  %469 = fcmp oge float %468, 0.000000e+00
  %470 = fneg float %468
  %471 = select i1 %469, float %468, float %470
  %472 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %.sroa.020.4.vec.extract = extractelement <2 x float> %472, i64 1
  %473 = fcmp oge float %.sroa.020.4.vec.extract, 0.000000e+00
  %474 = fneg float %.sroa.020.4.vec.extract
  %475 = select i1 %473, float %.sroa.020.4.vec.extract, float %474
  %476 = fadd float %471, %475
  %477 = fadd float %467, %476
  %478 = load float, ptr %412, align 4, !tbaa !18
  %479 = fcmp oge float %478, 0.000000e+00
  %480 = fneg float %478
  %481 = select i1 %479, float %478, float %480
  %482 = call <2 x float> @Cf(ptr noundef nonnull %412)
  %.sroa.019.4.vec.extract = extractelement <2 x float> %482, i64 1
  %483 = fcmp oge float %.sroa.019.4.vec.extract, 0.000000e+00
  %484 = fneg float %.sroa.019.4.vec.extract
  %485 = select i1 %483, float %.sroa.019.4.vec.extract, float %484
  %486 = fadd float %481, %485
  %487 = load float, ptr %gep1070, align 4, !tbaa !18
  %488 = fcmp oge float %487, 0.000000e+00
  %489 = fneg float %487
  %490 = select i1 %488, float %487, float %489
  %491 = call <2 x float> @Cf(ptr noundef nonnull %gep1070)
  %.sroa.018.4.vec.extract = extractelement <2 x float> %491, i64 1
  %492 = fcmp oge float %.sroa.018.4.vec.extract, 0.000000e+00
  %493 = fneg float %.sroa.018.4.vec.extract
  %494 = select i1 %492, float %.sroa.018.4.vec.extract, float %493
  %495 = fadd float %490, %494
  %496 = call float @llvm.fmuladd.f32(float %486, float %495, float %477)
  %497 = getelementptr inbounds float, ptr %36, i64 %indvars.iv1009
  store float %496, ptr %497, align 4, !tbaa !9
  %exitcond1013.not = icmp eq i64 %indvars.iv.next1010, %wide.trip.count1012
  br i1 %exitcond1013.not, label %._crit_edge967.loopexit, label %.lr.ph966, !llvm.loop !22

._crit_edge967.loopexit:                          ; preds = %.lr.ph966
  %.pre1045 = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge967

._crit_edge967:                                   ; preds = %._crit_edge967.loopexit, %345
  %498 = phi i32 [ %.pre1045, %._crit_edge967.loopexit ], [ %398, %345 ]
  %499 = sext i32 %498 to i64
  %500 = getelementptr %struct.complex, ptr %104, i64 %499
  %501 = load <2 x float>, ptr %500, align 4, !tbaa !9
  store <2 x float> %501, ptr %21, align 8, !tbaa !9
  %502 = add nsw i32 %498, -1
  %503 = sext i32 %502 to i64
  %504 = getelementptr inbounds %struct.complex, ptr %24, i64 %503
  %505 = load float, ptr %504, align 4, !tbaa !18
  %506 = getelementptr %struct.complex, ptr %105, i64 %503
  %507 = getelementptr inbounds i8, ptr %504, i64 4
  %508 = load float, ptr %507, align 4, !tbaa !20
  %509 = fneg float %508
  %510 = getelementptr inbounds float, ptr %23, i64 %499
  %511 = load float, ptr %510, align 4, !tbaa !9
  %512 = getelementptr %struct.complex, ptr %106, i64 %499
  %513 = load <2 x float>, ptr %512, align 4, !tbaa !9
  %514 = insertelement <2 x float> poison, float %511, i64 0
  %515 = shufflevector <2 x float> %514, <2 x float> poison, <2 x i32> zeroinitializer
  %516 = fmul <2 x float> %515, %513
  store <2 x float> %516, ptr %22, align 8, !tbaa !9
  %517 = load <2 x float>, ptr %506, align 4, !tbaa !9
  %518 = insertelement <2 x float> poison, float %508, i64 0
  %519 = insertelement <2 x float> %518, float %509, i64 1
  %520 = fmul <2 x float> %517, %519
  %521 = shufflevector <2 x float> %520, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %522 = insertelement <2 x float> poison, float %505, i64 0
  %523 = shufflevector <2 x float> %522, <2 x float> poison, <2 x i32> zeroinitializer
  %524 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %523, <2 x float> %517, <2 x float> %521)
  %525 = fsub <2 x float> %501, %524
  store <2 x float> %525, ptr %20, align 8, !tbaa !9
  %526 = getelementptr inbounds %struct.complex, ptr %35, i64 %499
  %527 = fsub <2 x float> %525, %516
  store <2 x float> %527, ptr %526, align 4, !tbaa !9
  %528 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %529 = shufflevector <2 x float> %501, <2 x float> %528, <2 x i32> <i32 0, i32 3>
  %530 = fcmp oge <2 x float> %529, zeroinitializer
  %531 = fneg <2 x float> %529
  %532 = select <2 x i1> %530, <2 x float> %529, <2 x float> %531
  %shift1111 = shufflevector <2 x float> %532, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %533 = fadd <2 x float> %532, %shift1111
  %534 = extractelement <2 x float> %533, i64 0
  %535 = load float, ptr %504, align 4, !tbaa !18
  %536 = fcmp oge float %535, 0.000000e+00
  %537 = fneg float %535
  %538 = select i1 %536, float %535, float %537
  %539 = load i32, ptr %1, align 4, !tbaa !5
  %540 = sext i32 %539 to i64
  %gep977 = getelementptr %struct.complex, ptr %invariant.gep, i64 %540
  %541 = call <2 x float> @Cf(ptr noundef %gep977)
  %.sroa.016.4.vec.extract = extractelement <2 x float> %541, i64 1
  %542 = fcmp oge float %.sroa.016.4.vec.extract, 0.000000e+00
  %543 = fneg float %.sroa.016.4.vec.extract
  %544 = select i1 %542, float %.sroa.016.4.vec.extract, float %543
  %545 = fadd float %538, %544
  %546 = load float, ptr %506, align 4, !tbaa !18
  %547 = fcmp oge float %546, 0.000000e+00
  %548 = fneg float %546
  %549 = select i1 %547, float %546, float %548
  %550 = load i32, ptr %1, align 4, !tbaa !5
  %551 = add i32 %100, %550
  %552 = sext i32 %551 to i64
  %553 = getelementptr inbounds %struct.complex, ptr %32, i64 %552
  %554 = call <2 x float> @Cf(ptr noundef %553)
  %.sroa.015.4.vec.extract = extractelement <2 x float> %554, i64 1
  %555 = fcmp oge float %.sroa.015.4.vec.extract, 0.000000e+00
  %556 = fneg float %.sroa.015.4.vec.extract
  %557 = select i1 %555, float %.sroa.015.4.vec.extract, float %556
  %558 = fadd float %549, %557
  %559 = call float @llvm.fmuladd.f32(float %545, float %558, float %534)
  %560 = load float, ptr %22, align 8, !tbaa !18
  %561 = fcmp oge float %560, 0.000000e+00
  %562 = fneg float %560
  %563 = select i1 %561, float %560, float %562
  %564 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %.sroa.014.4.vec.extract = extractelement <2 x float> %564, i64 1
  %565 = fcmp oge float %.sroa.014.4.vec.extract, 0.000000e+00
  %566 = fneg float %.sroa.014.4.vec.extract
  %567 = select i1 %565, float %.sroa.014.4.vec.extract, float %566
  %568 = fadd float %563, %567
  %569 = fadd float %559, %568
  %570 = load i32, ptr %1, align 4, !tbaa !5
  %571 = sext i32 %570 to i64
  %572 = getelementptr inbounds float, ptr %36, i64 %571
  store float %569, ptr %572, align 4, !tbaa !9
  br label %587

thread-pre-split:                                 ; preds = %344, %116
  %573 = fsub <2 x float> %111, %115
  store <2 x float> %573, ptr %13, align 4, !tbaa !9
  %574 = call <2 x float> @Cf(ptr noundef nonnull %21)
  %.sink1089 = load float, ptr %22, align 8, !tbaa !18
  %575 = call <2 x float> @Cf(ptr noundef nonnull %22)
  %576 = insertelement <2 x float> %111, float %.sink1089, i64 1
  %577 = fcmp oge <2 x float> %576, zeroinitializer
  %578 = fneg <2 x float> %576
  %579 = select <2 x i1> %577, <2 x float> %576, <2 x float> %578
  %580 = shufflevector <2 x float> %574, <2 x float> %575, <2 x i32> <i32 1, i32 3>
  %581 = fcmp oge <2 x float> %580, zeroinitializer
  %582 = fneg <2 x float> %580
  %583 = select <2 x i1> %581, <2 x float> %580, <2 x float> %582
  %584 = fadd <2 x float> %579, %583
  %shift1112 = shufflevector <2 x float> %584, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %585 = fadd <2 x float> %584, %shift1112
  %586 = extractelement <2 x float> %585, i64 0
  store float %586, ptr %14, align 4, !tbaa !9
  %.pr1052 = load i32, ptr %1, align 4, !tbaa !5
  br label %587

587:                                              ; preds = %thread-pre-split, %._crit_edge967, %._crit_edge
  %588 = phi i32 [ %.pr1052, %thread-pre-split ], [ %570, %._crit_edge967 ], [ %341, %._crit_edge ]
  %.not953968 = icmp slt i32 %588, 1
  br i1 %.not953968, label %._crit_edge973, label %.lr.ph972.preheader

.lr.ph972.preheader:                              ; preds = %587
  %589 = add nuw i32 %588, 1
  %wide.trip.count1017 = zext i32 %589 to i64
  br label %.lr.ph972

.lr.ph972:                                        ; preds = %.lr.ph972.preheader, %611
  %indvars.iv1014 = phi i64 [ 1, %.lr.ph972.preheader ], [ %indvars.iv.next1015, %611 ]
  %.0939969 = phi float [ 0.000000e+00, %.lr.ph972.preheader ], [ %613, %611 ]
  %590 = getelementptr inbounds float, ptr %36, i64 %indvars.iv1014
  %591 = load float, ptr %590, align 4, !tbaa !9
  %592 = fcmp ogt float %591, %86
  %593 = getelementptr inbounds %struct.complex, ptr %35, i64 %indvars.iv1014
  %594 = load float, ptr %593, align 4, !tbaa !18
  %595 = fcmp oge float %594, 0.000000e+00
  %596 = fneg float %594
  %597 = select i1 %595, float %594, float %596
  %598 = call <2 x float> @Cf(ptr noundef nonnull %593)
  %.sroa.013.4.vec.extract = extractelement <2 x float> %598, i64 1
  %599 = fcmp oge float %.sroa.013.4.vec.extract, 0.000000e+00
  %600 = fneg float %.sroa.013.4.vec.extract
  %601 = select i1 %599, float %.sroa.013.4.vec.extract, float %600
  %602 = fadd float %597, %601
  br i1 %592, label %603, label %606

603:                                              ; preds = %.lr.ph972
  %604 = load float, ptr %590, align 4, !tbaa !9
  %605 = fdiv float %602, %604
  br label %611

606:                                              ; preds = %.lr.ph972
  %607 = fadd float %85, %602
  %608 = load float, ptr %590, align 4, !tbaa !9
  %609 = fadd float %85, %608
  %610 = fdiv float %607, %609
  br label %611

611:                                              ; preds = %603, %606
  %.sink1092 = phi float [ %605, %603 ], [ %610, %606 ]
  %612 = fcmp oge float %.0939969, %.sink1092
  %613 = select i1 %612, float %.0939969, float %.sink1092
  %indvars.iv.next1015 = add nuw nsw i64 %indvars.iv1014, 1
  %exitcond1018.not = icmp eq i64 %indvars.iv.next1015, %wide.trip.count1017
  br i1 %exitcond1018.not, label %._crit_edge973, label %.lr.ph972, !llvm.loop !23

._crit_edge973:                                   ; preds = %611, %587
  %.0939.lcssa = phi float [ 0.000000e+00, %587 ], [ %613, %611 ]
  store float %.0939.lcssa, ptr %93, align 4, !tbaa !9
  %614 = fcmp ogt float %.0939.lcssa, %83
  br i1 %614, label %615, label %622

615:                                              ; preds = %._crit_edge973
  %616 = fmul float %.0939.lcssa, 2.000000e+00
  %617 = fcmp ole float %616, %.0942
  %618 = icmp ult i32 %.0941, 6
  %or.cond = select i1 %617, i1 %618, i1 false
  br i1 %or.cond, label %619, label %622

619:                                              ; preds = %615
  call void @cpttrs_(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull @c__1, ptr noundef %5, ptr noundef %6, ptr noundef nonnull %13, ptr noundef nonnull %1, ptr noundef nonnull %15) #8
  call void @caxpy_(ptr noundef nonnull %1, ptr noundef nonnull @c_b16, ptr noundef nonnull %13, ptr noundef nonnull @c__1, ptr noundef %gep979, ptr noundef nonnull @c__1) #8
  %620 = load float, ptr %93, align 4, !tbaa !9
  %621 = add nuw nsw i32 %.0941, 1
  br label %107

622:                                              ; preds = %615, %._crit_edge973
  %623 = load i32, ptr %1, align 4, !tbaa !5
  %.not954980 = icmp slt i32 %623, 1
  br i1 %.not954980, label %._crit_edge984, label %.lr.ph983.preheader

.lr.ph983.preheader:                              ; preds = %622
  %624 = add nuw i32 %623, 1
  %wide.trip.count1022 = zext i32 %624 to i64
  br label %.lr.ph983

.lr.ph983:                                        ; preds = %.lr.ph983.preheader, %.lr.ph983
  %indvars.iv1019 = phi i64 [ 1, %.lr.ph983.preheader ], [ %indvars.iv.next1020, %.lr.ph983 ]
  %625 = getelementptr inbounds float, ptr %36, i64 %indvars.iv1019
  %626 = load float, ptr %625, align 4, !tbaa !9
  %627 = fcmp ogt float %626, %86
  %628 = getelementptr inbounds %struct.complex, ptr %35, i64 %indvars.iv1019
  %629 = load float, ptr %628, align 4, !tbaa !18
  %630 = fcmp oge float %629, 0.000000e+00
  %631 = fneg float %629
  %632 = select i1 %630, float %629, float %631
  %633 = call <2 x float> @Cf(ptr noundef nonnull %628)
  %.sroa.011.4.vec.extract = extractelement <2 x float> %633, i64 1
  %634 = fcmp oge float %.sroa.011.4.vec.extract, 0.000000e+00
  %635 = fneg float %.sroa.011.4.vec.extract
  %636 = select i1 %634, float %.sroa.011.4.vec.extract, float %635
  %637 = fadd float %632, %636
  %638 = load float, ptr %625, align 4, !tbaa !9
  %639 = call float @llvm.fmuladd.f32(float %90, float %638, float %637)
  %640 = fadd float %85, %639
  %storemerge = select i1 %627, float %639, float %640
  store float %storemerge, ptr %625, align 4, !tbaa !9
  %indvars.iv.next1020 = add nuw nsw i64 %indvars.iv1019, 1
  %exitcond1023.not = icmp eq i64 %indvars.iv.next1020, %wide.trip.count1022
  br i1 %exitcond1023.not, label %._crit_edge984, label %.lr.ph983, !llvm.loop !24

._crit_edge984:                                   ; preds = %.lr.ph983, %622
  %641 = call i32 @isamax_(ptr noundef nonnull %1, ptr noundef nonnull %14, ptr noundef nonnull @c__1) #8
  %642 = sext i32 %641 to i64
  %643 = getelementptr inbounds float, ptr %36, i64 %642
  %644 = load float, ptr %643, align 4, !tbaa !9
  %645 = getelementptr inbounds float, ptr %33, i64 %indvars.iv1037
  store float %644, ptr %645, align 4, !tbaa !9
  store float 1.000000e+00, ptr %14, align 4, !tbaa !9
  %646 = load i32, ptr %1, align 4, !tbaa !5
  %.not955985 = icmp slt i32 %646, 2
  br i1 %.not955985, label %._crit_edge989.thread, label %.lr.ph988.preheader

._crit_edge989.thread:                            ; preds = %._crit_edge984
  %647 = sext i32 %646 to i64
  %648 = getelementptr inbounds float, ptr %25, i64 %647
  %649 = load float, ptr %648, align 4, !tbaa !9
  %650 = getelementptr inbounds float, ptr %36, i64 %647
  %651 = load float, ptr %650, align 4, !tbaa !9
  %652 = fdiv float %651, %649
  store float %652, ptr %650, align 4, !tbaa !9
  br label %._crit_edge993

.lr.ph988.preheader:                              ; preds = %._crit_edge984
  %653 = add nuw i32 %646, 1
  %wide.trip.count1027 = zext i32 %653 to i64
  br label %.lr.ph988

.lr.ph988:                                        ; preds = %.lr.ph988.preheader, %.lr.ph988
  %654 = phi float [ 1.000000e+00, %.lr.ph988.preheader ], [ %657, %.lr.ph988 ]
  %indvars.iv1024 = phi i64 [ 2, %.lr.ph988.preheader ], [ %indvars.iv.next1025, %.lr.ph988 ]
  %gep1072 = getelementptr %struct.complex, ptr %invariant.gep1071, i64 %indvars.iv1024
  %655 = call <2 x float> @Cf(ptr noundef nonnull %gep1072)
  %656 = call float @cabsf(<2 x float> noundef %655) #8
  %657 = call float @llvm.fmuladd.f32(float %654, float %656, float 1.000000e+00)
  %658 = getelementptr inbounds float, ptr %36, i64 %indvars.iv1024
  store float %657, ptr %658, align 4, !tbaa !9
  %indvars.iv.next1025 = add nuw nsw i64 %indvars.iv1024, 1
  %exitcond1028.not = icmp eq i64 %indvars.iv.next1025, %wide.trip.count1027
  br i1 %exitcond1028.not, label %._crit_edge989, label %.lr.ph988, !llvm.loop !25

._crit_edge989:                                   ; preds = %.lr.ph988
  %.pre1047 = load i32, ptr %1, align 4, !tbaa !5
  %659 = sext i32 %.pre1047 to i64
  %660 = getelementptr inbounds float, ptr %25, i64 %659
  %661 = load float, ptr %660, align 4, !tbaa !9
  %662 = getelementptr inbounds float, ptr %36, i64 %659
  %663 = load float, ptr %662, align 4, !tbaa !9
  %664 = fdiv float %663, %661
  store float %664, ptr %662, align 4, !tbaa !9
  %665 = icmp sgt i32 %.pre1047, 1
  br i1 %665, label %.lr.ph992.preheader, label %._crit_edge993

.lr.ph992.preheader:                              ; preds = %._crit_edge989
  %666 = zext nneg i32 %.pre1047 to i64
  %.phi.trans.insert1048 = getelementptr inbounds float, ptr %36, i64 %666
  %.pre1049 = load float, ptr %.phi.trans.insert1048, align 4, !tbaa !9
  br label %.lr.ph992

.lr.ph992:                                        ; preds = %.lr.ph992.preheader, %.lr.ph992
  %667 = phi float [ %.pre1049, %.lr.ph992.preheader ], [ %676, %.lr.ph992 ]
  %indvars.iv1029 = phi i64 [ %666, %.lr.ph992.preheader ], [ %indvars.iv.next1030, %.lr.ph992 ]
  %indvars.iv.next1030 = add nsw i64 %indvars.iv1029, -1
  %668 = getelementptr inbounds float, ptr %36, i64 %indvars.iv.next1030
  %669 = load float, ptr %668, align 4, !tbaa !9
  %670 = getelementptr inbounds float, ptr %25, i64 %indvars.iv.next1030
  %671 = load float, ptr %670, align 4, !tbaa !9
  %672 = fdiv float %669, %671
  %673 = getelementptr inbounds %struct.complex, ptr %26, i64 %indvars.iv.next1030
  %674 = call <2 x float> @Cf(ptr noundef nonnull %673)
  %675 = call float @cabsf(<2 x float> noundef %674) #8
  %676 = call float @llvm.fmuladd.f32(float %667, float %675, float %672)
  store float %676, ptr %668, align 4, !tbaa !9
  %677 = icmp ugt i64 %indvars.iv1029, 2
  br i1 %677, label %.lr.ph992, label %._crit_edge993, !llvm.loop !26

._crit_edge993:                                   ; preds = %.lr.ph992, %._crit_edge989.thread, %._crit_edge989
  %678 = call i32 @isamax_(ptr noundef nonnull %1, ptr noundef nonnull %14, ptr noundef nonnull @c__1) #8
  %679 = sext i32 %678 to i64
  %680 = getelementptr inbounds float, ptr %36, i64 %679
  %681 = load float, ptr %680, align 4, !tbaa !9
  %682 = fcmp oge float %681, 0.000000e+00
  %683 = fneg float %681
  %684 = select i1 %682, float %681, float %683
  %685 = load float, ptr %645, align 4, !tbaa !9
  %686 = fmul float %685, %684
  store float %686, ptr %645, align 4, !tbaa !9
  %687 = load i32, ptr %1, align 4, !tbaa !5
  %.not956994 = icmp slt i32 %687, 1
  br i1 %.not956994, label %._crit_edge999.thread, label %.lr.ph998

.lr.ph998:                                        ; preds = %._crit_edge993
  %688 = add nuw i32 %687, 1
  %wide.trip.count1035 = zext i32 %688 to i64
  %invariant.gep1073 = getelementptr %struct.complex, ptr %32, i64 %95
  br label %689

689:                                              ; preds = %.lr.ph998, %689
  %indvars.iv1032 = phi i64 [ 1, %.lr.ph998 ], [ %indvars.iv.next1033, %689 ]
  %.1943995 = phi float [ 0.000000e+00, %.lr.ph998 ], [ %693, %689 ]
  %gep1074 = getelementptr %struct.complex, ptr %invariant.gep1073, i64 %indvars.iv1032
  %690 = call <2 x float> @Cf(ptr noundef %gep1074)
  %691 = call float @cabsf(<2 x float> noundef %690) #8
  %692 = fcmp oge float %.1943995, %691
  %693 = select i1 %692, float %.1943995, float %691
  %indvars.iv.next1033 = add nuw nsw i64 %indvars.iv1032, 1
  %exitcond1036.not = icmp eq i64 %indvars.iv.next1033, %wide.trip.count1035
  br i1 %exitcond1036.not, label %._crit_edge999, label %689, !llvm.loop !27

._crit_edge999:                                   ; preds = %689
  %694 = fcmp une float %693, 0.000000e+00
  br i1 %694, label %695, label %._crit_edge999.thread

695:                                              ; preds = %._crit_edge999
  %696 = load float, ptr %645, align 4, !tbaa !9
  %697 = fdiv float %696, %693
  store float %697, ptr %645, align 4, !tbaa !9
  br label %._crit_edge999.thread

._crit_edge999.thread:                            ; preds = %._crit_edge993, %._crit_edge999, %695
  %indvars.iv.next1038 = add nuw nsw i64 %indvars.iv1037, 1
  %698 = load i32, ptr %19, align 4, !tbaa !5
  %699 = sext i32 %698 to i64
  %.not950.not = icmp slt i64 %indvars.iv1037, %699
  br i1 %.not950.not, label %.preheader, label %.loopexit, !llvm.loop !28

.loopexit:                                        ; preds = %._crit_edge999.thread, %.lr.ph1006.prol.loopexit, %.lr.ph1006, %middle.block, %58, %82, %59, %.thread
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %22) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %21) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %20) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %19) #8
  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 float @slamch_(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: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #4

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

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

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

; Function Attrs: nounwind
declare float @cabsf(<2 x float> noundef) local_unnamed_addr #6

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

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

; 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>) #7

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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #6 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { 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 = distinct !{!11, !12, !13, !14}
!12 = !{!"llvm.loop.mustprogress"}
!13 = !{!"llvm.loop.isvectorized", i32 1}
!14 = !{!"llvm.loop.unroll.runtime.disable"}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.unroll.disable"}
!17 = distinct !{!17, !12, !13}
!18 = !{!19, !10, i64 0}
!19 = !{!"", !10, i64 0, !10, i64 4}
!20 = !{!19, !10, i64 4}
!21 = distinct !{!21, !12}
!22 = distinct !{!22, !12}
!23 = distinct !{!23, !12}
!24 = distinct !{!24, !12}
!25 = distinct !{!25, !12}
!26 = distinct !{!26, !12}
!27 = distinct !{!27, !12}
!28 = distinct !{!28, !12}


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