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

; 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 }

@c__1 = external hidden global i32, align 4
@.str = external hidden unnamed_addr constant [13 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@c__2 = external hidden global i32, align 4

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

126:                                              ; preds = %13
  store i32 1, ptr %90, align 4
  br label %3404

127:                                              ; preds = %13
  %128 = load ptr, ptr %17, align 8, !tbaa !5
  %129 = load i32, ptr %128, align 4, !tbaa !9
  %130 = load ptr, ptr %18, align 8, !tbaa !5
  %131 = load i32, ptr %130, align 4, !tbaa !9
  %132 = icmp eq i32 %129, %131
  br i1 %132, label %133, label %165

133:                                              ; preds = %127
  %134 = load ptr, ptr %17, align 8, !tbaa !5
  %135 = load i32, ptr %134, align 4, !tbaa !9
  store i32 %135, ptr %31, align 4, !tbaa !9
  %136 = load ptr, ptr %17, align 8, !tbaa !5
  %137 = load i32, ptr %136, align 4, !tbaa !9
  %138 = load ptr, ptr %17, align 8, !tbaa !5
  %139 = load i32, ptr %138, align 4, !tbaa !9
  %140 = load i32, ptr %27, align 4, !tbaa !9
  %141 = mul nsw i32 %139, %140
  %142 = add nsw i32 %137, %141
  store i32 %142, ptr %32, align 4, !tbaa !9
  %143 = load ptr, ptr %19, align 8, !tbaa !5
  %144 = load i32, ptr %32, 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 %21, align 8, !tbaa !5
  %150 = load i32, ptr %31, 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 0
  store double %148, ptr %153, align 8, !tbaa !11
  %154 = load ptr, ptr %19, align 8, !tbaa !5
  %155 = load i32, ptr %32, align 4, !tbaa !9
  %156 = sext i32 %155 to i64
  %157 = getelementptr inbounds %struct.doublecomplex, ptr %154, i64 %156
  %158 = getelementptr inbounds %struct.doublecomplex, ptr %157, i32 0, i32 1
  %159 = load double, ptr %158, align 8, !tbaa !14
  %160 = load ptr, ptr %21, align 8, !tbaa !5
  %161 = load i32, ptr %31, align 4, !tbaa !9
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds %struct.doublecomplex, ptr %160, i64 %162
  %164 = getelementptr inbounds %struct.doublecomplex, ptr %163, i32 0, i32 1
  store double %159, ptr %164, align 8, !tbaa !14
  store i32 1, ptr %90, align 4
  br label %3404

165:                                              ; preds = %127
  %166 = load ptr, ptr %18, align 8, !tbaa !5
  %167 = load i32, ptr %166, align 4, !tbaa !9
  %168 = sub nsw i32 %167, 3
  store i32 %168, ptr %31, align 4, !tbaa !9
  %169 = load ptr, ptr %17, align 8, !tbaa !5
  %170 = load i32, ptr %169, align 4, !tbaa !9
  store i32 %170, ptr %51, align 4, !tbaa !9
  br label %171

171:                                              ; preds = %208, %165
  %172 = load i32, ptr %51, align 4, !tbaa !9
  %173 = load i32, ptr %31, align 4, !tbaa !9
  %174 = icmp sle i32 %172, %173
  br i1 %174, label %175, label %211

175:                                              ; preds = %171
  %176 = load i32, ptr %51, align 4, !tbaa !9
  %177 = add nsw i32 %176, 2
  %178 = load i32, ptr %51, align 4, !tbaa !9
  %179 = load i32, ptr %27, align 4, !tbaa !9
  %180 = mul nsw i32 %178, %179
  %181 = add nsw i32 %177, %180
  store i32 %181, ptr %32, align 4, !tbaa !9
  %182 = load ptr, ptr %19, align 8, !tbaa !5
  %183 = load i32, ptr %32, align 4, !tbaa !9
  %184 = sext i32 %183 to i64
  %185 = getelementptr inbounds %struct.doublecomplex, ptr %182, i64 %184
  %186 = getelementptr inbounds %struct.doublecomplex, ptr %185, i32 0, i32 0
  store double 0.000000e+00, ptr %186, align 8, !tbaa !11
  %187 = load ptr, ptr %19, align 8, !tbaa !5
  %188 = load i32, ptr %32, align 4, !tbaa !9
  %189 = sext i32 %188 to i64
  %190 = getelementptr inbounds %struct.doublecomplex, ptr %187, i64 %189
  %191 = getelementptr inbounds %struct.doublecomplex, ptr %190, i32 0, i32 1
  store double 0.000000e+00, ptr %191, align 8, !tbaa !14
  %192 = load i32, ptr %51, align 4, !tbaa !9
  %193 = add nsw i32 %192, 3
  %194 = load i32, ptr %51, align 4, !tbaa !9
  %195 = load i32, ptr %27, align 4, !tbaa !9
  %196 = mul nsw i32 %194, %195
  %197 = add nsw i32 %193, %196
  store i32 %197, ptr %32, align 4, !tbaa !9
  %198 = load ptr, ptr %19, align 8, !tbaa !5
  %199 = load i32, ptr %32, align 4, !tbaa !9
  %200 = sext i32 %199 to i64
  %201 = getelementptr inbounds %struct.doublecomplex, ptr %198, i64 %200
  %202 = getelementptr inbounds %struct.doublecomplex, ptr %201, i32 0, i32 0
  store double 0.000000e+00, ptr %202, align 8, !tbaa !11
  %203 = load ptr, ptr %19, align 8, !tbaa !5
  %204 = load i32, ptr %32, align 4, !tbaa !9
  %205 = sext i32 %204 to i64
  %206 = getelementptr inbounds %struct.doublecomplex, ptr %203, i64 %205
  %207 = getelementptr inbounds %struct.doublecomplex, ptr %206, i32 0, i32 1
  store double 0.000000e+00, ptr %207, align 8, !tbaa !14
  br label %208

208:                                              ; preds = %175
  %209 = load i32, ptr %51, align 4, !tbaa !9
  %210 = add nsw i32 %209, 1
  store i32 %210, ptr %51, align 4, !tbaa !9
  br label %171, !llvm.loop !15

211:                                              ; preds = %171
  %212 = load ptr, ptr %17, align 8, !tbaa !5
  %213 = load i32, ptr %212, align 4, !tbaa !9
  %214 = load ptr, ptr %18, align 8, !tbaa !5
  %215 = load i32, ptr %214, align 4, !tbaa !9
  %216 = sub nsw i32 %215, 2
  %217 = icmp sle i32 %213, %216
  br i1 %217, label %218, label %237

218:                                              ; preds = %211
  %219 = load ptr, ptr %18, align 8, !tbaa !5
  %220 = load i32, ptr %219, align 4, !tbaa !9
  %221 = load ptr, ptr %18, align 8, !tbaa !5
  %222 = load i32, ptr %221, align 4, !tbaa !9
  %223 = sub nsw i32 %222, 2
  %224 = load i32, ptr %27, align 4, !tbaa !9
  %225 = mul nsw i32 %223, %224
  %226 = add nsw i32 %220, %225
  store i32 %226, ptr %31, align 4, !tbaa !9
  %227 = load ptr, ptr %19, align 8, !tbaa !5
  %228 = load i32, ptr %31, align 4, !tbaa !9
  %229 = sext i32 %228 to i64
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %227, i64 %229
  %231 = getelementptr inbounds %struct.doublecomplex, ptr %230, i32 0, i32 0
  store double 0.000000e+00, ptr %231, align 8, !tbaa !11
  %232 = load ptr, ptr %19, align 8, !tbaa !5
  %233 = load i32, ptr %31, align 4, !tbaa !9
  %234 = sext i32 %233 to i64
  %235 = getelementptr inbounds %struct.doublecomplex, ptr %232, i64 %234
  %236 = getelementptr inbounds %struct.doublecomplex, ptr %235, i32 0, i32 1
  store double 0.000000e+00, ptr %236, align 8, !tbaa !14
  br label %237

237:                                              ; preds = %218, %211
  %238 = load ptr, ptr %14, align 8, !tbaa !5
  %239 = load i32, ptr %238, align 4, !tbaa !9
  %240 = icmp ne i32 %239, 0
  br i1 %240, label %241, label %244

241:                                              ; preds = %237
  store i32 1, ptr %85, align 4, !tbaa !9
  %242 = load ptr, ptr %16, align 8, !tbaa !5
  %243 = load i32, ptr %242, align 4, !tbaa !9
  store i32 %243, ptr %83, align 4, !tbaa !9
  br label %249

244:                                              ; preds = %237
  %245 = load ptr, ptr %17, align 8, !tbaa !5
  %246 = load i32, ptr %245, align 4, !tbaa !9
  store i32 %246, ptr %85, align 4, !tbaa !9
  %247 = load ptr, ptr %18, align 8, !tbaa !5
  %248 = load i32, ptr %247, align 4, !tbaa !9
  store i32 %248, ptr %83, align 4, !tbaa !9
  br label %249

249:                                              ; preds = %244, %241
  %250 = load ptr, ptr %18, align 8, !tbaa !5
  %251 = load i32, ptr %250, align 4, !tbaa !9
  store i32 %251, ptr %31, align 4, !tbaa !9
  %252 = load ptr, ptr %17, align 8, !tbaa !5
  %253 = load i32, ptr %252, align 4, !tbaa !9
  %254 = add nsw i32 %253, 1
  store i32 %254, ptr %50, align 4, !tbaa !9
  br label %255

255:                                              ; preds = %487, %249
  %256 = load i32, ptr %50, align 4, !tbaa !9
  %257 = load i32, ptr %31, align 4, !tbaa !9
  %258 = icmp sle i32 %256, %257
  br i1 %258, label %259, label %490

259:                                              ; preds = %255
  %260 = load ptr, ptr %19, align 8, !tbaa !5
  %261 = load i32, ptr %50, align 4, !tbaa !9
  %262 = load i32, ptr %50, align 4, !tbaa !9
  %263 = sub nsw i32 %262, 1
  %264 = load i32, ptr %27, align 4, !tbaa !9
  %265 = mul nsw i32 %263, %264
  %266 = add nsw i32 %261, %265
  %267 = sext i32 %266 to i64
  %268 = getelementptr inbounds %struct.doublecomplex, ptr %260, i64 %267
  %269 = call { double, double } @Cd(ptr noundef %268)
  %270 = extractvalue { double, double } %269, 0
  %271 = extractvalue { double, double } %269, 1
  %272 = fcmp une double %271, 0.000000e+00
  br i1 %272, label %273, label %486

273:                                              ; preds = %259
  %274 = load i32, ptr %50, align 4, !tbaa !9
  %275 = load i32, ptr %50, align 4, !tbaa !9
  %276 = sub nsw i32 %275, 1
  %277 = load i32, ptr %27, align 4, !tbaa !9
  %278 = mul nsw i32 %276, %277
  %279 = add nsw i32 %274, %278
  store i32 %279, ptr %32, align 4, !tbaa !9
  %280 = load i32, ptr %50, align 4, !tbaa !9
  %281 = load i32, ptr %50, align 4, !tbaa !9
  %282 = sub nsw i32 %281, 1
  %283 = load i32, ptr %27, align 4, !tbaa !9
  %284 = mul nsw i32 %282, %283
  %285 = add nsw i32 %280, %284
  store i32 %285, ptr %33, align 4, !tbaa !9
  %286 = load ptr, ptr %19, align 8, !tbaa !5
  %287 = load i32, ptr %33, align 4, !tbaa !9
  %288 = sext i32 %287 to i64
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %286, i64 %288
  %290 = getelementptr inbounds %struct.doublecomplex, ptr %289, i32 0, i32 0
  %291 = load double, ptr %290, align 8, !tbaa !11
  store double %291, ptr %36, align 8, !tbaa !17
  %292 = load double, ptr %36, align 8, !tbaa !17
  %293 = fcmp oge double %292, 0.000000e+00
  br i1 %293, label %294, label %296

294:                                              ; preds = %273
  %295 = load double, ptr %36, align 8, !tbaa !17
  br label %299

296:                                              ; preds = %273
  %297 = load double, ptr %36, align 8, !tbaa !17
  %298 = fneg double %297
  br label %299

299:                                              ; preds = %296, %294
  %300 = phi double [ %295, %294 ], [ %298, %296 ]
  %301 = load ptr, ptr %19, align 8, !tbaa !5
  %302 = load i32, ptr %50, align 4, !tbaa !9
  %303 = load i32, ptr %50, align 4, !tbaa !9
  %304 = sub nsw i32 %303, 1
  %305 = load i32, ptr %27, align 4, !tbaa !9
  %306 = mul nsw i32 %304, %305
  %307 = add nsw i32 %302, %306
  %308 = sext i32 %307 to i64
  %309 = getelementptr inbounds %struct.doublecomplex, ptr %301, i64 %308
  %310 = call { double, double } @Cd(ptr noundef %309)
  %311 = extractvalue { double, double } %310, 0
  %312 = extractvalue { double, double } %310, 1
  store double %312, ptr %37, align 8, !tbaa !17
  %313 = load double, ptr %37, align 8, !tbaa !17
  %314 = fcmp oge double %313, 0.000000e+00
  br i1 %314, label %315, label %317

315:                                              ; preds = %299
  %316 = load double, ptr %37, align 8, !tbaa !17
  br label %320

317:                                              ; preds = %299
  %318 = load double, ptr %37, align 8, !tbaa !17
  %319 = fneg double %318
  br label %320

320:                                              ; preds = %317, %315
  %321 = phi double [ %316, %315 ], [ %319, %317 ]
  %322 = fadd double %300, %321
  store double %322, ptr %38, align 8, !tbaa !17
  %323 = load ptr, ptr %19, align 8, !tbaa !5
  %324 = load i32, ptr %32, align 4, !tbaa !9
  %325 = sext i32 %324 to i64
  %326 = getelementptr inbounds %struct.doublecomplex, ptr %323, i64 %325
  %327 = getelementptr inbounds %struct.doublecomplex, ptr %326, i32 0, i32 0
  %328 = load double, ptr %327, align 8, !tbaa !11
  %329 = load double, ptr %38, align 8, !tbaa !17
  %330 = fdiv double %328, %329
  %331 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %330, ptr %331, align 8, !tbaa !11
  %332 = load ptr, ptr %19, align 8, !tbaa !5
  %333 = load i32, ptr %32, align 4, !tbaa !9
  %334 = sext i32 %333 to i64
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %332, i64 %334
  %336 = getelementptr inbounds %struct.doublecomplex, ptr %335, i32 0, i32 1
  %337 = load double, ptr %336, align 8, !tbaa !14
  %338 = load double, ptr %38, align 8, !tbaa !17
  %339 = fdiv double %337, %338
  %340 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %339, ptr %340, align 8, !tbaa !14
  %341 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %342 = load double, ptr %341, align 8, !tbaa !11
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %76, i32 0, i32 0
  store double %342, ptr %343, align 8, !tbaa !11
  %344 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %345 = load double, ptr %344, align 8, !tbaa !14
  %346 = getelementptr inbounds %struct.doublecomplex, ptr %76, i32 0, i32 1
  store double %345, ptr %346, align 8, !tbaa !14
  %347 = call { double, double } @Cd(ptr noundef %76)
  %348 = extractvalue { double, double } %347, 0
  %349 = extractvalue { double, double } %347, 1
  %350 = fneg double %349
  %351 = call ptr @_pCd(ptr noundef %43)
  %352 = getelementptr inbounds { double, double }, ptr %351, i32 0, i32 0
  %353 = getelementptr inbounds { double, double }, ptr %351, i32 0, i32 1
  store double %348, ptr %352, align 8
  store double %350, ptr %353, align 8
  %354 = call { double, double } @Cd(ptr noundef %76)
  %355 = extractvalue { double, double } %354, 0
  %356 = extractvalue { double, double } %354, 1
  %357 = getelementptr inbounds { double, double }, ptr %91, i32 0, i32 0
  %358 = getelementptr inbounds { double, double }, ptr %91, i32 0, i32 1
  store double %355, ptr %357, align 8
  store double %356, ptr %358, align 8
  %359 = getelementptr inbounds { double, double }, ptr %91, i32 0, i32 0
  %360 = load double, ptr %359, align 8
  %361 = getelementptr inbounds { double, double }, ptr %91, i32 0, i32 1
  %362 = load double, ptr %361, align 8
  %363 = call double @cabs(double noundef %360, double noundef %362) #6
  store double %363, ptr %36, align 8, !tbaa !17
  %364 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %365 = load double, ptr %364, align 8, !tbaa !11
  %366 = load double, ptr %36, align 8, !tbaa !17
  %367 = fdiv double %365, %366
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %367, ptr %368, align 8, !tbaa !11
  %369 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %370 = load double, ptr %369, align 8, !tbaa !14
  %371 = load double, ptr %36, align 8, !tbaa !17
  %372 = fdiv double %370, %371
  %373 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %372, ptr %373, align 8, !tbaa !14
  %374 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %375 = load double, ptr %374, align 8, !tbaa !11
  %376 = getelementptr inbounds %struct.doublecomplex, ptr %76, i32 0, i32 0
  store double %375, ptr %376, align 8, !tbaa !11
  %377 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %378 = load double, ptr %377, align 8, !tbaa !14
  %379 = getelementptr inbounds %struct.doublecomplex, ptr %76, i32 0, i32 1
  store double %378, ptr %379, align 8, !tbaa !14
  %380 = load i32, ptr %50, align 4, !tbaa !9
  %381 = load i32, ptr %50, align 4, !tbaa !9
  %382 = sub nsw i32 %381, 1
  %383 = load i32, ptr %27, align 4, !tbaa !9
  %384 = mul nsw i32 %382, %383
  %385 = add nsw i32 %380, %384
  store i32 %385, ptr %32, align 4, !tbaa !9
  %386 = load ptr, ptr %19, align 8, !tbaa !5
  %387 = load i32, ptr %50, align 4, !tbaa !9
  %388 = load i32, ptr %50, align 4, !tbaa !9
  %389 = sub nsw i32 %388, 1
  %390 = load i32, ptr %27, align 4, !tbaa !9
  %391 = mul nsw i32 %389, %390
  %392 = add nsw i32 %387, %391
  %393 = sext i32 %392 to i64
  %394 = getelementptr inbounds %struct.doublecomplex, ptr %386, i64 %393
  %395 = call { double, double } @Cd(ptr noundef %394)
  %396 = extractvalue { double, double } %395, 0
  %397 = extractvalue { double, double } %395, 1
  %398 = getelementptr inbounds { double, double }, ptr %92, i32 0, i32 0
  %399 = getelementptr inbounds { double, double }, ptr %92, i32 0, i32 1
  store double %396, ptr %398, align 8
  store double %397, ptr %399, align 8
  %400 = getelementptr inbounds { double, double }, ptr %92, i32 0, i32 0
  %401 = load double, ptr %400, align 8
  %402 = getelementptr inbounds { double, double }, ptr %92, i32 0, i32 1
  %403 = load double, ptr %402, align 8
  %404 = call double @cabs(double noundef %401, double noundef %403) #6
  store double %404, ptr %36, align 8, !tbaa !17
  %405 = load double, ptr %36, align 8, !tbaa !17
  %406 = load ptr, ptr %19, align 8, !tbaa !5
  %407 = load i32, ptr %32, align 4, !tbaa !9
  %408 = sext i32 %407 to i64
  %409 = getelementptr inbounds %struct.doublecomplex, ptr %406, i64 %408
  %410 = getelementptr inbounds %struct.doublecomplex, ptr %409, i32 0, i32 0
  store double %405, ptr %410, align 8, !tbaa !11
  %411 = load ptr, ptr %19, align 8, !tbaa !5
  %412 = load i32, ptr %32, align 4, !tbaa !9
  %413 = sext i32 %412 to i64
  %414 = getelementptr inbounds %struct.doublecomplex, ptr %411, i64 %413
  %415 = getelementptr inbounds %struct.doublecomplex, ptr %414, i32 0, i32 1
  store double 0.000000e+00, ptr %415, align 8, !tbaa !14
  %416 = load i32, ptr %83, align 4, !tbaa !9
  %417 = load i32, ptr %50, align 4, !tbaa !9
  %418 = sub nsw i32 %416, %417
  %419 = add nsw i32 %418, 1
  store i32 %419, ptr %32, align 4, !tbaa !9
  %420 = load ptr, ptr %19, align 8, !tbaa !5
  %421 = load i32, ptr %50, align 4, !tbaa !9
  %422 = load i32, ptr %50, align 4, !tbaa !9
  %423 = load i32, ptr %27, align 4, !tbaa !9
  %424 = mul nsw i32 %422, %423
  %425 = add nsw i32 %421, %424
  %426 = sext i32 %425 to i64
  %427 = getelementptr inbounds %struct.doublecomplex, ptr %420, i64 %426
  %428 = load ptr, ptr %20, align 8, !tbaa !5
  call void @zscal_(ptr noundef %32, ptr noundef %76, ptr noundef %427, ptr noundef %428)
  %429 = load i32, ptr %83, align 4, !tbaa !9
  store i32 %429, ptr %33, align 4, !tbaa !9
  %430 = load i32, ptr %50, align 4, !tbaa !9
  %431 = add nsw i32 %430, 1
  store i32 %431, ptr %34, align 4, !tbaa !9
  %432 = load i32, ptr %33, align 4, !tbaa !9
  %433 = load i32, ptr %34, align 4, !tbaa !9
  %434 = icmp sle i32 %432, %433
  br i1 %434, label %435, label %437

435:                                              ; preds = %320
  %436 = load i32, ptr %33, align 4, !tbaa !9
  br label %439

437:                                              ; preds = %320
  %438 = load i32, ptr %34, align 4, !tbaa !9
  br label %439

439:                                              ; preds = %437, %435
  %440 = phi i32 [ %436, %435 ], [ %438, %437 ]
  %441 = load i32, ptr %85, align 4, !tbaa !9
  %442 = sub nsw i32 %440, %441
  %443 = add nsw i32 %442, 1
  store i32 %443, ptr %32, align 4, !tbaa !9
  %444 = call { double, double } @Cd(ptr noundef %76)
  %445 = extractvalue { double, double } %444, 0
  %446 = extractvalue { double, double } %444, 1
  %447 = fneg double %446
  %448 = call ptr @_pCd(ptr noundef %42)
  %449 = getelementptr inbounds { double, double }, ptr %448, i32 0, i32 0
  %450 = getelementptr inbounds { double, double }, ptr %448, i32 0, i32 1
  store double %445, ptr %449, align 8
  store double %447, ptr %450, align 8
  %451 = load ptr, ptr %19, align 8, !tbaa !5
  %452 = load i32, ptr %85, align 4, !tbaa !9
  %453 = load i32, ptr %50, align 4, !tbaa !9
  %454 = load i32, ptr %27, align 4, !tbaa !9
  %455 = mul nsw i32 %453, %454
  %456 = add nsw i32 %452, %455
  %457 = sext i32 %456 to i64
  %458 = getelementptr inbounds %struct.doublecomplex, ptr %451, i64 %457
  call void @zscal_(ptr noundef %32, ptr noundef %42, ptr noundef %458, ptr noundef @c__1)
  %459 = load ptr, ptr %15, align 8, !tbaa !5
  %460 = load i32, ptr %459, align 4, !tbaa !9
  %461 = icmp ne i32 %460, 0
  br i1 %461, label %462, label %485

462:                                              ; preds = %439
  %463 = load ptr, ptr %23, align 8, !tbaa !5
  %464 = load i32, ptr %463, align 4, !tbaa !9
  %465 = load ptr, ptr %22, align 8, !tbaa !5
  %466 = load i32, ptr %465, align 4, !tbaa !9
  %467 = sub nsw i32 %464, %466
  %468 = add nsw i32 %467, 1
  store i32 %468, ptr %32, align 4, !tbaa !9
  %469 = call { double, double } @Cd(ptr noundef %76)
  %470 = extractvalue { double, double } %469, 0
  %471 = extractvalue { double, double } %469, 1
  %472 = fneg double %471
  %473 = call ptr @_pCd(ptr noundef %42)
  %474 = getelementptr inbounds { double, double }, ptr %473, i32 0, i32 0
  %475 = getelementptr inbounds { double, double }, ptr %473, i32 0, i32 1
  store double %470, ptr %474, align 8
  store double %472, ptr %475, align 8
  %476 = load ptr, ptr %24, align 8, !tbaa !5
  %477 = load ptr, ptr %22, align 8, !tbaa !5
  %478 = load i32, ptr %477, align 4, !tbaa !9
  %479 = load i32, ptr %50, align 4, !tbaa !9
  %480 = load i32, ptr %29, align 4, !tbaa !9
  %481 = mul nsw i32 %479, %480
  %482 = add nsw i32 %478, %481
  %483 = sext i32 %482 to i64
  %484 = getelementptr inbounds %struct.doublecomplex, ptr %476, i64 %483
  call void @zscal_(ptr noundef %32, ptr noundef %42, ptr noundef %484, ptr noundef @c__1)
  br label %485

485:                                              ; preds = %462, %439
  br label %486

486:                                              ; preds = %485, %259
  br label %487

487:                                              ; preds = %486
  %488 = load i32, ptr %50, align 4, !tbaa !9
  %489 = add nsw i32 %488, 1
  store i32 %489, ptr %50, align 4, !tbaa !9
  br label %255, !llvm.loop !18

490:                                              ; preds = %255
  %491 = load ptr, ptr %18, align 8, !tbaa !5
  %492 = load i32, ptr %491, align 4, !tbaa !9
  %493 = load ptr, ptr %17, align 8, !tbaa !5
  %494 = load i32, ptr %493, align 4, !tbaa !9
  %495 = sub nsw i32 %492, %494
  %496 = add nsw i32 %495, 1
  store i32 %496, ptr %77, align 4, !tbaa !9
  %497 = load ptr, ptr %23, align 8, !tbaa !5
  %498 = load i32, ptr %497, align 4, !tbaa !9
  %499 = load ptr, ptr %22, align 8, !tbaa !5
  %500 = load i32, ptr %499, align 4, !tbaa !9
  %501 = sub nsw i32 %498, %500
  %502 = add nsw i32 %501, 1
  store i32 %502, ptr %78, align 4, !tbaa !9
  %503 = call double @dlamch_(ptr noundef @.str)
  store double %503, ptr %80, align 8, !tbaa !17
  %504 = load double, ptr %80, align 8, !tbaa !17
  %505 = fdiv double 1.000000e+00, %504
  store double %505, ptr %81, align 8, !tbaa !17
  call void @dlabad_(ptr noundef %80, ptr noundef %81)
  %506 = call double @dlamch_(ptr noundef @.str.1)
  store double %506, ptr %87, align 8, !tbaa !17
  %507 = load double, ptr %80, align 8, !tbaa !17
  %508 = load i32, ptr %77, align 4, !tbaa !9
  %509 = sitofp i32 %508 to double
  %510 = load double, ptr %87, align 8, !tbaa !17
  %511 = fdiv double %509, %510
  %512 = fmul double %507, %511
  store double %512, ptr %82, align 8, !tbaa !17
  %513 = load ptr, ptr %14, align 8, !tbaa !5
  %514 = load i32, ptr %513, align 4, !tbaa !9
  %515 = icmp ne i32 %514, 0
  br i1 %515, label %516, label %519

516:                                              ; preds = %490
  store i32 1, ptr %63, align 4, !tbaa !9
  %517 = load ptr, ptr %16, align 8, !tbaa !5
  %518 = load i32, ptr %517, align 4, !tbaa !9
  store i32 %518, ptr %64, align 4, !tbaa !9
  br label %519

519:                                              ; preds = %516, %490
  %520 = load i32, ptr %77, align 4, !tbaa !9
  %521 = icmp sge i32 10, %520
  br i1 %521, label %522, label %523

522:                                              ; preds = %519
  br label %525

523:                                              ; preds = %519
  %524 = load i32, ptr %77, align 4, !tbaa !9
  br label %525

525:                                              ; preds = %523, %522
  %526 = phi i32 [ 10, %522 ], [ %524, %523 ]
  %527 = mul nsw i32 %526, 30
  store i32 %527, ptr %61, align 4, !tbaa !9
  %528 = load ptr, ptr %18, align 8, !tbaa !5
  %529 = load i32, ptr %528, align 4, !tbaa !9
  store i32 %529, ptr %50, align 4, !tbaa !9
  br label %530

530:                                              ; preds = %3372, %525
  %531 = load i32, ptr %50, align 4, !tbaa !9
  %532 = load ptr, ptr %17, align 8, !tbaa !5
  %533 = load i32, ptr %532, align 4, !tbaa !9
  %534 = icmp slt i32 %531, %533
  br i1 %534, label %535, label %536

535:                                              ; preds = %530
  br label %3403

536:                                              ; preds = %530
  %537 = load ptr, ptr %17, align 8, !tbaa !5
  %538 = load i32, ptr %537, align 4, !tbaa !9
  store i32 %538, ptr %53, align 4, !tbaa !9
  %539 = load i32, ptr %61, align 4, !tbaa !9
  store i32 %539, ptr %31, align 4, !tbaa !9
  store i32 0, ptr %86, align 4, !tbaa !9
  br label %540

540:                                              ; preds = %3366, %536
  %541 = load i32, ptr %86, align 4, !tbaa !9
  %542 = load i32, ptr %31, align 4, !tbaa !9
  %543 = icmp sle i32 %541, %542
  br i1 %543, label %544, label %3369

544:                                              ; preds = %540
  %545 = load i32, ptr %53, align 4, !tbaa !9
  %546 = add nsw i32 %545, 1
  store i32 %546, ptr %32, align 4, !tbaa !9
  %547 = load i32, ptr %50, align 4, !tbaa !9
  store i32 %547, ptr %52, align 4, !tbaa !9
  br label %548

548:                                              ; preds = %1237, %544
  %549 = load i32, ptr %52, align 4, !tbaa !9
  %550 = load i32, ptr %32, align 4, !tbaa !9
  %551 = icmp sge i32 %549, %550
  br i1 %551, label %552, label %1240

552:                                              ; preds = %548
  %553 = load i32, ptr %52, align 4, !tbaa !9
  %554 = load i32, ptr %52, align 4, !tbaa !9
  %555 = sub nsw i32 %554, 1
  %556 = load i32, ptr %27, align 4, !tbaa !9
  %557 = mul nsw i32 %555, %556
  %558 = add nsw i32 %553, %557
  store i32 %558, ptr %33, align 4, !tbaa !9
  %559 = load ptr, ptr %19, align 8, !tbaa !5
  %560 = load i32, ptr %33, align 4, !tbaa !9
  %561 = sext i32 %560 to i64
  %562 = getelementptr inbounds %struct.doublecomplex, ptr %559, i64 %561
  %563 = getelementptr inbounds %struct.doublecomplex, ptr %562, i32 0, i32 0
  %564 = load double, ptr %563, align 8, !tbaa !11
  store double %564, ptr %36, align 8, !tbaa !17
  %565 = load double, ptr %36, align 8, !tbaa !17
  %566 = fcmp oge double %565, 0.000000e+00
  br i1 %566, label %567, label %569

567:                                              ; preds = %552
  %568 = load double, ptr %36, align 8, !tbaa !17
  br label %572

569:                                              ; preds = %552
  %570 = load double, ptr %36, align 8, !tbaa !17
  %571 = fneg double %570
  br label %572

572:                                              ; preds = %569, %567
  %573 = phi double [ %568, %567 ], [ %571, %569 ]
  %574 = load ptr, ptr %19, align 8, !tbaa !5
  %575 = load i32, ptr %52, align 4, !tbaa !9
  %576 = load i32, ptr %52, align 4, !tbaa !9
  %577 = sub nsw i32 %576, 1
  %578 = load i32, ptr %27, align 4, !tbaa !9
  %579 = mul nsw i32 %577, %578
  %580 = add nsw i32 %575, %579
  %581 = sext i32 %580 to i64
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %574, i64 %581
  %583 = call { double, double } @Cd(ptr noundef %582)
  %584 = extractvalue { double, double } %583, 0
  %585 = extractvalue { double, double } %583, 1
  store double %585, ptr %37, align 8, !tbaa !17
  %586 = load double, ptr %37, align 8, !tbaa !17
  %587 = fcmp oge double %586, 0.000000e+00
  br i1 %587, label %588, label %590

588:                                              ; preds = %572
  %589 = load double, ptr %37, align 8, !tbaa !17
  br label %593

590:                                              ; preds = %572
  %591 = load double, ptr %37, align 8, !tbaa !17
  %592 = fneg double %591
  br label %593

593:                                              ; preds = %590, %588
  %594 = phi double [ %589, %588 ], [ %592, %590 ]
  %595 = fadd double %573, %594
  %596 = load double, ptr %82, align 8, !tbaa !17
  %597 = fcmp ole double %595, %596
  br i1 %597, label %598, label %599

598:                                              ; preds = %593
  br label %1241

599:                                              ; preds = %593
  %600 = load i32, ptr %52, align 4, !tbaa !9
  %601 = sub nsw i32 %600, 1
  %602 = load i32, ptr %52, align 4, !tbaa !9
  %603 = sub nsw i32 %602, 1
  %604 = load i32, ptr %27, align 4, !tbaa !9
  %605 = mul nsw i32 %603, %604
  %606 = add nsw i32 %601, %605
  store i32 %606, ptr %33, align 4, !tbaa !9
  %607 = load i32, ptr %52, align 4, !tbaa !9
  %608 = load i32, ptr %52, align 4, !tbaa !9
  %609 = load i32, ptr %27, align 4, !tbaa !9
  %610 = mul nsw i32 %608, %609
  %611 = add nsw i32 %607, %610
  store i32 %611, ptr %34, align 4, !tbaa !9
  %612 = load ptr, ptr %19, align 8, !tbaa !5
  %613 = load i32, ptr %33, align 4, !tbaa !9
  %614 = sext i32 %613 to i64
  %615 = getelementptr inbounds %struct.doublecomplex, ptr %612, i64 %614
  %616 = getelementptr inbounds %struct.doublecomplex, ptr %615, i32 0, i32 0
  %617 = load double, ptr %616, align 8, !tbaa !11
  store double %617, ptr %36, align 8, !tbaa !17
  %618 = load double, ptr %36, align 8, !tbaa !17
  %619 = fcmp oge double %618, 0.000000e+00
  br i1 %619, label %620, label %622

620:                                              ; preds = %599
  %621 = load double, ptr %36, align 8, !tbaa !17
  br label %625

622:                                              ; preds = %599
  %623 = load double, ptr %36, align 8, !tbaa !17
  %624 = fneg double %623
  br label %625

625:                                              ; preds = %622, %620
  %626 = phi double [ %621, %620 ], [ %624, %622 ]
  %627 = load ptr, ptr %19, align 8, !tbaa !5
  %628 = load i32, ptr %52, align 4, !tbaa !9
  %629 = sub nsw i32 %628, 1
  %630 = load i32, ptr %52, align 4, !tbaa !9
  %631 = sub nsw i32 %630, 1
  %632 = load i32, ptr %27, align 4, !tbaa !9
  %633 = mul nsw i32 %631, %632
  %634 = add nsw i32 %629, %633
  %635 = sext i32 %634 to i64
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %627, i64 %635
  %637 = call { double, double } @Cd(ptr noundef %636)
  %638 = extractvalue { double, double } %637, 0
  %639 = extractvalue { double, double } %637, 1
  store double %639, ptr %37, align 8, !tbaa !17
  %640 = load double, ptr %37, align 8, !tbaa !17
  %641 = fcmp oge double %640, 0.000000e+00
  br i1 %641, label %642, label %644

642:                                              ; preds = %625
  %643 = load double, ptr %37, align 8, !tbaa !17
  br label %647

644:                                              ; preds = %625
  %645 = load double, ptr %37, align 8, !tbaa !17
  %646 = fneg double %645
  br label %647

647:                                              ; preds = %644, %642
  %648 = phi double [ %643, %642 ], [ %646, %644 ]
  %649 = fadd double %626, %648
  %650 = load ptr, ptr %19, align 8, !tbaa !5
  %651 = load i32, ptr %34, align 4, !tbaa !9
  %652 = sext i32 %651 to i64
  %653 = getelementptr inbounds %struct.doublecomplex, ptr %650, i64 %652
  %654 = getelementptr inbounds %struct.doublecomplex, ptr %653, i32 0, i32 0
  %655 = load double, ptr %654, align 8, !tbaa !11
  store double %655, ptr %38, align 8, !tbaa !17
  %656 = load double, ptr %38, align 8, !tbaa !17
  %657 = fcmp oge double %656, 0.000000e+00
  br i1 %657, label %658, label %660

658:                                              ; preds = %647
  %659 = load double, ptr %38, align 8, !tbaa !17
  br label %663

660:                                              ; preds = %647
  %661 = load double, ptr %38, align 8, !tbaa !17
  %662 = fneg double %661
  br label %663

663:                                              ; preds = %660, %658
  %664 = phi double [ %659, %658 ], [ %662, %660 ]
  %665 = load ptr, ptr %19, align 8, !tbaa !5
  %666 = load i32, ptr %52, align 4, !tbaa !9
  %667 = load i32, ptr %52, align 4, !tbaa !9
  %668 = load i32, ptr %27, align 4, !tbaa !9
  %669 = mul nsw i32 %667, %668
  %670 = add nsw i32 %666, %669
  %671 = sext i32 %670 to i64
  %672 = getelementptr inbounds %struct.doublecomplex, ptr %665, i64 %671
  %673 = call { double, double } @Cd(ptr noundef %672)
  %674 = extractvalue { double, double } %673, 0
  %675 = extractvalue { double, double } %673, 1
  store double %675, ptr %39, align 8, !tbaa !17
  %676 = load double, ptr %39, align 8, !tbaa !17
  %677 = fcmp oge double %676, 0.000000e+00
  br i1 %677, label %678, label %680

678:                                              ; preds = %663
  %679 = load double, ptr %39, align 8, !tbaa !17
  br label %683

680:                                              ; preds = %663
  %681 = load double, ptr %39, align 8, !tbaa !17
  %682 = fneg double %681
  br label %683

683:                                              ; preds = %680, %678
  %684 = phi double [ %679, %678 ], [ %682, %680 ]
  %685 = fadd double %664, %684
  %686 = fadd double %649, %685
  store double %686, ptr %89, align 8, !tbaa !17
  %687 = load double, ptr %89, align 8, !tbaa !17
  %688 = fcmp oeq double %687, 0.000000e+00
  br i1 %688, label %689, label %751

689:                                              ; preds = %683
  %690 = load i32, ptr %52, align 4, !tbaa !9
  %691 = sub nsw i32 %690, 2
  %692 = load ptr, ptr %17, align 8, !tbaa !5
  %693 = load i32, ptr %692, align 4, !tbaa !9
  %694 = icmp sge i32 %691, %693
  br i1 %694, label %695, label %720

695:                                              ; preds = %689
  %696 = load i32, ptr %52, align 4, !tbaa !9
  %697 = sub nsw i32 %696, 1
  %698 = load i32, ptr %52, align 4, !tbaa !9
  %699 = sub nsw i32 %698, 2
  %700 = load i32, ptr %27, align 4, !tbaa !9
  %701 = mul nsw i32 %699, %700
  %702 = add nsw i32 %697, %701
  store i32 %702, ptr %33, align 4, !tbaa !9
  %703 = load ptr, ptr %19, align 8, !tbaa !5
  %704 = load i32, ptr %33, align 4, !tbaa !9
  %705 = sext i32 %704 to i64
  %706 = getelementptr inbounds %struct.doublecomplex, ptr %703, i64 %705
  %707 = getelementptr inbounds %struct.doublecomplex, ptr %706, i32 0, i32 0
  %708 = load double, ptr %707, align 8, !tbaa !11
  store double %708, ptr %36, align 8, !tbaa !17
  %709 = load double, ptr %36, align 8, !tbaa !17
  %710 = fcmp oge double %709, 0.000000e+00
  br i1 %710, label %711, label %713

711:                                              ; preds = %695
  %712 = load double, ptr %36, align 8, !tbaa !17
  br label %716

713:                                              ; preds = %695
  %714 = load double, ptr %36, align 8, !tbaa !17
  %715 = fneg double %714
  br label %716

716:                                              ; preds = %713, %711
  %717 = phi double [ %712, %711 ], [ %715, %713 ]
  %718 = load double, ptr %89, align 8, !tbaa !17
  %719 = fadd double %718, %717
  store double %719, ptr %89, align 8, !tbaa !17
  br label %720

720:                                              ; preds = %716, %689
  %721 = load i32, ptr %52, align 4, !tbaa !9
  %722 = add nsw i32 %721, 1
  %723 = load ptr, ptr %18, align 8, !tbaa !5
  %724 = load i32, ptr %723, align 4, !tbaa !9
  %725 = icmp sle i32 %722, %724
  br i1 %725, label %726, label %750

726:                                              ; preds = %720
  %727 = load i32, ptr %52, align 4, !tbaa !9
  %728 = add nsw i32 %727, 1
  %729 = load i32, ptr %52, align 4, !tbaa !9
  %730 = load i32, ptr %27, align 4, !tbaa !9
  %731 = mul nsw i32 %729, %730
  %732 = add nsw i32 %728, %731
  store i32 %732, ptr %33, align 4, !tbaa !9
  %733 = load ptr, ptr %19, align 8, !tbaa !5
  %734 = load i32, ptr %33, align 4, !tbaa !9
  %735 = sext i32 %734 to i64
  %736 = getelementptr inbounds %struct.doublecomplex, ptr %733, i64 %735
  %737 = getelementptr inbounds %struct.doublecomplex, ptr %736, i32 0, i32 0
  %738 = load double, ptr %737, align 8, !tbaa !11
  store double %738, ptr %36, align 8, !tbaa !17
  %739 = load double, ptr %36, align 8, !tbaa !17
  %740 = fcmp oge double %739, 0.000000e+00
  br i1 %740, label %741, label %743

741:                                              ; preds = %726
  %742 = load double, ptr %36, align 8, !tbaa !17
  br label %746

743:                                              ; preds = %726
  %744 = load double, ptr %36, align 8, !tbaa !17
  %745 = fneg double %744
  br label %746

746:                                              ; preds = %743, %741
  %747 = phi double [ %742, %741 ], [ %745, %743 ]
  %748 = load double, ptr %89, align 8, !tbaa !17
  %749 = fadd double %748, %747
  store double %749, ptr %89, align 8, !tbaa !17
  br label %750

750:                                              ; preds = %746, %720
  br label %751

751:                                              ; preds = %750, %683
  %752 = load i32, ptr %52, align 4, !tbaa !9
  %753 = load i32, ptr %52, align 4, !tbaa !9
  %754 = sub nsw i32 %753, 1
  %755 = load i32, ptr %27, align 4, !tbaa !9
  %756 = mul nsw i32 %754, %755
  %757 = add nsw i32 %752, %756
  store i32 %757, ptr %33, align 4, !tbaa !9
  %758 = load ptr, ptr %19, align 8, !tbaa !5
  %759 = load i32, ptr %33, align 4, !tbaa !9
  %760 = sext i32 %759 to i64
  %761 = getelementptr inbounds %struct.doublecomplex, ptr %758, i64 %760
  %762 = getelementptr inbounds %struct.doublecomplex, ptr %761, i32 0, i32 0
  %763 = load double, ptr %762, align 8, !tbaa !11
  store double %763, ptr %36, align 8, !tbaa !17
  %764 = load double, ptr %36, align 8, !tbaa !17
  %765 = fcmp oge double %764, 0.000000e+00
  br i1 %765, label %766, label %768

766:                                              ; preds = %751
  %767 = load double, ptr %36, align 8, !tbaa !17
  br label %771

768:                                              ; preds = %751
  %769 = load double, ptr %36, align 8, !tbaa !17
  %770 = fneg double %769
  br label %771

771:                                              ; preds = %768, %766
  %772 = phi double [ %767, %766 ], [ %770, %768 ]
  %773 = load double, ptr %87, align 8, !tbaa !17
  %774 = load double, ptr %89, align 8, !tbaa !17
  %775 = fmul double %773, %774
  %776 = fcmp ole double %772, %775
  br i1 %776, label %777, label %1236

777:                                              ; preds = %771
  %778 = load i32, ptr %52, align 4, !tbaa !9
  %779 = load i32, ptr %52, align 4, !tbaa !9
  %780 = sub nsw i32 %779, 1
  %781 = load i32, ptr %27, align 4, !tbaa !9
  %782 = mul nsw i32 %780, %781
  %783 = add nsw i32 %778, %782
  store i32 %783, ptr %33, align 4, !tbaa !9
  %784 = load i32, ptr %52, align 4, !tbaa !9
  %785 = sub nsw i32 %784, 1
  %786 = load i32, ptr %52, align 4, !tbaa !9
  %787 = load i32, ptr %27, align 4, !tbaa !9
  %788 = mul nsw i32 %786, %787
  %789 = add nsw i32 %785, %788
  store i32 %789, ptr %34, align 4, !tbaa !9
  %790 = load ptr, ptr %19, align 8, !tbaa !5
  %791 = load i32, ptr %33, align 4, !tbaa !9
  %792 = sext i32 %791 to i64
  %793 = getelementptr inbounds %struct.doublecomplex, ptr %790, i64 %792
  %794 = getelementptr inbounds %struct.doublecomplex, ptr %793, i32 0, i32 0
  %795 = load double, ptr %794, align 8, !tbaa !11
  store double %795, ptr %36, align 8, !tbaa !17
  %796 = load double, ptr %36, align 8, !tbaa !17
  %797 = fcmp oge double %796, 0.000000e+00
  br i1 %797, label %798, label %800

798:                                              ; preds = %777
  %799 = load double, ptr %36, align 8, !tbaa !17
  br label %803

800:                                              ; preds = %777
  %801 = load double, ptr %36, align 8, !tbaa !17
  %802 = fneg double %801
  br label %803

803:                                              ; preds = %800, %798
  %804 = phi double [ %799, %798 ], [ %802, %800 ]
  %805 = load ptr, ptr %19, align 8, !tbaa !5
  %806 = load i32, ptr %52, align 4, !tbaa !9
  %807 = load i32, ptr %52, align 4, !tbaa !9
  %808 = sub nsw i32 %807, 1
  %809 = load i32, ptr %27, align 4, !tbaa !9
  %810 = mul nsw i32 %808, %809
  %811 = add nsw i32 %806, %810
  %812 = sext i32 %811 to i64
  %813 = getelementptr inbounds %struct.doublecomplex, ptr %805, i64 %812
  %814 = call { double, double } @Cd(ptr noundef %813)
  %815 = extractvalue { double, double } %814, 0
  %816 = extractvalue { double, double } %814, 1
  store double %816, ptr %37, align 8, !tbaa !17
  %817 = load double, ptr %37, align 8, !tbaa !17
  %818 = fcmp oge double %817, 0.000000e+00
  br i1 %818, label %819, label %821

819:                                              ; preds = %803
  %820 = load double, ptr %37, align 8, !tbaa !17
  br label %824

821:                                              ; preds = %803
  %822 = load double, ptr %37, align 8, !tbaa !17
  %823 = fneg double %822
  br label %824

824:                                              ; preds = %821, %819
  %825 = phi double [ %820, %819 ], [ %823, %821 ]
  %826 = fadd double %804, %825
  store double %826, ptr %40, align 8, !tbaa !17
  %827 = load ptr, ptr %19, align 8, !tbaa !5
  %828 = load i32, ptr %34, 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 0
  %832 = load double, ptr %831, align 8, !tbaa !11
  store double %832, ptr %38, align 8, !tbaa !17
  %833 = load double, ptr %38, align 8, !tbaa !17
  %834 = fcmp oge double %833, 0.000000e+00
  br i1 %834, label %835, label %837

835:                                              ; preds = %824
  %836 = load double, ptr %38, align 8, !tbaa !17
  br label %840

837:                                              ; preds = %824
  %838 = load double, ptr %38, align 8, !tbaa !17
  %839 = fneg double %838
  br label %840

840:                                              ; preds = %837, %835
  %841 = phi double [ %836, %835 ], [ %839, %837 ]
  %842 = load ptr, ptr %19, align 8, !tbaa !5
  %843 = load i32, ptr %52, align 4, !tbaa !9
  %844 = sub nsw i32 %843, 1
  %845 = load i32, ptr %52, align 4, !tbaa !9
  %846 = load i32, ptr %27, align 4, !tbaa !9
  %847 = mul nsw i32 %845, %846
  %848 = add nsw i32 %844, %847
  %849 = sext i32 %848 to i64
  %850 = getelementptr inbounds %struct.doublecomplex, ptr %842, i64 %849
  %851 = call { double, double } @Cd(ptr noundef %850)
  %852 = extractvalue { double, double } %851, 0
  %853 = extractvalue { double, double } %851, 1
  store double %853, ptr %39, align 8, !tbaa !17
  %854 = load double, ptr %39, align 8, !tbaa !17
  %855 = fcmp oge double %854, 0.000000e+00
  br i1 %855, label %856, label %858

856:                                              ; preds = %840
  %857 = load double, ptr %39, align 8, !tbaa !17
  br label %861

858:                                              ; preds = %840
  %859 = load double, ptr %39, align 8, !tbaa !17
  %860 = fneg double %859
  br label %861

861:                                              ; preds = %858, %856
  %862 = phi double [ %857, %856 ], [ %860, %858 ]
  %863 = fadd double %841, %862
  store double %863, ptr %41, align 8, !tbaa !17
  %864 = load double, ptr %40, align 8, !tbaa !17
  %865 = load double, ptr %41, align 8, !tbaa !17
  %866 = fcmp oge double %864, %865
  br i1 %866, label %867, label %869

867:                                              ; preds = %861
  %868 = load double, ptr %40, align 8, !tbaa !17
  br label %871

869:                                              ; preds = %861
  %870 = load double, ptr %41, align 8, !tbaa !17
  br label %871

871:                                              ; preds = %869, %867
  %872 = phi double [ %868, %867 ], [ %870, %869 ]
  store double %872, ptr %69, align 8, !tbaa !17
  %873 = load i32, ptr %52, align 4, !tbaa !9
  %874 = load i32, ptr %52, align 4, !tbaa !9
  %875 = sub nsw i32 %874, 1
  %876 = load i32, ptr %27, align 4, !tbaa !9
  %877 = mul nsw i32 %875, %876
  %878 = add nsw i32 %873, %877
  store i32 %878, ptr %33, align 4, !tbaa !9
  %879 = load i32, ptr %52, align 4, !tbaa !9
  %880 = sub nsw i32 %879, 1
  %881 = load i32, ptr %52, align 4, !tbaa !9
  %882 = load i32, ptr %27, align 4, !tbaa !9
  %883 = mul nsw i32 %881, %882
  %884 = add nsw i32 %880, %883
  store i32 %884, ptr %34, align 4, !tbaa !9
  %885 = load ptr, ptr %19, align 8, !tbaa !5
  %886 = load i32, ptr %33, align 4, !tbaa !9
  %887 = sext i32 %886 to i64
  %888 = getelementptr inbounds %struct.doublecomplex, ptr %885, i64 %887
  %889 = getelementptr inbounds %struct.doublecomplex, ptr %888, i32 0, i32 0
  %890 = load double, ptr %889, align 8, !tbaa !11
  store double %890, ptr %36, align 8, !tbaa !17
  %891 = load double, ptr %36, align 8, !tbaa !17
  %892 = fcmp oge double %891, 0.000000e+00
  br i1 %892, label %893, label %895

893:                                              ; preds = %871
  %894 = load double, ptr %36, align 8, !tbaa !17
  br label %898

895:                                              ; preds = %871
  %896 = load double, ptr %36, align 8, !tbaa !17
  %897 = fneg double %896
  br label %898

898:                                              ; preds = %895, %893
  %899 = phi double [ %894, %893 ], [ %897, %895 ]
  %900 = load ptr, ptr %19, align 8, !tbaa !5
  %901 = load i32, ptr %52, align 4, !tbaa !9
  %902 = load i32, ptr %52, align 4, !tbaa !9
  %903 = sub nsw i32 %902, 1
  %904 = load i32, ptr %27, align 4, !tbaa !9
  %905 = mul nsw i32 %903, %904
  %906 = add nsw i32 %901, %905
  %907 = sext i32 %906 to i64
  %908 = getelementptr inbounds %struct.doublecomplex, ptr %900, i64 %907
  %909 = call { double, double } @Cd(ptr noundef %908)
  %910 = extractvalue { double, double } %909, 0
  %911 = extractvalue { double, double } %909, 1
  store double %911, ptr %37, align 8, !tbaa !17
  %912 = load double, ptr %37, align 8, !tbaa !17
  %913 = fcmp oge double %912, 0.000000e+00
  br i1 %913, label %914, label %916

914:                                              ; preds = %898
  %915 = load double, ptr %37, align 8, !tbaa !17
  br label %919

916:                                              ; preds = %898
  %917 = load double, ptr %37, align 8, !tbaa !17
  %918 = fneg double %917
  br label %919

919:                                              ; preds = %916, %914
  %920 = phi double [ %915, %914 ], [ %918, %916 ]
  %921 = fadd double %899, %920
  store double %921, ptr %40, align 8, !tbaa !17
  %922 = load ptr, ptr %19, align 8, !tbaa !5
  %923 = load i32, ptr %34, align 4, !tbaa !9
  %924 = sext i32 %923 to i64
  %925 = getelementptr inbounds %struct.doublecomplex, ptr %922, i64 %924
  %926 = getelementptr inbounds %struct.doublecomplex, ptr %925, i32 0, i32 0
  %927 = load double, ptr %926, align 8, !tbaa !11
  store double %927, ptr %38, align 8, !tbaa !17
  %928 = load double, ptr %38, align 8, !tbaa !17
  %929 = fcmp oge double %928, 0.000000e+00
  br i1 %929, label %930, label %932

930:                                              ; preds = %919
  %931 = load double, ptr %38, align 8, !tbaa !17
  br label %935

932:                                              ; preds = %919
  %933 = load double, ptr %38, align 8, !tbaa !17
  %934 = fneg double %933
  br label %935

935:                                              ; preds = %932, %930
  %936 = phi double [ %931, %930 ], [ %934, %932 ]
  %937 = load ptr, ptr %19, align 8, !tbaa !5
  %938 = load i32, ptr %52, align 4, !tbaa !9
  %939 = sub nsw i32 %938, 1
  %940 = load i32, ptr %52, align 4, !tbaa !9
  %941 = load i32, ptr %27, align 4, !tbaa !9
  %942 = mul nsw i32 %940, %941
  %943 = add nsw i32 %939, %942
  %944 = sext i32 %943 to i64
  %945 = getelementptr inbounds %struct.doublecomplex, ptr %937, i64 %944
  %946 = call { double, double } @Cd(ptr noundef %945)
  %947 = extractvalue { double, double } %946, 0
  %948 = extractvalue { double, double } %946, 1
  store double %948, ptr %39, align 8, !tbaa !17
  %949 = load double, ptr %39, align 8, !tbaa !17
  %950 = fcmp oge double %949, 0.000000e+00
  br i1 %950, label %951, label %953

951:                                              ; preds = %935
  %952 = load double, ptr %39, align 8, !tbaa !17
  br label %956

953:                                              ; preds = %935
  %954 = load double, ptr %39, align 8, !tbaa !17
  %955 = fneg double %954
  br label %956

956:                                              ; preds = %953, %951
  %957 = phi double [ %952, %951 ], [ %955, %953 ]
  %958 = fadd double %936, %957
  store double %958, ptr %41, align 8, !tbaa !17
  %959 = load double, ptr %40, align 8, !tbaa !17
  %960 = load double, ptr %41, align 8, !tbaa !17
  %961 = fcmp ole double %959, %960
  br i1 %961, label %962, label %964

962:                                              ; preds = %956
  %963 = load double, ptr %40, align 8, !tbaa !17
  br label %966

964:                                              ; preds = %956
  %965 = load double, ptr %41, align 8, !tbaa !17
  br label %966

966:                                              ; preds = %964, %962
  %967 = phi double [ %963, %962 ], [ %965, %964 ]
  store double %967, ptr %70, align 8, !tbaa !17
  %968 = load i32, ptr %52, align 4, !tbaa !9
  %969 = sub nsw i32 %968, 1
  %970 = load i32, ptr %52, align 4, !tbaa !9
  %971 = sub nsw i32 %970, 1
  %972 = load i32, ptr %27, align 4, !tbaa !9
  %973 = mul nsw i32 %971, %972
  %974 = add nsw i32 %969, %973
  store i32 %974, ptr %33, align 4, !tbaa !9
  %975 = load i32, ptr %52, align 4, !tbaa !9
  %976 = load i32, ptr %52, align 4, !tbaa !9
  %977 = load i32, ptr %27, align 4, !tbaa !9
  %978 = mul nsw i32 %976, %977
  %979 = add nsw i32 %975, %978
  store i32 %979, ptr %34, align 4, !tbaa !9
  %980 = load ptr, ptr %19, align 8, !tbaa !5
  %981 = load i32, ptr %33, align 4, !tbaa !9
  %982 = sext i32 %981 to i64
  %983 = getelementptr inbounds %struct.doublecomplex, ptr %980, i64 %982
  %984 = getelementptr inbounds %struct.doublecomplex, ptr %983, i32 0, i32 0
  %985 = load double, ptr %984, align 8, !tbaa !11
  %986 = load ptr, ptr %19, align 8, !tbaa !5
  %987 = load i32, ptr %34, align 4, !tbaa !9
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds %struct.doublecomplex, ptr %986, i64 %988
  %990 = getelementptr inbounds %struct.doublecomplex, ptr %989, i32 0, i32 0
  %991 = load double, ptr %990, align 8, !tbaa !11
  %992 = fsub double %985, %991
  %993 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %992, ptr %993, align 8, !tbaa !11
  %994 = load ptr, ptr %19, align 8, !tbaa !5
  %995 = load i32, ptr %33, align 4, !tbaa !9
  %996 = sext i32 %995 to i64
  %997 = getelementptr inbounds %struct.doublecomplex, ptr %994, i64 %996
  %998 = getelementptr inbounds %struct.doublecomplex, ptr %997, i32 0, i32 1
  %999 = load double, ptr %998, align 8, !tbaa !14
  %1000 = load ptr, ptr %19, align 8, !tbaa !5
  %1001 = load i32, ptr %34, align 4, !tbaa !9
  %1002 = sext i32 %1001 to i64
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %1000, i64 %1002
  %1004 = getelementptr inbounds %struct.doublecomplex, ptr %1003, i32 0, i32 1
  %1005 = load double, ptr %1004, align 8, !tbaa !14
  %1006 = fsub double %999, %1005
  %1007 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1006, ptr %1007, align 8, !tbaa !14
  %1008 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1009 = load double, ptr %1008, align 8, !tbaa !11
  %1010 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1009, ptr %1010, align 8, !tbaa !11
  %1011 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1012 = load double, ptr %1011, align 8, !tbaa !14
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1012, ptr %1013, align 8, !tbaa !14
  %1014 = load i32, ptr %52, align 4, !tbaa !9
  %1015 = load i32, ptr %52, align 4, !tbaa !9
  %1016 = load i32, ptr %27, align 4, !tbaa !9
  %1017 = mul nsw i32 %1015, %1016
  %1018 = add nsw i32 %1014, %1017
  store i32 %1018, ptr %35, align 4, !tbaa !9
  %1019 = load ptr, ptr %19, align 8, !tbaa !5
  %1020 = load i32, ptr %35, align 4, !tbaa !9
  %1021 = sext i32 %1020 to i64
  %1022 = getelementptr inbounds %struct.doublecomplex, ptr %1019, i64 %1021
  %1023 = getelementptr inbounds %struct.doublecomplex, ptr %1022, i32 0, i32 0
  %1024 = load double, ptr %1023, align 8, !tbaa !11
  store double %1024, ptr %36, align 8, !tbaa !17
  %1025 = load double, ptr %36, align 8, !tbaa !17
  %1026 = fcmp oge double %1025, 0.000000e+00
  br i1 %1026, label %1027, label %1029

1027:                                             ; preds = %966
  %1028 = load double, ptr %36, align 8, !tbaa !17
  br label %1032

1029:                                             ; preds = %966
  %1030 = load double, ptr %36, align 8, !tbaa !17
  %1031 = fneg double %1030
  br label %1032

1032:                                             ; preds = %1029, %1027
  %1033 = phi double [ %1028, %1027 ], [ %1031, %1029 ]
  %1034 = load ptr, ptr %19, align 8, !tbaa !5
  %1035 = load i32, ptr %52, align 4, !tbaa !9
  %1036 = load i32, ptr %52, align 4, !tbaa !9
  %1037 = load i32, ptr %27, align 4, !tbaa !9
  %1038 = mul nsw i32 %1036, %1037
  %1039 = add nsw i32 %1035, %1038
  %1040 = sext i32 %1039 to i64
  %1041 = getelementptr inbounds %struct.doublecomplex, ptr %1034, i64 %1040
  %1042 = call { double, double } @Cd(ptr noundef %1041)
  %1043 = extractvalue { double, double } %1042, 0
  %1044 = extractvalue { double, double } %1042, 1
  store double %1044, ptr %37, align 8, !tbaa !17
  %1045 = load double, ptr %37, align 8, !tbaa !17
  %1046 = fcmp oge double %1045, 0.000000e+00
  br i1 %1046, label %1047, label %1049

1047:                                             ; preds = %1032
  %1048 = load double, ptr %37, align 8, !tbaa !17
  br label %1052

1049:                                             ; preds = %1032
  %1050 = load double, ptr %37, align 8, !tbaa !17
  %1051 = fneg double %1050
  br label %1052

1052:                                             ; preds = %1049, %1047
  %1053 = phi double [ %1048, %1047 ], [ %1051, %1049 ]
  %1054 = fadd double %1033, %1053
  store double %1054, ptr %40, align 8, !tbaa !17
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1056 = load double, ptr %1055, align 8, !tbaa !11
  store double %1056, ptr %38, align 8, !tbaa !17
  %1057 = load double, ptr %38, align 8, !tbaa !17
  %1058 = fcmp oge double %1057, 0.000000e+00
  br i1 %1058, label %1059, label %1061

1059:                                             ; preds = %1052
  %1060 = load double, ptr %38, align 8, !tbaa !17
  br label %1064

1061:                                             ; preds = %1052
  %1062 = load double, ptr %38, align 8, !tbaa !17
  %1063 = fneg double %1062
  br label %1064

1064:                                             ; preds = %1061, %1059
  %1065 = phi double [ %1060, %1059 ], [ %1063, %1061 ]
  %1066 = call { double, double } @Cd(ptr noundef %42)
  %1067 = extractvalue { double, double } %1066, 0
  %1068 = extractvalue { double, double } %1066, 1
  store double %1068, ptr %39, align 8, !tbaa !17
  %1069 = load double, ptr %39, align 8, !tbaa !17
  %1070 = fcmp oge double %1069, 0.000000e+00
  br i1 %1070, label %1071, label %1073

1071:                                             ; preds = %1064
  %1072 = load double, ptr %39, align 8, !tbaa !17
  br label %1076

1073:                                             ; preds = %1064
  %1074 = load double, ptr %39, align 8, !tbaa !17
  %1075 = fneg double %1074
  br label %1076

1076:                                             ; preds = %1073, %1071
  %1077 = phi double [ %1072, %1071 ], [ %1075, %1073 ]
  %1078 = fadd double %1065, %1077
  store double %1078, ptr %41, align 8, !tbaa !17
  %1079 = load double, ptr %40, align 8, !tbaa !17
  %1080 = load double, ptr %41, align 8, !tbaa !17
  %1081 = fcmp oge double %1079, %1080
  br i1 %1081, label %1082, label %1084

1082:                                             ; preds = %1076
  %1083 = load double, ptr %40, align 8, !tbaa !17
  br label %1086

1084:                                             ; preds = %1076
  %1085 = load double, ptr %41, align 8, !tbaa !17
  br label %1086

1086:                                             ; preds = %1084, %1082
  %1087 = phi double [ %1083, %1082 ], [ %1085, %1084 ]
  store double %1087, ptr %68, align 8, !tbaa !17
  %1088 = load i32, ptr %52, align 4, !tbaa !9
  %1089 = sub nsw i32 %1088, 1
  %1090 = load i32, ptr %52, align 4, !tbaa !9
  %1091 = sub nsw i32 %1090, 1
  %1092 = load i32, ptr %27, align 4, !tbaa !9
  %1093 = mul nsw i32 %1091, %1092
  %1094 = add nsw i32 %1089, %1093
  store i32 %1094, ptr %33, align 4, !tbaa !9
  %1095 = load i32, ptr %52, align 4, !tbaa !9
  %1096 = load i32, ptr %52, align 4, !tbaa !9
  %1097 = load i32, ptr %27, align 4, !tbaa !9
  %1098 = mul nsw i32 %1096, %1097
  %1099 = add nsw i32 %1095, %1098
  store i32 %1099, ptr %34, align 4, !tbaa !9
  %1100 = load ptr, ptr %19, align 8, !tbaa !5
  %1101 = load i32, ptr %33, align 4, !tbaa !9
  %1102 = sext i32 %1101 to i64
  %1103 = getelementptr inbounds %struct.doublecomplex, ptr %1100, i64 %1102
  %1104 = getelementptr inbounds %struct.doublecomplex, ptr %1103, i32 0, i32 0
  %1105 = load double, ptr %1104, align 8, !tbaa !11
  %1106 = load ptr, ptr %19, align 8, !tbaa !5
  %1107 = load i32, ptr %34, 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 = fsub double %1105, %1111
  %1113 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1112, ptr %1113, align 8, !tbaa !11
  %1114 = load ptr, ptr %19, align 8, !tbaa !5
  %1115 = load i32, ptr %33, align 4, !tbaa !9
  %1116 = sext i32 %1115 to i64
  %1117 = getelementptr inbounds %struct.doublecomplex, ptr %1114, i64 %1116
  %1118 = getelementptr inbounds %struct.doublecomplex, ptr %1117, i32 0, i32 1
  %1119 = load double, ptr %1118, align 8, !tbaa !14
  %1120 = load ptr, ptr %19, align 8, !tbaa !5
  %1121 = load i32, ptr %34, align 4, !tbaa !9
  %1122 = sext i32 %1121 to i64
  %1123 = getelementptr inbounds %struct.doublecomplex, ptr %1120, i64 %1122
  %1124 = getelementptr inbounds %struct.doublecomplex, ptr %1123, i32 0, i32 1
  %1125 = load double, ptr %1124, align 8, !tbaa !14
  %1126 = fsub double %1119, %1125
  %1127 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1126, ptr %1127, align 8, !tbaa !14
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1129 = load double, ptr %1128, align 8, !tbaa !11
  %1130 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1129, ptr %1130, align 8, !tbaa !11
  %1131 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1132 = load double, ptr %1131, align 8, !tbaa !14
  %1133 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1132, ptr %1133, align 8, !tbaa !14
  %1134 = load i32, ptr %52, align 4, !tbaa !9
  %1135 = load i32, ptr %52, align 4, !tbaa !9
  %1136 = load i32, ptr %27, align 4, !tbaa !9
  %1137 = mul nsw i32 %1135, %1136
  %1138 = add nsw i32 %1134, %1137
  store i32 %1138, ptr %35, align 4, !tbaa !9
  %1139 = load ptr, ptr %19, align 8, !tbaa !5
  %1140 = load i32, ptr %35, align 4, !tbaa !9
  %1141 = sext i32 %1140 to i64
  %1142 = getelementptr inbounds %struct.doublecomplex, ptr %1139, i64 %1141
  %1143 = getelementptr inbounds %struct.doublecomplex, ptr %1142, i32 0, i32 0
  %1144 = load double, ptr %1143, align 8, !tbaa !11
  store double %1144, ptr %36, align 8, !tbaa !17
  %1145 = load double, ptr %36, align 8, !tbaa !17
  %1146 = fcmp oge double %1145, 0.000000e+00
  br i1 %1146, label %1147, label %1149

1147:                                             ; preds = %1086
  %1148 = load double, ptr %36, align 8, !tbaa !17
  br label %1152

1149:                                             ; preds = %1086
  %1150 = load double, ptr %36, align 8, !tbaa !17
  %1151 = fneg double %1150
  br label %1152

1152:                                             ; preds = %1149, %1147
  %1153 = phi double [ %1148, %1147 ], [ %1151, %1149 ]
  %1154 = load ptr, ptr %19, align 8, !tbaa !5
  %1155 = load i32, ptr %52, align 4, !tbaa !9
  %1156 = load i32, ptr %52, align 4, !tbaa !9
  %1157 = load i32, ptr %27, align 4, !tbaa !9
  %1158 = mul nsw i32 %1156, %1157
  %1159 = add nsw i32 %1155, %1158
  %1160 = sext i32 %1159 to i64
  %1161 = getelementptr inbounds %struct.doublecomplex, ptr %1154, i64 %1160
  %1162 = call { double, double } @Cd(ptr noundef %1161)
  %1163 = extractvalue { double, double } %1162, 0
  %1164 = extractvalue { double, double } %1162, 1
  store double %1164, ptr %37, align 8, !tbaa !17
  %1165 = load double, ptr %37, align 8, !tbaa !17
  %1166 = fcmp oge double %1165, 0.000000e+00
  br i1 %1166, label %1167, label %1169

1167:                                             ; preds = %1152
  %1168 = load double, ptr %37, align 8, !tbaa !17
  br label %1172

1169:                                             ; preds = %1152
  %1170 = load double, ptr %37, align 8, !tbaa !17
  %1171 = fneg double %1170
  br label %1172

1172:                                             ; preds = %1169, %1167
  %1173 = phi double [ %1168, %1167 ], [ %1171, %1169 ]
  %1174 = fadd double %1153, %1173
  store double %1174, ptr %40, align 8, !tbaa !17
  %1175 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1176 = load double, ptr %1175, align 8, !tbaa !11
  store double %1176, ptr %38, align 8, !tbaa !17
  %1177 = load double, ptr %38, align 8, !tbaa !17
  %1178 = fcmp oge double %1177, 0.000000e+00
  br i1 %1178, label %1179, label %1181

1179:                                             ; preds = %1172
  %1180 = load double, ptr %38, align 8, !tbaa !17
  br label %1184

1181:                                             ; preds = %1172
  %1182 = load double, ptr %38, align 8, !tbaa !17
  %1183 = fneg double %1182
  br label %1184

1184:                                             ; preds = %1181, %1179
  %1185 = phi double [ %1180, %1179 ], [ %1183, %1181 ]
  %1186 = call { double, double } @Cd(ptr noundef %42)
  %1187 = extractvalue { double, double } %1186, 0
  %1188 = extractvalue { double, double } %1186, 1
  store double %1188, ptr %39, align 8, !tbaa !17
  %1189 = load double, ptr %39, align 8, !tbaa !17
  %1190 = fcmp oge double %1189, 0.000000e+00
  br i1 %1190, label %1191, label %1193

1191:                                             ; preds = %1184
  %1192 = load double, ptr %39, align 8, !tbaa !17
  br label %1196

1193:                                             ; preds = %1184
  %1194 = load double, ptr %39, align 8, !tbaa !17
  %1195 = fneg double %1194
  br label %1196

1196:                                             ; preds = %1193, %1191
  %1197 = phi double [ %1192, %1191 ], [ %1195, %1193 ]
  %1198 = fadd double %1185, %1197
  store double %1198, ptr %41, align 8, !tbaa !17
  %1199 = load double, ptr %40, align 8, !tbaa !17
  %1200 = load double, ptr %41, align 8, !tbaa !17
  %1201 = fcmp ole double %1199, %1200
  br i1 %1201, label %1202, label %1204

1202:                                             ; preds = %1196
  %1203 = load double, ptr %40, align 8, !tbaa !17
  br label %1206

1204:                                             ; preds = %1196
  %1205 = load double, ptr %41, align 8, !tbaa !17
  br label %1206

1206:                                             ; preds = %1204, %1202
  %1207 = phi double [ %1203, %1202 ], [ %1205, %1204 ]
  store double %1207, ptr %71, align 8, !tbaa !17
  %1208 = load double, ptr %68, align 8, !tbaa !17
  %1209 = load double, ptr %69, align 8, !tbaa !17
  %1210 = fadd double %1208, %1209
  store double %1210, ptr %55, align 8, !tbaa !17
  %1211 = load double, ptr %82, align 8, !tbaa !17
  store double %1211, ptr %36, align 8, !tbaa !17
  %1212 = load double, ptr %87, align 8, !tbaa !17
  %1213 = load double, ptr %71, align 8, !tbaa !17
  %1214 = load double, ptr %68, align 8, !tbaa !17
  %1215 = load double, ptr %55, align 8, !tbaa !17
  %1216 = fdiv double %1214, %1215
  %1217 = fmul double %1213, %1216
  %1218 = fmul double %1212, %1217
  store double %1218, ptr %37, align 8, !tbaa !17
  %1219 = load double, ptr %70, align 8, !tbaa !17
  %1220 = load double, ptr %69, align 8, !tbaa !17
  %1221 = load double, ptr %55, align 8, !tbaa !17
  %1222 = fdiv double %1220, %1221
  %1223 = fmul double %1219, %1222
  %1224 = load double, ptr %36, align 8, !tbaa !17
  %1225 = load double, ptr %37, align 8, !tbaa !17
  %1226 = fcmp oge double %1224, %1225
  br i1 %1226, label %1227, label %1229

1227:                                             ; preds = %1206
  %1228 = load double, ptr %36, align 8, !tbaa !17
  br label %1231

1229:                                             ; preds = %1206
  %1230 = load double, ptr %37, align 8, !tbaa !17
  br label %1231

1231:                                             ; preds = %1229, %1227
  %1232 = phi double [ %1228, %1227 ], [ %1230, %1229 ]
  %1233 = fcmp ole double %1223, %1232
  br i1 %1233, label %1234, label %1235

1234:                                             ; preds = %1231
  br label %1241

1235:                                             ; preds = %1231
  br label %1236

1236:                                             ; preds = %1235, %771
  br label %1237

1237:                                             ; preds = %1236
  %1238 = load i32, ptr %52, align 4, !tbaa !9
  %1239 = add nsw i32 %1238, -1
  store i32 %1239, ptr %52, align 4, !tbaa !9
  br label %548, !llvm.loop !19

1240:                                             ; preds = %548
  br label %1241

1241:                                             ; preds = %1240, %1234, %598
  %1242 = load i32, ptr %52, align 4, !tbaa !9
  store i32 %1242, ptr %53, align 4, !tbaa !9
  %1243 = load i32, ptr %53, align 4, !tbaa !9
  %1244 = load ptr, ptr %17, align 8, !tbaa !5
  %1245 = load i32, ptr %1244, align 4, !tbaa !9
  %1246 = icmp sgt i32 %1243, %1245
  br i1 %1246, label %1247, label %1264

1247:                                             ; preds = %1241
  %1248 = load i32, ptr %53, align 4, !tbaa !9
  %1249 = load i32, ptr %53, align 4, !tbaa !9
  %1250 = sub nsw i32 %1249, 1
  %1251 = load i32, ptr %27, align 4, !tbaa !9
  %1252 = mul nsw i32 %1250, %1251
  %1253 = add nsw i32 %1248, %1252
  store i32 %1253, ptr %32, align 4, !tbaa !9
  %1254 = load ptr, ptr %19, align 8, !tbaa !5
  %1255 = load i32, ptr %32, align 4, !tbaa !9
  %1256 = sext i32 %1255 to i64
  %1257 = getelementptr inbounds %struct.doublecomplex, ptr %1254, i64 %1256
  %1258 = getelementptr inbounds %struct.doublecomplex, ptr %1257, i32 0, i32 0
  store double 0.000000e+00, ptr %1258, align 8, !tbaa !11
  %1259 = load ptr, ptr %19, align 8, !tbaa !5
  %1260 = load i32, ptr %32, align 4, !tbaa !9
  %1261 = sext i32 %1260 to i64
  %1262 = getelementptr inbounds %struct.doublecomplex, ptr %1259, i64 %1261
  %1263 = getelementptr inbounds %struct.doublecomplex, ptr %1262, i32 0, i32 1
  store double 0.000000e+00, ptr %1263, align 8, !tbaa !14
  br label %1264

1264:                                             ; preds = %1247, %1241
  %1265 = load i32, ptr %53, align 4, !tbaa !9
  %1266 = load i32, ptr %50, align 4, !tbaa !9
  %1267 = icmp sge i32 %1265, %1266
  br i1 %1267, label %1268, label %1269

1268:                                             ; preds = %1264
  br label %3372

1269:                                             ; preds = %1264
  %1270 = load ptr, ptr %14, align 8, !tbaa !5
  %1271 = load i32, ptr %1270, align 4, !tbaa !9
  %1272 = icmp ne i32 %1271, 0
  br i1 %1272, label %1276, label %1273

1273:                                             ; preds = %1269
  %1274 = load i32, ptr %53, align 4, !tbaa !9
  store i32 %1274, ptr %63, align 4, !tbaa !9
  %1275 = load i32, ptr %50, align 4, !tbaa !9
  store i32 %1275, ptr %64, align 4, !tbaa !9
  br label %1276

1276:                                             ; preds = %1273, %1269
  %1277 = load i32, ptr %86, align 4, !tbaa !9
  %1278 = icmp eq i32 %1277, 10
  br i1 %1278, label %1279, label %1329

1279:                                             ; preds = %1276
  %1280 = load i32, ptr %53, align 4, !tbaa !9
  %1281 = add nsw i32 %1280, 1
  %1282 = load i32, ptr %53, align 4, !tbaa !9
  %1283 = load i32, ptr %27, align 4, !tbaa !9
  %1284 = mul nsw i32 %1282, %1283
  %1285 = add nsw i32 %1281, %1284
  store i32 %1285, ptr %32, align 4, !tbaa !9
  %1286 = load ptr, ptr %19, align 8, !tbaa !5
  %1287 = load i32, ptr %32, align 4, !tbaa !9
  %1288 = sext i32 %1287 to i64
  %1289 = getelementptr inbounds %struct.doublecomplex, ptr %1286, i64 %1288
  %1290 = getelementptr inbounds %struct.doublecomplex, ptr %1289, i32 0, i32 0
  %1291 = load double, ptr %1290, align 8, !tbaa !11
  store double %1291, ptr %36, align 8, !tbaa !17
  %1292 = load double, ptr %36, align 8, !tbaa !17
  %1293 = fcmp oge double %1292, 0.000000e+00
  br i1 %1293, label %1294, label %1296

1294:                                             ; preds = %1279
  %1295 = load double, ptr %36, align 8, !tbaa !17
  br label %1299

1296:                                             ; preds = %1279
  %1297 = load double, ptr %36, align 8, !tbaa !17
  %1298 = fneg double %1297
  br label %1299

1299:                                             ; preds = %1296, %1294
  %1300 = phi double [ %1295, %1294 ], [ %1298, %1296 ]
  %1301 = fmul double %1300, 7.500000e-01
  store double %1301, ptr %55, align 8, !tbaa !17
  %1302 = load i32, ptr %53, align 4, !tbaa !9
  %1303 = load i32, ptr %53, align 4, !tbaa !9
  %1304 = load i32, ptr %27, align 4, !tbaa !9
  %1305 = mul nsw i32 %1303, %1304
  %1306 = add nsw i32 %1302, %1305
  store i32 %1306, ptr %32, align 4, !tbaa !9
  %1307 = load double, ptr %55, align 8, !tbaa !17
  %1308 = load ptr, ptr %19, align 8, !tbaa !5
  %1309 = load i32, ptr %32, align 4, !tbaa !9
  %1310 = sext i32 %1309 to i64
  %1311 = getelementptr inbounds %struct.doublecomplex, ptr %1308, i64 %1310
  %1312 = getelementptr inbounds %struct.doublecomplex, ptr %1311, i32 0, i32 0
  %1313 = load double, ptr %1312, align 8, !tbaa !11
  %1314 = fadd double %1307, %1313
  %1315 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1314, ptr %1315, align 8, !tbaa !11
  %1316 = load ptr, ptr %19, align 8, !tbaa !5
  %1317 = load i32, ptr %32, align 4, !tbaa !9
  %1318 = sext i32 %1317 to i64
  %1319 = getelementptr inbounds %struct.doublecomplex, ptr %1316, i64 %1318
  %1320 = getelementptr inbounds %struct.doublecomplex, ptr %1319, i32 0, i32 1
  %1321 = load double, ptr %1320, align 8, !tbaa !14
  %1322 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1321, ptr %1322, align 8, !tbaa !14
  %1323 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1324 = load double, ptr %1323, align 8, !tbaa !11
  %1325 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1324, ptr %1325, align 8, !tbaa !11
  %1326 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1327 = load double, ptr %1326, align 8, !tbaa !14
  %1328 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1327, ptr %1328, align 8, !tbaa !14
  br label %1808

1329:                                             ; preds = %1276
  %1330 = load i32, ptr %86, align 4, !tbaa !9
  %1331 = icmp eq i32 %1330, 20
  br i1 %1331, label %1332, label %1382

1332:                                             ; preds = %1329
  %1333 = load i32, ptr %50, align 4, !tbaa !9
  %1334 = load i32, ptr %50, align 4, !tbaa !9
  %1335 = sub nsw i32 %1334, 1
  %1336 = load i32, ptr %27, align 4, !tbaa !9
  %1337 = mul nsw i32 %1335, %1336
  %1338 = add nsw i32 %1333, %1337
  store i32 %1338, ptr %32, align 4, !tbaa !9
  %1339 = load ptr, ptr %19, align 8, !tbaa !5
  %1340 = load i32, ptr %32, align 4, !tbaa !9
  %1341 = sext i32 %1340 to i64
  %1342 = getelementptr inbounds %struct.doublecomplex, ptr %1339, i64 %1341
  %1343 = getelementptr inbounds %struct.doublecomplex, ptr %1342, i32 0, i32 0
  %1344 = load double, ptr %1343, align 8, !tbaa !11
  store double %1344, ptr %36, align 8, !tbaa !17
  %1345 = load double, ptr %36, align 8, !tbaa !17
  %1346 = fcmp oge double %1345, 0.000000e+00
  br i1 %1346, label %1347, label %1349

1347:                                             ; preds = %1332
  %1348 = load double, ptr %36, align 8, !tbaa !17
  br label %1352

1349:                                             ; preds = %1332
  %1350 = load double, ptr %36, align 8, !tbaa !17
  %1351 = fneg double %1350
  br label %1352

1352:                                             ; preds = %1349, %1347
  %1353 = phi double [ %1348, %1347 ], [ %1351, %1349 ]
  %1354 = fmul double %1353, 7.500000e-01
  store double %1354, ptr %55, align 8, !tbaa !17
  %1355 = load i32, ptr %50, align 4, !tbaa !9
  %1356 = load i32, ptr %50, align 4, !tbaa !9
  %1357 = load i32, ptr %27, align 4, !tbaa !9
  %1358 = mul nsw i32 %1356, %1357
  %1359 = add nsw i32 %1355, %1358
  store i32 %1359, ptr %32, align 4, !tbaa !9
  %1360 = load double, ptr %55, align 8, !tbaa !17
  %1361 = load ptr, ptr %19, align 8, !tbaa !5
  %1362 = load i32, ptr %32, align 4, !tbaa !9
  %1363 = sext i32 %1362 to i64
  %1364 = getelementptr inbounds %struct.doublecomplex, ptr %1361, i64 %1363
  %1365 = getelementptr inbounds %struct.doublecomplex, ptr %1364, i32 0, i32 0
  %1366 = load double, ptr %1365, align 8, !tbaa !11
  %1367 = fadd double %1360, %1366
  %1368 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1367, ptr %1368, align 8, !tbaa !11
  %1369 = load ptr, ptr %19, align 8, !tbaa !5
  %1370 = load i32, ptr %32, align 4, !tbaa !9
  %1371 = sext i32 %1370 to i64
  %1372 = getelementptr inbounds %struct.doublecomplex, ptr %1369, i64 %1371
  %1373 = getelementptr inbounds %struct.doublecomplex, ptr %1372, i32 0, i32 1
  %1374 = load double, ptr %1373, align 8, !tbaa !14
  %1375 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1374, ptr %1375, align 8, !tbaa !14
  %1376 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1377 = load double, ptr %1376, align 8, !tbaa !11
  %1378 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1377, ptr %1378, align 8, !tbaa !11
  %1379 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1380 = load double, ptr %1379, align 8, !tbaa !14
  %1381 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1380, ptr %1381, align 8, !tbaa !14
  br label %1807

1382:                                             ; preds = %1329
  %1383 = load i32, ptr %50, align 4, !tbaa !9
  %1384 = load i32, ptr %50, align 4, !tbaa !9
  %1385 = load i32, ptr %27, align 4, !tbaa !9
  %1386 = mul nsw i32 %1384, %1385
  %1387 = add nsw i32 %1383, %1386
  store i32 %1387, ptr %32, align 4, !tbaa !9
  %1388 = load ptr, ptr %19, align 8, !tbaa !5
  %1389 = load i32, ptr %32, align 4, !tbaa !9
  %1390 = sext i32 %1389 to i64
  %1391 = getelementptr inbounds %struct.doublecomplex, ptr %1388, i64 %1390
  %1392 = getelementptr inbounds %struct.doublecomplex, ptr %1391, i32 0, i32 0
  %1393 = load double, ptr %1392, align 8, !tbaa !11
  %1394 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1393, ptr %1394, align 8, !tbaa !11
  %1395 = load ptr, ptr %19, align 8, !tbaa !5
  %1396 = load i32, ptr %32, align 4, !tbaa !9
  %1397 = sext i32 %1396 to i64
  %1398 = getelementptr inbounds %struct.doublecomplex, ptr %1395, i64 %1397
  %1399 = getelementptr inbounds %struct.doublecomplex, ptr %1398, i32 0, i32 1
  %1400 = load double, ptr %1399, align 8, !tbaa !14
  %1401 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1400, ptr %1401, align 8, !tbaa !14
  %1402 = load ptr, ptr %19, align 8, !tbaa !5
  %1403 = load i32, ptr %50, align 4, !tbaa !9
  %1404 = sub nsw i32 %1403, 1
  %1405 = load i32, ptr %50, align 4, !tbaa !9
  %1406 = load i32, ptr %27, align 4, !tbaa !9
  %1407 = mul nsw i32 %1405, %1406
  %1408 = add nsw i32 %1404, %1407
  %1409 = sext i32 %1408 to i64
  %1410 = getelementptr inbounds %struct.doublecomplex, ptr %1402, i64 %1409
  %1411 = call { double, double } @Cd(ptr noundef %1410)
  %1412 = extractvalue { double, double } %1411, 0
  %1413 = extractvalue { double, double } %1411, 1
  %1414 = getelementptr inbounds { double, double }, ptr %93, i32 0, i32 0
  %1415 = getelementptr inbounds { double, double }, ptr %93, i32 0, i32 1
  store double %1412, ptr %1414, align 8
  store double %1413, ptr %1415, align 8
  %1416 = getelementptr inbounds { double, double }, ptr %93, i32 0, i32 0
  %1417 = load double, ptr %1416, align 8
  %1418 = getelementptr inbounds { double, double }, ptr %93, i32 0, i32 1
  %1419 = load double, ptr %1418, align 8
  %1420 = call { double, double } @csqrt(double noundef %1417, double noundef %1419) #6
  %1421 = extractvalue { double, double } %1420, 0
  %1422 = extractvalue { double, double } %1420, 1
  %1423 = call ptr @_pCd(ptr noundef %43)
  %1424 = getelementptr inbounds { double, double }, ptr %1423, i32 0, i32 0
  %1425 = getelementptr inbounds { double, double }, ptr %1423, i32 0, i32 1
  store double %1421, ptr %1424, align 8
  store double %1422, ptr %1425, align 8
  %1426 = load ptr, ptr %19, align 8, !tbaa !5
  %1427 = load i32, ptr %50, align 4, !tbaa !9
  %1428 = load i32, ptr %50, align 4, !tbaa !9
  %1429 = sub nsw i32 %1428, 1
  %1430 = load i32, ptr %27, align 4, !tbaa !9
  %1431 = mul nsw i32 %1429, %1430
  %1432 = add nsw i32 %1427, %1431
  %1433 = sext i32 %1432 to i64
  %1434 = getelementptr inbounds %struct.doublecomplex, ptr %1426, i64 %1433
  %1435 = call { double, double } @Cd(ptr noundef %1434)
  %1436 = extractvalue { double, double } %1435, 0
  %1437 = extractvalue { double, double } %1435, 1
  %1438 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 0
  %1439 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 1
  store double %1436, ptr %1438, align 8
  store double %1437, ptr %1439, align 8
  %1440 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 0
  %1441 = load double, ptr %1440, align 8
  %1442 = getelementptr inbounds { double, double }, ptr %94, i32 0, i32 1
  %1443 = load double, ptr %1442, align 8
  %1444 = call { double, double } @csqrt(double noundef %1441, double noundef %1443) #6
  %1445 = extractvalue { double, double } %1444, 0
  %1446 = extractvalue { double, double } %1444, 1
  %1447 = call ptr @_pCd(ptr noundef %44)
  %1448 = getelementptr inbounds { double, double }, ptr %1447, i32 0, i32 0
  %1449 = getelementptr inbounds { double, double }, ptr %1447, i32 0, i32 1
  store double %1445, ptr %1448, align 8
  store double %1446, ptr %1449, align 8
  %1450 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1451 = load double, ptr %1450, align 8, !tbaa !11
  %1452 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1453 = load double, ptr %1452, align 8, !tbaa !11
  %1454 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1455 = load double, ptr %1454, align 8, !tbaa !14
  %1456 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1457 = load double, ptr %1456, align 8, !tbaa !14
  %1458 = fmul double %1455, %1457
  %1459 = fneg double %1458
  %1460 = call double @llvm.fmuladd.f64(double %1451, double %1453, double %1459)
  %1461 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1460, ptr %1461, align 8, !tbaa !11
  %1462 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1463 = load double, ptr %1462, align 8, !tbaa !11
  %1464 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1465 = load double, ptr %1464, align 8, !tbaa !14
  %1466 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1467 = load double, ptr %1466, align 8, !tbaa !14
  %1468 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1469 = load double, ptr %1468, align 8, !tbaa !11
  %1470 = fmul double %1467, %1469
  %1471 = call double @llvm.fmuladd.f64(double %1463, double %1465, double %1470)
  %1472 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1471, ptr %1472, align 8, !tbaa !14
  %1473 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1474 = load double, ptr %1473, align 8, !tbaa !11
  %1475 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  store double %1474, ptr %1475, align 8, !tbaa !11
  %1476 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1477 = load double, ptr %1476, align 8, !tbaa !14
  %1478 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  store double %1477, ptr %1478, align 8, !tbaa !14
  %1479 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %1480 = load double, ptr %1479, align 8, !tbaa !11
  store double %1480, ptr %36, align 8, !tbaa !17
  %1481 = load double, ptr %36, align 8, !tbaa !17
  %1482 = fcmp oge double %1481, 0.000000e+00
  br i1 %1482, label %1483, label %1485

1483:                                             ; preds = %1382
  %1484 = load double, ptr %36, align 8, !tbaa !17
  br label %1488

1485:                                             ; preds = %1382
  %1486 = load double, ptr %36, align 8, !tbaa !17
  %1487 = fneg double %1486
  br label %1488

1488:                                             ; preds = %1485, %1483
  %1489 = phi double [ %1484, %1483 ], [ %1487, %1485 ]
  %1490 = call { double, double } @Cd(ptr noundef %57)
  %1491 = extractvalue { double, double } %1490, 0
  %1492 = extractvalue { double, double } %1490, 1
  store double %1492, ptr %37, align 8, !tbaa !17
  %1493 = load double, ptr %37, align 8, !tbaa !17
  %1494 = fcmp oge double %1493, 0.000000e+00
  br i1 %1494, label %1495, label %1497

1495:                                             ; preds = %1488
  %1496 = load double, ptr %37, align 8, !tbaa !17
  br label %1500

1497:                                             ; preds = %1488
  %1498 = load double, ptr %37, align 8, !tbaa !17
  %1499 = fneg double %1498
  br label %1500

1500:                                             ; preds = %1497, %1495
  %1501 = phi double [ %1496, %1495 ], [ %1499, %1497 ]
  %1502 = fadd double %1489, %1501
  store double %1502, ptr %55, align 8, !tbaa !17
  %1503 = load double, ptr %55, align 8, !tbaa !17
  %1504 = fcmp une double %1503, 0.000000e+00
  br i1 %1504, label %1505, label %1806

1505:                                             ; preds = %1500
  %1506 = load i32, ptr %50, align 4, !tbaa !9
  %1507 = sub nsw i32 %1506, 1
  %1508 = load i32, ptr %50, align 4, !tbaa !9
  %1509 = sub nsw i32 %1508, 1
  %1510 = load i32, ptr %27, align 4, !tbaa !9
  %1511 = mul nsw i32 %1509, %1510
  %1512 = add nsw i32 %1507, %1511
  store i32 %1512, ptr %32, align 4, !tbaa !9
  %1513 = load ptr, ptr %19, align 8, !tbaa !5
  %1514 = load i32, ptr %32, align 4, !tbaa !9
  %1515 = sext i32 %1514 to i64
  %1516 = getelementptr inbounds %struct.doublecomplex, ptr %1513, i64 %1515
  %1517 = getelementptr inbounds %struct.doublecomplex, ptr %1516, i32 0, i32 0
  %1518 = load double, ptr %1517, align 8, !tbaa !11
  %1519 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1520 = load double, ptr %1519, align 8, !tbaa !11
  %1521 = fsub double %1518, %1520
  %1522 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1521, ptr %1522, align 8, !tbaa !11
  %1523 = load ptr, ptr %19, align 8, !tbaa !5
  %1524 = load i32, ptr %32, align 4, !tbaa !9
  %1525 = sext i32 %1524 to i64
  %1526 = getelementptr inbounds %struct.doublecomplex, ptr %1523, i64 %1525
  %1527 = getelementptr inbounds %struct.doublecomplex, ptr %1526, i32 0, i32 1
  %1528 = load double, ptr %1527, align 8, !tbaa !14
  %1529 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1530 = load double, ptr %1529, align 8, !tbaa !14
  %1531 = fsub double %1528, %1530
  %1532 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1531, ptr %1532, align 8, !tbaa !14
  %1533 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1534 = load double, ptr %1533, align 8, !tbaa !11
  %1535 = fmul double %1534, 5.000000e-01
  %1536 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1535, ptr %1536, align 8, !tbaa !11
  %1537 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1538 = load double, ptr %1537, align 8, !tbaa !14
  %1539 = fmul double %1538, 5.000000e-01
  %1540 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1539, ptr %1540, align 8, !tbaa !14
  %1541 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1542 = load double, ptr %1541, align 8, !tbaa !11
  %1543 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  store double %1542, ptr %1543, align 8, !tbaa !11
  %1544 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1545 = load double, ptr %1544, align 8, !tbaa !14
  %1546 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 1
  store double %1545, ptr %1546, align 8, !tbaa !14
  %1547 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1548 = load double, ptr %1547, align 8, !tbaa !11
  store double %1548, ptr %36, align 8, !tbaa !17
  %1549 = load double, ptr %36, align 8, !tbaa !17
  %1550 = fcmp oge double %1549, 0.000000e+00
  br i1 %1550, label %1551, label %1553

1551:                                             ; preds = %1505
  %1552 = load double, ptr %36, align 8, !tbaa !17
  br label %1556

1553:                                             ; preds = %1505
  %1554 = load double, ptr %36, align 8, !tbaa !17
  %1555 = fneg double %1554
  br label %1556

1556:                                             ; preds = %1553, %1551
  %1557 = phi double [ %1552, %1551 ], [ %1555, %1553 ]
  %1558 = call { double, double } @Cd(ptr noundef %59)
  %1559 = extractvalue { double, double } %1558, 0
  %1560 = extractvalue { double, double } %1558, 1
  store double %1560, ptr %37, align 8, !tbaa !17
  %1561 = load double, ptr %37, align 8, !tbaa !17
  %1562 = fcmp oge double %1561, 0.000000e+00
  br i1 %1562, label %1563, label %1565

1563:                                             ; preds = %1556
  %1564 = load double, ptr %37, align 8, !tbaa !17
  br label %1568

1565:                                             ; preds = %1556
  %1566 = load double, ptr %37, align 8, !tbaa !17
  %1567 = fneg double %1566
  br label %1568

1568:                                             ; preds = %1565, %1563
  %1569 = phi double [ %1564, %1563 ], [ %1567, %1565 ]
  %1570 = fadd double %1557, %1569
  store double %1570, ptr %79, align 8, !tbaa !17
  %1571 = load double, ptr %55, align 8, !tbaa !17
  store double %1571, ptr %38, align 8, !tbaa !17
  %1572 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1573 = load double, ptr %1572, align 8, !tbaa !11
  store double %1573, ptr %36, align 8, !tbaa !17
  %1574 = load double, ptr %36, align 8, !tbaa !17
  %1575 = fcmp oge double %1574, 0.000000e+00
  br i1 %1575, label %1576, label %1578

1576:                                             ; preds = %1568
  %1577 = load double, ptr %36, align 8, !tbaa !17
  br label %1581

1578:                                             ; preds = %1568
  %1579 = load double, ptr %36, align 8, !tbaa !17
  %1580 = fneg double %1579
  br label %1581

1581:                                             ; preds = %1578, %1576
  %1582 = phi double [ %1577, %1576 ], [ %1580, %1578 ]
  %1583 = call { double, double } @Cd(ptr noundef %59)
  %1584 = extractvalue { double, double } %1583, 0
  %1585 = extractvalue { double, double } %1583, 1
  store double %1585, ptr %37, align 8, !tbaa !17
  %1586 = load double, ptr %37, align 8, !tbaa !17
  %1587 = fcmp oge double %1586, 0.000000e+00
  br i1 %1587, label %1588, label %1590

1588:                                             ; preds = %1581
  %1589 = load double, ptr %37, align 8, !tbaa !17
  br label %1593

1590:                                             ; preds = %1581
  %1591 = load double, ptr %37, align 8, !tbaa !17
  %1592 = fneg double %1591
  br label %1593

1593:                                             ; preds = %1590, %1588
  %1594 = phi double [ %1589, %1588 ], [ %1592, %1590 ]
  %1595 = fadd double %1582, %1594
  store double %1595, ptr %39, align 8, !tbaa !17
  %1596 = load double, ptr %38, align 8, !tbaa !17
  %1597 = load double, ptr %39, align 8, !tbaa !17
  %1598 = fcmp oge double %1596, %1597
  br i1 %1598, label %1599, label %1601

1599:                                             ; preds = %1593
  %1600 = load double, ptr %38, align 8, !tbaa !17
  br label %1603

1601:                                             ; preds = %1593
  %1602 = load double, ptr %39, align 8, !tbaa !17
  br label %1603

1603:                                             ; preds = %1601, %1599
  %1604 = phi double [ %1600, %1599 ], [ %1602, %1601 ]
  store double %1604, ptr %55, align 8, !tbaa !17
  %1605 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1606 = load double, ptr %1605, align 8, !tbaa !11
  %1607 = load double, ptr %55, align 8, !tbaa !17
  %1608 = fdiv double %1606, %1607
  %1609 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 0
  store double %1608, ptr %1609, align 8, !tbaa !11
  %1610 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 1
  %1611 = load double, ptr %1610, align 8, !tbaa !14
  %1612 = load double, ptr %55, align 8, !tbaa !17
  %1613 = fdiv double %1611, %1612
  %1614 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 1
  store double %1613, ptr %1614, align 8, !tbaa !14
  %1615 = call { double, double } @Cd(ptr noundef %46)
  %1616 = extractvalue { double, double } %1615, 0
  %1617 = extractvalue { double, double } %1615, 1
  %1618 = load i32, ptr @c__2, align 4, !tbaa !9
  %1619 = getelementptr inbounds { double, double }, ptr %95, i32 0, i32 0
  %1620 = getelementptr inbounds { double, double }, ptr %95, i32 0, i32 1
  store double %1616, ptr %1619, align 8
  store double %1617, ptr %1620, align 8
  %1621 = getelementptr inbounds { double, double }, ptr %95, i32 0, i32 0
  %1622 = load double, ptr %1621, align 8
  %1623 = getelementptr inbounds { double, double }, ptr %95, i32 0, i32 1
  %1624 = load double, ptr %1623, align 8
  %1625 = call { double, double } @zpow_ui(double noundef %1622, double noundef %1624, i32 noundef %1618)
  %1626 = extractvalue { double, double } %1625, 0
  %1627 = extractvalue { double, double } %1625, 1
  %1628 = call ptr @_pCd(ptr noundef %45)
  %1629 = getelementptr inbounds { double, double }, ptr %1628, i32 0, i32 0
  %1630 = getelementptr inbounds { double, double }, ptr %1628, i32 0, i32 1
  store double %1626, ptr %1629, align 8
  store double %1627, ptr %1630, align 8
  %1631 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %1632 = load double, ptr %1631, align 8, !tbaa !11
  %1633 = load double, ptr %55, align 8, !tbaa !17
  %1634 = fdiv double %1632, %1633
  %1635 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  store double %1634, ptr %1635, align 8, !tbaa !11
  %1636 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  %1637 = load double, ptr %1636, align 8, !tbaa !14
  %1638 = load double, ptr %55, align 8, !tbaa !17
  %1639 = fdiv double %1637, %1638
  %1640 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  store double %1639, ptr %1640, align 8, !tbaa !14
  %1641 = call { double, double } @Cd(ptr noundef %48)
  %1642 = extractvalue { double, double } %1641, 0
  %1643 = extractvalue { double, double } %1641, 1
  %1644 = load i32, ptr @c__2, align 4, !tbaa !9
  %1645 = getelementptr inbounds { double, double }, ptr %96, i32 0, i32 0
  %1646 = getelementptr inbounds { double, double }, ptr %96, i32 0, i32 1
  store double %1642, ptr %1645, align 8
  store double %1643, ptr %1646, align 8
  %1647 = getelementptr inbounds { double, double }, ptr %96, i32 0, i32 0
  %1648 = load double, ptr %1647, align 8
  %1649 = getelementptr inbounds { double, double }, ptr %96, i32 0, i32 1
  %1650 = load double, ptr %1649, align 8
  %1651 = call { double, double } @zpow_ui(double noundef %1648, double noundef %1650, i32 noundef %1644)
  %1652 = extractvalue { double, double } %1651, 0
  %1653 = extractvalue { double, double } %1651, 1
  %1654 = call ptr @_pCd(ptr noundef %47)
  %1655 = getelementptr inbounds { double, double }, ptr %1654, i32 0, i32 0
  %1656 = getelementptr inbounds { double, double }, ptr %1654, i32 0, i32 1
  store double %1652, ptr %1655, align 8
  store double %1653, ptr %1656, align 8
  %1657 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %1658 = load double, ptr %1657, align 8, !tbaa !11
  %1659 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %1660 = load double, ptr %1659, align 8, !tbaa !11
  %1661 = fadd double %1658, %1660
  %1662 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %1661, ptr %1662, align 8, !tbaa !11
  %1663 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %1664 = load double, ptr %1663, align 8, !tbaa !14
  %1665 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %1666 = load double, ptr %1665, align 8, !tbaa !14
  %1667 = fadd double %1664, %1666
  %1668 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %1667, ptr %1668, align 8, !tbaa !14
  %1669 = call { double, double } @Cd(ptr noundef %44)
  %1670 = extractvalue { double, double } %1669, 0
  %1671 = extractvalue { double, double } %1669, 1
  %1672 = getelementptr inbounds { double, double }, ptr %97, i32 0, i32 0
  %1673 = getelementptr inbounds { double, double }, ptr %97, i32 0, i32 1
  store double %1670, ptr %1672, align 8
  store double %1671, ptr %1673, align 8
  %1674 = getelementptr inbounds { double, double }, ptr %97, i32 0, i32 0
  %1675 = load double, ptr %1674, align 8
  %1676 = getelementptr inbounds { double, double }, ptr %97, i32 0, i32 1
  %1677 = load double, ptr %1676, align 8
  %1678 = call { double, double } @csqrt(double noundef %1675, double noundef %1677) #6
  %1679 = extractvalue { double, double } %1678, 0
  %1680 = extractvalue { double, double } %1678, 1
  %1681 = call ptr @_pCd(ptr noundef %43)
  %1682 = getelementptr inbounds { double, double }, ptr %1681, i32 0, i32 0
  %1683 = getelementptr inbounds { double, double }, ptr %1681, i32 0, i32 1
  store double %1679, ptr %1682, align 8
  store double %1680, ptr %1683, align 8
  %1684 = load double, ptr %55, align 8, !tbaa !17
  %1685 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1686 = load double, ptr %1685, align 8, !tbaa !11
  %1687 = fmul double %1684, %1686
  %1688 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1687, ptr %1688, align 8, !tbaa !11
  %1689 = load double, ptr %55, align 8, !tbaa !17
  %1690 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1691 = load double, ptr %1690, align 8, !tbaa !14
  %1692 = fmul double %1689, %1691
  %1693 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1692, ptr %1693, align 8, !tbaa !14
  %1694 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1695 = load double, ptr %1694, align 8, !tbaa !11
  %1696 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 0
  store double %1695, ptr %1696, align 8, !tbaa !11
  %1697 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1698 = load double, ptr %1697, align 8, !tbaa !14
  %1699 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 1
  store double %1698, ptr %1699, align 8, !tbaa !14
  %1700 = load double, ptr %79, align 8, !tbaa !17
  %1701 = fcmp ogt double %1700, 0.000000e+00
  br i1 %1701, label %1702, label %1752

1702:                                             ; preds = %1603
  %1703 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1704 = load double, ptr %1703, align 8, !tbaa !11
  %1705 = load double, ptr %79, align 8, !tbaa !17
  %1706 = fdiv double %1704, %1705
  %1707 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1706, ptr %1707, align 8, !tbaa !11
  %1708 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 1
  %1709 = load double, ptr %1708, align 8, !tbaa !14
  %1710 = load double, ptr %79, align 8, !tbaa !17
  %1711 = fdiv double %1709, %1710
  %1712 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1711, ptr %1712, align 8, !tbaa !14
  %1713 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1714 = load double, ptr %1713, align 8, !tbaa !11
  %1715 = load double, ptr %79, align 8, !tbaa !17
  %1716 = fdiv double %1714, %1715
  %1717 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1716, ptr %1717, align 8, !tbaa !11
  %1718 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 1
  %1719 = load double, ptr %1718, align 8, !tbaa !14
  %1720 = load double, ptr %79, align 8, !tbaa !17
  %1721 = fdiv double %1719, %1720
  %1722 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1721, ptr %1722, align 8, !tbaa !14
  %1723 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1724 = load double, ptr %1723, align 8, !tbaa !11
  %1725 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 0
  %1726 = load double, ptr %1725, align 8, !tbaa !11
  %1727 = call { double, double } @Cd(ptr noundef %43)
  %1728 = extractvalue { double, double } %1727, 0
  %1729 = extractvalue { double, double } %1727, 1
  %1730 = call { double, double } @Cd(ptr noundef %60)
  %1731 = extractvalue { double, double } %1730, 0
  %1732 = extractvalue { double, double } %1730, 1
  %1733 = fmul double %1729, %1732
  %1734 = call double @llvm.fmuladd.f64(double %1724, double %1726, double %1733)
  %1735 = fcmp olt double %1734, 0.000000e+00
  br i1 %1735, label %1736, label %1751

1736:                                             ; preds = %1702
  %1737 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 0
  %1738 = load double, ptr %1737, align 8, !tbaa !11
  %1739 = fneg double %1738
  %1740 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %1739, ptr %1740, align 8, !tbaa !11
  %1741 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 1
  %1742 = load double, ptr %1741, align 8, !tbaa !14
  %1743 = fneg double %1742
  %1744 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %1743, ptr %1744, align 8, !tbaa !14
  %1745 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1746 = load double, ptr %1745, align 8, !tbaa !11
  %1747 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 0
  store double %1746, ptr %1747, align 8, !tbaa !11
  %1748 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1749 = load double, ptr %1748, align 8, !tbaa !14
  %1750 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 1
  store double %1749, ptr %1750, align 8, !tbaa !14
  br label %1751

1751:                                             ; preds = %1736, %1702
  br label %1752

1752:                                             ; preds = %1751, %1603
  %1753 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 0
  %1754 = load double, ptr %1753, align 8, !tbaa !11
  %1755 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 0
  %1756 = load double, ptr %1755, align 8, !tbaa !11
  %1757 = fadd double %1754, %1756
  %1758 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  store double %1757, ptr %1758, align 8, !tbaa !11
  %1759 = getelementptr inbounds %struct.doublecomplex, ptr %59, i32 0, i32 1
  %1760 = load double, ptr %1759, align 8, !tbaa !14
  %1761 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 0, i32 1
  %1762 = load double, ptr %1761, align 8, !tbaa !14
  %1763 = fadd double %1760, %1762
  %1764 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  store double %1763, ptr %1764, align 8, !tbaa !14
  call void @zladiv_(ptr noundef %44, ptr noundef %57, ptr noundef %45)
  %1765 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %1766 = load double, ptr %1765, align 8, !tbaa !11
  %1767 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1768 = load double, ptr %1767, align 8, !tbaa !11
  %1769 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  %1770 = load double, ptr %1769, align 8, !tbaa !14
  %1771 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1772 = load double, ptr %1771, align 8, !tbaa !14
  %1773 = fmul double %1770, %1772
  %1774 = fneg double %1773
  %1775 = call double @llvm.fmuladd.f64(double %1766, double %1768, double %1774)
  %1776 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1775, ptr %1776, align 8, !tbaa !11
  %1777 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %1778 = load double, ptr %1777, align 8, !tbaa !11
  %1779 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1780 = load double, ptr %1779, align 8, !tbaa !14
  %1781 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  %1782 = load double, ptr %1781, align 8, !tbaa !14
  %1783 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1784 = load double, ptr %1783, align 8, !tbaa !11
  %1785 = fmul double %1782, %1784
  %1786 = call double @llvm.fmuladd.f64(double %1778, double %1780, double %1785)
  %1787 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1786, ptr %1787, align 8, !tbaa !14
  %1788 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1789 = load double, ptr %1788, align 8, !tbaa !11
  %1790 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1791 = load double, ptr %1790, align 8, !tbaa !11
  %1792 = fsub double %1789, %1791
  %1793 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1792, ptr %1793, align 8, !tbaa !11
  %1794 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1795 = load double, ptr %1794, align 8, !tbaa !14
  %1796 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1797 = load double, ptr %1796, align 8, !tbaa !14
  %1798 = fsub double %1795, %1797
  %1799 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1798, ptr %1799, align 8, !tbaa !14
  %1800 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1801 = load double, ptr %1800, align 8, !tbaa !11
  %1802 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1801, ptr %1802, align 8, !tbaa !11
  %1803 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1804 = load double, ptr %1803, align 8, !tbaa !14
  %1805 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1804, ptr %1805, align 8, !tbaa !14
  br label %1806

1806:                                             ; preds = %1752, %1500
  br label %1807

1807:                                             ; preds = %1806, %1352
  br label %1808

1808:                                             ; preds = %1807, %1299
  %1809 = load i32, ptr %53, align 4, !tbaa !9
  %1810 = add nsw i32 %1809, 1
  store i32 %1810, ptr %32, align 4, !tbaa !9
  %1811 = load i32, ptr %50, align 4, !tbaa !9
  %1812 = sub nsw i32 %1811, 1
  store i32 %1812, ptr %54, align 4, !tbaa !9
  br label %1813

1813:                                             ; preds = %2064, %1808
  %1814 = load i32, ptr %54, align 4, !tbaa !9
  %1815 = load i32, ptr %32, align 4, !tbaa !9
  %1816 = icmp sge i32 %1814, %1815
  br i1 %1816, label %1817, label %2067

1817:                                             ; preds = %1813
  %1818 = load i32, ptr %54, align 4, !tbaa !9
  %1819 = load i32, ptr %54, align 4, !tbaa !9
  %1820 = load i32, ptr %27, align 4, !tbaa !9
  %1821 = mul nsw i32 %1819, %1820
  %1822 = add nsw i32 %1818, %1821
  store i32 %1822, ptr %33, align 4, !tbaa !9
  %1823 = load ptr, ptr %19, align 8, !tbaa !5
  %1824 = load i32, ptr %33, align 4, !tbaa !9
  %1825 = sext i32 %1824 to i64
  %1826 = getelementptr inbounds %struct.doublecomplex, ptr %1823, i64 %1825
  %1827 = getelementptr inbounds %struct.doublecomplex, ptr %1826, i32 0, i32 0
  %1828 = load double, ptr %1827, align 8, !tbaa !11
  %1829 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 0
  store double %1828, ptr %1829, align 8, !tbaa !11
  %1830 = load ptr, ptr %19, align 8, !tbaa !5
  %1831 = load i32, ptr %33, align 4, !tbaa !9
  %1832 = sext i32 %1831 to i64
  %1833 = getelementptr inbounds %struct.doublecomplex, ptr %1830, i64 %1832
  %1834 = getelementptr inbounds %struct.doublecomplex, ptr %1833, i32 0, i32 1
  %1835 = load double, ptr %1834, align 8, !tbaa !14
  %1836 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 1
  store double %1835, ptr %1836, align 8, !tbaa !14
  %1837 = load i32, ptr %54, align 4, !tbaa !9
  %1838 = add nsw i32 %1837, 1
  %1839 = load i32, ptr %54, align 4, !tbaa !9
  %1840 = add nsw i32 %1839, 1
  %1841 = load i32, ptr %27, align 4, !tbaa !9
  %1842 = mul nsw i32 %1840, %1841
  %1843 = add nsw i32 %1838, %1842
  store i32 %1843, ptr %33, align 4, !tbaa !9
  %1844 = load ptr, ptr %19, align 8, !tbaa !5
  %1845 = load i32, ptr %33, align 4, !tbaa !9
  %1846 = sext i32 %1845 to i64
  %1847 = getelementptr inbounds %struct.doublecomplex, ptr %1844, i64 %1846
  %1848 = getelementptr inbounds %struct.doublecomplex, ptr %1847, i32 0, i32 0
  %1849 = load double, ptr %1848, align 8, !tbaa !11
  %1850 = getelementptr inbounds %struct.doublecomplex, ptr %75, i32 0, i32 0
  store double %1849, ptr %1850, align 8, !tbaa !11
  %1851 = load ptr, ptr %19, align 8, !tbaa !5
  %1852 = load i32, ptr %33, align 4, !tbaa !9
  %1853 = sext i32 %1852 to i64
  %1854 = getelementptr inbounds %struct.doublecomplex, ptr %1851, i64 %1853
  %1855 = getelementptr inbounds %struct.doublecomplex, ptr %1854, i32 0, i32 1
  %1856 = load double, ptr %1855, align 8, !tbaa !14
  %1857 = getelementptr inbounds %struct.doublecomplex, ptr %75, i32 0, i32 1
  store double %1856, ptr %1857, align 8, !tbaa !14
  %1858 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 0
  %1859 = load double, ptr %1858, align 8, !tbaa !11
  %1860 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1861 = load double, ptr %1860, align 8, !tbaa !11
  %1862 = fsub double %1859, %1861
  %1863 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1862, ptr %1863, align 8, !tbaa !11
  %1864 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 1
  %1865 = load double, ptr %1864, align 8, !tbaa !14
  %1866 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1867 = load double, ptr %1866, align 8, !tbaa !14
  %1868 = fsub double %1865, %1867
  %1869 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1868, ptr %1869, align 8, !tbaa !14
  %1870 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1871 = load double, ptr %1870, align 8, !tbaa !11
  %1872 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %1871, ptr %1872, align 8, !tbaa !11
  %1873 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1874 = load double, ptr %1873, align 8, !tbaa !14
  %1875 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %1874, ptr %1875, align 8, !tbaa !14
  %1876 = load i32, ptr %54, align 4, !tbaa !9
  %1877 = add nsw i32 %1876, 1
  %1878 = load i32, ptr %54, align 4, !tbaa !9
  %1879 = load i32, ptr %27, align 4, !tbaa !9
  %1880 = mul nsw i32 %1878, %1879
  %1881 = add nsw i32 %1877, %1880
  store i32 %1881, ptr %33, align 4, !tbaa !9
  %1882 = load ptr, ptr %19, align 8, !tbaa !5
  %1883 = load i32, ptr %33, align 4, !tbaa !9
  %1884 = sext i32 %1883 to i64
  %1885 = getelementptr inbounds %struct.doublecomplex, ptr %1882, i64 %1884
  %1886 = getelementptr inbounds %struct.doublecomplex, ptr %1885, i32 0, i32 0
  %1887 = load double, ptr %1886, align 8, !tbaa !11
  store double %1887, ptr %74, align 8, !tbaa !17
  %1888 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1889 = load double, ptr %1888, align 8, !tbaa !11
  store double %1889, ptr %36, align 8, !tbaa !17
  %1890 = load double, ptr %36, align 8, !tbaa !17
  %1891 = fcmp oge double %1890, 0.000000e+00
  br i1 %1891, label %1892, label %1894

1892:                                             ; preds = %1817
  %1893 = load double, ptr %36, align 8, !tbaa !17
  br label %1897

1894:                                             ; preds = %1817
  %1895 = load double, ptr %36, align 8, !tbaa !17
  %1896 = fneg double %1895
  br label %1897

1897:                                             ; preds = %1894, %1892
  %1898 = phi double [ %1893, %1892 ], [ %1896, %1894 ]
  %1899 = call { double, double } @Cd(ptr noundef %84)
  %1900 = extractvalue { double, double } %1899, 0
  %1901 = extractvalue { double, double } %1899, 1
  store double %1901, ptr %37, align 8, !tbaa !17
  %1902 = load double, ptr %37, align 8, !tbaa !17
  %1903 = fcmp oge double %1902, 0.000000e+00
  br i1 %1903, label %1904, label %1906

1904:                                             ; preds = %1897
  %1905 = load double, ptr %37, align 8, !tbaa !17
  br label %1909

1906:                                             ; preds = %1897
  %1907 = load double, ptr %37, align 8, !tbaa !17
  %1908 = fneg double %1907
  br label %1909

1909:                                             ; preds = %1906, %1904
  %1910 = phi double [ %1905, %1904 ], [ %1908, %1906 ]
  %1911 = fadd double %1898, %1910
  %1912 = load double, ptr %74, align 8, !tbaa !17
  %1913 = fcmp oge double %1912, 0.000000e+00
  br i1 %1913, label %1914, label %1916

1914:                                             ; preds = %1909
  %1915 = load double, ptr %74, align 8, !tbaa !17
  br label %1919

1916:                                             ; preds = %1909
  %1917 = load double, ptr %74, align 8, !tbaa !17
  %1918 = fneg double %1917
  br label %1919

1919:                                             ; preds = %1916, %1914
  %1920 = phi double [ %1915, %1914 ], [ %1918, %1916 ]
  %1921 = fadd double %1911, %1920
  store double %1921, ptr %55, align 8, !tbaa !17
  %1922 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1923 = load double, ptr %1922, align 8, !tbaa !11
  %1924 = load double, ptr %55, align 8, !tbaa !17
  %1925 = fdiv double %1923, %1924
  %1926 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1925, ptr %1926, align 8, !tbaa !11
  %1927 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %1928 = load double, ptr %1927, align 8, !tbaa !14
  %1929 = load double, ptr %55, align 8, !tbaa !17
  %1930 = fdiv double %1928, %1929
  %1931 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1930, ptr %1931, align 8, !tbaa !14
  %1932 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1933 = load double, ptr %1932, align 8, !tbaa !11
  %1934 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %1933, ptr %1934, align 8, !tbaa !11
  %1935 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1936 = load double, ptr %1935, align 8, !tbaa !14
  %1937 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %1936, ptr %1937, align 8, !tbaa !14
  %1938 = load double, ptr %55, align 8, !tbaa !17
  %1939 = load double, ptr %74, align 8, !tbaa !17
  %1940 = fdiv double %1939, %1938
  store double %1940, ptr %74, align 8, !tbaa !17
  %1941 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1942 = load double, ptr %1941, align 8, !tbaa !11
  %1943 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %1944 = getelementptr inbounds %struct.doublecomplex, ptr %1943, i32 0, i32 0
  store double %1942, ptr %1944, align 16, !tbaa !11
  %1945 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %1946 = load double, ptr %1945, align 8, !tbaa !14
  %1947 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %1948 = getelementptr inbounds %struct.doublecomplex, ptr %1947, i32 0, i32 1
  store double %1946, ptr %1948, align 8, !tbaa !14
  %1949 = load double, ptr %74, align 8, !tbaa !17
  %1950 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %1951 = getelementptr inbounds %struct.doublecomplex, ptr %1950, i32 0, i32 0
  store double %1949, ptr %1951, align 16, !tbaa !11
  %1952 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %1953 = getelementptr inbounds %struct.doublecomplex, ptr %1952, i32 0, i32 1
  store double 0.000000e+00, ptr %1953, align 8, !tbaa !14
  %1954 = load i32, ptr %54, align 4, !tbaa !9
  %1955 = load i32, ptr %54, align 4, !tbaa !9
  %1956 = sub nsw i32 %1955, 1
  %1957 = load i32, ptr %27, align 4, !tbaa !9
  %1958 = mul nsw i32 %1956, %1957
  %1959 = add nsw i32 %1954, %1958
  store i32 %1959, ptr %33, align 4, !tbaa !9
  %1960 = load ptr, ptr %19, align 8, !tbaa !5
  %1961 = load i32, ptr %33, align 4, !tbaa !9
  %1962 = sext i32 %1961 to i64
  %1963 = getelementptr inbounds %struct.doublecomplex, ptr %1960, i64 %1962
  %1964 = getelementptr inbounds %struct.doublecomplex, ptr %1963, i32 0, i32 0
  %1965 = load double, ptr %1964, align 8, !tbaa !11
  store double %1965, ptr %72, align 8, !tbaa !17
  %1966 = load double, ptr %72, align 8, !tbaa !17
  %1967 = fcmp oge double %1966, 0.000000e+00
  br i1 %1967, label %1968, label %1970

1968:                                             ; preds = %1919
  %1969 = load double, ptr %72, align 8, !tbaa !17
  br label %1973

1970:                                             ; preds = %1919
  %1971 = load double, ptr %72, align 8, !tbaa !17
  %1972 = fneg double %1971
  br label %1973

1973:                                             ; preds = %1970, %1968
  %1974 = phi double [ %1969, %1968 ], [ %1972, %1970 ]
  %1975 = load double, ptr %74, align 8, !tbaa !17
  %1976 = fcmp oge double %1975, 0.000000e+00
  br i1 %1976, label %1977, label %1979

1977:                                             ; preds = %1973
  %1978 = load double, ptr %74, align 8, !tbaa !17
  br label %1982

1979:                                             ; preds = %1973
  %1980 = load double, ptr %74, align 8, !tbaa !17
  %1981 = fneg double %1980
  br label %1982

1982:                                             ; preds = %1979, %1977
  %1983 = phi double [ %1978, %1977 ], [ %1981, %1979 ]
  %1984 = fmul double %1974, %1983
  %1985 = load double, ptr %87, align 8, !tbaa !17
  %1986 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1987 = load double, ptr %1986, align 8, !tbaa !11
  store double %1987, ptr %36, align 8, !tbaa !17
  %1988 = load double, ptr %36, align 8, !tbaa !17
  %1989 = fcmp oge double %1988, 0.000000e+00
  br i1 %1989, label %1990, label %1992

1990:                                             ; preds = %1982
  %1991 = load double, ptr %36, align 8, !tbaa !17
  br label %1995

1992:                                             ; preds = %1982
  %1993 = load double, ptr %36, align 8, !tbaa !17
  %1994 = fneg double %1993
  br label %1995

1995:                                             ; preds = %1992, %1990
  %1996 = phi double [ %1991, %1990 ], [ %1994, %1992 ]
  %1997 = call { double, double } @Cd(ptr noundef %84)
  %1998 = extractvalue { double, double } %1997, 0
  %1999 = extractvalue { double, double } %1997, 1
  store double %1999, ptr %37, align 8, !tbaa !17
  %2000 = load double, ptr %37, align 8, !tbaa !17
  %2001 = fcmp oge double %2000, 0.000000e+00
  br i1 %2001, label %2002, label %2004

2002:                                             ; preds = %1995
  %2003 = load double, ptr %37, align 8, !tbaa !17
  br label %2007

2004:                                             ; preds = %1995
  %2005 = load double, ptr %37, align 8, !tbaa !17
  %2006 = fneg double %2005
  br label %2007

2007:                                             ; preds = %2004, %2002
  %2008 = phi double [ %2003, %2002 ], [ %2006, %2004 ]
  %2009 = fadd double %1996, %2008
  %2010 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 0
  %2011 = load double, ptr %2010, align 8, !tbaa !11
  store double %2011, ptr %38, align 8, !tbaa !17
  %2012 = load double, ptr %38, align 8, !tbaa !17
  %2013 = fcmp oge double %2012, 0.000000e+00
  br i1 %2013, label %2014, label %2016

2014:                                             ; preds = %2007
  %2015 = load double, ptr %38, align 8, !tbaa !17
  br label %2019

2016:                                             ; preds = %2007
  %2017 = load double, ptr %38, align 8, !tbaa !17
  %2018 = fneg double %2017
  br label %2019

2019:                                             ; preds = %2016, %2014
  %2020 = phi double [ %2015, %2014 ], [ %2018, %2016 ]
  %2021 = call { double, double } @Cd(ptr noundef %73)
  %2022 = extractvalue { double, double } %2021, 0
  %2023 = extractvalue { double, double } %2021, 1
  store double %2023, ptr %39, align 8, !tbaa !17
  %2024 = load double, ptr %39, align 8, !tbaa !17
  %2025 = fcmp oge double %2024, 0.000000e+00
  br i1 %2025, label %2026, label %2028

2026:                                             ; preds = %2019
  %2027 = load double, ptr %39, align 8, !tbaa !17
  br label %2031

2028:                                             ; preds = %2019
  %2029 = load double, ptr %39, align 8, !tbaa !17
  %2030 = fneg double %2029
  br label %2031

2031:                                             ; preds = %2028, %2026
  %2032 = phi double [ %2027, %2026 ], [ %2030, %2028 ]
  %2033 = fadd double %2020, %2032
  %2034 = getelementptr inbounds %struct.doublecomplex, ptr %75, i32 0, i32 0
  %2035 = load double, ptr %2034, align 8, !tbaa !11
  store double %2035, ptr %40, align 8, !tbaa !17
  %2036 = load double, ptr %40, align 8, !tbaa !17
  %2037 = fcmp oge double %2036, 0.000000e+00
  br i1 %2037, label %2038, label %2040

2038:                                             ; preds = %2031
  %2039 = load double, ptr %40, align 8, !tbaa !17
  br label %2043

2040:                                             ; preds = %2031
  %2041 = load double, ptr %40, align 8, !tbaa !17
  %2042 = fneg double %2041
  br label %2043

2043:                                             ; preds = %2040, %2038
  %2044 = phi double [ %2039, %2038 ], [ %2042, %2040 ]
  %2045 = call { double, double } @Cd(ptr noundef %75)
  %2046 = extractvalue { double, double } %2045, 0
  %2047 = extractvalue { double, double } %2045, 1
  store double %2047, ptr %41, align 8, !tbaa !17
  %2048 = load double, ptr %41, align 8, !tbaa !17
  %2049 = fcmp oge double %2048, 0.000000e+00
  br i1 %2049, label %2050, label %2052

2050:                                             ; preds = %2043
  %2051 = load double, ptr %41, align 8, !tbaa !17
  br label %2055

2052:                                             ; preds = %2043
  %2053 = load double, ptr %41, align 8, !tbaa !17
  %2054 = fneg double %2053
  br label %2055

2055:                                             ; preds = %2052, %2050
  %2056 = phi double [ %2051, %2050 ], [ %2054, %2052 ]
  %2057 = fadd double %2044, %2056
  %2058 = fadd double %2033, %2057
  %2059 = fmul double %2009, %2058
  %2060 = fmul double %1985, %2059
  %2061 = fcmp ole double %1984, %2060
  br i1 %2061, label %2062, label %2063

2062:                                             ; preds = %2055
  br label %2204

2063:                                             ; preds = %2055
  br label %2064

2064:                                             ; preds = %2063
  %2065 = load i32, ptr %54, align 4, !tbaa !9
  %2066 = add nsw i32 %2065, -1
  store i32 %2066, ptr %54, align 4, !tbaa !9
  br label %1813, !llvm.loop !20

2067:                                             ; preds = %1813
  %2068 = load i32, ptr %53, align 4, !tbaa !9
  %2069 = load i32, ptr %53, align 4, !tbaa !9
  %2070 = load i32, ptr %27, align 4, !tbaa !9
  %2071 = mul nsw i32 %2069, %2070
  %2072 = add nsw i32 %2068, %2071
  store i32 %2072, ptr %32, align 4, !tbaa !9
  %2073 = load ptr, ptr %19, align 8, !tbaa !5
  %2074 = load i32, ptr %32, align 4, !tbaa !9
  %2075 = sext i32 %2074 to i64
  %2076 = getelementptr inbounds %struct.doublecomplex, ptr %2073, i64 %2075
  %2077 = getelementptr inbounds %struct.doublecomplex, ptr %2076, i32 0, i32 0
  %2078 = load double, ptr %2077, align 8, !tbaa !11
  %2079 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 0
  store double %2078, ptr %2079, align 8, !tbaa !11
  %2080 = load ptr, ptr %19, align 8, !tbaa !5
  %2081 = load i32, ptr %32, align 4, !tbaa !9
  %2082 = sext i32 %2081 to i64
  %2083 = getelementptr inbounds %struct.doublecomplex, ptr %2080, i64 %2082
  %2084 = getelementptr inbounds %struct.doublecomplex, ptr %2083, i32 0, i32 1
  %2085 = load double, ptr %2084, align 8, !tbaa !14
  %2086 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 1
  store double %2085, ptr %2086, align 8, !tbaa !14
  %2087 = load i32, ptr %53, align 4, !tbaa !9
  %2088 = add nsw i32 %2087, 1
  %2089 = load i32, ptr %53, align 4, !tbaa !9
  %2090 = add nsw i32 %2089, 1
  %2091 = load i32, ptr %27, align 4, !tbaa !9
  %2092 = mul nsw i32 %2090, %2091
  %2093 = add nsw i32 %2088, %2092
  store i32 %2093, ptr %32, align 4, !tbaa !9
  %2094 = load ptr, ptr %19, align 8, !tbaa !5
  %2095 = load i32, ptr %32, align 4, !tbaa !9
  %2096 = sext i32 %2095 to i64
  %2097 = getelementptr inbounds %struct.doublecomplex, ptr %2094, i64 %2096
  %2098 = getelementptr inbounds %struct.doublecomplex, ptr %2097, i32 0, i32 0
  %2099 = load double, ptr %2098, align 8, !tbaa !11
  %2100 = getelementptr inbounds %struct.doublecomplex, ptr %75, i32 0, i32 0
  store double %2099, ptr %2100, align 8, !tbaa !11
  %2101 = load ptr, ptr %19, align 8, !tbaa !5
  %2102 = load i32, ptr %32, align 4, !tbaa !9
  %2103 = sext i32 %2102 to i64
  %2104 = getelementptr inbounds %struct.doublecomplex, ptr %2101, i64 %2103
  %2105 = getelementptr inbounds %struct.doublecomplex, ptr %2104, i32 0, i32 1
  %2106 = load double, ptr %2105, align 8, !tbaa !14
  %2107 = getelementptr inbounds %struct.doublecomplex, ptr %75, i32 0, i32 1
  store double %2106, ptr %2107, align 8, !tbaa !14
  %2108 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 0
  %2109 = load double, ptr %2108, align 8, !tbaa !11
  %2110 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %2111 = load double, ptr %2110, align 8, !tbaa !11
  %2112 = fsub double %2109, %2111
  %2113 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2112, ptr %2113, align 8, !tbaa !11
  %2114 = getelementptr inbounds %struct.doublecomplex, ptr %73, i32 0, i32 1
  %2115 = load double, ptr %2114, align 8, !tbaa !14
  %2116 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %2117 = load double, ptr %2116, align 8, !tbaa !14
  %2118 = fsub double %2115, %2117
  %2119 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2118, ptr %2119, align 8, !tbaa !14
  %2120 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2121 = load double, ptr %2120, align 8, !tbaa !11
  %2122 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %2121, ptr %2122, align 8, !tbaa !11
  %2123 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2124 = load double, ptr %2123, align 8, !tbaa !14
  %2125 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %2124, ptr %2125, align 8, !tbaa !14
  %2126 = load i32, ptr %53, align 4, !tbaa !9
  %2127 = add nsw i32 %2126, 1
  %2128 = load i32, ptr %53, align 4, !tbaa !9
  %2129 = load i32, ptr %27, align 4, !tbaa !9
  %2130 = mul nsw i32 %2128, %2129
  %2131 = add nsw i32 %2127, %2130
  store i32 %2131, ptr %32, align 4, !tbaa !9
  %2132 = load ptr, ptr %19, align 8, !tbaa !5
  %2133 = load i32, ptr %32, 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 0
  %2137 = load double, ptr %2136, align 8, !tbaa !11
  store double %2137, ptr %74, align 8, !tbaa !17
  %2138 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2139 = load double, ptr %2138, align 8, !tbaa !11
  store double %2139, ptr %36, align 8, !tbaa !17
  %2140 = load double, ptr %36, align 8, !tbaa !17
  %2141 = fcmp oge double %2140, 0.000000e+00
  br i1 %2141, label %2142, label %2144

2142:                                             ; preds = %2067
  %2143 = load double, ptr %36, align 8, !tbaa !17
  br label %2147

2144:                                             ; preds = %2067
  %2145 = load double, ptr %36, align 8, !tbaa !17
  %2146 = fneg double %2145
  br label %2147

2147:                                             ; preds = %2144, %2142
  %2148 = phi double [ %2143, %2142 ], [ %2146, %2144 ]
  %2149 = call { double, double } @Cd(ptr noundef %84)
  %2150 = extractvalue { double, double } %2149, 0
  %2151 = extractvalue { double, double } %2149, 1
  store double %2151, ptr %37, align 8, !tbaa !17
  %2152 = load double, ptr %37, align 8, !tbaa !17
  %2153 = fcmp oge double %2152, 0.000000e+00
  br i1 %2153, label %2154, label %2156

2154:                                             ; preds = %2147
  %2155 = load double, ptr %37, align 8, !tbaa !17
  br label %2159

2156:                                             ; preds = %2147
  %2157 = load double, ptr %37, align 8, !tbaa !17
  %2158 = fneg double %2157
  br label %2159

2159:                                             ; preds = %2156, %2154
  %2160 = phi double [ %2155, %2154 ], [ %2158, %2156 ]
  %2161 = fadd double %2148, %2160
  %2162 = load double, ptr %74, align 8, !tbaa !17
  %2163 = fcmp oge double %2162, 0.000000e+00
  br i1 %2163, label %2164, label %2166

2164:                                             ; preds = %2159
  %2165 = load double, ptr %74, align 8, !tbaa !17
  br label %2169

2166:                                             ; preds = %2159
  %2167 = load double, ptr %74, align 8, !tbaa !17
  %2168 = fneg double %2167
  br label %2169

2169:                                             ; preds = %2166, %2164
  %2170 = phi double [ %2165, %2164 ], [ %2168, %2166 ]
  %2171 = fadd double %2161, %2170
  store double %2171, ptr %55, align 8, !tbaa !17
  %2172 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2173 = load double, ptr %2172, align 8, !tbaa !11
  %2174 = load double, ptr %55, align 8, !tbaa !17
  %2175 = fdiv double %2173, %2174
  %2176 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2175, ptr %2176, align 8, !tbaa !11
  %2177 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2178 = load double, ptr %2177, align 8, !tbaa !14
  %2179 = load double, ptr %55, align 8, !tbaa !17
  %2180 = fdiv double %2178, %2179
  %2181 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2180, ptr %2181, align 8, !tbaa !14
  %2182 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2183 = load double, ptr %2182, align 8, !tbaa !11
  %2184 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %2183, ptr %2184, align 8, !tbaa !11
  %2185 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2186 = load double, ptr %2185, align 8, !tbaa !14
  %2187 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %2186, ptr %2187, align 8, !tbaa !14
  %2188 = load double, ptr %55, align 8, !tbaa !17
  %2189 = load double, ptr %74, align 8, !tbaa !17
  %2190 = fdiv double %2189, %2188
  store double %2190, ptr %74, align 8, !tbaa !17
  %2191 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2192 = load double, ptr %2191, align 8, !tbaa !11
  %2193 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %2194 = getelementptr inbounds %struct.doublecomplex, ptr %2193, i32 0, i32 0
  store double %2192, ptr %2194, align 16, !tbaa !11
  %2195 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2196 = load double, ptr %2195, align 8, !tbaa !14
  %2197 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %2198 = getelementptr inbounds %struct.doublecomplex, ptr %2197, i32 0, i32 1
  store double %2196, ptr %2198, align 8, !tbaa !14
  %2199 = load double, ptr %74, align 8, !tbaa !17
  %2200 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %2201 = getelementptr inbounds %struct.doublecomplex, ptr %2200, i32 0, i32 0
  store double %2199, ptr %2201, align 16, !tbaa !11
  %2202 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %2203 = getelementptr inbounds %struct.doublecomplex, ptr %2202, i32 0, i32 1
  store double 0.000000e+00, ptr %2203, align 8, !tbaa !14
  br label %2204

2204:                                             ; preds = %2169, %2062
  %2205 = load i32, ptr %50, align 4, !tbaa !9
  %2206 = sub nsw i32 %2205, 1
  store i32 %2206, ptr %32, align 4, !tbaa !9
  %2207 = load i32, ptr %54, align 4, !tbaa !9
  store i32 %2207, ptr %52, align 4, !tbaa !9
  br label %2208

2208:                                             ; preds = %3243, %2204
  %2209 = load i32, ptr %52, align 4, !tbaa !9
  %2210 = load i32, ptr %32, align 4, !tbaa !9
  %2211 = icmp sle i32 %2209, %2210
  br i1 %2211, label %2212, label %3246

2212:                                             ; preds = %2208
  %2213 = load i32, ptr %52, align 4, !tbaa !9
  %2214 = load i32, ptr %54, align 4, !tbaa !9
  %2215 = icmp sgt i32 %2213, %2214
  br i1 %2215, label %2216, label %2227

2216:                                             ; preds = %2212
  %2217 = load ptr, ptr %19, align 8, !tbaa !5
  %2218 = load i32, ptr %52, align 4, !tbaa !9
  %2219 = load i32, ptr %52, align 4, !tbaa !9
  %2220 = sub nsw i32 %2219, 1
  %2221 = load i32, ptr %27, align 4, !tbaa !9
  %2222 = mul nsw i32 %2220, %2221
  %2223 = add nsw i32 %2218, %2222
  %2224 = sext i32 %2223 to i64
  %2225 = getelementptr inbounds %struct.doublecomplex, ptr %2217, i64 %2224
  %2226 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  call void @zcopy_(ptr noundef @c__2, ptr noundef %2225, ptr noundef @c__1, ptr noundef %2226, ptr noundef @c__1)
  br label %2227

2227:                                             ; preds = %2216, %2212
  %2228 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %2229 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  call void @zlarfg_(ptr noundef @c__2, ptr noundef %2228, ptr noundef %2229, ptr noundef @c__1, ptr noundef %65)
  %2230 = load i32, ptr %52, align 4, !tbaa !9
  %2231 = load i32, ptr %54, align 4, !tbaa !9
  %2232 = icmp sgt i32 %2230, %2231
  br i1 %2232, label %2233, label %2273

2233:                                             ; preds = %2227
  %2234 = load i32, ptr %52, align 4, !tbaa !9
  %2235 = load i32, ptr %52, align 4, !tbaa !9
  %2236 = sub nsw i32 %2235, 1
  %2237 = load i32, ptr %27, align 4, !tbaa !9
  %2238 = mul nsw i32 %2236, %2237
  %2239 = add nsw i32 %2234, %2238
  store i32 %2239, ptr %33, align 4, !tbaa !9
  %2240 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %2241 = getelementptr inbounds %struct.doublecomplex, ptr %2240, i32 0, i32 0
  %2242 = load double, ptr %2241, align 16, !tbaa !11
  %2243 = load ptr, ptr %19, align 8, !tbaa !5
  %2244 = load i32, ptr %33, align 4, !tbaa !9
  %2245 = sext i32 %2244 to i64
  %2246 = getelementptr inbounds %struct.doublecomplex, ptr %2243, i64 %2245
  %2247 = getelementptr inbounds %struct.doublecomplex, ptr %2246, i32 0, i32 0
  store double %2242, ptr %2247, align 8, !tbaa !11
  %2248 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 0
  %2249 = getelementptr inbounds %struct.doublecomplex, ptr %2248, i32 0, i32 1
  %2250 = load double, ptr %2249, align 8, !tbaa !14
  %2251 = load ptr, ptr %19, align 8, !tbaa !5
  %2252 = load i32, ptr %33, 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
  store double %2250, ptr %2255, align 8, !tbaa !14
  %2256 = load i32, ptr %52, align 4, !tbaa !9
  %2257 = add nsw i32 %2256, 1
  %2258 = load i32, ptr %52, align 4, !tbaa !9
  %2259 = sub nsw i32 %2258, 1
  %2260 = load i32, ptr %27, align 4, !tbaa !9
  %2261 = mul nsw i32 %2259, %2260
  %2262 = add nsw i32 %2257, %2261
  store i32 %2262, ptr %33, align 4, !tbaa !9
  %2263 = load ptr, ptr %19, align 8, !tbaa !5
  %2264 = load i32, ptr %33, align 4, !tbaa !9
  %2265 = sext i32 %2264 to i64
  %2266 = getelementptr inbounds %struct.doublecomplex, ptr %2263, i64 %2265
  %2267 = getelementptr inbounds %struct.doublecomplex, ptr %2266, i32 0, i32 0
  store double 0.000000e+00, ptr %2267, align 8, !tbaa !11
  %2268 = load ptr, ptr %19, align 8, !tbaa !5
  %2269 = load i32, ptr %33, align 4, !tbaa !9
  %2270 = sext i32 %2269 to i64
  %2271 = getelementptr inbounds %struct.doublecomplex, ptr %2268, i64 %2270
  %2272 = getelementptr inbounds %struct.doublecomplex, ptr %2271, i32 0, i32 1
  store double 0.000000e+00, ptr %2272, align 8, !tbaa !14
  br label %2273

2273:                                             ; preds = %2233, %2227
  %2274 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %2275 = getelementptr inbounds %struct.doublecomplex, ptr %2274, i32 0, i32 0
  %2276 = load double, ptr %2275, align 16, !tbaa !11
  %2277 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %2276, ptr %2277, align 8, !tbaa !11
  %2278 = getelementptr inbounds [2 x %struct.doublecomplex], ptr %58, i64 0, i64 1
  %2279 = getelementptr inbounds %struct.doublecomplex, ptr %2278, i32 0, i32 1
  %2280 = load double, ptr %2279, align 8, !tbaa !14
  %2281 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %2280, ptr %2281, align 8, !tbaa !14
  %2282 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2283 = load double, ptr %2282, align 8, !tbaa !11
  %2284 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2285 = load double, ptr %2284, align 8, !tbaa !11
  %2286 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2287 = load double, ptr %2286, align 8, !tbaa !14
  %2288 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %2289 = load double, ptr %2288, align 8, !tbaa !14
  %2290 = fmul double %2287, %2289
  %2291 = fneg double %2290
  %2292 = call double @llvm.fmuladd.f64(double %2283, double %2285, double %2291)
  %2293 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2292, ptr %2293, align 8, !tbaa !11
  %2294 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2295 = load double, ptr %2294, align 8, !tbaa !11
  %2296 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %2297 = load double, ptr %2296, align 8, !tbaa !14
  %2298 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2299 = load double, ptr %2298, align 8, !tbaa !14
  %2300 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2301 = load double, ptr %2300, align 8, !tbaa !11
  %2302 = fmul double %2299, %2301
  %2303 = call double @llvm.fmuladd.f64(double %2295, double %2297, double %2302)
  %2304 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2303, ptr %2304, align 8, !tbaa !14
  %2305 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2306 = load double, ptr %2305, align 8, !tbaa !11
  store double %2306, ptr %66, align 8, !tbaa !17
  %2307 = load i32, ptr %64, align 4, !tbaa !9
  store i32 %2307, ptr %33, align 4, !tbaa !9
  %2308 = load i32, ptr %52, align 4, !tbaa !9
  store i32 %2308, ptr %51, align 4, !tbaa !9
  br label %2309

2309:                                             ; preds = %2520, %2273
  %2310 = load i32, ptr %51, align 4, !tbaa !9
  %2311 = load i32, ptr %33, align 4, !tbaa !9
  %2312 = icmp sle i32 %2310, %2311
  br i1 %2312, label %2313, label %2523

2313:                                             ; preds = %2309
  %2314 = call { double, double } @Cd(ptr noundef %65)
  %2315 = extractvalue { double, double } %2314, 0
  %2316 = extractvalue { double, double } %2314, 1
  %2317 = fneg double %2316
  %2318 = call ptr @_pCd(ptr noundef %44)
  %2319 = getelementptr inbounds { double, double }, ptr %2318, i32 0, i32 0
  %2320 = getelementptr inbounds { double, double }, ptr %2318, i32 0, i32 1
  store double %2315, ptr %2319, align 8
  store double %2317, ptr %2320, align 8
  %2321 = load i32, ptr %52, align 4, !tbaa !9
  %2322 = load i32, ptr %51, align 4, !tbaa !9
  %2323 = load i32, ptr %27, align 4, !tbaa !9
  %2324 = mul nsw i32 %2322, %2323
  %2325 = add nsw i32 %2321, %2324
  store i32 %2325, ptr %34, align 4, !tbaa !9
  %2326 = getelementptr inbounds %struct.doublecomplex, ptr %44, 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 %34, 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 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2335 = load double, ptr %2334, align 8, !tbaa !14
  %2336 = load ptr, ptr %19, align 8, !tbaa !5
  %2337 = load i32, ptr %34, align 4, !tbaa !9
  %2338 = sext i32 %2337 to i64
  %2339 = getelementptr inbounds %struct.doublecomplex, ptr %2336, i64 %2338
  %2340 = getelementptr inbounds %struct.doublecomplex, ptr %2339, i32 0, i32 1
  %2341 = load double, ptr %2340, align 8, !tbaa !14
  %2342 = fmul double %2335, %2341
  %2343 = fneg double %2342
  %2344 = call double @llvm.fmuladd.f64(double %2327, double %2333, double %2343)
  %2345 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2344, ptr %2345, align 8, !tbaa !11
  %2346 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2347 = load double, ptr %2346, align 8, !tbaa !11
  %2348 = load ptr, ptr %19, align 8, !tbaa !5
  %2349 = load i32, ptr %34, align 4, !tbaa !9
  %2350 = sext i32 %2349 to i64
  %2351 = getelementptr inbounds %struct.doublecomplex, ptr %2348, i64 %2350
  %2352 = getelementptr inbounds %struct.doublecomplex, ptr %2351, i32 0, i32 1
  %2353 = load double, ptr %2352, align 8, !tbaa !14
  %2354 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2355 = load double, ptr %2354, align 8, !tbaa !14
  %2356 = load ptr, ptr %19, align 8, !tbaa !5
  %2357 = load i32, ptr %34, 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 0
  %2361 = load double, ptr %2360, align 8, !tbaa !11
  %2362 = fmul double %2355, %2361
  %2363 = call double @llvm.fmuladd.f64(double %2347, double %2353, double %2362)
  %2364 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2363, ptr %2364, align 8, !tbaa !14
  %2365 = load i32, ptr %52, align 4, !tbaa !9
  %2366 = add nsw i32 %2365, 1
  %2367 = load i32, ptr %51, align 4, !tbaa !9
  %2368 = load i32, ptr %27, align 4, !tbaa !9
  %2369 = mul nsw i32 %2367, %2368
  %2370 = add nsw i32 %2366, %2369
  store i32 %2370, ptr %35, align 4, !tbaa !9
  %2371 = load double, ptr %66, align 8, !tbaa !17
  %2372 = load ptr, ptr %19, align 8, !tbaa !5
  %2373 = load i32, ptr %35, align 4, !tbaa !9
  %2374 = sext i32 %2373 to i64
  %2375 = getelementptr inbounds %struct.doublecomplex, ptr %2372, i64 %2374
  %2376 = getelementptr inbounds %struct.doublecomplex, ptr %2375, i32 0, i32 0
  %2377 = load double, ptr %2376, align 8, !tbaa !11
  %2378 = fmul double %2371, %2377
  %2379 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  store double %2378, ptr %2379, align 8, !tbaa !11
  %2380 = load double, ptr %66, align 8, !tbaa !17
  %2381 = load ptr, ptr %19, align 8, !tbaa !5
  %2382 = load i32, ptr %35, align 4, !tbaa !9
  %2383 = sext i32 %2382 to i64
  %2384 = getelementptr inbounds %struct.doublecomplex, ptr %2381, i64 %2383
  %2385 = getelementptr inbounds %struct.doublecomplex, ptr %2384, i32 0, i32 1
  %2386 = load double, ptr %2385, align 8, !tbaa !14
  %2387 = fmul double %2380, %2386
  %2388 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  store double %2387, ptr %2388, align 8, !tbaa !14
  %2389 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2390 = load double, ptr %2389, align 8, !tbaa !11
  %2391 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %2392 = load double, ptr %2391, align 8, !tbaa !11
  %2393 = fadd double %2390, %2392
  %2394 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2393, ptr %2394, align 8, !tbaa !11
  %2395 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2396 = load double, ptr %2395, align 8, !tbaa !14
  %2397 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %2398 = load double, ptr %2397, align 8, !tbaa !14
  %2399 = fadd double %2396, %2398
  %2400 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2399, ptr %2400, align 8, !tbaa !14
  %2401 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2402 = load double, ptr %2401, align 8, !tbaa !11
  %2403 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  store double %2402, ptr %2403, align 8, !tbaa !11
  %2404 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2405 = load double, ptr %2404, align 8, !tbaa !14
  %2406 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  store double %2405, ptr %2406, align 8, !tbaa !14
  %2407 = load i32, ptr %52, align 4, !tbaa !9
  %2408 = load i32, ptr %51, align 4, !tbaa !9
  %2409 = load i32, ptr %27, align 4, !tbaa !9
  %2410 = mul nsw i32 %2408, %2409
  %2411 = add nsw i32 %2407, %2410
  store i32 %2411, ptr %34, align 4, !tbaa !9
  %2412 = load i32, ptr %52, align 4, !tbaa !9
  %2413 = load i32, ptr %51, align 4, !tbaa !9
  %2414 = load i32, ptr %27, align 4, !tbaa !9
  %2415 = mul nsw i32 %2413, %2414
  %2416 = add nsw i32 %2412, %2415
  store i32 %2416, ptr %35, align 4, !tbaa !9
  %2417 = load ptr, ptr %19, align 8, !tbaa !5
  %2418 = load i32, ptr %35, align 4, !tbaa !9
  %2419 = sext i32 %2418 to i64
  %2420 = getelementptr inbounds %struct.doublecomplex, ptr %2417, i64 %2419
  %2421 = getelementptr inbounds %struct.doublecomplex, ptr %2420, i32 0, i32 0
  %2422 = load double, ptr %2421, align 8, !tbaa !11
  %2423 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2424 = load double, ptr %2423, align 8, !tbaa !11
  %2425 = fsub double %2422, %2424
  %2426 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2425, ptr %2426, align 8, !tbaa !11
  %2427 = load ptr, ptr %19, align 8, !tbaa !5
  %2428 = load i32, ptr %35, align 4, !tbaa !9
  %2429 = sext i32 %2428 to i64
  %2430 = getelementptr inbounds %struct.doublecomplex, ptr %2427, i64 %2429
  %2431 = getelementptr inbounds %struct.doublecomplex, ptr %2430, i32 0, i32 1
  %2432 = load double, ptr %2431, align 8, !tbaa !14
  %2433 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2434 = load double, ptr %2433, align 8, !tbaa !14
  %2435 = fsub double %2432, %2434
  %2436 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2435, ptr %2436, align 8, !tbaa !14
  %2437 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2438 = load double, ptr %2437, align 8, !tbaa !11
  %2439 = load ptr, ptr %19, align 8, !tbaa !5
  %2440 = load i32, ptr %34, align 4, !tbaa !9
  %2441 = sext i32 %2440 to i64
  %2442 = getelementptr inbounds %struct.doublecomplex, ptr %2439, i64 %2441
  %2443 = getelementptr inbounds %struct.doublecomplex, ptr %2442, i32 0, i32 0
  store double %2438, ptr %2443, align 8, !tbaa !11
  %2444 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2445 = load double, ptr %2444, align 8, !tbaa !14
  %2446 = load ptr, ptr %19, align 8, !tbaa !5
  %2447 = load i32, ptr %34, align 4, !tbaa !9
  %2448 = sext i32 %2447 to i64
  %2449 = getelementptr inbounds %struct.doublecomplex, ptr %2446, i64 %2448
  %2450 = getelementptr inbounds %struct.doublecomplex, ptr %2449, i32 0, i32 1
  store double %2445, ptr %2450, align 8, !tbaa !14
  %2451 = load i32, ptr %52, align 4, !tbaa !9
  %2452 = add nsw i32 %2451, 1
  %2453 = load i32, ptr %51, align 4, !tbaa !9
  %2454 = load i32, ptr %27, align 4, !tbaa !9
  %2455 = mul nsw i32 %2453, %2454
  %2456 = add nsw i32 %2452, %2455
  store i32 %2456, ptr %34, align 4, !tbaa !9
  %2457 = load i32, ptr %52, align 4, !tbaa !9
  %2458 = add nsw i32 %2457, 1
  %2459 = load i32, ptr %51, align 4, !tbaa !9
  %2460 = load i32, ptr %27, align 4, !tbaa !9
  %2461 = mul nsw i32 %2459, %2460
  %2462 = add nsw i32 %2458, %2461
  store i32 %2462, ptr %35, align 4, !tbaa !9
  %2463 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2464 = load double, ptr %2463, align 8, !tbaa !11
  %2465 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2466 = load double, ptr %2465, align 8, !tbaa !11
  %2467 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2468 = load double, ptr %2467, align 8, !tbaa !14
  %2469 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %2470 = load double, ptr %2469, align 8, !tbaa !14
  %2471 = fmul double %2468, %2470
  %2472 = fneg double %2471
  %2473 = call double @llvm.fmuladd.f64(double %2464, double %2466, double %2472)
  %2474 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2473, ptr %2474, align 8, !tbaa !11
  %2475 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2476 = load double, ptr %2475, align 8, !tbaa !11
  %2477 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %2478 = load double, ptr %2477, align 8, !tbaa !14
  %2479 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2480 = load double, ptr %2479, align 8, !tbaa !14
  %2481 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2482 = load double, ptr %2481, align 8, !tbaa !11
  %2483 = fmul double %2480, %2482
  %2484 = call double @llvm.fmuladd.f64(double %2476, double %2478, double %2483)
  %2485 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2484, ptr %2485, align 8, !tbaa !14
  %2486 = load ptr, ptr %19, align 8, !tbaa !5
  %2487 = load i32, ptr %35, align 4, !tbaa !9
  %2488 = sext i32 %2487 to i64
  %2489 = getelementptr inbounds %struct.doublecomplex, ptr %2486, i64 %2488
  %2490 = getelementptr inbounds %struct.doublecomplex, ptr %2489, i32 0, i32 0
  %2491 = load double, ptr %2490, align 8, !tbaa !11
  %2492 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2493 = load double, ptr %2492, align 8, !tbaa !11
  %2494 = fsub double %2491, %2493
  %2495 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2494, ptr %2495, align 8, !tbaa !11
  %2496 = load ptr, ptr %19, align 8, !tbaa !5
  %2497 = load i32, ptr %35, align 4, !tbaa !9
  %2498 = sext i32 %2497 to i64
  %2499 = getelementptr inbounds %struct.doublecomplex, ptr %2496, i64 %2498
  %2500 = getelementptr inbounds %struct.doublecomplex, ptr %2499, i32 0, i32 1
  %2501 = load double, ptr %2500, align 8, !tbaa !14
  %2502 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2503 = load double, ptr %2502, align 8, !tbaa !14
  %2504 = fsub double %2501, %2503
  %2505 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2504, ptr %2505, align 8, !tbaa !14
  %2506 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2507 = load double, ptr %2506, align 8, !tbaa !11
  %2508 = load ptr, ptr %19, align 8, !tbaa !5
  %2509 = load i32, ptr %34, align 4, !tbaa !9
  %2510 = sext i32 %2509 to i64
  %2511 = getelementptr inbounds %struct.doublecomplex, ptr %2508, i64 %2510
  %2512 = getelementptr inbounds %struct.doublecomplex, ptr %2511, i32 0, i32 0
  store double %2507, ptr %2512, align 8, !tbaa !11
  %2513 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2514 = load double, ptr %2513, align 8, !tbaa !14
  %2515 = load ptr, ptr %19, align 8, !tbaa !5
  %2516 = load i32, ptr %34, align 4, !tbaa !9
  %2517 = sext i32 %2516 to i64
  %2518 = getelementptr inbounds %struct.doublecomplex, ptr %2515, i64 %2517
  %2519 = getelementptr inbounds %struct.doublecomplex, ptr %2518, i32 0, i32 1
  store double %2514, ptr %2519, align 8, !tbaa !14
  br label %2520

2520:                                             ; preds = %2313
  %2521 = load i32, ptr %51, align 4, !tbaa !9
  %2522 = add nsw i32 %2521, 1
  store i32 %2522, ptr %51, align 4, !tbaa !9
  br label %2309, !llvm.loop !21

2523:                                             ; preds = %2309
  %2524 = load i32, ptr %52, align 4, !tbaa !9
  %2525 = add nsw i32 %2524, 2
  store i32 %2525, ptr %34, align 4, !tbaa !9
  %2526 = load i32, ptr %34, align 4, !tbaa !9
  %2527 = load i32, ptr %50, align 4, !tbaa !9
  %2528 = icmp sle i32 %2526, %2527
  br i1 %2528, label %2529, label %2531

2529:                                             ; preds = %2523
  %2530 = load i32, ptr %34, align 4, !tbaa !9
  br label %2533

2531:                                             ; preds = %2523
  %2532 = load i32, ptr %50, align 4, !tbaa !9
  br label %2533

2533:                                             ; preds = %2531, %2529
  %2534 = phi i32 [ %2530, %2529 ], [ %2532, %2531 ]
  store i32 %2534, ptr %33, align 4, !tbaa !9
  %2535 = load i32, ptr %63, align 4, !tbaa !9
  store i32 %2535, ptr %51, align 4, !tbaa !9
  br label %2536

2536:                                             ; preds = %2747, %2533
  %2537 = load i32, ptr %51, align 4, !tbaa !9
  %2538 = load i32, ptr %33, align 4, !tbaa !9
  %2539 = icmp sle i32 %2537, %2538
  br i1 %2539, label %2540, label %2750

2540:                                             ; preds = %2536
  %2541 = load i32, ptr %51, align 4, !tbaa !9
  %2542 = load i32, ptr %52, align 4, !tbaa !9
  %2543 = load i32, ptr %27, align 4, !tbaa !9
  %2544 = mul nsw i32 %2542, %2543
  %2545 = add nsw i32 %2541, %2544
  store i32 %2545, ptr %34, align 4, !tbaa !9
  %2546 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2547 = load double, ptr %2546, align 8, !tbaa !11
  %2548 = load ptr, ptr %19, align 8, !tbaa !5
  %2549 = load i32, ptr %34, align 4, !tbaa !9
  %2550 = sext i32 %2549 to i64
  %2551 = getelementptr inbounds %struct.doublecomplex, ptr %2548, i64 %2550
  %2552 = getelementptr inbounds %struct.doublecomplex, ptr %2551, i32 0, i32 0
  %2553 = load double, ptr %2552, align 8, !tbaa !11
  %2554 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2555 = load double, ptr %2554, align 8, !tbaa !14
  %2556 = load ptr, ptr %19, align 8, !tbaa !5
  %2557 = load i32, ptr %34, align 4, !tbaa !9
  %2558 = sext i32 %2557 to i64
  %2559 = getelementptr inbounds %struct.doublecomplex, ptr %2556, i64 %2558
  %2560 = getelementptr inbounds %struct.doublecomplex, ptr %2559, i32 0, i32 1
  %2561 = load double, ptr %2560, align 8, !tbaa !14
  %2562 = fmul double %2555, %2561
  %2563 = fneg double %2562
  %2564 = call double @llvm.fmuladd.f64(double %2547, double %2553, double %2563)
  %2565 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2564, ptr %2565, align 8, !tbaa !11
  %2566 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2567 = load double, ptr %2566, align 8, !tbaa !11
  %2568 = load ptr, ptr %19, align 8, !tbaa !5
  %2569 = load i32, ptr %34, align 4, !tbaa !9
  %2570 = sext i32 %2569 to i64
  %2571 = getelementptr inbounds %struct.doublecomplex, ptr %2568, i64 %2570
  %2572 = getelementptr inbounds %struct.doublecomplex, ptr %2571, i32 0, i32 1
  %2573 = load double, ptr %2572, align 8, !tbaa !14
  %2574 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2575 = load double, ptr %2574, align 8, !tbaa !14
  %2576 = load ptr, ptr %19, align 8, !tbaa !5
  %2577 = load i32, ptr %34, align 4, !tbaa !9
  %2578 = sext i32 %2577 to i64
  %2579 = getelementptr inbounds %struct.doublecomplex, ptr %2576, i64 %2578
  %2580 = getelementptr inbounds %struct.doublecomplex, ptr %2579, i32 0, i32 0
  %2581 = load double, ptr %2580, align 8, !tbaa !11
  %2582 = fmul double %2575, %2581
  %2583 = call double @llvm.fmuladd.f64(double %2567, double %2573, double %2582)
  %2584 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2583, ptr %2584, align 8, !tbaa !14
  %2585 = load i32, ptr %51, align 4, !tbaa !9
  %2586 = load i32, ptr %52, align 4, !tbaa !9
  %2587 = add nsw i32 %2586, 1
  %2588 = load i32, ptr %27, align 4, !tbaa !9
  %2589 = mul nsw i32 %2587, %2588
  %2590 = add nsw i32 %2585, %2589
  store i32 %2590, ptr %35, align 4, !tbaa !9
  %2591 = load double, ptr %66, align 8, !tbaa !17
  %2592 = load ptr, ptr %19, align 8, !tbaa !5
  %2593 = load i32, ptr %35, align 4, !tbaa !9
  %2594 = sext i32 %2593 to i64
  %2595 = getelementptr inbounds %struct.doublecomplex, ptr %2592, i64 %2594
  %2596 = getelementptr inbounds %struct.doublecomplex, ptr %2595, i32 0, i32 0
  %2597 = load double, ptr %2596, align 8, !tbaa !11
  %2598 = fmul double %2591, %2597
  %2599 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %2598, ptr %2599, align 8, !tbaa !11
  %2600 = load double, ptr %66, align 8, !tbaa !17
  %2601 = load ptr, ptr %19, align 8, !tbaa !5
  %2602 = load i32, ptr %35, align 4, !tbaa !9
  %2603 = sext i32 %2602 to i64
  %2604 = getelementptr inbounds %struct.doublecomplex, ptr %2601, i64 %2603
  %2605 = getelementptr inbounds %struct.doublecomplex, ptr %2604, i32 0, i32 1
  %2606 = load double, ptr %2605, align 8, !tbaa !14
  %2607 = fmul double %2600, %2606
  %2608 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %2607, ptr %2608, align 8, !tbaa !14
  %2609 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2610 = load double, ptr %2609, align 8, !tbaa !11
  %2611 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2612 = load double, ptr %2611, align 8, !tbaa !11
  %2613 = fadd double %2610, %2612
  %2614 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2613, ptr %2614, align 8, !tbaa !11
  %2615 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2616 = load double, ptr %2615, align 8, !tbaa !14
  %2617 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2618 = load double, ptr %2617, align 8, !tbaa !14
  %2619 = fadd double %2616, %2618
  %2620 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2619, ptr %2620, align 8, !tbaa !14
  %2621 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2622 = load double, ptr %2621, align 8, !tbaa !11
  %2623 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  store double %2622, ptr %2623, align 8, !tbaa !11
  %2624 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2625 = load double, ptr %2624, align 8, !tbaa !14
  %2626 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  store double %2625, ptr %2626, align 8, !tbaa !14
  %2627 = load i32, ptr %51, align 4, !tbaa !9
  %2628 = load i32, ptr %52, align 4, !tbaa !9
  %2629 = load i32, ptr %27, align 4, !tbaa !9
  %2630 = mul nsw i32 %2628, %2629
  %2631 = add nsw i32 %2627, %2630
  store i32 %2631, ptr %34, align 4, !tbaa !9
  %2632 = load i32, ptr %51, align 4, !tbaa !9
  %2633 = load i32, ptr %52, align 4, !tbaa !9
  %2634 = load i32, ptr %27, align 4, !tbaa !9
  %2635 = mul nsw i32 %2633, %2634
  %2636 = add nsw i32 %2632, %2635
  store i32 %2636, ptr %35, align 4, !tbaa !9
  %2637 = load ptr, ptr %19, align 8, !tbaa !5
  %2638 = load i32, ptr %35, align 4, !tbaa !9
  %2639 = sext i32 %2638 to i64
  %2640 = getelementptr inbounds %struct.doublecomplex, ptr %2637, i64 %2639
  %2641 = getelementptr inbounds %struct.doublecomplex, ptr %2640, i32 0, i32 0
  %2642 = load double, ptr %2641, align 8, !tbaa !11
  %2643 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2644 = load double, ptr %2643, align 8, !tbaa !11
  %2645 = fsub double %2642, %2644
  %2646 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2645, ptr %2646, align 8, !tbaa !11
  %2647 = load ptr, ptr %19, align 8, !tbaa !5
  %2648 = load i32, ptr %35, align 4, !tbaa !9
  %2649 = sext i32 %2648 to i64
  %2650 = getelementptr inbounds %struct.doublecomplex, ptr %2647, i64 %2649
  %2651 = getelementptr inbounds %struct.doublecomplex, ptr %2650, i32 0, i32 1
  %2652 = load double, ptr %2651, align 8, !tbaa !14
  %2653 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2654 = load double, ptr %2653, align 8, !tbaa !14
  %2655 = fsub double %2652, %2654
  %2656 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2655, ptr %2656, align 8, !tbaa !14
  %2657 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2658 = load double, ptr %2657, align 8, !tbaa !11
  %2659 = load ptr, ptr %19, align 8, !tbaa !5
  %2660 = load i32, ptr %34, align 4, !tbaa !9
  %2661 = sext i32 %2660 to i64
  %2662 = getelementptr inbounds %struct.doublecomplex, ptr %2659, i64 %2661
  %2663 = getelementptr inbounds %struct.doublecomplex, ptr %2662, i32 0, i32 0
  store double %2658, ptr %2663, align 8, !tbaa !11
  %2664 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2665 = load double, ptr %2664, align 8, !tbaa !14
  %2666 = load ptr, ptr %19, align 8, !tbaa !5
  %2667 = load i32, ptr %34, align 4, !tbaa !9
  %2668 = sext i32 %2667 to i64
  %2669 = getelementptr inbounds %struct.doublecomplex, ptr %2666, i64 %2668
  %2670 = getelementptr inbounds %struct.doublecomplex, ptr %2669, i32 0, i32 1
  store double %2665, ptr %2670, align 8, !tbaa !14
  %2671 = load i32, ptr %51, align 4, !tbaa !9
  %2672 = load i32, ptr %52, align 4, !tbaa !9
  %2673 = add nsw i32 %2672, 1
  %2674 = load i32, ptr %27, align 4, !tbaa !9
  %2675 = mul nsw i32 %2673, %2674
  %2676 = add nsw i32 %2671, %2675
  store i32 %2676, ptr %34, align 4, !tbaa !9
  %2677 = load i32, ptr %51, align 4, !tbaa !9
  %2678 = load i32, ptr %52, align 4, !tbaa !9
  %2679 = add nsw i32 %2678, 1
  %2680 = load i32, ptr %27, align 4, !tbaa !9
  %2681 = mul nsw i32 %2679, %2680
  %2682 = add nsw i32 %2677, %2681
  store i32 %2682, ptr %35, align 4, !tbaa !9
  %2683 = call { double, double } @Cd(ptr noundef %67)
  %2684 = extractvalue { double, double } %2683, 0
  %2685 = extractvalue { double, double } %2683, 1
  %2686 = fneg double %2685
  %2687 = call ptr @_pCd(ptr noundef %44)
  %2688 = getelementptr inbounds { double, double }, ptr %2687, i32 0, i32 0
  %2689 = getelementptr inbounds { double, double }, ptr %2687, i32 0, i32 1
  store double %2684, ptr %2688, align 8
  store double %2686, ptr %2689, align 8
  %2690 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2691 = load double, ptr %2690, align 8, !tbaa !11
  %2692 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2693 = load double, ptr %2692, align 8, !tbaa !11
  %2694 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2695 = load double, ptr %2694, align 8, !tbaa !14
  %2696 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2697 = load double, ptr %2696, align 8, !tbaa !14
  %2698 = fmul double %2695, %2697
  %2699 = fneg double %2698
  %2700 = call double @llvm.fmuladd.f64(double %2691, double %2693, double %2699)
  %2701 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2700, ptr %2701, align 8, !tbaa !11
  %2702 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2703 = load double, ptr %2702, align 8, !tbaa !11
  %2704 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2705 = load double, ptr %2704, align 8, !tbaa !14
  %2706 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2707 = load double, ptr %2706, align 8, !tbaa !14
  %2708 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2709 = load double, ptr %2708, align 8, !tbaa !11
  %2710 = fmul double %2707, %2709
  %2711 = call double @llvm.fmuladd.f64(double %2703, double %2705, double %2710)
  %2712 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2711, ptr %2712, align 8, !tbaa !14
  %2713 = load ptr, ptr %19, align 8, !tbaa !5
  %2714 = load i32, ptr %35, align 4, !tbaa !9
  %2715 = sext i32 %2714 to i64
  %2716 = getelementptr inbounds %struct.doublecomplex, ptr %2713, i64 %2715
  %2717 = getelementptr inbounds %struct.doublecomplex, ptr %2716, i32 0, i32 0
  %2718 = load double, ptr %2717, align 8, !tbaa !11
  %2719 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2720 = load double, ptr %2719, align 8, !tbaa !11
  %2721 = fsub double %2718, %2720
  %2722 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2721, ptr %2722, align 8, !tbaa !11
  %2723 = load ptr, ptr %19, align 8, !tbaa !5
  %2724 = load i32, ptr %35, align 4, !tbaa !9
  %2725 = sext i32 %2724 to i64
  %2726 = getelementptr inbounds %struct.doublecomplex, ptr %2723, i64 %2725
  %2727 = getelementptr inbounds %struct.doublecomplex, ptr %2726, i32 0, i32 1
  %2728 = load double, ptr %2727, align 8, !tbaa !14
  %2729 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2730 = load double, ptr %2729, align 8, !tbaa !14
  %2731 = fsub double %2728, %2730
  %2732 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2731, ptr %2732, align 8, !tbaa !14
  %2733 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2734 = load double, ptr %2733, align 8, !tbaa !11
  %2735 = load ptr, ptr %19, align 8, !tbaa !5
  %2736 = load i32, ptr %34, align 4, !tbaa !9
  %2737 = sext i32 %2736 to i64
  %2738 = getelementptr inbounds %struct.doublecomplex, ptr %2735, i64 %2737
  %2739 = getelementptr inbounds %struct.doublecomplex, ptr %2738, i32 0, i32 0
  store double %2734, ptr %2739, align 8, !tbaa !11
  %2740 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2741 = load double, ptr %2740, align 8, !tbaa !14
  %2742 = load ptr, ptr %19, align 8, !tbaa !5
  %2743 = load i32, ptr %34, align 4, !tbaa !9
  %2744 = sext i32 %2743 to i64
  %2745 = getelementptr inbounds %struct.doublecomplex, ptr %2742, i64 %2744
  %2746 = getelementptr inbounds %struct.doublecomplex, ptr %2745, i32 0, i32 1
  store double %2741, ptr %2746, align 8, !tbaa !14
  br label %2747

2747:                                             ; preds = %2540
  %2748 = load i32, ptr %51, align 4, !tbaa !9
  %2749 = add nsw i32 %2748, 1
  store i32 %2749, ptr %51, align 4, !tbaa !9
  br label %2536, !llvm.loop !22

2750:                                             ; preds = %2536
  %2751 = load ptr, ptr %15, align 8, !tbaa !5
  %2752 = load i32, ptr %2751, align 4, !tbaa !9
  %2753 = icmp ne i32 %2752, 0
  br i1 %2753, label %2754, label %2974

2754:                                             ; preds = %2750
  %2755 = load ptr, ptr %23, align 8, !tbaa !5
  %2756 = load i32, ptr %2755, align 4, !tbaa !9
  store i32 %2756, ptr %33, align 4, !tbaa !9
  %2757 = load ptr, ptr %22, align 8, !tbaa !5
  %2758 = load i32, ptr %2757, align 4, !tbaa !9
  store i32 %2758, ptr %51, align 4, !tbaa !9
  br label %2759

2759:                                             ; preds = %2970, %2754
  %2760 = load i32, ptr %51, align 4, !tbaa !9
  %2761 = load i32, ptr %33, align 4, !tbaa !9
  %2762 = icmp sle i32 %2760, %2761
  br i1 %2762, label %2763, label %2973

2763:                                             ; preds = %2759
  %2764 = load i32, ptr %51, align 4, !tbaa !9
  %2765 = load i32, ptr %52, align 4, !tbaa !9
  %2766 = load i32, ptr %29, align 4, !tbaa !9
  %2767 = mul nsw i32 %2765, %2766
  %2768 = add nsw i32 %2764, %2767
  store i32 %2768, ptr %34, align 4, !tbaa !9
  %2769 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2770 = load double, ptr %2769, align 8, !tbaa !11
  %2771 = load ptr, ptr %24, align 8, !tbaa !5
  %2772 = load i32, ptr %34, align 4, !tbaa !9
  %2773 = sext i32 %2772 to i64
  %2774 = getelementptr inbounds %struct.doublecomplex, ptr %2771, i64 %2773
  %2775 = getelementptr inbounds %struct.doublecomplex, ptr %2774, i32 0, i32 0
  %2776 = load double, ptr %2775, align 8, !tbaa !11
  %2777 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2778 = load double, ptr %2777, align 8, !tbaa !14
  %2779 = load ptr, ptr %24, align 8, !tbaa !5
  %2780 = load i32, ptr %34, align 4, !tbaa !9
  %2781 = sext i32 %2780 to i64
  %2782 = getelementptr inbounds %struct.doublecomplex, ptr %2779, i64 %2781
  %2783 = getelementptr inbounds %struct.doublecomplex, ptr %2782, i32 0, i32 1
  %2784 = load double, ptr %2783, align 8, !tbaa !14
  %2785 = fmul double %2778, %2784
  %2786 = fneg double %2785
  %2787 = call double @llvm.fmuladd.f64(double %2770, double %2776, double %2786)
  %2788 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2787, ptr %2788, align 8, !tbaa !11
  %2789 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2790 = load double, ptr %2789, align 8, !tbaa !11
  %2791 = load ptr, ptr %24, align 8, !tbaa !5
  %2792 = load i32, ptr %34, align 4, !tbaa !9
  %2793 = sext i32 %2792 to i64
  %2794 = getelementptr inbounds %struct.doublecomplex, ptr %2791, i64 %2793
  %2795 = getelementptr inbounds %struct.doublecomplex, ptr %2794, i32 0, i32 1
  %2796 = load double, ptr %2795, align 8, !tbaa !14
  %2797 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2798 = load double, ptr %2797, align 8, !tbaa !14
  %2799 = load ptr, ptr %24, align 8, !tbaa !5
  %2800 = load i32, ptr %34, align 4, !tbaa !9
  %2801 = sext i32 %2800 to i64
  %2802 = getelementptr inbounds %struct.doublecomplex, ptr %2799, i64 %2801
  %2803 = getelementptr inbounds %struct.doublecomplex, ptr %2802, i32 0, i32 0
  %2804 = load double, ptr %2803, align 8, !tbaa !11
  %2805 = fmul double %2798, %2804
  %2806 = call double @llvm.fmuladd.f64(double %2790, double %2796, double %2805)
  %2807 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2806, ptr %2807, align 8, !tbaa !14
  %2808 = load i32, ptr %51, align 4, !tbaa !9
  %2809 = load i32, ptr %52, align 4, !tbaa !9
  %2810 = add nsw i32 %2809, 1
  %2811 = load i32, ptr %29, align 4, !tbaa !9
  %2812 = mul nsw i32 %2810, %2811
  %2813 = add nsw i32 %2808, %2812
  store i32 %2813, ptr %35, align 4, !tbaa !9
  %2814 = load double, ptr %66, align 8, !tbaa !17
  %2815 = load ptr, ptr %24, align 8, !tbaa !5
  %2816 = load i32, ptr %35, align 4, !tbaa !9
  %2817 = sext i32 %2816 to i64
  %2818 = getelementptr inbounds %struct.doublecomplex, ptr %2815, i64 %2817
  %2819 = getelementptr inbounds %struct.doublecomplex, ptr %2818, i32 0, i32 0
  %2820 = load double, ptr %2819, align 8, !tbaa !11
  %2821 = fmul double %2814, %2820
  %2822 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %2821, ptr %2822, align 8, !tbaa !11
  %2823 = load double, ptr %66, align 8, !tbaa !17
  %2824 = load ptr, ptr %24, align 8, !tbaa !5
  %2825 = load i32, ptr %35, align 4, !tbaa !9
  %2826 = sext i32 %2825 to i64
  %2827 = getelementptr inbounds %struct.doublecomplex, ptr %2824, i64 %2826
  %2828 = getelementptr inbounds %struct.doublecomplex, ptr %2827, i32 0, i32 1
  %2829 = load double, ptr %2828, align 8, !tbaa !14
  %2830 = fmul double %2823, %2829
  %2831 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %2830, ptr %2831, align 8, !tbaa !14
  %2832 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2833 = load double, ptr %2832, align 8, !tbaa !11
  %2834 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2835 = load double, ptr %2834, align 8, !tbaa !11
  %2836 = fadd double %2833, %2835
  %2837 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2836, ptr %2837, align 8, !tbaa !11
  %2838 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2839 = load double, ptr %2838, align 8, !tbaa !14
  %2840 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2841 = load double, ptr %2840, align 8, !tbaa !14
  %2842 = fadd double %2839, %2841
  %2843 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2842, ptr %2843, align 8, !tbaa !14
  %2844 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2845 = load double, ptr %2844, align 8, !tbaa !11
  %2846 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  store double %2845, ptr %2846, align 8, !tbaa !11
  %2847 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2848 = load double, ptr %2847, align 8, !tbaa !14
  %2849 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  store double %2848, ptr %2849, align 8, !tbaa !14
  %2850 = load i32, ptr %51, align 4, !tbaa !9
  %2851 = load i32, ptr %52, align 4, !tbaa !9
  %2852 = load i32, ptr %29, align 4, !tbaa !9
  %2853 = mul nsw i32 %2851, %2852
  %2854 = add nsw i32 %2850, %2853
  store i32 %2854, ptr %34, align 4, !tbaa !9
  %2855 = load i32, ptr %51, align 4, !tbaa !9
  %2856 = load i32, ptr %52, align 4, !tbaa !9
  %2857 = load i32, ptr %29, align 4, !tbaa !9
  %2858 = mul nsw i32 %2856, %2857
  %2859 = add nsw i32 %2855, %2858
  store i32 %2859, ptr %35, align 4, !tbaa !9
  %2860 = load ptr, ptr %24, align 8, !tbaa !5
  %2861 = load i32, ptr %35, align 4, !tbaa !9
  %2862 = sext i32 %2861 to i64
  %2863 = getelementptr inbounds %struct.doublecomplex, ptr %2860, i64 %2862
  %2864 = getelementptr inbounds %struct.doublecomplex, ptr %2863, i32 0, i32 0
  %2865 = load double, ptr %2864, align 8, !tbaa !11
  %2866 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2867 = load double, ptr %2866, align 8, !tbaa !11
  %2868 = fsub double %2865, %2867
  %2869 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2868, ptr %2869, align 8, !tbaa !11
  %2870 = load ptr, ptr %24, align 8, !tbaa !5
  %2871 = load i32, ptr %35, align 4, !tbaa !9
  %2872 = sext i32 %2871 to i64
  %2873 = getelementptr inbounds %struct.doublecomplex, ptr %2870, i64 %2872
  %2874 = getelementptr inbounds %struct.doublecomplex, ptr %2873, i32 0, i32 1
  %2875 = load double, ptr %2874, align 8, !tbaa !14
  %2876 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2877 = load double, ptr %2876, align 8, !tbaa !14
  %2878 = fsub double %2875, %2877
  %2879 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2878, ptr %2879, align 8, !tbaa !14
  %2880 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2881 = load double, ptr %2880, align 8, !tbaa !11
  %2882 = load ptr, ptr %24, align 8, !tbaa !5
  %2883 = load i32, ptr %34, align 4, !tbaa !9
  %2884 = sext i32 %2883 to i64
  %2885 = getelementptr inbounds %struct.doublecomplex, ptr %2882, i64 %2884
  %2886 = getelementptr inbounds %struct.doublecomplex, ptr %2885, i32 0, i32 0
  store double %2881, ptr %2886, align 8, !tbaa !11
  %2887 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2888 = load double, ptr %2887, align 8, !tbaa !14
  %2889 = load ptr, ptr %24, align 8, !tbaa !5
  %2890 = load i32, ptr %34, align 4, !tbaa !9
  %2891 = sext i32 %2890 to i64
  %2892 = getelementptr inbounds %struct.doublecomplex, ptr %2889, i64 %2891
  %2893 = getelementptr inbounds %struct.doublecomplex, ptr %2892, i32 0, i32 1
  store double %2888, ptr %2893, align 8, !tbaa !14
  %2894 = load i32, ptr %51, align 4, !tbaa !9
  %2895 = load i32, ptr %52, align 4, !tbaa !9
  %2896 = add nsw i32 %2895, 1
  %2897 = load i32, ptr %29, align 4, !tbaa !9
  %2898 = mul nsw i32 %2896, %2897
  %2899 = add nsw i32 %2894, %2898
  store i32 %2899, ptr %34, align 4, !tbaa !9
  %2900 = load i32, ptr %51, align 4, !tbaa !9
  %2901 = load i32, ptr %52, align 4, !tbaa !9
  %2902 = add nsw i32 %2901, 1
  %2903 = load i32, ptr %29, align 4, !tbaa !9
  %2904 = mul nsw i32 %2902, %2903
  %2905 = add nsw i32 %2900, %2904
  store i32 %2905, ptr %35, align 4, !tbaa !9
  %2906 = call { double, double } @Cd(ptr noundef %67)
  %2907 = extractvalue { double, double } %2906, 0
  %2908 = extractvalue { double, double } %2906, 1
  %2909 = fneg double %2908
  %2910 = call ptr @_pCd(ptr noundef %44)
  %2911 = getelementptr inbounds { double, double }, ptr %2910, i32 0, i32 0
  %2912 = getelementptr inbounds { double, double }, ptr %2910, i32 0, i32 1
  store double %2907, ptr %2911, align 8
  store double %2909, ptr %2912, align 8
  %2913 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2914 = load double, ptr %2913, align 8, !tbaa !11
  %2915 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2916 = load double, ptr %2915, align 8, !tbaa !11
  %2917 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2918 = load double, ptr %2917, align 8, !tbaa !14
  %2919 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2920 = load double, ptr %2919, align 8, !tbaa !14
  %2921 = fmul double %2918, %2920
  %2922 = fneg double %2921
  %2923 = call double @llvm.fmuladd.f64(double %2914, double %2916, double %2922)
  %2924 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2923, ptr %2924, align 8, !tbaa !11
  %2925 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %2926 = load double, ptr %2925, align 8, !tbaa !11
  %2927 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2928 = load double, ptr %2927, align 8, !tbaa !14
  %2929 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %2930 = load double, ptr %2929, align 8, !tbaa !14
  %2931 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2932 = load double, ptr %2931, align 8, !tbaa !11
  %2933 = fmul double %2930, %2932
  %2934 = call double @llvm.fmuladd.f64(double %2926, double %2928, double %2933)
  %2935 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2934, ptr %2935, align 8, !tbaa !14
  %2936 = load ptr, ptr %24, align 8, !tbaa !5
  %2937 = load i32, ptr %35, align 4, !tbaa !9
  %2938 = sext i32 %2937 to i64
  %2939 = getelementptr inbounds %struct.doublecomplex, ptr %2936, i64 %2938
  %2940 = getelementptr inbounds %struct.doublecomplex, ptr %2939, i32 0, i32 0
  %2941 = load double, ptr %2940, align 8, !tbaa !11
  %2942 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2943 = load double, ptr %2942, align 8, !tbaa !11
  %2944 = fsub double %2941, %2943
  %2945 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2944, ptr %2945, align 8, !tbaa !11
  %2946 = load ptr, ptr %24, align 8, !tbaa !5
  %2947 = load i32, ptr %35, align 4, !tbaa !9
  %2948 = sext i32 %2947 to i64
  %2949 = getelementptr inbounds %struct.doublecomplex, ptr %2946, i64 %2948
  %2950 = getelementptr inbounds %struct.doublecomplex, ptr %2949, i32 0, i32 1
  %2951 = load double, ptr %2950, align 8, !tbaa !14
  %2952 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2953 = load double, ptr %2952, align 8, !tbaa !14
  %2954 = fsub double %2951, %2953
  %2955 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2954, ptr %2955, align 8, !tbaa !14
  %2956 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2957 = load double, ptr %2956, align 8, !tbaa !11
  %2958 = load ptr, ptr %24, align 8, !tbaa !5
  %2959 = load i32, ptr %34, align 4, !tbaa !9
  %2960 = sext i32 %2959 to i64
  %2961 = getelementptr inbounds %struct.doublecomplex, ptr %2958, i64 %2960
  %2962 = getelementptr inbounds %struct.doublecomplex, ptr %2961, i32 0, i32 0
  store double %2957, ptr %2962, align 8, !tbaa !11
  %2963 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2964 = load double, ptr %2963, align 8, !tbaa !14
  %2965 = load ptr, ptr %24, align 8, !tbaa !5
  %2966 = load i32, ptr %34, 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 1
  store double %2964, ptr %2969, align 8, !tbaa !14
  br label %2970

2970:                                             ; preds = %2763
  %2971 = load i32, ptr %51, align 4, !tbaa !9
  %2972 = add nsw i32 %2971, 1
  store i32 %2972, ptr %51, align 4, !tbaa !9
  br label %2759, !llvm.loop !23

2973:                                             ; preds = %2759
  br label %2974

2974:                                             ; preds = %2973, %2750
  %2975 = load i32, ptr %52, align 4, !tbaa !9
  %2976 = load i32, ptr %54, align 4, !tbaa !9
  %2977 = icmp eq i32 %2975, %2976
  br i1 %2977, label %2978, label %3242

2978:                                             ; preds = %2974
  %2979 = load i32, ptr %54, align 4, !tbaa !9
  %2980 = load i32, ptr %53, align 4, !tbaa !9
  %2981 = icmp sgt i32 %2979, %2980
  br i1 %2981, label %2982, label %3242

2982:                                             ; preds = %2978
  %2983 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2984 = load double, ptr %2983, align 8, !tbaa !11
  %2985 = fsub double 1.000000e+00, %2984
  %2986 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2985, ptr %2986, align 8, !tbaa !11
  %2987 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %2988 = load double, ptr %2987, align 8, !tbaa !14
  %2989 = fsub double 0.000000e+00, %2988
  %2990 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2989, ptr %2990, align 8, !tbaa !14
  %2991 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2992 = load double, ptr %2991, align 8, !tbaa !11
  %2993 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  store double %2992, ptr %2993, align 8, !tbaa !11
  %2994 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2995 = load double, ptr %2994, align 8, !tbaa !14
  %2996 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  store double %2995, ptr %2996, align 8, !tbaa !14
  %2997 = call { double, double } @Cd(ptr noundef %49)
  %2998 = extractvalue { double, double } %2997, 0
  %2999 = extractvalue { double, double } %2997, 1
  %3000 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 0
  %3001 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 1
  store double %2998, ptr %3000, align 8
  store double %2999, ptr %3001, align 8
  %3002 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 0
  %3003 = load double, ptr %3002, align 8
  %3004 = getelementptr inbounds { double, double }, ptr %98, i32 0, i32 1
  %3005 = load double, ptr %3004, align 8
  %3006 = call double @cabs(double noundef %3003, double noundef %3005) #6
  store double %3006, ptr %36, align 8, !tbaa !17
  %3007 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  %3008 = load double, ptr %3007, align 8, !tbaa !11
  %3009 = load double, ptr %36, align 8, !tbaa !17
  %3010 = fdiv double %3008, %3009
  %3011 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3010, ptr %3011, align 8, !tbaa !11
  %3012 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  %3013 = load double, ptr %3012, align 8, !tbaa !14
  %3014 = load double, ptr %36, align 8, !tbaa !17
  %3015 = fdiv double %3013, %3014
  %3016 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3015, ptr %3016, align 8, !tbaa !14
  %3017 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3018 = load double, ptr %3017, align 8, !tbaa !11
  %3019 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  store double %3018, ptr %3019, align 8, !tbaa !11
  %3020 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3021 = load double, ptr %3020, align 8, !tbaa !14
  %3022 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  store double %3021, ptr %3022, align 8, !tbaa !14
  %3023 = load i32, ptr %54, align 4, !tbaa !9
  %3024 = add nsw i32 %3023, 1
  %3025 = load i32, ptr %54, align 4, !tbaa !9
  %3026 = load i32, ptr %27, align 4, !tbaa !9
  %3027 = mul nsw i32 %3025, %3026
  %3028 = add nsw i32 %3024, %3027
  store i32 %3028, ptr %33, align 4, !tbaa !9
  %3029 = load i32, ptr %54, align 4, !tbaa !9
  %3030 = add nsw i32 %3029, 1
  %3031 = load i32, ptr %54, align 4, !tbaa !9
  %3032 = load i32, ptr %27, align 4, !tbaa !9
  %3033 = mul nsw i32 %3031, %3032
  %3034 = add nsw i32 %3030, %3033
  store i32 %3034, ptr %34, align 4, !tbaa !9
  %3035 = call { double, double } @Cd(ptr noundef %49)
  %3036 = extractvalue { double, double } %3035, 0
  %3037 = extractvalue { double, double } %3035, 1
  %3038 = fneg double %3037
  %3039 = call ptr @_pCd(ptr noundef %43)
  %3040 = getelementptr inbounds { double, double }, ptr %3039, i32 0, i32 0
  %3041 = getelementptr inbounds { double, double }, ptr %3039, i32 0, i32 1
  store double %3036, ptr %3040, align 8
  store double %3038, ptr %3041, align 8
  %3042 = load ptr, ptr %19, align 8, !tbaa !5
  %3043 = load i32, ptr %34, align 4, !tbaa !9
  %3044 = sext i32 %3043 to i64
  %3045 = getelementptr inbounds %struct.doublecomplex, ptr %3042, i64 %3044
  %3046 = getelementptr inbounds %struct.doublecomplex, ptr %3045, i32 0, i32 0
  %3047 = load double, ptr %3046, align 8, !tbaa !11
  %3048 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %3049 = load double, ptr %3048, align 8, !tbaa !11
  %3050 = load ptr, ptr %19, align 8, !tbaa !5
  %3051 = load i32, ptr %34, align 4, !tbaa !9
  %3052 = sext i32 %3051 to i64
  %3053 = getelementptr inbounds %struct.doublecomplex, ptr %3050, i64 %3052
  %3054 = getelementptr inbounds %struct.doublecomplex, ptr %3053, i32 0, i32 1
  %3055 = load double, ptr %3054, align 8, !tbaa !14
  %3056 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %3057 = load double, ptr %3056, align 8, !tbaa !14
  %3058 = fmul double %3055, %3057
  %3059 = fneg double %3058
  %3060 = call double @llvm.fmuladd.f64(double %3047, double %3049, double %3059)
  %3061 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3060, ptr %3061, align 8, !tbaa !11
  %3062 = load ptr, ptr %19, align 8, !tbaa !5
  %3063 = load i32, ptr %34, align 4, !tbaa !9
  %3064 = sext i32 %3063 to i64
  %3065 = getelementptr inbounds %struct.doublecomplex, ptr %3062, i64 %3064
  %3066 = getelementptr inbounds %struct.doublecomplex, ptr %3065, i32 0, i32 0
  %3067 = load double, ptr %3066, align 8, !tbaa !11
  %3068 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %3069 = load double, ptr %3068, align 8, !tbaa !14
  %3070 = load ptr, ptr %19, align 8, !tbaa !5
  %3071 = load i32, ptr %34, align 4, !tbaa !9
  %3072 = sext i32 %3071 to i64
  %3073 = getelementptr inbounds %struct.doublecomplex, ptr %3070, i64 %3072
  %3074 = getelementptr inbounds %struct.doublecomplex, ptr %3073, i32 0, i32 1
  %3075 = load double, ptr %3074, align 8, !tbaa !14
  %3076 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %3077 = load double, ptr %3076, align 8, !tbaa !11
  %3078 = fmul double %3075, %3077
  %3079 = call double @llvm.fmuladd.f64(double %3067, double %3069, double %3078)
  %3080 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3079, ptr %3080, align 8, !tbaa !14
  %3081 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3082 = load double, ptr %3081, align 8, !tbaa !11
  %3083 = load ptr, ptr %19, align 8, !tbaa !5
  %3084 = load i32, ptr %33, align 4, !tbaa !9
  %3085 = sext i32 %3084 to i64
  %3086 = getelementptr inbounds %struct.doublecomplex, ptr %3083, i64 %3085
  %3087 = getelementptr inbounds %struct.doublecomplex, ptr %3086, i32 0, i32 0
  store double %3082, ptr %3087, align 8, !tbaa !11
  %3088 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3089 = load double, ptr %3088, align 8, !tbaa !14
  %3090 = load ptr, ptr %19, align 8, !tbaa !5
  %3091 = load i32, ptr %33, align 4, !tbaa !9
  %3092 = sext i32 %3091 to i64
  %3093 = getelementptr inbounds %struct.doublecomplex, ptr %3090, i64 %3092
  %3094 = getelementptr inbounds %struct.doublecomplex, ptr %3093, i32 0, i32 1
  store double %3089, ptr %3094, align 8, !tbaa !14
  %3095 = load i32, ptr %54, align 4, !tbaa !9
  %3096 = add nsw i32 %3095, 2
  %3097 = load i32, ptr %50, align 4, !tbaa !9
  %3098 = icmp sle i32 %3096, %3097
  br i1 %3098, label %3099, label %3167

3099:                                             ; preds = %2982
  %3100 = load i32, ptr %54, align 4, !tbaa !9
  %3101 = add nsw i32 %3100, 2
  %3102 = load i32, ptr %54, align 4, !tbaa !9
  %3103 = add nsw i32 %3102, 1
  %3104 = load i32, ptr %27, align 4, !tbaa !9
  %3105 = mul nsw i32 %3103, %3104
  %3106 = add nsw i32 %3101, %3105
  store i32 %3106, ptr %33, align 4, !tbaa !9
  %3107 = load i32, ptr %54, align 4, !tbaa !9
  %3108 = add nsw i32 %3107, 2
  %3109 = load i32, ptr %54, align 4, !tbaa !9
  %3110 = add nsw i32 %3109, 1
  %3111 = load i32, ptr %27, align 4, !tbaa !9
  %3112 = mul nsw i32 %3110, %3111
  %3113 = add nsw i32 %3108, %3112
  store i32 %3113, ptr %34, align 4, !tbaa !9
  %3114 = load ptr, ptr %19, align 8, !tbaa !5
  %3115 = load i32, ptr %34, align 4, !tbaa !9
  %3116 = sext i32 %3115 to i64
  %3117 = getelementptr inbounds %struct.doublecomplex, ptr %3114, i64 %3116
  %3118 = getelementptr inbounds %struct.doublecomplex, ptr %3117, i32 0, i32 0
  %3119 = load double, ptr %3118, align 8, !tbaa !11
  %3120 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  %3121 = load double, ptr %3120, align 8, !tbaa !11
  %3122 = load ptr, ptr %19, align 8, !tbaa !5
  %3123 = load i32, ptr %34, align 4, !tbaa !9
  %3124 = sext i32 %3123 to i64
  %3125 = getelementptr inbounds %struct.doublecomplex, ptr %3122, i64 %3124
  %3126 = getelementptr inbounds %struct.doublecomplex, ptr %3125, i32 0, i32 1
  %3127 = load double, ptr %3126, align 8, !tbaa !14
  %3128 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  %3129 = load double, ptr %3128, align 8, !tbaa !14
  %3130 = fmul double %3127, %3129
  %3131 = fneg double %3130
  %3132 = call double @llvm.fmuladd.f64(double %3119, double %3121, double %3131)
  %3133 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3132, ptr %3133, align 8, !tbaa !11
  %3134 = load ptr, ptr %19, align 8, !tbaa !5
  %3135 = load i32, ptr %34, align 4, !tbaa !9
  %3136 = sext i32 %3135 to i64
  %3137 = getelementptr inbounds %struct.doublecomplex, ptr %3134, i64 %3136
  %3138 = getelementptr inbounds %struct.doublecomplex, ptr %3137, i32 0, i32 0
  %3139 = load double, ptr %3138, align 8, !tbaa !11
  %3140 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  %3141 = load double, ptr %3140, align 8, !tbaa !14
  %3142 = load ptr, ptr %19, align 8, !tbaa !5
  %3143 = load i32, ptr %34, align 4, !tbaa !9
  %3144 = sext i32 %3143 to i64
  %3145 = getelementptr inbounds %struct.doublecomplex, ptr %3142, i64 %3144
  %3146 = getelementptr inbounds %struct.doublecomplex, ptr %3145, i32 0, i32 1
  %3147 = load double, ptr %3146, align 8, !tbaa !14
  %3148 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  %3149 = load double, ptr %3148, align 8, !tbaa !11
  %3150 = fmul double %3147, %3149
  %3151 = call double @llvm.fmuladd.f64(double %3139, double %3141, double %3150)
  %3152 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3151, ptr %3152, align 8, !tbaa !14
  %3153 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3154 = load double, ptr %3153, align 8, !tbaa !11
  %3155 = load ptr, ptr %19, align 8, !tbaa !5
  %3156 = load i32, ptr %33, align 4, !tbaa !9
  %3157 = sext i32 %3156 to i64
  %3158 = getelementptr inbounds %struct.doublecomplex, ptr %3155, i64 %3157
  %3159 = getelementptr inbounds %struct.doublecomplex, ptr %3158, i32 0, i32 0
  store double %3154, ptr %3159, align 8, !tbaa !11
  %3160 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3161 = load double, ptr %3160, align 8, !tbaa !14
  %3162 = load ptr, ptr %19, align 8, !tbaa !5
  %3163 = load i32, ptr %33, align 4, !tbaa !9
  %3164 = sext i32 %3163 to i64
  %3165 = getelementptr inbounds %struct.doublecomplex, ptr %3162, i64 %3164
  %3166 = getelementptr inbounds %struct.doublecomplex, ptr %3165, i32 0, i32 1
  store double %3161, ptr %3166, align 8, !tbaa !14
  br label %3167

3167:                                             ; preds = %3099, %2982
  %3168 = load i32, ptr %50, align 4, !tbaa !9
  store i32 %3168, ptr %33, align 4, !tbaa !9
  %3169 = load i32, ptr %54, align 4, !tbaa !9
  store i32 %3169, ptr %51, align 4, !tbaa !9
  br label %3170

3170:                                             ; preds = %3238, %3167
  %3171 = load i32, ptr %51, align 4, !tbaa !9
  %3172 = load i32, ptr %33, align 4, !tbaa !9
  %3173 = icmp sle i32 %3171, %3172
  br i1 %3173, label %3174, label %3241

3174:                                             ; preds = %3170
  %3175 = load i32, ptr %51, align 4, !tbaa !9
  %3176 = load i32, ptr %54, align 4, !tbaa !9
  %3177 = add nsw i32 %3176, 1
  %3178 = icmp ne i32 %3175, %3177
  br i1 %3178, label %3179, label %3237

3179:                                             ; preds = %3174
  %3180 = load i32, ptr %64, align 4, !tbaa !9
  %3181 = load i32, ptr %51, align 4, !tbaa !9
  %3182 = icmp sgt i32 %3180, %3181
  br i1 %3182, label %3183, label %3197

3183:                                             ; preds = %3179
  %3184 = load i32, ptr %64, align 4, !tbaa !9
  %3185 = load i32, ptr %51, align 4, !tbaa !9
  %3186 = sub nsw i32 %3184, %3185
  store i32 %3186, ptr %34, align 4, !tbaa !9
  %3187 = load ptr, ptr %19, align 8, !tbaa !5
  %3188 = load i32, ptr %51, align 4, !tbaa !9
  %3189 = load i32, ptr %51, align 4, !tbaa !9
  %3190 = add nsw i32 %3189, 1
  %3191 = load i32, ptr %27, align 4, !tbaa !9
  %3192 = mul nsw i32 %3190, %3191
  %3193 = add nsw i32 %3188, %3192
  %3194 = sext i32 %3193 to i64
  %3195 = getelementptr inbounds %struct.doublecomplex, ptr %3187, i64 %3194
  %3196 = load ptr, ptr %20, align 8, !tbaa !5
  call void @zscal_(ptr noundef %34, ptr noundef %49, ptr noundef %3195, ptr noundef %3196)
  br label %3197

3197:                                             ; preds = %3183, %3179
  %3198 = load i32, ptr %51, align 4, !tbaa !9
  %3199 = load i32, ptr %63, align 4, !tbaa !9
  %3200 = sub nsw i32 %3198, %3199
  store i32 %3200, ptr %34, align 4, !tbaa !9
  %3201 = call { double, double } @Cd(ptr noundef %49)
  %3202 = extractvalue { double, double } %3201, 0
  %3203 = extractvalue { double, double } %3201, 1
  %3204 = fneg double %3203
  %3205 = call ptr @_pCd(ptr noundef %42)
  %3206 = getelementptr inbounds { double, double }, ptr %3205, i32 0, i32 0
  %3207 = getelementptr inbounds { double, double }, ptr %3205, i32 0, i32 1
  store double %3202, ptr %3206, align 8
  store double %3204, ptr %3207, align 8
  %3208 = load ptr, ptr %19, align 8, !tbaa !5
  %3209 = load i32, ptr %63, align 4, !tbaa !9
  %3210 = load i32, ptr %51, align 4, !tbaa !9
  %3211 = load i32, ptr %27, align 4, !tbaa !9
  %3212 = mul nsw i32 %3210, %3211
  %3213 = add nsw i32 %3209, %3212
  %3214 = sext i32 %3213 to i64
  %3215 = getelementptr inbounds %struct.doublecomplex, ptr %3208, i64 %3214
  call void @zscal_(ptr noundef %34, ptr noundef %42, ptr noundef %3215, ptr noundef @c__1)
  %3216 = load ptr, ptr %15, align 8, !tbaa !5
  %3217 = load i32, ptr %3216, align 4, !tbaa !9
  %3218 = icmp ne i32 %3217, 0
  br i1 %3218, label %3219, label %3236

3219:                                             ; preds = %3197
  %3220 = call { double, double } @Cd(ptr noundef %49)
  %3221 = extractvalue { double, double } %3220, 0
  %3222 = extractvalue { double, double } %3220, 1
  %3223 = fneg double %3222
  %3224 = call ptr @_pCd(ptr noundef %42)
  %3225 = getelementptr inbounds { double, double }, ptr %3224, i32 0, i32 0
  %3226 = getelementptr inbounds { double, double }, ptr %3224, i32 0, i32 1
  store double %3221, ptr %3225, align 8
  store double %3223, ptr %3226, align 8
  %3227 = load ptr, ptr %24, align 8, !tbaa !5
  %3228 = load ptr, ptr %22, align 8, !tbaa !5
  %3229 = load i32, ptr %3228, align 4, !tbaa !9
  %3230 = load i32, ptr %51, align 4, !tbaa !9
  %3231 = load i32, ptr %29, align 4, !tbaa !9
  %3232 = mul nsw i32 %3230, %3231
  %3233 = add nsw i32 %3229, %3232
  %3234 = sext i32 %3233 to i64
  %3235 = getelementptr inbounds %struct.doublecomplex, ptr %3227, i64 %3234
  call void @zscal_(ptr noundef %78, ptr noundef %42, ptr noundef %3235, ptr noundef @c__1)
  br label %3236

3236:                                             ; preds = %3219, %3197
  br label %3237

3237:                                             ; preds = %3236, %3174
  br label %3238

3238:                                             ; preds = %3237
  %3239 = load i32, ptr %51, align 4, !tbaa !9
  %3240 = add nsw i32 %3239, 1
  store i32 %3240, ptr %51, align 4, !tbaa !9
  br label %3170, !llvm.loop !24

3241:                                             ; preds = %3170
  br label %3242

3242:                                             ; preds = %3241, %2978, %2974
  br label %3243

3243:                                             ; preds = %3242
  %3244 = load i32, ptr %52, align 4, !tbaa !9
  %3245 = add nsw i32 %3244, 1
  store i32 %3245, ptr %52, align 4, !tbaa !9
  br label %2208, !llvm.loop !25

3246:                                             ; preds = %2208
  %3247 = load i32, ptr %50, align 4, !tbaa !9
  %3248 = load i32, ptr %50, align 4, !tbaa !9
  %3249 = sub nsw i32 %3248, 1
  %3250 = load i32, ptr %27, align 4, !tbaa !9
  %3251 = mul nsw i32 %3249, %3250
  %3252 = add nsw i32 %3247, %3251
  store i32 %3252, ptr %32, align 4, !tbaa !9
  %3253 = load ptr, ptr %19, align 8, !tbaa !5
  %3254 = load i32, ptr %32, align 4, !tbaa !9
  %3255 = sext i32 %3254 to i64
  %3256 = getelementptr inbounds %struct.doublecomplex, ptr %3253, i64 %3255
  %3257 = getelementptr inbounds %struct.doublecomplex, ptr %3256, i32 0, i32 0
  %3258 = load double, ptr %3257, align 8, !tbaa !11
  %3259 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  store double %3258, ptr %3259, align 8, !tbaa !11
  %3260 = load ptr, ptr %19, align 8, !tbaa !5
  %3261 = load i32, ptr %32, align 4, !tbaa !9
  %3262 = sext i32 %3261 to i64
  %3263 = getelementptr inbounds %struct.doublecomplex, ptr %3260, i64 %3262
  %3264 = getelementptr inbounds %struct.doublecomplex, ptr %3263, i32 0, i32 1
  %3265 = load double, ptr %3264, align 8, !tbaa !14
  %3266 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  store double %3265, ptr %3266, align 8, !tbaa !14
  %3267 = call { double, double } @Cd(ptr noundef %49)
  %3268 = extractvalue { double, double } %3267, 0
  %3269 = extractvalue { double, double } %3267, 1
  %3270 = fcmp une double %3269, 0.000000e+00
  br i1 %3270, label %3271, label %3365

3271:                                             ; preds = %3246
  %3272 = call { double, double } @Cd(ptr noundef %49)
  %3273 = extractvalue { double, double } %3272, 0
  %3274 = extractvalue { double, double } %3272, 1
  %3275 = getelementptr inbounds { double, double }, ptr %99, i32 0, i32 0
  %3276 = getelementptr inbounds { double, double }, ptr %99, i32 0, i32 1
  store double %3273, ptr %3275, align 8
  store double %3274, ptr %3276, align 8
  %3277 = getelementptr inbounds { double, double }, ptr %99, i32 0, i32 0
  %3278 = load double, ptr %3277, align 8
  %3279 = getelementptr inbounds { double, double }, ptr %99, i32 0, i32 1
  %3280 = load double, ptr %3279, align 8
  %3281 = call double @cabs(double noundef %3278, double noundef %3280) #6
  store double %3281, ptr %62, align 8, !tbaa !17
  %3282 = load i32, ptr %50, align 4, !tbaa !9
  %3283 = load i32, ptr %50, align 4, !tbaa !9
  %3284 = sub nsw i32 %3283, 1
  %3285 = load i32, ptr %27, align 4, !tbaa !9
  %3286 = mul nsw i32 %3284, %3285
  %3287 = add nsw i32 %3282, %3286
  store i32 %3287, ptr %32, align 4, !tbaa !9
  %3288 = load double, ptr %62, align 8, !tbaa !17
  %3289 = load ptr, ptr %19, align 8, !tbaa !5
  %3290 = load i32, ptr %32, align 4, !tbaa !9
  %3291 = sext i32 %3290 to i64
  %3292 = getelementptr inbounds %struct.doublecomplex, ptr %3289, i64 %3291
  %3293 = getelementptr inbounds %struct.doublecomplex, ptr %3292, i32 0, i32 0
  store double %3288, ptr %3293, align 8, !tbaa !11
  %3294 = load ptr, ptr %19, align 8, !tbaa !5
  %3295 = load i32, ptr %32, align 4, !tbaa !9
  %3296 = sext i32 %3295 to i64
  %3297 = getelementptr inbounds %struct.doublecomplex, ptr %3294, i64 %3296
  %3298 = getelementptr inbounds %struct.doublecomplex, ptr %3297, i32 0, i32 1
  store double 0.000000e+00, ptr %3298, align 8, !tbaa !14
  %3299 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  %3300 = load double, ptr %3299, align 8, !tbaa !11
  %3301 = load double, ptr %62, align 8, !tbaa !17
  %3302 = fdiv double %3300, %3301
  %3303 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3302, ptr %3303, align 8, !tbaa !11
  %3304 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  %3305 = load double, ptr %3304, align 8, !tbaa !14
  %3306 = load double, ptr %62, align 8, !tbaa !17
  %3307 = fdiv double %3305, %3306
  %3308 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3307, ptr %3308, align 8, !tbaa !14
  %3309 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3310 = load double, ptr %3309, align 8, !tbaa !11
  %3311 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 0
  store double %3310, ptr %3311, align 8, !tbaa !11
  %3312 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3313 = load double, ptr %3312, align 8, !tbaa !14
  %3314 = getelementptr inbounds %struct.doublecomplex, ptr %49, i32 0, i32 1
  store double %3313, ptr %3314, align 8, !tbaa !14
  %3315 = load i32, ptr %64, align 4, !tbaa !9
  %3316 = load i32, ptr %50, align 4, !tbaa !9
  %3317 = icmp sgt i32 %3315, %3316
  br i1 %3317, label %3318, label %3339

3318:                                             ; preds = %3271
  %3319 = load i32, ptr %64, align 4, !tbaa !9
  %3320 = load i32, ptr %50, align 4, !tbaa !9
  %3321 = sub nsw i32 %3319, %3320
  store i32 %3321, ptr %32, align 4, !tbaa !9
  %3322 = call { double, double } @Cd(ptr noundef %49)
  %3323 = extractvalue { double, double } %3322, 0
  %3324 = extractvalue { double, double } %3322, 1
  %3325 = fneg double %3324
  %3326 = call ptr @_pCd(ptr noundef %42)
  %3327 = getelementptr inbounds { double, double }, ptr %3326, i32 0, i32 0
  %3328 = getelementptr inbounds { double, double }, ptr %3326, i32 0, i32 1
  store double %3323, ptr %3327, align 8
  store double %3325, ptr %3328, align 8
  %3329 = load ptr, ptr %19, align 8, !tbaa !5
  %3330 = load i32, ptr %50, align 4, !tbaa !9
  %3331 = load i32, ptr %50, align 4, !tbaa !9
  %3332 = add nsw i32 %3331, 1
  %3333 = load i32, ptr %27, align 4, !tbaa !9
  %3334 = mul nsw i32 %3332, %3333
  %3335 = add nsw i32 %3330, %3334
  %3336 = sext i32 %3335 to i64
  %3337 = getelementptr inbounds %struct.doublecomplex, ptr %3329, i64 %3336
  %3338 = load ptr, ptr %20, align 8, !tbaa !5
  call void @zscal_(ptr noundef %32, ptr noundef %42, ptr noundef %3337, ptr noundef %3338)
  br label %3339

3339:                                             ; preds = %3318, %3271
  %3340 = load i32, ptr %50, align 4, !tbaa !9
  %3341 = load i32, ptr %63, align 4, !tbaa !9
  %3342 = sub nsw i32 %3340, %3341
  store i32 %3342, ptr %32, align 4, !tbaa !9
  %3343 = load ptr, ptr %19, align 8, !tbaa !5
  %3344 = load i32, ptr %63, align 4, !tbaa !9
  %3345 = load i32, ptr %50, align 4, !tbaa !9
  %3346 = load i32, ptr %27, align 4, !tbaa !9
  %3347 = mul nsw i32 %3345, %3346
  %3348 = add nsw i32 %3344, %3347
  %3349 = sext i32 %3348 to i64
  %3350 = getelementptr inbounds %struct.doublecomplex, ptr %3343, i64 %3349
  call void @zscal_(ptr noundef %32, ptr noundef %49, ptr noundef %3350, ptr noundef @c__1)
  %3351 = load ptr, ptr %15, align 8, !tbaa !5
  %3352 = load i32, ptr %3351, align 4, !tbaa !9
  %3353 = icmp ne i32 %3352, 0
  br i1 %3353, label %3354, label %3364

3354:                                             ; preds = %3339
  %3355 = load ptr, ptr %24, align 8, !tbaa !5
  %3356 = load ptr, ptr %22, align 8, !tbaa !5
  %3357 = load i32, ptr %3356, align 4, !tbaa !9
  %3358 = load i32, ptr %50, align 4, !tbaa !9
  %3359 = load i32, ptr %29, align 4, !tbaa !9
  %3360 = mul nsw i32 %3358, %3359
  %3361 = add nsw i32 %3357, %3360
  %3362 = sext i32 %3361 to i64
  %3363 = getelementptr inbounds %struct.doublecomplex, ptr %3355, i64 %3362
  call void @zscal_(ptr noundef %78, ptr noundef %49, ptr noundef %3363, ptr noundef @c__1)
  br label %3364

3364:                                             ; preds = %3354, %3339
  br label %3365

3365:                                             ; preds = %3364, %3246
  br label %3366

3366:                                             ; preds = %3365
  %3367 = load i32, ptr %86, align 4, !tbaa !9
  %3368 = add nsw i32 %3367, 1
  store i32 %3368, ptr %86, align 4, !tbaa !9
  br label %540, !llvm.loop !26

3369:                                             ; preds = %540
  %3370 = load i32, ptr %50, align 4, !tbaa !9
  %3371 = load ptr, ptr %26, align 8, !tbaa !5
  store i32 %3370, ptr %3371, align 4, !tbaa !9
  store i32 1, ptr %90, align 4
  br label %3404

3372:                                             ; preds = %1268
  %3373 = load i32, ptr %50, align 4, !tbaa !9
  store i32 %3373, ptr %31, align 4, !tbaa !9
  %3374 = load i32, ptr %50, align 4, !tbaa !9
  %3375 = load i32, ptr %50, align 4, !tbaa !9
  %3376 = load i32, ptr %27, align 4, !tbaa !9
  %3377 = mul nsw i32 %3375, %3376
  %3378 = add nsw i32 %3374, %3377
  store i32 %3378, ptr %32, align 4, !tbaa !9
  %3379 = load ptr, ptr %19, align 8, !tbaa !5
  %3380 = load i32, ptr %32, align 4, !tbaa !9
  %3381 = sext i32 %3380 to i64
  %3382 = getelementptr inbounds %struct.doublecomplex, ptr %3379, i64 %3381
  %3383 = getelementptr inbounds %struct.doublecomplex, ptr %3382, i32 0, i32 0
  %3384 = load double, ptr %3383, align 8, !tbaa !11
  %3385 = load ptr, ptr %21, align 8, !tbaa !5
  %3386 = load i32, ptr %31, align 4, !tbaa !9
  %3387 = sext i32 %3386 to i64
  %3388 = getelementptr inbounds %struct.doublecomplex, ptr %3385, i64 %3387
  %3389 = getelementptr inbounds %struct.doublecomplex, ptr %3388, i32 0, i32 0
  store double %3384, ptr %3389, align 8, !tbaa !11
  %3390 = load ptr, ptr %19, align 8, !tbaa !5
  %3391 = load i32, ptr %32, align 4, !tbaa !9
  %3392 = sext i32 %3391 to i64
  %3393 = getelementptr inbounds %struct.doublecomplex, ptr %3390, i64 %3392
  %3394 = getelementptr inbounds %struct.doublecomplex, ptr %3393, i32 0, i32 1
  %3395 = load double, ptr %3394, align 8, !tbaa !14
  %3396 = load ptr, ptr %21, align 8, !tbaa !5
  %3397 = load i32, ptr %31, align 4, !tbaa !9
  %3398 = sext i32 %3397 to i64
  %3399 = getelementptr inbounds %struct.doublecomplex, ptr %3396, i64 %3398
  %3400 = getelementptr inbounds %struct.doublecomplex, ptr %3399, i32 0, i32 1
  store double %3395, ptr %3400, align 8, !tbaa !14
  %3401 = load i32, ptr %53, align 4, !tbaa !9
  %3402 = sub nsw i32 %3401, 1
  store i32 %3402, ptr %50, align 4, !tbaa !9
  br label %530

3403:                                             ; preds = %535
  store i32 1, ptr %90, align 4
  br label %3404

3404:                                             ; preds = %3403, %3369, %133, %126
  call void @llvm.lifetime.end.p0(i64 8, ptr %89) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %88) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %87) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %84) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %82) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %75) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %73) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %71) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %69) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %67) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %65) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %60) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %59) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %58) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %57) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  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: inlinehint nounwind uwtable
declare hidden { double, double } @Cd(ptr noundef) #2

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

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

declare void @zscal_(ptr noundef, ptr noundef, ptr noundef, ptr noundef) #4

declare double @dlamch_(ptr noundef) #4

declare void @dlabad_(ptr noundef, ptr noundef) #4

; Function Attrs: nounwind
declare { double, double } @csqrt(double noundef, double noundef) #3

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

; Function Attrs: nounwind uwtable
declare hidden { double, double } @zpow_ui(double noundef, double noundef, i32 noundef) #0

declare void @zladiv_(ptr noundef, ptr noundef, ptr noundef) #4

declare void @zcopy_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #4

declare void @zlarfg_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #4

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 8}
!13 = !{!"double", !7, i64 0}
!14 = !{!12, !13, i64 8}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = !{!13, !13, i64 0}
!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}


; 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 }

@c__1 = external hidden global i32, align 4
@.str = external hidden unnamed_addr constant [13 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@c__2 = external hidden global i32, align 4

; Function Attrs: nounwind uwtable
define dso_local void @zlahqr_(ptr nocapture noundef readonly %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr nocapture noundef readonly %4, ptr noundef %5, ptr noundef %6, ptr nocapture noundef writeonly %7, ptr nocapture noundef readonly %8, ptr nocapture noundef readonly %9, ptr noundef %10, ptr nocapture noundef readonly %11, ptr nocapture noundef writeonly %12) local_unnamed_addr #0 {
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca %struct.doublecomplex, align 16
  %17 = alloca %struct.doublecomplex, align 16
  %18 = alloca %struct.doublecomplex, align 16
  %19 = alloca %struct.doublecomplex, align 16
  %20 = alloca %struct.doublecomplex, align 16
  %21 = alloca %struct.doublecomplex, align 16
  %22 = alloca %struct.doublecomplex, align 16
  %23 = alloca %struct.doublecomplex, align 16
  %24 = alloca %struct.doublecomplex, align 16
  %25 = alloca [2 x %struct.doublecomplex], align 16
  %26 = alloca %struct.doublecomplex, align 16
  %27 = alloca %struct.doublecomplex, align 16
  %28 = alloca %struct.doublecomplex, align 16
  %29 = alloca %struct.doublecomplex, align 16
  %30 = alloca %struct.doublecomplex, align 16
  %31 = alloca %struct.doublecomplex, align 16
  %32 = alloca %struct.doublecomplex, align 16
  %33 = alloca i32, align 4
  %34 = alloca double, align 8
  %35 = alloca double, align 8
  %36 = alloca %struct.doublecomplex, align 16
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %14) #9
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %15) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %16) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %17) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %18) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %19) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %20) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %21) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %22) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %23) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %24) #9
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %25) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %26) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %27) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %28) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %29) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %30) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %31) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %32) #9
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %33) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %34) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %35) #9
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %36) #9
  %37 = load i32, ptr %6, align 4, !tbaa !5
  %narrow = xor i32 %37, -1
  %38 = sext i32 %narrow to i64
  %39 = getelementptr inbounds %struct.doublecomplex, ptr %5, i64 %38
  %40 = getelementptr inbounds i8, ptr %7, i64 -16
  %41 = load i32, ptr %11, align 4, !tbaa !5
  %narrow904 = xor i32 %41, -1
  %42 = sext i32 %narrow904 to i64
  %43 = getelementptr inbounds %struct.doublecomplex, ptr %10, i64 %42
  store i32 0, ptr %12, align 4, !tbaa !5
  %44 = load i32, ptr %2, align 4, !tbaa !5
  %45 = icmp eq i32 %44, 0
  br i1 %45, label %.loopexit935, label %46

46:                                               ; preds = %13
  %47 = load i32, ptr %3, align 4, !tbaa !5
  %48 = load i32, ptr %4, align 4, !tbaa !5
  %49 = icmp eq i32 %47, %48
  br i1 %49, label %50, label %58

50:                                               ; preds = %46
  %51 = add i32 %37, 1
  %52 = mul i32 %47, %51
  %53 = sext i32 %52 to i64
  %54 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %53
  %55 = sext i32 %47 to i64
  %56 = getelementptr inbounds %struct.doublecomplex, ptr %40, i64 %55
  %57 = load <2 x double>, ptr %54, align 8, !tbaa !9
  store <2 x double> %57, ptr %56, align 8, !tbaa !9
  br label %.loopexit935

58:                                               ; preds = %46
  %59 = add nsw i32 %48, -3
  %.not941 = icmp sgt i32 %47, %59
  br i1 %.not941, label %._crit_edge1043, label %.lr.ph.preheader

._crit_edge1043:                                  ; preds = %58
  %.pre1044 = add nsw i32 %48, -2
  br label %82

.lr.ph.preheader:                                 ; preds = %58
  %60 = sext i32 %47 to i64
  %61 = sext i32 %37 to i64
  %62 = add i32 %48, -2
  %63 = sub i32 %48, %47
  %64 = add i32 %48, -3
  %xtraiter = and i32 %63, 1
  %lcmp.mod.not = icmp eq i32 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.lr.ph.prol.loopexit, label %.lr.ph.prol

.lr.ph.prol:                                      ; preds = %.lr.ph.preheader
  %65 = mul nsw i64 %60, %61
  %66 = getelementptr %struct.doublecomplex, ptr %39, i64 %60
  %67 = getelementptr i8, ptr %66, i64 32
  %68 = getelementptr %struct.doublecomplex, ptr %67, i64 %65
  %69 = add nsw i64 %60, 3
  %70 = add nsw i64 %69, %65
  %71 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %70
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %68, i8 0, i64 16, i1 false)
  %indvars.iv.next.prol = add nsw i64 %60, 1
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %71, i8 0, i64 16, i1 false)
  br label %.lr.ph.prol.loopexit

.lr.ph.prol.loopexit:                             ; preds = %.lr.ph.prol, %.lr.ph.preheader
  %.lcssa1089.unr = phi i64 [ poison, %.lr.ph.preheader ], [ %70, %.lr.ph.prol ]
  %indvars.iv.unr = phi i64 [ %60, %.lr.ph.preheader ], [ %indvars.iv.next.prol, %.lr.ph.prol ]
  %72 = icmp eq i32 %64, %47
  br i1 %72, label %._crit_edge, label %.lr.ph.preheader.new

.lr.ph.preheader.new:                             ; preds = %.lr.ph.prol.loopexit
  %invariant.gep1100 = getelementptr i8, ptr %39, i64 32
  %invariant.gep1102 = getelementptr i8, ptr %39, i64 48
  %invariant.gep1104 = getelementptr i8, ptr %39, i64 32
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph, %.lr.ph.preheader.new
  %indvars.iv = phi i64 [ %indvars.iv.unr, %.lr.ph.preheader.new ], [ %indvars.iv.next.1, %.lr.ph ]
  %73 = mul nsw i64 %indvars.iv, %61
  %gep1101 = getelementptr %struct.doublecomplex, ptr %invariant.gep1100, i64 %indvars.iv
  %74 = getelementptr %struct.doublecomplex, ptr %gep1101, i64 %73
  %gep1103 = getelementptr %struct.doublecomplex, ptr %invariant.gep1102, i64 %indvars.iv
  %75 = getelementptr %struct.doublecomplex, ptr %gep1103, i64 %73
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %74, i8 0, i64 16, i1 false)
  %indvars.iv.next = add nsw i64 %indvars.iv, 1
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %75, i8 0, i64 16, i1 false)
  %76 = mul nsw i64 %indvars.iv.next, %61
  %gep1105 = getelementptr %struct.doublecomplex, ptr %invariant.gep1104, i64 %indvars.iv.next
  %77 = getelementptr %struct.doublecomplex, ptr %gep1105, i64 %76
  %78 = add nsw i64 %indvars.iv, 4
  %79 = add nsw i64 %78, %76
  %80 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %79
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %77, i8 0, i64 16, i1 false)
  %indvars.iv.next.1 = add nsw i64 %indvars.iv, 2
  %lftr.wideiv.1 = trunc i64 %indvars.iv.next.1 to i32
  %exitcond.not.1 = icmp eq i32 %62, %lftr.wideiv.1
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %80, i8 0, i64 16, i1 false)
  br i1 %exitcond.not.1, label %._crit_edge, label %.lr.ph, !llvm.loop !11

._crit_edge:                                      ; preds = %.lr.ph, %.lr.ph.prol.loopexit
  %.lcssa1089 = phi i64 [ %.lcssa1089.unr, %.lr.ph.prol.loopexit ], [ %79, %.lr.ph ]
  %81 = trunc nsw i64 %.lcssa1089 to i32
  store i32 %81, ptr %14, align 4, !tbaa !5
  br label %82

82:                                               ; preds = %._crit_edge1043, %._crit_edge
  %.pre-phi = phi i32 [ %.pre1044, %._crit_edge1043 ], [ %62, %._crit_edge ]
  %.not905 = icmp sgt i32 %47, %.pre-phi
  br i1 %.not905, label %88, label %83

83:                                               ; preds = %82
  %84 = mul nsw i32 %.pre-phi, %37
  %85 = add nsw i32 %84, %48
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %86
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %87, i8 0, i64 16, i1 false)
  br label %88

88:                                               ; preds = %83, %82
  %89 = load i32, ptr %0, align 4, !tbaa !5
  %.not906 = icmp eq i32 %89, 0
  %spec.select930 = select i1 %.not906, ptr %4, ptr %2
  %spec.select931 = select i1 %.not906, i32 %47, i32 1
  %.0882 = load i32, ptr %spec.select930, align 4, !tbaa !5
  %.not907.not944 = icmp slt i32 %47, %48
  br i1 %.not907.not944, label %.lr.ph948, label %._crit_edge949

.lr.ph948:                                        ; preds = %88
  %90 = sext i32 %47 to i64
  %91 = sext i32 %37 to i64
  %92 = sext i32 %spec.select931 to i64
  %93 = sext i32 %41 to i64
  %wide.trip.count = sext i32 %48 to i64
  %invariant.gep = getelementptr %struct.doublecomplex, ptr %39, i64 %92
  br label %94

94:                                               ; preds = %.lr.ph948, %174
  %indvars.iv1002 = phi i64 [ %90, %.lr.ph948 ], [ %indvars.iv.next1003, %174 ]
  %indvars.iv.next1003 = add nsw i64 %indvars.iv1002, 1
  %95 = mul nsw i64 %indvars.iv1002, %91
  %96 = add nsw i64 %indvars.iv.next1003, %95
  %97 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %96
  %98 = call { double, double } @Cd(ptr noundef %97)
  %99 = extractvalue { double, double } %98, 1
  %100 = fcmp une double %99, 0.000000e+00
  br i1 %100, label %101, label %174

101:                                              ; preds = %94
  %indvars = trunc i64 %indvars.iv.next1003 to i32
  %102 = trunc nsw i64 %96 to i32
  store i32 %102, ptr %14, align 4, !tbaa !5
  %103 = load double, ptr %97, align 8, !tbaa !13
  %104 = call { double, double } @Cd(ptr noundef nonnull %97)
  %105 = extractvalue { double, double } %104, 1
  %106 = insertelement <2 x double> poison, double %103, i64 0
  %107 = insertelement <2 x double> %106, double %105, i64 1
  %108 = fcmp oge <2 x double> %107, zeroinitializer
  %109 = fneg <2 x double> %107
  %110 = select <2 x i1> %108, <2 x double> %107, <2 x double> %109
  %shift = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %111 = fadd <2 x double> %110, %shift
  %112 = load i32, ptr %14, align 4, !tbaa !5
  %113 = sext i32 %112 to i64
  %114 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %113
  %115 = load <2 x double>, ptr %114, align 8, !tbaa !9
  %116 = shufflevector <2 x double> %111, <2 x double> poison, <2 x i32> zeroinitializer
  %117 = fdiv <2 x double> %115, %116
  store <2 x double> %117, ptr %16, align 16, !tbaa !9
  store <2 x double> %117, ptr %32, align 16, !tbaa !9
  %118 = call { double, double } @Cd(ptr noundef nonnull %32)
  %119 = extractvalue { double, double } %118, 0
  %120 = extractvalue { double, double } %118, 1
  %121 = fneg double %120
  %122 = call ptr @_pCd(ptr noundef nonnull %17)
  %123 = getelementptr inbounds i8, ptr %122, i64 8
  store double %119, ptr %122, align 8
  store double %121, ptr %123, align 8
  %124 = call { double, double } @Cd(ptr noundef nonnull %32)
  %125 = extractvalue { double, double } %124, 0
  %126 = extractvalue { double, double } %124, 1
  %127 = call double @cabs(double noundef %125, double noundef %126) #9
  %128 = load <2 x double>, ptr %17, align 16, !tbaa !9
  %129 = insertelement <2 x double> poison, double %127, i64 0
  %130 = shufflevector <2 x double> %129, <2 x double> poison, <2 x i32> zeroinitializer
  %131 = fdiv <2 x double> %128, %130
  store <2 x double> %131, ptr %16, align 16, !tbaa !9
  store <2 x double> %131, ptr %32, align 16, !tbaa !9
  store i32 %102, ptr %14, align 4, !tbaa !5
  %132 = call { double, double } @Cd(ptr noundef nonnull %97)
  %133 = extractvalue { double, double } %132, 0
  %134 = extractvalue { double, double } %132, 1
  %135 = call double @cabs(double noundef %133, double noundef %134) #9
  %136 = load i32, ptr %14, align 4, !tbaa !5
  %137 = sext i32 %136 to i64
  %138 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %137
  store double %135, ptr %138, align 8, !tbaa !13
  %139 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %137, i32 1
  store double 0.000000e+00, ptr %139, align 8, !tbaa !15
  %140 = trunc nsw i64 %indvars.iv1002 to i32
  %141 = sub i32 %.0882, %140
  store i32 %141, ptr %14, align 4, !tbaa !5
  %142 = mul nsw i64 %indvars.iv.next1003, %91
  %143 = mul nsw i32 %37, %indvars
  %144 = sext i32 %143 to i64
  %145 = getelementptr %struct.doublecomplex, ptr %39, i64 %indvars.iv.next1003
  %146 = getelementptr %struct.doublecomplex, ptr %145, i64 %144
  call void @zscal_(ptr noundef nonnull %14, ptr noundef nonnull %32, ptr noundef %146, ptr noundef nonnull %6) #9
  %147 = trunc i64 %indvars.iv1002 to i32
  %148 = add i32 %147, 2
  store i32 %148, ptr %15, align 4, !tbaa !5
  %149 = call i32 @llvm.smin.i32(i32 %.0882, i32 %148)
  %reass.sub = sub i32 %149, %spec.select931
  %150 = add i32 %reass.sub, 1
  store i32 %150, ptr %14, align 4, !tbaa !5
  %151 = call { double, double } @Cd(ptr noundef nonnull %32)
  %152 = extractvalue { double, double } %151, 0
  %153 = extractvalue { double, double } %151, 1
  %154 = fneg double %153
  %155 = call ptr @_pCd(ptr noundef nonnull %16)
  %156 = getelementptr inbounds i8, ptr %155, i64 8
  store double %152, ptr %155, align 8
  store double %154, ptr %156, align 8
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %142
  call void @zscal_(ptr noundef nonnull %14, ptr noundef nonnull %16, ptr noundef %gep, ptr noundef nonnull @c__1) #9
  %157 = load i32, ptr %1, align 4, !tbaa !5
  %.not928 = icmp eq i32 %157, 0
  br i1 %.not928, label %174, label %158

158:                                              ; preds = %101
  %159 = load i32, ptr %9, align 4, !tbaa !5
  %160 = load i32, ptr %8, align 4, !tbaa !5
  %161 = add i32 %159, 1
  %162 = sub i32 %161, %160
  store i32 %162, ptr %14, align 4, !tbaa !5
  %163 = call { double, double } @Cd(ptr noundef nonnull %32)
  %164 = extractvalue { double, double } %163, 0
  %165 = extractvalue { double, double } %163, 1
  %166 = fneg double %165
  %167 = call ptr @_pCd(ptr noundef nonnull %16)
  %168 = getelementptr inbounds i8, ptr %167, i64 8
  store double %164, ptr %167, align 8
  store double %166, ptr %168, align 8
  %169 = load i32, ptr %8, align 4, !tbaa !5
  %170 = mul nsw i64 %indvars.iv.next1003, %93
  %171 = sext i32 %169 to i64
  %172 = getelementptr %struct.doublecomplex, ptr %43, i64 %170
  %173 = getelementptr %struct.doublecomplex, ptr %172, i64 %171
  call void @zscal_(ptr noundef nonnull %14, ptr noundef nonnull %16, ptr noundef %173, ptr noundef nonnull @c__1) #9
  br label %174

174:                                              ; preds = %94, %158, %101
  %exitcond1005.not = icmp eq i64 %indvars.iv.next1003, %wide.trip.count
  br i1 %exitcond1005.not, label %._crit_edge949.loopexit, label %94, !llvm.loop !16

._crit_edge949.loopexit:                          ; preds = %174
  %.pre = load i32, ptr %4, align 4, !tbaa !5
  %.pre1040 = load i32, ptr %3, align 4, !tbaa !5
  br label %._crit_edge949

._crit_edge949:                                   ; preds = %._crit_edge949.loopexit, %88
  %175 = phi i32 [ %.pre1040, %._crit_edge949.loopexit ], [ %47, %88 ]
  %176 = phi i32 [ %.pre, %._crit_edge949.loopexit ], [ %48, %88 ]
  %177 = sub nsw i32 %176, %175
  %178 = add nsw i32 %177, 1
  %179 = load i32, ptr %9, align 4, !tbaa !5
  %180 = load i32, ptr %8, align 4, !tbaa !5
  %181 = add i32 %179, 1
  %182 = sub i32 %181, %180
  store i32 %182, ptr %33, align 4, !tbaa !5
  %183 = call double @dlamch_(ptr noundef nonnull @.str) #9
  store double %183, ptr %34, align 8, !tbaa !9
  %184 = fdiv double 1.000000e+00, %183
  store double %184, ptr %35, align 8, !tbaa !9
  call void @dlabad_(ptr noundef nonnull %34, ptr noundef nonnull %35) #9
  %185 = call double @dlamch_(ptr noundef nonnull @.str.1) #9
  %186 = load double, ptr %34, align 8, !tbaa !9
  %187 = sitofp i32 %178 to double
  %188 = fdiv double %187, %185
  %189 = fmul double %186, %188
  %190 = load i32, ptr %0, align 4, !tbaa !5
  %.not908 = icmp eq i32 %190, 0
  br i1 %.not908, label %193, label %191

191:                                              ; preds = %._crit_edge949
  %192 = load i32, ptr %2, align 4, !tbaa !5
  br label %193

193:                                              ; preds = %191, %._crit_edge949
  %.0887 = phi i32 [ %192, %191 ], [ undef, %._crit_edge949 ]
  %194 = icmp slt i32 %177, 10
  %195 = mul nsw i32 %178, 30
  %196 = select i1 %194, i32 300, i32 %195
  %197 = load i32, ptr %4, align 4, !tbaa !5
  %198 = load i32, ptr %3, align 4, !tbaa !5
  %199 = icmp slt i32 %197, %198
  br i1 %199, label %.loopexit935, label %.preheader.lr.ph

.preheader.lr.ph:                                 ; preds = %193
  %.not909983 = icmp slt i32 %196, 0
  %200 = getelementptr inbounds i8, ptr %17, i64 8
  %201 = add i32 %37, 1
  %202 = getelementptr inbounds i8, ptr %18, i64 8
  %203 = getelementptr inbounds i8, ptr %24, i64 8
  %204 = getelementptr inbounds i8, ptr %25, i64 16
  %205 = getelementptr inbounds i8, ptr %25, i64 24
  %206 = getelementptr inbounds i8, ptr %28, i64 8
  br i1 %.not909983, label %.preheader._crit_edge, label %.preheader.preheader

.preheader.preheader:                             ; preds = %.preheader.lr.ph
  %207 = sext i32 %37 to i64
  %208 = sext i32 %41 to i64
  %indvars.iv.next10071045 = add nsw i64 %207, 1
  %invariant.gep1057 = getelementptr i8, ptr %39, i64 16
  %invariant.gep1061 = getelementptr i8, ptr %39, i64 16
  br label %.preheader

.preheader:                                       ; preds = %.preheader.preheader, %998
  %209 = phi i32 [ %425, %998 ], [ %198, %.preheader.preheader ]
  %.1994 = phi i32 [ %1001, %998 ], [ %197, %.preheader.preheader ]
  %.1884993 = phi i32 [ %.2885985, %998 ], [ 1, %.preheader.preheader ]
  %.1888992 = phi i32 [ %.2889984, %998 ], [ %.0887, %.preheader.preheader ]
  %210 = add i32 %.1994, -1
  %211 = mul nsw i32 %210, %37
  %212 = add nsw i32 %211, %.1994
  %213 = sext i32 %212 to i64
  %214 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %213
  %215 = mul i32 %.1994, %201
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %216
  %218 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %216, i32 1
  %219 = mul nsw i32 %.1994, %37
  %220 = add nsw i32 %219, %.1994
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %221
  %223 = add nsw i32 %210, %219
  %224 = sext i32 %223 to i64
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %224
  %226 = add nsw i32 %211, %210
  %227 = sext i32 %226 to i64
  %228 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %227
  %229 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %213, i32 1
  %230 = add i32 %.1994, 1
  %231 = mul nsw i32 %230, %37
  %232 = add nsw i32 %231, %.1994
  %233 = sext i32 %232 to i64
  %234 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %233
  %235 = mul nsw i32 %.1994, %41
  %236 = sext i32 %.1994 to i64
  %237 = sext i32 %210 to i64
  br label %238

238:                                              ; preds = %.preheader, %996
  %.0876987 = phi i32 [ %209, %.preheader ], [ %.0874.lcssa, %996 ]
  %.0880986 = phi i32 [ 0, %.preheader ], [ %997, %996 ]
  %.2885985 = phi i32 [ %.1884993, %.preheader ], [ %spec.select929, %996 ]
  %.2889984 = phi i32 [ %.1888992, %.preheader ], [ %spec.select, %996 ]
  %239 = add nsw i32 %.0876987, 1
  store i32 %239, ptr %14, align 4, !tbaa !5
  %.not910950.not = icmp sgt i32 %.1994, %.0876987
  br i1 %.not910950.not, label %.lr.ph953, label %._crit_edge954

.lr.ph953:                                        ; preds = %238, %422
  %indvars.iv1006 = phi i64 [ %indvars.iv.next1007, %422 ], [ %236, %238 ]
  %indvars1009 = trunc i64 %indvars.iv1006 to i32
  %indvars.iv.next1007 = add nsw i64 %indvars.iv1006, -1
  %indvars1008 = trunc i64 %indvars.iv.next1007 to i32
  %240 = mul nsw i32 %37, %indvars1008
  %241 = sext i32 %240 to i64
  %242 = getelementptr %struct.doublecomplex, ptr %39, i64 %indvars.iv1006
  %243 = getelementptr %struct.doublecomplex, ptr %242, i64 %241
  %244 = load double, ptr %243, align 8, !tbaa !13
  %245 = call { double, double } @Cd(ptr noundef nonnull %243)
  %246 = extractvalue { double, double } %245, 1
  %247 = insertelement <2 x double> poison, double %244, i64 0
  %248 = insertelement <2 x double> %247, double %246, i64 1
  %249 = fcmp oge <2 x double> %248, zeroinitializer
  %250 = fneg <2 x double> %248
  %251 = select <2 x i1> %249, <2 x double> %248, <2 x double> %250
  %shift1073 = shufflevector <2 x double> %251, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %252 = fadd <2 x double> %251, %shift1073
  %253 = extractelement <2 x double> %252, i64 0
  %254 = fcmp ugt double %253, %189
  br i1 %254, label %255, label %._crit_edge954

255:                                              ; preds = %.lr.ph953
  %256 = mul i64 %indvars.iv.next1007, %indvars.iv.next10071045
  %257 = mul nsw i64 %indvars.iv1006, %207
  %258 = mul nsw i32 %37, %indvars1009
  %259 = add nsw i32 %258, %indvars1009
  store i32 %259, ptr %15, align 4, !tbaa !5
  %260 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %256
  %261 = load double, ptr %260, align 8, !tbaa !13
  %262 = call { double, double } @Cd(ptr noundef nonnull %260)
  %263 = extractvalue { double, double } %262, 1
  %264 = load i32, ptr %15, align 4, !tbaa !5
  %265 = sext i32 %264 to i64
  %266 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %265
  %267 = load double, ptr %266, align 8, !tbaa !13
  %268 = sext i32 %259 to i64
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %268
  %270 = call { double, double } @Cd(ptr noundef %269)
  %271 = extractvalue { double, double } %270, 1
  %272 = insertelement <2 x double> poison, double %261, i64 0
  %273 = insertelement <2 x double> %272, double %267, i64 1
  %274 = fcmp oge <2 x double> %273, zeroinitializer
  %275 = fneg <2 x double> %273
  %276 = select <2 x i1> %274, <2 x double> %273, <2 x double> %275
  %277 = insertelement <2 x double> poison, double %263, i64 0
  %278 = insertelement <2 x double> %277, double %271, i64 1
  %279 = fcmp oge <2 x double> %278, zeroinitializer
  %280 = fneg <2 x double> %278
  %281 = select <2 x i1> %279, <2 x double> %278, <2 x double> %280
  %282 = fadd <2 x double> %276, %281
  %shift1074 = shufflevector <2 x double> %282, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %283 = fadd <2 x double> %282, %shift1074
  %284 = extractelement <2 x double> %283, i64 0
  %285 = fcmp oeq double %284, 0.000000e+00
  br i1 %285, label %286, label %309

286:                                              ; preds = %255
  %287 = add nsw i64 %indvars.iv1006, -2
  %288 = load i32, ptr %3, align 4, !tbaa !5
  %289 = sext i32 %288 to i64
  %.not911 = icmp slt i64 %287, %289
  br i1 %.not911, label %299, label %290

290:                                              ; preds = %286
  %291 = mul nsw i64 %287, %207
  %292 = getelementptr %struct.doublecomplex, ptr %39, i64 %291
  %293 = getelementptr %struct.doublecomplex, ptr %292, i64 %indvars.iv.next1007
  %294 = load double, ptr %293, align 8, !tbaa !13
  %295 = fcmp oge double %294, 0.000000e+00
  %296 = fneg double %294
  %297 = select i1 %295, double %294, double %296
  %298 = fadd double %284, %297
  br label %299

299:                                              ; preds = %290, %286
  %.0878 = phi double [ %298, %290 ], [ %284, %286 ]
  %300 = load i32, ptr %4, align 4, !tbaa !5
  %301 = sext i32 %300 to i64
  %.not912.not = icmp slt i64 %indvars.iv1006, %301
  br i1 %.not912.not, label %302, label %309

302:                                              ; preds = %299
  %gep1058 = getelementptr %struct.doublecomplex, ptr %invariant.gep1057, i64 %indvars.iv1006
  %303 = getelementptr %struct.doublecomplex, ptr %gep1058, i64 %257
  %304 = load double, ptr %303, align 8, !tbaa !13
  %305 = fcmp oge double %304, 0.000000e+00
  %306 = fneg double %304
  %307 = select i1 %305, double %304, double %306
  %308 = fadd double %.0878, %307
  br label %309

309:                                              ; preds = %299, %302, %255
  %.1879 = phi double [ %308, %302 ], [ %.0878, %299 ], [ %284, %255 ]
  %310 = load double, ptr %243, align 8, !tbaa !13
  %311 = fcmp oge double %310, 0.000000e+00
  %312 = fneg double %310
  %313 = select i1 %311, double %310, double %312
  %314 = fmul double %185, %.1879
  %315 = fcmp ugt double %313, %314
  br i1 %315, label %422, label %316

316:                                              ; preds = %309
  %317 = add nsw i32 %258, %indvars1008
  store i32 %317, ptr %15, align 4, !tbaa !5
  %318 = call { double, double } @Cd(ptr noundef nonnull %243)
  %319 = extractvalue { double, double } %318, 1
  %320 = load i32, ptr %15, align 4, !tbaa !5
  %321 = sext i32 %320 to i64
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %321
  %323 = load double, ptr %322, align 8, !tbaa !13
  %324 = sext i32 %317 to i64
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %324
  %326 = call { double, double } @Cd(ptr noundef %325)
  %327 = extractvalue { double, double } %326, 1
  store i32 %317, ptr %15, align 4, !tbaa !5
  %328 = load double, ptr %243, align 8, !tbaa !13
  %329 = call { double, double } @Cd(ptr noundef nonnull %243)
  %330 = extractvalue { double, double } %329, 1
  %331 = insertelement <2 x double> poison, double %328, i64 0
  %332 = insertelement <2 x double> %331, double %330, i64 1
  %333 = fcmp oge <2 x double> %332, zeroinitializer
  %334 = fneg <2 x double> %332
  %335 = select <2 x i1> %333, <2 x double> %332, <2 x double> %334
  %336 = load i32, ptr %15, align 4, !tbaa !5
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %337
  %339 = load double, ptr %338, align 8, !tbaa !13
  %340 = call { double, double } @Cd(ptr noundef %325)
  %341 = extractvalue { double, double } %340, 1
  %342 = insertelement <2 x double> poison, double %339, i64 0
  %343 = insertelement <2 x double> %342, double %341, i64 1
  %344 = fcmp oge <2 x double> %343, zeroinitializer
  %345 = fneg <2 x double> %343
  %346 = select <2 x i1> %344, <2 x double> %343, <2 x double> %345
  %347 = shufflevector <2 x double> %335, <2 x double> %346, <2 x i32> <i32 0, i32 2>
  %348 = shufflevector <2 x double> %335, <2 x double> %346, <2 x i32> <i32 1, i32 3>
  %349 = fadd <2 x double> %347, %348
  %350 = extractelement <2 x double> %349, i64 0
  %351 = extractelement <2 x double> %349, i64 1
  %352 = fcmp ole double %350, %351
  %353 = select i1 %352, double %350, double %351
  store i32 %259, ptr %15, align 4, !tbaa !5
  %354 = load <2 x double>, ptr %260, align 8, !tbaa !9
  %355 = load <2 x double>, ptr %269, align 8, !tbaa !9
  %356 = fsub <2 x double> %354, %355
  store <2 x double> %356, ptr %17, align 16, !tbaa !9
  store <2 x double> %356, ptr %16, align 16, !tbaa !9
  %357 = extractelement <2 x double> %355, i64 0
  %358 = fcmp oge double %357, 0.000000e+00
  %359 = fneg double %357
  %360 = select i1 %358, double %357, double %359
  %361 = call { double, double } @Cd(ptr noundef nonnull %269)
  %362 = extractvalue { double, double } %361, 1
  %363 = load double, ptr %16, align 16, !tbaa !13
  %364 = call { double, double } @Cd(ptr noundef nonnull %16)
  %365 = extractvalue { double, double } %364, 1
  %366 = insertelement <2 x double> poison, double %319, i64 0
  %367 = insertelement <2 x double> %366, double %362, i64 1
  %368 = fcmp oge <2 x double> %367, zeroinitializer
  %369 = fneg <2 x double> %367
  %370 = select <2 x i1> %368, <2 x double> %367, <2 x double> %369
  %371 = insertelement <2 x double> poison, double %313, i64 0
  %372 = insertelement <2 x double> %371, double %360, i64 1
  %373 = fadd <2 x double> %372, %370
  %374 = insertelement <2 x double> poison, double %323, i64 0
  %375 = insertelement <2 x double> %374, double %363, i64 1
  %376 = fcmp oge <2 x double> %375, zeroinitializer
  %377 = fneg <2 x double> %375
  %378 = select <2 x i1> %376, <2 x double> %375, <2 x double> %377
  %379 = insertelement <2 x double> poison, double %327, i64 0
  %380 = insertelement <2 x double> %379, double %365, i64 1
  %381 = fcmp oge <2 x double> %380, zeroinitializer
  %382 = fneg <2 x double> %380
  %383 = select <2 x i1> %381, <2 x double> %380, <2 x double> %382
  %384 = fadd <2 x double> %378, %383
  %385 = fcmp oge <2 x double> %373, %384
  %386 = select <2 x i1> %385, <2 x double> %373, <2 x double> %384
  store i32 %259, ptr %15, align 4, !tbaa !5
  %387 = load <2 x double>, ptr %260, align 8, !tbaa !9
  %388 = load <2 x double>, ptr %269, align 8, !tbaa !9
  %389 = fsub <2 x double> %387, %388
  store <2 x double> %389, ptr %17, align 16, !tbaa !9
  store <2 x double> %389, ptr %16, align 16, !tbaa !9
  %390 = extractelement <2 x double> %388, i64 0
  %391 = fcmp oge double %390, 0.000000e+00
  %392 = fneg double %390
  %393 = select i1 %391, double %390, double %392
  %394 = call { double, double } @Cd(ptr noundef nonnull %269)
  %395 = extractvalue { double, double } %394, 1
  %396 = fcmp oge double %395, 0.000000e+00
  %397 = fneg double %395
  %398 = select i1 %396, double %395, double %397
  %399 = fadd double %393, %398
  %400 = load <2 x double>, ptr %16, align 16
  %401 = call { double, double } @Cd(ptr noundef nonnull %16)
  %402 = extractvalue { double, double } %401, 1
  %403 = insertelement <2 x double> %400, double %402, i64 1
  %404 = fcmp oge <2 x double> %403, zeroinitializer
  %405 = fneg <2 x double> %403
  %406 = select <2 x i1> %404, <2 x double> %403, <2 x double> %405
  %shift1075 = shufflevector <2 x double> %406, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %407 = fadd <2 x double> %406, %shift1075
  %408 = extractelement <2 x double> %407, i64 0
  %409 = fcmp ole double %399, %408
  %410 = select i1 %409, double %399, double %408
  %411 = extractelement <2 x double> %386, i64 0
  %412 = extractelement <2 x double> %386, i64 1
  %413 = fadd double %411, %412
  %414 = fdiv double %412, %413
  %415 = fmul double %414, %410
  %416 = fmul double %185, %415
  %417 = fdiv double %411, %413
  %418 = fmul double %353, %417
  %419 = fcmp oge double %189, %416
  %420 = select i1 %419, double %189, double %416
  %421 = fcmp ugt double %418, %420
  br i1 %421, label %422, label %._crit_edge954

422:                                              ; preds = %309, %316
  %423 = load i32, ptr %14, align 4, !tbaa !5
  %424 = sext i32 %423 to i64
  %.not910.not = icmp sgt i64 %indvars.iv1006, %424
  br i1 %.not910.not, label %.lr.ph953, label %._crit_edge954, !llvm.loop !17

._crit_edge954:                                   ; preds = %.lr.ph953, %316, %422, %238
  %.0874.lcssa = phi i32 [ %.1994, %238 ], [ %indvars1008, %422 ], [ %indvars1009, %316 ], [ %indvars1009, %.lr.ph953 ]
  %425 = load i32, ptr %3, align 4, !tbaa !5
  %426 = icmp sgt i32 %.0874.lcssa, %425
  br i1 %426, label %427, label %433

427:                                              ; preds = %._crit_edge954
  %428 = add nsw i32 %.0874.lcssa, -1
  %429 = mul nsw i32 %428, %37
  %430 = add nsw i32 %429, %.0874.lcssa
  %431 = sext i32 %430 to i64
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %431
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %432, i8 0, i64 16, i1 false)
  br label %433

433:                                              ; preds = %427, %._crit_edge954
  %.not913 = icmp slt i32 %.0874.lcssa, %.1994
  br i1 %.not913, label %434, label %998

434:                                              ; preds = %433
  %435 = load i32, ptr %0, align 4, !tbaa !5
  %.not914 = icmp eq i32 %435, 0
  %spec.select = select i1 %.not914, i32 %.1994, i32 %.2889984
  %spec.select929 = select i1 %.not914, i32 %.0874.lcssa, i32 %.2885985
  switch i32 %.0880986, label %467 [
    i32 10, label %436
    i32 20, label %456
  ]

436:                                              ; preds = %434
  %437 = add nsw i32 %.0874.lcssa, 1
  %438 = mul nsw i32 %.0874.lcssa, %37
  %439 = add nsw i32 %437, %438
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %440
  %442 = load double, ptr %441, align 8, !tbaa !13
  %443 = fcmp oge double %442, 0.000000e+00
  %444 = fneg double %442
  %445 = select i1 %443, double %442, double %444
  %446 = fmul double %445, 7.500000e-01
  %447 = add nsw i32 %438, %.0874.lcssa
  %448 = sext i32 %447 to i64
  %449 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %448
  %450 = load double, ptr %449, align 8, !tbaa !13
  %451 = fadd double %450, %446
  %452 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %448, i32 1
  %453 = load double, ptr %452, align 8, !tbaa !15
  %454 = insertelement <2 x double> poison, double %451, i64 0
  %455 = insertelement <2 x double> %454, double %453, i64 1
  br label %601

456:                                              ; preds = %434
  %457 = load double, ptr %214, align 8, !tbaa !13
  %458 = fcmp oge double %457, 0.000000e+00
  %459 = fneg double %457
  %460 = select i1 %458, double %457, double %459
  %461 = fmul double %460, 7.500000e-01
  %462 = load double, ptr %217, align 8, !tbaa !13
  %463 = fadd double %462, %461
  %464 = load double, ptr %218, align 8, !tbaa !15
  %465 = insertelement <2 x double> poison, double %463, i64 0
  %466 = insertelement <2 x double> %465, double %464, i64 1
  br label %601

467:                                              ; preds = %434
  store i32 %220, ptr %14, align 4, !tbaa !5
  %468 = load <2 x double>, ptr %222, align 8, !tbaa !9
  %469 = call { double, double } @Cd(ptr noundef %225)
  %470 = extractvalue { double, double } %469, 0
  %471 = extractvalue { double, double } %469, 1
  %472 = call { double, double } @csqrt(double noundef %470, double noundef %471) #9
  %473 = extractvalue { double, double } %472, 0
  %474 = extractvalue { double, double } %472, 1
  %475 = call ptr @_pCd(ptr noundef nonnull %17)
  %476 = getelementptr inbounds i8, ptr %475, i64 8
  store double %473, ptr %475, align 8
  store double %474, ptr %476, align 8
  %477 = call { double, double } @Cd(ptr noundef %214)
  %478 = extractvalue { double, double } %477, 0
  %479 = extractvalue { double, double } %477, 1
  %480 = call { double, double } @csqrt(double noundef %478, double noundef %479) #9
  %481 = extractvalue { double, double } %480, 0
  %482 = extractvalue { double, double } %480, 1
  %483 = call ptr @_pCd(ptr noundef nonnull %18)
  %484 = getelementptr inbounds i8, ptr %483, i64 8
  store double %481, ptr %483, align 8
  store double %482, ptr %484, align 8
  %485 = load <2 x double>, ptr %17, align 16
  %486 = load double, ptr %200, align 8, !tbaa !15
  %487 = fneg double %486
  %488 = load <2 x double>, ptr %18, align 16, !tbaa !9
  %489 = insertelement <2 x double> poison, double %486, i64 0
  %490 = insertelement <2 x double> %489, double %487, i64 1
  %491 = fmul <2 x double> %488, %490
  %492 = shufflevector <2 x double> %491, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %493 = shufflevector <2 x double> %485, <2 x double> poison, <2 x i32> zeroinitializer
  %494 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %493, <2 x double> %488, <2 x double> %492)
  store <2 x double> %494, ptr %16, align 16, !tbaa !9
  store <2 x double> %494, ptr %24, align 16, !tbaa !9
  %495 = extractelement <2 x double> %494, i64 0
  %496 = fcmp oge double %495, 0.000000e+00
  %497 = fneg double %495
  %498 = select i1 %496, double %495, double %497
  %499 = call { double, double } @Cd(ptr noundef nonnull %24)
  %500 = extractvalue { double, double } %499, 1
  %501 = fcmp oge double %500, 0.000000e+00
  %502 = fneg double %500
  %503 = select i1 %501, double %500, double %502
  %504 = fadd double %498, %503
  %505 = fcmp une double %504, 0.000000e+00
  br i1 %505, label %506, label %601

506:                                              ; preds = %467
  store i32 %226, ptr %14, align 4, !tbaa !5
  %507 = load <2 x double>, ptr %228, align 8, !tbaa !9
  %508 = fsub <2 x double> %507, %468
  store <2 x double> %508, ptr %17, align 16, !tbaa !9
  %509 = fmul <2 x double> %508, <double 5.000000e-01, double 5.000000e-01>
  store <2 x double> %509, ptr %16, align 16, !tbaa !9
  store <2 x double> %509, ptr %26, align 16, !tbaa !9
  %510 = extractelement <2 x double> %509, i64 0
  %511 = fcmp oge double %510, 0.000000e+00
  %512 = fneg double %510
  %513 = select i1 %511, double %510, double %512
  %514 = call { double, double } @Cd(ptr noundef nonnull %26)
  %515 = extractvalue { double, double } %514, 1
  %516 = fcmp oge double %515, 0.000000e+00
  %517 = fneg double %515
  %518 = select i1 %516, double %515, double %517
  %519 = fadd double %513, %518
  %520 = load <2 x double>, ptr %26, align 16
  %521 = call { double, double } @Cd(ptr noundef nonnull %26)
  %522 = extractvalue { double, double } %521, 1
  %523 = insertelement <2 x double> %520, double %522, i64 1
  %524 = fcmp oge <2 x double> %523, zeroinitializer
  %525 = fneg <2 x double> %523
  %526 = select <2 x i1> %524, <2 x double> %523, <2 x double> %525
  %shift1076 = shufflevector <2 x double> %526, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %527 = fadd <2 x double> %526, %shift1076
  %528 = extractelement <2 x double> %527, i64 0
  %529 = fcmp oge double %504, %528
  %530 = select i1 %529, double %504, double %528
  %531 = load <2 x double>, ptr %26, align 16, !tbaa !9
  %532 = insertelement <2 x double> poison, double %530, i64 0
  %533 = shufflevector <2 x double> %532, <2 x double> poison, <2 x i32> zeroinitializer
  %534 = fdiv <2 x double> %531, %533
  store <2 x double> %534, ptr %20, align 16, !tbaa !9
  %535 = call { double, double } @Cd(ptr noundef nonnull %20)
  %536 = extractvalue { double, double } %535, 0
  %537 = extractvalue { double, double } %535, 1
  %538 = load i32, ptr @c__2, align 4, !tbaa !5
  %539 = call { double, double } @zpow_ui(double noundef %536, double noundef %537, i32 noundef %538)
  %540 = extractvalue { double, double } %539, 0
  %541 = extractvalue { double, double } %539, 1
  %542 = call ptr @_pCd(ptr noundef nonnull %19)
  %543 = getelementptr inbounds i8, ptr %542, i64 8
  store double %540, ptr %542, align 8
  store double %541, ptr %543, align 8
  %544 = load <2 x double>, ptr %24, align 16, !tbaa !9
  %545 = fdiv <2 x double> %544, %533
  store <2 x double> %545, ptr %22, align 16, !tbaa !9
  %546 = call { double, double } @Cd(ptr noundef nonnull %22)
  %547 = extractvalue { double, double } %546, 0
  %548 = extractvalue { double, double } %546, 1
  %549 = load i32, ptr @c__2, align 4, !tbaa !5
  %550 = call { double, double } @zpow_ui(double noundef %547, double noundef %548, i32 noundef %549)
  %551 = extractvalue { double, double } %550, 0
  %552 = extractvalue { double, double } %550, 1
  %553 = call ptr @_pCd(ptr noundef nonnull %21)
  %554 = getelementptr inbounds i8, ptr %553, i64 8
  store double %551, ptr %553, align 8
  store double %552, ptr %554, align 8
  %555 = load <2 x double>, ptr %19, align 16, !tbaa !9
  %556 = load <2 x double>, ptr %21, align 16, !tbaa !9
  %557 = fadd <2 x double> %555, %556
  store <2 x double> %557, ptr %18, align 16, !tbaa !9
  %558 = call { double, double } @Cd(ptr noundef nonnull %18)
  %559 = extractvalue { double, double } %558, 0
  %560 = extractvalue { double, double } %558, 1
  %561 = call { double, double } @csqrt(double noundef %559, double noundef %560) #9
  %562 = extractvalue { double, double } %561, 0
  %563 = extractvalue { double, double } %561, 1
  %564 = call ptr @_pCd(ptr noundef nonnull %17)
  %565 = getelementptr inbounds i8, ptr %564, i64 8
  store double %562, ptr %564, align 8
  store double %563, ptr %565, align 8
  %566 = load <2 x double>, ptr %17, align 16, !tbaa !9
  %567 = fmul <2 x double> %533, %566
  store <2 x double> %567, ptr %16, align 16, !tbaa !9
  store <2 x double> %567, ptr %27, align 16, !tbaa !9
  %568 = fcmp ogt double %519, 0.000000e+00
  br i1 %568, label %569, label %586

569:                                              ; preds = %506
  %570 = load <2 x double>, ptr %26, align 16, !tbaa !9
  %571 = insertelement <2 x double> poison, double %519, i64 0
  %572 = shufflevector <2 x double> %571, <2 x double> poison, <2 x i32> zeroinitializer
  %573 = fdiv <2 x double> %570, %572
  store <2 x double> %573, ptr %16, align 16, !tbaa !9
  store <2 x double> %573, ptr %17, align 16, !tbaa !9
  %574 = call { double, double } @Cd(ptr noundef nonnull %17)
  %575 = extractvalue { double, double } %574, 1
  %576 = call { double, double } @Cd(ptr noundef nonnull %27)
  %577 = extractvalue { double, double } %576, 1
  %578 = fmul double %575, %577
  %579 = extractelement <2 x double> %567, i64 0
  %580 = extractelement <2 x double> %573, i64 0
  %581 = call double @llvm.fmuladd.f64(double %580, double %579, double %578)
  %582 = fcmp olt double %581, 0.000000e+00
  %583 = load <2 x double>, ptr %27, align 16, !tbaa !9
  br i1 %582, label %584, label %586

584:                                              ; preds = %569
  %585 = fneg <2 x double> %583
  store <2 x double> %585, ptr %18, align 16, !tbaa !9
  store <2 x double> %585, ptr %27, align 16, !tbaa !9
  br label %586

586:                                              ; preds = %569, %584, %506
  %587 = phi <2 x double> [ %583, %569 ], [ %585, %584 ], [ %567, %506 ]
  %588 = load <2 x double>, ptr %26, align 16, !tbaa !9
  %589 = fadd <2 x double> %588, %587
  store <2 x double> %589, ptr %19, align 16, !tbaa !9
  call void @zladiv_(ptr noundef nonnull %18, ptr noundef nonnull %24, ptr noundef nonnull %19) #9
  %590 = load <2 x double>, ptr %24, align 16
  %591 = load double, ptr %203, align 8, !tbaa !15
  %592 = fneg double %591
  %593 = load <2 x double>, ptr %18, align 16, !tbaa !9
  %594 = insertelement <2 x double> poison, double %591, i64 0
  %595 = insertelement <2 x double> %594, double %592, i64 1
  %596 = fmul <2 x double> %593, %595
  %597 = shufflevector <2 x double> %596, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %598 = shufflevector <2 x double> %590, <2 x double> poison, <2 x i32> zeroinitializer
  %599 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %598, <2 x double> %593, <2 x double> %597)
  store <2 x double> %599, ptr %17, align 16, !tbaa !9
  %600 = fsub <2 x double> %468, %599
  br label %601

601:                                              ; preds = %456, %586, %467, %436
  %602 = phi <2 x double> [ %455, %436 ], [ %466, %456 ], [ %600, %586 ], [ %468, %467 ]
  %603 = add nsw i32 %.0874.lcssa, 1
  store i32 %603, ptr %14, align 4, !tbaa !5
  br label %604

604:                                              ; preds = %607, %601
  %indvars.iv1010 = phi i64 [ %indvars.iv.next1011, %607 ], [ %237, %601 ]
  %605 = load i32, ptr %14, align 4, !tbaa !5
  %606 = sext i32 %605 to i64
  %.not915 = icmp slt i64 %indvars.iv1010, %606
  br i1 %.not915, label %680, label %607

607:                                              ; preds = %604
  %608 = mul nsw i64 %indvars.iv1010, %207
  %609 = getelementptr %struct.doublecomplex, ptr %39, i64 %608
  %610 = getelementptr %struct.doublecomplex, ptr %609, i64 %indvars.iv1010
  %611 = load <2 x double>, ptr %610, align 8, !tbaa !9
  store <2 x double> %611, ptr %30, align 16, !tbaa !9
  %612 = add nsw i64 %indvars.iv1010, 1
  %613 = trunc nsw i64 %612 to i32
  %614 = mul i32 %201, %613
  %615 = sext i32 %614 to i64
  %616 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %615
  %617 = load <2 x double>, ptr %616, align 8, !tbaa !9
  store <2 x double> %617, ptr %31, align 16, !tbaa !9
  %618 = fsub <2 x double> %611, %602
  store <2 x double> %618, ptr %16, align 16, !tbaa !9
  store <2 x double> %618, ptr %36, align 16, !tbaa !9
  %619 = getelementptr %struct.doublecomplex, ptr %39, i64 %612
  %620 = getelementptr %struct.doublecomplex, ptr %619, i64 %608
  %621 = load double, ptr %620, align 8, !tbaa !13
  %622 = extractelement <2 x double> %618, i64 0
  %623 = fcmp oge double %622, 0.000000e+00
  %624 = fneg double %622
  %625 = select i1 %623, double %622, double %624
  %626 = call { double, double } @Cd(ptr noundef nonnull %36)
  %627 = extractvalue { double, double } %626, 1
  %628 = fcmp oge double %627, 0.000000e+00
  %629 = fneg double %627
  %630 = select i1 %628, double %627, double %629
  %631 = fadd double %625, %630
  %632 = fcmp oge double %621, 0.000000e+00
  %633 = fneg double %621
  %634 = select i1 %632, double %621, double %633
  %635 = fadd double %634, %631
  %636 = load <2 x double>, ptr %36, align 16, !tbaa !9
  %637 = insertelement <2 x double> poison, double %635, i64 0
  %638 = shufflevector <2 x double> %637, <2 x double> poison, <2 x i32> zeroinitializer
  %639 = fdiv <2 x double> %636, %638
  store <2 x double> %639, ptr %16, align 16, !tbaa !9
  store <2 x double> %639, ptr %36, align 16, !tbaa !9
  %640 = fdiv double %621, %635
  store <2 x double> %639, ptr %25, align 16, !tbaa !9
  store double %640, ptr %204, align 16, !tbaa !13
  store double 0.000000e+00, ptr %205, align 8, !tbaa !15
  %indvars.iv.next1011 = add nsw i64 %indvars.iv1010, -1
  %641 = mul nsw i64 %indvars.iv.next1011, %207
  %642 = getelementptr %struct.doublecomplex, ptr %39, i64 %641
  %643 = getelementptr %struct.doublecomplex, ptr %642, i64 %indvars.iv1010
  %644 = load double, ptr %643, align 8, !tbaa !13
  %645 = insertelement <2 x double> poison, double %640, i64 0
  %646 = insertelement <2 x double> %645, double %644, i64 1
  %647 = fcmp oge <2 x double> %646, zeroinitializer
  %648 = fneg <2 x double> %646
  %649 = select <2 x i1> %647, <2 x double> %646, <2 x double> %648
  %shift1077 = shufflevector <2 x double> %649, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %650 = fmul <2 x double> %649, %shift1077
  %651 = extractelement <2 x double> %650, i64 0
  %652 = call { double, double } @Cd(ptr noundef nonnull %36)
  %653 = extractvalue { double, double } %652, 1
  %654 = load double, ptr %30, align 16, !tbaa !13
  %655 = call { double, double } @Cd(ptr noundef nonnull %30)
  %656 = extractvalue { double, double } %655, 1
  %657 = insertelement <2 x double> %639, double %654, i64 1
  %658 = fcmp oge <2 x double> %657, zeroinitializer
  %659 = fneg <2 x double> %657
  %660 = select <2 x i1> %658, <2 x double> %657, <2 x double> %659
  %661 = insertelement <2 x double> poison, double %653, i64 0
  %662 = insertelement <2 x double> %661, double %656, i64 1
  %663 = fcmp oge <2 x double> %662, zeroinitializer
  %664 = fneg <2 x double> %662
  %665 = select <2 x i1> %663, <2 x double> %662, <2 x double> %664
  %666 = fadd <2 x double> %660, %665
  %667 = load <2 x double>, ptr %31, align 16
  %668 = call { double, double } @Cd(ptr noundef nonnull %31)
  %669 = extractvalue { double, double } %668, 1
  %670 = insertelement <2 x double> %667, double %669, i64 1
  %671 = fcmp oge <2 x double> %670, zeroinitializer
  %672 = fneg <2 x double> %670
  %673 = select <2 x i1> %671, <2 x double> %670, <2 x double> %672
  %shift1078 = shufflevector <2 x double> %673, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %674 = fadd <2 x double> %673, %shift1078
  %shift1079 = shufflevector <2 x double> %666, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %675 = fadd <2 x double> %shift1079, %674
  %676 = fmul <2 x double> %666, %675
  %677 = extractelement <2 x double> %676, i64 0
  %678 = fmul double %185, %677
  %679 = fcmp ugt double %651, %678
  br i1 %679, label %604, label %.loopexit934, !llvm.loop !18

680:                                              ; preds = %604
  %681 = mul nsw i32 %.0874.lcssa, %37
  %682 = add nsw i32 %681, %.0874.lcssa
  %683 = sext i32 %682 to i64
  %684 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %683
  %685 = load <2 x double>, ptr %684, align 8, !tbaa !9
  store <2 x double> %685, ptr %30, align 16, !tbaa !9
  %686 = mul i32 %603, %201
  %687 = sext i32 %686 to i64
  %688 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %687
  %689 = load <2 x double>, ptr %688, align 8, !tbaa !9
  store <2 x double> %689, ptr %31, align 16, !tbaa !9
  %690 = fsub <2 x double> %685, %602
  store <2 x double> %690, ptr %16, align 16, !tbaa !9
  store <2 x double> %690, ptr %36, align 16, !tbaa !9
  %691 = add nsw i32 %603, %681
  store i32 %691, ptr %14, align 4, !tbaa !5
  %692 = sext i32 %691 to i64
  %693 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %692
  %694 = load double, ptr %693, align 8, !tbaa !13
  %695 = extractelement <2 x double> %690, i64 0
  %696 = fcmp oge double %695, 0.000000e+00
  %697 = fneg double %695
  %698 = select i1 %696, double %695, double %697
  %699 = call { double, double } @Cd(ptr noundef nonnull %36)
  %700 = extractvalue { double, double } %699, 1
  %701 = fcmp oge double %700, 0.000000e+00
  %702 = fneg double %700
  %703 = select i1 %701, double %700, double %702
  %704 = fadd double %698, %703
  %705 = fcmp oge double %694, 0.000000e+00
  %706 = fneg double %694
  %707 = select i1 %705, double %694, double %706
  %708 = fadd double %707, %704
  %709 = load <2 x double>, ptr %36, align 16, !tbaa !9
  %710 = insertelement <2 x double> poison, double %708, i64 0
  %711 = shufflevector <2 x double> %710, <2 x double> poison, <2 x i32> zeroinitializer
  %712 = fdiv <2 x double> %709, %711
  store <2 x double> %712, ptr %16, align 16, !tbaa !9
  store <2 x double> %712, ptr %36, align 16, !tbaa !9
  %713 = fdiv double %694, %708
  store <2 x double> %712, ptr %25, align 16, !tbaa !9
  store double %713, ptr %204, align 16, !tbaa !13
  store double 0.000000e+00, ptr %205, align 8, !tbaa !15
  br label %.loopexit934

.loopexit934:                                     ; preds = %607, %680
  %.0877996 = trunc i64 %indvars.iv1010 to i32
  store i32 %210, ptr %14, align 4, !tbaa !5
  %.not916977.not = icmp sgt i32 %.1994, %.0877996
  br i1 %.not916977.not, label %.lr.ph981, label %._crit_edge982

.lr.ph981:                                        ; preds = %.loopexit934
  %714 = icmp slt i32 %.0874.lcssa, %.0877996
  %715 = add nsw i32 %.0877996, 1
  %716 = mul nsw i32 %37, %.0877996
  %717 = add nsw i32 %715, %716
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %718
  %720 = add nsw i32 %.0877996, 2
  %.not923 = icmp sgt i32 %720, %.1994
  %721 = mul nsw i32 %715, %37
  %722 = add nsw i32 %721, %720
  %723 = sext i32 %722 to i64
  %724 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %723
  %725 = getelementptr inbounds i8, ptr %724, i64 8
  %sext1046 = shl i64 %indvars.iv1010, 32
  %726 = ashr exact i64 %sext1046, 32
  %727 = sext i32 %spec.select to i64
  %728 = sext i32 %spec.select929 to i64
  %sext = sext i32 %715 to i64
  %invariant.gep1059 = getelementptr %struct.doublecomplex, ptr %39, i64 %728
  br label %729

729:                                              ; preds = %.lr.ph981, %.loopexit
  %indvars.iv1014 = phi i64 [ %726, %.lr.ph981 ], [ %indvars.iv.next1015, %.loopexit ]
  %730 = icmp sgt i64 %indvars.iv1014, %726
  br i1 %730, label %732, label %731

731:                                              ; preds = %729
  call void @zlarfg_(ptr noundef nonnull @c__2, ptr noundef nonnull %25, ptr noundef nonnull %204, ptr noundef nonnull @c__1, ptr noundef nonnull %28) #9
  br label %742

732:                                              ; preds = %729
  %indvars1038 = trunc i64 %indvars.iv1014 to i32
  %733 = add nsw i32 %indvars1038, -1
  %734 = mul nsw i32 %733, %37
  %735 = sext i32 %734 to i64
  %736 = getelementptr %struct.doublecomplex, ptr %39, i64 %indvars.iv1014
  %737 = getelementptr %struct.doublecomplex, ptr %736, i64 %735
  call void @zcopy_(ptr noundef nonnull @c__2, ptr noundef %737, ptr noundef nonnull @c__1, ptr noundef nonnull %25, ptr noundef nonnull @c__1) #9
  call void @zlarfg_(ptr noundef nonnull @c__2, ptr noundef nonnull %25, ptr noundef nonnull %204, ptr noundef nonnull @c__1, ptr noundef nonnull %28) #9
  %738 = add nsw i64 %indvars.iv1014, -1
  %739 = mul nsw i64 %738, %207
  %740 = load <2 x double>, ptr %25, align 16, !tbaa !9
  store <2 x double> %740, ptr %737, align 8, !tbaa !9
  %gep1062 = getelementptr %struct.doublecomplex, ptr %invariant.gep1061, i64 %indvars.iv1014
  %741 = getelementptr %struct.doublecomplex, ptr %gep1062, i64 %739
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %741, i8 0, i64 16, i1 false)
  br label %742

742:                                              ; preds = %731, %732
  %743 = load <2 x double>, ptr %204, align 16, !tbaa !9
  store <2 x double> %743, ptr %29, align 16, !tbaa !9
  %744 = load <2 x double>, ptr %28, align 16
  %745 = load double, ptr %206, align 8, !tbaa !15
  %746 = fneg double %745
  %747 = insertelement <2 x double> poison, double %745, i64 0
  %748 = insertelement <2 x double> %747, double %746, i64 1
  %749 = fmul <2 x double> %743, %748
  %750 = shufflevector <2 x double> %749, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %751 = shufflevector <2 x double> %744, <2 x double> poison, <2 x i32> zeroinitializer
  %752 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %751, <2 x double> %743, <2 x double> %750)
  store <2 x double> %752, ptr %16, align 16, !tbaa !9
  %.not918959 = icmp sgt i64 %indvars.iv1014, %727
  br i1 %.not918959, label %._crit_edge963, label %.lr.ph962

.lr.ph962:                                        ; preds = %742
  %753 = add nsw i64 %indvars.iv1014, 1
  %754 = shufflevector <2 x double> %752, <2 x double> poison, <2 x i32> zeroinitializer
  %invariant.gep1106 = getelementptr %struct.doublecomplex, ptr %39, i64 %indvars.iv1014
  br label %755

755:                                              ; preds = %.lr.ph962, %755
  %indvars.iv1016 = phi i64 [ %indvars.iv1014, %.lr.ph962 ], [ %indvars.iv.next1017, %755 ]
  %756 = call { double, double } @Cd(ptr noundef nonnull %28)
  %757 = extractvalue { double, double } %756, 0
  %758 = extractvalue { double, double } %756, 1
  %759 = fneg double %758
  %760 = call ptr @_pCd(ptr noundef nonnull %18)
  %761 = getelementptr inbounds i8, ptr %760, i64 8
  store double %757, ptr %760, align 8
  store double %759, ptr %761, align 8
  %762 = mul nsw i64 %indvars.iv1016, %207
  %763 = load <2 x double>, ptr %18, align 16
  %gep1107 = getelementptr %struct.doublecomplex, ptr %invariant.gep1106, i64 %762
  %764 = load double, ptr %202, align 8, !tbaa !15
  %765 = fneg double %764
  %766 = add nsw i64 %753, %762
  %767 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %766
  %768 = load <2 x double>, ptr %767, align 8, !tbaa !9
  %769 = fmul <2 x double> %754, %768
  store <2 x double> %769, ptr %19, align 16, !tbaa !9
  %770 = load <2 x double>, ptr %gep1107, align 8, !tbaa !9
  %771 = insertelement <2 x double> poison, double %764, i64 0
  %772 = insertelement <2 x double> %771, double %765, i64 1
  %773 = fmul <2 x double> %770, %772
  %774 = shufflevector <2 x double> %773, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %775 = shufflevector <2 x double> %763, <2 x double> poison, <2 x i32> zeroinitializer
  %776 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %775, <2 x double> %770, <2 x double> %774)
  %777 = fadd <2 x double> %776, %769
  %778 = fsub <2 x double> %770, %777
  store <2 x double> %778, ptr %gep1107, align 8, !tbaa !9
  %779 = trunc nsw i64 %766 to i32
  store i32 %779, ptr %15, align 4, !tbaa !5
  %780 = load <2 x double>, ptr %29, align 16, !tbaa !9
  %781 = shufflevector <2 x double> %777, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %782 = fneg <2 x double> %777
  %783 = shufflevector <2 x double> %781, <2 x double> %782, <2 x i32> <i32 0, i32 3>
  %784 = fmul <2 x double> %780, %783
  %785 = shufflevector <2 x double> %784, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %786 = shufflevector <2 x double> %777, <2 x double> poison, <2 x i32> zeroinitializer
  %787 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %786, <2 x double> %780, <2 x double> %785)
  store <2 x double> %787, ptr %17, align 16, !tbaa !9
  %788 = fsub <2 x double> %768, %787
  store <2 x double> %788, ptr %16, align 16, !tbaa !9
  store <2 x double> %788, ptr %767, align 8, !tbaa !9
  %indvars.iv.next1017 = add nsw i64 %indvars.iv1016, 1
  %.not918.not = icmp slt i64 %indvars.iv1016, %727
  br i1 %.not918.not, label %755, label %._crit_edge963, !llvm.loop !19

._crit_edge963:                                   ; preds = %755, %742
  %789 = trunc i64 %indvars.iv1014 to i32
  %790 = add i32 %789, 2
  store i32 %790, ptr %15, align 4, !tbaa !5
  %791 = call i32 @llvm.smin.i32(i32 %790, i32 %.1994)
  %.not920964 = icmp sgt i32 %spec.select929, %791
  br i1 %.not920964, label %._crit_edge968, label %.lr.ph967

.lr.ph967:                                        ; preds = %._crit_edge963
  %792 = mul nsw i64 %indvars.iv1014, %207
  %793 = add nsw i64 %indvars.iv1014, 1
  %794 = mul nsw i64 %793, %207
  %795 = sext i32 %791 to i64
  %796 = shufflevector <2 x double> %752, <2 x double> poison, <2 x i32> zeroinitializer
  %invariant.gep1108 = getelementptr %struct.doublecomplex, ptr %39, i64 %792
  br label %797

797:                                              ; preds = %.lr.ph967, %797
  %indvars.iv1020 = phi i64 [ %728, %.lr.ph967 ], [ %indvars.iv.next1021, %797 ]
  %798 = load <2 x double>, ptr %28, align 16
  %gep1109 = getelementptr %struct.doublecomplex, ptr %invariant.gep1108, i64 %indvars.iv1020
  %799 = load double, ptr %206, align 8, !tbaa !15
  %800 = fneg double %799
  %801 = load <2 x double>, ptr %gep1109, align 8, !tbaa !9
  %802 = insertelement <2 x double> poison, double %799, i64 0
  %803 = insertelement <2 x double> %802, double %800, i64 1
  %804 = fmul <2 x double> %801, %803
  %805 = shufflevector <2 x double> %804, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %806 = shufflevector <2 x double> %798, <2 x double> poison, <2 x i32> zeroinitializer
  %807 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %806, <2 x double> %801, <2 x double> %805)
  store <2 x double> %807, ptr %17, align 16, !tbaa !9
  %808 = add nsw i64 %indvars.iv1020, %794
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %808
  %810 = load <2 x double>, ptr %809, align 8, !tbaa !9
  %811 = fmul <2 x double> %796, %810
  store <2 x double> %811, ptr %18, align 16, !tbaa !9
  %812 = fadd <2 x double> %807, %811
  %813 = fsub <2 x double> %801, %812
  store <2 x double> %813, ptr %16, align 16, !tbaa !9
  store <2 x double> %813, ptr %gep1109, align 8, !tbaa !9
  %814 = trunc nsw i64 %808 to i32
  store i32 %814, ptr %15, align 4, !tbaa !5
  %815 = call { double, double } @Cd(ptr noundef nonnull %29)
  %816 = extractvalue { double, double } %815, 0
  %817 = extractvalue { double, double } %815, 1
  %818 = fneg double %817
  %819 = call ptr @_pCd(ptr noundef nonnull %18)
  %820 = getelementptr inbounds i8, ptr %819, i64 8
  store double %816, ptr %819, align 8
  store double %818, ptr %820, align 8
  %821 = load <2 x double>, ptr %18, align 16, !tbaa !9
  %822 = shufflevector <2 x double> %812, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %823 = fneg <2 x double> %812
  %824 = shufflevector <2 x double> %822, <2 x double> %823, <2 x i32> <i32 0, i32 3>
  %825 = fmul <2 x double> %821, %824
  %826 = shufflevector <2 x double> %825, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %827 = shufflevector <2 x double> %812, <2 x double> poison, <2 x i32> zeroinitializer
  %828 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %827, <2 x double> %821, <2 x double> %826)
  store <2 x double> %828, ptr %17, align 16, !tbaa !9
  %829 = load <2 x double>, ptr %809, align 8, !tbaa !9
  %830 = fsub <2 x double> %829, %828
  store <2 x double> %830, ptr %16, align 16, !tbaa !9
  %831 = load i32, ptr %15, align 4, !tbaa !5
  %832 = sext i32 %831 to i64
  %833 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %832
  store <2 x double> %830, ptr %833, align 8, !tbaa !9
  %indvars.iv.next1021 = add nsw i64 %indvars.iv1020, 1
  %.not920.not = icmp slt i64 %indvars.iv1020, %795
  br i1 %.not920.not, label %797, label %._crit_edge968, !llvm.loop !20

._crit_edge968:                                   ; preds = %797, %._crit_edge963
  %834 = load i32, ptr %1, align 4, !tbaa !5
  %.not921 = icmp eq i32 %834, 0
  br i1 %.not921, label %.loopexit933, label %835

835:                                              ; preds = %._crit_edge968
  %836 = load i32, ptr %9, align 4, !tbaa !5
  %837 = load i32, ptr %8, align 4, !tbaa !5
  %.not922969 = icmp sgt i32 %837, %836
  br i1 %.not922969, label %.loopexit933, label %.lr.ph972

.lr.ph972:                                        ; preds = %835
  %838 = mul nsw i64 %indvars.iv1014, %208
  %839 = add nsw i64 %indvars.iv1014, 1
  %840 = mul nsw i64 %839, %208
  %841 = sext i32 %837 to i64
  %842 = add i32 %836, 1
  %843 = shufflevector <2 x double> %752, <2 x double> poison, <2 x i32> zeroinitializer
  %invariant.gep1110 = getelementptr %struct.doublecomplex, ptr %43, i64 %838
  br label %844

844:                                              ; preds = %.lr.ph972, %844
  %indvars.iv1024 = phi i64 [ %841, %.lr.ph972 ], [ %indvars.iv.next1025, %844 ]
  %845 = load <2 x double>, ptr %28, align 16
  %gep1111 = getelementptr %struct.doublecomplex, ptr %invariant.gep1110, i64 %indvars.iv1024
  %846 = load double, ptr %206, align 8, !tbaa !15
  %847 = fneg double %846
  %848 = load <2 x double>, ptr %gep1111, align 8, !tbaa !9
  %849 = insertelement <2 x double> poison, double %846, i64 0
  %850 = insertelement <2 x double> %849, double %847, i64 1
  %851 = fmul <2 x double> %848, %850
  %852 = shufflevector <2 x double> %851, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %853 = shufflevector <2 x double> %845, <2 x double> poison, <2 x i32> zeroinitializer
  %854 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %853, <2 x double> %848, <2 x double> %852)
  store <2 x double> %854, ptr %17, align 16, !tbaa !9
  %855 = add nsw i64 %indvars.iv1024, %840
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %855
  %857 = load <2 x double>, ptr %856, align 8, !tbaa !9
  %858 = fmul <2 x double> %843, %857
  store <2 x double> %858, ptr %18, align 16, !tbaa !9
  %859 = fadd <2 x double> %854, %858
  %860 = fsub <2 x double> %848, %859
  store <2 x double> %860, ptr %16, align 16, !tbaa !9
  store <2 x double> %860, ptr %gep1111, align 8, !tbaa !9
  %861 = trunc nsw i64 %855 to i32
  store i32 %861, ptr %15, align 4, !tbaa !5
  %862 = call { double, double } @Cd(ptr noundef nonnull %29)
  %863 = extractvalue { double, double } %862, 0
  %864 = extractvalue { double, double } %862, 1
  %865 = fneg double %864
  %866 = call ptr @_pCd(ptr noundef nonnull %18)
  %867 = getelementptr inbounds i8, ptr %866, i64 8
  store double %863, ptr %866, align 8
  store double %865, ptr %867, align 8
  %868 = load <2 x double>, ptr %18, align 16, !tbaa !9
  %869 = shufflevector <2 x double> %859, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %870 = fneg <2 x double> %859
  %871 = shufflevector <2 x double> %869, <2 x double> %870, <2 x i32> <i32 0, i32 3>
  %872 = fmul <2 x double> %868, %871
  %873 = shufflevector <2 x double> %872, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %874 = shufflevector <2 x double> %859, <2 x double> poison, <2 x i32> zeroinitializer
  %875 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %874, <2 x double> %868, <2 x double> %873)
  store <2 x double> %875, ptr %17, align 16, !tbaa !9
  %876 = load <2 x double>, ptr %856, align 8, !tbaa !9
  %877 = fsub <2 x double> %876, %875
  store <2 x double> %877, ptr %16, align 16, !tbaa !9
  %878 = load i32, ptr %15, align 4, !tbaa !5
  %879 = sext i32 %878 to i64
  %880 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %879
  store <2 x double> %877, ptr %880, align 8, !tbaa !9
  %indvars.iv.next1025 = add nsw i64 %indvars.iv1024, 1
  %lftr.wideiv1028 = trunc i64 %indvars.iv.next1025 to i32
  %exitcond1029.not = icmp eq i32 %842, %lftr.wideiv1028
  br i1 %exitcond1029.not, label %.loopexit933, label %844, !llvm.loop !21

.loopexit933:                                     ; preds = %844, %835, %._crit_edge968
  %881 = icmp eq i64 %indvars.iv1014, %726
  %or.cond = and i1 %714, %881
  br i1 %or.cond, label %882, label %.loopexit

882:                                              ; preds = %.loopexit933
  %883 = load <2 x double>, ptr %28, align 16, !tbaa !9
  %884 = fsub <2 x double> <double 1.000000e+00, double 0.000000e+00>, %883
  store <2 x double> %884, ptr %16, align 16, !tbaa !9
  store <2 x double> %884, ptr %23, align 16, !tbaa !9
  %885 = call { double, double } @Cd(ptr noundef nonnull %23)
  %886 = extractvalue { double, double } %885, 0
  %887 = extractvalue { double, double } %885, 1
  %888 = call double @cabs(double noundef %886, double noundef %887) #9
  %889 = load <2 x double>, ptr %23, align 16, !tbaa !9
  %890 = insertelement <2 x double> poison, double %888, i64 0
  %891 = shufflevector <2 x double> %890, <2 x double> poison, <2 x i32> zeroinitializer
  %892 = fdiv <2 x double> %889, %891
  store <2 x double> %892, ptr %16, align 16, !tbaa !9
  store <2 x double> %892, ptr %23, align 16, !tbaa !9
  store i32 %717, ptr %15, align 4, !tbaa !5
  %893 = call { double, double } @Cd(ptr noundef nonnull %23)
  %894 = extractvalue { double, double } %893, 0
  %895 = extractvalue { double, double } %893, 1
  %896 = fneg double %895
  %897 = call ptr @_pCd(ptr noundef nonnull %17)
  %898 = getelementptr inbounds i8, ptr %897, i64 8
  store double %894, ptr %897, align 8
  store double %896, ptr %898, align 8
  %899 = load i32, ptr %15, align 4, !tbaa !5
  %900 = sext i32 %899 to i64
  %901 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %900
  %902 = load double, ptr %901, align 8, !tbaa !13
  %903 = getelementptr inbounds i8, ptr %901, i64 8
  %904 = load double, ptr %903, align 8, !tbaa !15
  %905 = fneg double %904
  %906 = load <2 x double>, ptr %17, align 16, !tbaa !9
  %907 = insertelement <2 x double> poison, double %904, i64 0
  %908 = insertelement <2 x double> %907, double %905, i64 1
  %909 = fmul <2 x double> %906, %908
  %910 = shufflevector <2 x double> %909, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %911 = insertelement <2 x double> poison, double %902, i64 0
  %912 = shufflevector <2 x double> %911, <2 x double> poison, <2 x i32> zeroinitializer
  %913 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %912, <2 x double> %906, <2 x double> %910)
  store <2 x double> %913, ptr %16, align 16, !tbaa !9
  store <2 x double> %913, ptr %719, align 8, !tbaa !9
  br i1 %.not923, label %.lr.ph976.preheader, label %914

914:                                              ; preds = %882
  store i32 %722, ptr %15, align 4, !tbaa !5
  %915 = load double, ptr %724, align 8, !tbaa !13
  %916 = load double, ptr %725, align 8, !tbaa !15
  %917 = fneg double %916
  %918 = load <2 x double>, ptr %23, align 16, !tbaa !9
  %919 = insertelement <2 x double> poison, double %916, i64 0
  %920 = insertelement <2 x double> %919, double %917, i64 1
  %921 = fmul <2 x double> %918, %920
  %922 = shufflevector <2 x double> %921, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %923 = insertelement <2 x double> poison, double %915, i64 0
  %924 = shufflevector <2 x double> %923, <2 x double> poison, <2 x i32> zeroinitializer
  %925 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %924, <2 x double> %918, <2 x double> %922)
  store <2 x double> %925, ptr %16, align 16, !tbaa !9
  store <2 x double> %925, ptr %724, align 8, !tbaa !9
  br label %.lr.ph976.preheader

.lr.ph976.preheader:                              ; preds = %882, %914
  br label %.lr.ph976

.lr.ph976:                                        ; preds = %.lr.ph976.preheader, %960
  %indvars.iv1030 = phi i64 [ %indvars.iv.next1031, %960 ], [ %726, %.lr.ph976.preheader ]
  %indvars1033 = trunc i64 %indvars.iv1030 to i32
  %926 = icmp eq i64 %indvars.iv1030, %sext
  br i1 %926, label %960, label %927

927:                                              ; preds = %.lr.ph976
  %928 = icmp slt i64 %indvars.iv1030, %727
  br i1 %928, label %929, label %937

929:                                              ; preds = %927
  %930 = trunc i64 %indvars.iv1030 to i32
  %931 = sub i32 %spec.select, %930
  store i32 %931, ptr %15, align 4, !tbaa !5
  %932 = add nsw i32 %indvars1033, 1
  %933 = mul nsw i32 %932, %37
  %934 = sext i32 %933 to i64
  %935 = getelementptr %struct.doublecomplex, ptr %39, i64 %indvars.iv1030
  %936 = getelementptr %struct.doublecomplex, ptr %935, i64 %934
  call void @zscal_(ptr noundef nonnull %15, ptr noundef nonnull %23, ptr noundef %936, ptr noundef nonnull %6) #9
  br label %937

937:                                              ; preds = %929, %927
  %938 = trunc i64 %indvars.iv1030 to i32
  %939 = sub i32 %938, %spec.select929
  store i32 %939, ptr %15, align 4, !tbaa !5
  %940 = call { double, double } @Cd(ptr noundef nonnull %23)
  %941 = extractvalue { double, double } %940, 0
  %942 = extractvalue { double, double } %940, 1
  %943 = fneg double %942
  %944 = call ptr @_pCd(ptr noundef nonnull %16)
  %945 = getelementptr inbounds i8, ptr %944, i64 8
  store double %941, ptr %944, align 8
  store double %943, ptr %945, align 8
  %946 = mul nsw i64 %indvars.iv1030, %207
  %gep1060 = getelementptr %struct.doublecomplex, ptr %invariant.gep1059, i64 %946
  call void @zscal_(ptr noundef nonnull %15, ptr noundef nonnull %16, ptr noundef %gep1060, ptr noundef nonnull @c__1) #9
  %947 = load i32, ptr %1, align 4, !tbaa !5
  %.not926 = icmp eq i32 %947, 0
  br i1 %.not926, label %960, label %948

948:                                              ; preds = %937
  %949 = call { double, double } @Cd(ptr noundef nonnull %23)
  %950 = extractvalue { double, double } %949, 0
  %951 = extractvalue { double, double } %949, 1
  %952 = fneg double %951
  %953 = call ptr @_pCd(ptr noundef nonnull %16)
  %954 = getelementptr inbounds i8, ptr %953, i64 8
  store double %950, ptr %953, align 8
  store double %952, ptr %954, align 8
  %955 = load i32, ptr %8, align 4, !tbaa !5
  %956 = mul nsw i64 %indvars.iv1030, %208
  %957 = sext i32 %955 to i64
  %958 = getelementptr %struct.doublecomplex, ptr %43, i64 %956
  %959 = getelementptr %struct.doublecomplex, ptr %958, i64 %957
  call void @zscal_(ptr noundef nonnull %33, ptr noundef nonnull %16, ptr noundef %959, ptr noundef nonnull @c__1) #9
  br label %960

960:                                              ; preds = %.lr.ph976, %948, %937
  %indvars.iv.next1031 = add nsw i64 %indvars.iv1030, 1
  %lftr.wideiv1034 = trunc i64 %indvars.iv.next1031 to i32
  %exitcond1035.not = icmp eq i32 %230, %lftr.wideiv1034
  br i1 %exitcond1035.not, label %.loopexit, label %.lr.ph976, !llvm.loop !22

.loopexit:                                        ; preds = %960, %.loopexit933
  %indvars.iv.next1015 = add nsw i64 %indvars.iv1014, 1
  %961 = load i32, ptr %14, align 4, !tbaa !5
  %962 = sext i32 %961 to i64
  %.not916.not = icmp slt i64 %indvars.iv1014, %962
  br i1 %.not916.not, label %729, label %._crit_edge982, !llvm.loop !23

._crit_edge982:                                   ; preds = %.loopexit, %.loopexit934
  store i32 %212, ptr %14, align 4, !tbaa !5
  %963 = load <2 x double>, ptr %214, align 8, !tbaa !9
  store <2 x double> %963, ptr %23, align 16, !tbaa !9
  %964 = call { double, double } @Cd(ptr noundef nonnull %23)
  %965 = extractvalue { double, double } %964, 1
  %966 = fcmp une double %965, 0.000000e+00
  br i1 %966, label %967, label %996

967:                                              ; preds = %._crit_edge982
  %968 = call { double, double } @Cd(ptr noundef nonnull %23)
  %969 = extractvalue { double, double } %968, 0
  %970 = extractvalue { double, double } %968, 1
  %971 = call double @cabs(double noundef %969, double noundef %970) #9
  store double %971, ptr %214, align 8, !tbaa !13
  store double 0.000000e+00, ptr %229, align 8, !tbaa !15
  %972 = load <2 x double>, ptr %23, align 16, !tbaa !9
  %973 = insertelement <2 x double> poison, double %971, i64 0
  %974 = shufflevector <2 x double> %973, <2 x double> poison, <2 x i32> zeroinitializer
  %975 = fdiv <2 x double> %972, %974
  store <2 x double> %975, ptr %16, align 16, !tbaa !9
  store <2 x double> %975, ptr %23, align 16, !tbaa !9
  %976 = icmp sgt i32 %spec.select, %.1994
  br i1 %976, label %977, label %985

977:                                              ; preds = %967
  %978 = sub nsw i32 %spec.select, %.1994
  store i32 %978, ptr %14, align 4, !tbaa !5
  %979 = call { double, double } @Cd(ptr noundef nonnull %23)
  %980 = extractvalue { double, double } %979, 0
  %981 = extractvalue { double, double } %979, 1
  %982 = fneg double %981
  %983 = call ptr @_pCd(ptr noundef nonnull %16)
  %984 = getelementptr inbounds i8, ptr %983, i64 8
  store double %980, ptr %983, align 8
  store double %982, ptr %984, align 8
  call void @zscal_(ptr noundef nonnull %14, ptr noundef nonnull %16, ptr noundef nonnull %234, ptr noundef nonnull %6) #9
  br label %985

985:                                              ; preds = %977, %967
  %986 = sub nsw i32 %.1994, %spec.select929
  store i32 %986, ptr %14, align 4, !tbaa !5
  %987 = add nsw i32 %spec.select929, %219
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds %struct.doublecomplex, ptr %39, i64 %988
  call void @zscal_(ptr noundef nonnull %14, ptr noundef nonnull %23, ptr noundef %989, ptr noundef nonnull @c__1) #9
  %990 = load i32, ptr %1, align 4, !tbaa !5
  %.not917 = icmp eq i32 %990, 0
  br i1 %.not917, label %996, label %991

991:                                              ; preds = %985
  %992 = load i32, ptr %8, align 4, !tbaa !5
  %993 = add nsw i32 %992, %235
  %994 = sext i32 %993 to i64
  %995 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %994
  call void @zscal_(ptr noundef nonnull %33, ptr noundef nonnull %23, ptr noundef %995, ptr noundef nonnull @c__1) #9
  br label %996

996:                                              ; preds = %._crit_edge982, %991, %985
  %997 = add nuw nsw i32 %.0880986, 1
  %exitcond1039.not = icmp eq i32 %.0880986, %196
  br i1 %exitcond1039.not, label %.preheader._crit_edge, label %238, !llvm.loop !24

.preheader._crit_edge:                            ; preds = %996, %.preheader.lr.ph
  %.1.lcssa940 = phi i32 [ %197, %.preheader.lr.ph ], [ %.1994, %996 ]
  store i32 %.1.lcssa940, ptr %12, align 4, !tbaa !5
  br label %.loopexit935

998:                                              ; preds = %433
  store i32 %215, ptr %14, align 4, !tbaa !5
  %999 = getelementptr inbounds %struct.doublecomplex, ptr %40, i64 %236
  %1000 = load <2 x double>, ptr %217, align 8, !tbaa !9
  store <2 x double> %1000, ptr %999, align 8, !tbaa !9
  %1001 = add nsw i32 %.0874.lcssa, -1
  br i1 %426, label %.preheader, label %.loopexit935

.loopexit935:                                     ; preds = %998, %193, %13, %.preheader._crit_edge, %50
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %36) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %35) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %34) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %33) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %32) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %31) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %30) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %29) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %28) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %27) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %26) #9
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %25) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %24) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %23) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %22) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %21) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %20) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %19) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %18) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %15) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %14) #9
  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

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

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

declare void @zscal_(ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #4

declare double @dlamch_(ptr noundef) local_unnamed_addr #4

declare void @dlabad_(ptr noundef, ptr noundef) local_unnamed_addr #4

; Function Attrs: nounwind
declare { double, double } @csqrt(double noundef, double noundef) local_unnamed_addr #5

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

; Function Attrs: nounwind uwtable
declare hidden { double, double } @zpow_ui(double noundef, double noundef, i32 noundef) local_unnamed_addr #0

declare void @zladiv_(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #4

declare void @zcopy_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #4

declare void @zlarfg_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #4

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

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

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

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

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

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

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


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