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

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

%struct.doublecomplex = type { double, double }

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

66:                                               ; preds = %10
  %67 = load ptr, ptr %13, align 8, !tbaa !5
  %68 = load i32, ptr %67, align 4, !tbaa !9
  %69 = icmp eq i32 %68, 0
  br i1 %69, label %70, label %71

70:                                               ; preds = %66, %10
  store i32 1, ptr %42, align 4
  br label %3926

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

75:                                               ; preds = %71
  %76 = load ptr, ptr %13, align 8, !tbaa !5
  %77 = load i32, ptr %76, align 4, !tbaa !9
  %78 = icmp sle i32 %77, 1
  br i1 %78, label %79, label %751

79:                                               ; preds = %75
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %80

80:                                               ; preds = %747, %79
  %81 = load ptr, ptr %12, align 8, !tbaa !5
  %82 = load i32, ptr %81, align 4, !tbaa !9
  %83 = sub nsw i32 %82, 1
  store i32 %83, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %40, align 4, !tbaa !9
  br label %84

84:                                               ; preds = %351, %80
  %85 = load i32, ptr %40, align 4, !tbaa !9
  %86 = load i32, ptr %23, align 4, !tbaa !9
  %87 = icmp sle i32 %85, %86
  br i1 %87, label %88, label %354

88:                                               ; preds = %84
  %89 = load ptr, ptr %18, align 8, !tbaa !5
  %90 = load i32, ptr %40, align 4, !tbaa !9
  %91 = sext i32 %90 to i64
  %92 = getelementptr inbounds i32, ptr %89, i64 %91
  %93 = load i32, ptr %92, align 4, !tbaa !9
  %94 = load i32, ptr %40, align 4, !tbaa !9
  %95 = icmp eq i32 %93, %94
  br i1 %95, label %96, label %204

96:                                               ; preds = %88
  %97 = load i32, ptr %40, align 4, !tbaa !9
  %98 = add nsw i32 %97, 1
  %99 = load i32, ptr %41, align 4, !tbaa !9
  %100 = load i32, ptr %21, align 4, !tbaa !9
  %101 = mul nsw i32 %99, %100
  %102 = add nsw i32 %98, %101
  store i32 %102, ptr %24, align 4, !tbaa !9
  %103 = load i32, ptr %40, align 4, !tbaa !9
  %104 = add nsw i32 %103, 1
  %105 = load i32, ptr %41, align 4, !tbaa !9
  %106 = load i32, ptr %21, align 4, !tbaa !9
  %107 = mul nsw i32 %105, %106
  %108 = add nsw i32 %104, %107
  store i32 %108, ptr %25, align 4, !tbaa !9
  %109 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %109, ptr %26, align 4, !tbaa !9
  %110 = load i32, ptr %40, align 4, !tbaa !9
  %111 = load i32, ptr %41, align 4, !tbaa !9
  %112 = load i32, ptr %21, align 4, !tbaa !9
  %113 = mul nsw i32 %111, %112
  %114 = add nsw i32 %110, %113
  store i32 %114, ptr %27, align 4, !tbaa !9
  %115 = load ptr, ptr %14, align 8, !tbaa !5
  %116 = load i32, ptr %26, align 4, !tbaa !9
  %117 = sext i32 %116 to i64
  %118 = getelementptr inbounds %struct.doublecomplex, ptr %115, i64 %117
  %119 = getelementptr inbounds %struct.doublecomplex, ptr %118, i32 0, i32 0
  %120 = load double, ptr %119, align 8, !tbaa !11
  %121 = load ptr, ptr %19, align 8, !tbaa !5
  %122 = load i32, ptr %27, align 4, !tbaa !9
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds %struct.doublecomplex, ptr %121, i64 %123
  %125 = getelementptr inbounds %struct.doublecomplex, ptr %124, i32 0, i32 0
  %126 = load double, ptr %125, align 8, !tbaa !11
  %127 = load ptr, ptr %14, align 8, !tbaa !5
  %128 = load i32, ptr %26, align 4, !tbaa !9
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds %struct.doublecomplex, ptr %127, i64 %129
  %131 = getelementptr inbounds %struct.doublecomplex, ptr %130, i32 0, i32 1
  %132 = load double, ptr %131, align 8, !tbaa !14
  %133 = load ptr, ptr %19, align 8, !tbaa !5
  %134 = load i32, ptr %27, align 4, !tbaa !9
  %135 = sext i32 %134 to i64
  %136 = getelementptr inbounds %struct.doublecomplex, ptr %133, i64 %135
  %137 = getelementptr inbounds %struct.doublecomplex, ptr %136, i32 0, i32 1
  %138 = load double, ptr %137, align 8, !tbaa !14
  %139 = fmul double %132, %138
  %140 = fneg double %139
  %141 = call double @llvm.fmuladd.f64(double %120, double %126, double %140)
  %142 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %141, ptr %142, align 8, !tbaa !11
  %143 = load ptr, ptr %14, align 8, !tbaa !5
  %144 = load i32, ptr %26, align 4, !tbaa !9
  %145 = sext i32 %144 to i64
  %146 = getelementptr inbounds %struct.doublecomplex, ptr %143, i64 %145
  %147 = getelementptr inbounds %struct.doublecomplex, ptr %146, i32 0, i32 0
  %148 = load double, ptr %147, align 8, !tbaa !11
  %149 = load ptr, ptr %19, align 8, !tbaa !5
  %150 = load i32, ptr %27, align 4, !tbaa !9
  %151 = sext i32 %150 to i64
  %152 = getelementptr inbounds %struct.doublecomplex, ptr %149, i64 %151
  %153 = getelementptr inbounds %struct.doublecomplex, ptr %152, i32 0, i32 1
  %154 = load double, ptr %153, align 8, !tbaa !14
  %155 = load ptr, ptr %14, align 8, !tbaa !5
  %156 = load i32, ptr %26, align 4, !tbaa !9
  %157 = sext i32 %156 to i64
  %158 = getelementptr inbounds %struct.doublecomplex, ptr %155, i64 %157
  %159 = getelementptr inbounds %struct.doublecomplex, ptr %158, i32 0, i32 1
  %160 = load double, ptr %159, align 8, !tbaa !14
  %161 = load ptr, ptr %19, align 8, !tbaa !5
  %162 = load i32, ptr %27, align 4, !tbaa !9
  %163 = sext i32 %162 to i64
  %164 = getelementptr inbounds %struct.doublecomplex, ptr %161, i64 %163
  %165 = getelementptr inbounds %struct.doublecomplex, ptr %164, i32 0, i32 0
  %166 = load double, ptr %165, align 8, !tbaa !11
  %167 = fmul double %160, %166
  %168 = call double @llvm.fmuladd.f64(double %148, double %154, double %167)
  %169 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %168, ptr %169, align 8, !tbaa !14
  %170 = load ptr, ptr %19, align 8, !tbaa !5
  %171 = load i32, ptr %25, align 4, !tbaa !9
  %172 = sext i32 %171 to i64
  %173 = getelementptr inbounds %struct.doublecomplex, ptr %170, i64 %172
  %174 = getelementptr inbounds %struct.doublecomplex, ptr %173, i32 0, i32 0
  %175 = load double, ptr %174, align 8, !tbaa !11
  %176 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %177 = load double, ptr %176, align 8, !tbaa !11
  %178 = fsub double %175, %177
  %179 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %178, ptr %179, align 8, !tbaa !11
  %180 = load ptr, ptr %19, align 8, !tbaa !5
  %181 = load i32, ptr %25, align 4, !tbaa !9
  %182 = sext i32 %181 to i64
  %183 = getelementptr inbounds %struct.doublecomplex, ptr %180, i64 %182
  %184 = getelementptr inbounds %struct.doublecomplex, ptr %183, i32 0, i32 1
  %185 = load double, ptr %184, align 8, !tbaa !14
  %186 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %187 = load double, ptr %186, align 8, !tbaa !14
  %188 = fsub double %185, %187
  %189 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %188, ptr %189, align 8, !tbaa !14
  %190 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %191 = load double, ptr %190, align 8, !tbaa !11
  %192 = load ptr, ptr %19, align 8, !tbaa !5
  %193 = load i32, ptr %24, align 4, !tbaa !9
  %194 = sext i32 %193 to i64
  %195 = getelementptr inbounds %struct.doublecomplex, ptr %192, i64 %194
  %196 = getelementptr inbounds %struct.doublecomplex, ptr %195, i32 0, i32 0
  store double %191, ptr %196, align 8, !tbaa !11
  %197 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %198 = load double, ptr %197, align 8, !tbaa !14
  %199 = load ptr, ptr %19, align 8, !tbaa !5
  %200 = load i32, ptr %24, align 4, !tbaa !9
  %201 = sext i32 %200 to i64
  %202 = getelementptr inbounds %struct.doublecomplex, ptr %199, i64 %201
  %203 = getelementptr inbounds %struct.doublecomplex, ptr %202, i32 0, i32 1
  store double %198, ptr %203, align 8, !tbaa !14
  br label %350

204:                                              ; preds = %88
  %205 = load i32, ptr %40, align 4, !tbaa !9
  %206 = load i32, ptr %41, align 4, !tbaa !9
  %207 = load i32, ptr %21, align 4, !tbaa !9
  %208 = mul nsw i32 %206, %207
  %209 = add nsw i32 %205, %208
  store i32 %209, ptr %24, align 4, !tbaa !9
  %210 = load ptr, ptr %19, align 8, !tbaa !5
  %211 = load i32, ptr %24, align 4, !tbaa !9
  %212 = sext i32 %211 to i64
  %213 = getelementptr inbounds %struct.doublecomplex, ptr %210, i64 %212
  %214 = getelementptr inbounds %struct.doublecomplex, ptr %213, i32 0, i32 0
  %215 = load double, ptr %214, align 8, !tbaa !11
  %216 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %215, ptr %216, align 8, !tbaa !11
  %217 = load ptr, ptr %19, align 8, !tbaa !5
  %218 = load i32, ptr %24, align 4, !tbaa !9
  %219 = sext i32 %218 to i64
  %220 = getelementptr inbounds %struct.doublecomplex, ptr %217, i64 %219
  %221 = getelementptr inbounds %struct.doublecomplex, ptr %220, i32 0, i32 1
  %222 = load double, ptr %221, align 8, !tbaa !14
  %223 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %222, ptr %223, align 8, !tbaa !14
  %224 = load i32, ptr %40, align 4, !tbaa !9
  %225 = load i32, ptr %41, align 4, !tbaa !9
  %226 = load i32, ptr %21, align 4, !tbaa !9
  %227 = mul nsw i32 %225, %226
  %228 = add nsw i32 %224, %227
  store i32 %228, ptr %24, align 4, !tbaa !9
  %229 = load i32, ptr %40, align 4, !tbaa !9
  %230 = add nsw i32 %229, 1
  %231 = load i32, ptr %41, align 4, !tbaa !9
  %232 = load i32, ptr %21, align 4, !tbaa !9
  %233 = mul nsw i32 %231, %232
  %234 = add nsw i32 %230, %233
  store i32 %234, ptr %25, align 4, !tbaa !9
  %235 = load ptr, ptr %19, align 8, !tbaa !5
  %236 = load i32, ptr %25, align 4, !tbaa !9
  %237 = sext i32 %236 to i64
  %238 = getelementptr inbounds %struct.doublecomplex, ptr %235, i64 %237
  %239 = getelementptr inbounds %struct.doublecomplex, ptr %238, i32 0, i32 0
  %240 = load double, ptr %239, align 8, !tbaa !11
  %241 = load ptr, ptr %19, align 8, !tbaa !5
  %242 = load i32, ptr %24, align 4, !tbaa !9
  %243 = sext i32 %242 to i64
  %244 = getelementptr inbounds %struct.doublecomplex, ptr %241, i64 %243
  %245 = getelementptr inbounds %struct.doublecomplex, ptr %244, i32 0, i32 0
  store double %240, ptr %245, align 8, !tbaa !11
  %246 = load ptr, ptr %19, align 8, !tbaa !5
  %247 = load i32, ptr %25, align 4, !tbaa !9
  %248 = sext i32 %247 to i64
  %249 = getelementptr inbounds %struct.doublecomplex, ptr %246, i64 %248
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %249, i32 0, i32 1
  %251 = load double, ptr %250, align 8, !tbaa !14
  %252 = load ptr, ptr %19, align 8, !tbaa !5
  %253 = load i32, ptr %24, align 4, !tbaa !9
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds %struct.doublecomplex, ptr %252, i64 %254
  %256 = getelementptr inbounds %struct.doublecomplex, ptr %255, i32 0, i32 1
  store double %251, ptr %256, align 8, !tbaa !14
  %257 = load i32, ptr %40, align 4, !tbaa !9
  %258 = add nsw i32 %257, 1
  %259 = load i32, ptr %41, align 4, !tbaa !9
  %260 = load i32, ptr %21, align 4, !tbaa !9
  %261 = mul nsw i32 %259, %260
  %262 = add nsw i32 %258, %261
  store i32 %262, ptr %24, align 4, !tbaa !9
  %263 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %263, ptr %25, align 4, !tbaa !9
  %264 = load i32, ptr %40, align 4, !tbaa !9
  %265 = load i32, ptr %41, align 4, !tbaa !9
  %266 = load i32, ptr %21, align 4, !tbaa !9
  %267 = mul nsw i32 %265, %266
  %268 = add nsw i32 %264, %267
  store i32 %268, ptr %26, align 4, !tbaa !9
  %269 = load ptr, ptr %14, align 8, !tbaa !5
  %270 = load i32, ptr %25, align 4, !tbaa !9
  %271 = sext i32 %270 to i64
  %272 = getelementptr inbounds %struct.doublecomplex, ptr %269, i64 %271
  %273 = getelementptr inbounds %struct.doublecomplex, ptr %272, i32 0, i32 0
  %274 = load double, ptr %273, align 8, !tbaa !11
  %275 = load ptr, ptr %19, align 8, !tbaa !5
  %276 = load i32, ptr %26, align 4, !tbaa !9
  %277 = sext i32 %276 to i64
  %278 = getelementptr inbounds %struct.doublecomplex, ptr %275, i64 %277
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %278, i32 0, i32 0
  %280 = load double, ptr %279, align 8, !tbaa !11
  %281 = load ptr, ptr %14, align 8, !tbaa !5
  %282 = load i32, ptr %25, align 4, !tbaa !9
  %283 = sext i32 %282 to i64
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %281, i64 %283
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %284, i32 0, i32 1
  %286 = load double, ptr %285, align 8, !tbaa !14
  %287 = load ptr, ptr %19, align 8, !tbaa !5
  %288 = load i32, ptr %26, align 4, !tbaa !9
  %289 = sext i32 %288 to i64
  %290 = getelementptr inbounds %struct.doublecomplex, ptr %287, i64 %289
  %291 = getelementptr inbounds %struct.doublecomplex, ptr %290, i32 0, i32 1
  %292 = load double, ptr %291, align 8, !tbaa !14
  %293 = fmul double %286, %292
  %294 = fneg double %293
  %295 = call double @llvm.fmuladd.f64(double %274, double %280, double %294)
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %295, ptr %296, align 8, !tbaa !11
  %297 = load ptr, ptr %14, align 8, !tbaa !5
  %298 = load i32, ptr %25, align 4, !tbaa !9
  %299 = sext i32 %298 to i64
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %297, i64 %299
  %301 = getelementptr inbounds %struct.doublecomplex, ptr %300, i32 0, i32 0
  %302 = load double, ptr %301, align 8, !tbaa !11
  %303 = load ptr, ptr %19, align 8, !tbaa !5
  %304 = load i32, ptr %26, align 4, !tbaa !9
  %305 = sext i32 %304 to i64
  %306 = getelementptr inbounds %struct.doublecomplex, ptr %303, i64 %305
  %307 = getelementptr inbounds %struct.doublecomplex, ptr %306, i32 0, i32 1
  %308 = load double, ptr %307, align 8, !tbaa !14
  %309 = load ptr, ptr %14, align 8, !tbaa !5
  %310 = load i32, ptr %25, align 4, !tbaa !9
  %311 = sext i32 %310 to i64
  %312 = getelementptr inbounds %struct.doublecomplex, ptr %309, i64 %311
  %313 = getelementptr inbounds %struct.doublecomplex, ptr %312, i32 0, i32 1
  %314 = load double, ptr %313, align 8, !tbaa !14
  %315 = load ptr, ptr %19, align 8, !tbaa !5
  %316 = load i32, ptr %26, align 4, !tbaa !9
  %317 = sext i32 %316 to i64
  %318 = getelementptr inbounds %struct.doublecomplex, ptr %315, i64 %317
  %319 = getelementptr inbounds %struct.doublecomplex, ptr %318, i32 0, i32 0
  %320 = load double, ptr %319, align 8, !tbaa !11
  %321 = fmul double %314, %320
  %322 = call double @llvm.fmuladd.f64(double %302, double %308, double %321)
  %323 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %322, ptr %323, align 8, !tbaa !14
  %324 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %325 = load double, ptr %324, align 8, !tbaa !11
  %326 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %327 = load double, ptr %326, align 8, !tbaa !11
  %328 = fsub double %325, %327
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %328, ptr %329, align 8, !tbaa !11
  %330 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %331 = load double, ptr %330, align 8, !tbaa !14
  %332 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %333 = load double, ptr %332, align 8, !tbaa !14
  %334 = fsub double %331, %333
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %334, ptr %335, align 8, !tbaa !14
  %336 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %337 = load double, ptr %336, align 8, !tbaa !11
  %338 = load ptr, ptr %19, align 8, !tbaa !5
  %339 = load i32, ptr %24, align 4, !tbaa !9
  %340 = sext i32 %339 to i64
  %341 = getelementptr inbounds %struct.doublecomplex, ptr %338, i64 %340
  %342 = getelementptr inbounds %struct.doublecomplex, ptr %341, i32 0, i32 0
  store double %337, ptr %342, align 8, !tbaa !11
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %344 = load double, ptr %343, align 8, !tbaa !14
  %345 = load ptr, ptr %19, align 8, !tbaa !5
  %346 = load i32, ptr %24, align 4, !tbaa !9
  %347 = sext i32 %346 to i64
  %348 = getelementptr inbounds %struct.doublecomplex, ptr %345, i64 %347
  %349 = getelementptr inbounds %struct.doublecomplex, ptr %348, i32 0, i32 1
  store double %344, ptr %349, align 8, !tbaa !14
  br label %350

350:                                              ; preds = %204, %96
  br label %351

351:                                              ; preds = %350
  %352 = load i32, ptr %40, align 4, !tbaa !9
  %353 = add nsw i32 %352, 1
  store i32 %353, ptr %40, align 4, !tbaa !9
  br label %84, !llvm.loop !15

354:                                              ; preds = %84
  %355 = load ptr, ptr %12, align 8, !tbaa !5
  %356 = load i32, ptr %355, align 4, !tbaa !9
  %357 = load i32, ptr %41, align 4, !tbaa !9
  %358 = load i32, ptr %21, align 4, !tbaa !9
  %359 = mul nsw i32 %357, %358
  %360 = add nsw i32 %356, %359
  store i32 %360, ptr %23, align 4, !tbaa !9
  %361 = load ptr, ptr %19, align 8, !tbaa !5
  %362 = load ptr, ptr %12, align 8, !tbaa !5
  %363 = load i32, ptr %362, align 4, !tbaa !9
  %364 = load i32, ptr %41, align 4, !tbaa !9
  %365 = load i32, ptr %21, align 4, !tbaa !9
  %366 = mul nsw i32 %364, %365
  %367 = add nsw i32 %363, %366
  %368 = sext i32 %367 to i64
  %369 = getelementptr inbounds %struct.doublecomplex, ptr %361, i64 %368
  %370 = call { double, double } @Cd(ptr noundef %369)
  %371 = extractvalue { double, double } %370, 0
  %372 = extractvalue { double, double } %370, 1
  %373 = load ptr, ptr %15, align 8, !tbaa !5
  %374 = load ptr, ptr %12, align 8, !tbaa !5
  %375 = load i32, ptr %374, align 4, !tbaa !9
  %376 = sext i32 %375 to i64
  %377 = getelementptr inbounds %struct.doublecomplex, ptr %373, i64 %376
  %378 = call { double, double } @Cd(ptr noundef %377)
  %379 = extractvalue { double, double } %378, 0
  %380 = extractvalue { double, double } %378, 1
  %381 = call { double, double } @__divdc3(double noundef %371, double noundef %372, double noundef %379, double noundef %380) #4
  %382 = extractvalue { double, double } %381, 0
  %383 = extractvalue { double, double } %381, 1
  %384 = call ptr @_pCd(ptr noundef %31)
  %385 = getelementptr inbounds { double, double }, ptr %384, i32 0, i32 0
  %386 = getelementptr inbounds { double, double }, ptr %384, i32 0, i32 1
  store double %382, ptr %385, align 8
  store double %383, ptr %386, align 8
  %387 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %388 = load double, ptr %387, align 8, !tbaa !11
  %389 = load ptr, ptr %19, align 8, !tbaa !5
  %390 = load i32, ptr %23, align 4, !tbaa !9
  %391 = sext i32 %390 to i64
  %392 = getelementptr inbounds %struct.doublecomplex, ptr %389, i64 %391
  %393 = getelementptr inbounds %struct.doublecomplex, ptr %392, i32 0, i32 0
  store double %388, ptr %393, align 8, !tbaa !11
  %394 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %395 = load double, ptr %394, align 8, !tbaa !14
  %396 = load ptr, ptr %19, align 8, !tbaa !5
  %397 = load i32, ptr %23, align 4, !tbaa !9
  %398 = sext i32 %397 to i64
  %399 = getelementptr inbounds %struct.doublecomplex, ptr %396, i64 %398
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %399, i32 0, i32 1
  store double %395, ptr %400, align 8, !tbaa !14
  %401 = load ptr, ptr %12, align 8, !tbaa !5
  %402 = load i32, ptr %401, align 4, !tbaa !9
  %403 = icmp sgt i32 %402, 1
  br i1 %403, label %404, label %535

404:                                              ; preds = %354
  %405 = load ptr, ptr %12, align 8, !tbaa !5
  %406 = load i32, ptr %405, align 4, !tbaa !9
  %407 = sub nsw i32 %406, 1
  %408 = load i32, ptr %41, align 4, !tbaa !9
  %409 = load i32, ptr %21, align 4, !tbaa !9
  %410 = mul nsw i32 %408, %409
  %411 = add nsw i32 %407, %410
  store i32 %411, ptr %23, align 4, !tbaa !9
  %412 = load ptr, ptr %12, align 8, !tbaa !5
  %413 = load i32, ptr %412, align 4, !tbaa !9
  %414 = sub nsw i32 %413, 1
  %415 = load i32, ptr %41, align 4, !tbaa !9
  %416 = load i32, ptr %21, align 4, !tbaa !9
  %417 = mul nsw i32 %415, %416
  %418 = add nsw i32 %414, %417
  store i32 %418, ptr %24, align 4, !tbaa !9
  %419 = load ptr, ptr %12, align 8, !tbaa !5
  %420 = load i32, ptr %419, align 4, !tbaa !9
  %421 = sub nsw i32 %420, 1
  store i32 %421, ptr %25, align 4, !tbaa !9
  %422 = load ptr, ptr %12, align 8, !tbaa !5
  %423 = load i32, ptr %422, align 4, !tbaa !9
  %424 = load i32, ptr %41, align 4, !tbaa !9
  %425 = load i32, ptr %21, align 4, !tbaa !9
  %426 = mul nsw i32 %424, %425
  %427 = add nsw i32 %423, %426
  store i32 %427, ptr %26, align 4, !tbaa !9
  %428 = load ptr, ptr %16, align 8, !tbaa !5
  %429 = load i32, ptr %25, align 4, !tbaa !9
  %430 = sext i32 %429 to i64
  %431 = getelementptr inbounds %struct.doublecomplex, ptr %428, i64 %430
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %431, i32 0, i32 0
  %433 = load double, ptr %432, align 8, !tbaa !11
  %434 = load ptr, ptr %19, align 8, !tbaa !5
  %435 = load i32, ptr %26, align 4, !tbaa !9
  %436 = sext i32 %435 to i64
  %437 = getelementptr inbounds %struct.doublecomplex, ptr %434, i64 %436
  %438 = getelementptr inbounds %struct.doublecomplex, ptr %437, i32 0, i32 0
  %439 = load double, ptr %438, align 8, !tbaa !11
  %440 = load ptr, ptr %16, align 8, !tbaa !5
  %441 = load i32, ptr %25, align 4, !tbaa !9
  %442 = sext i32 %441 to i64
  %443 = getelementptr inbounds %struct.doublecomplex, ptr %440, i64 %442
  %444 = getelementptr inbounds %struct.doublecomplex, ptr %443, i32 0, i32 1
  %445 = load double, ptr %444, align 8, !tbaa !14
  %446 = load ptr, ptr %19, align 8, !tbaa !5
  %447 = load i32, ptr %26, align 4, !tbaa !9
  %448 = sext i32 %447 to i64
  %449 = getelementptr inbounds %struct.doublecomplex, ptr %446, i64 %448
  %450 = getelementptr inbounds %struct.doublecomplex, ptr %449, i32 0, i32 1
  %451 = load double, ptr %450, align 8, !tbaa !14
  %452 = fmul double %445, %451
  %453 = fneg double %452
  %454 = call double @llvm.fmuladd.f64(double %433, double %439, double %453)
  %455 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %454, ptr %455, align 8, !tbaa !11
  %456 = load ptr, ptr %16, align 8, !tbaa !5
  %457 = load i32, ptr %25, align 4, !tbaa !9
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %456, i64 %458
  %460 = getelementptr inbounds %struct.doublecomplex, ptr %459, i32 0, i32 0
  %461 = load double, ptr %460, align 8, !tbaa !11
  %462 = load ptr, ptr %19, align 8, !tbaa !5
  %463 = load i32, ptr %26, align 4, !tbaa !9
  %464 = sext i32 %463 to i64
  %465 = getelementptr inbounds %struct.doublecomplex, ptr %462, i64 %464
  %466 = getelementptr inbounds %struct.doublecomplex, ptr %465, i32 0, i32 1
  %467 = load double, ptr %466, align 8, !tbaa !14
  %468 = load ptr, ptr %16, align 8, !tbaa !5
  %469 = load i32, ptr %25, align 4, !tbaa !9
  %470 = sext i32 %469 to i64
  %471 = getelementptr inbounds %struct.doublecomplex, ptr %468, i64 %470
  %472 = getelementptr inbounds %struct.doublecomplex, ptr %471, i32 0, i32 1
  %473 = load double, ptr %472, align 8, !tbaa !14
  %474 = load ptr, ptr %19, align 8, !tbaa !5
  %475 = load i32, ptr %26, align 4, !tbaa !9
  %476 = sext i32 %475 to i64
  %477 = getelementptr inbounds %struct.doublecomplex, ptr %474, i64 %476
  %478 = getelementptr inbounds %struct.doublecomplex, ptr %477, i32 0, i32 0
  %479 = load double, ptr %478, align 8, !tbaa !11
  %480 = fmul double %473, %479
  %481 = call double @llvm.fmuladd.f64(double %461, double %467, double %480)
  %482 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %481, ptr %482, align 8, !tbaa !14
  %483 = load ptr, ptr %19, align 8, !tbaa !5
  %484 = load i32, ptr %24, align 4, !tbaa !9
  %485 = sext i32 %484 to i64
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %483, i64 %485
  %487 = getelementptr inbounds %struct.doublecomplex, ptr %486, i32 0, i32 0
  %488 = load double, ptr %487, align 8, !tbaa !11
  %489 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %490 = load double, ptr %489, align 8, !tbaa !11
  %491 = fsub double %488, %490
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %491, ptr %492, align 8, !tbaa !11
  %493 = load ptr, ptr %19, align 8, !tbaa !5
  %494 = load i32, ptr %24, align 4, !tbaa !9
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds %struct.doublecomplex, ptr %493, i64 %495
  %497 = getelementptr inbounds %struct.doublecomplex, ptr %496, i32 0, i32 1
  %498 = load double, ptr %497, align 8, !tbaa !14
  %499 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %500 = load double, ptr %499, align 8, !tbaa !14
  %501 = fsub double %498, %500
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %501, ptr %502, align 8, !tbaa !14
  %503 = call { double, double } @Cd(ptr noundef %32)
  %504 = extractvalue { double, double } %503, 0
  %505 = extractvalue { double, double } %503, 1
  %506 = load ptr, ptr %15, align 8, !tbaa !5
  %507 = load ptr, ptr %12, align 8, !tbaa !5
  %508 = load i32, ptr %507, align 4, !tbaa !9
  %509 = sub nsw i32 %508, 1
  %510 = sext i32 %509 to i64
  %511 = getelementptr inbounds %struct.doublecomplex, ptr %506, i64 %510
  %512 = call { double, double } @Cd(ptr noundef %511)
  %513 = extractvalue { double, double } %512, 0
  %514 = extractvalue { double, double } %512, 1
  %515 = call { double, double } @__divdc3(double noundef %504, double noundef %505, double noundef %513, double noundef %514) #4
  %516 = extractvalue { double, double } %515, 0
  %517 = extractvalue { double, double } %515, 1
  %518 = call ptr @_pCd(ptr noundef %31)
  %519 = getelementptr inbounds { double, double }, ptr %518, i32 0, i32 0
  %520 = getelementptr inbounds { double, double }, ptr %518, i32 0, i32 1
  store double %516, ptr %519, align 8
  store double %517, ptr %520, align 8
  %521 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %522 = load double, ptr %521, align 8, !tbaa !11
  %523 = load ptr, ptr %19, align 8, !tbaa !5
  %524 = load i32, ptr %23, align 4, !tbaa !9
  %525 = sext i32 %524 to i64
  %526 = getelementptr inbounds %struct.doublecomplex, ptr %523, i64 %525
  %527 = getelementptr inbounds %struct.doublecomplex, ptr %526, i32 0, i32 0
  store double %522, ptr %527, align 8, !tbaa !11
  %528 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %529 = load double, ptr %528, align 8, !tbaa !14
  %530 = load ptr, ptr %19, align 8, !tbaa !5
  %531 = load i32, ptr %23, align 4, !tbaa !9
  %532 = sext i32 %531 to i64
  %533 = getelementptr inbounds %struct.doublecomplex, ptr %530, i64 %532
  %534 = getelementptr inbounds %struct.doublecomplex, ptr %533, i32 0, i32 1
  store double %529, ptr %534, align 8, !tbaa !14
  br label %535

535:                                              ; preds = %404, %354
  %536 = load ptr, ptr %12, align 8, !tbaa !5
  %537 = load i32, ptr %536, align 4, !tbaa !9
  %538 = sub nsw i32 %537, 2
  store i32 %538, ptr %40, align 4, !tbaa !9
  br label %539

539:                                              ; preds = %739, %535
  %540 = load i32, ptr %40, align 4, !tbaa !9
  %541 = icmp sge i32 %540, 1
  br i1 %541, label %542, label %742

542:                                              ; preds = %539
  %543 = load i32, ptr %40, align 4, !tbaa !9
  %544 = load i32, ptr %41, align 4, !tbaa !9
  %545 = load i32, ptr %21, align 4, !tbaa !9
  %546 = mul nsw i32 %544, %545
  %547 = add nsw i32 %543, %546
  store i32 %547, ptr %23, align 4, !tbaa !9
  %548 = load i32, ptr %40, align 4, !tbaa !9
  %549 = load i32, ptr %41, align 4, !tbaa !9
  %550 = load i32, ptr %21, align 4, !tbaa !9
  %551 = mul nsw i32 %549, %550
  %552 = add nsw i32 %548, %551
  store i32 %552, ptr %24, align 4, !tbaa !9
  %553 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %553, ptr %25, align 4, !tbaa !9
  %554 = load i32, ptr %40, align 4, !tbaa !9
  %555 = add nsw i32 %554, 1
  %556 = load i32, ptr %41, align 4, !tbaa !9
  %557 = load i32, ptr %21, align 4, !tbaa !9
  %558 = mul nsw i32 %556, %557
  %559 = add nsw i32 %555, %558
  store i32 %559, ptr %26, align 4, !tbaa !9
  %560 = load ptr, ptr %16, align 8, !tbaa !5
  %561 = load i32, ptr %25, align 4, !tbaa !9
  %562 = sext i32 %561 to i64
  %563 = getelementptr inbounds %struct.doublecomplex, ptr %560, i64 %562
  %564 = getelementptr inbounds %struct.doublecomplex, ptr %563, i32 0, i32 0
  %565 = load double, ptr %564, align 8, !tbaa !11
  %566 = load ptr, ptr %19, align 8, !tbaa !5
  %567 = load i32, ptr %26, align 4, !tbaa !9
  %568 = sext i32 %567 to i64
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %566, i64 %568
  %570 = getelementptr inbounds %struct.doublecomplex, ptr %569, i32 0, i32 0
  %571 = load double, ptr %570, align 8, !tbaa !11
  %572 = load ptr, ptr %16, align 8, !tbaa !5
  %573 = load i32, ptr %25, align 4, !tbaa !9
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %572, i64 %574
  %576 = getelementptr inbounds %struct.doublecomplex, ptr %575, i32 0, i32 1
  %577 = load double, ptr %576, align 8, !tbaa !14
  %578 = load ptr, ptr %19, align 8, !tbaa !5
  %579 = load i32, ptr %26, align 4, !tbaa !9
  %580 = sext i32 %579 to i64
  %581 = getelementptr inbounds %struct.doublecomplex, ptr %578, i64 %580
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %581, i32 0, i32 1
  %583 = load double, ptr %582, align 8, !tbaa !14
  %584 = fmul double %577, %583
  %585 = fneg double %584
  %586 = call double @llvm.fmuladd.f64(double %565, double %571, double %585)
  %587 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %586, ptr %587, align 8, !tbaa !11
  %588 = load ptr, ptr %16, align 8, !tbaa !5
  %589 = load i32, ptr %25, align 4, !tbaa !9
  %590 = sext i32 %589 to i64
  %591 = getelementptr inbounds %struct.doublecomplex, ptr %588, i64 %590
  %592 = getelementptr inbounds %struct.doublecomplex, ptr %591, i32 0, i32 0
  %593 = load double, ptr %592, align 8, !tbaa !11
  %594 = load ptr, ptr %19, align 8, !tbaa !5
  %595 = load i32, ptr %26, align 4, !tbaa !9
  %596 = sext i32 %595 to i64
  %597 = getelementptr inbounds %struct.doublecomplex, ptr %594, i64 %596
  %598 = getelementptr inbounds %struct.doublecomplex, ptr %597, i32 0, i32 1
  %599 = load double, ptr %598, align 8, !tbaa !14
  %600 = load ptr, ptr %16, align 8, !tbaa !5
  %601 = load i32, ptr %25, align 4, !tbaa !9
  %602 = sext i32 %601 to i64
  %603 = getelementptr inbounds %struct.doublecomplex, ptr %600, i64 %602
  %604 = getelementptr inbounds %struct.doublecomplex, ptr %603, i32 0, i32 1
  %605 = load double, ptr %604, align 8, !tbaa !14
  %606 = load ptr, ptr %19, align 8, !tbaa !5
  %607 = load i32, ptr %26, align 4, !tbaa !9
  %608 = sext i32 %607 to i64
  %609 = getelementptr inbounds %struct.doublecomplex, ptr %606, i64 %608
  %610 = getelementptr inbounds %struct.doublecomplex, ptr %609, i32 0, i32 0
  %611 = load double, ptr %610, align 8, !tbaa !11
  %612 = fmul double %605, %611
  %613 = call double @llvm.fmuladd.f64(double %593, double %599, double %612)
  %614 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %613, ptr %614, align 8, !tbaa !14
  %615 = load ptr, ptr %19, align 8, !tbaa !5
  %616 = load i32, ptr %24, align 4, !tbaa !9
  %617 = sext i32 %616 to i64
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %615, i64 %617
  %619 = getelementptr inbounds %struct.doublecomplex, ptr %618, i32 0, i32 0
  %620 = load double, ptr %619, align 8, !tbaa !11
  %621 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %622 = load double, ptr %621, align 8, !tbaa !11
  %623 = fsub double %620, %622
  %624 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %623, ptr %624, align 8, !tbaa !11
  %625 = load ptr, ptr %19, align 8, !tbaa !5
  %626 = load i32, ptr %24, align 4, !tbaa !9
  %627 = sext i32 %626 to i64
  %628 = getelementptr inbounds %struct.doublecomplex, ptr %625, i64 %627
  %629 = getelementptr inbounds %struct.doublecomplex, ptr %628, i32 0, i32 1
  %630 = load double, ptr %629, align 8, !tbaa !14
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %632 = load double, ptr %631, align 8, !tbaa !14
  %633 = fsub double %630, %632
  %634 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %633, ptr %634, align 8, !tbaa !14
  %635 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %635, ptr %27, align 4, !tbaa !9
  %636 = load i32, ptr %40, align 4, !tbaa !9
  %637 = add nsw i32 %636, 2
  %638 = load i32, ptr %41, align 4, !tbaa !9
  %639 = load i32, ptr %21, align 4, !tbaa !9
  %640 = mul nsw i32 %638, %639
  %641 = add nsw i32 %637, %640
  store i32 %641, ptr %28, align 4, !tbaa !9
  %642 = load ptr, ptr %17, align 8, !tbaa !5
  %643 = load i32, ptr %27, align 4, !tbaa !9
  %644 = sext i32 %643 to i64
  %645 = getelementptr inbounds %struct.doublecomplex, ptr %642, i64 %644
  %646 = getelementptr inbounds %struct.doublecomplex, ptr %645, i32 0, i32 0
  %647 = load double, ptr %646, align 8, !tbaa !11
  %648 = load ptr, ptr %19, align 8, !tbaa !5
  %649 = load i32, ptr %28, align 4, !tbaa !9
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds %struct.doublecomplex, ptr %648, i64 %650
  %652 = getelementptr inbounds %struct.doublecomplex, ptr %651, i32 0, i32 0
  %653 = load double, ptr %652, align 8, !tbaa !11
  %654 = load ptr, ptr %17, align 8, !tbaa !5
  %655 = load i32, ptr %27, align 4, !tbaa !9
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds %struct.doublecomplex, ptr %654, i64 %656
  %658 = getelementptr inbounds %struct.doublecomplex, ptr %657, i32 0, i32 1
  %659 = load double, ptr %658, align 8, !tbaa !14
  %660 = load ptr, ptr %19, align 8, !tbaa !5
  %661 = load i32, ptr %28, align 4, !tbaa !9
  %662 = sext i32 %661 to i64
  %663 = getelementptr inbounds %struct.doublecomplex, ptr %660, i64 %662
  %664 = getelementptr inbounds %struct.doublecomplex, ptr %663, i32 0, i32 1
  %665 = load double, ptr %664, align 8, !tbaa !14
  %666 = fmul double %659, %665
  %667 = fneg double %666
  %668 = call double @llvm.fmuladd.f64(double %647, double %653, double %667)
  %669 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %668, ptr %669, align 8, !tbaa !11
  %670 = load ptr, ptr %17, align 8, !tbaa !5
  %671 = load i32, ptr %27, align 4, !tbaa !9
  %672 = sext i32 %671 to i64
  %673 = getelementptr inbounds %struct.doublecomplex, ptr %670, i64 %672
  %674 = getelementptr inbounds %struct.doublecomplex, ptr %673, i32 0, i32 0
  %675 = load double, ptr %674, align 8, !tbaa !11
  %676 = load ptr, ptr %19, align 8, !tbaa !5
  %677 = load i32, ptr %28, align 4, !tbaa !9
  %678 = sext i32 %677 to i64
  %679 = getelementptr inbounds %struct.doublecomplex, ptr %676, i64 %678
  %680 = getelementptr inbounds %struct.doublecomplex, ptr %679, i32 0, i32 1
  %681 = load double, ptr %680, align 8, !tbaa !14
  %682 = load ptr, ptr %17, align 8, !tbaa !5
  %683 = load i32, ptr %27, align 4, !tbaa !9
  %684 = sext i32 %683 to i64
  %685 = getelementptr inbounds %struct.doublecomplex, ptr %682, i64 %684
  %686 = getelementptr inbounds %struct.doublecomplex, ptr %685, i32 0, i32 1
  %687 = load double, ptr %686, align 8, !tbaa !14
  %688 = load ptr, ptr %19, align 8, !tbaa !5
  %689 = load i32, ptr %28, align 4, !tbaa !9
  %690 = sext i32 %689 to i64
  %691 = getelementptr inbounds %struct.doublecomplex, ptr %688, i64 %690
  %692 = getelementptr inbounds %struct.doublecomplex, ptr %691, i32 0, i32 0
  %693 = load double, ptr %692, align 8, !tbaa !11
  %694 = fmul double %687, %693
  %695 = call double @llvm.fmuladd.f64(double %675, double %681, double %694)
  %696 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %695, ptr %696, align 8, !tbaa !14
  %697 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %698 = load double, ptr %697, align 8, !tbaa !11
  %699 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %700 = load double, ptr %699, align 8, !tbaa !11
  %701 = fsub double %698, %700
  %702 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %701, ptr %702, align 8, !tbaa !11
  %703 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %704 = load double, ptr %703, align 8, !tbaa !14
  %705 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %706 = load double, ptr %705, align 8, !tbaa !14
  %707 = fsub double %704, %706
  %708 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %707, ptr %708, align 8, !tbaa !14
  %709 = call { double, double } @Cd(ptr noundef %32)
  %710 = extractvalue { double, double } %709, 0
  %711 = extractvalue { double, double } %709, 1
  %712 = load ptr, ptr %15, align 8, !tbaa !5
  %713 = load i32, ptr %40, align 4, !tbaa !9
  %714 = sext i32 %713 to i64
  %715 = getelementptr inbounds %struct.doublecomplex, ptr %712, i64 %714
  %716 = call { double, double } @Cd(ptr noundef %715)
  %717 = extractvalue { double, double } %716, 0
  %718 = extractvalue { double, double } %716, 1
  %719 = call { double, double } @__divdc3(double noundef %710, double noundef %711, double noundef %717, double noundef %718) #4
  %720 = extractvalue { double, double } %719, 0
  %721 = extractvalue { double, double } %719, 1
  %722 = call ptr @_pCd(ptr noundef %31)
  %723 = getelementptr inbounds { double, double }, ptr %722, i32 0, i32 0
  %724 = getelementptr inbounds { double, double }, ptr %722, i32 0, i32 1
  store double %720, ptr %723, align 8
  store double %721, ptr %724, align 8
  %725 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %726 = load double, ptr %725, align 8, !tbaa !11
  %727 = load ptr, ptr %19, align 8, !tbaa !5
  %728 = load i32, ptr %23, align 4, !tbaa !9
  %729 = sext i32 %728 to i64
  %730 = getelementptr inbounds %struct.doublecomplex, ptr %727, i64 %729
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %730, i32 0, i32 0
  store double %726, ptr %731, align 8, !tbaa !11
  %732 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %733 = load double, ptr %732, align 8, !tbaa !14
  %734 = load ptr, ptr %19, align 8, !tbaa !5
  %735 = load i32, ptr %23, align 4, !tbaa !9
  %736 = sext i32 %735 to i64
  %737 = getelementptr inbounds %struct.doublecomplex, ptr %734, i64 %736
  %738 = getelementptr inbounds %struct.doublecomplex, ptr %737, i32 0, i32 1
  store double %733, ptr %738, align 8, !tbaa !14
  br label %739

739:                                              ; preds = %542
  %740 = load i32, ptr %40, align 4, !tbaa !9
  %741 = add nsw i32 %740, -1
  store i32 %741, ptr %40, align 4, !tbaa !9
  br label %539, !llvm.loop !17

742:                                              ; preds = %539
  %743 = load i32, ptr %41, align 4, !tbaa !9
  %744 = load ptr, ptr %13, align 8, !tbaa !5
  %745 = load i32, ptr %744, align 4, !tbaa !9
  %746 = icmp slt i32 %743, %745
  br i1 %746, label %747, label %750

747:                                              ; preds = %742
  %748 = load i32, ptr %41, align 4, !tbaa !9
  %749 = add nsw i32 %748, 1
  store i32 %749, ptr %41, align 4, !tbaa !9
  br label %80

750:                                              ; preds = %742
  br label %1425

751:                                              ; preds = %75
  %752 = load ptr, ptr %13, align 8, !tbaa !5
  %753 = load i32, ptr %752, align 4, !tbaa !9
  store i32 %753, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %754

754:                                              ; preds = %1421, %751
  %755 = load i32, ptr %41, align 4, !tbaa !9
  %756 = load i32, ptr %23, align 4, !tbaa !9
  %757 = icmp sle i32 %755, %756
  br i1 %757, label %758, label %1424

758:                                              ; preds = %754
  %759 = load ptr, ptr %12, align 8, !tbaa !5
  %760 = load i32, ptr %759, align 4, !tbaa !9
  %761 = sub nsw i32 %760, 1
  store i32 %761, ptr %24, align 4, !tbaa !9
  store i32 1, ptr %40, align 4, !tbaa !9
  br label %762

762:                                              ; preds = %1029, %758
  %763 = load i32, ptr %40, align 4, !tbaa !9
  %764 = load i32, ptr %24, align 4, !tbaa !9
  %765 = icmp sle i32 %763, %764
  br i1 %765, label %766, label %1032

766:                                              ; preds = %762
  %767 = load ptr, ptr %18, align 8, !tbaa !5
  %768 = load i32, ptr %40, align 4, !tbaa !9
  %769 = sext i32 %768 to i64
  %770 = getelementptr inbounds i32, ptr %767, i64 %769
  %771 = load i32, ptr %770, align 4, !tbaa !9
  %772 = load i32, ptr %40, align 4, !tbaa !9
  %773 = icmp eq i32 %771, %772
  br i1 %773, label %774, label %882

774:                                              ; preds = %766
  %775 = load i32, ptr %40, align 4, !tbaa !9
  %776 = add nsw i32 %775, 1
  %777 = load i32, ptr %41, align 4, !tbaa !9
  %778 = load i32, ptr %21, align 4, !tbaa !9
  %779 = mul nsw i32 %777, %778
  %780 = add nsw i32 %776, %779
  store i32 %780, ptr %25, align 4, !tbaa !9
  %781 = load i32, ptr %40, align 4, !tbaa !9
  %782 = add nsw i32 %781, 1
  %783 = load i32, ptr %41, align 4, !tbaa !9
  %784 = load i32, ptr %21, align 4, !tbaa !9
  %785 = mul nsw i32 %783, %784
  %786 = add nsw i32 %782, %785
  store i32 %786, ptr %26, align 4, !tbaa !9
  %787 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %787, ptr %27, align 4, !tbaa !9
  %788 = load i32, ptr %40, align 4, !tbaa !9
  %789 = load i32, ptr %41, align 4, !tbaa !9
  %790 = load i32, ptr %21, align 4, !tbaa !9
  %791 = mul nsw i32 %789, %790
  %792 = add nsw i32 %788, %791
  store i32 %792, ptr %28, align 4, !tbaa !9
  %793 = load ptr, ptr %14, align 8, !tbaa !5
  %794 = load i32, ptr %27, align 4, !tbaa !9
  %795 = sext i32 %794 to i64
  %796 = getelementptr inbounds %struct.doublecomplex, ptr %793, i64 %795
  %797 = getelementptr inbounds %struct.doublecomplex, ptr %796, i32 0, i32 0
  %798 = load double, ptr %797, align 8, !tbaa !11
  %799 = load ptr, ptr %19, align 8, !tbaa !5
  %800 = load i32, ptr %28, align 4, !tbaa !9
  %801 = sext i32 %800 to i64
  %802 = getelementptr inbounds %struct.doublecomplex, ptr %799, i64 %801
  %803 = getelementptr inbounds %struct.doublecomplex, ptr %802, i32 0, i32 0
  %804 = load double, ptr %803, align 8, !tbaa !11
  %805 = load ptr, ptr %14, align 8, !tbaa !5
  %806 = load i32, ptr %27, align 4, !tbaa !9
  %807 = sext i32 %806 to i64
  %808 = getelementptr inbounds %struct.doublecomplex, ptr %805, i64 %807
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %808, i32 0, i32 1
  %810 = load double, ptr %809, align 8, !tbaa !14
  %811 = load ptr, ptr %19, align 8, !tbaa !5
  %812 = load i32, ptr %28, align 4, !tbaa !9
  %813 = sext i32 %812 to i64
  %814 = getelementptr inbounds %struct.doublecomplex, ptr %811, i64 %813
  %815 = getelementptr inbounds %struct.doublecomplex, ptr %814, i32 0, i32 1
  %816 = load double, ptr %815, align 8, !tbaa !14
  %817 = fmul double %810, %816
  %818 = fneg double %817
  %819 = call double @llvm.fmuladd.f64(double %798, double %804, double %818)
  %820 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %819, ptr %820, align 8, !tbaa !11
  %821 = load ptr, ptr %14, align 8, !tbaa !5
  %822 = load i32, ptr %27, align 4, !tbaa !9
  %823 = sext i32 %822 to i64
  %824 = getelementptr inbounds %struct.doublecomplex, ptr %821, i64 %823
  %825 = getelementptr inbounds %struct.doublecomplex, ptr %824, i32 0, i32 0
  %826 = load double, ptr %825, align 8, !tbaa !11
  %827 = load ptr, ptr %19, align 8, !tbaa !5
  %828 = load i32, ptr %28, align 4, !tbaa !9
  %829 = sext i32 %828 to i64
  %830 = getelementptr inbounds %struct.doublecomplex, ptr %827, i64 %829
  %831 = getelementptr inbounds %struct.doublecomplex, ptr %830, i32 0, i32 1
  %832 = load double, ptr %831, align 8, !tbaa !14
  %833 = load ptr, ptr %14, align 8, !tbaa !5
  %834 = load i32, ptr %27, align 4, !tbaa !9
  %835 = sext i32 %834 to i64
  %836 = getelementptr inbounds %struct.doublecomplex, ptr %833, i64 %835
  %837 = getelementptr inbounds %struct.doublecomplex, ptr %836, i32 0, i32 1
  %838 = load double, ptr %837, align 8, !tbaa !14
  %839 = load ptr, ptr %19, align 8, !tbaa !5
  %840 = load i32, ptr %28, align 4, !tbaa !9
  %841 = sext i32 %840 to i64
  %842 = getelementptr inbounds %struct.doublecomplex, ptr %839, i64 %841
  %843 = getelementptr inbounds %struct.doublecomplex, ptr %842, i32 0, i32 0
  %844 = load double, ptr %843, align 8, !tbaa !11
  %845 = fmul double %838, %844
  %846 = call double @llvm.fmuladd.f64(double %826, double %832, double %845)
  %847 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %846, ptr %847, align 8, !tbaa !14
  %848 = load ptr, ptr %19, align 8, !tbaa !5
  %849 = load i32, ptr %26, align 4, !tbaa !9
  %850 = sext i32 %849 to i64
  %851 = getelementptr inbounds %struct.doublecomplex, ptr %848, i64 %850
  %852 = getelementptr inbounds %struct.doublecomplex, ptr %851, i32 0, i32 0
  %853 = load double, ptr %852, align 8, !tbaa !11
  %854 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %855 = load double, ptr %854, align 8, !tbaa !11
  %856 = fsub double %853, %855
  %857 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %856, ptr %857, align 8, !tbaa !11
  %858 = load ptr, ptr %19, align 8, !tbaa !5
  %859 = load i32, ptr %26, align 4, !tbaa !9
  %860 = sext i32 %859 to i64
  %861 = getelementptr inbounds %struct.doublecomplex, ptr %858, i64 %860
  %862 = getelementptr inbounds %struct.doublecomplex, ptr %861, i32 0, i32 1
  %863 = load double, ptr %862, align 8, !tbaa !14
  %864 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %865 = load double, ptr %864, align 8, !tbaa !14
  %866 = fsub double %863, %865
  %867 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %866, ptr %867, align 8, !tbaa !14
  %868 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %869 = load double, ptr %868, align 8, !tbaa !11
  %870 = load ptr, ptr %19, align 8, !tbaa !5
  %871 = load i32, ptr %25, align 4, !tbaa !9
  %872 = sext i32 %871 to i64
  %873 = getelementptr inbounds %struct.doublecomplex, ptr %870, i64 %872
  %874 = getelementptr inbounds %struct.doublecomplex, ptr %873, i32 0, i32 0
  store double %869, ptr %874, align 8, !tbaa !11
  %875 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %876 = load double, ptr %875, align 8, !tbaa !14
  %877 = load ptr, ptr %19, align 8, !tbaa !5
  %878 = load i32, ptr %25, align 4, !tbaa !9
  %879 = sext i32 %878 to i64
  %880 = getelementptr inbounds %struct.doublecomplex, ptr %877, i64 %879
  %881 = getelementptr inbounds %struct.doublecomplex, ptr %880, i32 0, i32 1
  store double %876, ptr %881, align 8, !tbaa !14
  br label %1028

882:                                              ; preds = %766
  %883 = load i32, ptr %40, align 4, !tbaa !9
  %884 = load i32, ptr %41, align 4, !tbaa !9
  %885 = load i32, ptr %21, align 4, !tbaa !9
  %886 = mul nsw i32 %884, %885
  %887 = add nsw i32 %883, %886
  store i32 %887, ptr %25, align 4, !tbaa !9
  %888 = load ptr, ptr %19, align 8, !tbaa !5
  %889 = load i32, ptr %25, align 4, !tbaa !9
  %890 = sext i32 %889 to i64
  %891 = getelementptr inbounds %struct.doublecomplex, ptr %888, i64 %890
  %892 = getelementptr inbounds %struct.doublecomplex, ptr %891, i32 0, i32 0
  %893 = load double, ptr %892, align 8, !tbaa !11
  %894 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %893, ptr %894, align 8, !tbaa !11
  %895 = load ptr, ptr %19, align 8, !tbaa !5
  %896 = load i32, ptr %25, align 4, !tbaa !9
  %897 = sext i32 %896 to i64
  %898 = getelementptr inbounds %struct.doublecomplex, ptr %895, i64 %897
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %898, i32 0, i32 1
  %900 = load double, ptr %899, align 8, !tbaa !14
  %901 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %900, ptr %901, align 8, !tbaa !14
  %902 = load i32, ptr %40, align 4, !tbaa !9
  %903 = load i32, ptr %41, align 4, !tbaa !9
  %904 = load i32, ptr %21, align 4, !tbaa !9
  %905 = mul nsw i32 %903, %904
  %906 = add nsw i32 %902, %905
  store i32 %906, ptr %25, align 4, !tbaa !9
  %907 = load i32, ptr %40, align 4, !tbaa !9
  %908 = add nsw i32 %907, 1
  %909 = load i32, ptr %41, align 4, !tbaa !9
  %910 = load i32, ptr %21, align 4, !tbaa !9
  %911 = mul nsw i32 %909, %910
  %912 = add nsw i32 %908, %911
  store i32 %912, ptr %26, align 4, !tbaa !9
  %913 = load ptr, ptr %19, align 8, !tbaa !5
  %914 = load i32, ptr %26, align 4, !tbaa !9
  %915 = sext i32 %914 to i64
  %916 = getelementptr inbounds %struct.doublecomplex, ptr %913, i64 %915
  %917 = getelementptr inbounds %struct.doublecomplex, ptr %916, i32 0, i32 0
  %918 = load double, ptr %917, align 8, !tbaa !11
  %919 = load ptr, ptr %19, align 8, !tbaa !5
  %920 = load i32, ptr %25, align 4, !tbaa !9
  %921 = sext i32 %920 to i64
  %922 = getelementptr inbounds %struct.doublecomplex, ptr %919, i64 %921
  %923 = getelementptr inbounds %struct.doublecomplex, ptr %922, i32 0, i32 0
  store double %918, ptr %923, align 8, !tbaa !11
  %924 = load ptr, ptr %19, align 8, !tbaa !5
  %925 = load i32, ptr %26, align 4, !tbaa !9
  %926 = sext i32 %925 to i64
  %927 = getelementptr inbounds %struct.doublecomplex, ptr %924, i64 %926
  %928 = getelementptr inbounds %struct.doublecomplex, ptr %927, i32 0, i32 1
  %929 = load double, ptr %928, align 8, !tbaa !14
  %930 = load ptr, ptr %19, align 8, !tbaa !5
  %931 = load i32, ptr %25, align 4, !tbaa !9
  %932 = sext i32 %931 to i64
  %933 = getelementptr inbounds %struct.doublecomplex, ptr %930, i64 %932
  %934 = getelementptr inbounds %struct.doublecomplex, ptr %933, i32 0, i32 1
  store double %929, ptr %934, align 8, !tbaa !14
  %935 = load i32, ptr %40, align 4, !tbaa !9
  %936 = add nsw i32 %935, 1
  %937 = load i32, ptr %41, align 4, !tbaa !9
  %938 = load i32, ptr %21, align 4, !tbaa !9
  %939 = mul nsw i32 %937, %938
  %940 = add nsw i32 %936, %939
  store i32 %940, ptr %25, align 4, !tbaa !9
  %941 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %941, ptr %26, align 4, !tbaa !9
  %942 = load i32, ptr %40, align 4, !tbaa !9
  %943 = load i32, ptr %41, align 4, !tbaa !9
  %944 = load i32, ptr %21, align 4, !tbaa !9
  %945 = mul nsw i32 %943, %944
  %946 = add nsw i32 %942, %945
  store i32 %946, ptr %27, align 4, !tbaa !9
  %947 = load ptr, ptr %14, align 8, !tbaa !5
  %948 = load i32, ptr %26, align 4, !tbaa !9
  %949 = sext i32 %948 to i64
  %950 = getelementptr inbounds %struct.doublecomplex, ptr %947, i64 %949
  %951 = getelementptr inbounds %struct.doublecomplex, ptr %950, i32 0, i32 0
  %952 = load double, ptr %951, align 8, !tbaa !11
  %953 = load ptr, ptr %19, align 8, !tbaa !5
  %954 = load i32, ptr %27, align 4, !tbaa !9
  %955 = sext i32 %954 to i64
  %956 = getelementptr inbounds %struct.doublecomplex, ptr %953, i64 %955
  %957 = getelementptr inbounds %struct.doublecomplex, ptr %956, i32 0, i32 0
  %958 = load double, ptr %957, align 8, !tbaa !11
  %959 = load ptr, ptr %14, align 8, !tbaa !5
  %960 = load i32, ptr %26, align 4, !tbaa !9
  %961 = sext i32 %960 to i64
  %962 = getelementptr inbounds %struct.doublecomplex, ptr %959, i64 %961
  %963 = getelementptr inbounds %struct.doublecomplex, ptr %962, i32 0, i32 1
  %964 = load double, ptr %963, align 8, !tbaa !14
  %965 = load ptr, ptr %19, align 8, !tbaa !5
  %966 = load i32, ptr %27, align 4, !tbaa !9
  %967 = sext i32 %966 to i64
  %968 = getelementptr inbounds %struct.doublecomplex, ptr %965, i64 %967
  %969 = getelementptr inbounds %struct.doublecomplex, ptr %968, i32 0, i32 1
  %970 = load double, ptr %969, align 8, !tbaa !14
  %971 = fmul double %964, %970
  %972 = fneg double %971
  %973 = call double @llvm.fmuladd.f64(double %952, double %958, double %972)
  %974 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %973, ptr %974, align 8, !tbaa !11
  %975 = load ptr, ptr %14, align 8, !tbaa !5
  %976 = load i32, ptr %26, align 4, !tbaa !9
  %977 = sext i32 %976 to i64
  %978 = getelementptr inbounds %struct.doublecomplex, ptr %975, i64 %977
  %979 = getelementptr inbounds %struct.doublecomplex, ptr %978, i32 0, i32 0
  %980 = load double, ptr %979, align 8, !tbaa !11
  %981 = load ptr, ptr %19, align 8, !tbaa !5
  %982 = load i32, ptr %27, align 4, !tbaa !9
  %983 = sext i32 %982 to i64
  %984 = getelementptr inbounds %struct.doublecomplex, ptr %981, i64 %983
  %985 = getelementptr inbounds %struct.doublecomplex, ptr %984, i32 0, i32 1
  %986 = load double, ptr %985, align 8, !tbaa !14
  %987 = load ptr, ptr %14, align 8, !tbaa !5
  %988 = load i32, ptr %26, align 4, !tbaa !9
  %989 = sext i32 %988 to i64
  %990 = getelementptr inbounds %struct.doublecomplex, ptr %987, i64 %989
  %991 = getelementptr inbounds %struct.doublecomplex, ptr %990, i32 0, i32 1
  %992 = load double, ptr %991, align 8, !tbaa !14
  %993 = load ptr, ptr %19, align 8, !tbaa !5
  %994 = load i32, ptr %27, align 4, !tbaa !9
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds %struct.doublecomplex, ptr %993, i64 %995
  %997 = getelementptr inbounds %struct.doublecomplex, ptr %996, i32 0, i32 0
  %998 = load double, ptr %997, align 8, !tbaa !11
  %999 = fmul double %992, %998
  %1000 = call double @llvm.fmuladd.f64(double %980, double %986, double %999)
  %1001 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1000, ptr %1001, align 8, !tbaa !14
  %1002 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1003 = load double, ptr %1002, align 8, !tbaa !11
  %1004 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1005 = load double, ptr %1004, align 8, !tbaa !11
  %1006 = fsub double %1003, %1005
  %1007 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1006, ptr %1007, align 8, !tbaa !11
  %1008 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1009 = load double, ptr %1008, align 8, !tbaa !14
  %1010 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %1011 = load double, ptr %1010, align 8, !tbaa !14
  %1012 = fsub double %1009, %1011
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1012, ptr %1013, align 8, !tbaa !14
  %1014 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1015 = load double, ptr %1014, align 8, !tbaa !11
  %1016 = load ptr, ptr %19, align 8, !tbaa !5
  %1017 = load i32, ptr %25, align 4, !tbaa !9
  %1018 = sext i32 %1017 to i64
  %1019 = getelementptr inbounds %struct.doublecomplex, ptr %1016, i64 %1018
  %1020 = getelementptr inbounds %struct.doublecomplex, ptr %1019, i32 0, i32 0
  store double %1015, ptr %1020, align 8, !tbaa !11
  %1021 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1022 = load double, ptr %1021, align 8, !tbaa !14
  %1023 = load ptr, ptr %19, align 8, !tbaa !5
  %1024 = load i32, ptr %25, align 4, !tbaa !9
  %1025 = sext i32 %1024 to i64
  %1026 = getelementptr inbounds %struct.doublecomplex, ptr %1023, i64 %1025
  %1027 = getelementptr inbounds %struct.doublecomplex, ptr %1026, i32 0, i32 1
  store double %1022, ptr %1027, align 8, !tbaa !14
  br label %1028

1028:                                             ; preds = %882, %774
  br label %1029

1029:                                             ; preds = %1028
  %1030 = load i32, ptr %40, align 4, !tbaa !9
  %1031 = add nsw i32 %1030, 1
  store i32 %1031, ptr %40, align 4, !tbaa !9
  br label %762, !llvm.loop !18

1032:                                             ; preds = %762
  %1033 = load ptr, ptr %12, align 8, !tbaa !5
  %1034 = load i32, ptr %1033, align 4, !tbaa !9
  %1035 = load i32, ptr %41, align 4, !tbaa !9
  %1036 = load i32, ptr %21, align 4, !tbaa !9
  %1037 = mul nsw i32 %1035, %1036
  %1038 = add nsw i32 %1034, %1037
  store i32 %1038, ptr %24, align 4, !tbaa !9
  %1039 = load ptr, ptr %19, align 8, !tbaa !5
  %1040 = load ptr, ptr %12, align 8, !tbaa !5
  %1041 = load i32, ptr %1040, align 4, !tbaa !9
  %1042 = load i32, ptr %41, align 4, !tbaa !9
  %1043 = load i32, ptr %21, align 4, !tbaa !9
  %1044 = mul nsw i32 %1042, %1043
  %1045 = add nsw i32 %1041, %1044
  %1046 = sext i32 %1045 to i64
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %1039, i64 %1046
  %1048 = call { double, double } @Cd(ptr noundef %1047)
  %1049 = extractvalue { double, double } %1048, 0
  %1050 = extractvalue { double, double } %1048, 1
  %1051 = load ptr, ptr %15, align 8, !tbaa !5
  %1052 = load ptr, ptr %12, align 8, !tbaa !5
  %1053 = load i32, ptr %1052, align 4, !tbaa !9
  %1054 = sext i32 %1053 to i64
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %1051, i64 %1054
  %1056 = call { double, double } @Cd(ptr noundef %1055)
  %1057 = extractvalue { double, double } %1056, 0
  %1058 = extractvalue { double, double } %1056, 1
  %1059 = call { double, double } @__divdc3(double noundef %1049, double noundef %1050, double noundef %1057, double noundef %1058) #4
  %1060 = extractvalue { double, double } %1059, 0
  %1061 = extractvalue { double, double } %1059, 1
  %1062 = call ptr @_pCd(ptr noundef %31)
  %1063 = getelementptr inbounds { double, double }, ptr %1062, i32 0, i32 0
  %1064 = getelementptr inbounds { double, double }, ptr %1062, i32 0, i32 1
  store double %1060, ptr %1063, align 8
  store double %1061, ptr %1064, align 8
  %1065 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1066 = load double, ptr %1065, align 8, !tbaa !11
  %1067 = load ptr, ptr %19, align 8, !tbaa !5
  %1068 = load i32, ptr %24, align 4, !tbaa !9
  %1069 = sext i32 %1068 to i64
  %1070 = getelementptr inbounds %struct.doublecomplex, ptr %1067, i64 %1069
  %1071 = getelementptr inbounds %struct.doublecomplex, ptr %1070, i32 0, i32 0
  store double %1066, ptr %1071, align 8, !tbaa !11
  %1072 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1073 = load double, ptr %1072, align 8, !tbaa !14
  %1074 = load ptr, ptr %19, align 8, !tbaa !5
  %1075 = load i32, ptr %24, align 4, !tbaa !9
  %1076 = sext i32 %1075 to i64
  %1077 = getelementptr inbounds %struct.doublecomplex, ptr %1074, i64 %1076
  %1078 = getelementptr inbounds %struct.doublecomplex, ptr %1077, i32 0, i32 1
  store double %1073, ptr %1078, align 8, !tbaa !14
  %1079 = load ptr, ptr %12, align 8, !tbaa !5
  %1080 = load i32, ptr %1079, align 4, !tbaa !9
  %1081 = icmp sgt i32 %1080, 1
  br i1 %1081, label %1082, label %1213

1082:                                             ; preds = %1032
  %1083 = load ptr, ptr %12, align 8, !tbaa !5
  %1084 = load i32, ptr %1083, align 4, !tbaa !9
  %1085 = sub nsw i32 %1084, 1
  %1086 = load i32, ptr %41, align 4, !tbaa !9
  %1087 = load i32, ptr %21, align 4, !tbaa !9
  %1088 = mul nsw i32 %1086, %1087
  %1089 = add nsw i32 %1085, %1088
  store i32 %1089, ptr %24, align 4, !tbaa !9
  %1090 = load ptr, ptr %12, align 8, !tbaa !5
  %1091 = load i32, ptr %1090, align 4, !tbaa !9
  %1092 = sub nsw i32 %1091, 1
  %1093 = load i32, ptr %41, align 4, !tbaa !9
  %1094 = load i32, ptr %21, align 4, !tbaa !9
  %1095 = mul nsw i32 %1093, %1094
  %1096 = add nsw i32 %1092, %1095
  store i32 %1096, ptr %25, align 4, !tbaa !9
  %1097 = load ptr, ptr %12, align 8, !tbaa !5
  %1098 = load i32, ptr %1097, align 4, !tbaa !9
  %1099 = sub nsw i32 %1098, 1
  store i32 %1099, ptr %26, align 4, !tbaa !9
  %1100 = load ptr, ptr %12, align 8, !tbaa !5
  %1101 = load i32, ptr %1100, align 4, !tbaa !9
  %1102 = load i32, ptr %41, align 4, !tbaa !9
  %1103 = load i32, ptr %21, align 4, !tbaa !9
  %1104 = mul nsw i32 %1102, %1103
  %1105 = add nsw i32 %1101, %1104
  store i32 %1105, ptr %27, align 4, !tbaa !9
  %1106 = load ptr, ptr %16, align 8, !tbaa !5
  %1107 = load i32, ptr %26, align 4, !tbaa !9
  %1108 = sext i32 %1107 to i64
  %1109 = getelementptr inbounds %struct.doublecomplex, ptr %1106, i64 %1108
  %1110 = getelementptr inbounds %struct.doublecomplex, ptr %1109, i32 0, i32 0
  %1111 = load double, ptr %1110, align 8, !tbaa !11
  %1112 = load ptr, ptr %19, align 8, !tbaa !5
  %1113 = load i32, ptr %27, align 4, !tbaa !9
  %1114 = sext i32 %1113 to i64
  %1115 = getelementptr inbounds %struct.doublecomplex, ptr %1112, i64 %1114
  %1116 = getelementptr inbounds %struct.doublecomplex, ptr %1115, i32 0, i32 0
  %1117 = load double, ptr %1116, align 8, !tbaa !11
  %1118 = load ptr, ptr %16, align 8, !tbaa !5
  %1119 = load i32, ptr %26, align 4, !tbaa !9
  %1120 = sext i32 %1119 to i64
  %1121 = getelementptr inbounds %struct.doublecomplex, ptr %1118, i64 %1120
  %1122 = getelementptr inbounds %struct.doublecomplex, ptr %1121, i32 0, i32 1
  %1123 = load double, ptr %1122, align 8, !tbaa !14
  %1124 = load ptr, ptr %19, align 8, !tbaa !5
  %1125 = load i32, ptr %27, align 4, !tbaa !9
  %1126 = sext i32 %1125 to i64
  %1127 = getelementptr inbounds %struct.doublecomplex, ptr %1124, i64 %1126
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %1127, i32 0, i32 1
  %1129 = load double, ptr %1128, align 8, !tbaa !14
  %1130 = fmul double %1123, %1129
  %1131 = fneg double %1130
  %1132 = call double @llvm.fmuladd.f64(double %1111, double %1117, double %1131)
  %1133 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1132, ptr %1133, align 8, !tbaa !11
  %1134 = load ptr, ptr %16, align 8, !tbaa !5
  %1135 = load i32, ptr %26, align 4, !tbaa !9
  %1136 = sext i32 %1135 to i64
  %1137 = getelementptr inbounds %struct.doublecomplex, ptr %1134, i64 %1136
  %1138 = getelementptr inbounds %struct.doublecomplex, ptr %1137, i32 0, i32 0
  %1139 = load double, ptr %1138, align 8, !tbaa !11
  %1140 = load ptr, ptr %19, align 8, !tbaa !5
  %1141 = load i32, ptr %27, align 4, !tbaa !9
  %1142 = sext i32 %1141 to i64
  %1143 = getelementptr inbounds %struct.doublecomplex, ptr %1140, i64 %1142
  %1144 = getelementptr inbounds %struct.doublecomplex, ptr %1143, i32 0, i32 1
  %1145 = load double, ptr %1144, align 8, !tbaa !14
  %1146 = load ptr, ptr %16, align 8, !tbaa !5
  %1147 = load i32, ptr %26, align 4, !tbaa !9
  %1148 = sext i32 %1147 to i64
  %1149 = getelementptr inbounds %struct.doublecomplex, ptr %1146, i64 %1148
  %1150 = getelementptr inbounds %struct.doublecomplex, ptr %1149, i32 0, i32 1
  %1151 = load double, ptr %1150, align 8, !tbaa !14
  %1152 = load ptr, ptr %19, align 8, !tbaa !5
  %1153 = load i32, ptr %27, align 4, !tbaa !9
  %1154 = sext i32 %1153 to i64
  %1155 = getelementptr inbounds %struct.doublecomplex, ptr %1152, i64 %1154
  %1156 = getelementptr inbounds %struct.doublecomplex, ptr %1155, i32 0, i32 0
  %1157 = load double, ptr %1156, align 8, !tbaa !11
  %1158 = fmul double %1151, %1157
  %1159 = call double @llvm.fmuladd.f64(double %1139, double %1145, double %1158)
  %1160 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %1159, ptr %1160, align 8, !tbaa !14
  %1161 = load ptr, ptr %19, align 8, !tbaa !5
  %1162 = load i32, ptr %25, align 4, !tbaa !9
  %1163 = sext i32 %1162 to i64
  %1164 = getelementptr inbounds %struct.doublecomplex, ptr %1161, i64 %1163
  %1165 = getelementptr inbounds %struct.doublecomplex, ptr %1164, i32 0, i32 0
  %1166 = load double, ptr %1165, align 8, !tbaa !11
  %1167 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1168 = load double, ptr %1167, align 8, !tbaa !11
  %1169 = fsub double %1166, %1168
  %1170 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1169, ptr %1170, align 8, !tbaa !11
  %1171 = load ptr, ptr %19, align 8, !tbaa !5
  %1172 = load i32, ptr %25, align 4, !tbaa !9
  %1173 = sext i32 %1172 to i64
  %1174 = getelementptr inbounds %struct.doublecomplex, ptr %1171, i64 %1173
  %1175 = getelementptr inbounds %struct.doublecomplex, ptr %1174, i32 0, i32 1
  %1176 = load double, ptr %1175, align 8, !tbaa !14
  %1177 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1178 = load double, ptr %1177, align 8, !tbaa !14
  %1179 = fsub double %1176, %1178
  %1180 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1179, ptr %1180, align 8, !tbaa !14
  %1181 = call { double, double } @Cd(ptr noundef %32)
  %1182 = extractvalue { double, double } %1181, 0
  %1183 = extractvalue { double, double } %1181, 1
  %1184 = load ptr, ptr %15, align 8, !tbaa !5
  %1185 = load ptr, ptr %12, align 8, !tbaa !5
  %1186 = load i32, ptr %1185, align 4, !tbaa !9
  %1187 = sub nsw i32 %1186, 1
  %1188 = sext i32 %1187 to i64
  %1189 = getelementptr inbounds %struct.doublecomplex, ptr %1184, i64 %1188
  %1190 = call { double, double } @Cd(ptr noundef %1189)
  %1191 = extractvalue { double, double } %1190, 0
  %1192 = extractvalue { double, double } %1190, 1
  %1193 = call { double, double } @__divdc3(double noundef %1182, double noundef %1183, double noundef %1191, double noundef %1192) #4
  %1194 = extractvalue { double, double } %1193, 0
  %1195 = extractvalue { double, double } %1193, 1
  %1196 = call ptr @_pCd(ptr noundef %31)
  %1197 = getelementptr inbounds { double, double }, ptr %1196, i32 0, i32 0
  %1198 = getelementptr inbounds { double, double }, ptr %1196, i32 0, i32 1
  store double %1194, ptr %1197, align 8
  store double %1195, ptr %1198, align 8
  %1199 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1200 = load double, ptr %1199, align 8, !tbaa !11
  %1201 = load ptr, ptr %19, align 8, !tbaa !5
  %1202 = load i32, ptr %24, align 4, !tbaa !9
  %1203 = sext i32 %1202 to i64
  %1204 = getelementptr inbounds %struct.doublecomplex, ptr %1201, i64 %1203
  %1205 = getelementptr inbounds %struct.doublecomplex, ptr %1204, i32 0, i32 0
  store double %1200, ptr %1205, align 8, !tbaa !11
  %1206 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1207 = load double, ptr %1206, align 8, !tbaa !14
  %1208 = load ptr, ptr %19, align 8, !tbaa !5
  %1209 = load i32, ptr %24, align 4, !tbaa !9
  %1210 = sext i32 %1209 to i64
  %1211 = getelementptr inbounds %struct.doublecomplex, ptr %1208, i64 %1210
  %1212 = getelementptr inbounds %struct.doublecomplex, ptr %1211, i32 0, i32 1
  store double %1207, ptr %1212, align 8, !tbaa !14
  br label %1213

1213:                                             ; preds = %1082, %1032
  %1214 = load ptr, ptr %12, align 8, !tbaa !5
  %1215 = load i32, ptr %1214, align 4, !tbaa !9
  %1216 = sub nsw i32 %1215, 2
  store i32 %1216, ptr %40, align 4, !tbaa !9
  br label %1217

1217:                                             ; preds = %1417, %1213
  %1218 = load i32, ptr %40, align 4, !tbaa !9
  %1219 = icmp sge i32 %1218, 1
  br i1 %1219, label %1220, label %1420

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

1417:                                             ; preds = %1220
  %1418 = load i32, ptr %40, align 4, !tbaa !9
  %1419 = add nsw i32 %1418, -1
  store i32 %1419, ptr %40, align 4, !tbaa !9
  br label %1217, !llvm.loop !19

1420:                                             ; preds = %1217
  br label %1421

1421:                                             ; preds = %1420
  %1422 = load i32, ptr %41, align 4, !tbaa !9
  %1423 = add nsw i32 %1422, 1
  store i32 %1423, ptr %41, align 4, !tbaa !9
  br label %754, !llvm.loop !20

1424:                                             ; preds = %754
  br label %1425

1425:                                             ; preds = %1424, %750
  br label %3925

1426:                                             ; preds = %71
  %1427 = load ptr, ptr %11, align 8, !tbaa !5
  %1428 = load i32, ptr %1427, align 4, !tbaa !9
  %1429 = icmp eq i32 %1428, 1
  br i1 %1429, label %1430, label %2679

1430:                                             ; preds = %1426
  %1431 = load ptr, ptr %13, align 8, !tbaa !5
  %1432 = load i32, ptr %1431, align 4, !tbaa !9
  %1433 = icmp sle i32 %1432, 1
  br i1 %1433, label %1434, label %2055

1434:                                             ; preds = %1430
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %1435

1435:                                             ; preds = %2051, %1434
  %1436 = load i32, ptr %41, align 4, !tbaa !9
  %1437 = load i32, ptr %21, align 4, !tbaa !9
  %1438 = mul nsw i32 %1436, %1437
  %1439 = add nsw i32 %1438, 1
  store i32 %1439, ptr %23, align 4, !tbaa !9
  %1440 = load ptr, ptr %19, align 8, !tbaa !5
  %1441 = load i32, ptr %41, align 4, !tbaa !9
  %1442 = load i32, ptr %21, align 4, !tbaa !9
  %1443 = mul nsw i32 %1441, %1442
  %1444 = add nsw i32 %1443, 1
  %1445 = sext i32 %1444 to i64
  %1446 = getelementptr inbounds %struct.doublecomplex, ptr %1440, i64 %1445
  %1447 = call { double, double } @Cd(ptr noundef %1446)
  %1448 = extractvalue { double, double } %1447, 0
  %1449 = extractvalue { double, double } %1447, 1
  %1450 = load ptr, ptr %15, align 8, !tbaa !5
  %1451 = getelementptr inbounds %struct.doublecomplex, ptr %1450, i64 1
  %1452 = call { double, double } @Cd(ptr noundef %1451)
  %1453 = extractvalue { double, double } %1452, 0
  %1454 = extractvalue { double, double } %1452, 1
  %1455 = call { double, double } @__divdc3(double noundef %1448, double noundef %1449, double noundef %1453, double noundef %1454) #4
  %1456 = extractvalue { double, double } %1455, 0
  %1457 = extractvalue { double, double } %1455, 1
  %1458 = call ptr @_pCd(ptr noundef %31)
  %1459 = getelementptr inbounds { double, double }, ptr %1458, i32 0, i32 0
  %1460 = getelementptr inbounds { double, double }, ptr %1458, i32 0, i32 1
  store double %1456, ptr %1459, align 8
  store double %1457, ptr %1460, align 8
  %1461 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1462 = load double, ptr %1461, align 8, !tbaa !11
  %1463 = load ptr, ptr %19, align 8, !tbaa !5
  %1464 = load i32, ptr %23, align 4, !tbaa !9
  %1465 = sext i32 %1464 to i64
  %1466 = getelementptr inbounds %struct.doublecomplex, ptr %1463, i64 %1465
  %1467 = getelementptr inbounds %struct.doublecomplex, ptr %1466, i32 0, i32 0
  store double %1462, ptr %1467, align 8, !tbaa !11
  %1468 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1469 = load double, ptr %1468, align 8, !tbaa !14
  %1470 = load ptr, ptr %19, align 8, !tbaa !5
  %1471 = load i32, ptr %23, align 4, !tbaa !9
  %1472 = sext i32 %1471 to i64
  %1473 = getelementptr inbounds %struct.doublecomplex, ptr %1470, i64 %1472
  %1474 = getelementptr inbounds %struct.doublecomplex, ptr %1473, i32 0, i32 1
  store double %1469, ptr %1474, align 8, !tbaa !14
  %1475 = load ptr, ptr %12, align 8, !tbaa !5
  %1476 = load i32, ptr %1475, align 4, !tbaa !9
  %1477 = icmp sgt i32 %1476, 1
  br i1 %1477, label %1478, label %1586

1478:                                             ; preds = %1435
  %1479 = load i32, ptr %41, align 4, !tbaa !9
  %1480 = load i32, ptr %21, align 4, !tbaa !9
  %1481 = mul nsw i32 %1479, %1480
  %1482 = add nsw i32 %1481, 2
  store i32 %1482, ptr %23, align 4, !tbaa !9
  %1483 = load i32, ptr %41, align 4, !tbaa !9
  %1484 = load i32, ptr %21, align 4, !tbaa !9
  %1485 = mul nsw i32 %1483, %1484
  %1486 = add nsw i32 %1485, 2
  store i32 %1486, ptr %24, align 4, !tbaa !9
  %1487 = load i32, ptr %41, align 4, !tbaa !9
  %1488 = load i32, ptr %21, align 4, !tbaa !9
  %1489 = mul nsw i32 %1487, %1488
  %1490 = add nsw i32 %1489, 1
  store i32 %1490, ptr %25, align 4, !tbaa !9
  %1491 = load ptr, ptr %16, align 8, !tbaa !5
  %1492 = getelementptr inbounds %struct.doublecomplex, ptr %1491, i64 1
  %1493 = getelementptr inbounds %struct.doublecomplex, ptr %1492, i32 0, i32 0
  %1494 = load double, ptr %1493, align 8, !tbaa !11
  %1495 = load ptr, ptr %19, align 8, !tbaa !5
  %1496 = load i32, ptr %25, align 4, !tbaa !9
  %1497 = sext i32 %1496 to i64
  %1498 = getelementptr inbounds %struct.doublecomplex, ptr %1495, i64 %1497
  %1499 = getelementptr inbounds %struct.doublecomplex, ptr %1498, i32 0, i32 0
  %1500 = load double, ptr %1499, align 8, !tbaa !11
  %1501 = load ptr, ptr %16, align 8, !tbaa !5
  %1502 = getelementptr inbounds %struct.doublecomplex, ptr %1501, i64 1
  %1503 = getelementptr inbounds %struct.doublecomplex, ptr %1502, i32 0, i32 1
  %1504 = load double, ptr %1503, align 8, !tbaa !14
  %1505 = load ptr, ptr %19, align 8, !tbaa !5
  %1506 = load i32, ptr %25, align 4, !tbaa !9
  %1507 = sext i32 %1506 to i64
  %1508 = getelementptr inbounds %struct.doublecomplex, ptr %1505, i64 %1507
  %1509 = getelementptr inbounds %struct.doublecomplex, ptr %1508, i32 0, i32 1
  %1510 = load double, ptr %1509, align 8, !tbaa !14
  %1511 = fmul double %1504, %1510
  %1512 = fneg double %1511
  %1513 = call double @llvm.fmuladd.f64(double %1494, double %1500, double %1512)
  %1514 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1513, ptr %1514, align 8, !tbaa !11
  %1515 = load ptr, ptr %16, align 8, !tbaa !5
  %1516 = getelementptr inbounds %struct.doublecomplex, ptr %1515, i64 1
  %1517 = getelementptr inbounds %struct.doublecomplex, ptr %1516, i32 0, i32 0
  %1518 = load double, ptr %1517, align 8, !tbaa !11
  %1519 = load ptr, ptr %19, align 8, !tbaa !5
  %1520 = load i32, ptr %25, align 4, !tbaa !9
  %1521 = sext i32 %1520 to i64
  %1522 = getelementptr inbounds %struct.doublecomplex, ptr %1519, i64 %1521
  %1523 = getelementptr inbounds %struct.doublecomplex, ptr %1522, i32 0, i32 1
  %1524 = load double, ptr %1523, align 8, !tbaa !14
  %1525 = load ptr, ptr %16, align 8, !tbaa !5
  %1526 = getelementptr inbounds %struct.doublecomplex, ptr %1525, i64 1
  %1527 = getelementptr inbounds %struct.doublecomplex, ptr %1526, i32 0, i32 1
  %1528 = load double, ptr %1527, align 8, !tbaa !14
  %1529 = load ptr, ptr %19, align 8, !tbaa !5
  %1530 = load i32, ptr %25, align 4, !tbaa !9
  %1531 = sext i32 %1530 to i64
  %1532 = getelementptr inbounds %struct.doublecomplex, ptr %1529, i64 %1531
  %1533 = getelementptr inbounds %struct.doublecomplex, ptr %1532, i32 0, i32 0
  %1534 = load double, ptr %1533, align 8, !tbaa !11
  %1535 = fmul double %1528, %1534
  %1536 = call double @llvm.fmuladd.f64(double %1518, double %1524, double %1535)
  %1537 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %1536, ptr %1537, align 8, !tbaa !14
  %1538 = load ptr, ptr %19, align 8, !tbaa !5
  %1539 = load i32, ptr %24, align 4, !tbaa !9
  %1540 = sext i32 %1539 to i64
  %1541 = getelementptr inbounds %struct.doublecomplex, ptr %1538, i64 %1540
  %1542 = getelementptr inbounds %struct.doublecomplex, ptr %1541, i32 0, i32 0
  %1543 = load double, ptr %1542, align 8, !tbaa !11
  %1544 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1545 = load double, ptr %1544, align 8, !tbaa !11
  %1546 = fsub double %1543, %1545
  %1547 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1546, ptr %1547, align 8, !tbaa !11
  %1548 = load ptr, ptr %19, align 8, !tbaa !5
  %1549 = load i32, ptr %24, align 4, !tbaa !9
  %1550 = sext i32 %1549 to i64
  %1551 = getelementptr inbounds %struct.doublecomplex, ptr %1548, i64 %1550
  %1552 = getelementptr inbounds %struct.doublecomplex, ptr %1551, i32 0, i32 1
  %1553 = load double, ptr %1552, align 8, !tbaa !14
  %1554 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1555 = load double, ptr %1554, align 8, !tbaa !14
  %1556 = fsub double %1553, %1555
  %1557 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1556, ptr %1557, align 8, !tbaa !14
  %1558 = call { double, double } @Cd(ptr noundef %32)
  %1559 = extractvalue { double, double } %1558, 0
  %1560 = extractvalue { double, double } %1558, 1
  %1561 = load ptr, ptr %15, align 8, !tbaa !5
  %1562 = getelementptr inbounds %struct.doublecomplex, ptr %1561, i64 2
  %1563 = call { double, double } @Cd(ptr noundef %1562)
  %1564 = extractvalue { double, double } %1563, 0
  %1565 = extractvalue { double, double } %1563, 1
  %1566 = call { double, double } @__divdc3(double noundef %1559, double noundef %1560, double noundef %1564, double noundef %1565) #4
  %1567 = extractvalue { double, double } %1566, 0
  %1568 = extractvalue { double, double } %1566, 1
  %1569 = call ptr @_pCd(ptr noundef %31)
  %1570 = getelementptr inbounds { double, double }, ptr %1569, i32 0, i32 0
  %1571 = getelementptr inbounds { double, double }, ptr %1569, i32 0, i32 1
  store double %1567, ptr %1570, align 8
  store double %1568, ptr %1571, align 8
  %1572 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1573 = load double, ptr %1572, align 8, !tbaa !11
  %1574 = load ptr, ptr %19, align 8, !tbaa !5
  %1575 = load i32, ptr %23, align 4, !tbaa !9
  %1576 = sext i32 %1575 to i64
  %1577 = getelementptr inbounds %struct.doublecomplex, ptr %1574, i64 %1576
  %1578 = getelementptr inbounds %struct.doublecomplex, ptr %1577, i32 0, i32 0
  store double %1573, ptr %1578, align 8, !tbaa !11
  %1579 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1580 = load double, ptr %1579, align 8, !tbaa !14
  %1581 = load ptr, ptr %19, align 8, !tbaa !5
  %1582 = load i32, ptr %23, align 4, !tbaa !9
  %1583 = sext i32 %1582 to i64
  %1584 = getelementptr inbounds %struct.doublecomplex, ptr %1581, i64 %1583
  %1585 = getelementptr inbounds %struct.doublecomplex, ptr %1584, i32 0, i32 1
  store double %1580, ptr %1585, align 8, !tbaa !14
  br label %1586

1586:                                             ; preds = %1478, %1435
  %1587 = load ptr, ptr %12, align 8, !tbaa !5
  %1588 = load i32, ptr %1587, align 4, !tbaa !9
  store i32 %1588, ptr %23, align 4, !tbaa !9
  store i32 3, ptr %40, align 4, !tbaa !9
  br label %1589

1589:                                             ; preds = %1792, %1586
  %1590 = load i32, ptr %40, align 4, !tbaa !9
  %1591 = load i32, ptr %23, align 4, !tbaa !9
  %1592 = icmp sle i32 %1590, %1591
  br i1 %1592, label %1593, label %1795

1593:                                             ; preds = %1589
  %1594 = load i32, ptr %40, align 4, !tbaa !9
  %1595 = load i32, ptr %41, align 4, !tbaa !9
  %1596 = load i32, ptr %21, align 4, !tbaa !9
  %1597 = mul nsw i32 %1595, %1596
  %1598 = add nsw i32 %1594, %1597
  store i32 %1598, ptr %24, align 4, !tbaa !9
  %1599 = load i32, ptr %40, align 4, !tbaa !9
  %1600 = load i32, ptr %41, align 4, !tbaa !9
  %1601 = load i32, ptr %21, align 4, !tbaa !9
  %1602 = mul nsw i32 %1600, %1601
  %1603 = add nsw i32 %1599, %1602
  store i32 %1603, ptr %25, align 4, !tbaa !9
  %1604 = load i32, ptr %40, align 4, !tbaa !9
  %1605 = sub nsw i32 %1604, 1
  store i32 %1605, ptr %26, align 4, !tbaa !9
  %1606 = load i32, ptr %40, align 4, !tbaa !9
  %1607 = sub nsw i32 %1606, 1
  %1608 = load i32, ptr %41, align 4, !tbaa !9
  %1609 = load i32, ptr %21, align 4, !tbaa !9
  %1610 = mul nsw i32 %1608, %1609
  %1611 = add nsw i32 %1607, %1610
  store i32 %1611, ptr %27, align 4, !tbaa !9
  %1612 = load ptr, ptr %16, align 8, !tbaa !5
  %1613 = load i32, ptr %26, align 4, !tbaa !9
  %1614 = sext i32 %1613 to i64
  %1615 = getelementptr inbounds %struct.doublecomplex, ptr %1612, i64 %1614
  %1616 = getelementptr inbounds %struct.doublecomplex, ptr %1615, i32 0, i32 0
  %1617 = load double, ptr %1616, align 8, !tbaa !11
  %1618 = load ptr, ptr %19, align 8, !tbaa !5
  %1619 = load i32, ptr %27, align 4, !tbaa !9
  %1620 = sext i32 %1619 to i64
  %1621 = getelementptr inbounds %struct.doublecomplex, ptr %1618, i64 %1620
  %1622 = getelementptr inbounds %struct.doublecomplex, ptr %1621, i32 0, i32 0
  %1623 = load double, ptr %1622, align 8, !tbaa !11
  %1624 = load ptr, ptr %16, align 8, !tbaa !5
  %1625 = load i32, ptr %26, align 4, !tbaa !9
  %1626 = sext i32 %1625 to i64
  %1627 = getelementptr inbounds %struct.doublecomplex, ptr %1624, i64 %1626
  %1628 = getelementptr inbounds %struct.doublecomplex, ptr %1627, i32 0, i32 1
  %1629 = load double, ptr %1628, align 8, !tbaa !14
  %1630 = load ptr, ptr %19, align 8, !tbaa !5
  %1631 = load i32, ptr %27, align 4, !tbaa !9
  %1632 = sext i32 %1631 to i64
  %1633 = getelementptr inbounds %struct.doublecomplex, ptr %1630, i64 %1632
  %1634 = getelementptr inbounds %struct.doublecomplex, ptr %1633, i32 0, i32 1
  %1635 = load double, ptr %1634, align 8, !tbaa !14
  %1636 = fmul double %1629, %1635
  %1637 = fneg double %1636
  %1638 = call double @llvm.fmuladd.f64(double %1617, double %1623, double %1637)
  %1639 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %1638, ptr %1639, align 8, !tbaa !11
  %1640 = load ptr, ptr %16, align 8, !tbaa !5
  %1641 = load i32, ptr %26, align 4, !tbaa !9
  %1642 = sext i32 %1641 to i64
  %1643 = getelementptr inbounds %struct.doublecomplex, ptr %1640, i64 %1642
  %1644 = getelementptr inbounds %struct.doublecomplex, ptr %1643, i32 0, i32 0
  %1645 = load double, ptr %1644, align 8, !tbaa !11
  %1646 = load ptr, ptr %19, align 8, !tbaa !5
  %1647 = load i32, ptr %27, align 4, !tbaa !9
  %1648 = sext i32 %1647 to i64
  %1649 = getelementptr inbounds %struct.doublecomplex, ptr %1646, i64 %1648
  %1650 = getelementptr inbounds %struct.doublecomplex, ptr %1649, i32 0, i32 1
  %1651 = load double, ptr %1650, align 8, !tbaa !14
  %1652 = load ptr, ptr %16, align 8, !tbaa !5
  %1653 = load i32, ptr %26, align 4, !tbaa !9
  %1654 = sext i32 %1653 to i64
  %1655 = getelementptr inbounds %struct.doublecomplex, ptr %1652, i64 %1654
  %1656 = getelementptr inbounds %struct.doublecomplex, ptr %1655, i32 0, i32 1
  %1657 = load double, ptr %1656, align 8, !tbaa !14
  %1658 = load ptr, ptr %19, align 8, !tbaa !5
  %1659 = load i32, ptr %27, align 4, !tbaa !9
  %1660 = sext i32 %1659 to i64
  %1661 = getelementptr inbounds %struct.doublecomplex, ptr %1658, i64 %1660
  %1662 = getelementptr inbounds %struct.doublecomplex, ptr %1661, i32 0, i32 0
  %1663 = load double, ptr %1662, align 8, !tbaa !11
  %1664 = fmul double %1657, %1663
  %1665 = call double @llvm.fmuladd.f64(double %1645, double %1651, double %1664)
  %1666 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %1665, ptr %1666, align 8, !tbaa !14
  %1667 = load ptr, ptr %19, align 8, !tbaa !5
  %1668 = load i32, ptr %25, align 4, !tbaa !9
  %1669 = sext i32 %1668 to i64
  %1670 = getelementptr inbounds %struct.doublecomplex, ptr %1667, i64 %1669
  %1671 = getelementptr inbounds %struct.doublecomplex, ptr %1670, i32 0, i32 0
  %1672 = load double, ptr %1671, align 8, !tbaa !11
  %1673 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1674 = load double, ptr %1673, align 8, !tbaa !11
  %1675 = fsub double %1672, %1674
  %1676 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %1675, ptr %1676, align 8, !tbaa !11
  %1677 = load ptr, ptr %19, align 8, !tbaa !5
  %1678 = load i32, ptr %25, align 4, !tbaa !9
  %1679 = sext i32 %1678 to i64
  %1680 = getelementptr inbounds %struct.doublecomplex, ptr %1677, i64 %1679
  %1681 = getelementptr inbounds %struct.doublecomplex, ptr %1680, i32 0, i32 1
  %1682 = load double, ptr %1681, align 8, !tbaa !14
  %1683 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1684 = load double, ptr %1683, align 8, !tbaa !14
  %1685 = fsub double %1682, %1684
  %1686 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %1685, ptr %1686, align 8, !tbaa !14
  %1687 = load i32, ptr %40, align 4, !tbaa !9
  %1688 = sub nsw i32 %1687, 2
  store i32 %1688, ptr %28, align 4, !tbaa !9
  %1689 = load i32, ptr %40, align 4, !tbaa !9
  %1690 = sub nsw i32 %1689, 2
  %1691 = load i32, ptr %41, align 4, !tbaa !9
  %1692 = load i32, ptr %21, align 4, !tbaa !9
  %1693 = mul nsw i32 %1691, %1692
  %1694 = add nsw i32 %1690, %1693
  store i32 %1694, ptr %29, align 4, !tbaa !9
  %1695 = load ptr, ptr %17, align 8, !tbaa !5
  %1696 = load i32, ptr %28, align 4, !tbaa !9
  %1697 = sext i32 %1696 to i64
  %1698 = getelementptr inbounds %struct.doublecomplex, ptr %1695, i64 %1697
  %1699 = getelementptr inbounds %struct.doublecomplex, ptr %1698, i32 0, i32 0
  %1700 = load double, ptr %1699, align 8, !tbaa !11
  %1701 = load ptr, ptr %19, align 8, !tbaa !5
  %1702 = load i32, ptr %29, align 4, !tbaa !9
  %1703 = sext i32 %1702 to i64
  %1704 = getelementptr inbounds %struct.doublecomplex, ptr %1701, i64 %1703
  %1705 = getelementptr inbounds %struct.doublecomplex, ptr %1704, i32 0, i32 0
  %1706 = load double, ptr %1705, align 8, !tbaa !11
  %1707 = load ptr, ptr %17, align 8, !tbaa !5
  %1708 = load i32, ptr %28, align 4, !tbaa !9
  %1709 = sext i32 %1708 to i64
  %1710 = getelementptr inbounds %struct.doublecomplex, ptr %1707, i64 %1709
  %1711 = getelementptr inbounds %struct.doublecomplex, ptr %1710, i32 0, i32 1
  %1712 = load double, ptr %1711, align 8, !tbaa !14
  %1713 = load ptr, ptr %19, align 8, !tbaa !5
  %1714 = load i32, ptr %29, align 4, !tbaa !9
  %1715 = sext i32 %1714 to i64
  %1716 = getelementptr inbounds %struct.doublecomplex, ptr %1713, i64 %1715
  %1717 = getelementptr inbounds %struct.doublecomplex, ptr %1716, i32 0, i32 1
  %1718 = load double, ptr %1717, align 8, !tbaa !14
  %1719 = fmul double %1712, %1718
  %1720 = fneg double %1719
  %1721 = call double @llvm.fmuladd.f64(double %1700, double %1706, double %1720)
  %1722 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %1721, ptr %1722, align 8, !tbaa !11
  %1723 = load ptr, ptr %17, align 8, !tbaa !5
  %1724 = load i32, ptr %28, align 4, !tbaa !9
  %1725 = sext i32 %1724 to i64
  %1726 = getelementptr inbounds %struct.doublecomplex, ptr %1723, i64 %1725
  %1727 = getelementptr inbounds %struct.doublecomplex, ptr %1726, i32 0, i32 0
  %1728 = load double, ptr %1727, align 8, !tbaa !11
  %1729 = load ptr, ptr %19, align 8, !tbaa !5
  %1730 = load i32, ptr %29, align 4, !tbaa !9
  %1731 = sext i32 %1730 to i64
  %1732 = getelementptr inbounds %struct.doublecomplex, ptr %1729, i64 %1731
  %1733 = getelementptr inbounds %struct.doublecomplex, ptr %1732, i32 0, i32 1
  %1734 = load double, ptr %1733, align 8, !tbaa !14
  %1735 = load ptr, ptr %17, align 8, !tbaa !5
  %1736 = load i32, ptr %28, align 4, !tbaa !9
  %1737 = sext i32 %1736 to i64
  %1738 = getelementptr inbounds %struct.doublecomplex, ptr %1735, i64 %1737
  %1739 = getelementptr inbounds %struct.doublecomplex, ptr %1738, i32 0, i32 1
  %1740 = load double, ptr %1739, align 8, !tbaa !14
  %1741 = load ptr, ptr %19, align 8, !tbaa !5
  %1742 = load i32, ptr %29, align 4, !tbaa !9
  %1743 = sext i32 %1742 to i64
  %1744 = getelementptr inbounds %struct.doublecomplex, ptr %1741, i64 %1743
  %1745 = getelementptr inbounds %struct.doublecomplex, ptr %1744, i32 0, i32 0
  %1746 = load double, ptr %1745, align 8, !tbaa !11
  %1747 = fmul double %1740, %1746
  %1748 = call double @llvm.fmuladd.f64(double %1728, double %1734, double %1747)
  %1749 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %1748, ptr %1749, align 8, !tbaa !14
  %1750 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %1751 = load double, ptr %1750, align 8, !tbaa !11
  %1752 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %1753 = load double, ptr %1752, align 8, !tbaa !11
  %1754 = fsub double %1751, %1753
  %1755 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1754, ptr %1755, align 8, !tbaa !11
  %1756 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %1757 = load double, ptr %1756, align 8, !tbaa !14
  %1758 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %1759 = load double, ptr %1758, align 8, !tbaa !14
  %1760 = fsub double %1757, %1759
  %1761 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1760, ptr %1761, align 8, !tbaa !14
  %1762 = call { double, double } @Cd(ptr noundef %32)
  %1763 = extractvalue { double, double } %1762, 0
  %1764 = extractvalue { double, double } %1762, 1
  %1765 = load ptr, ptr %15, align 8, !tbaa !5
  %1766 = load i32, ptr %40, align 4, !tbaa !9
  %1767 = sext i32 %1766 to i64
  %1768 = getelementptr inbounds %struct.doublecomplex, ptr %1765, i64 %1767
  %1769 = call { double, double } @Cd(ptr noundef %1768)
  %1770 = extractvalue { double, double } %1769, 0
  %1771 = extractvalue { double, double } %1769, 1
  %1772 = call { double, double } @__divdc3(double noundef %1763, double noundef %1764, double noundef %1770, double noundef %1771) #4
  %1773 = extractvalue { double, double } %1772, 0
  %1774 = extractvalue { double, double } %1772, 1
  %1775 = call ptr @_pCd(ptr noundef %31)
  %1776 = getelementptr inbounds { double, double }, ptr %1775, i32 0, i32 0
  %1777 = getelementptr inbounds { double, double }, ptr %1775, i32 0, i32 1
  store double %1773, ptr %1776, align 8
  store double %1774, ptr %1777, align 8
  %1778 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1779 = load double, ptr %1778, align 8, !tbaa !11
  %1780 = load ptr, ptr %19, align 8, !tbaa !5
  %1781 = load i32, ptr %24, align 4, !tbaa !9
  %1782 = sext i32 %1781 to i64
  %1783 = getelementptr inbounds %struct.doublecomplex, ptr %1780, i64 %1782
  %1784 = getelementptr inbounds %struct.doublecomplex, ptr %1783, i32 0, i32 0
  store double %1779, ptr %1784, align 8, !tbaa !11
  %1785 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1786 = load double, ptr %1785, align 8, !tbaa !14
  %1787 = load ptr, ptr %19, align 8, !tbaa !5
  %1788 = load i32, ptr %24, align 4, !tbaa !9
  %1789 = sext i32 %1788 to i64
  %1790 = getelementptr inbounds %struct.doublecomplex, ptr %1787, i64 %1789
  %1791 = getelementptr inbounds %struct.doublecomplex, ptr %1790, i32 0, i32 1
  store double %1786, ptr %1791, align 8, !tbaa !14
  br label %1792

1792:                                             ; preds = %1593
  %1793 = load i32, ptr %40, align 4, !tbaa !9
  %1794 = add nsw i32 %1793, 1
  store i32 %1794, ptr %40, align 4, !tbaa !9
  br label %1589, !llvm.loop !21

1795:                                             ; preds = %1589
  %1796 = load ptr, ptr %12, align 8, !tbaa !5
  %1797 = load i32, ptr %1796, align 4, !tbaa !9
  %1798 = sub nsw i32 %1797, 1
  store i32 %1798, ptr %40, align 4, !tbaa !9
  br label %1799

1799:                                             ; preds = %2043, %1795
  %1800 = load i32, ptr %40, align 4, !tbaa !9
  %1801 = icmp sge i32 %1800, 1
  br i1 %1801, label %1802, label %2046

1802:                                             ; preds = %1799
  %1803 = load ptr, ptr %18, align 8, !tbaa !5
  %1804 = load i32, ptr %40, align 4, !tbaa !9
  %1805 = sext i32 %1804 to i64
  %1806 = getelementptr inbounds i32, ptr %1803, i64 %1805
  %1807 = load i32, ptr %1806, align 4, !tbaa !9
  %1808 = load i32, ptr %40, align 4, !tbaa !9
  %1809 = icmp eq i32 %1807, %1808
  br i1 %1809, label %1810, label %1917

1810:                                             ; preds = %1802
  %1811 = load i32, ptr %40, align 4, !tbaa !9
  %1812 = load i32, ptr %41, align 4, !tbaa !9
  %1813 = load i32, ptr %21, align 4, !tbaa !9
  %1814 = mul nsw i32 %1812, %1813
  %1815 = add nsw i32 %1811, %1814
  store i32 %1815, ptr %23, align 4, !tbaa !9
  %1816 = load i32, ptr %40, align 4, !tbaa !9
  %1817 = load i32, ptr %41, align 4, !tbaa !9
  %1818 = load i32, ptr %21, align 4, !tbaa !9
  %1819 = mul nsw i32 %1817, %1818
  %1820 = add nsw i32 %1816, %1819
  store i32 %1820, ptr %24, align 4, !tbaa !9
  %1821 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %1821, ptr %25, align 4, !tbaa !9
  %1822 = load i32, ptr %40, align 4, !tbaa !9
  %1823 = add nsw i32 %1822, 1
  %1824 = load i32, ptr %41, align 4, !tbaa !9
  %1825 = load i32, ptr %21, align 4, !tbaa !9
  %1826 = mul nsw i32 %1824, %1825
  %1827 = add nsw i32 %1823, %1826
  store i32 %1827, ptr %26, align 4, !tbaa !9
  %1828 = load ptr, ptr %14, align 8, !tbaa !5
  %1829 = load i32, ptr %25, align 4, !tbaa !9
  %1830 = sext i32 %1829 to i64
  %1831 = getelementptr inbounds %struct.doublecomplex, ptr %1828, i64 %1830
  %1832 = getelementptr inbounds %struct.doublecomplex, ptr %1831, i32 0, i32 0
  %1833 = load double, ptr %1832, align 8, !tbaa !11
  %1834 = load ptr, ptr %19, align 8, !tbaa !5
  %1835 = load i32, ptr %26, align 4, !tbaa !9
  %1836 = sext i32 %1835 to i64
  %1837 = getelementptr inbounds %struct.doublecomplex, ptr %1834, i64 %1836
  %1838 = getelementptr inbounds %struct.doublecomplex, ptr %1837, i32 0, i32 0
  %1839 = load double, ptr %1838, align 8, !tbaa !11
  %1840 = load ptr, ptr %14, align 8, !tbaa !5
  %1841 = load i32, ptr %25, align 4, !tbaa !9
  %1842 = sext i32 %1841 to i64
  %1843 = getelementptr inbounds %struct.doublecomplex, ptr %1840, i64 %1842
  %1844 = getelementptr inbounds %struct.doublecomplex, ptr %1843, i32 0, i32 1
  %1845 = load double, ptr %1844, align 8, !tbaa !14
  %1846 = load ptr, ptr %19, align 8, !tbaa !5
  %1847 = load i32, ptr %26, align 4, !tbaa !9
  %1848 = sext i32 %1847 to i64
  %1849 = getelementptr inbounds %struct.doublecomplex, ptr %1846, i64 %1848
  %1850 = getelementptr inbounds %struct.doublecomplex, ptr %1849, i32 0, i32 1
  %1851 = load double, ptr %1850, align 8, !tbaa !14
  %1852 = fmul double %1845, %1851
  %1853 = fneg double %1852
  %1854 = call double @llvm.fmuladd.f64(double %1833, double %1839, double %1853)
  %1855 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1854, ptr %1855, align 8, !tbaa !11
  %1856 = load ptr, ptr %14, align 8, !tbaa !5
  %1857 = load i32, ptr %25, align 4, !tbaa !9
  %1858 = sext i32 %1857 to i64
  %1859 = getelementptr inbounds %struct.doublecomplex, ptr %1856, i64 %1858
  %1860 = getelementptr inbounds %struct.doublecomplex, ptr %1859, i32 0, i32 0
  %1861 = load double, ptr %1860, align 8, !tbaa !11
  %1862 = load ptr, ptr %19, align 8, !tbaa !5
  %1863 = load i32, ptr %26, align 4, !tbaa !9
  %1864 = sext i32 %1863 to i64
  %1865 = getelementptr inbounds %struct.doublecomplex, ptr %1862, i64 %1864
  %1866 = getelementptr inbounds %struct.doublecomplex, ptr %1865, i32 0, i32 1
  %1867 = load double, ptr %1866, align 8, !tbaa !14
  %1868 = load ptr, ptr %14, align 8, !tbaa !5
  %1869 = load i32, ptr %25, align 4, !tbaa !9
  %1870 = sext i32 %1869 to i64
  %1871 = getelementptr inbounds %struct.doublecomplex, ptr %1868, i64 %1870
  %1872 = getelementptr inbounds %struct.doublecomplex, ptr %1871, i32 0, i32 1
  %1873 = load double, ptr %1872, align 8, !tbaa !14
  %1874 = load ptr, ptr %19, align 8, !tbaa !5
  %1875 = load i32, ptr %26, align 4, !tbaa !9
  %1876 = sext i32 %1875 to i64
  %1877 = getelementptr inbounds %struct.doublecomplex, ptr %1874, i64 %1876
  %1878 = getelementptr inbounds %struct.doublecomplex, ptr %1877, i32 0, i32 0
  %1879 = load double, ptr %1878, align 8, !tbaa !11
  %1880 = fmul double %1873, %1879
  %1881 = call double @llvm.fmuladd.f64(double %1861, double %1867, double %1880)
  %1882 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1881, ptr %1882, align 8, !tbaa !14
  %1883 = load ptr, ptr %19, align 8, !tbaa !5
  %1884 = load i32, ptr %24, align 4, !tbaa !9
  %1885 = sext i32 %1884 to i64
  %1886 = getelementptr inbounds %struct.doublecomplex, ptr %1883, i64 %1885
  %1887 = getelementptr inbounds %struct.doublecomplex, ptr %1886, i32 0, i32 0
  %1888 = load double, ptr %1887, align 8, !tbaa !11
  %1889 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1890 = load double, ptr %1889, align 8, !tbaa !11
  %1891 = fsub double %1888, %1890
  %1892 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1891, ptr %1892, align 8, !tbaa !11
  %1893 = load ptr, ptr %19, align 8, !tbaa !5
  %1894 = load i32, ptr %24, align 4, !tbaa !9
  %1895 = sext i32 %1894 to i64
  %1896 = getelementptr inbounds %struct.doublecomplex, ptr %1893, i64 %1895
  %1897 = getelementptr inbounds %struct.doublecomplex, ptr %1896, i32 0, i32 1
  %1898 = load double, ptr %1897, align 8, !tbaa !14
  %1899 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %1900 = load double, ptr %1899, align 8, !tbaa !14
  %1901 = fsub double %1898, %1900
  %1902 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1901, ptr %1902, align 8, !tbaa !14
  %1903 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1904 = load double, ptr %1903, align 8, !tbaa !11
  %1905 = load ptr, ptr %19, align 8, !tbaa !5
  %1906 = load i32, ptr %23, align 4, !tbaa !9
  %1907 = sext i32 %1906 to i64
  %1908 = getelementptr inbounds %struct.doublecomplex, ptr %1905, i64 %1907
  %1909 = getelementptr inbounds %struct.doublecomplex, ptr %1908, i32 0, i32 0
  store double %1904, ptr %1909, align 8, !tbaa !11
  %1910 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1911 = load double, ptr %1910, align 8, !tbaa !14
  %1912 = load ptr, ptr %19, align 8, !tbaa !5
  %1913 = load i32, ptr %23, align 4, !tbaa !9
  %1914 = sext i32 %1913 to i64
  %1915 = getelementptr inbounds %struct.doublecomplex, ptr %1912, i64 %1914
  %1916 = getelementptr inbounds %struct.doublecomplex, ptr %1915, i32 0, i32 1
  store double %1911, ptr %1916, align 8, !tbaa !14
  br label %2042

1917:                                             ; preds = %1802
  %1918 = load i32, ptr %40, align 4, !tbaa !9
  %1919 = add nsw i32 %1918, 1
  %1920 = load i32, ptr %41, align 4, !tbaa !9
  %1921 = load i32, ptr %21, align 4, !tbaa !9
  %1922 = mul nsw i32 %1920, %1921
  %1923 = add nsw i32 %1919, %1922
  store i32 %1923, ptr %23, align 4, !tbaa !9
  %1924 = load ptr, ptr %19, align 8, !tbaa !5
  %1925 = load i32, ptr %23, align 4, !tbaa !9
  %1926 = sext i32 %1925 to i64
  %1927 = getelementptr inbounds %struct.doublecomplex, ptr %1924, i64 %1926
  %1928 = getelementptr inbounds %struct.doublecomplex, ptr %1927, i32 0, i32 0
  %1929 = load double, ptr %1928, align 8, !tbaa !11
  %1930 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1929, ptr %1930, align 8, !tbaa !11
  %1931 = load ptr, ptr %19, align 8, !tbaa !5
  %1932 = load i32, ptr %23, align 4, !tbaa !9
  %1933 = sext i32 %1932 to i64
  %1934 = getelementptr inbounds %struct.doublecomplex, ptr %1931, i64 %1933
  %1935 = getelementptr inbounds %struct.doublecomplex, ptr %1934, i32 0, i32 1
  %1936 = load double, ptr %1935, align 8, !tbaa !14
  %1937 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1936, ptr %1937, align 8, !tbaa !14
  %1938 = load i32, ptr %40, align 4, !tbaa !9
  %1939 = add nsw i32 %1938, 1
  %1940 = load i32, ptr %41, align 4, !tbaa !9
  %1941 = load i32, ptr %21, align 4, !tbaa !9
  %1942 = mul nsw i32 %1940, %1941
  %1943 = add nsw i32 %1939, %1942
  store i32 %1943, ptr %23, align 4, !tbaa !9
  %1944 = load i32, ptr %40, align 4, !tbaa !9
  %1945 = load i32, ptr %41, align 4, !tbaa !9
  %1946 = load i32, ptr %21, align 4, !tbaa !9
  %1947 = mul nsw i32 %1945, %1946
  %1948 = add nsw i32 %1944, %1947
  store i32 %1948, ptr %24, align 4, !tbaa !9
  %1949 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %1949, ptr %25, align 4, !tbaa !9
  %1950 = load ptr, ptr %14, align 8, !tbaa !5
  %1951 = load i32, ptr %25, align 4, !tbaa !9
  %1952 = sext i32 %1951 to i64
  %1953 = getelementptr inbounds %struct.doublecomplex, ptr %1950, i64 %1952
  %1954 = getelementptr inbounds %struct.doublecomplex, ptr %1953, i32 0, i32 0
  %1955 = load double, ptr %1954, align 8, !tbaa !11
  %1956 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1957 = load double, ptr %1956, align 8, !tbaa !11
  %1958 = load ptr, ptr %14, align 8, !tbaa !5
  %1959 = load i32, ptr %25, align 4, !tbaa !9
  %1960 = sext i32 %1959 to i64
  %1961 = getelementptr inbounds %struct.doublecomplex, ptr %1958, i64 %1960
  %1962 = getelementptr inbounds %struct.doublecomplex, ptr %1961, i32 0, i32 1
  %1963 = load double, ptr %1962, align 8, !tbaa !14
  %1964 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1965 = load double, ptr %1964, align 8, !tbaa !14
  %1966 = fmul double %1963, %1965
  %1967 = fneg double %1966
  %1968 = call double @llvm.fmuladd.f64(double %1955, double %1957, double %1967)
  %1969 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1968, ptr %1969, align 8, !tbaa !11
  %1970 = load ptr, ptr %14, align 8, !tbaa !5
  %1971 = load i32, ptr %25, align 4, !tbaa !9
  %1972 = sext i32 %1971 to i64
  %1973 = getelementptr inbounds %struct.doublecomplex, ptr %1970, i64 %1972
  %1974 = getelementptr inbounds %struct.doublecomplex, ptr %1973, i32 0, i32 0
  %1975 = load double, ptr %1974, align 8, !tbaa !11
  %1976 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1977 = load double, ptr %1976, align 8, !tbaa !14
  %1978 = load ptr, ptr %14, align 8, !tbaa !5
  %1979 = load i32, ptr %25, align 4, !tbaa !9
  %1980 = sext i32 %1979 to i64
  %1981 = getelementptr inbounds %struct.doublecomplex, ptr %1978, i64 %1980
  %1982 = getelementptr inbounds %struct.doublecomplex, ptr %1981, i32 0, i32 1
  %1983 = load double, ptr %1982, align 8, !tbaa !14
  %1984 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1985 = load double, ptr %1984, align 8, !tbaa !11
  %1986 = fmul double %1983, %1985
  %1987 = call double @llvm.fmuladd.f64(double %1975, double %1977, double %1986)
  %1988 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1987, ptr %1988, align 8, !tbaa !14
  %1989 = load ptr, ptr %19, align 8, !tbaa !5
  %1990 = load i32, ptr %24, align 4, !tbaa !9
  %1991 = sext i32 %1990 to i64
  %1992 = getelementptr inbounds %struct.doublecomplex, ptr %1989, i64 %1991
  %1993 = getelementptr inbounds %struct.doublecomplex, ptr %1992, i32 0, i32 0
  %1994 = load double, ptr %1993, align 8, !tbaa !11
  %1995 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1996 = load double, ptr %1995, align 8, !tbaa !11
  %1997 = fsub double %1994, %1996
  %1998 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1997, ptr %1998, align 8, !tbaa !11
  %1999 = load ptr, ptr %19, align 8, !tbaa !5
  %2000 = load i32, ptr %24, align 4, !tbaa !9
  %2001 = sext i32 %2000 to i64
  %2002 = getelementptr inbounds %struct.doublecomplex, ptr %1999, i64 %2001
  %2003 = getelementptr inbounds %struct.doublecomplex, ptr %2002, i32 0, i32 1
  %2004 = load double, ptr %2003, align 8, !tbaa !14
  %2005 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %2006 = load double, ptr %2005, align 8, !tbaa !14
  %2007 = fsub double %2004, %2006
  %2008 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %2007, ptr %2008, align 8, !tbaa !14
  %2009 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2010 = load double, ptr %2009, align 8, !tbaa !11
  %2011 = load ptr, ptr %19, align 8, !tbaa !5
  %2012 = load i32, ptr %23, align 4, !tbaa !9
  %2013 = sext i32 %2012 to i64
  %2014 = getelementptr inbounds %struct.doublecomplex, ptr %2011, i64 %2013
  %2015 = getelementptr inbounds %struct.doublecomplex, ptr %2014, i32 0, i32 0
  store double %2010, ptr %2015, align 8, !tbaa !11
  %2016 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2017 = load double, ptr %2016, align 8, !tbaa !14
  %2018 = load ptr, ptr %19, align 8, !tbaa !5
  %2019 = load i32, ptr %23, align 4, !tbaa !9
  %2020 = sext i32 %2019 to i64
  %2021 = getelementptr inbounds %struct.doublecomplex, ptr %2018, i64 %2020
  %2022 = getelementptr inbounds %struct.doublecomplex, ptr %2021, i32 0, i32 1
  store double %2017, ptr %2022, align 8, !tbaa !14
  %2023 = load i32, ptr %40, align 4, !tbaa !9
  %2024 = load i32, ptr %41, align 4, !tbaa !9
  %2025 = load i32, ptr %21, align 4, !tbaa !9
  %2026 = mul nsw i32 %2024, %2025
  %2027 = add nsw i32 %2023, %2026
  store i32 %2027, ptr %23, align 4, !tbaa !9
  %2028 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2029 = load double, ptr %2028, align 8, !tbaa !11
  %2030 = load ptr, ptr %19, align 8, !tbaa !5
  %2031 = load i32, ptr %23, align 4, !tbaa !9
  %2032 = sext i32 %2031 to i64
  %2033 = getelementptr inbounds %struct.doublecomplex, ptr %2030, i64 %2032
  %2034 = getelementptr inbounds %struct.doublecomplex, ptr %2033, i32 0, i32 0
  store double %2029, ptr %2034, align 8, !tbaa !11
  %2035 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2036 = load double, ptr %2035, align 8, !tbaa !14
  %2037 = load ptr, ptr %19, align 8, !tbaa !5
  %2038 = load i32, ptr %23, align 4, !tbaa !9
  %2039 = sext i32 %2038 to i64
  %2040 = getelementptr inbounds %struct.doublecomplex, ptr %2037, i64 %2039
  %2041 = getelementptr inbounds %struct.doublecomplex, ptr %2040, i32 0, i32 1
  store double %2036, ptr %2041, align 8, !tbaa !14
  br label %2042

2042:                                             ; preds = %1917, %1810
  br label %2043

2043:                                             ; preds = %2042
  %2044 = load i32, ptr %40, align 4, !tbaa !9
  %2045 = add nsw i32 %2044, -1
  store i32 %2045, ptr %40, align 4, !tbaa !9
  br label %1799, !llvm.loop !22

2046:                                             ; preds = %1799
  %2047 = load i32, ptr %41, align 4, !tbaa !9
  %2048 = load ptr, ptr %13, align 8, !tbaa !5
  %2049 = load i32, ptr %2048, align 4, !tbaa !9
  %2050 = icmp slt i32 %2047, %2049
  br i1 %2050, label %2051, label %2054

2051:                                             ; preds = %2046
  %2052 = load i32, ptr %41, align 4, !tbaa !9
  %2053 = add nsw i32 %2052, 1
  store i32 %2053, ptr %41, align 4, !tbaa !9
  br label %1435

2054:                                             ; preds = %2046
  br label %2678

2055:                                             ; preds = %1430
  %2056 = load ptr, ptr %13, align 8, !tbaa !5
  %2057 = load i32, ptr %2056, align 4, !tbaa !9
  store i32 %2057, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %2058

2058:                                             ; preds = %2674, %2055
  %2059 = load i32, ptr %41, align 4, !tbaa !9
  %2060 = load i32, ptr %23, align 4, !tbaa !9
  %2061 = icmp sle i32 %2059, %2060
  br i1 %2061, label %2062, label %2677

2062:                                             ; preds = %2058
  %2063 = load i32, ptr %41, align 4, !tbaa !9
  %2064 = load i32, ptr %21, align 4, !tbaa !9
  %2065 = mul nsw i32 %2063, %2064
  %2066 = add nsw i32 %2065, 1
  store i32 %2066, ptr %24, align 4, !tbaa !9
  %2067 = load ptr, ptr %19, align 8, !tbaa !5
  %2068 = load i32, ptr %41, align 4, !tbaa !9
  %2069 = load i32, ptr %21, align 4, !tbaa !9
  %2070 = mul nsw i32 %2068, %2069
  %2071 = add nsw i32 %2070, 1
  %2072 = sext i32 %2071 to i64
  %2073 = getelementptr inbounds %struct.doublecomplex, ptr %2067, i64 %2072
  %2074 = call { double, double } @Cd(ptr noundef %2073)
  %2075 = extractvalue { double, double } %2074, 0
  %2076 = extractvalue { double, double } %2074, 1
  %2077 = load ptr, ptr %15, align 8, !tbaa !5
  %2078 = getelementptr inbounds %struct.doublecomplex, ptr %2077, i64 1
  %2079 = call { double, double } @Cd(ptr noundef %2078)
  %2080 = extractvalue { double, double } %2079, 0
  %2081 = extractvalue { double, double } %2079, 1
  %2082 = call { double, double } @__divdc3(double noundef %2075, double noundef %2076, double noundef %2080, double noundef %2081) #4
  %2083 = extractvalue { double, double } %2082, 0
  %2084 = extractvalue { double, double } %2082, 1
  %2085 = call ptr @_pCd(ptr noundef %31)
  %2086 = getelementptr inbounds { double, double }, ptr %2085, i32 0, i32 0
  %2087 = getelementptr inbounds { double, double }, ptr %2085, i32 0, i32 1
  store double %2083, ptr %2086, align 8
  store double %2084, ptr %2087, align 8
  %2088 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2089 = load double, ptr %2088, align 8, !tbaa !11
  %2090 = load ptr, ptr %19, align 8, !tbaa !5
  %2091 = load i32, ptr %24, align 4, !tbaa !9
  %2092 = sext i32 %2091 to i64
  %2093 = getelementptr inbounds %struct.doublecomplex, ptr %2090, i64 %2092
  %2094 = getelementptr inbounds %struct.doublecomplex, ptr %2093, i32 0, i32 0
  store double %2089, ptr %2094, align 8, !tbaa !11
  %2095 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2096 = load double, ptr %2095, align 8, !tbaa !14
  %2097 = load ptr, ptr %19, align 8, !tbaa !5
  %2098 = load i32, ptr %24, align 4, !tbaa !9
  %2099 = sext i32 %2098 to i64
  %2100 = getelementptr inbounds %struct.doublecomplex, ptr %2097, i64 %2099
  %2101 = getelementptr inbounds %struct.doublecomplex, ptr %2100, i32 0, i32 1
  store double %2096, ptr %2101, align 8, !tbaa !14
  %2102 = load ptr, ptr %12, align 8, !tbaa !5
  %2103 = load i32, ptr %2102, align 4, !tbaa !9
  %2104 = icmp sgt i32 %2103, 1
  br i1 %2104, label %2105, label %2213

2105:                                             ; preds = %2062
  %2106 = load i32, ptr %41, align 4, !tbaa !9
  %2107 = load i32, ptr %21, align 4, !tbaa !9
  %2108 = mul nsw i32 %2106, %2107
  %2109 = add nsw i32 %2108, 2
  store i32 %2109, ptr %24, align 4, !tbaa !9
  %2110 = load i32, ptr %41, align 4, !tbaa !9
  %2111 = load i32, ptr %21, align 4, !tbaa !9
  %2112 = mul nsw i32 %2110, %2111
  %2113 = add nsw i32 %2112, 2
  store i32 %2113, ptr %25, align 4, !tbaa !9
  %2114 = load i32, ptr %41, align 4, !tbaa !9
  %2115 = load i32, ptr %21, align 4, !tbaa !9
  %2116 = mul nsw i32 %2114, %2115
  %2117 = add nsw i32 %2116, 1
  store i32 %2117, ptr %26, align 4, !tbaa !9
  %2118 = load ptr, ptr %16, align 8, !tbaa !5
  %2119 = getelementptr inbounds %struct.doublecomplex, ptr %2118, i64 1
  %2120 = getelementptr inbounds %struct.doublecomplex, ptr %2119, i32 0, i32 0
  %2121 = load double, ptr %2120, align 8, !tbaa !11
  %2122 = load ptr, ptr %19, align 8, !tbaa !5
  %2123 = load i32, ptr %26, align 4, !tbaa !9
  %2124 = sext i32 %2123 to i64
  %2125 = getelementptr inbounds %struct.doublecomplex, ptr %2122, i64 %2124
  %2126 = getelementptr inbounds %struct.doublecomplex, ptr %2125, i32 0, i32 0
  %2127 = load double, ptr %2126, align 8, !tbaa !11
  %2128 = load ptr, ptr %16, align 8, !tbaa !5
  %2129 = getelementptr inbounds %struct.doublecomplex, ptr %2128, i64 1
  %2130 = getelementptr inbounds %struct.doublecomplex, ptr %2129, i32 0, i32 1
  %2131 = load double, ptr %2130, align 8, !tbaa !14
  %2132 = load ptr, ptr %19, align 8, !tbaa !5
  %2133 = load i32, ptr %26, align 4, !tbaa !9
  %2134 = sext i32 %2133 to i64
  %2135 = getelementptr inbounds %struct.doublecomplex, ptr %2132, i64 %2134
  %2136 = getelementptr inbounds %struct.doublecomplex, ptr %2135, i32 0, i32 1
  %2137 = load double, ptr %2136, align 8, !tbaa !14
  %2138 = fmul double %2131, %2137
  %2139 = fneg double %2138
  %2140 = call double @llvm.fmuladd.f64(double %2121, double %2127, double %2139)
  %2141 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %2140, ptr %2141, align 8, !tbaa !11
  %2142 = load ptr, ptr %16, align 8, !tbaa !5
  %2143 = getelementptr inbounds %struct.doublecomplex, ptr %2142, i64 1
  %2144 = getelementptr inbounds %struct.doublecomplex, ptr %2143, i32 0, i32 0
  %2145 = load double, ptr %2144, align 8, !tbaa !11
  %2146 = load ptr, ptr %19, align 8, !tbaa !5
  %2147 = load i32, ptr %26, align 4, !tbaa !9
  %2148 = sext i32 %2147 to i64
  %2149 = getelementptr inbounds %struct.doublecomplex, ptr %2146, i64 %2148
  %2150 = getelementptr inbounds %struct.doublecomplex, ptr %2149, i32 0, i32 1
  %2151 = load double, ptr %2150, align 8, !tbaa !14
  %2152 = load ptr, ptr %16, align 8, !tbaa !5
  %2153 = getelementptr inbounds %struct.doublecomplex, ptr %2152, i64 1
  %2154 = getelementptr inbounds %struct.doublecomplex, ptr %2153, i32 0, i32 1
  %2155 = load double, ptr %2154, align 8, !tbaa !14
  %2156 = load ptr, ptr %19, align 8, !tbaa !5
  %2157 = load i32, ptr %26, align 4, !tbaa !9
  %2158 = sext i32 %2157 to i64
  %2159 = getelementptr inbounds %struct.doublecomplex, ptr %2156, i64 %2158
  %2160 = getelementptr inbounds %struct.doublecomplex, ptr %2159, i32 0, i32 0
  %2161 = load double, ptr %2160, align 8, !tbaa !11
  %2162 = fmul double %2155, %2161
  %2163 = call double @llvm.fmuladd.f64(double %2145, double %2151, double %2162)
  %2164 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %2163, ptr %2164, align 8, !tbaa !14
  %2165 = load ptr, ptr %19, align 8, !tbaa !5
  %2166 = load i32, ptr %25, align 4, !tbaa !9
  %2167 = sext i32 %2166 to i64
  %2168 = getelementptr inbounds %struct.doublecomplex, ptr %2165, i64 %2167
  %2169 = getelementptr inbounds %struct.doublecomplex, ptr %2168, i32 0, i32 0
  %2170 = load double, ptr %2169, align 8, !tbaa !11
  %2171 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %2172 = load double, ptr %2171, align 8, !tbaa !11
  %2173 = fsub double %2170, %2172
  %2174 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %2173, ptr %2174, align 8, !tbaa !11
  %2175 = load ptr, ptr %19, align 8, !tbaa !5
  %2176 = load i32, ptr %25, align 4, !tbaa !9
  %2177 = sext i32 %2176 to i64
  %2178 = getelementptr inbounds %struct.doublecomplex, ptr %2175, i64 %2177
  %2179 = getelementptr inbounds %struct.doublecomplex, ptr %2178, i32 0, i32 1
  %2180 = load double, ptr %2179, align 8, !tbaa !14
  %2181 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %2182 = load double, ptr %2181, align 8, !tbaa !14
  %2183 = fsub double %2180, %2182
  %2184 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %2183, ptr %2184, align 8, !tbaa !14
  %2185 = call { double, double } @Cd(ptr noundef %32)
  %2186 = extractvalue { double, double } %2185, 0
  %2187 = extractvalue { double, double } %2185, 1
  %2188 = load ptr, ptr %15, align 8, !tbaa !5
  %2189 = getelementptr inbounds %struct.doublecomplex, ptr %2188, i64 2
  %2190 = call { double, double } @Cd(ptr noundef %2189)
  %2191 = extractvalue { double, double } %2190, 0
  %2192 = extractvalue { double, double } %2190, 1
  %2193 = call { double, double } @__divdc3(double noundef %2186, double noundef %2187, double noundef %2191, double noundef %2192) #4
  %2194 = extractvalue { double, double } %2193, 0
  %2195 = extractvalue { double, double } %2193, 1
  %2196 = call ptr @_pCd(ptr noundef %31)
  %2197 = getelementptr inbounds { double, double }, ptr %2196, i32 0, i32 0
  %2198 = getelementptr inbounds { double, double }, ptr %2196, i32 0, i32 1
  store double %2194, ptr %2197, align 8
  store double %2195, ptr %2198, align 8
  %2199 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2200 = load double, ptr %2199, align 8, !tbaa !11
  %2201 = load ptr, ptr %19, align 8, !tbaa !5
  %2202 = load i32, ptr %24, align 4, !tbaa !9
  %2203 = sext i32 %2202 to i64
  %2204 = getelementptr inbounds %struct.doublecomplex, ptr %2201, i64 %2203
  %2205 = getelementptr inbounds %struct.doublecomplex, ptr %2204, i32 0, i32 0
  store double %2200, ptr %2205, align 8, !tbaa !11
  %2206 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2207 = load double, ptr %2206, align 8, !tbaa !14
  %2208 = load ptr, ptr %19, align 8, !tbaa !5
  %2209 = load i32, ptr %24, align 4, !tbaa !9
  %2210 = sext i32 %2209 to i64
  %2211 = getelementptr inbounds %struct.doublecomplex, ptr %2208, i64 %2210
  %2212 = getelementptr inbounds %struct.doublecomplex, ptr %2211, i32 0, i32 1
  store double %2207, ptr %2212, align 8, !tbaa !14
  br label %2213

2213:                                             ; preds = %2105, %2062
  %2214 = load ptr, ptr %12, align 8, !tbaa !5
  %2215 = load i32, ptr %2214, align 4, !tbaa !9
  store i32 %2215, ptr %24, align 4, !tbaa !9
  store i32 3, ptr %40, align 4, !tbaa !9
  br label %2216

2216:                                             ; preds = %2419, %2213
  %2217 = load i32, ptr %40, align 4, !tbaa !9
  %2218 = load i32, ptr %24, align 4, !tbaa !9
  %2219 = icmp sle i32 %2217, %2218
  br i1 %2219, label %2220, label %2422

2220:                                             ; preds = %2216
  %2221 = load i32, ptr %40, align 4, !tbaa !9
  %2222 = load i32, ptr %41, align 4, !tbaa !9
  %2223 = load i32, ptr %21, align 4, !tbaa !9
  %2224 = mul nsw i32 %2222, %2223
  %2225 = add nsw i32 %2221, %2224
  store i32 %2225, ptr %25, align 4, !tbaa !9
  %2226 = load i32, ptr %40, align 4, !tbaa !9
  %2227 = load i32, ptr %41, align 4, !tbaa !9
  %2228 = load i32, ptr %21, align 4, !tbaa !9
  %2229 = mul nsw i32 %2227, %2228
  %2230 = add nsw i32 %2226, %2229
  store i32 %2230, ptr %26, align 4, !tbaa !9
  %2231 = load i32, ptr %40, align 4, !tbaa !9
  %2232 = sub nsw i32 %2231, 1
  store i32 %2232, ptr %27, align 4, !tbaa !9
  %2233 = load i32, ptr %40, align 4, !tbaa !9
  %2234 = sub nsw i32 %2233, 1
  %2235 = load i32, ptr %41, align 4, !tbaa !9
  %2236 = load i32, ptr %21, align 4, !tbaa !9
  %2237 = mul nsw i32 %2235, %2236
  %2238 = add nsw i32 %2234, %2237
  store i32 %2238, ptr %28, align 4, !tbaa !9
  %2239 = load ptr, ptr %16, align 8, !tbaa !5
  %2240 = load i32, ptr %27, align 4, !tbaa !9
  %2241 = sext i32 %2240 to i64
  %2242 = getelementptr inbounds %struct.doublecomplex, ptr %2239, i64 %2241
  %2243 = getelementptr inbounds %struct.doublecomplex, ptr %2242, i32 0, i32 0
  %2244 = load double, ptr %2243, align 8, !tbaa !11
  %2245 = load ptr, ptr %19, align 8, !tbaa !5
  %2246 = load i32, ptr %28, align 4, !tbaa !9
  %2247 = sext i32 %2246 to i64
  %2248 = getelementptr inbounds %struct.doublecomplex, ptr %2245, i64 %2247
  %2249 = getelementptr inbounds %struct.doublecomplex, ptr %2248, i32 0, i32 0
  %2250 = load double, ptr %2249, align 8, !tbaa !11
  %2251 = load ptr, ptr %16, align 8, !tbaa !5
  %2252 = load i32, ptr %27, align 4, !tbaa !9
  %2253 = sext i32 %2252 to i64
  %2254 = getelementptr inbounds %struct.doublecomplex, ptr %2251, i64 %2253
  %2255 = getelementptr inbounds %struct.doublecomplex, ptr %2254, i32 0, i32 1
  %2256 = load double, ptr %2255, align 8, !tbaa !14
  %2257 = load ptr, ptr %19, align 8, !tbaa !5
  %2258 = load i32, ptr %28, align 4, !tbaa !9
  %2259 = sext i32 %2258 to i64
  %2260 = getelementptr inbounds %struct.doublecomplex, ptr %2257, i64 %2259
  %2261 = getelementptr inbounds %struct.doublecomplex, ptr %2260, i32 0, i32 1
  %2262 = load double, ptr %2261, align 8, !tbaa !14
  %2263 = fmul double %2256, %2262
  %2264 = fneg double %2263
  %2265 = call double @llvm.fmuladd.f64(double %2244, double %2250, double %2264)
  %2266 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %2265, ptr %2266, align 8, !tbaa !11
  %2267 = load ptr, ptr %16, align 8, !tbaa !5
  %2268 = load i32, ptr %27, align 4, !tbaa !9
  %2269 = sext i32 %2268 to i64
  %2270 = getelementptr inbounds %struct.doublecomplex, ptr %2267, i64 %2269
  %2271 = getelementptr inbounds %struct.doublecomplex, ptr %2270, i32 0, i32 0
  %2272 = load double, ptr %2271, align 8, !tbaa !11
  %2273 = load ptr, ptr %19, align 8, !tbaa !5
  %2274 = load i32, ptr %28, align 4, !tbaa !9
  %2275 = sext i32 %2274 to i64
  %2276 = getelementptr inbounds %struct.doublecomplex, ptr %2273, i64 %2275
  %2277 = getelementptr inbounds %struct.doublecomplex, ptr %2276, i32 0, i32 1
  %2278 = load double, ptr %2277, align 8, !tbaa !14
  %2279 = load ptr, ptr %16, align 8, !tbaa !5
  %2280 = load i32, ptr %27, align 4, !tbaa !9
  %2281 = sext i32 %2280 to i64
  %2282 = getelementptr inbounds %struct.doublecomplex, ptr %2279, i64 %2281
  %2283 = getelementptr inbounds %struct.doublecomplex, ptr %2282, i32 0, i32 1
  %2284 = load double, ptr %2283, align 8, !tbaa !14
  %2285 = load ptr, ptr %19, align 8, !tbaa !5
  %2286 = load i32, ptr %28, align 4, !tbaa !9
  %2287 = sext i32 %2286 to i64
  %2288 = getelementptr inbounds %struct.doublecomplex, ptr %2285, i64 %2287
  %2289 = getelementptr inbounds %struct.doublecomplex, ptr %2288, i32 0, i32 0
  %2290 = load double, ptr %2289, align 8, !tbaa !11
  %2291 = fmul double %2284, %2290
  %2292 = call double @llvm.fmuladd.f64(double %2272, double %2278, double %2291)
  %2293 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %2292, ptr %2293, align 8, !tbaa !14
  %2294 = load ptr, ptr %19, align 8, !tbaa !5
  %2295 = load i32, ptr %26, align 4, !tbaa !9
  %2296 = sext i32 %2295 to i64
  %2297 = getelementptr inbounds %struct.doublecomplex, ptr %2294, i64 %2296
  %2298 = getelementptr inbounds %struct.doublecomplex, ptr %2297, i32 0, i32 0
  %2299 = load double, ptr %2298, align 8, !tbaa !11
  %2300 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %2301 = load double, ptr %2300, align 8, !tbaa !11
  %2302 = fsub double %2299, %2301
  %2303 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %2302, ptr %2303, align 8, !tbaa !11
  %2304 = load ptr, ptr %19, align 8, !tbaa !5
  %2305 = load i32, ptr %26, align 4, !tbaa !9
  %2306 = sext i32 %2305 to i64
  %2307 = getelementptr inbounds %struct.doublecomplex, ptr %2304, i64 %2306
  %2308 = getelementptr inbounds %struct.doublecomplex, ptr %2307, i32 0, i32 1
  %2309 = load double, ptr %2308, align 8, !tbaa !14
  %2310 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %2311 = load double, ptr %2310, align 8, !tbaa !14
  %2312 = fsub double %2309, %2311
  %2313 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %2312, ptr %2313, align 8, !tbaa !14
  %2314 = load i32, ptr %40, align 4, !tbaa !9
  %2315 = sub nsw i32 %2314, 2
  store i32 %2315, ptr %29, align 4, !tbaa !9
  %2316 = load i32, ptr %40, align 4, !tbaa !9
  %2317 = sub nsw i32 %2316, 2
  %2318 = load i32, ptr %41, align 4, !tbaa !9
  %2319 = load i32, ptr %21, align 4, !tbaa !9
  %2320 = mul nsw i32 %2318, %2319
  %2321 = add nsw i32 %2317, %2320
  store i32 %2321, ptr %30, align 4, !tbaa !9
  %2322 = load ptr, ptr %17, align 8, !tbaa !5
  %2323 = load i32, ptr %29, align 4, !tbaa !9
  %2324 = sext i32 %2323 to i64
  %2325 = getelementptr inbounds %struct.doublecomplex, ptr %2322, i64 %2324
  %2326 = getelementptr inbounds %struct.doublecomplex, ptr %2325, i32 0, i32 0
  %2327 = load double, ptr %2326, align 8, !tbaa !11
  %2328 = load ptr, ptr %19, align 8, !tbaa !5
  %2329 = load i32, ptr %30, align 4, !tbaa !9
  %2330 = sext i32 %2329 to i64
  %2331 = getelementptr inbounds %struct.doublecomplex, ptr %2328, i64 %2330
  %2332 = getelementptr inbounds %struct.doublecomplex, ptr %2331, i32 0, i32 0
  %2333 = load double, ptr %2332, align 8, !tbaa !11
  %2334 = load ptr, ptr %17, align 8, !tbaa !5
  %2335 = load i32, ptr %29, align 4, !tbaa !9
  %2336 = sext i32 %2335 to i64
  %2337 = getelementptr inbounds %struct.doublecomplex, ptr %2334, i64 %2336
  %2338 = getelementptr inbounds %struct.doublecomplex, ptr %2337, i32 0, i32 1
  %2339 = load double, ptr %2338, align 8, !tbaa !14
  %2340 = load ptr, ptr %19, align 8, !tbaa !5
  %2341 = load i32, ptr %30, align 4, !tbaa !9
  %2342 = sext i32 %2341 to i64
  %2343 = getelementptr inbounds %struct.doublecomplex, ptr %2340, i64 %2342
  %2344 = getelementptr inbounds %struct.doublecomplex, ptr %2343, i32 0, i32 1
  %2345 = load double, ptr %2344, align 8, !tbaa !14
  %2346 = fmul double %2339, %2345
  %2347 = fneg double %2346
  %2348 = call double @llvm.fmuladd.f64(double %2327, double %2333, double %2347)
  %2349 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %2348, ptr %2349, align 8, !tbaa !11
  %2350 = load ptr, ptr %17, align 8, !tbaa !5
  %2351 = load i32, ptr %29, align 4, !tbaa !9
  %2352 = sext i32 %2351 to i64
  %2353 = getelementptr inbounds %struct.doublecomplex, ptr %2350, i64 %2352
  %2354 = getelementptr inbounds %struct.doublecomplex, ptr %2353, i32 0, i32 0
  %2355 = load double, ptr %2354, align 8, !tbaa !11
  %2356 = load ptr, ptr %19, align 8, !tbaa !5
  %2357 = load i32, ptr %30, align 4, !tbaa !9
  %2358 = sext i32 %2357 to i64
  %2359 = getelementptr inbounds %struct.doublecomplex, ptr %2356, i64 %2358
  %2360 = getelementptr inbounds %struct.doublecomplex, ptr %2359, i32 0, i32 1
  %2361 = load double, ptr %2360, align 8, !tbaa !14
  %2362 = load ptr, ptr %17, align 8, !tbaa !5
  %2363 = load i32, ptr %29, align 4, !tbaa !9
  %2364 = sext i32 %2363 to i64
  %2365 = getelementptr inbounds %struct.doublecomplex, ptr %2362, i64 %2364
  %2366 = getelementptr inbounds %struct.doublecomplex, ptr %2365, i32 0, i32 1
  %2367 = load double, ptr %2366, align 8, !tbaa !14
  %2368 = load ptr, ptr %19, align 8, !tbaa !5
  %2369 = load i32, ptr %30, align 4, !tbaa !9
  %2370 = sext i32 %2369 to i64
  %2371 = getelementptr inbounds %struct.doublecomplex, ptr %2368, i64 %2370
  %2372 = getelementptr inbounds %struct.doublecomplex, ptr %2371, i32 0, i32 0
  %2373 = load double, ptr %2372, align 8, !tbaa !11
  %2374 = fmul double %2367, %2373
  %2375 = call double @llvm.fmuladd.f64(double %2355, double %2361, double %2374)
  %2376 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %2375, ptr %2376, align 8, !tbaa !14
  %2377 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %2378 = load double, ptr %2377, align 8, !tbaa !11
  %2379 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %2380 = load double, ptr %2379, align 8, !tbaa !11
  %2381 = fsub double %2378, %2380
  %2382 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %2381, ptr %2382, align 8, !tbaa !11
  %2383 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %2384 = load double, ptr %2383, align 8, !tbaa !14
  %2385 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %2386 = load double, ptr %2385, align 8, !tbaa !14
  %2387 = fsub double %2384, %2386
  %2388 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %2387, ptr %2388, align 8, !tbaa !14
  %2389 = call { double, double } @Cd(ptr noundef %32)
  %2390 = extractvalue { double, double } %2389, 0
  %2391 = extractvalue { double, double } %2389, 1
  %2392 = load ptr, ptr %15, align 8, !tbaa !5
  %2393 = load i32, ptr %40, align 4, !tbaa !9
  %2394 = sext i32 %2393 to i64
  %2395 = getelementptr inbounds %struct.doublecomplex, ptr %2392, i64 %2394
  %2396 = call { double, double } @Cd(ptr noundef %2395)
  %2397 = extractvalue { double, double } %2396, 0
  %2398 = extractvalue { double, double } %2396, 1
  %2399 = call { double, double } @__divdc3(double noundef %2390, double noundef %2391, double noundef %2397, double noundef %2398) #4
  %2400 = extractvalue { double, double } %2399, 0
  %2401 = extractvalue { double, double } %2399, 1
  %2402 = call ptr @_pCd(ptr noundef %31)
  %2403 = getelementptr inbounds { double, double }, ptr %2402, i32 0, i32 0
  %2404 = getelementptr inbounds { double, double }, ptr %2402, i32 0, i32 1
  store double %2400, ptr %2403, align 8
  store double %2401, ptr %2404, align 8
  %2405 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2406 = load double, ptr %2405, align 8, !tbaa !11
  %2407 = load ptr, ptr %19, align 8, !tbaa !5
  %2408 = load i32, ptr %25, align 4, !tbaa !9
  %2409 = sext i32 %2408 to i64
  %2410 = getelementptr inbounds %struct.doublecomplex, ptr %2407, i64 %2409
  %2411 = getelementptr inbounds %struct.doublecomplex, ptr %2410, i32 0, i32 0
  store double %2406, ptr %2411, align 8, !tbaa !11
  %2412 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2413 = load double, ptr %2412, align 8, !tbaa !14
  %2414 = load ptr, ptr %19, align 8, !tbaa !5
  %2415 = load i32, ptr %25, align 4, !tbaa !9
  %2416 = sext i32 %2415 to i64
  %2417 = getelementptr inbounds %struct.doublecomplex, ptr %2414, i64 %2416
  %2418 = getelementptr inbounds %struct.doublecomplex, ptr %2417, i32 0, i32 1
  store double %2413, ptr %2418, align 8, !tbaa !14
  br label %2419

2419:                                             ; preds = %2220
  %2420 = load i32, ptr %40, align 4, !tbaa !9
  %2421 = add nsw i32 %2420, 1
  store i32 %2421, ptr %40, align 4, !tbaa !9
  br label %2216, !llvm.loop !23

2422:                                             ; preds = %2216
  %2423 = load ptr, ptr %12, align 8, !tbaa !5
  %2424 = load i32, ptr %2423, align 4, !tbaa !9
  %2425 = sub nsw i32 %2424, 1
  store i32 %2425, ptr %40, align 4, !tbaa !9
  br label %2426

2426:                                             ; preds = %2670, %2422
  %2427 = load i32, ptr %40, align 4, !tbaa !9
  %2428 = icmp sge i32 %2427, 1
  br i1 %2428, label %2429, label %2673

2429:                                             ; preds = %2426
  %2430 = load ptr, ptr %18, align 8, !tbaa !5
  %2431 = load i32, ptr %40, align 4, !tbaa !9
  %2432 = sext i32 %2431 to i64
  %2433 = getelementptr inbounds i32, ptr %2430, i64 %2432
  %2434 = load i32, ptr %2433, align 4, !tbaa !9
  %2435 = load i32, ptr %40, align 4, !tbaa !9
  %2436 = icmp eq i32 %2434, %2435
  br i1 %2436, label %2437, label %2544

2437:                                             ; preds = %2429
  %2438 = load i32, ptr %40, align 4, !tbaa !9
  %2439 = load i32, ptr %41, align 4, !tbaa !9
  %2440 = load i32, ptr %21, align 4, !tbaa !9
  %2441 = mul nsw i32 %2439, %2440
  %2442 = add nsw i32 %2438, %2441
  store i32 %2442, ptr %24, align 4, !tbaa !9
  %2443 = load i32, ptr %40, align 4, !tbaa !9
  %2444 = load i32, ptr %41, align 4, !tbaa !9
  %2445 = load i32, ptr %21, align 4, !tbaa !9
  %2446 = mul nsw i32 %2444, %2445
  %2447 = add nsw i32 %2443, %2446
  store i32 %2447, ptr %25, align 4, !tbaa !9
  %2448 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %2448, ptr %26, align 4, !tbaa !9
  %2449 = load i32, ptr %40, align 4, !tbaa !9
  %2450 = add nsw i32 %2449, 1
  %2451 = load i32, ptr %41, align 4, !tbaa !9
  %2452 = load i32, ptr %21, align 4, !tbaa !9
  %2453 = mul nsw i32 %2451, %2452
  %2454 = add nsw i32 %2450, %2453
  store i32 %2454, ptr %27, align 4, !tbaa !9
  %2455 = load ptr, ptr %14, align 8, !tbaa !5
  %2456 = load i32, ptr %26, align 4, !tbaa !9
  %2457 = sext i32 %2456 to i64
  %2458 = getelementptr inbounds %struct.doublecomplex, ptr %2455, i64 %2457
  %2459 = getelementptr inbounds %struct.doublecomplex, ptr %2458, i32 0, i32 0
  %2460 = load double, ptr %2459, align 8, !tbaa !11
  %2461 = load ptr, ptr %19, align 8, !tbaa !5
  %2462 = load i32, ptr %27, align 4, !tbaa !9
  %2463 = sext i32 %2462 to i64
  %2464 = getelementptr inbounds %struct.doublecomplex, ptr %2461, i64 %2463
  %2465 = getelementptr inbounds %struct.doublecomplex, ptr %2464, i32 0, i32 0
  %2466 = load double, ptr %2465, align 8, !tbaa !11
  %2467 = load ptr, ptr %14, align 8, !tbaa !5
  %2468 = load i32, ptr %26, align 4, !tbaa !9
  %2469 = sext i32 %2468 to i64
  %2470 = getelementptr inbounds %struct.doublecomplex, ptr %2467, i64 %2469
  %2471 = getelementptr inbounds %struct.doublecomplex, ptr %2470, i32 0, i32 1
  %2472 = load double, ptr %2471, align 8, !tbaa !14
  %2473 = load ptr, ptr %19, align 8, !tbaa !5
  %2474 = load i32, ptr %27, align 4, !tbaa !9
  %2475 = sext i32 %2474 to i64
  %2476 = getelementptr inbounds %struct.doublecomplex, ptr %2473, i64 %2475
  %2477 = getelementptr inbounds %struct.doublecomplex, ptr %2476, i32 0, i32 1
  %2478 = load double, ptr %2477, align 8, !tbaa !14
  %2479 = fmul double %2472, %2478
  %2480 = fneg double %2479
  %2481 = call double @llvm.fmuladd.f64(double %2460, double %2466, double %2480)
  %2482 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %2481, ptr %2482, align 8, !tbaa !11
  %2483 = load ptr, ptr %14, align 8, !tbaa !5
  %2484 = load i32, ptr %26, align 4, !tbaa !9
  %2485 = sext i32 %2484 to i64
  %2486 = getelementptr inbounds %struct.doublecomplex, ptr %2483, i64 %2485
  %2487 = getelementptr inbounds %struct.doublecomplex, ptr %2486, i32 0, i32 0
  %2488 = load double, ptr %2487, align 8, !tbaa !11
  %2489 = load ptr, ptr %19, align 8, !tbaa !5
  %2490 = load i32, ptr %27, align 4, !tbaa !9
  %2491 = sext i32 %2490 to i64
  %2492 = getelementptr inbounds %struct.doublecomplex, ptr %2489, i64 %2491
  %2493 = getelementptr inbounds %struct.doublecomplex, ptr %2492, i32 0, i32 1
  %2494 = load double, ptr %2493, align 8, !tbaa !14
  %2495 = load ptr, ptr %14, align 8, !tbaa !5
  %2496 = load i32, ptr %26, align 4, !tbaa !9
  %2497 = sext i32 %2496 to i64
  %2498 = getelementptr inbounds %struct.doublecomplex, ptr %2495, i64 %2497
  %2499 = getelementptr inbounds %struct.doublecomplex, ptr %2498, i32 0, i32 1
  %2500 = load double, ptr %2499, align 8, !tbaa !14
  %2501 = load ptr, ptr %19, align 8, !tbaa !5
  %2502 = load i32, ptr %27, align 4, !tbaa !9
  %2503 = sext i32 %2502 to i64
  %2504 = getelementptr inbounds %struct.doublecomplex, ptr %2501, i64 %2503
  %2505 = getelementptr inbounds %struct.doublecomplex, ptr %2504, i32 0, i32 0
  %2506 = load double, ptr %2505, align 8, !tbaa !11
  %2507 = fmul double %2500, %2506
  %2508 = call double @llvm.fmuladd.f64(double %2488, double %2494, double %2507)
  %2509 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %2508, ptr %2509, align 8, !tbaa !14
  %2510 = load ptr, ptr %19, align 8, !tbaa !5
  %2511 = load i32, ptr %25, align 4, !tbaa !9
  %2512 = sext i32 %2511 to i64
  %2513 = getelementptr inbounds %struct.doublecomplex, ptr %2510, i64 %2512
  %2514 = getelementptr inbounds %struct.doublecomplex, ptr %2513, i32 0, i32 0
  %2515 = load double, ptr %2514, align 8, !tbaa !11
  %2516 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %2517 = load double, ptr %2516, align 8, !tbaa !11
  %2518 = fsub double %2515, %2517
  %2519 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %2518, ptr %2519, align 8, !tbaa !11
  %2520 = load ptr, ptr %19, align 8, !tbaa !5
  %2521 = load i32, ptr %25, align 4, !tbaa !9
  %2522 = sext i32 %2521 to i64
  %2523 = getelementptr inbounds %struct.doublecomplex, ptr %2520, i64 %2522
  %2524 = getelementptr inbounds %struct.doublecomplex, ptr %2523, i32 0, i32 1
  %2525 = load double, ptr %2524, align 8, !tbaa !14
  %2526 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %2527 = load double, ptr %2526, align 8, !tbaa !14
  %2528 = fsub double %2525, %2527
  %2529 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %2528, ptr %2529, align 8, !tbaa !14
  %2530 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2531 = load double, ptr %2530, align 8, !tbaa !11
  %2532 = load ptr, ptr %19, align 8, !tbaa !5
  %2533 = load i32, ptr %24, align 4, !tbaa !9
  %2534 = sext i32 %2533 to i64
  %2535 = getelementptr inbounds %struct.doublecomplex, ptr %2532, i64 %2534
  %2536 = getelementptr inbounds %struct.doublecomplex, ptr %2535, i32 0, i32 0
  store double %2531, ptr %2536, align 8, !tbaa !11
  %2537 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2538 = load double, ptr %2537, align 8, !tbaa !14
  %2539 = load ptr, ptr %19, align 8, !tbaa !5
  %2540 = load i32, ptr %24, align 4, !tbaa !9
  %2541 = sext i32 %2540 to i64
  %2542 = getelementptr inbounds %struct.doublecomplex, ptr %2539, i64 %2541
  %2543 = getelementptr inbounds %struct.doublecomplex, ptr %2542, i32 0, i32 1
  store double %2538, ptr %2543, align 8, !tbaa !14
  br label %2669

2544:                                             ; preds = %2429
  %2545 = load i32, ptr %40, align 4, !tbaa !9
  %2546 = add nsw i32 %2545, 1
  %2547 = load i32, ptr %41, align 4, !tbaa !9
  %2548 = load i32, ptr %21, align 4, !tbaa !9
  %2549 = mul nsw i32 %2547, %2548
  %2550 = add nsw i32 %2546, %2549
  store i32 %2550, ptr %24, align 4, !tbaa !9
  %2551 = load ptr, ptr %19, align 8, !tbaa !5
  %2552 = load i32, ptr %24, align 4, !tbaa !9
  %2553 = sext i32 %2552 to i64
  %2554 = getelementptr inbounds %struct.doublecomplex, ptr %2551, i64 %2553
  %2555 = getelementptr inbounds %struct.doublecomplex, ptr %2554, i32 0, i32 0
  %2556 = load double, ptr %2555, align 8, !tbaa !11
  %2557 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2556, ptr %2557, align 8, !tbaa !11
  %2558 = load ptr, ptr %19, align 8, !tbaa !5
  %2559 = load i32, ptr %24, align 4, !tbaa !9
  %2560 = sext i32 %2559 to i64
  %2561 = getelementptr inbounds %struct.doublecomplex, ptr %2558, i64 %2560
  %2562 = getelementptr inbounds %struct.doublecomplex, ptr %2561, i32 0, i32 1
  %2563 = load double, ptr %2562, align 8, !tbaa !14
  %2564 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2563, ptr %2564, align 8, !tbaa !14
  %2565 = load i32, ptr %40, align 4, !tbaa !9
  %2566 = add nsw i32 %2565, 1
  %2567 = load i32, ptr %41, align 4, !tbaa !9
  %2568 = load i32, ptr %21, align 4, !tbaa !9
  %2569 = mul nsw i32 %2567, %2568
  %2570 = add nsw i32 %2566, %2569
  store i32 %2570, ptr %24, align 4, !tbaa !9
  %2571 = load i32, ptr %40, align 4, !tbaa !9
  %2572 = load i32, ptr %41, align 4, !tbaa !9
  %2573 = load i32, ptr %21, align 4, !tbaa !9
  %2574 = mul nsw i32 %2572, %2573
  %2575 = add nsw i32 %2571, %2574
  store i32 %2575, ptr %25, align 4, !tbaa !9
  %2576 = load i32, ptr %40, align 4, !tbaa !9
  store i32 %2576, ptr %26, align 4, !tbaa !9
  %2577 = load ptr, ptr %14, align 8, !tbaa !5
  %2578 = load i32, ptr %26, align 4, !tbaa !9
  %2579 = sext i32 %2578 to i64
  %2580 = getelementptr inbounds %struct.doublecomplex, ptr %2577, i64 %2579
  %2581 = getelementptr inbounds %struct.doublecomplex, ptr %2580, i32 0, i32 0
  %2582 = load double, ptr %2581, align 8, !tbaa !11
  %2583 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2584 = load double, ptr %2583, align 8, !tbaa !11
  %2585 = load ptr, ptr %14, align 8, !tbaa !5
  %2586 = load i32, ptr %26, align 4, !tbaa !9
  %2587 = sext i32 %2586 to i64
  %2588 = getelementptr inbounds %struct.doublecomplex, ptr %2585, i64 %2587
  %2589 = getelementptr inbounds %struct.doublecomplex, ptr %2588, i32 0, i32 1
  %2590 = load double, ptr %2589, align 8, !tbaa !14
  %2591 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2592 = load double, ptr %2591, align 8, !tbaa !14
  %2593 = fmul double %2590, %2592
  %2594 = fneg double %2593
  %2595 = call double @llvm.fmuladd.f64(double %2582, double %2584, double %2594)
  %2596 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %2595, ptr %2596, align 8, !tbaa !11
  %2597 = load ptr, ptr %14, align 8, !tbaa !5
  %2598 = load i32, ptr %26, align 4, !tbaa !9
  %2599 = sext i32 %2598 to i64
  %2600 = getelementptr inbounds %struct.doublecomplex, ptr %2597, i64 %2599
  %2601 = getelementptr inbounds %struct.doublecomplex, ptr %2600, i32 0, i32 0
  %2602 = load double, ptr %2601, align 8, !tbaa !11
  %2603 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2604 = load double, ptr %2603, align 8, !tbaa !14
  %2605 = load ptr, ptr %14, align 8, !tbaa !5
  %2606 = load i32, ptr %26, align 4, !tbaa !9
  %2607 = sext i32 %2606 to i64
  %2608 = getelementptr inbounds %struct.doublecomplex, ptr %2605, i64 %2607
  %2609 = getelementptr inbounds %struct.doublecomplex, ptr %2608, i32 0, i32 1
  %2610 = load double, ptr %2609, align 8, !tbaa !14
  %2611 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2612 = load double, ptr %2611, align 8, !tbaa !11
  %2613 = fmul double %2610, %2612
  %2614 = call double @llvm.fmuladd.f64(double %2602, double %2604, double %2613)
  %2615 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %2614, ptr %2615, align 8, !tbaa !14
  %2616 = load ptr, ptr %19, align 8, !tbaa !5
  %2617 = load i32, ptr %25, align 4, !tbaa !9
  %2618 = sext i32 %2617 to i64
  %2619 = getelementptr inbounds %struct.doublecomplex, ptr %2616, i64 %2618
  %2620 = getelementptr inbounds %struct.doublecomplex, ptr %2619, i32 0, i32 0
  %2621 = load double, ptr %2620, align 8, !tbaa !11
  %2622 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %2623 = load double, ptr %2622, align 8, !tbaa !11
  %2624 = fsub double %2621, %2623
  %2625 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %2624, ptr %2625, align 8, !tbaa !11
  %2626 = load ptr, ptr %19, align 8, !tbaa !5
  %2627 = load i32, ptr %25, align 4, !tbaa !9
  %2628 = sext i32 %2627 to i64
  %2629 = getelementptr inbounds %struct.doublecomplex, ptr %2626, i64 %2628
  %2630 = getelementptr inbounds %struct.doublecomplex, ptr %2629, i32 0, i32 1
  %2631 = load double, ptr %2630, align 8, !tbaa !14
  %2632 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %2633 = load double, ptr %2632, align 8, !tbaa !14
  %2634 = fsub double %2631, %2633
  %2635 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %2634, ptr %2635, align 8, !tbaa !14
  %2636 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2637 = load double, ptr %2636, align 8, !tbaa !11
  %2638 = load ptr, ptr %19, align 8, !tbaa !5
  %2639 = load i32, ptr %24, align 4, !tbaa !9
  %2640 = sext i32 %2639 to i64
  %2641 = getelementptr inbounds %struct.doublecomplex, ptr %2638, i64 %2640
  %2642 = getelementptr inbounds %struct.doublecomplex, ptr %2641, i32 0, i32 0
  store double %2637, ptr %2642, align 8, !tbaa !11
  %2643 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2644 = load double, ptr %2643, align 8, !tbaa !14
  %2645 = load ptr, ptr %19, align 8, !tbaa !5
  %2646 = load i32, ptr %24, align 4, !tbaa !9
  %2647 = sext i32 %2646 to i64
  %2648 = getelementptr inbounds %struct.doublecomplex, ptr %2645, i64 %2647
  %2649 = getelementptr inbounds %struct.doublecomplex, ptr %2648, i32 0, i32 1
  store double %2644, ptr %2649, align 8, !tbaa !14
  %2650 = load i32, ptr %40, align 4, !tbaa !9
  %2651 = load i32, ptr %41, align 4, !tbaa !9
  %2652 = load i32, ptr %21, align 4, !tbaa !9
  %2653 = mul nsw i32 %2651, %2652
  %2654 = add nsw i32 %2650, %2653
  store i32 %2654, ptr %24, align 4, !tbaa !9
  %2655 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2656 = load double, ptr %2655, align 8, !tbaa !11
  %2657 = load ptr, ptr %19, align 8, !tbaa !5
  %2658 = load i32, ptr %24, align 4, !tbaa !9
  %2659 = sext i32 %2658 to i64
  %2660 = getelementptr inbounds %struct.doublecomplex, ptr %2657, i64 %2659
  %2661 = getelementptr inbounds %struct.doublecomplex, ptr %2660, i32 0, i32 0
  store double %2656, ptr %2661, align 8, !tbaa !11
  %2662 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2663 = load double, ptr %2662, align 8, !tbaa !14
  %2664 = load ptr, ptr %19, align 8, !tbaa !5
  %2665 = load i32, ptr %24, align 4, !tbaa !9
  %2666 = sext i32 %2665 to i64
  %2667 = getelementptr inbounds %struct.doublecomplex, ptr %2664, i64 %2666
  %2668 = getelementptr inbounds %struct.doublecomplex, ptr %2667, i32 0, i32 1
  store double %2663, ptr %2668, align 8, !tbaa !14
  br label %2669

2669:                                             ; preds = %2544, %2437
  br label %2670

2670:                                             ; preds = %2669
  %2671 = load i32, ptr %40, align 4, !tbaa !9
  %2672 = add nsw i32 %2671, -1
  store i32 %2672, ptr %40, align 4, !tbaa !9
  br label %2426, !llvm.loop !24

2673:                                             ; preds = %2426
  br label %2674

2674:                                             ; preds = %2673
  %2675 = load i32, ptr %41, align 4, !tbaa !9
  %2676 = add nsw i32 %2675, 1
  store i32 %2676, ptr %41, align 4, !tbaa !9
  br label %2058, !llvm.loop !25

2677:                                             ; preds = %2058
  br label %2678

2678:                                             ; preds = %2677, %2054
  br label %3924

2679:                                             ; preds = %1426
  %2680 = load ptr, ptr %13, align 8, !tbaa !5
  %2681 = load i32, ptr %2680, align 4, !tbaa !9
  %2682 = icmp sle i32 %2681, 1
  br i1 %2682, label %2683, label %3302

2683:                                             ; preds = %2679
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %2684

2684:                                             ; preds = %3298, %2683
  %2685 = load i32, ptr %41, align 4, !tbaa !9
  %2686 = load i32, ptr %21, align 4, !tbaa !9
  %2687 = mul nsw i32 %2685, %2686
  %2688 = add nsw i32 %2687, 1
  store i32 %2688, ptr %23, align 4, !tbaa !9
  %2689 = load ptr, ptr %15, align 8, !tbaa !5
  %2690 = getelementptr inbounds %struct.doublecomplex, ptr %2689, i64 1
  %2691 = call { double, double } @Cd(ptr noundef %2690)
  %2692 = extractvalue { double, double } %2691, 0
  %2693 = extractvalue { double, double } %2691, 1
  %2694 = fneg double %2693
  %2695 = call ptr @_pCd(ptr noundef %32)
  %2696 = getelementptr inbounds { double, double }, ptr %2695, i32 0, i32 0
  %2697 = getelementptr inbounds { double, double }, ptr %2695, i32 0, i32 1
  store double %2692, ptr %2696, align 8
  store double %2694, ptr %2697, align 8
  %2698 = load ptr, ptr %19, align 8, !tbaa !5
  %2699 = load i32, ptr %41, align 4, !tbaa !9
  %2700 = load i32, ptr %21, align 4, !tbaa !9
  %2701 = mul nsw i32 %2699, %2700
  %2702 = add nsw i32 %2701, 1
  %2703 = sext i32 %2702 to i64
  %2704 = getelementptr inbounds %struct.doublecomplex, ptr %2698, i64 %2703
  %2705 = call { double, double } @Cd(ptr noundef %2704)
  %2706 = extractvalue { double, double } %2705, 0
  %2707 = extractvalue { double, double } %2705, 1
  %2708 = call { double, double } @Cd(ptr noundef %32)
  %2709 = extractvalue { double, double } %2708, 0
  %2710 = extractvalue { double, double } %2708, 1
  %2711 = call { double, double } @__divdc3(double noundef %2706, double noundef %2707, double noundef %2709, double noundef %2710) #4
  %2712 = extractvalue { double, double } %2711, 0
  %2713 = extractvalue { double, double } %2711, 1
  %2714 = call ptr @_pCd(ptr noundef %31)
  %2715 = getelementptr inbounds { double, double }, ptr %2714, i32 0, i32 0
  %2716 = getelementptr inbounds { double, double }, ptr %2714, i32 0, i32 1
  store double %2712, ptr %2715, align 8
  store double %2713, ptr %2716, align 8
  %2717 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2718 = load double, ptr %2717, align 8, !tbaa !11
  %2719 = load ptr, ptr %19, align 8, !tbaa !5
  %2720 = load i32, ptr %23, align 4, !tbaa !9
  %2721 = sext i32 %2720 to i64
  %2722 = getelementptr inbounds %struct.doublecomplex, ptr %2719, i64 %2721
  %2723 = getelementptr inbounds %struct.doublecomplex, ptr %2722, i32 0, i32 0
  store double %2718, ptr %2723, align 8, !tbaa !11
  %2724 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2725 = load double, ptr %2724, align 8, !tbaa !14
  %2726 = load ptr, ptr %19, align 8, !tbaa !5
  %2727 = load i32, ptr %23, align 4, !tbaa !9
  %2728 = sext i32 %2727 to i64
  %2729 = getelementptr inbounds %struct.doublecomplex, ptr %2726, i64 %2728
  %2730 = getelementptr inbounds %struct.doublecomplex, ptr %2729, i32 0, i32 1
  store double %2725, ptr %2730, align 8, !tbaa !14
  %2731 = load ptr, ptr %12, align 8, !tbaa !5
  %2732 = load i32, ptr %2731, align 4, !tbaa !9
  %2733 = icmp sgt i32 %2732, 1
  br i1 %2733, label %2734, label %2850

2734:                                             ; preds = %2684
  %2735 = load i32, ptr %41, align 4, !tbaa !9
  %2736 = load i32, ptr %21, align 4, !tbaa !9
  %2737 = mul nsw i32 %2735, %2736
  %2738 = add nsw i32 %2737, 2
  store i32 %2738, ptr %23, align 4, !tbaa !9
  %2739 = load i32, ptr %41, align 4, !tbaa !9
  %2740 = load i32, ptr %21, align 4, !tbaa !9
  %2741 = mul nsw i32 %2739, %2740
  %2742 = add nsw i32 %2741, 2
  store i32 %2742, ptr %24, align 4, !tbaa !9
  %2743 = load ptr, ptr %16, align 8, !tbaa !5
  %2744 = getelementptr inbounds %struct.doublecomplex, ptr %2743, i64 1
  %2745 = call { double, double } @Cd(ptr noundef %2744)
  %2746 = extractvalue { double, double } %2745, 0
  %2747 = extractvalue { double, double } %2745, 1
  %2748 = fneg double %2747
  %2749 = call ptr @_pCd(ptr noundef %34)
  %2750 = getelementptr inbounds { double, double }, ptr %2749, i32 0, i32 0
  %2751 = getelementptr inbounds { double, double }, ptr %2749, i32 0, i32 1
  store double %2746, ptr %2750, align 8
  store double %2748, ptr %2751, align 8
  %2752 = load i32, ptr %41, align 4, !tbaa !9
  %2753 = load i32, ptr %21, align 4, !tbaa !9
  %2754 = mul nsw i32 %2752, %2753
  %2755 = add nsw i32 %2754, 1
  store i32 %2755, ptr %25, align 4, !tbaa !9
  %2756 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %2757 = load double, ptr %2756, align 8, !tbaa !11
  %2758 = load ptr, ptr %19, align 8, !tbaa !5
  %2759 = load i32, ptr %25, align 4, !tbaa !9
  %2760 = sext i32 %2759 to i64
  %2761 = getelementptr inbounds %struct.doublecomplex, ptr %2758, i64 %2760
  %2762 = getelementptr inbounds %struct.doublecomplex, ptr %2761, i32 0, i32 0
  %2763 = load double, ptr %2762, align 8, !tbaa !11
  %2764 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %2765 = load double, ptr %2764, align 8, !tbaa !14
  %2766 = load ptr, ptr %19, align 8, !tbaa !5
  %2767 = load i32, ptr %25, align 4, !tbaa !9
  %2768 = sext i32 %2767 to i64
  %2769 = getelementptr inbounds %struct.doublecomplex, ptr %2766, i64 %2768
  %2770 = getelementptr inbounds %struct.doublecomplex, ptr %2769, i32 0, i32 1
  %2771 = load double, ptr %2770, align 8, !tbaa !14
  %2772 = fmul double %2765, %2771
  %2773 = fneg double %2772
  %2774 = call double @llvm.fmuladd.f64(double %2757, double %2763, double %2773)
  %2775 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %2774, ptr %2775, align 8, !tbaa !11
  %2776 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %2777 = load double, ptr %2776, align 8, !tbaa !11
  %2778 = load ptr, ptr %19, align 8, !tbaa !5
  %2779 = load i32, ptr %25, align 4, !tbaa !9
  %2780 = sext i32 %2779 to i64
  %2781 = getelementptr inbounds %struct.doublecomplex, ptr %2778, i64 %2780
  %2782 = getelementptr inbounds %struct.doublecomplex, ptr %2781, i32 0, i32 1
  %2783 = load double, ptr %2782, align 8, !tbaa !14
  %2784 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %2785 = load double, ptr %2784, align 8, !tbaa !14
  %2786 = load ptr, ptr %19, align 8, !tbaa !5
  %2787 = load i32, ptr %25, align 4, !tbaa !9
  %2788 = sext i32 %2787 to i64
  %2789 = getelementptr inbounds %struct.doublecomplex, ptr %2786, i64 %2788
  %2790 = getelementptr inbounds %struct.doublecomplex, ptr %2789, i32 0, i32 0
  %2791 = load double, ptr %2790, align 8, !tbaa !11
  %2792 = fmul double %2785, %2791
  %2793 = call double @llvm.fmuladd.f64(double %2777, double %2783, double %2792)
  %2794 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %2793, ptr %2794, align 8, !tbaa !14
  %2795 = load ptr, ptr %19, align 8, !tbaa !5
  %2796 = load i32, ptr %24, align 4, !tbaa !9
  %2797 = sext i32 %2796 to i64
  %2798 = getelementptr inbounds %struct.doublecomplex, ptr %2795, i64 %2797
  %2799 = getelementptr inbounds %struct.doublecomplex, ptr %2798, i32 0, i32 0
  %2800 = load double, ptr %2799, align 8, !tbaa !11
  %2801 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %2802 = load double, ptr %2801, align 8, !tbaa !11
  %2803 = fsub double %2800, %2802
  %2804 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %2803, ptr %2804, align 8, !tbaa !11
  %2805 = load ptr, ptr %19, align 8, !tbaa !5
  %2806 = load i32, ptr %24, align 4, !tbaa !9
  %2807 = sext i32 %2806 to i64
  %2808 = getelementptr inbounds %struct.doublecomplex, ptr %2805, i64 %2807
  %2809 = getelementptr inbounds %struct.doublecomplex, ptr %2808, i32 0, i32 1
  %2810 = load double, ptr %2809, align 8, !tbaa !14
  %2811 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %2812 = load double, ptr %2811, align 8, !tbaa !14
  %2813 = fsub double %2810, %2812
  %2814 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %2813, ptr %2814, align 8, !tbaa !14
  %2815 = load ptr, ptr %15, align 8, !tbaa !5
  %2816 = getelementptr inbounds %struct.doublecomplex, ptr %2815, i64 2
  %2817 = call { double, double } @Cd(ptr noundef %2816)
  %2818 = extractvalue { double, double } %2817, 0
  %2819 = extractvalue { double, double } %2817, 1
  %2820 = fneg double %2819
  %2821 = call ptr @_pCd(ptr noundef %35)
  %2822 = getelementptr inbounds { double, double }, ptr %2821, i32 0, i32 0
  %2823 = getelementptr inbounds { double, double }, ptr %2821, i32 0, i32 1
  store double %2818, ptr %2822, align 8
  store double %2820, ptr %2823, align 8
  %2824 = call { double, double } @Cd(ptr noundef %32)
  %2825 = extractvalue { double, double } %2824, 0
  %2826 = extractvalue { double, double } %2824, 1
  %2827 = call { double, double } @Cd(ptr noundef %35)
  %2828 = extractvalue { double, double } %2827, 0
  %2829 = extractvalue { double, double } %2827, 1
  %2830 = call { double, double } @__divdc3(double noundef %2825, double noundef %2826, double noundef %2828, double noundef %2829) #4
  %2831 = extractvalue { double, double } %2830, 0
  %2832 = extractvalue { double, double } %2830, 1
  %2833 = call ptr @_pCd(ptr noundef %31)
  %2834 = getelementptr inbounds { double, double }, ptr %2833, i32 0, i32 0
  %2835 = getelementptr inbounds { double, double }, ptr %2833, i32 0, i32 1
  store double %2831, ptr %2834, align 8
  store double %2832, ptr %2835, align 8
  %2836 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %2837 = load double, ptr %2836, align 8, !tbaa !11
  %2838 = load ptr, ptr %19, align 8, !tbaa !5
  %2839 = load i32, ptr %23, align 4, !tbaa !9
  %2840 = sext i32 %2839 to i64
  %2841 = getelementptr inbounds %struct.doublecomplex, ptr %2838, i64 %2840
  %2842 = getelementptr inbounds %struct.doublecomplex, ptr %2841, i32 0, i32 0
  store double %2837, ptr %2842, align 8, !tbaa !11
  %2843 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %2844 = load double, ptr %2843, align 8, !tbaa !14
  %2845 = load ptr, ptr %19, align 8, !tbaa !5
  %2846 = load i32, ptr %23, align 4, !tbaa !9
  %2847 = sext i32 %2846 to i64
  %2848 = getelementptr inbounds %struct.doublecomplex, ptr %2845, i64 %2847
  %2849 = getelementptr inbounds %struct.doublecomplex, ptr %2848, i32 0, i32 1
  store double %2844, ptr %2849, align 8, !tbaa !14
  br label %2850

2850:                                             ; preds = %2734, %2684
  %2851 = load ptr, ptr %12, align 8, !tbaa !5
  %2852 = load i32, ptr %2851, align 4, !tbaa !9
  store i32 %2852, ptr %23, align 4, !tbaa !9
  store i32 3, ptr %40, align 4, !tbaa !9
  br label %2853

2853:                                             ; preds = %3051, %2850
  %2854 = load i32, ptr %40, align 4, !tbaa !9
  %2855 = load i32, ptr %23, align 4, !tbaa !9
  %2856 = icmp sle i32 %2854, %2855
  br i1 %2856, label %2857, label %3054

2857:                                             ; preds = %2853
  %2858 = load i32, ptr %40, align 4, !tbaa !9
  %2859 = load i32, ptr %41, align 4, !tbaa !9
  %2860 = load i32, ptr %21, align 4, !tbaa !9
  %2861 = mul nsw i32 %2859, %2860
  %2862 = add nsw i32 %2858, %2861
  store i32 %2862, ptr %24, align 4, !tbaa !9
  %2863 = load i32, ptr %40, align 4, !tbaa !9
  %2864 = load i32, ptr %41, align 4, !tbaa !9
  %2865 = load i32, ptr %21, align 4, !tbaa !9
  %2866 = mul nsw i32 %2864, %2865
  %2867 = add nsw i32 %2863, %2866
  store i32 %2867, ptr %25, align 4, !tbaa !9
  %2868 = load ptr, ptr %16, align 8, !tbaa !5
  %2869 = load i32, ptr %40, align 4, !tbaa !9
  %2870 = sub nsw i32 %2869, 1
  %2871 = sext i32 %2870 to i64
  %2872 = getelementptr inbounds %struct.doublecomplex, ptr %2868, i64 %2871
  %2873 = call { double, double } @Cd(ptr noundef %2872)
  %2874 = extractvalue { double, double } %2873, 0
  %2875 = extractvalue { double, double } %2873, 1
  %2876 = fneg double %2875
  %2877 = call ptr @_pCd(ptr noundef %35)
  %2878 = getelementptr inbounds { double, double }, ptr %2877, i32 0, i32 0
  %2879 = getelementptr inbounds { double, double }, ptr %2877, i32 0, i32 1
  store double %2874, ptr %2878, align 8
  store double %2876, ptr %2879, align 8
  %2880 = load i32, ptr %40, align 4, !tbaa !9
  %2881 = sub nsw i32 %2880, 1
  %2882 = load i32, ptr %41, align 4, !tbaa !9
  %2883 = load i32, ptr %21, align 4, !tbaa !9
  %2884 = mul nsw i32 %2882, %2883
  %2885 = add nsw i32 %2881, %2884
  store i32 %2885, ptr %26, align 4, !tbaa !9
  %2886 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %2887 = load double, ptr %2886, align 8, !tbaa !11
  %2888 = load ptr, ptr %19, align 8, !tbaa !5
  %2889 = load i32, ptr %26, align 4, !tbaa !9
  %2890 = sext i32 %2889 to i64
  %2891 = getelementptr inbounds %struct.doublecomplex, ptr %2888, i64 %2890
  %2892 = getelementptr inbounds %struct.doublecomplex, ptr %2891, i32 0, i32 0
  %2893 = load double, ptr %2892, align 8, !tbaa !11
  %2894 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %2895 = load double, ptr %2894, align 8, !tbaa !14
  %2896 = load ptr, ptr %19, align 8, !tbaa !5
  %2897 = load i32, ptr %26, align 4, !tbaa !9
  %2898 = sext i32 %2897 to i64
  %2899 = getelementptr inbounds %struct.doublecomplex, ptr %2896, i64 %2898
  %2900 = getelementptr inbounds %struct.doublecomplex, ptr %2899, i32 0, i32 1
  %2901 = load double, ptr %2900, align 8, !tbaa !14
  %2902 = fmul double %2895, %2901
  %2903 = fneg double %2902
  %2904 = call double @llvm.fmuladd.f64(double %2887, double %2893, double %2903)
  %2905 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %2904, ptr %2905, align 8, !tbaa !11
  %2906 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %2907 = load double, ptr %2906, align 8, !tbaa !11
  %2908 = load ptr, ptr %19, align 8, !tbaa !5
  %2909 = load i32, ptr %26, align 4, !tbaa !9
  %2910 = sext i32 %2909 to i64
  %2911 = getelementptr inbounds %struct.doublecomplex, ptr %2908, i64 %2910
  %2912 = getelementptr inbounds %struct.doublecomplex, ptr %2911, i32 0, i32 1
  %2913 = load double, ptr %2912, align 8, !tbaa !14
  %2914 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %2915 = load double, ptr %2914, align 8, !tbaa !14
  %2916 = load ptr, ptr %19, align 8, !tbaa !5
  %2917 = load i32, ptr %26, align 4, !tbaa !9
  %2918 = sext i32 %2917 to i64
  %2919 = getelementptr inbounds %struct.doublecomplex, ptr %2916, i64 %2918
  %2920 = getelementptr inbounds %struct.doublecomplex, ptr %2919, i32 0, i32 0
  %2921 = load double, ptr %2920, align 8, !tbaa !11
  %2922 = fmul double %2915, %2921
  %2923 = call double @llvm.fmuladd.f64(double %2907, double %2913, double %2922)
  %2924 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %2923, ptr %2924, align 8, !tbaa !14
  %2925 = load ptr, ptr %19, align 8, !tbaa !5
  %2926 = load i32, ptr %25, align 4, !tbaa !9
  %2927 = sext i32 %2926 to i64
  %2928 = getelementptr inbounds %struct.doublecomplex, ptr %2925, i64 %2927
  %2929 = getelementptr inbounds %struct.doublecomplex, ptr %2928, i32 0, i32 0
  %2930 = load double, ptr %2929, align 8, !tbaa !11
  %2931 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %2932 = load double, ptr %2931, align 8, !tbaa !11
  %2933 = fsub double %2930, %2932
  %2934 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %2933, ptr %2934, align 8, !tbaa !11
  %2935 = load ptr, ptr %19, align 8, !tbaa !5
  %2936 = load i32, ptr %25, align 4, !tbaa !9
  %2937 = sext i32 %2936 to i64
  %2938 = getelementptr inbounds %struct.doublecomplex, ptr %2935, i64 %2937
  %2939 = getelementptr inbounds %struct.doublecomplex, ptr %2938, i32 0, i32 1
  %2940 = load double, ptr %2939, align 8, !tbaa !14
  %2941 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %2942 = load double, ptr %2941, align 8, !tbaa !14
  %2943 = fsub double %2940, %2942
  %2944 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %2943, ptr %2944, align 8, !tbaa !14
  %2945 = load ptr, ptr %17, align 8, !tbaa !5
  %2946 = load i32, ptr %40, align 4, !tbaa !9
  %2947 = sub nsw i32 %2946, 2
  %2948 = sext i32 %2947 to i64
  %2949 = getelementptr inbounds %struct.doublecomplex, ptr %2945, i64 %2948
  %2950 = call { double, double } @Cd(ptr noundef %2949)
  %2951 = extractvalue { double, double } %2950, 0
  %2952 = extractvalue { double, double } %2950, 1
  %2953 = fneg double %2952
  %2954 = call ptr @_pCd(ptr noundef %37)
  %2955 = getelementptr inbounds { double, double }, ptr %2954, i32 0, i32 0
  %2956 = getelementptr inbounds { double, double }, ptr %2954, i32 0, i32 1
  store double %2951, ptr %2955, align 8
  store double %2953, ptr %2956, align 8
  %2957 = load i32, ptr %40, align 4, !tbaa !9
  %2958 = sub nsw i32 %2957, 2
  %2959 = load i32, ptr %41, align 4, !tbaa !9
  %2960 = load i32, ptr %21, align 4, !tbaa !9
  %2961 = mul nsw i32 %2959, %2960
  %2962 = add nsw i32 %2958, %2961
  store i32 %2962, ptr %27, align 4, !tbaa !9
  %2963 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %2964 = load double, ptr %2963, align 8, !tbaa !11
  %2965 = load ptr, ptr %19, align 8, !tbaa !5
  %2966 = load i32, ptr %27, align 4, !tbaa !9
  %2967 = sext i32 %2966 to i64
  %2968 = getelementptr inbounds %struct.doublecomplex, ptr %2965, i64 %2967
  %2969 = getelementptr inbounds %struct.doublecomplex, ptr %2968, i32 0, i32 0
  %2970 = load double, ptr %2969, align 8, !tbaa !11
  %2971 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %2972 = load double, ptr %2971, align 8, !tbaa !14
  %2973 = load ptr, ptr %19, align 8, !tbaa !5
  %2974 = load i32, ptr %27, align 4, !tbaa !9
  %2975 = sext i32 %2974 to i64
  %2976 = getelementptr inbounds %struct.doublecomplex, ptr %2973, i64 %2975
  %2977 = getelementptr inbounds %struct.doublecomplex, ptr %2976, i32 0, i32 1
  %2978 = load double, ptr %2977, align 8, !tbaa !14
  %2979 = fmul double %2972, %2978
  %2980 = fneg double %2979
  %2981 = call double @llvm.fmuladd.f64(double %2964, double %2970, double %2980)
  %2982 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  store double %2981, ptr %2982, align 8, !tbaa !11
  %2983 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %2984 = load double, ptr %2983, align 8, !tbaa !11
  %2985 = load ptr, ptr %19, align 8, !tbaa !5
  %2986 = load i32, ptr %27, align 4, !tbaa !9
  %2987 = sext i32 %2986 to i64
  %2988 = getelementptr inbounds %struct.doublecomplex, ptr %2985, i64 %2987
  %2989 = getelementptr inbounds %struct.doublecomplex, ptr %2988, i32 0, i32 1
  %2990 = load double, ptr %2989, align 8, !tbaa !14
  %2991 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %2992 = load double, ptr %2991, align 8, !tbaa !14
  %2993 = load ptr, ptr %19, align 8, !tbaa !5
  %2994 = load i32, ptr %27, align 4, !tbaa !9
  %2995 = sext i32 %2994 to i64
  %2996 = getelementptr inbounds %struct.doublecomplex, ptr %2993, i64 %2995
  %2997 = getelementptr inbounds %struct.doublecomplex, ptr %2996, i32 0, i32 0
  %2998 = load double, ptr %2997, align 8, !tbaa !11
  %2999 = fmul double %2992, %2998
  %3000 = call double @llvm.fmuladd.f64(double %2984, double %2990, double %2999)
  %3001 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  store double %3000, ptr %3001, align 8, !tbaa !14
  %3002 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3003 = load double, ptr %3002, align 8, !tbaa !11
  %3004 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %3005 = load double, ptr %3004, align 8, !tbaa !11
  %3006 = fsub double %3003, %3005
  %3007 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3006, ptr %3007, align 8, !tbaa !11
  %3008 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3009 = load double, ptr %3008, align 8, !tbaa !14
  %3010 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %3011 = load double, ptr %3010, align 8, !tbaa !14
  %3012 = fsub double %3009, %3011
  %3013 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3012, ptr %3013, align 8, !tbaa !14
  %3014 = load ptr, ptr %15, align 8, !tbaa !5
  %3015 = load i32, ptr %40, align 4, !tbaa !9
  %3016 = sext i32 %3015 to i64
  %3017 = getelementptr inbounds %struct.doublecomplex, ptr %3014, i64 %3016
  %3018 = call { double, double } @Cd(ptr noundef %3017)
  %3019 = extractvalue { double, double } %3018, 0
  %3020 = extractvalue { double, double } %3018, 1
  %3021 = fneg double %3020
  %3022 = call ptr @_pCd(ptr noundef %38)
  %3023 = getelementptr inbounds { double, double }, ptr %3022, i32 0, i32 0
  %3024 = getelementptr inbounds { double, double }, ptr %3022, i32 0, i32 1
  store double %3019, ptr %3023, align 8
  store double %3021, ptr %3024, align 8
  %3025 = call { double, double } @Cd(ptr noundef %32)
  %3026 = extractvalue { double, double } %3025, 0
  %3027 = extractvalue { double, double } %3025, 1
  %3028 = call { double, double } @Cd(ptr noundef %38)
  %3029 = extractvalue { double, double } %3028, 0
  %3030 = extractvalue { double, double } %3028, 1
  %3031 = call { double, double } @__divdc3(double noundef %3026, double noundef %3027, double noundef %3029, double noundef %3030) #4
  %3032 = extractvalue { double, double } %3031, 0
  %3033 = extractvalue { double, double } %3031, 1
  %3034 = call ptr @_pCd(ptr noundef %31)
  %3035 = getelementptr inbounds { double, double }, ptr %3034, i32 0, i32 0
  %3036 = getelementptr inbounds { double, double }, ptr %3034, i32 0, i32 1
  store double %3032, ptr %3035, align 8
  store double %3033, ptr %3036, align 8
  %3037 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3038 = load double, ptr %3037, align 8, !tbaa !11
  %3039 = load ptr, ptr %19, align 8, !tbaa !5
  %3040 = load i32, ptr %24, align 4, !tbaa !9
  %3041 = sext i32 %3040 to i64
  %3042 = getelementptr inbounds %struct.doublecomplex, ptr %3039, i64 %3041
  %3043 = getelementptr inbounds %struct.doublecomplex, ptr %3042, i32 0, i32 0
  store double %3038, ptr %3043, align 8, !tbaa !11
  %3044 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3045 = load double, ptr %3044, align 8, !tbaa !14
  %3046 = load ptr, ptr %19, align 8, !tbaa !5
  %3047 = load i32, ptr %24, align 4, !tbaa !9
  %3048 = sext i32 %3047 to i64
  %3049 = getelementptr inbounds %struct.doublecomplex, ptr %3046, i64 %3048
  %3050 = getelementptr inbounds %struct.doublecomplex, ptr %3049, i32 0, i32 1
  store double %3045, ptr %3050, align 8, !tbaa !14
  br label %3051

3051:                                             ; preds = %2857
  %3052 = load i32, ptr %40, align 4, !tbaa !9
  %3053 = add nsw i32 %3052, 1
  store i32 %3053, ptr %40, align 4, !tbaa !9
  br label %2853, !llvm.loop !26

3054:                                             ; preds = %2853
  %3055 = load ptr, ptr %12, align 8, !tbaa !5
  %3056 = load i32, ptr %3055, align 4, !tbaa !9
  %3057 = sub nsw i32 %3056, 1
  store i32 %3057, ptr %40, align 4, !tbaa !9
  br label %3058

3058:                                             ; preds = %3290, %3054
  %3059 = load i32, ptr %40, align 4, !tbaa !9
  %3060 = icmp sge i32 %3059, 1
  br i1 %3060, label %3061, label %3293

3061:                                             ; preds = %3058
  %3062 = load ptr, ptr %18, align 8, !tbaa !5
  %3063 = load i32, ptr %40, align 4, !tbaa !9
  %3064 = sext i32 %3063 to i64
  %3065 = getelementptr inbounds i32, ptr %3062, i64 %3064
  %3066 = load i32, ptr %3065, align 4, !tbaa !9
  %3067 = load i32, ptr %40, align 4, !tbaa !9
  %3068 = icmp eq i32 %3066, %3067
  br i1 %3068, label %3069, label %3170

3069:                                             ; preds = %3061
  %3070 = load i32, ptr %40, align 4, !tbaa !9
  %3071 = load i32, ptr %41, align 4, !tbaa !9
  %3072 = load i32, ptr %21, align 4, !tbaa !9
  %3073 = mul nsw i32 %3071, %3072
  %3074 = add nsw i32 %3070, %3073
  store i32 %3074, ptr %23, align 4, !tbaa !9
  %3075 = load i32, ptr %40, align 4, !tbaa !9
  %3076 = load i32, ptr %41, align 4, !tbaa !9
  %3077 = load i32, ptr %21, align 4, !tbaa !9
  %3078 = mul nsw i32 %3076, %3077
  %3079 = add nsw i32 %3075, %3078
  store i32 %3079, ptr %24, align 4, !tbaa !9
  %3080 = load ptr, ptr %14, align 8, !tbaa !5
  %3081 = load i32, ptr %40, align 4, !tbaa !9
  %3082 = sext i32 %3081 to i64
  %3083 = getelementptr inbounds %struct.doublecomplex, ptr %3080, i64 %3082
  %3084 = call { double, double } @Cd(ptr noundef %3083)
  %3085 = extractvalue { double, double } %3084, 0
  %3086 = extractvalue { double, double } %3084, 1
  %3087 = fneg double %3086
  %3088 = call ptr @_pCd(ptr noundef %33)
  %3089 = getelementptr inbounds { double, double }, ptr %3088, i32 0, i32 0
  %3090 = getelementptr inbounds { double, double }, ptr %3088, i32 0, i32 1
  store double %3085, ptr %3089, align 8
  store double %3087, ptr %3090, align 8
  %3091 = load i32, ptr %40, align 4, !tbaa !9
  %3092 = add nsw i32 %3091, 1
  %3093 = load i32, ptr %41, align 4, !tbaa !9
  %3094 = load i32, ptr %21, align 4, !tbaa !9
  %3095 = mul nsw i32 %3093, %3094
  %3096 = add nsw i32 %3092, %3095
  store i32 %3096, ptr %25, align 4, !tbaa !9
  %3097 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3098 = load double, ptr %3097, align 8, !tbaa !11
  %3099 = load ptr, ptr %19, align 8, !tbaa !5
  %3100 = load i32, ptr %25, align 4, !tbaa !9
  %3101 = sext i32 %3100 to i64
  %3102 = getelementptr inbounds %struct.doublecomplex, ptr %3099, i64 %3101
  %3103 = getelementptr inbounds %struct.doublecomplex, ptr %3102, i32 0, i32 0
  %3104 = load double, ptr %3103, align 8, !tbaa !11
  %3105 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3106 = load double, ptr %3105, align 8, !tbaa !14
  %3107 = load ptr, ptr %19, align 8, !tbaa !5
  %3108 = load i32, ptr %25, align 4, !tbaa !9
  %3109 = sext i32 %3108 to i64
  %3110 = getelementptr inbounds %struct.doublecomplex, ptr %3107, i64 %3109
  %3111 = getelementptr inbounds %struct.doublecomplex, ptr %3110, i32 0, i32 1
  %3112 = load double, ptr %3111, align 8, !tbaa !14
  %3113 = fmul double %3106, %3112
  %3114 = fneg double %3113
  %3115 = call double @llvm.fmuladd.f64(double %3098, double %3104, double %3114)
  %3116 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3115, ptr %3116, align 8, !tbaa !11
  %3117 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3118 = load double, ptr %3117, align 8, !tbaa !11
  %3119 = load ptr, ptr %19, align 8, !tbaa !5
  %3120 = load i32, ptr %25, align 4, !tbaa !9
  %3121 = sext i32 %3120 to i64
  %3122 = getelementptr inbounds %struct.doublecomplex, ptr %3119, i64 %3121
  %3123 = getelementptr inbounds %struct.doublecomplex, ptr %3122, i32 0, i32 1
  %3124 = load double, ptr %3123, align 8, !tbaa !14
  %3125 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3126 = load double, ptr %3125, align 8, !tbaa !14
  %3127 = load ptr, ptr %19, align 8, !tbaa !5
  %3128 = load i32, ptr %25, align 4, !tbaa !9
  %3129 = sext i32 %3128 to i64
  %3130 = getelementptr inbounds %struct.doublecomplex, ptr %3127, i64 %3129
  %3131 = getelementptr inbounds %struct.doublecomplex, ptr %3130, i32 0, i32 0
  %3132 = load double, ptr %3131, align 8, !tbaa !11
  %3133 = fmul double %3126, %3132
  %3134 = call double @llvm.fmuladd.f64(double %3118, double %3124, double %3133)
  %3135 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3134, ptr %3135, align 8, !tbaa !14
  %3136 = load ptr, ptr %19, align 8, !tbaa !5
  %3137 = load i32, ptr %24, align 4, !tbaa !9
  %3138 = sext i32 %3137 to i64
  %3139 = getelementptr inbounds %struct.doublecomplex, ptr %3136, i64 %3138
  %3140 = getelementptr inbounds %struct.doublecomplex, ptr %3139, i32 0, i32 0
  %3141 = load double, ptr %3140, align 8, !tbaa !11
  %3142 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %3143 = load double, ptr %3142, align 8, !tbaa !11
  %3144 = fsub double %3141, %3143
  %3145 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %3144, ptr %3145, align 8, !tbaa !11
  %3146 = load ptr, ptr %19, align 8, !tbaa !5
  %3147 = load i32, ptr %24, align 4, !tbaa !9
  %3148 = sext i32 %3147 to i64
  %3149 = getelementptr inbounds %struct.doublecomplex, ptr %3146, i64 %3148
  %3150 = getelementptr inbounds %struct.doublecomplex, ptr %3149, i32 0, i32 1
  %3151 = load double, ptr %3150, align 8, !tbaa !14
  %3152 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %3153 = load double, ptr %3152, align 8, !tbaa !14
  %3154 = fsub double %3151, %3153
  %3155 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %3154, ptr %3155, align 8, !tbaa !14
  %3156 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3157 = load double, ptr %3156, align 8, !tbaa !11
  %3158 = load ptr, ptr %19, align 8, !tbaa !5
  %3159 = load i32, ptr %23, align 4, !tbaa !9
  %3160 = sext i32 %3159 to i64
  %3161 = getelementptr inbounds %struct.doublecomplex, ptr %3158, i64 %3160
  %3162 = getelementptr inbounds %struct.doublecomplex, ptr %3161, i32 0, i32 0
  store double %3157, ptr %3162, align 8, !tbaa !11
  %3163 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3164 = load double, ptr %3163, align 8, !tbaa !14
  %3165 = load ptr, ptr %19, align 8, !tbaa !5
  %3166 = load i32, ptr %23, align 4, !tbaa !9
  %3167 = sext i32 %3166 to i64
  %3168 = getelementptr inbounds %struct.doublecomplex, ptr %3165, i64 %3167
  %3169 = getelementptr inbounds %struct.doublecomplex, ptr %3168, i32 0, i32 1
  store double %3164, ptr %3169, align 8, !tbaa !14
  br label %3289

3170:                                             ; preds = %3061
  %3171 = load i32, ptr %40, align 4, !tbaa !9
  %3172 = add nsw i32 %3171, 1
  %3173 = load i32, ptr %41, align 4, !tbaa !9
  %3174 = load i32, ptr %21, align 4, !tbaa !9
  %3175 = mul nsw i32 %3173, %3174
  %3176 = add nsw i32 %3172, %3175
  store i32 %3176, ptr %23, align 4, !tbaa !9
  %3177 = load ptr, ptr %19, align 8, !tbaa !5
  %3178 = load i32, ptr %23, align 4, !tbaa !9
  %3179 = sext i32 %3178 to i64
  %3180 = getelementptr inbounds %struct.doublecomplex, ptr %3177, i64 %3179
  %3181 = getelementptr inbounds %struct.doublecomplex, ptr %3180, i32 0, i32 0
  %3182 = load double, ptr %3181, align 8, !tbaa !11
  %3183 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3182, ptr %3183, align 8, !tbaa !11
  %3184 = load ptr, ptr %19, align 8, !tbaa !5
  %3185 = load i32, ptr %23, align 4, !tbaa !9
  %3186 = sext i32 %3185 to i64
  %3187 = getelementptr inbounds %struct.doublecomplex, ptr %3184, i64 %3186
  %3188 = getelementptr inbounds %struct.doublecomplex, ptr %3187, i32 0, i32 1
  %3189 = load double, ptr %3188, align 8, !tbaa !14
  %3190 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3189, ptr %3190, align 8, !tbaa !14
  %3191 = load i32, ptr %40, align 4, !tbaa !9
  %3192 = add nsw i32 %3191, 1
  %3193 = load i32, ptr %41, align 4, !tbaa !9
  %3194 = load i32, ptr %21, align 4, !tbaa !9
  %3195 = mul nsw i32 %3193, %3194
  %3196 = add nsw i32 %3192, %3195
  store i32 %3196, ptr %23, align 4, !tbaa !9
  %3197 = load i32, ptr %40, align 4, !tbaa !9
  %3198 = load i32, ptr %41, align 4, !tbaa !9
  %3199 = load i32, ptr %21, align 4, !tbaa !9
  %3200 = mul nsw i32 %3198, %3199
  %3201 = add nsw i32 %3197, %3200
  store i32 %3201, ptr %24, align 4, !tbaa !9
  %3202 = load ptr, ptr %14, align 8, !tbaa !5
  %3203 = load i32, ptr %40, align 4, !tbaa !9
  %3204 = sext i32 %3203 to i64
  %3205 = getelementptr inbounds %struct.doublecomplex, ptr %3202, i64 %3204
  %3206 = call { double, double } @Cd(ptr noundef %3205)
  %3207 = extractvalue { double, double } %3206, 0
  %3208 = extractvalue { double, double } %3206, 1
  %3209 = fneg double %3208
  %3210 = call ptr @_pCd(ptr noundef %33)
  %3211 = getelementptr inbounds { double, double }, ptr %3210, i32 0, i32 0
  %3212 = getelementptr inbounds { double, double }, ptr %3210, i32 0, i32 1
  store double %3207, ptr %3211, align 8
  store double %3209, ptr %3212, align 8
  %3213 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3214 = load double, ptr %3213, align 8, !tbaa !11
  %3215 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3216 = load double, ptr %3215, align 8, !tbaa !11
  %3217 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3218 = load double, ptr %3217, align 8, !tbaa !14
  %3219 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3220 = load double, ptr %3219, align 8, !tbaa !14
  %3221 = fmul double %3218, %3220
  %3222 = fneg double %3221
  %3223 = call double @llvm.fmuladd.f64(double %3214, double %3216, double %3222)
  %3224 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3223, ptr %3224, align 8, !tbaa !11
  %3225 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3226 = load double, ptr %3225, align 8, !tbaa !11
  %3227 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3228 = load double, ptr %3227, align 8, !tbaa !14
  %3229 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3230 = load double, ptr %3229, align 8, !tbaa !14
  %3231 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3232 = load double, ptr %3231, align 8, !tbaa !11
  %3233 = fmul double %3230, %3232
  %3234 = call double @llvm.fmuladd.f64(double %3226, double %3228, double %3233)
  %3235 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3234, ptr %3235, align 8, !tbaa !14
  %3236 = load ptr, ptr %19, align 8, !tbaa !5
  %3237 = load i32, ptr %24, align 4, !tbaa !9
  %3238 = sext i32 %3237 to i64
  %3239 = getelementptr inbounds %struct.doublecomplex, ptr %3236, i64 %3238
  %3240 = getelementptr inbounds %struct.doublecomplex, ptr %3239, i32 0, i32 0
  %3241 = load double, ptr %3240, align 8, !tbaa !11
  %3242 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %3243 = load double, ptr %3242, align 8, !tbaa !11
  %3244 = fsub double %3241, %3243
  %3245 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %3244, ptr %3245, align 8, !tbaa !11
  %3246 = load ptr, ptr %19, align 8, !tbaa !5
  %3247 = load i32, ptr %24, align 4, !tbaa !9
  %3248 = sext i32 %3247 to i64
  %3249 = getelementptr inbounds %struct.doublecomplex, ptr %3246, i64 %3248
  %3250 = getelementptr inbounds %struct.doublecomplex, ptr %3249, i32 0, i32 1
  %3251 = load double, ptr %3250, align 8, !tbaa !14
  %3252 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %3253 = load double, ptr %3252, align 8, !tbaa !14
  %3254 = fsub double %3251, %3253
  %3255 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %3254, ptr %3255, align 8, !tbaa !14
  %3256 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3257 = load double, ptr %3256, align 8, !tbaa !11
  %3258 = load ptr, ptr %19, align 8, !tbaa !5
  %3259 = load i32, ptr %23, align 4, !tbaa !9
  %3260 = sext i32 %3259 to i64
  %3261 = getelementptr inbounds %struct.doublecomplex, ptr %3258, i64 %3260
  %3262 = getelementptr inbounds %struct.doublecomplex, ptr %3261, i32 0, i32 0
  store double %3257, ptr %3262, align 8, !tbaa !11
  %3263 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3264 = load double, ptr %3263, align 8, !tbaa !14
  %3265 = load ptr, ptr %19, align 8, !tbaa !5
  %3266 = load i32, ptr %23, align 4, !tbaa !9
  %3267 = sext i32 %3266 to i64
  %3268 = getelementptr inbounds %struct.doublecomplex, ptr %3265, i64 %3267
  %3269 = getelementptr inbounds %struct.doublecomplex, ptr %3268, i32 0, i32 1
  store double %3264, ptr %3269, align 8, !tbaa !14
  %3270 = load i32, ptr %40, align 4, !tbaa !9
  %3271 = load i32, ptr %41, align 4, !tbaa !9
  %3272 = load i32, ptr %21, align 4, !tbaa !9
  %3273 = mul nsw i32 %3271, %3272
  %3274 = add nsw i32 %3270, %3273
  store i32 %3274, ptr %23, align 4, !tbaa !9
  %3275 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3276 = load double, ptr %3275, align 8, !tbaa !11
  %3277 = load ptr, ptr %19, align 8, !tbaa !5
  %3278 = load i32, ptr %23, align 4, !tbaa !9
  %3279 = sext i32 %3278 to i64
  %3280 = getelementptr inbounds %struct.doublecomplex, ptr %3277, i64 %3279
  %3281 = getelementptr inbounds %struct.doublecomplex, ptr %3280, i32 0, i32 0
  store double %3276, ptr %3281, align 8, !tbaa !11
  %3282 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3283 = load double, ptr %3282, align 8, !tbaa !14
  %3284 = load ptr, ptr %19, align 8, !tbaa !5
  %3285 = load i32, ptr %23, align 4, !tbaa !9
  %3286 = sext i32 %3285 to i64
  %3287 = getelementptr inbounds %struct.doublecomplex, ptr %3284, i64 %3286
  %3288 = getelementptr inbounds %struct.doublecomplex, ptr %3287, i32 0, i32 1
  store double %3283, ptr %3288, align 8, !tbaa !14
  br label %3289

3289:                                             ; preds = %3170, %3069
  br label %3290

3290:                                             ; preds = %3289
  %3291 = load i32, ptr %40, align 4, !tbaa !9
  %3292 = add nsw i32 %3291, -1
  store i32 %3292, ptr %40, align 4, !tbaa !9
  br label %3058, !llvm.loop !27

3293:                                             ; preds = %3058
  %3294 = load i32, ptr %41, align 4, !tbaa !9
  %3295 = load ptr, ptr %13, align 8, !tbaa !5
  %3296 = load i32, ptr %3295, align 4, !tbaa !9
  %3297 = icmp slt i32 %3294, %3296
  br i1 %3297, label %3298, label %3301

3298:                                             ; preds = %3293
  %3299 = load i32, ptr %41, align 4, !tbaa !9
  %3300 = add nsw i32 %3299, 1
  store i32 %3300, ptr %41, align 4, !tbaa !9
  br label %2684

3301:                                             ; preds = %3293
  br label %3923

3302:                                             ; preds = %2679
  %3303 = load ptr, ptr %13, align 8, !tbaa !5
  %3304 = load i32, ptr %3303, align 4, !tbaa !9
  store i32 %3304, ptr %23, align 4, !tbaa !9
  store i32 1, ptr %41, align 4, !tbaa !9
  br label %3305

3305:                                             ; preds = %3919, %3302
  %3306 = load i32, ptr %41, align 4, !tbaa !9
  %3307 = load i32, ptr %23, align 4, !tbaa !9
  %3308 = icmp sle i32 %3306, %3307
  br i1 %3308, label %3309, label %3922

3309:                                             ; preds = %3305
  %3310 = load i32, ptr %41, align 4, !tbaa !9
  %3311 = load i32, ptr %21, align 4, !tbaa !9
  %3312 = mul nsw i32 %3310, %3311
  %3313 = add nsw i32 %3312, 1
  store i32 %3313, ptr %24, align 4, !tbaa !9
  %3314 = load ptr, ptr %15, align 8, !tbaa !5
  %3315 = getelementptr inbounds %struct.doublecomplex, ptr %3314, i64 1
  %3316 = call { double, double } @Cd(ptr noundef %3315)
  %3317 = extractvalue { double, double } %3316, 0
  %3318 = extractvalue { double, double } %3316, 1
  %3319 = fneg double %3318
  %3320 = call ptr @_pCd(ptr noundef %32)
  %3321 = getelementptr inbounds { double, double }, ptr %3320, i32 0, i32 0
  %3322 = getelementptr inbounds { double, double }, ptr %3320, i32 0, i32 1
  store double %3317, ptr %3321, align 8
  store double %3319, ptr %3322, align 8
  %3323 = load ptr, ptr %19, align 8, !tbaa !5
  %3324 = load i32, ptr %41, align 4, !tbaa !9
  %3325 = load i32, ptr %21, align 4, !tbaa !9
  %3326 = mul nsw i32 %3324, %3325
  %3327 = add nsw i32 %3326, 1
  %3328 = sext i32 %3327 to i64
  %3329 = getelementptr inbounds %struct.doublecomplex, ptr %3323, i64 %3328
  %3330 = call { double, double } @Cd(ptr noundef %3329)
  %3331 = extractvalue { double, double } %3330, 0
  %3332 = extractvalue { double, double } %3330, 1
  %3333 = call { double, double } @Cd(ptr noundef %32)
  %3334 = extractvalue { double, double } %3333, 0
  %3335 = extractvalue { double, double } %3333, 1
  %3336 = call { double, double } @__divdc3(double noundef %3331, double noundef %3332, double noundef %3334, double noundef %3335) #4
  %3337 = extractvalue { double, double } %3336, 0
  %3338 = extractvalue { double, double } %3336, 1
  %3339 = call ptr @_pCd(ptr noundef %31)
  %3340 = getelementptr inbounds { double, double }, ptr %3339, i32 0, i32 0
  %3341 = getelementptr inbounds { double, double }, ptr %3339, i32 0, i32 1
  store double %3337, ptr %3340, align 8
  store double %3338, ptr %3341, align 8
  %3342 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3343 = load double, ptr %3342, align 8, !tbaa !11
  %3344 = load ptr, ptr %19, align 8, !tbaa !5
  %3345 = load i32, ptr %24, align 4, !tbaa !9
  %3346 = sext i32 %3345 to i64
  %3347 = getelementptr inbounds %struct.doublecomplex, ptr %3344, i64 %3346
  %3348 = getelementptr inbounds %struct.doublecomplex, ptr %3347, i32 0, i32 0
  store double %3343, ptr %3348, align 8, !tbaa !11
  %3349 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3350 = load double, ptr %3349, align 8, !tbaa !14
  %3351 = load ptr, ptr %19, align 8, !tbaa !5
  %3352 = load i32, ptr %24, align 4, !tbaa !9
  %3353 = sext i32 %3352 to i64
  %3354 = getelementptr inbounds %struct.doublecomplex, ptr %3351, i64 %3353
  %3355 = getelementptr inbounds %struct.doublecomplex, ptr %3354, i32 0, i32 1
  store double %3350, ptr %3355, align 8, !tbaa !14
  %3356 = load ptr, ptr %12, align 8, !tbaa !5
  %3357 = load i32, ptr %3356, align 4, !tbaa !9
  %3358 = icmp sgt i32 %3357, 1
  br i1 %3358, label %3359, label %3475

3359:                                             ; preds = %3309
  %3360 = load i32, ptr %41, align 4, !tbaa !9
  %3361 = load i32, ptr %21, align 4, !tbaa !9
  %3362 = mul nsw i32 %3360, %3361
  %3363 = add nsw i32 %3362, 2
  store i32 %3363, ptr %24, align 4, !tbaa !9
  %3364 = load i32, ptr %41, align 4, !tbaa !9
  %3365 = load i32, ptr %21, align 4, !tbaa !9
  %3366 = mul nsw i32 %3364, %3365
  %3367 = add nsw i32 %3366, 2
  store i32 %3367, ptr %25, align 4, !tbaa !9
  %3368 = load ptr, ptr %16, align 8, !tbaa !5
  %3369 = getelementptr inbounds %struct.doublecomplex, ptr %3368, i64 1
  %3370 = call { double, double } @Cd(ptr noundef %3369)
  %3371 = extractvalue { double, double } %3370, 0
  %3372 = extractvalue { double, double } %3370, 1
  %3373 = fneg double %3372
  %3374 = call ptr @_pCd(ptr noundef %34)
  %3375 = getelementptr inbounds { double, double }, ptr %3374, i32 0, i32 0
  %3376 = getelementptr inbounds { double, double }, ptr %3374, i32 0, i32 1
  store double %3371, ptr %3375, align 8
  store double %3373, ptr %3376, align 8
  %3377 = load i32, ptr %41, align 4, !tbaa !9
  %3378 = load i32, ptr %21, align 4, !tbaa !9
  %3379 = mul nsw i32 %3377, %3378
  %3380 = add nsw i32 %3379, 1
  store i32 %3380, ptr %26, align 4, !tbaa !9
  %3381 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %3382 = load double, ptr %3381, align 8, !tbaa !11
  %3383 = load ptr, ptr %19, align 8, !tbaa !5
  %3384 = load i32, ptr %26, align 4, !tbaa !9
  %3385 = sext i32 %3384 to i64
  %3386 = getelementptr inbounds %struct.doublecomplex, ptr %3383, i64 %3385
  %3387 = getelementptr inbounds %struct.doublecomplex, ptr %3386, i32 0, i32 0
  %3388 = load double, ptr %3387, align 8, !tbaa !11
  %3389 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %3390 = load double, ptr %3389, align 8, !tbaa !14
  %3391 = load ptr, ptr %19, align 8, !tbaa !5
  %3392 = load i32, ptr %26, align 4, !tbaa !9
  %3393 = sext i32 %3392 to i64
  %3394 = getelementptr inbounds %struct.doublecomplex, ptr %3391, i64 %3393
  %3395 = getelementptr inbounds %struct.doublecomplex, ptr %3394, i32 0, i32 1
  %3396 = load double, ptr %3395, align 8, !tbaa !14
  %3397 = fmul double %3390, %3396
  %3398 = fneg double %3397
  %3399 = call double @llvm.fmuladd.f64(double %3382, double %3388, double %3398)
  %3400 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %3399, ptr %3400, align 8, !tbaa !11
  %3401 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %3402 = load double, ptr %3401, align 8, !tbaa !11
  %3403 = load ptr, ptr %19, align 8, !tbaa !5
  %3404 = load i32, ptr %26, align 4, !tbaa !9
  %3405 = sext i32 %3404 to i64
  %3406 = getelementptr inbounds %struct.doublecomplex, ptr %3403, i64 %3405
  %3407 = getelementptr inbounds %struct.doublecomplex, ptr %3406, i32 0, i32 1
  %3408 = load double, ptr %3407, align 8, !tbaa !14
  %3409 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %3410 = load double, ptr %3409, align 8, !tbaa !14
  %3411 = load ptr, ptr %19, align 8, !tbaa !5
  %3412 = load i32, ptr %26, align 4, !tbaa !9
  %3413 = sext i32 %3412 to i64
  %3414 = getelementptr inbounds %struct.doublecomplex, ptr %3411, i64 %3413
  %3415 = getelementptr inbounds %struct.doublecomplex, ptr %3414, i32 0, i32 0
  %3416 = load double, ptr %3415, align 8, !tbaa !11
  %3417 = fmul double %3410, %3416
  %3418 = call double @llvm.fmuladd.f64(double %3402, double %3408, double %3417)
  %3419 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %3418, ptr %3419, align 8, !tbaa !14
  %3420 = load ptr, ptr %19, align 8, !tbaa !5
  %3421 = load i32, ptr %25, align 4, !tbaa !9
  %3422 = sext i32 %3421 to i64
  %3423 = getelementptr inbounds %struct.doublecomplex, ptr %3420, i64 %3422
  %3424 = getelementptr inbounds %struct.doublecomplex, ptr %3423, i32 0, i32 0
  %3425 = load double, ptr %3424, align 8, !tbaa !11
  %3426 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3427 = load double, ptr %3426, align 8, !tbaa !11
  %3428 = fsub double %3425, %3427
  %3429 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3428, ptr %3429, align 8, !tbaa !11
  %3430 = load ptr, ptr %19, align 8, !tbaa !5
  %3431 = load i32, ptr %25, align 4, !tbaa !9
  %3432 = sext i32 %3431 to i64
  %3433 = getelementptr inbounds %struct.doublecomplex, ptr %3430, i64 %3432
  %3434 = getelementptr inbounds %struct.doublecomplex, ptr %3433, i32 0, i32 1
  %3435 = load double, ptr %3434, align 8, !tbaa !14
  %3436 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3437 = load double, ptr %3436, align 8, !tbaa !14
  %3438 = fsub double %3435, %3437
  %3439 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3438, ptr %3439, align 8, !tbaa !14
  %3440 = load ptr, ptr %15, align 8, !tbaa !5
  %3441 = getelementptr inbounds %struct.doublecomplex, ptr %3440, i64 2
  %3442 = call { double, double } @Cd(ptr noundef %3441)
  %3443 = extractvalue { double, double } %3442, 0
  %3444 = extractvalue { double, double } %3442, 1
  %3445 = fneg double %3444
  %3446 = call ptr @_pCd(ptr noundef %35)
  %3447 = getelementptr inbounds { double, double }, ptr %3446, i32 0, i32 0
  %3448 = getelementptr inbounds { double, double }, ptr %3446, i32 0, i32 1
  store double %3443, ptr %3447, align 8
  store double %3445, ptr %3448, align 8
  %3449 = call { double, double } @Cd(ptr noundef %32)
  %3450 = extractvalue { double, double } %3449, 0
  %3451 = extractvalue { double, double } %3449, 1
  %3452 = call { double, double } @Cd(ptr noundef %35)
  %3453 = extractvalue { double, double } %3452, 0
  %3454 = extractvalue { double, double } %3452, 1
  %3455 = call { double, double } @__divdc3(double noundef %3450, double noundef %3451, double noundef %3453, double noundef %3454) #4
  %3456 = extractvalue { double, double } %3455, 0
  %3457 = extractvalue { double, double } %3455, 1
  %3458 = call ptr @_pCd(ptr noundef %31)
  %3459 = getelementptr inbounds { double, double }, ptr %3458, i32 0, i32 0
  %3460 = getelementptr inbounds { double, double }, ptr %3458, i32 0, i32 1
  store double %3456, ptr %3459, align 8
  store double %3457, ptr %3460, align 8
  %3461 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3462 = load double, ptr %3461, align 8, !tbaa !11
  %3463 = load ptr, ptr %19, align 8, !tbaa !5
  %3464 = load i32, ptr %24, align 4, !tbaa !9
  %3465 = sext i32 %3464 to i64
  %3466 = getelementptr inbounds %struct.doublecomplex, ptr %3463, i64 %3465
  %3467 = getelementptr inbounds %struct.doublecomplex, ptr %3466, i32 0, i32 0
  store double %3462, ptr %3467, align 8, !tbaa !11
  %3468 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3469 = load double, ptr %3468, align 8, !tbaa !14
  %3470 = load ptr, ptr %19, align 8, !tbaa !5
  %3471 = load i32, ptr %24, align 4, !tbaa !9
  %3472 = sext i32 %3471 to i64
  %3473 = getelementptr inbounds %struct.doublecomplex, ptr %3470, i64 %3472
  %3474 = getelementptr inbounds %struct.doublecomplex, ptr %3473, i32 0, i32 1
  store double %3469, ptr %3474, align 8, !tbaa !14
  br label %3475

3475:                                             ; preds = %3359, %3309
  %3476 = load ptr, ptr %12, align 8, !tbaa !5
  %3477 = load i32, ptr %3476, align 4, !tbaa !9
  store i32 %3477, ptr %24, align 4, !tbaa !9
  store i32 3, ptr %40, align 4, !tbaa !9
  br label %3478

3478:                                             ; preds = %3676, %3475
  %3479 = load i32, ptr %40, align 4, !tbaa !9
  %3480 = load i32, ptr %24, align 4, !tbaa !9
  %3481 = icmp sle i32 %3479, %3480
  br i1 %3481, label %3482, label %3679

3482:                                             ; preds = %3478
  %3483 = load i32, ptr %40, align 4, !tbaa !9
  %3484 = load i32, ptr %41, align 4, !tbaa !9
  %3485 = load i32, ptr %21, align 4, !tbaa !9
  %3486 = mul nsw i32 %3484, %3485
  %3487 = add nsw i32 %3483, %3486
  store i32 %3487, ptr %25, align 4, !tbaa !9
  %3488 = load i32, ptr %40, align 4, !tbaa !9
  %3489 = load i32, ptr %41, align 4, !tbaa !9
  %3490 = load i32, ptr %21, align 4, !tbaa !9
  %3491 = mul nsw i32 %3489, %3490
  %3492 = add nsw i32 %3488, %3491
  store i32 %3492, ptr %26, align 4, !tbaa !9
  %3493 = load ptr, ptr %16, align 8, !tbaa !5
  %3494 = load i32, ptr %40, align 4, !tbaa !9
  %3495 = sub nsw i32 %3494, 1
  %3496 = sext i32 %3495 to i64
  %3497 = getelementptr inbounds %struct.doublecomplex, ptr %3493, i64 %3496
  %3498 = call { double, double } @Cd(ptr noundef %3497)
  %3499 = extractvalue { double, double } %3498, 0
  %3500 = extractvalue { double, double } %3498, 1
  %3501 = fneg double %3500
  %3502 = call ptr @_pCd(ptr noundef %35)
  %3503 = getelementptr inbounds { double, double }, ptr %3502, i32 0, i32 0
  %3504 = getelementptr inbounds { double, double }, ptr %3502, i32 0, i32 1
  store double %3499, ptr %3503, align 8
  store double %3501, ptr %3504, align 8
  %3505 = load i32, ptr %40, align 4, !tbaa !9
  %3506 = sub nsw i32 %3505, 1
  %3507 = load i32, ptr %41, align 4, !tbaa !9
  %3508 = load i32, ptr %21, align 4, !tbaa !9
  %3509 = mul nsw i32 %3507, %3508
  %3510 = add nsw i32 %3506, %3509
  store i32 %3510, ptr %27, align 4, !tbaa !9
  %3511 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %3512 = load double, ptr %3511, align 8, !tbaa !11
  %3513 = load ptr, ptr %19, align 8, !tbaa !5
  %3514 = load i32, ptr %27, align 4, !tbaa !9
  %3515 = sext i32 %3514 to i64
  %3516 = getelementptr inbounds %struct.doublecomplex, ptr %3513, i64 %3515
  %3517 = getelementptr inbounds %struct.doublecomplex, ptr %3516, i32 0, i32 0
  %3518 = load double, ptr %3517, align 8, !tbaa !11
  %3519 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %3520 = load double, ptr %3519, align 8, !tbaa !14
  %3521 = load ptr, ptr %19, align 8, !tbaa !5
  %3522 = load i32, ptr %27, align 4, !tbaa !9
  %3523 = sext i32 %3522 to i64
  %3524 = getelementptr inbounds %struct.doublecomplex, ptr %3521, i64 %3523
  %3525 = getelementptr inbounds %struct.doublecomplex, ptr %3524, i32 0, i32 1
  %3526 = load double, ptr %3525, align 8, !tbaa !14
  %3527 = fmul double %3520, %3526
  %3528 = fneg double %3527
  %3529 = call double @llvm.fmuladd.f64(double %3512, double %3518, double %3528)
  %3530 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %3529, ptr %3530, align 8, !tbaa !11
  %3531 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %3532 = load double, ptr %3531, align 8, !tbaa !11
  %3533 = load ptr, ptr %19, align 8, !tbaa !5
  %3534 = load i32, ptr %27, align 4, !tbaa !9
  %3535 = sext i32 %3534 to i64
  %3536 = getelementptr inbounds %struct.doublecomplex, ptr %3533, i64 %3535
  %3537 = getelementptr inbounds %struct.doublecomplex, ptr %3536, i32 0, i32 1
  %3538 = load double, ptr %3537, align 8, !tbaa !14
  %3539 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %3540 = load double, ptr %3539, align 8, !tbaa !14
  %3541 = load ptr, ptr %19, align 8, !tbaa !5
  %3542 = load i32, ptr %27, align 4, !tbaa !9
  %3543 = sext i32 %3542 to i64
  %3544 = getelementptr inbounds %struct.doublecomplex, ptr %3541, i64 %3543
  %3545 = getelementptr inbounds %struct.doublecomplex, ptr %3544, i32 0, i32 0
  %3546 = load double, ptr %3545, align 8, !tbaa !11
  %3547 = fmul double %3540, %3546
  %3548 = call double @llvm.fmuladd.f64(double %3532, double %3538, double %3547)
  %3549 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %3548, ptr %3549, align 8, !tbaa !14
  %3550 = load ptr, ptr %19, align 8, !tbaa !5
  %3551 = load i32, ptr %26, align 4, !tbaa !9
  %3552 = sext i32 %3551 to i64
  %3553 = getelementptr inbounds %struct.doublecomplex, ptr %3550, i64 %3552
  %3554 = getelementptr inbounds %struct.doublecomplex, ptr %3553, i32 0, i32 0
  %3555 = load double, ptr %3554, align 8, !tbaa !11
  %3556 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %3557 = load double, ptr %3556, align 8, !tbaa !11
  %3558 = fsub double %3555, %3557
  %3559 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %3558, ptr %3559, align 8, !tbaa !11
  %3560 = load ptr, ptr %19, align 8, !tbaa !5
  %3561 = load i32, ptr %26, align 4, !tbaa !9
  %3562 = sext i32 %3561 to i64
  %3563 = getelementptr inbounds %struct.doublecomplex, ptr %3560, i64 %3562
  %3564 = getelementptr inbounds %struct.doublecomplex, ptr %3563, i32 0, i32 1
  %3565 = load double, ptr %3564, align 8, !tbaa !14
  %3566 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %3567 = load double, ptr %3566, align 8, !tbaa !14
  %3568 = fsub double %3565, %3567
  %3569 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %3568, ptr %3569, align 8, !tbaa !14
  %3570 = load ptr, ptr %17, align 8, !tbaa !5
  %3571 = load i32, ptr %40, align 4, !tbaa !9
  %3572 = sub nsw i32 %3571, 2
  %3573 = sext i32 %3572 to i64
  %3574 = getelementptr inbounds %struct.doublecomplex, ptr %3570, i64 %3573
  %3575 = call { double, double } @Cd(ptr noundef %3574)
  %3576 = extractvalue { double, double } %3575, 0
  %3577 = extractvalue { double, double } %3575, 1
  %3578 = fneg double %3577
  %3579 = call ptr @_pCd(ptr noundef %37)
  %3580 = getelementptr inbounds { double, double }, ptr %3579, i32 0, i32 0
  %3581 = getelementptr inbounds { double, double }, ptr %3579, i32 0, i32 1
  store double %3576, ptr %3580, align 8
  store double %3578, ptr %3581, align 8
  %3582 = load i32, ptr %40, align 4, !tbaa !9
  %3583 = sub nsw i32 %3582, 2
  %3584 = load i32, ptr %41, align 4, !tbaa !9
  %3585 = load i32, ptr %21, align 4, !tbaa !9
  %3586 = mul nsw i32 %3584, %3585
  %3587 = add nsw i32 %3583, %3586
  store i32 %3587, ptr %28, align 4, !tbaa !9
  %3588 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %3589 = load double, ptr %3588, align 8, !tbaa !11
  %3590 = load ptr, ptr %19, align 8, !tbaa !5
  %3591 = load i32, ptr %28, align 4, !tbaa !9
  %3592 = sext i32 %3591 to i64
  %3593 = getelementptr inbounds %struct.doublecomplex, ptr %3590, i64 %3592
  %3594 = getelementptr inbounds %struct.doublecomplex, ptr %3593, i32 0, i32 0
  %3595 = load double, ptr %3594, align 8, !tbaa !11
  %3596 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %3597 = load double, ptr %3596, align 8, !tbaa !14
  %3598 = load ptr, ptr %19, align 8, !tbaa !5
  %3599 = load i32, ptr %28, align 4, !tbaa !9
  %3600 = sext i32 %3599 to i64
  %3601 = getelementptr inbounds %struct.doublecomplex, ptr %3598, i64 %3600
  %3602 = getelementptr inbounds %struct.doublecomplex, ptr %3601, i32 0, i32 1
  %3603 = load double, ptr %3602, align 8, !tbaa !14
  %3604 = fmul double %3597, %3603
  %3605 = fneg double %3604
  %3606 = call double @llvm.fmuladd.f64(double %3589, double %3595, double %3605)
  %3607 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  store double %3606, ptr %3607, align 8, !tbaa !11
  %3608 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %3609 = load double, ptr %3608, align 8, !tbaa !11
  %3610 = load ptr, ptr %19, align 8, !tbaa !5
  %3611 = load i32, ptr %28, align 4, !tbaa !9
  %3612 = sext i32 %3611 to i64
  %3613 = getelementptr inbounds %struct.doublecomplex, ptr %3610, i64 %3612
  %3614 = getelementptr inbounds %struct.doublecomplex, ptr %3613, i32 0, i32 1
  %3615 = load double, ptr %3614, align 8, !tbaa !14
  %3616 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %3617 = load double, ptr %3616, align 8, !tbaa !14
  %3618 = load ptr, ptr %19, align 8, !tbaa !5
  %3619 = load i32, ptr %28, align 4, !tbaa !9
  %3620 = sext i32 %3619 to i64
  %3621 = getelementptr inbounds %struct.doublecomplex, ptr %3618, i64 %3620
  %3622 = getelementptr inbounds %struct.doublecomplex, ptr %3621, i32 0, i32 0
  %3623 = load double, ptr %3622, align 8, !tbaa !11
  %3624 = fmul double %3617, %3623
  %3625 = call double @llvm.fmuladd.f64(double %3609, double %3615, double %3624)
  %3626 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  store double %3625, ptr %3626, align 8, !tbaa !14
  %3627 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3628 = load double, ptr %3627, align 8, !tbaa !11
  %3629 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 0
  %3630 = load double, ptr %3629, align 8, !tbaa !11
  %3631 = fsub double %3628, %3630
  %3632 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3631, ptr %3632, align 8, !tbaa !11
  %3633 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3634 = load double, ptr %3633, align 8, !tbaa !14
  %3635 = getelementptr inbounds %struct.doublecomplex, ptr %36, i32 0, i32 1
  %3636 = load double, ptr %3635, align 8, !tbaa !14
  %3637 = fsub double %3634, %3636
  %3638 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3637, ptr %3638, align 8, !tbaa !14
  %3639 = load ptr, ptr %15, align 8, !tbaa !5
  %3640 = load i32, ptr %40, align 4, !tbaa !9
  %3641 = sext i32 %3640 to i64
  %3642 = getelementptr inbounds %struct.doublecomplex, ptr %3639, i64 %3641
  %3643 = call { double, double } @Cd(ptr noundef %3642)
  %3644 = extractvalue { double, double } %3643, 0
  %3645 = extractvalue { double, double } %3643, 1
  %3646 = fneg double %3645
  %3647 = call ptr @_pCd(ptr noundef %38)
  %3648 = getelementptr inbounds { double, double }, ptr %3647, i32 0, i32 0
  %3649 = getelementptr inbounds { double, double }, ptr %3647, i32 0, i32 1
  store double %3644, ptr %3648, align 8
  store double %3646, ptr %3649, align 8
  %3650 = call { double, double } @Cd(ptr noundef %32)
  %3651 = extractvalue { double, double } %3650, 0
  %3652 = extractvalue { double, double } %3650, 1
  %3653 = call { double, double } @Cd(ptr noundef %38)
  %3654 = extractvalue { double, double } %3653, 0
  %3655 = extractvalue { double, double } %3653, 1
  %3656 = call { double, double } @__divdc3(double noundef %3651, double noundef %3652, double noundef %3654, double noundef %3655) #4
  %3657 = extractvalue { double, double } %3656, 0
  %3658 = extractvalue { double, double } %3656, 1
  %3659 = call ptr @_pCd(ptr noundef %31)
  %3660 = getelementptr inbounds { double, double }, ptr %3659, i32 0, i32 0
  %3661 = getelementptr inbounds { double, double }, ptr %3659, i32 0, i32 1
  store double %3657, ptr %3660, align 8
  store double %3658, ptr %3661, align 8
  %3662 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3663 = load double, ptr %3662, align 8, !tbaa !11
  %3664 = load ptr, ptr %19, align 8, !tbaa !5
  %3665 = load i32, ptr %25, align 4, !tbaa !9
  %3666 = sext i32 %3665 to i64
  %3667 = getelementptr inbounds %struct.doublecomplex, ptr %3664, i64 %3666
  %3668 = getelementptr inbounds %struct.doublecomplex, ptr %3667, i32 0, i32 0
  store double %3663, ptr %3668, align 8, !tbaa !11
  %3669 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3670 = load double, ptr %3669, align 8, !tbaa !14
  %3671 = load ptr, ptr %19, align 8, !tbaa !5
  %3672 = load i32, ptr %25, align 4, !tbaa !9
  %3673 = sext i32 %3672 to i64
  %3674 = getelementptr inbounds %struct.doublecomplex, ptr %3671, i64 %3673
  %3675 = getelementptr inbounds %struct.doublecomplex, ptr %3674, i32 0, i32 1
  store double %3670, ptr %3675, align 8, !tbaa !14
  br label %3676

3676:                                             ; preds = %3482
  %3677 = load i32, ptr %40, align 4, !tbaa !9
  %3678 = add nsw i32 %3677, 1
  store i32 %3678, ptr %40, align 4, !tbaa !9
  br label %3478, !llvm.loop !28

3679:                                             ; preds = %3478
  %3680 = load ptr, ptr %12, align 8, !tbaa !5
  %3681 = load i32, ptr %3680, align 4, !tbaa !9
  %3682 = sub nsw i32 %3681, 1
  store i32 %3682, ptr %40, align 4, !tbaa !9
  br label %3683

3683:                                             ; preds = %3915, %3679
  %3684 = load i32, ptr %40, align 4, !tbaa !9
  %3685 = icmp sge i32 %3684, 1
  br i1 %3685, label %3686, label %3918

3686:                                             ; preds = %3683
  %3687 = load ptr, ptr %18, align 8, !tbaa !5
  %3688 = load i32, ptr %40, align 4, !tbaa !9
  %3689 = sext i32 %3688 to i64
  %3690 = getelementptr inbounds i32, ptr %3687, i64 %3689
  %3691 = load i32, ptr %3690, align 4, !tbaa !9
  %3692 = load i32, ptr %40, align 4, !tbaa !9
  %3693 = icmp eq i32 %3691, %3692
  br i1 %3693, label %3694, label %3795

3694:                                             ; preds = %3686
  %3695 = load i32, ptr %40, align 4, !tbaa !9
  %3696 = load i32, ptr %41, align 4, !tbaa !9
  %3697 = load i32, ptr %21, align 4, !tbaa !9
  %3698 = mul nsw i32 %3696, %3697
  %3699 = add nsw i32 %3695, %3698
  store i32 %3699, ptr %24, align 4, !tbaa !9
  %3700 = load i32, ptr %40, align 4, !tbaa !9
  %3701 = load i32, ptr %41, align 4, !tbaa !9
  %3702 = load i32, ptr %21, align 4, !tbaa !9
  %3703 = mul nsw i32 %3701, %3702
  %3704 = add nsw i32 %3700, %3703
  store i32 %3704, ptr %25, align 4, !tbaa !9
  %3705 = load ptr, ptr %14, align 8, !tbaa !5
  %3706 = load i32, ptr %40, align 4, !tbaa !9
  %3707 = sext i32 %3706 to i64
  %3708 = getelementptr inbounds %struct.doublecomplex, ptr %3705, i64 %3707
  %3709 = call { double, double } @Cd(ptr noundef %3708)
  %3710 = extractvalue { double, double } %3709, 0
  %3711 = extractvalue { double, double } %3709, 1
  %3712 = fneg double %3711
  %3713 = call ptr @_pCd(ptr noundef %33)
  %3714 = getelementptr inbounds { double, double }, ptr %3713, i32 0, i32 0
  %3715 = getelementptr inbounds { double, double }, ptr %3713, i32 0, i32 1
  store double %3710, ptr %3714, align 8
  store double %3712, ptr %3715, align 8
  %3716 = load i32, ptr %40, align 4, !tbaa !9
  %3717 = add nsw i32 %3716, 1
  %3718 = load i32, ptr %41, align 4, !tbaa !9
  %3719 = load i32, ptr %21, align 4, !tbaa !9
  %3720 = mul nsw i32 %3718, %3719
  %3721 = add nsw i32 %3717, %3720
  store i32 %3721, ptr %26, align 4, !tbaa !9
  %3722 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3723 = load double, ptr %3722, align 8, !tbaa !11
  %3724 = load ptr, ptr %19, align 8, !tbaa !5
  %3725 = load i32, ptr %26, align 4, !tbaa !9
  %3726 = sext i32 %3725 to i64
  %3727 = getelementptr inbounds %struct.doublecomplex, ptr %3724, i64 %3726
  %3728 = getelementptr inbounds %struct.doublecomplex, ptr %3727, i32 0, i32 0
  %3729 = load double, ptr %3728, align 8, !tbaa !11
  %3730 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3731 = load double, ptr %3730, align 8, !tbaa !14
  %3732 = load ptr, ptr %19, align 8, !tbaa !5
  %3733 = load i32, ptr %26, align 4, !tbaa !9
  %3734 = sext i32 %3733 to i64
  %3735 = getelementptr inbounds %struct.doublecomplex, ptr %3732, i64 %3734
  %3736 = getelementptr inbounds %struct.doublecomplex, ptr %3735, i32 0, i32 1
  %3737 = load double, ptr %3736, align 8, !tbaa !14
  %3738 = fmul double %3731, %3737
  %3739 = fneg double %3738
  %3740 = call double @llvm.fmuladd.f64(double %3723, double %3729, double %3739)
  %3741 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3740, ptr %3741, align 8, !tbaa !11
  %3742 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3743 = load double, ptr %3742, align 8, !tbaa !11
  %3744 = load ptr, ptr %19, align 8, !tbaa !5
  %3745 = load i32, ptr %26, align 4, !tbaa !9
  %3746 = sext i32 %3745 to i64
  %3747 = getelementptr inbounds %struct.doublecomplex, ptr %3744, i64 %3746
  %3748 = getelementptr inbounds %struct.doublecomplex, ptr %3747, i32 0, i32 1
  %3749 = load double, ptr %3748, align 8, !tbaa !14
  %3750 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3751 = load double, ptr %3750, align 8, !tbaa !14
  %3752 = load ptr, ptr %19, align 8, !tbaa !5
  %3753 = load i32, ptr %26, align 4, !tbaa !9
  %3754 = sext i32 %3753 to i64
  %3755 = getelementptr inbounds %struct.doublecomplex, ptr %3752, i64 %3754
  %3756 = getelementptr inbounds %struct.doublecomplex, ptr %3755, i32 0, i32 0
  %3757 = load double, ptr %3756, align 8, !tbaa !11
  %3758 = fmul double %3751, %3757
  %3759 = call double @llvm.fmuladd.f64(double %3743, double %3749, double %3758)
  %3760 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3759, ptr %3760, align 8, !tbaa !14
  %3761 = load ptr, ptr %19, align 8, !tbaa !5
  %3762 = load i32, ptr %25, align 4, !tbaa !9
  %3763 = sext i32 %3762 to i64
  %3764 = getelementptr inbounds %struct.doublecomplex, ptr %3761, i64 %3763
  %3765 = getelementptr inbounds %struct.doublecomplex, ptr %3764, i32 0, i32 0
  %3766 = load double, ptr %3765, align 8, !tbaa !11
  %3767 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %3768 = load double, ptr %3767, align 8, !tbaa !11
  %3769 = fsub double %3766, %3768
  %3770 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %3769, ptr %3770, align 8, !tbaa !11
  %3771 = load ptr, ptr %19, align 8, !tbaa !5
  %3772 = load i32, ptr %25, align 4, !tbaa !9
  %3773 = sext i32 %3772 to i64
  %3774 = getelementptr inbounds %struct.doublecomplex, ptr %3771, i64 %3773
  %3775 = getelementptr inbounds %struct.doublecomplex, ptr %3774, i32 0, i32 1
  %3776 = load double, ptr %3775, align 8, !tbaa !14
  %3777 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %3778 = load double, ptr %3777, align 8, !tbaa !14
  %3779 = fsub double %3776, %3778
  %3780 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %3779, ptr %3780, align 8, !tbaa !14
  %3781 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3782 = load double, ptr %3781, align 8, !tbaa !11
  %3783 = load ptr, ptr %19, align 8, !tbaa !5
  %3784 = load i32, ptr %24, align 4, !tbaa !9
  %3785 = sext i32 %3784 to i64
  %3786 = getelementptr inbounds %struct.doublecomplex, ptr %3783, i64 %3785
  %3787 = getelementptr inbounds %struct.doublecomplex, ptr %3786, i32 0, i32 0
  store double %3782, ptr %3787, align 8, !tbaa !11
  %3788 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3789 = load double, ptr %3788, align 8, !tbaa !14
  %3790 = load ptr, ptr %19, align 8, !tbaa !5
  %3791 = load i32, ptr %24, align 4, !tbaa !9
  %3792 = sext i32 %3791 to i64
  %3793 = getelementptr inbounds %struct.doublecomplex, ptr %3790, i64 %3792
  %3794 = getelementptr inbounds %struct.doublecomplex, ptr %3793, i32 0, i32 1
  store double %3789, ptr %3794, align 8, !tbaa !14
  br label %3914

3795:                                             ; preds = %3686
  %3796 = load i32, ptr %40, align 4, !tbaa !9
  %3797 = add nsw i32 %3796, 1
  %3798 = load i32, ptr %41, align 4, !tbaa !9
  %3799 = load i32, ptr %21, align 4, !tbaa !9
  %3800 = mul nsw i32 %3798, %3799
  %3801 = add nsw i32 %3797, %3800
  store i32 %3801, ptr %24, align 4, !tbaa !9
  %3802 = load ptr, ptr %19, align 8, !tbaa !5
  %3803 = load i32, ptr %24, align 4, !tbaa !9
  %3804 = sext i32 %3803 to i64
  %3805 = getelementptr inbounds %struct.doublecomplex, ptr %3802, i64 %3804
  %3806 = getelementptr inbounds %struct.doublecomplex, ptr %3805, i32 0, i32 0
  %3807 = load double, ptr %3806, align 8, !tbaa !11
  %3808 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3807, ptr %3808, align 8, !tbaa !11
  %3809 = load ptr, ptr %19, align 8, !tbaa !5
  %3810 = load i32, ptr %24, align 4, !tbaa !9
  %3811 = sext i32 %3810 to i64
  %3812 = getelementptr inbounds %struct.doublecomplex, ptr %3809, i64 %3811
  %3813 = getelementptr inbounds %struct.doublecomplex, ptr %3812, i32 0, i32 1
  %3814 = load double, ptr %3813, align 8, !tbaa !14
  %3815 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3814, ptr %3815, align 8, !tbaa !14
  %3816 = load i32, ptr %40, align 4, !tbaa !9
  %3817 = add nsw i32 %3816, 1
  %3818 = load i32, ptr %41, align 4, !tbaa !9
  %3819 = load i32, ptr %21, align 4, !tbaa !9
  %3820 = mul nsw i32 %3818, %3819
  %3821 = add nsw i32 %3817, %3820
  store i32 %3821, ptr %24, align 4, !tbaa !9
  %3822 = load i32, ptr %40, align 4, !tbaa !9
  %3823 = load i32, ptr %41, align 4, !tbaa !9
  %3824 = load i32, ptr %21, align 4, !tbaa !9
  %3825 = mul nsw i32 %3823, %3824
  %3826 = add nsw i32 %3822, %3825
  store i32 %3826, ptr %25, align 4, !tbaa !9
  %3827 = load ptr, ptr %14, align 8, !tbaa !5
  %3828 = load i32, ptr %40, align 4, !tbaa !9
  %3829 = sext i32 %3828 to i64
  %3830 = getelementptr inbounds %struct.doublecomplex, ptr %3827, i64 %3829
  %3831 = call { double, double } @Cd(ptr noundef %3830)
  %3832 = extractvalue { double, double } %3831, 0
  %3833 = extractvalue { double, double } %3831, 1
  %3834 = fneg double %3833
  %3835 = call ptr @_pCd(ptr noundef %33)
  %3836 = getelementptr inbounds { double, double }, ptr %3835, i32 0, i32 0
  %3837 = getelementptr inbounds { double, double }, ptr %3835, i32 0, i32 1
  store double %3832, ptr %3836, align 8
  store double %3834, ptr %3837, align 8
  %3838 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3839 = load double, ptr %3838, align 8, !tbaa !11
  %3840 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3841 = load double, ptr %3840, align 8, !tbaa !11
  %3842 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3843 = load double, ptr %3842, align 8, !tbaa !14
  %3844 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3845 = load double, ptr %3844, align 8, !tbaa !14
  %3846 = fmul double %3843, %3845
  %3847 = fneg double %3846
  %3848 = call double @llvm.fmuladd.f64(double %3839, double %3841, double %3847)
  %3849 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %3848, ptr %3849, align 8, !tbaa !11
  %3850 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %3851 = load double, ptr %3850, align 8, !tbaa !11
  %3852 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3853 = load double, ptr %3852, align 8, !tbaa !14
  %3854 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %3855 = load double, ptr %3854, align 8, !tbaa !14
  %3856 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3857 = load double, ptr %3856, align 8, !tbaa !11
  %3858 = fmul double %3855, %3857
  %3859 = call double @llvm.fmuladd.f64(double %3851, double %3853, double %3858)
  %3860 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %3859, ptr %3860, align 8, !tbaa !14
  %3861 = load ptr, ptr %19, align 8, !tbaa !5
  %3862 = load i32, ptr %25, align 4, !tbaa !9
  %3863 = sext i32 %3862 to i64
  %3864 = getelementptr inbounds %struct.doublecomplex, ptr %3861, i64 %3863
  %3865 = getelementptr inbounds %struct.doublecomplex, ptr %3864, i32 0, i32 0
  %3866 = load double, ptr %3865, align 8, !tbaa !11
  %3867 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %3868 = load double, ptr %3867, align 8, !tbaa !11
  %3869 = fsub double %3866, %3868
  %3870 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %3869, ptr %3870, align 8, !tbaa !11
  %3871 = load ptr, ptr %19, align 8, !tbaa !5
  %3872 = load i32, ptr %25, align 4, !tbaa !9
  %3873 = sext i32 %3872 to i64
  %3874 = getelementptr inbounds %struct.doublecomplex, ptr %3871, i64 %3873
  %3875 = getelementptr inbounds %struct.doublecomplex, ptr %3874, i32 0, i32 1
  %3876 = load double, ptr %3875, align 8, !tbaa !14
  %3877 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %3878 = load double, ptr %3877, align 8, !tbaa !14
  %3879 = fsub double %3876, %3878
  %3880 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %3879, ptr %3880, align 8, !tbaa !14
  %3881 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %3882 = load double, ptr %3881, align 8, !tbaa !11
  %3883 = load ptr, ptr %19, align 8, !tbaa !5
  %3884 = load i32, ptr %24, align 4, !tbaa !9
  %3885 = sext i32 %3884 to i64
  %3886 = getelementptr inbounds %struct.doublecomplex, ptr %3883, i64 %3885
  %3887 = getelementptr inbounds %struct.doublecomplex, ptr %3886, i32 0, i32 0
  store double %3882, ptr %3887, align 8, !tbaa !11
  %3888 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %3889 = load double, ptr %3888, align 8, !tbaa !14
  %3890 = load ptr, ptr %19, align 8, !tbaa !5
  %3891 = load i32, ptr %24, align 4, !tbaa !9
  %3892 = sext i32 %3891 to i64
  %3893 = getelementptr inbounds %struct.doublecomplex, ptr %3890, i64 %3892
  %3894 = getelementptr inbounds %struct.doublecomplex, ptr %3893, i32 0, i32 1
  store double %3889, ptr %3894, align 8, !tbaa !14
  %3895 = load i32, ptr %40, align 4, !tbaa !9
  %3896 = load i32, ptr %41, align 4, !tbaa !9
  %3897 = load i32, ptr %21, align 4, !tbaa !9
  %3898 = mul nsw i32 %3896, %3897
  %3899 = add nsw i32 %3895, %3898
  store i32 %3899, ptr %24, align 4, !tbaa !9
  %3900 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3901 = load double, ptr %3900, align 8, !tbaa !11
  %3902 = load ptr, ptr %19, align 8, !tbaa !5
  %3903 = load i32, ptr %24, align 4, !tbaa !9
  %3904 = sext i32 %3903 to i64
  %3905 = getelementptr inbounds %struct.doublecomplex, ptr %3902, i64 %3904
  %3906 = getelementptr inbounds %struct.doublecomplex, ptr %3905, i32 0, i32 0
  store double %3901, ptr %3906, align 8, !tbaa !11
  %3907 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3908 = load double, ptr %3907, align 8, !tbaa !14
  %3909 = load ptr, ptr %19, align 8, !tbaa !5
  %3910 = load i32, ptr %24, align 4, !tbaa !9
  %3911 = sext i32 %3910 to i64
  %3912 = getelementptr inbounds %struct.doublecomplex, ptr %3909, i64 %3911
  %3913 = getelementptr inbounds %struct.doublecomplex, ptr %3912, i32 0, i32 1
  store double %3908, ptr %3913, align 8, !tbaa !14
  br label %3914

3914:                                             ; preds = %3795, %3694
  br label %3915

3915:                                             ; preds = %3914
  %3916 = load i32, ptr %40, align 4, !tbaa !9
  %3917 = add nsw i32 %3916, -1
  store i32 %3917, ptr %40, align 4, !tbaa !9
  br label %3683, !llvm.loop !29

3918:                                             ; preds = %3683
  br label %3919

3919:                                             ; preds = %3918
  %3920 = load i32, ptr %41, align 4, !tbaa !9
  %3921 = add nsw i32 %3920, 1
  store i32 %3921, ptr %41, align 4, !tbaa !9
  br label %3305, !llvm.loop !30

3922:                                             ; preds = %3305
  br label %3923

3923:                                             ; preds = %3922, %3301
  br label %3924

3924:                                             ; preds = %3923, %2678
  br label %3925

3925:                                             ; preds = %3924, %1425
  store i32 1, ptr %42, align 4
  br label %3926

3926:                                             ; preds = %3925, %70
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %37) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %36) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #4
  ret void
}

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

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

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

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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 8}
!13 = !{!"double", !7, i64 0}
!14 = !{!12, !13, i64 8}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = distinct !{!17, !16}
!18 = distinct !{!18, !16}
!19 = distinct !{!19, !16}
!20 = distinct !{!20, !16}
!21 = distinct !{!21, !16}
!22 = distinct !{!22, !16}
!23 = distinct !{!23, !16}
!24 = distinct !{!24, !16}
!25 = distinct !{!25, !16}
!26 = distinct !{!26, !16}
!27 = distinct !{!27, !16}
!28 = distinct !{!28, !16}
!29 = distinct !{!29, !16}
!30 = distinct !{!30, !16}


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

%struct.doublecomplex = type { double, double }

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

28:                                               ; preds = %10
  %29 = load i32, ptr %2, align 4, !tbaa !5
  %30 = icmp eq i32 %29, 0
  br i1 %30, label %.loopexit, label %31

31:                                               ; preds = %28
  %32 = load i32, ptr %0, align 4, !tbaa !5
  %33 = icmp slt i32 %29, 2
  switch i32 %32, label %636 [
    i32 0, label %34
    i32 1, label %367
  ]

34:                                               ; preds = %31
  %invariant.gep1166 = getelementptr i8, ptr %4, i64 -32
  %35 = sext i32 %23 to i64
  br i1 %33, label %.preheader1119, label %.preheader1121

.preheader1121:                                   ; preds = %34
  %36 = add nuw i32 %29, 1
  %wide.trip.count1227 = zext i32 %36 to i64
  br label %203

.preheader1119:                                   ; preds = %34, %._crit_edge1165
  %indvars.iv1237 = phi i64 [ %indvars.iv.next1238, %._crit_edge1165 ], [ 1, %34 ]
  %37 = load i32, ptr %1, align 4, !tbaa !5
  %.not1116.not1157 = icmp sgt i32 %37, 1
  %38 = mul nsw i64 %indvars.iv1237, %35
  br i1 %.not1116.not1157, label %.lr.ph1160, label %._crit_edge1161

.lr.ph1160:                                       ; preds = %.preheader1119
  %39 = trunc nsw i64 %38 to i32
  %40 = add i32 %39, 1
  %wide.trip.count1232 = zext nneg i32 %37 to i64
  %invariant.gep1334 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  %invariant.gep1336 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  br label %41

41:                                               ; preds = %.lr.ph1160, %86
  %indvars.iv1229 = phi i64 [ 1, %.lr.ph1160 ], [ %indvars.iv.next1230, %86 ]
  %42 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv1229
  %43 = load i32, ptr %42, align 4, !tbaa !5
  %44 = zext i32 %43 to i64
  %45 = icmp eq i64 %indvars.iv1229, %44
  br i1 %45, label %46, label %66

46:                                               ; preds = %41
  %47 = trunc nuw nsw i64 %indvars.iv1229 to i32
  %48 = add i32 %40, %47
  %49 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv1229
  %50 = load double, ptr %49, align 8, !tbaa !9
  %gep1337 = getelementptr %struct.doublecomplex, ptr %invariant.gep1336, i64 %indvars.iv1229
  %51 = getelementptr inbounds i8, ptr %49, i64 8
  %52 = load double, ptr %51, align 8, !tbaa !12
  %53 = fneg double %52
  %54 = load <2 x double>, ptr %gep1337, align 8, !tbaa !13
  %55 = insertelement <2 x double> poison, double %52, i64 0
  %56 = insertelement <2 x double> %55, double %53, i64 1
  %57 = fmul <2 x double> %54, %56
  %58 = shufflevector <2 x double> %57, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %59 = insertelement <2 x double> poison, double %50, i64 0
  %60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
  %61 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %54, <2 x double> %58)
  store <2 x double> %61, ptr %12, align 16, !tbaa !13
  %62 = sext i32 %48 to i64
  %63 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %62
  %64 = load <2 x double>, ptr %63, align 8, !tbaa !13
  %65 = fsub <2 x double> %64, %61
  store <2 x double> %65, ptr %11, align 16, !tbaa !13
  store <2 x double> %65, ptr %63, align 8, !tbaa !13
  br label %86

66:                                               ; preds = %41
  %gep1335 = getelementptr %struct.doublecomplex, ptr %invariant.gep1334, i64 %indvars.iv1229
  %67 = trunc nuw nsw i64 %indvars.iv1229 to i32
  %68 = add i32 %40, %67
  %69 = sext i32 %68 to i64
  %70 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %69
  %71 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv1229
  %72 = getelementptr inbounds i8, ptr %71, i64 8
  %73 = load <2 x double>, ptr %gep1335, align 8, !tbaa !13
  %74 = load <2 x double>, ptr %70, align 8, !tbaa !13
  store <2 x double> %74, ptr %gep1335, align 8, !tbaa !13
  %75 = load double, ptr %71, align 8, !tbaa !9
  %76 = load double, ptr %72, align 8, !tbaa !12
  %77 = fneg double %76
  %78 = insertelement <2 x double> poison, double %76, i64 0
  %79 = insertelement <2 x double> %78, double %77, i64 1
  %80 = fmul <2 x double> %74, %79
  %81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %82 = insertelement <2 x double> poison, double %75, i64 0
  %83 = shufflevector <2 x double> %82, <2 x double> poison, <2 x i32> zeroinitializer
  %84 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> %74, <2 x double> %81)
  store <2 x double> %84, ptr %12, align 16, !tbaa !13
  %85 = fsub <2 x double> %73, %84
  store <2 x double> %85, ptr %11, align 16, !tbaa !13
  store <2 x double> %85, ptr %70, align 8, !tbaa !13
  br label %86

86:                                               ; preds = %46, %66
  %indvars.iv.next1230 = add nuw nsw i64 %indvars.iv1229, 1
  %exitcond1233.not = icmp eq i64 %indvars.iv.next1230, %wide.trip.count1232
  br i1 %exitcond1233.not, label %._crit_edge1161, label %41, !llvm.loop !14

._crit_edge1161:                                  ; preds = %86, %.preheader1119
  %87 = sext i32 %37 to i64
  %88 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  %89 = getelementptr %struct.doublecomplex, ptr %88, i64 %87
  %90 = call { double, double } @Cd(ptr noundef %89)
  %91 = extractvalue { double, double } %90, 0
  %92 = extractvalue { double, double } %90, 1
  %93 = load i32, ptr %1, align 4, !tbaa !5
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %94
  %96 = call { double, double } @Cd(ptr noundef nonnull %95)
  %97 = extractvalue { double, double } %96, 0
  %98 = extractvalue { double, double } %96, 1
  %99 = call { double, double } @__divdc3(double noundef %91, double noundef %92, double noundef %97, double noundef %98) #4
  %100 = extractvalue { double, double } %99, 0
  %101 = extractvalue { double, double } %99, 1
  %102 = call ptr @_pCd(ptr noundef nonnull %11)
  %103 = getelementptr inbounds i8, ptr %102, i64 8
  store double %100, ptr %102, align 8
  store double %101, ptr %103, align 8
  %104 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %104, ptr %89, align 8, !tbaa !13
  %105 = load i32, ptr %1, align 4, !tbaa !5
  %106 = icmp sgt i32 %105, 1
  br i1 %106, label %107, label %._crit_edge1165

107:                                              ; preds = %._crit_edge1161
  %108 = add nsw i32 %105, -1
  %109 = zext nneg i32 %108 to i64
  %110 = zext nneg i32 %105 to i64
  %111 = zext nneg i32 %108 to i64
  %112 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %111
  %113 = load double, ptr %112, align 8, !tbaa !9
  %114 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  %115 = getelementptr %struct.doublecomplex, ptr %114, i64 %110
  %116 = getelementptr inbounds i8, ptr %112, i64 8
  %117 = load double, ptr %116, align 8, !tbaa !12
  %118 = fneg double %117
  %119 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  %120 = getelementptr %struct.doublecomplex, ptr %119, i64 %109
  %121 = load <2 x double>, ptr %115, align 8, !tbaa !13
  %122 = insertelement <2 x double> poison, double %117, i64 0
  %123 = insertelement <2 x double> %122, double %118, i64 1
  %124 = fmul <2 x double> %121, %123
  %125 = shufflevector <2 x double> %124, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %126 = insertelement <2 x double> poison, double %113, i64 0
  %127 = shufflevector <2 x double> %126, <2 x double> poison, <2 x i32> zeroinitializer
  %128 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %127, <2 x double> %121, <2 x double> %125)
  %129 = load <2 x double>, ptr %120, align 8, !tbaa !13
  %130 = fsub <2 x double> %129, %128
  store <2 x double> %130, ptr %12, align 16, !tbaa !13
  %131 = call { double, double } @Cd(ptr noundef nonnull %12)
  %132 = extractvalue { double, double } %131, 0
  %133 = extractvalue { double, double } %131, 1
  %134 = load i32, ptr %1, align 4, !tbaa !5
  %135 = sext i32 %134 to i64
  %gep1167 = getelementptr %struct.doublecomplex, ptr %invariant.gep1166, i64 %135
  %136 = call { double, double } @Cd(ptr noundef %gep1167)
  %137 = extractvalue { double, double } %136, 0
  %138 = extractvalue { double, double } %136, 1
  %139 = call { double, double } @__divdc3(double noundef %132, double noundef %133, double noundef %137, double noundef %138) #4
  %140 = extractvalue { double, double } %139, 0
  %141 = extractvalue { double, double } %139, 1
  %142 = call ptr @_pCd(ptr noundef nonnull %11)
  %143 = getelementptr inbounds i8, ptr %142, i64 8
  store double %140, ptr %142, align 8
  store double %141, ptr %143, align 8
  %144 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %144, ptr %120, align 8, !tbaa !13
  %.pre1275 = load i32, ptr %1, align 4, !tbaa !5
  %145 = icmp sgt i32 %.pre1275, 2
  br i1 %145, label %.lr.ph1164, label %._crit_edge1165

.lr.ph1164:                                       ; preds = %107
  %146 = add nsw i32 %.pre1275, -2
  %147 = add i64 %38, 1
  %148 = add i64 %38, 2
  %149 = zext nneg i32 %146 to i64
  %invariant.gep1338 = getelementptr %struct.doublecomplex, ptr %25, i64 %38
  br label %150

150:                                              ; preds = %.lr.ph1164, %150
  %indvars.iv1234 = phi i64 [ %149, %.lr.ph1164 ], [ %indvars.iv.next1235, %150 ]
  %151 = add i64 %147, %indvars.iv1234
  %152 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1234
  %153 = load double, ptr %152, align 8, !tbaa !9
  %sext1284 = shl i64 %151, 32
  %154 = ashr exact i64 %sext1284, 28
  %155 = getelementptr inbounds i8, ptr %25, i64 %154
  %156 = getelementptr inbounds i8, ptr %152, i64 8
  %157 = load double, ptr %156, align 8, !tbaa !12
  %158 = fneg double %157
  %gep1339 = getelementptr %struct.doublecomplex, ptr %invariant.gep1338, i64 %indvars.iv1234
  %159 = add i64 %148, %indvars.iv1234
  %160 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %indvars.iv1234
  %161 = load double, ptr %160, align 8, !tbaa !9
  %sext1285 = shl i64 %159, 32
  %162 = ashr exact i64 %sext1285, 28
  %163 = getelementptr inbounds i8, ptr %25, i64 %162
  %164 = getelementptr inbounds i8, ptr %160, i64 8
  %165 = load double, ptr %164, align 8, !tbaa !12
  %166 = fneg double %165
  %167 = load <2 x double>, ptr %155, align 8, !tbaa !13
  %168 = insertelement <2 x double> poison, double %157, i64 0
  %169 = insertelement <2 x double> %168, double %158, i64 1
  %170 = fmul <2 x double> %167, %169
  %171 = shufflevector <2 x double> %170, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %172 = insertelement <2 x double> poison, double %153, i64 0
  %173 = shufflevector <2 x double> %172, <2 x double> poison, <2 x i32> zeroinitializer
  %174 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %173, <2 x double> %167, <2 x double> %171)
  %175 = load <2 x double>, ptr %gep1339, align 8, !tbaa !13
  %176 = fsub <2 x double> %175, %174
  %177 = load <2 x double>, ptr %163, align 8, !tbaa !13
  %178 = insertelement <2 x double> poison, double %165, i64 0
  %179 = insertelement <2 x double> %178, double %166, i64 1
  %180 = fmul <2 x double> %177, %179
  %181 = shufflevector <2 x double> %180, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %182 = insertelement <2 x double> poison, double %161, i64 0
  %183 = shufflevector <2 x double> %182, <2 x double> poison, <2 x i32> zeroinitializer
  %184 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %183, <2 x double> %177, <2 x double> %181)
  %185 = fsub <2 x double> %176, %184
  store <2 x double> %185, ptr %12, align 16, !tbaa !13
  %186 = call { double, double } @Cd(ptr noundef nonnull %12)
  %187 = extractvalue { double, double } %186, 0
  %188 = extractvalue { double, double } %186, 1
  %189 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1234
  %190 = call { double, double } @Cd(ptr noundef nonnull %189)
  %191 = extractvalue { double, double } %190, 0
  %192 = extractvalue { double, double } %190, 1
  %193 = call { double, double } @__divdc3(double noundef %187, double noundef %188, double noundef %191, double noundef %192) #4
  %194 = extractvalue { double, double } %193, 0
  %195 = extractvalue { double, double } %193, 1
  %196 = call ptr @_pCd(ptr noundef nonnull %11)
  %197 = getelementptr inbounds i8, ptr %196, i64 8
  store double %194, ptr %196, align 8
  store double %195, ptr %197, align 8
  %198 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %198, ptr %gep1339, align 8, !tbaa !13
  %indvars.iv.next1235 = add nsw i64 %indvars.iv1234, -1
  %199 = icmp ugt i64 %indvars.iv1234, 1
  br i1 %199, label %150, label %._crit_edge1165, !llvm.loop !16

._crit_edge1165:                                  ; preds = %150, %._crit_edge1161, %107
  %200 = load i32, ptr %2, align 4, !tbaa !5
  %201 = sext i32 %200 to i64
  %202 = icmp slt i64 %indvars.iv1237, %201
  %indvars.iv.next1238 = add nuw nsw i64 %indvars.iv1237, 1
  br i1 %202, label %.preheader1119, label %.loopexit

203:                                              ; preds = %.preheader1121, %._crit_edge1155
  %indvars.iv1224 = phi i64 [ 1, %.preheader1121 ], [ %indvars.iv.next1225, %._crit_edge1155 ]
  %204 = load i32, ptr %1, align 4, !tbaa !5
  %.not1115.not1147 = icmp sgt i32 %204, 1
  %205 = mul nsw i64 %indvars.iv1224, %35
  br i1 %.not1115.not1147, label %.lr.ph1150, label %._crit_edge1151

.lr.ph1150:                                       ; preds = %203
  %206 = trunc nsw i64 %205 to i32
  %207 = add i32 %206, 1
  %wide.trip.count1219 = zext nneg i32 %204 to i64
  %invariant.gep1328 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  %invariant.gep1330 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  br label %208

208:                                              ; preds = %.lr.ph1150, %253
  %indvars.iv1216 = phi i64 [ 1, %.lr.ph1150 ], [ %indvars.iv.next1217, %253 ]
  %209 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv1216
  %210 = load i32, ptr %209, align 4, !tbaa !5
  %211 = zext i32 %210 to i64
  %212 = icmp eq i64 %indvars.iv1216, %211
  br i1 %212, label %213, label %233

213:                                              ; preds = %208
  %214 = trunc nuw nsw i64 %indvars.iv1216 to i32
  %215 = add i32 %207, %214
  %216 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv1216
  %217 = load double, ptr %216, align 8, !tbaa !9
  %gep1331 = getelementptr %struct.doublecomplex, ptr %invariant.gep1330, i64 %indvars.iv1216
  %218 = getelementptr inbounds i8, ptr %216, i64 8
  %219 = load double, ptr %218, align 8, !tbaa !12
  %220 = fneg double %219
  %221 = load <2 x double>, ptr %gep1331, align 8, !tbaa !13
  %222 = insertelement <2 x double> poison, double %219, i64 0
  %223 = insertelement <2 x double> %222, double %220, i64 1
  %224 = fmul <2 x double> %221, %223
  %225 = shufflevector <2 x double> %224, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %226 = insertelement <2 x double> poison, double %217, i64 0
  %227 = shufflevector <2 x double> %226, <2 x double> poison, <2 x i32> zeroinitializer
  %228 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %227, <2 x double> %221, <2 x double> %225)
  store <2 x double> %228, ptr %12, align 16, !tbaa !13
  %229 = sext i32 %215 to i64
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %229
  %231 = load <2 x double>, ptr %230, align 8, !tbaa !13
  %232 = fsub <2 x double> %231, %228
  store <2 x double> %232, ptr %11, align 16, !tbaa !13
  store <2 x double> %232, ptr %230, align 8, !tbaa !13
  br label %253

233:                                              ; preds = %208
  %gep1329 = getelementptr %struct.doublecomplex, ptr %invariant.gep1328, i64 %indvars.iv1216
  %234 = trunc nuw nsw i64 %indvars.iv1216 to i32
  %235 = add i32 %207, %234
  %236 = sext i32 %235 to i64
  %237 = getelementptr inbounds %struct.doublecomplex, ptr %25, i64 %236
  %238 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv1216
  %239 = getelementptr inbounds i8, ptr %238, i64 8
  %240 = load <2 x double>, ptr %gep1329, align 8, !tbaa !13
  %241 = load <2 x double>, ptr %237, align 8, !tbaa !13
  store <2 x double> %241, ptr %gep1329, align 8, !tbaa !13
  %242 = load double, ptr %238, align 8, !tbaa !9
  %243 = load double, ptr %239, align 8, !tbaa !12
  %244 = fneg double %243
  %245 = insertelement <2 x double> poison, double %243, i64 0
  %246 = insertelement <2 x double> %245, double %244, i64 1
  %247 = fmul <2 x double> %241, %246
  %248 = shufflevector <2 x double> %247, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %249 = insertelement <2 x double> poison, double %242, i64 0
  %250 = shufflevector <2 x double> %249, <2 x double> poison, <2 x i32> zeroinitializer
  %251 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %250, <2 x double> %241, <2 x double> %248)
  store <2 x double> %251, ptr %12, align 16, !tbaa !13
  %252 = fsub <2 x double> %240, %251
  store <2 x double> %252, ptr %11, align 16, !tbaa !13
  store <2 x double> %252, ptr %237, align 8, !tbaa !13
  br label %253

253:                                              ; preds = %213, %233
  %indvars.iv.next1217 = add nuw nsw i64 %indvars.iv1216, 1
  %exitcond1220.not = icmp eq i64 %indvars.iv.next1217, %wide.trip.count1219
  br i1 %exitcond1220.not, label %._crit_edge1151, label %208, !llvm.loop !17

._crit_edge1151:                                  ; preds = %253, %203
  %254 = sext i32 %204 to i64
  %255 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  %256 = getelementptr %struct.doublecomplex, ptr %255, i64 %254
  %257 = call { double, double } @Cd(ptr noundef %256)
  %258 = extractvalue { double, double } %257, 0
  %259 = extractvalue { double, double } %257, 1
  %260 = load i32, ptr %1, align 4, !tbaa !5
  %261 = sext i32 %260 to i64
  %262 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %261
  %263 = call { double, double } @Cd(ptr noundef nonnull %262)
  %264 = extractvalue { double, double } %263, 0
  %265 = extractvalue { double, double } %263, 1
  %266 = call { double, double } @__divdc3(double noundef %258, double noundef %259, double noundef %264, double noundef %265) #4
  %267 = extractvalue { double, double } %266, 0
  %268 = extractvalue { double, double } %266, 1
  %269 = call ptr @_pCd(ptr noundef nonnull %11)
  %270 = getelementptr inbounds i8, ptr %269, i64 8
  store double %267, ptr %269, align 8
  store double %268, ptr %270, align 8
  %271 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %271, ptr %256, align 8, !tbaa !13
  %272 = load i32, ptr %1, align 4, !tbaa !5
  %273 = icmp sgt i32 %272, 1
  br i1 %273, label %274, label %._crit_edge1155

274:                                              ; preds = %._crit_edge1151
  %275 = add nsw i32 %272, -1
  %276 = zext nneg i32 %275 to i64
  %277 = zext nneg i32 %272 to i64
  %278 = zext nneg i32 %275 to i64
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %278
  %280 = load double, ptr %279, align 8, !tbaa !9
  %281 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  %282 = getelementptr %struct.doublecomplex, ptr %281, i64 %277
  %283 = getelementptr inbounds i8, ptr %279, i64 8
  %284 = load double, ptr %283, align 8, !tbaa !12
  %285 = fneg double %284
  %286 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  %287 = getelementptr %struct.doublecomplex, ptr %286, i64 %276
  %288 = load <2 x double>, ptr %282, align 8, !tbaa !13
  %289 = insertelement <2 x double> poison, double %284, i64 0
  %290 = insertelement <2 x double> %289, double %285, i64 1
  %291 = fmul <2 x double> %288, %290
  %292 = shufflevector <2 x double> %291, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %293 = insertelement <2 x double> poison, double %280, i64 0
  %294 = shufflevector <2 x double> %293, <2 x double> poison, <2 x i32> zeroinitializer
  %295 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %294, <2 x double> %288, <2 x double> %292)
  %296 = load <2 x double>, ptr %287, align 8, !tbaa !13
  %297 = fsub <2 x double> %296, %295
  store <2 x double> %297, ptr %12, align 16, !tbaa !13
  %298 = call { double, double } @Cd(ptr noundef nonnull %12)
  %299 = extractvalue { double, double } %298, 0
  %300 = extractvalue { double, double } %298, 1
  %301 = load i32, ptr %1, align 4, !tbaa !5
  %302 = sext i32 %301 to i64
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep1166, i64 %302
  %303 = call { double, double } @Cd(ptr noundef %gep)
  %304 = extractvalue { double, double } %303, 0
  %305 = extractvalue { double, double } %303, 1
  %306 = call { double, double } @__divdc3(double noundef %299, double noundef %300, double noundef %304, double noundef %305) #4
  %307 = extractvalue { double, double } %306, 0
  %308 = extractvalue { double, double } %306, 1
  %309 = call ptr @_pCd(ptr noundef nonnull %11)
  %310 = getelementptr inbounds i8, ptr %309, i64 8
  store double %307, ptr %309, align 8
  store double %308, ptr %310, align 8
  %311 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %311, ptr %287, align 8, !tbaa !13
  %.pre1274 = load i32, ptr %1, align 4, !tbaa !5
  %312 = icmp sgt i32 %.pre1274, 2
  br i1 %312, label %.lr.ph1154, label %._crit_edge1155

.lr.ph1154:                                       ; preds = %274
  %313 = add nsw i32 %.pre1274, -2
  %314 = add i64 %205, 1
  %315 = add i64 %205, 2
  %316 = zext nneg i32 %313 to i64
  %invariant.gep1332 = getelementptr %struct.doublecomplex, ptr %25, i64 %205
  br label %317

317:                                              ; preds = %.lr.ph1154, %317
  %indvars.iv1221 = phi i64 [ %316, %.lr.ph1154 ], [ %indvars.iv.next1222, %317 ]
  %318 = add i64 %314, %indvars.iv1221
  %319 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1221
  %320 = load double, ptr %319, align 8, !tbaa !9
  %sext = shl i64 %318, 32
  %321 = ashr exact i64 %sext, 28
  %322 = getelementptr inbounds i8, ptr %25, i64 %321
  %323 = getelementptr inbounds i8, ptr %319, i64 8
  %324 = load double, ptr %323, align 8, !tbaa !12
  %325 = fneg double %324
  %gep1333 = getelementptr %struct.doublecomplex, ptr %invariant.gep1332, i64 %indvars.iv1221
  %326 = add i64 %315, %indvars.iv1221
  %327 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %indvars.iv1221
  %328 = load double, ptr %327, align 8, !tbaa !9
  %sext1283 = shl i64 %326, 32
  %329 = ashr exact i64 %sext1283, 28
  %330 = getelementptr inbounds i8, ptr %25, i64 %329
  %331 = getelementptr inbounds i8, ptr %327, i64 8
  %332 = load double, ptr %331, align 8, !tbaa !12
  %333 = fneg double %332
  %334 = load <2 x double>, ptr %322, align 8, !tbaa !13
  %335 = insertelement <2 x double> poison, double %324, i64 0
  %336 = insertelement <2 x double> %335, double %325, i64 1
  %337 = fmul <2 x double> %334, %336
  %338 = shufflevector <2 x double> %337, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %339 = insertelement <2 x double> poison, double %320, i64 0
  %340 = shufflevector <2 x double> %339, <2 x double> poison, <2 x i32> zeroinitializer
  %341 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %340, <2 x double> %334, <2 x double> %338)
  %342 = load <2 x double>, ptr %gep1333, align 8, !tbaa !13
  %343 = fsub <2 x double> %342, %341
  %344 = load <2 x double>, ptr %330, align 8, !tbaa !13
  %345 = insertelement <2 x double> poison, double %332, i64 0
  %346 = insertelement <2 x double> %345, double %333, i64 1
  %347 = fmul <2 x double> %344, %346
  %348 = shufflevector <2 x double> %347, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %349 = insertelement <2 x double> poison, double %328, i64 0
  %350 = shufflevector <2 x double> %349, <2 x double> poison, <2 x i32> zeroinitializer
  %351 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %350, <2 x double> %344, <2 x double> %348)
  %352 = fsub <2 x double> %343, %351
  store <2 x double> %352, ptr %12, align 16, !tbaa !13
  %353 = call { double, double } @Cd(ptr noundef nonnull %12)
  %354 = extractvalue { double, double } %353, 0
  %355 = extractvalue { double, double } %353, 1
  %356 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1221
  %357 = call { double, double } @Cd(ptr noundef nonnull %356)
  %358 = extractvalue { double, double } %357, 0
  %359 = extractvalue { double, double } %357, 1
  %360 = call { double, double } @__divdc3(double noundef %354, double noundef %355, double noundef %358, double noundef %359) #4
  %361 = extractvalue { double, double } %360, 0
  %362 = extractvalue { double, double } %360, 1
  %363 = call ptr @_pCd(ptr noundef nonnull %11)
  %364 = getelementptr inbounds i8, ptr %363, i64 8
  store double %361, ptr %363, align 8
  store double %362, ptr %364, align 8
  %365 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %365, ptr %gep1333, align 8, !tbaa !13
  %indvars.iv.next1222 = add nsw i64 %indvars.iv1221, -1
  %366 = icmp ugt i64 %indvars.iv1221, 1
  br i1 %366, label %317, label %._crit_edge1155, !llvm.loop !18

._crit_edge1155:                                  ; preds = %317, %._crit_edge1151, %274
  %indvars.iv.next1225 = add nuw nsw i64 %indvars.iv1224, 1
  %exitcond1228.not = icmp eq i64 %indvars.iv.next1225, %wide.trip.count1227
  br i1 %exitcond1228.not, label %.loopexit, label %203, !llvm.loop !19

367:                                              ; preds = %31
  %368 = getelementptr inbounds i8, ptr %5, i64 8
  %369 = getelementptr inbounds i8, ptr %4, i64 16
  %370 = sext i32 %23 to i64
  br i1 %33, label %.preheader1123, label %.preheader1125

.preheader1125:                                   ; preds = %367
  %371 = add nuw i32 %29, 1
  %wide.trip.count1203 = zext i32 %371 to i64
  br label %505

.preheader1123:                                   ; preds = %367, %._crit_edge1146
  %indvars.iv1213 = phi i64 [ %indvars.iv.next1214, %._crit_edge1146 ], [ 1, %367 ]
  %372 = mul nsw i64 %indvars.iv1213, %370
  %373 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %374 = getelementptr i8, ptr %373, i64 16
  %375 = call { double, double } @Cd(ptr noundef %374)
  %376 = extractvalue { double, double } %375, 0
  %377 = extractvalue { double, double } %375, 1
  %378 = call { double, double } @Cd(ptr noundef %4)
  %379 = extractvalue { double, double } %378, 0
  %380 = extractvalue { double, double } %378, 1
  %381 = call { double, double } @__divdc3(double noundef %376, double noundef %377, double noundef %379, double noundef %380) #4
  %382 = extractvalue { double, double } %381, 0
  %383 = extractvalue { double, double } %381, 1
  %384 = call ptr @_pCd(ptr noundef nonnull %11)
  %385 = getelementptr inbounds i8, ptr %384, i64 8
  store double %382, ptr %384, align 8
  store double %383, ptr %385, align 8
  %386 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %386, ptr %374, align 8, !tbaa !13
  %387 = load i32, ptr %1, align 4, !tbaa !5
  %388 = icmp sgt i32 %387, 1
  br i1 %388, label %389, label %._crit_edge1146

389:                                              ; preds = %.preheader1123
  %390 = load double, ptr %5, align 8, !tbaa !9
  %391 = load double, ptr %368, align 8, !tbaa !12
  %392 = fneg double %391
  %393 = getelementptr i8, ptr %373, i64 32
  %394 = insertelement <2 x double> poison, double %391, i64 0
  %395 = insertelement <2 x double> %394, double %392, i64 1
  %396 = fmul <2 x double> %386, %395
  %397 = shufflevector <2 x double> %396, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %398 = insertelement <2 x double> poison, double %390, i64 0
  %399 = shufflevector <2 x double> %398, <2 x double> poison, <2 x i32> zeroinitializer
  %400 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %399, <2 x double> %386, <2 x double> %397)
  %401 = load <2 x double>, ptr %393, align 8, !tbaa !13
  %402 = fsub <2 x double> %401, %400
  store <2 x double> %402, ptr %12, align 16, !tbaa !13
  %403 = call { double, double } @Cd(ptr noundef nonnull %12)
  %404 = extractvalue { double, double } %403, 0
  %405 = extractvalue { double, double } %403, 1
  %406 = call { double, double } @Cd(ptr noundef nonnull %369)
  %407 = extractvalue { double, double } %406, 0
  %408 = extractvalue { double, double } %406, 1
  %409 = call { double, double } @__divdc3(double noundef %404, double noundef %405, double noundef %407, double noundef %408) #4
  %410 = extractvalue { double, double } %409, 0
  %411 = extractvalue { double, double } %409, 1
  %412 = call ptr @_pCd(ptr noundef nonnull %11)
  %413 = getelementptr inbounds i8, ptr %412, i64 8
  store double %410, ptr %412, align 8
  store double %411, ptr %413, align 8
  %414 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %414, ptr %393, align 8, !tbaa !13
  %.pre1272 = load i32, ptr %1, align 4, !tbaa !5
  %.not11131136 = icmp slt i32 %.pre1272, 3
  br i1 %.not11131136, label %._crit_edge1140, label %.lr.ph1139.preheader

.lr.ph1139.preheader:                             ; preds = %389
  %415 = add nuw i32 %.pre1272, 1
  %wide.trip.count1208 = zext i32 %415 to i64
  %invariant.gep1314 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %invariant.gep1316 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %invariant.gep1318 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  br label %.lr.ph1139

.lr.ph1139:                                       ; preds = %.lr.ph1139.preheader, %.lr.ph1139
  %indvars.iv1205 = phi i64 [ 3, %.lr.ph1139.preheader ], [ %indvars.iv.next1206, %.lr.ph1139 ]
  %416 = add nsw i64 %indvars.iv1205, -1
  %417 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %416
  %418 = load double, ptr %417, align 8, !tbaa !9
  %gep1315 = getelementptr %struct.doublecomplex, ptr %invariant.gep1314, i64 %416
  %419 = getelementptr inbounds i8, ptr %417, i64 8
  %420 = load double, ptr %419, align 8, !tbaa !12
  %421 = fneg double %420
  %gep1317 = getelementptr %struct.doublecomplex, ptr %invariant.gep1316, i64 %indvars.iv1205
  %422 = add nsw i64 %indvars.iv1205, -2
  %423 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %422
  %424 = load double, ptr %423, align 8, !tbaa !9
  %gep1319 = getelementptr %struct.doublecomplex, ptr %invariant.gep1318, i64 %422
  %425 = getelementptr inbounds i8, ptr %423, i64 8
  %426 = load double, ptr %425, align 8, !tbaa !12
  %427 = fneg double %426
  %428 = load <2 x double>, ptr %gep1315, align 8, !tbaa !13
  %429 = insertelement <2 x double> poison, double %420, i64 0
  %430 = insertelement <2 x double> %429, double %421, i64 1
  %431 = fmul <2 x double> %428, %430
  %432 = shufflevector <2 x double> %431, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %433 = insertelement <2 x double> poison, double %418, i64 0
  %434 = shufflevector <2 x double> %433, <2 x double> poison, <2 x i32> zeroinitializer
  %435 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %434, <2 x double> %428, <2 x double> %432)
  %436 = load <2 x double>, ptr %gep1317, align 8, !tbaa !13
  %437 = fsub <2 x double> %436, %435
  %438 = load <2 x double>, ptr %gep1319, align 8, !tbaa !13
  %439 = insertelement <2 x double> poison, double %426, i64 0
  %440 = insertelement <2 x double> %439, double %427, i64 1
  %441 = fmul <2 x double> %438, %440
  %442 = shufflevector <2 x double> %441, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %443 = insertelement <2 x double> poison, double %424, i64 0
  %444 = shufflevector <2 x double> %443, <2 x double> poison, <2 x i32> zeroinitializer
  %445 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %444, <2 x double> %438, <2 x double> %442)
  %446 = fsub <2 x double> %437, %445
  store <2 x double> %446, ptr %12, align 16, !tbaa !13
  %447 = call { double, double } @Cd(ptr noundef nonnull %12)
  %448 = extractvalue { double, double } %447, 0
  %449 = extractvalue { double, double } %447, 1
  %450 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1205
  %451 = call { double, double } @Cd(ptr noundef nonnull %450)
  %452 = extractvalue { double, double } %451, 0
  %453 = extractvalue { double, double } %451, 1
  %454 = call { double, double } @__divdc3(double noundef %448, double noundef %449, double noundef %452, double noundef %453) #4
  %455 = extractvalue { double, double } %454, 0
  %456 = extractvalue { double, double } %454, 1
  %457 = call ptr @_pCd(ptr noundef nonnull %11)
  %458 = getelementptr inbounds i8, ptr %457, i64 8
  store double %455, ptr %457, align 8
  store double %456, ptr %458, align 8
  %459 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %459, ptr %gep1317, align 8, !tbaa !13
  %indvars.iv.next1206 = add nuw nsw i64 %indvars.iv1205, 1
  %exitcond1209.not = icmp eq i64 %indvars.iv.next1206, %wide.trip.count1208
  br i1 %exitcond1209.not, label %._crit_edge1140.loopexit, label %.lr.ph1139, !llvm.loop !20

._crit_edge1140.loopexit:                         ; preds = %.lr.ph1139
  %.pre1273 = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge1140

._crit_edge1140:                                  ; preds = %._crit_edge1140.loopexit, %389
  %460 = phi i32 [ %.pre1273, %._crit_edge1140.loopexit ], [ %.pre1272, %389 ]
  %461 = icmp sgt i32 %460, 1
  br i1 %461, label %.lr.ph1145.preheader, label %._crit_edge1146

.lr.ph1145.preheader:                             ; preds = %._crit_edge1140
  %462 = zext nneg i32 %460 to i64
  %invariant.gep1320 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %invariant.gep1322 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %invariant.gep1324 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  %invariant.gep1326 = getelementptr %struct.doublecomplex, ptr %25, i64 %372
  br label %.lr.ph1145

.lr.ph1145:                                       ; preds = %.lr.ph1145.preheader, %499
  %indvars.iv1210 = phi i64 [ %462, %.lr.ph1145.preheader ], [ %indvars.iv.next1211, %499 ]
  %indvars.iv.next1211 = add nsw i64 %indvars.iv1210, -1
  %463 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv.next1211
  %464 = load i32, ptr %463, align 4, !tbaa !5
  %465 = zext i32 %464 to i64
  %466 = icmp eq i64 %indvars.iv.next1211, %465
  br i1 %466, label %467, label %483

467:                                              ; preds = %.lr.ph1145
  %468 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1211
  %469 = load double, ptr %468, align 8, !tbaa !9
  %gep1325 = getelementptr %struct.doublecomplex, ptr %invariant.gep1324, i64 %indvars.iv1210
  %470 = getelementptr inbounds i8, ptr %468, i64 8
  %471 = load double, ptr %470, align 8, !tbaa !12
  %472 = fneg double %471
  %gep1327 = getelementptr %struct.doublecomplex, ptr %invariant.gep1326, i64 %indvars.iv.next1211
  %473 = load <2 x double>, ptr %gep1325, align 8, !tbaa !13
  %474 = insertelement <2 x double> poison, double %471, i64 0
  %475 = insertelement <2 x double> %474, double %472, i64 1
  %476 = fmul <2 x double> %473, %475
  %477 = shufflevector <2 x double> %476, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %478 = insertelement <2 x double> poison, double %469, i64 0
  %479 = shufflevector <2 x double> %478, <2 x double> poison, <2 x i32> zeroinitializer
  %480 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %479, <2 x double> %473, <2 x double> %477)
  store <2 x double> %480, ptr %12, align 16, !tbaa !13
  %481 = load <2 x double>, ptr %gep1327, align 8, !tbaa !13
  %482 = fsub <2 x double> %481, %480
  store <2 x double> %482, ptr %gep1327, align 8, !tbaa !13
  br label %499

483:                                              ; preds = %.lr.ph1145
  %gep1321 = getelementptr %struct.doublecomplex, ptr %invariant.gep1320, i64 %indvars.iv1210
  %484 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1211
  %485 = load double, ptr %484, align 8, !tbaa !9
  %486 = getelementptr inbounds i8, ptr %484, i64 8
  %487 = load double, ptr %486, align 8, !tbaa !12
  %488 = fneg double %487
  %gep1323 = getelementptr %struct.doublecomplex, ptr %invariant.gep1322, i64 %indvars.iv.next1211
  %489 = load <2 x double>, ptr %gep1321, align 8, !tbaa !13
  %490 = insertelement <2 x double> poison, double %487, i64 0
  %491 = insertelement <2 x double> %490, double %488, i64 1
  %492 = fmul <2 x double> %489, %491
  %493 = shufflevector <2 x double> %492, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %494 = insertelement <2 x double> poison, double %485, i64 0
  %495 = shufflevector <2 x double> %494, <2 x double> poison, <2 x i32> zeroinitializer
  %496 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %495, <2 x double> %489, <2 x double> %493)
  store <2 x double> %496, ptr %12, align 16, !tbaa !13
  %497 = load <2 x double>, ptr %gep1323, align 8, !tbaa !13
  %498 = fsub <2 x double> %497, %496
  store <2 x double> %498, ptr %gep1321, align 8, !tbaa !13
  store <2 x double> %489, ptr %gep1323, align 8, !tbaa !13
  br label %499

499:                                              ; preds = %467, %483
  %500 = phi <2 x double> [ %482, %467 ], [ %498, %483 ]
  %501 = icmp ugt i64 %indvars.iv1210, 2
  br i1 %501, label %.lr.ph1145, label %._crit_edge1146.loopexit, !llvm.loop !21

._crit_edge1146.loopexit:                         ; preds = %499
  store <2 x double> %500, ptr %11, align 16
  br label %._crit_edge1146

._crit_edge1146:                                  ; preds = %._crit_edge1146.loopexit, %.preheader1123, %._crit_edge1140
  %502 = load i32, ptr %2, align 4, !tbaa !5
  %503 = sext i32 %502 to i64
  %504 = icmp slt i64 %indvars.iv1213, %503
  %indvars.iv.next1214 = add nuw nsw i64 %indvars.iv1213, 1
  br i1 %504, label %.preheader1123, label %.loopexit

505:                                              ; preds = %.preheader1125, %._crit_edge1134
  %indvars.iv1200 = phi i64 [ 1, %.preheader1125 ], [ %indvars.iv.next1201, %._crit_edge1134 ]
  %506 = mul nsw i64 %indvars.iv1200, %370
  %507 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %508 = getelementptr i8, ptr %507, i64 16
  %509 = call { double, double } @Cd(ptr noundef %508)
  %510 = extractvalue { double, double } %509, 0
  %511 = extractvalue { double, double } %509, 1
  %512 = call { double, double } @Cd(ptr noundef %4)
  %513 = extractvalue { double, double } %512, 0
  %514 = extractvalue { double, double } %512, 1
  %515 = call { double, double } @__divdc3(double noundef %510, double noundef %511, double noundef %513, double noundef %514) #4
  %516 = extractvalue { double, double } %515, 0
  %517 = extractvalue { double, double } %515, 1
  %518 = call ptr @_pCd(ptr noundef nonnull %11)
  %519 = getelementptr inbounds i8, ptr %518, i64 8
  store double %516, ptr %518, align 8
  store double %517, ptr %519, align 8
  %520 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %520, ptr %508, align 8, !tbaa !13
  %521 = load i32, ptr %1, align 4, !tbaa !5
  %522 = icmp sgt i32 %521, 1
  br i1 %522, label %523, label %._crit_edge1134

523:                                              ; preds = %505
  %524 = load double, ptr %5, align 8, !tbaa !9
  %525 = load double, ptr %368, align 8, !tbaa !12
  %526 = fneg double %525
  %527 = getelementptr i8, ptr %507, i64 32
  %528 = insertelement <2 x double> poison, double %525, i64 0
  %529 = insertelement <2 x double> %528, double %526, i64 1
  %530 = fmul <2 x double> %520, %529
  %531 = shufflevector <2 x double> %530, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %532 = insertelement <2 x double> poison, double %524, i64 0
  %533 = shufflevector <2 x double> %532, <2 x double> poison, <2 x i32> zeroinitializer
  %534 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %533, <2 x double> %520, <2 x double> %531)
  %535 = load <2 x double>, ptr %527, align 8, !tbaa !13
  %536 = fsub <2 x double> %535, %534
  store <2 x double> %536, ptr %12, align 16, !tbaa !13
  %537 = call { double, double } @Cd(ptr noundef nonnull %12)
  %538 = extractvalue { double, double } %537, 0
  %539 = extractvalue { double, double } %537, 1
  %540 = call { double, double } @Cd(ptr noundef nonnull %369)
  %541 = extractvalue { double, double } %540, 0
  %542 = extractvalue { double, double } %540, 1
  %543 = call { double, double } @__divdc3(double noundef %538, double noundef %539, double noundef %541, double noundef %542) #4
  %544 = extractvalue { double, double } %543, 0
  %545 = extractvalue { double, double } %543, 1
  %546 = call ptr @_pCd(ptr noundef nonnull %11)
  %547 = getelementptr inbounds i8, ptr %546, i64 8
  store double %544, ptr %546, align 8
  store double %545, ptr %547, align 8
  %548 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %548, ptr %527, align 8, !tbaa !13
  %.pre = load i32, ptr %1, align 4, !tbaa !5
  %.not11121127 = icmp slt i32 %.pre, 3
  br i1 %.not11121127, label %._crit_edge, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %523
  %549 = add nuw i32 %.pre, 1
  %wide.trip.count = zext i32 %549 to i64
  %invariant.gep1300 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %invariant.gep1302 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %invariant.gep1304 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv = phi i64 [ 3, %.lr.ph.preheader ], [ %indvars.iv.next, %.lr.ph ]
  %550 = add nsw i64 %indvars.iv, -1
  %551 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %550
  %552 = load double, ptr %551, align 8, !tbaa !9
  %gep1301 = getelementptr %struct.doublecomplex, ptr %invariant.gep1300, i64 %550
  %553 = getelementptr inbounds i8, ptr %551, i64 8
  %554 = load double, ptr %553, align 8, !tbaa !12
  %555 = fneg double %554
  %gep1303 = getelementptr %struct.doublecomplex, ptr %invariant.gep1302, i64 %indvars.iv
  %556 = add nsw i64 %indvars.iv, -2
  %557 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %556
  %558 = load double, ptr %557, align 8, !tbaa !9
  %gep1305 = getelementptr %struct.doublecomplex, ptr %invariant.gep1304, i64 %556
  %559 = getelementptr inbounds i8, ptr %557, i64 8
  %560 = load double, ptr %559, align 8, !tbaa !12
  %561 = fneg double %560
  %562 = load <2 x double>, ptr %gep1301, align 8, !tbaa !13
  %563 = insertelement <2 x double> poison, double %554, i64 0
  %564 = insertelement <2 x double> %563, double %555, i64 1
  %565 = fmul <2 x double> %562, %564
  %566 = shufflevector <2 x double> %565, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %567 = insertelement <2 x double> poison, double %552, i64 0
  %568 = shufflevector <2 x double> %567, <2 x double> poison, <2 x i32> zeroinitializer
  %569 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %568, <2 x double> %562, <2 x double> %566)
  %570 = load <2 x double>, ptr %gep1303, align 8, !tbaa !13
  %571 = fsub <2 x double> %570, %569
  %572 = load <2 x double>, ptr %gep1305, align 8, !tbaa !13
  %573 = insertelement <2 x double> poison, double %560, i64 0
  %574 = insertelement <2 x double> %573, double %561, i64 1
  %575 = fmul <2 x double> %572, %574
  %576 = shufflevector <2 x double> %575, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %577 = insertelement <2 x double> poison, double %558, i64 0
  %578 = shufflevector <2 x double> %577, <2 x double> poison, <2 x i32> zeroinitializer
  %579 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %578, <2 x double> %572, <2 x double> %576)
  %580 = fsub <2 x double> %571, %579
  store <2 x double> %580, ptr %12, align 16, !tbaa !13
  %581 = call { double, double } @Cd(ptr noundef nonnull %12)
  %582 = extractvalue { double, double } %581, 0
  %583 = extractvalue { double, double } %581, 1
  %584 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv
  %585 = call { double, double } @Cd(ptr noundef nonnull %584)
  %586 = extractvalue { double, double } %585, 0
  %587 = extractvalue { double, double } %585, 1
  %588 = call { double, double } @__divdc3(double noundef %582, double noundef %583, double noundef %586, double noundef %587) #4
  %589 = extractvalue { double, double } %588, 0
  %590 = extractvalue { double, double } %588, 1
  %591 = call ptr @_pCd(ptr noundef nonnull %11)
  %592 = getelementptr inbounds i8, ptr %591, i64 8
  store double %589, ptr %591, align 8
  store double %590, ptr %592, align 8
  %593 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %593, ptr %gep1303, align 8, !tbaa !13
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge.loopexit, label %.lr.ph, !llvm.loop !22

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

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %523
  %594 = phi i32 [ %.pre1271, %._crit_edge.loopexit ], [ %.pre, %523 ]
  %595 = icmp sgt i32 %594, 1
  br i1 %595, label %.lr.ph1133.preheader, label %._crit_edge1134

.lr.ph1133.preheader:                             ; preds = %._crit_edge
  %596 = zext nneg i32 %594 to i64
  %invariant.gep1306 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %invariant.gep1308 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %invariant.gep1310 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  %invariant.gep1312 = getelementptr %struct.doublecomplex, ptr %25, i64 %506
  br label %.lr.ph1133

.lr.ph1133:                                       ; preds = %.lr.ph1133.preheader, %633
  %indvars.iv1197 = phi i64 [ %596, %.lr.ph1133.preheader ], [ %indvars.iv.next1198, %633 ]
  %indvars.iv.next1198 = add nsw i64 %indvars.iv1197, -1
  %597 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv.next1198
  %598 = load i32, ptr %597, align 4, !tbaa !5
  %599 = zext i32 %598 to i64
  %600 = icmp eq i64 %indvars.iv.next1198, %599
  br i1 %600, label %601, label %617

601:                                              ; preds = %.lr.ph1133
  %602 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1198
  %603 = load double, ptr %602, align 8, !tbaa !9
  %gep1311 = getelementptr %struct.doublecomplex, ptr %invariant.gep1310, i64 %indvars.iv1197
  %604 = getelementptr inbounds i8, ptr %602, i64 8
  %605 = load double, ptr %604, align 8, !tbaa !12
  %606 = fneg double %605
  %gep1313 = getelementptr %struct.doublecomplex, ptr %invariant.gep1312, i64 %indvars.iv.next1198
  %607 = load <2 x double>, ptr %gep1311, align 8, !tbaa !13
  %608 = insertelement <2 x double> poison, double %605, i64 0
  %609 = insertelement <2 x double> %608, double %606, i64 1
  %610 = fmul <2 x double> %607, %609
  %611 = shufflevector <2 x double> %610, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %612 = insertelement <2 x double> poison, double %603, i64 0
  %613 = shufflevector <2 x double> %612, <2 x double> poison, <2 x i32> zeroinitializer
  %614 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %613, <2 x double> %607, <2 x double> %611)
  store <2 x double> %614, ptr %12, align 16, !tbaa !13
  %615 = load <2 x double>, ptr %gep1313, align 8, !tbaa !13
  %616 = fsub <2 x double> %615, %614
  store <2 x double> %616, ptr %gep1313, align 8, !tbaa !13
  br label %633

617:                                              ; preds = %.lr.ph1133
  %gep1307 = getelementptr %struct.doublecomplex, ptr %invariant.gep1306, i64 %indvars.iv1197
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1198
  %619 = load double, ptr %618, align 8, !tbaa !9
  %620 = getelementptr inbounds i8, ptr %618, i64 8
  %621 = load double, ptr %620, align 8, !tbaa !12
  %622 = fneg double %621
  %gep1309 = getelementptr %struct.doublecomplex, ptr %invariant.gep1308, i64 %indvars.iv.next1198
  %623 = load <2 x double>, ptr %gep1307, align 8, !tbaa !13
  %624 = insertelement <2 x double> poison, double %621, i64 0
  %625 = insertelement <2 x double> %624, double %622, i64 1
  %626 = fmul <2 x double> %623, %625
  %627 = shufflevector <2 x double> %626, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %628 = insertelement <2 x double> poison, double %619, i64 0
  %629 = shufflevector <2 x double> %628, <2 x double> poison, <2 x i32> zeroinitializer
  %630 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %629, <2 x double> %623, <2 x double> %627)
  store <2 x double> %630, ptr %12, align 16, !tbaa !13
  %631 = load <2 x double>, ptr %gep1309, align 8, !tbaa !13
  %632 = fsub <2 x double> %631, %630
  store <2 x double> %632, ptr %gep1307, align 8, !tbaa !13
  store <2 x double> %623, ptr %gep1309, align 8, !tbaa !13
  br label %633

633:                                              ; preds = %601, %617
  %634 = phi <2 x double> [ %616, %601 ], [ %632, %617 ]
  %635 = icmp ugt i64 %indvars.iv1197, 2
  br i1 %635, label %.lr.ph1133, label %._crit_edge1134.loopexit, !llvm.loop !23

._crit_edge1134.loopexit:                         ; preds = %633
  store <2 x double> %634, ptr %11, align 16
  br label %._crit_edge1134

._crit_edge1134:                                  ; preds = %._crit_edge1134.loopexit, %505, %._crit_edge
  %indvars.iv.next1201 = add nuw nsw i64 %indvars.iv1200, 1
  %exitcond1204.not = icmp eq i64 %indvars.iv.next1201, %wide.trip.count1203
  br i1 %exitcond1204.not, label %.loopexit, label %505, !llvm.loop !24

636:                                              ; preds = %31
  %637 = getelementptr inbounds i8, ptr %14, i64 8
  %638 = getelementptr inbounds i8, ptr %13, i64 8
  %639 = getelementptr inbounds i8, ptr %4, i64 16
  %640 = getelementptr inbounds i8, ptr %15, i64 8
  %641 = getelementptr inbounds i8, ptr %16, i64 8
  %642 = sext i32 %23 to i64
  br i1 %33, label %.preheader, label %.preheader1117

.preheader1117:                                   ; preds = %636
  %643 = add nuw i32 %29, 1
  %wide.trip.count1251 = zext i32 %643 to i64
  br label %818

.preheader:                                       ; preds = %636, %._crit_edge1190
  %indvars.iv1261 = phi i64 [ %indvars.iv.next1262, %._crit_edge1190 ], [ 1, %636 ]
  %644 = mul nsw i64 %indvars.iv1261, %642
  %645 = call { double, double } @Cd(ptr noundef %4)
  %646 = extractvalue { double, double } %645, 0
  %647 = extractvalue { double, double } %645, 1
  %648 = fneg double %647
  %649 = call ptr @_pCd(ptr noundef nonnull %12)
  %650 = getelementptr inbounds i8, ptr %649, i64 8
  store double %646, ptr %649, align 8
  store double %648, ptr %650, align 8
  %651 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %652 = getelementptr i8, ptr %651, i64 16
  %653 = call { double, double } @Cd(ptr noundef %652)
  %654 = extractvalue { double, double } %653, 0
  %655 = extractvalue { double, double } %653, 1
  %656 = call { double, double } @Cd(ptr noundef nonnull %12)
  %657 = extractvalue { double, double } %656, 0
  %658 = extractvalue { double, double } %656, 1
  %659 = call { double, double } @__divdc3(double noundef %654, double noundef %655, double noundef %657, double noundef %658) #4
  %660 = extractvalue { double, double } %659, 0
  %661 = extractvalue { double, double } %659, 1
  %662 = call ptr @_pCd(ptr noundef nonnull %11)
  %663 = getelementptr inbounds i8, ptr %662, i64 8
  store double %660, ptr %662, align 8
  store double %661, ptr %663, align 8
  %664 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %664, ptr %652, align 8, !tbaa !13
  %665 = load i32, ptr %1, align 4, !tbaa !5
  %666 = icmp sgt i32 %665, 1
  br i1 %666, label %667, label %._crit_edge1190

667:                                              ; preds = %.preheader
  %668 = call { double, double } @Cd(ptr noundef %5)
  %669 = extractvalue { double, double } %668, 0
  %670 = extractvalue { double, double } %668, 1
  %671 = fneg double %670
  %672 = call ptr @_pCd(ptr noundef nonnull %14)
  %673 = getelementptr inbounds i8, ptr %672, i64 8
  store double %669, ptr %672, align 8
  store double %671, ptr %673, align 8
  %674 = load <2 x double>, ptr %14, align 16
  %675 = load double, ptr %637, align 8, !tbaa !12
  %676 = fneg double %675
  %677 = load <2 x double>, ptr %652, align 8, !tbaa !13
  %678 = insertelement <2 x double> poison, double %675, i64 0
  %679 = insertelement <2 x double> %678, double %676, i64 1
  %680 = fmul <2 x double> %677, %679
  %681 = shufflevector <2 x double> %680, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %682 = shufflevector <2 x double> %674, <2 x double> poison, <2 x i32> zeroinitializer
  %683 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %682, <2 x double> %677, <2 x double> %681)
  store <2 x double> %683, ptr %13, align 16, !tbaa !13
  %684 = getelementptr i8, ptr %651, i64 32
  %685 = load <2 x double>, ptr %684, align 8, !tbaa !13
  %686 = fsub <2 x double> %685, %683
  store <2 x double> %686, ptr %12, align 16, !tbaa !13
  %687 = call { double, double } @Cd(ptr noundef nonnull %639)
  %688 = extractvalue { double, double } %687, 0
  %689 = extractvalue { double, double } %687, 1
  %690 = fneg double %689
  %691 = call ptr @_pCd(ptr noundef nonnull %15)
  %692 = getelementptr inbounds i8, ptr %691, i64 8
  store double %688, ptr %691, align 8
  store double %690, ptr %692, align 8
  %693 = call { double, double } @Cd(ptr noundef nonnull %12)
  %694 = extractvalue { double, double } %693, 0
  %695 = extractvalue { double, double } %693, 1
  %696 = call { double, double } @Cd(ptr noundef nonnull %15)
  %697 = extractvalue { double, double } %696, 0
  %698 = extractvalue { double, double } %696, 1
  %699 = call { double, double } @__divdc3(double noundef %694, double noundef %695, double noundef %697, double noundef %698) #4
  %700 = extractvalue { double, double } %699, 0
  %701 = extractvalue { double, double } %699, 1
  %702 = call ptr @_pCd(ptr noundef nonnull %11)
  %703 = getelementptr inbounds i8, ptr %702, i64 8
  store double %700, ptr %702, align 8
  store double %701, ptr %703, align 8
  %704 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %704, ptr %684, align 8, !tbaa !13
  %.pre1278 = load i32, ptr %1, align 4, !tbaa !5
  %.not11101180 = icmp slt i32 %.pre1278, 3
  br i1 %.not11101180, label %._crit_edge1184, label %.lr.ph1183.preheader

.lr.ph1183.preheader:                             ; preds = %667
  %705 = add nuw i32 %.pre1278, 1
  %wide.trip.count1256 = zext i32 %705 to i64
  %invariant.gep1354 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %invariant.gep1356 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %invariant.gep1358 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  br label %.lr.ph1183

.lr.ph1183:                                       ; preds = %.lr.ph1183.preheader, %.lr.ph1183
  %indvars.iv1253 = phi i64 [ 3, %.lr.ph1183.preheader ], [ %indvars.iv.next1254, %.lr.ph1183 ]
  %706 = add nsw i64 %indvars.iv1253, -1
  %707 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %706
  %708 = call { double, double } @Cd(ptr noundef nonnull %707)
  %709 = extractvalue { double, double } %708, 0
  %710 = extractvalue { double, double } %708, 1
  %711 = fneg double %710
  %712 = call ptr @_pCd(ptr noundef nonnull %15)
  %713 = getelementptr inbounds i8, ptr %712, i64 8
  store double %709, ptr %712, align 8
  store double %711, ptr %713, align 8
  %714 = load <2 x double>, ptr %15, align 16
  %gep1355 = getelementptr %struct.doublecomplex, ptr %invariant.gep1354, i64 %706
  %715 = load double, ptr %640, align 8, !tbaa !12
  %716 = fneg double %715
  %717 = load <2 x double>, ptr %gep1355, align 8, !tbaa !13
  %718 = insertelement <2 x double> poison, double %715, i64 0
  %719 = insertelement <2 x double> %718, double %716, i64 1
  %720 = fmul <2 x double> %717, %719
  %721 = shufflevector <2 x double> %720, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %722 = shufflevector <2 x double> %714, <2 x double> poison, <2 x i32> zeroinitializer
  %723 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %722, <2 x double> %717, <2 x double> %721)
  store <2 x double> %723, ptr %14, align 16, !tbaa !13
  %gep1357 = getelementptr %struct.doublecomplex, ptr %invariant.gep1356, i64 %indvars.iv1253
  %724 = load <2 x double>, ptr %gep1357, align 8, !tbaa !13
  %725 = fsub <2 x double> %724, %723
  store <2 x double> %725, ptr %13, align 16, !tbaa !13
  %726 = add nsw i64 %indvars.iv1253, -2
  %727 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %726
  %728 = call { double, double } @Cd(ptr noundef nonnull %727)
  %729 = extractvalue { double, double } %728, 0
  %730 = extractvalue { double, double } %728, 1
  %731 = fneg double %730
  %732 = call ptr @_pCd(ptr noundef nonnull %16)
  %733 = getelementptr inbounds i8, ptr %732, i64 8
  store double %729, ptr %732, align 8
  store double %731, ptr %733, align 8
  %734 = load <2 x double>, ptr %16, align 16
  %gep1359 = getelementptr %struct.doublecomplex, ptr %invariant.gep1358, i64 %726
  %735 = load double, ptr %641, align 8, !tbaa !12
  %736 = fneg double %735
  %737 = load <2 x double>, ptr %gep1359, align 8, !tbaa !13
  %738 = insertelement <2 x double> poison, double %735, i64 0
  %739 = insertelement <2 x double> %738, double %736, i64 1
  %740 = fmul <2 x double> %737, %739
  %741 = shufflevector <2 x double> %740, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %742 = shufflevector <2 x double> %734, <2 x double> poison, <2 x i32> zeroinitializer
  %743 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %742, <2 x double> %737, <2 x double> %741)
  %744 = load <2 x double>, ptr %13, align 16, !tbaa !13
  %745 = fsub <2 x double> %744, %743
  store <2 x double> %745, ptr %12, align 16, !tbaa !13
  %746 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1253
  %747 = call { double, double } @Cd(ptr noundef nonnull %746)
  %748 = extractvalue { double, double } %747, 0
  %749 = extractvalue { double, double } %747, 1
  %750 = fneg double %749
  %751 = call ptr @_pCd(ptr noundef nonnull %17)
  %752 = getelementptr inbounds i8, ptr %751, i64 8
  store double %748, ptr %751, align 8
  store double %750, ptr %752, align 8
  %753 = call { double, double } @Cd(ptr noundef nonnull %12)
  %754 = extractvalue { double, double } %753, 0
  %755 = extractvalue { double, double } %753, 1
  %756 = call { double, double } @Cd(ptr noundef nonnull %17)
  %757 = extractvalue { double, double } %756, 0
  %758 = extractvalue { double, double } %756, 1
  %759 = call { double, double } @__divdc3(double noundef %754, double noundef %755, double noundef %757, double noundef %758) #4
  %760 = extractvalue { double, double } %759, 0
  %761 = extractvalue { double, double } %759, 1
  %762 = call ptr @_pCd(ptr noundef nonnull %11)
  %763 = getelementptr inbounds i8, ptr %762, i64 8
  store double %760, ptr %762, align 8
  store double %761, ptr %763, align 8
  %764 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %764, ptr %gep1357, align 8, !tbaa !13
  %indvars.iv.next1254 = add nuw nsw i64 %indvars.iv1253, 1
  %exitcond1257.not = icmp eq i64 %indvars.iv.next1254, %wide.trip.count1256
  br i1 %exitcond1257.not, label %._crit_edge1184.loopexit, label %.lr.ph1183, !llvm.loop !25

._crit_edge1184.loopexit:                         ; preds = %.lr.ph1183
  %.pre1279 = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge1184

._crit_edge1184:                                  ; preds = %._crit_edge1184.loopexit, %667
  %765 = phi i32 [ %.pre1279, %._crit_edge1184.loopexit ], [ %.pre1278, %667 ]
  %766 = icmp sgt i32 %765, 1
  br i1 %766, label %.lr.ph1189.preheader, label %._crit_edge1190

.lr.ph1189.preheader:                             ; preds = %._crit_edge1184
  %767 = zext nneg i32 %765 to i64
  %invariant.gep1360 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %invariant.gep1362 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %invariant.gep1364 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  %invariant.gep1366 = getelementptr %struct.doublecomplex, ptr %25, i64 %644
  br label %.lr.ph1189

.lr.ph1189:                                       ; preds = %.lr.ph1189.preheader, %812
  %indvars.iv1258 = phi i64 [ %767, %.lr.ph1189.preheader ], [ %indvars.iv.next1259, %812 ]
  %indvars.iv.next1259 = add nsw i64 %indvars.iv1258, -1
  %768 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv.next1259
  %769 = load i32, ptr %768, align 4, !tbaa !5
  %770 = zext i32 %769 to i64
  %771 = icmp eq i64 %indvars.iv.next1259, %770
  br i1 %771, label %772, label %792

772:                                              ; preds = %.lr.ph1189
  %773 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1259
  %774 = call { double, double } @Cd(ptr noundef nonnull %773)
  %775 = extractvalue { double, double } %774, 0
  %776 = extractvalue { double, double } %774, 1
  %777 = fneg double %776
  %778 = call ptr @_pCd(ptr noundef nonnull %13)
  %779 = getelementptr inbounds i8, ptr %778, i64 8
  store double %775, ptr %778, align 8
  store double %777, ptr %779, align 8
  %780 = load <2 x double>, ptr %13, align 16
  %gep1365 = getelementptr %struct.doublecomplex, ptr %invariant.gep1364, i64 %indvars.iv1258
  %781 = load double, ptr %638, align 8, !tbaa !12
  %782 = fneg double %781
  %gep1367 = getelementptr %struct.doublecomplex, ptr %invariant.gep1366, i64 %indvars.iv.next1259
  %783 = load <2 x double>, ptr %gep1365, align 8, !tbaa !13
  %784 = insertelement <2 x double> poison, double %781, i64 0
  %785 = insertelement <2 x double> %784, double %782, i64 1
  %786 = fmul <2 x double> %783, %785
  %787 = shufflevector <2 x double> %786, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %788 = shufflevector <2 x double> %780, <2 x double> poison, <2 x i32> zeroinitializer
  %789 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %788, <2 x double> %783, <2 x double> %787)
  store <2 x double> %789, ptr %12, align 16, !tbaa !13
  %790 = load <2 x double>, ptr %gep1367, align 8, !tbaa !13
  %791 = fsub <2 x double> %790, %789
  store <2 x double> %791, ptr %gep1367, align 8, !tbaa !13
  br label %812

792:                                              ; preds = %.lr.ph1189
  %gep1361 = getelementptr %struct.doublecomplex, ptr %invariant.gep1360, i64 %indvars.iv1258
  %793 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1259
  %gep1363 = getelementptr %struct.doublecomplex, ptr %invariant.gep1362, i64 %indvars.iv.next1259
  %794 = load <2 x double>, ptr %gep1361, align 8, !tbaa !13
  %795 = call { double, double } @Cd(ptr noundef nonnull %793)
  %796 = extractvalue { double, double } %795, 0
  %797 = extractvalue { double, double } %795, 1
  %798 = fneg double %797
  %799 = call ptr @_pCd(ptr noundef nonnull %13)
  %800 = getelementptr inbounds i8, ptr %799, i64 8
  store double %796, ptr %799, align 8
  store double %798, ptr %800, align 8
  %801 = load <2 x double>, ptr %13, align 16
  %802 = load double, ptr %638, align 8, !tbaa !12
  %803 = fneg double %802
  %804 = insertelement <2 x double> poison, double %802, i64 0
  %805 = insertelement <2 x double> %804, double %803, i64 1
  %806 = fmul <2 x double> %794, %805
  %807 = shufflevector <2 x double> %806, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %808 = shufflevector <2 x double> %801, <2 x double> poison, <2 x i32> zeroinitializer
  %809 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %808, <2 x double> %794, <2 x double> %807)
  store <2 x double> %809, ptr %12, align 16, !tbaa !13
  %810 = load <2 x double>, ptr %gep1363, align 8, !tbaa !13
  %811 = fsub <2 x double> %810, %809
  store <2 x double> %811, ptr %gep1361, align 8, !tbaa !13
  store <2 x double> %794, ptr %gep1363, align 8, !tbaa !13
  br label %812

812:                                              ; preds = %772, %792
  %813 = phi <2 x double> [ %791, %772 ], [ %811, %792 ]
  store <2 x double> %813, ptr %11, align 16
  %814 = icmp ugt i64 %indvars.iv1258, 2
  br i1 %814, label %.lr.ph1189, label %._crit_edge1190, !llvm.loop !26

._crit_edge1190:                                  ; preds = %812, %.preheader, %._crit_edge1184
  %815 = load i32, ptr %2, align 4, !tbaa !5
  %816 = sext i32 %815 to i64
  %817 = icmp slt i64 %indvars.iv1261, %816
  %indvars.iv.next1262 = add nuw nsw i64 %indvars.iv1261, 1
  br i1 %817, label %.preheader, label %.loopexit

818:                                              ; preds = %.preheader1117, %._crit_edge1178
  %indvars.iv1248 = phi i64 [ 1, %.preheader1117 ], [ %indvars.iv.next1249, %._crit_edge1178 ]
  %819 = mul nsw i64 %indvars.iv1248, %642
  %820 = call { double, double } @Cd(ptr noundef %4)
  %821 = extractvalue { double, double } %820, 0
  %822 = extractvalue { double, double } %820, 1
  %823 = fneg double %822
  %824 = call ptr @_pCd(ptr noundef nonnull %12)
  %825 = getelementptr inbounds i8, ptr %824, i64 8
  store double %821, ptr %824, align 8
  store double %823, ptr %825, align 8
  %826 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %827 = getelementptr i8, ptr %826, i64 16
  %828 = call { double, double } @Cd(ptr noundef %827)
  %829 = extractvalue { double, double } %828, 0
  %830 = extractvalue { double, double } %828, 1
  %831 = call { double, double } @Cd(ptr noundef nonnull %12)
  %832 = extractvalue { double, double } %831, 0
  %833 = extractvalue { double, double } %831, 1
  %834 = call { double, double } @__divdc3(double noundef %829, double noundef %830, double noundef %832, double noundef %833) #4
  %835 = extractvalue { double, double } %834, 0
  %836 = extractvalue { double, double } %834, 1
  %837 = call ptr @_pCd(ptr noundef nonnull %11)
  %838 = getelementptr inbounds i8, ptr %837, i64 8
  store double %835, ptr %837, align 8
  store double %836, ptr %838, align 8
  %839 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %839, ptr %827, align 8, !tbaa !13
  %840 = load i32, ptr %1, align 4, !tbaa !5
  %841 = icmp sgt i32 %840, 1
  br i1 %841, label %842, label %._crit_edge1178

842:                                              ; preds = %818
  %843 = call { double, double } @Cd(ptr noundef %5)
  %844 = extractvalue { double, double } %843, 0
  %845 = extractvalue { double, double } %843, 1
  %846 = fneg double %845
  %847 = call ptr @_pCd(ptr noundef nonnull %14)
  %848 = getelementptr inbounds i8, ptr %847, i64 8
  store double %844, ptr %847, align 8
  store double %846, ptr %848, align 8
  %849 = load <2 x double>, ptr %14, align 16
  %850 = load double, ptr %637, align 8, !tbaa !12
  %851 = fneg double %850
  %852 = load <2 x double>, ptr %827, align 8, !tbaa !13
  %853 = insertelement <2 x double> poison, double %850, i64 0
  %854 = insertelement <2 x double> %853, double %851, i64 1
  %855 = fmul <2 x double> %852, %854
  %856 = shufflevector <2 x double> %855, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %857 = shufflevector <2 x double> %849, <2 x double> poison, <2 x i32> zeroinitializer
  %858 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %857, <2 x double> %852, <2 x double> %856)
  store <2 x double> %858, ptr %13, align 16, !tbaa !13
  %859 = getelementptr i8, ptr %826, i64 32
  %860 = load <2 x double>, ptr %859, align 8, !tbaa !13
  %861 = fsub <2 x double> %860, %858
  store <2 x double> %861, ptr %12, align 16, !tbaa !13
  %862 = call { double, double } @Cd(ptr noundef nonnull %639)
  %863 = extractvalue { double, double } %862, 0
  %864 = extractvalue { double, double } %862, 1
  %865 = fneg double %864
  %866 = call ptr @_pCd(ptr noundef nonnull %15)
  %867 = getelementptr inbounds i8, ptr %866, i64 8
  store double %863, ptr %866, align 8
  store double %865, ptr %867, align 8
  %868 = call { double, double } @Cd(ptr noundef nonnull %12)
  %869 = extractvalue { double, double } %868, 0
  %870 = extractvalue { double, double } %868, 1
  %871 = call { double, double } @Cd(ptr noundef nonnull %15)
  %872 = extractvalue { double, double } %871, 0
  %873 = extractvalue { double, double } %871, 1
  %874 = call { double, double } @__divdc3(double noundef %869, double noundef %870, double noundef %872, double noundef %873) #4
  %875 = extractvalue { double, double } %874, 0
  %876 = extractvalue { double, double } %874, 1
  %877 = call ptr @_pCd(ptr noundef nonnull %11)
  %878 = getelementptr inbounds i8, ptr %877, i64 8
  store double %875, ptr %877, align 8
  store double %876, ptr %878, align 8
  %879 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %879, ptr %859, align 8, !tbaa !13
  %.pre1276 = load i32, ptr %1, align 4, !tbaa !5
  %.not11091168 = icmp slt i32 %.pre1276, 3
  br i1 %.not11091168, label %._crit_edge1172, label %.lr.ph1171.preheader

.lr.ph1171.preheader:                             ; preds = %842
  %880 = add nuw i32 %.pre1276, 1
  %wide.trip.count1243 = zext i32 %880 to i64
  %invariant.gep1340 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %invariant.gep1342 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %invariant.gep1344 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  br label %.lr.ph1171

.lr.ph1171:                                       ; preds = %.lr.ph1171.preheader, %.lr.ph1171
  %indvars.iv1240 = phi i64 [ 3, %.lr.ph1171.preheader ], [ %indvars.iv.next1241, %.lr.ph1171 ]
  %881 = add nsw i64 %indvars.iv1240, -1
  %882 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %881
  %883 = call { double, double } @Cd(ptr noundef nonnull %882)
  %884 = extractvalue { double, double } %883, 0
  %885 = extractvalue { double, double } %883, 1
  %886 = fneg double %885
  %887 = call ptr @_pCd(ptr noundef nonnull %15)
  %888 = getelementptr inbounds i8, ptr %887, i64 8
  store double %884, ptr %887, align 8
  store double %886, ptr %888, align 8
  %889 = load <2 x double>, ptr %15, align 16
  %gep1341 = getelementptr %struct.doublecomplex, ptr %invariant.gep1340, i64 %881
  %890 = load double, ptr %640, align 8, !tbaa !12
  %891 = fneg double %890
  %892 = load <2 x double>, ptr %gep1341, align 8, !tbaa !13
  %893 = insertelement <2 x double> poison, double %890, i64 0
  %894 = insertelement <2 x double> %893, double %891, i64 1
  %895 = fmul <2 x double> %892, %894
  %896 = shufflevector <2 x double> %895, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %897 = shufflevector <2 x double> %889, <2 x double> poison, <2 x i32> zeroinitializer
  %898 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %897, <2 x double> %892, <2 x double> %896)
  store <2 x double> %898, ptr %14, align 16, !tbaa !13
  %gep1343 = getelementptr %struct.doublecomplex, ptr %invariant.gep1342, i64 %indvars.iv1240
  %899 = load <2 x double>, ptr %gep1343, align 8, !tbaa !13
  %900 = fsub <2 x double> %899, %898
  store <2 x double> %900, ptr %13, align 16, !tbaa !13
  %901 = add nsw i64 %indvars.iv1240, -2
  %902 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %901
  %903 = call { double, double } @Cd(ptr noundef nonnull %902)
  %904 = extractvalue { double, double } %903, 0
  %905 = extractvalue { double, double } %903, 1
  %906 = fneg double %905
  %907 = call ptr @_pCd(ptr noundef nonnull %16)
  %908 = getelementptr inbounds i8, ptr %907, i64 8
  store double %904, ptr %907, align 8
  store double %906, ptr %908, align 8
  %909 = load <2 x double>, ptr %16, align 16
  %gep1345 = getelementptr %struct.doublecomplex, ptr %invariant.gep1344, i64 %901
  %910 = load double, ptr %641, align 8, !tbaa !12
  %911 = fneg double %910
  %912 = load <2 x double>, ptr %gep1345, align 8, !tbaa !13
  %913 = insertelement <2 x double> poison, double %910, i64 0
  %914 = insertelement <2 x double> %913, double %911, i64 1
  %915 = fmul <2 x double> %912, %914
  %916 = shufflevector <2 x double> %915, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %917 = shufflevector <2 x double> %909, <2 x double> poison, <2 x i32> zeroinitializer
  %918 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %917, <2 x double> %912, <2 x double> %916)
  %919 = load <2 x double>, ptr %13, align 16, !tbaa !13
  %920 = fsub <2 x double> %919, %918
  store <2 x double> %920, ptr %12, align 16, !tbaa !13
  %921 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1240
  %922 = call { double, double } @Cd(ptr noundef nonnull %921)
  %923 = extractvalue { double, double } %922, 0
  %924 = extractvalue { double, double } %922, 1
  %925 = fneg double %924
  %926 = call ptr @_pCd(ptr noundef nonnull %17)
  %927 = getelementptr inbounds i8, ptr %926, i64 8
  store double %923, ptr %926, align 8
  store double %925, ptr %927, align 8
  %928 = call { double, double } @Cd(ptr noundef nonnull %12)
  %929 = extractvalue { double, double } %928, 0
  %930 = extractvalue { double, double } %928, 1
  %931 = call { double, double } @Cd(ptr noundef nonnull %17)
  %932 = extractvalue { double, double } %931, 0
  %933 = extractvalue { double, double } %931, 1
  %934 = call { double, double } @__divdc3(double noundef %929, double noundef %930, double noundef %932, double noundef %933) #4
  %935 = extractvalue { double, double } %934, 0
  %936 = extractvalue { double, double } %934, 1
  %937 = call ptr @_pCd(ptr noundef nonnull %11)
  %938 = getelementptr inbounds i8, ptr %937, i64 8
  store double %935, ptr %937, align 8
  store double %936, ptr %938, align 8
  %939 = load <2 x double>, ptr %11, align 16, !tbaa !13
  store <2 x double> %939, ptr %gep1343, align 8, !tbaa !13
  %indvars.iv.next1241 = add nuw nsw i64 %indvars.iv1240, 1
  %exitcond1244.not = icmp eq i64 %indvars.iv.next1241, %wide.trip.count1243
  br i1 %exitcond1244.not, label %._crit_edge1172.loopexit, label %.lr.ph1171, !llvm.loop !27

._crit_edge1172.loopexit:                         ; preds = %.lr.ph1171
  %.pre1277 = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge1172

._crit_edge1172:                                  ; preds = %._crit_edge1172.loopexit, %842
  %940 = phi i32 [ %.pre1277, %._crit_edge1172.loopexit ], [ %.pre1276, %842 ]
  %941 = icmp sgt i32 %940, 1
  br i1 %941, label %.lr.ph1177.preheader, label %._crit_edge1178

.lr.ph1177.preheader:                             ; preds = %._crit_edge1172
  %942 = zext nneg i32 %940 to i64
  %invariant.gep1346 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %invariant.gep1348 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %invariant.gep1350 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  %invariant.gep1352 = getelementptr %struct.doublecomplex, ptr %25, i64 %819
  br label %.lr.ph1177

.lr.ph1177:                                       ; preds = %.lr.ph1177.preheader, %987
  %indvars.iv1245 = phi i64 [ %942, %.lr.ph1177.preheader ], [ %indvars.iv.next1246, %987 ]
  %indvars.iv.next1246 = add nsw i64 %indvars.iv1245, -1
  %943 = getelementptr inbounds i32, ptr %22, i64 %indvars.iv.next1246
  %944 = load i32, ptr %943, align 4, !tbaa !5
  %945 = zext i32 %944 to i64
  %946 = icmp eq i64 %indvars.iv.next1246, %945
  br i1 %946, label %947, label %967

947:                                              ; preds = %.lr.ph1177
  %948 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1246
  %949 = call { double, double } @Cd(ptr noundef nonnull %948)
  %950 = extractvalue { double, double } %949, 0
  %951 = extractvalue { double, double } %949, 1
  %952 = fneg double %951
  %953 = call ptr @_pCd(ptr noundef nonnull %13)
  %954 = getelementptr inbounds i8, ptr %953, i64 8
  store double %950, ptr %953, align 8
  store double %952, ptr %954, align 8
  %955 = load <2 x double>, ptr %13, align 16
  %gep1351 = getelementptr %struct.doublecomplex, ptr %invariant.gep1350, i64 %indvars.iv1245
  %956 = load double, ptr %638, align 8, !tbaa !12
  %957 = fneg double %956
  %gep1353 = getelementptr %struct.doublecomplex, ptr %invariant.gep1352, i64 %indvars.iv.next1246
  %958 = load <2 x double>, ptr %gep1351, align 8, !tbaa !13
  %959 = insertelement <2 x double> poison, double %956, i64 0
  %960 = insertelement <2 x double> %959, double %957, i64 1
  %961 = fmul <2 x double> %958, %960
  %962 = shufflevector <2 x double> %961, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %963 = shufflevector <2 x double> %955, <2 x double> poison, <2 x i32> zeroinitializer
  %964 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %963, <2 x double> %958, <2 x double> %962)
  store <2 x double> %964, ptr %12, align 16, !tbaa !13
  %965 = load <2 x double>, ptr %gep1353, align 8, !tbaa !13
  %966 = fsub <2 x double> %965, %964
  store <2 x double> %966, ptr %gep1353, align 8, !tbaa !13
  br label %987

967:                                              ; preds = %.lr.ph1177
  %gep1347 = getelementptr %struct.doublecomplex, ptr %invariant.gep1346, i64 %indvars.iv1245
  %968 = getelementptr inbounds %struct.doublecomplex, ptr %18, i64 %indvars.iv.next1246
  %gep1349 = getelementptr %struct.doublecomplex, ptr %invariant.gep1348, i64 %indvars.iv.next1246
  %969 = load <2 x double>, ptr %gep1347, align 8, !tbaa !13
  %970 = call { double, double } @Cd(ptr noundef nonnull %968)
  %971 = extractvalue { double, double } %970, 0
  %972 = extractvalue { double, double } %970, 1
  %973 = fneg double %972
  %974 = call ptr @_pCd(ptr noundef nonnull %13)
  %975 = getelementptr inbounds i8, ptr %974, i64 8
  store double %971, ptr %974, align 8
  store double %973, ptr %975, align 8
  %976 = load <2 x double>, ptr %13, align 16
  %977 = load double, ptr %638, align 8, !tbaa !12
  %978 = fneg double %977
  %979 = insertelement <2 x double> poison, double %977, i64 0
  %980 = insertelement <2 x double> %979, double %978, i64 1
  %981 = fmul <2 x double> %969, %980
  %982 = shufflevector <2 x double> %981, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %983 = shufflevector <2 x double> %976, <2 x double> poison, <2 x i32> zeroinitializer
  %984 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %983, <2 x double> %969, <2 x double> %982)
  store <2 x double> %984, ptr %12, align 16, !tbaa !13
  %985 = load <2 x double>, ptr %gep1349, align 8, !tbaa !13
  %986 = fsub <2 x double> %985, %984
  store <2 x double> %986, ptr %gep1347, align 8, !tbaa !13
  store <2 x double> %969, ptr %gep1349, align 8, !tbaa !13
  br label %987

987:                                              ; preds = %947, %967
  %988 = phi <2 x double> [ %966, %947 ], [ %986, %967 ]
  store <2 x double> %988, ptr %11, align 16
  %989 = icmp ugt i64 %indvars.iv1245, 2
  br i1 %989, label %.lr.ph1177, label %._crit_edge1178, !llvm.loop !28

._crit_edge1178:                                  ; preds = %987, %818, %._crit_edge1172
  %indvars.iv.next1249 = add nuw nsw i64 %indvars.iv1248, 1
  %exitcond1252.not = icmp eq i64 %indvars.iv.next1249, %wide.trip.count1251
  br i1 %exitcond1252.not, label %.loopexit, label %818, !llvm.loop !29

.loopexit:                                        ; preds = %._crit_edge1134, %._crit_edge1146, %._crit_edge1155, %._crit_edge1165, %._crit_edge1178, %._crit_edge1190, %10, %28
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %15) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %13) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %12) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %11) #4
  ret void
}

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

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

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

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

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

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

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


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