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

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

@.str = external hidden unnamed_addr constant [13 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [4 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@c_b2 = external hidden global %struct.doublecomplex, align 8
@c__2 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c__3 = external hidden global i32, align 4
@.str.3 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zlaqr5_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9, ptr noundef %10, ptr noundef %11, ptr noundef %12, ptr noundef %13, ptr noundef %14, ptr noundef %15, ptr noundef %16, ptr noundef %17, ptr noundef %18, ptr noundef %19, ptr noundef %20, ptr noundef %21, ptr noundef %22, ptr noundef %23) #0 {
  %25 = alloca ptr, align 8
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca ptr, align 8
  %44 = alloca ptr, align 8
  %45 = alloca ptr, align 8
  %46 = alloca ptr, align 8
  %47 = alloca ptr, align 8
  %48 = alloca ptr, align 8
  %49 = alloca i32, align 4
  %50 = alloca i32, align 4
  %51 = alloca i32, align 4
  %52 = alloca i32, align 4
  %53 = alloca i32, align 4
  %54 = alloca i32, align 4
  %55 = alloca i32, align 4
  %56 = alloca i32, align 4
  %57 = alloca i32, align 4
  %58 = alloca i32, align 4
  %59 = alloca i32, align 4
  %60 = alloca i32, align 4
  %61 = alloca i32, align 4
  %62 = alloca i32, align 4
  %63 = alloca i32, align 4
  %64 = alloca i32, align 4
  %65 = alloca i32, align 4
  %66 = alloca i32, align 4
  %67 = alloca i32, align 4
  %68 = alloca i32, align 4
  %69 = alloca i32, align 4
  %70 = alloca i32, align 4
  %71 = alloca i32, align 4
  %72 = alloca double, align 8
  %73 = alloca double, align 8
  %74 = alloca double, align 8
  %75 = alloca double, align 8
  %76 = alloca double, align 8
  %77 = alloca double, align 8
  %78 = alloca double, align 8
  %79 = alloca double, align 8
  %80 = alloca double, align 8
  %81 = alloca double, align 8
  %82 = alloca %struct.doublecomplex, align 8
  %83 = alloca %struct.doublecomplex, align 8
  %84 = alloca %struct.doublecomplex, align 8
  %85 = alloca %struct.doublecomplex, align 8
  %86 = alloca %struct.doublecomplex, align 8
  %87 = alloca %struct.doublecomplex, align 8
  %88 = alloca %struct.doublecomplex, align 8
  %89 = alloca %struct.doublecomplex, align 8
  %90 = alloca %struct.doublecomplex, align 8
  %91 = alloca i32, align 4
  %92 = alloca i32, align 4
  %93 = alloca i32, align 4
  %94 = alloca i32, align 4
  %95 = alloca i32, align 4
  %96 = alloca i32, align 4
  %97 = alloca i32, align 4
  %98 = alloca i32, align 4
  %99 = alloca i32, align 4
  %100 = alloca i32, align 4
  %101 = alloca i32, align 4
  %102 = alloca %struct.doublecomplex, align 8
  %103 = alloca i32, align 4
  %104 = alloca i32, align 4
  %105 = alloca i32, align 4
  %106 = alloca i32, align 4
  %107 = alloca i32, align 4
  %108 = alloca i32, align 4
  %109 = alloca i32, align 4
  %110 = alloca i32, align 4
  %111 = alloca double, align 8
  %112 = alloca double, align 8
  %113 = alloca double, align 8
  %114 = alloca double, align 8
  %115 = alloca i32, align 4
  %116 = alloca i32, align 4
  %117 = alloca i32, align 4
  %118 = alloca [3 x %struct.doublecomplex], align 16
  %119 = alloca double, align 8
  %120 = alloca double, align 8
  %121 = alloca %struct.doublecomplex, align 8
  %122 = alloca double, align 8
  %123 = alloca double, align 8
  %124 = alloca i32, align 4
  %125 = alloca i32, align 4
  %126 = alloca double, align 8
  %127 = alloca double, align 8
  %128 = alloca double, align 8
  %129 = alloca i32, align 4
  store ptr %0, ptr %25, align 8, !tbaa !5
  store ptr %1, ptr %26, align 8, !tbaa !5
  store ptr %2, ptr %27, align 8, !tbaa !5
  store ptr %3, ptr %28, align 8, !tbaa !5
  store ptr %4, ptr %29, align 8, !tbaa !5
  store ptr %5, ptr %30, align 8, !tbaa !5
  store ptr %6, ptr %31, align 8, !tbaa !5
  store ptr %7, ptr %32, align 8, !tbaa !5
  store ptr %8, ptr %33, align 8, !tbaa !5
  store ptr %9, ptr %34, align 8, !tbaa !5
  store ptr %10, ptr %35, align 8, !tbaa !5
  store ptr %11, ptr %36, align 8, !tbaa !5
  store ptr %12, ptr %37, align 8, !tbaa !5
  store ptr %13, ptr %38, align 8, !tbaa !5
  store ptr %14, ptr %39, align 8, !tbaa !5
  store ptr %15, ptr %40, align 8, !tbaa !5
  store ptr %16, ptr %41, align 8, !tbaa !5
  store ptr %17, ptr %42, align 8, !tbaa !5
  store ptr %18, ptr %43, align 8, !tbaa !5
  store ptr %19, ptr %44, align 8, !tbaa !5
  store ptr %20, ptr %45, align 8, !tbaa !5
  store ptr %21, ptr %46, align 8, !tbaa !5
  store ptr %22, ptr %47, align 8, !tbaa !5
  store ptr %23, ptr %48, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %51) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %59) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %72) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %74) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %76) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %77) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %78) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %81) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %82) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %83) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %84) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %85) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %86) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %87) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %88) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %89) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %90) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %93) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %101) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %102) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %108) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %110) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %111) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %112) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %113) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %114) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %115) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %116) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %117) #5
  call void @llvm.lifetime.start.p0(i64 48, ptr %118) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %119) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %120) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %121) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %122) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %123) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %124) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %125) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %126) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %127) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %128) #5
  %130 = load ptr, ptr %32, align 8, !tbaa !5
  %131 = getelementptr inbounds %struct.doublecomplex, ptr %130, i32 -1
  store ptr %131, ptr %32, align 8, !tbaa !5
  %132 = load ptr, ptr %34, align 8, !tbaa !5
  %133 = load i32, ptr %132, align 4, !tbaa !9
  store i32 %133, ptr %49, align 4, !tbaa !9
  %134 = load i32, ptr %49, align 4, !tbaa !9
  %135 = mul nsw i32 %134, 1
  %136 = add nsw i32 1, %135
  store i32 %136, ptr %50, align 4, !tbaa !9
  %137 = load i32, ptr %50, align 4, !tbaa !9
  %138 = load ptr, ptr %33, align 8, !tbaa !5
  %139 = sext i32 %137 to i64
  %140 = sub i64 0, %139
  %141 = getelementptr inbounds %struct.doublecomplex, ptr %138, i64 %140
  store ptr %141, ptr %33, align 8, !tbaa !5
  %142 = load ptr, ptr %38, align 8, !tbaa !5
  %143 = load i32, ptr %142, align 4, !tbaa !9
  store i32 %143, ptr %59, align 4, !tbaa !9
  %144 = load i32, ptr %59, align 4, !tbaa !9
  %145 = mul nsw i32 %144, 1
  %146 = add nsw i32 1, %145
  store i32 %146, ptr %60, align 4, !tbaa !9
  %147 = load i32, ptr %60, align 4, !tbaa !9
  %148 = load ptr, ptr %37, align 8, !tbaa !5
  %149 = sext i32 %147 to i64
  %150 = sub i64 0, %149
  %151 = getelementptr inbounds %struct.doublecomplex, ptr %148, i64 %150
  store ptr %151, ptr %37, align 8, !tbaa !5
  %152 = load ptr, ptr %40, align 8, !tbaa !5
  %153 = load i32, ptr %152, align 4, !tbaa !9
  store i32 %153, ptr %53, align 4, !tbaa !9
  %154 = load i32, ptr %53, align 4, !tbaa !9
  %155 = mul nsw i32 %154, 1
  %156 = add nsw i32 1, %155
  store i32 %156, ptr %54, align 4, !tbaa !9
  %157 = load i32, ptr %54, align 4, !tbaa !9
  %158 = load ptr, ptr %39, align 8, !tbaa !5
  %159 = sext i32 %157 to i64
  %160 = sub i64 0, %159
  %161 = getelementptr inbounds %struct.doublecomplex, ptr %158, i64 %160
  store ptr %161, ptr %39, align 8, !tbaa !5
  %162 = load ptr, ptr %42, align 8, !tbaa !5
  %163 = load i32, ptr %162, align 4, !tbaa !9
  store i32 %163, ptr %51, align 4, !tbaa !9
  %164 = load i32, ptr %51, align 4, !tbaa !9
  %165 = mul nsw i32 %164, 1
  %166 = add nsw i32 1, %165
  store i32 %166, ptr %52, align 4, !tbaa !9
  %167 = load i32, ptr %52, align 4, !tbaa !9
  %168 = load ptr, ptr %41, align 8, !tbaa !5
  %169 = sext i32 %167 to i64
  %170 = sub i64 0, %169
  %171 = getelementptr inbounds %struct.doublecomplex, ptr %168, i64 %170
  store ptr %171, ptr %41, align 8, !tbaa !5
  %172 = load ptr, ptr %45, align 8, !tbaa !5
  %173 = load i32, ptr %172, align 4, !tbaa !9
  store i32 %173, ptr %57, align 4, !tbaa !9
  %174 = load i32, ptr %57, align 4, !tbaa !9
  %175 = mul nsw i32 %174, 1
  %176 = add nsw i32 1, %175
  store i32 %176, ptr %58, align 4, !tbaa !9
  %177 = load i32, ptr %58, align 4, !tbaa !9
  %178 = load ptr, ptr %44, align 8, !tbaa !5
  %179 = sext i32 %177 to i64
  %180 = sub i64 0, %179
  %181 = getelementptr inbounds %struct.doublecomplex, ptr %178, i64 %180
  store ptr %181, ptr %44, align 8, !tbaa !5
  %182 = load ptr, ptr %48, align 8, !tbaa !5
  %183 = load i32, ptr %182, align 4, !tbaa !9
  store i32 %183, ptr %55, align 4, !tbaa !9
  %184 = load i32, ptr %55, align 4, !tbaa !9
  %185 = mul nsw i32 %184, 1
  %186 = add nsw i32 1, %185
  store i32 %186, ptr %56, align 4, !tbaa !9
  %187 = load i32, ptr %56, align 4, !tbaa !9
  %188 = load ptr, ptr %47, align 8, !tbaa !5
  %189 = sext i32 %187 to i64
  %190 = sub i64 0, %189
  %191 = getelementptr inbounds %struct.doublecomplex, ptr %188, i64 %190
  store ptr %191, ptr %47, align 8, !tbaa !5
  %192 = load ptr, ptr %31, align 8, !tbaa !5
  %193 = load i32, ptr %192, align 4, !tbaa !9
  %194 = icmp slt i32 %193, 2
  br i1 %194, label %195, label %196

195:                                              ; preds = %24
  store i32 1, ptr %129, align 4
  br label %7630

196:                                              ; preds = %24
  %197 = load ptr, ptr %29, align 8, !tbaa !5
  %198 = load i32, ptr %197, align 4, !tbaa !9
  %199 = load ptr, ptr %30, align 8, !tbaa !5
  %200 = load i32, ptr %199, align 4, !tbaa !9
  %201 = icmp sge i32 %198, %200
  br i1 %201, label %202, label %203

202:                                              ; preds = %196
  store i32 1, ptr %129, align 4
  br label %7630

203:                                              ; preds = %196
  %204 = load ptr, ptr %31, align 8, !tbaa !5
  %205 = load i32, ptr %204, align 4, !tbaa !9
  %206 = load ptr, ptr %31, align 8, !tbaa !5
  %207 = load i32, ptr %206, align 4, !tbaa !9
  %208 = srem i32 %207, 2
  %209 = sub nsw i32 %205, %208
  store i32 %209, ptr %116, align 4, !tbaa !9
  %210 = call double @dlamch_(ptr noundef @.str)
  store double %210, ptr %119, align 8, !tbaa !11
  %211 = load double, ptr %119, align 8, !tbaa !11
  %212 = fdiv double 1.000000e+00, %211
  store double %212, ptr %120, align 8, !tbaa !11
  call void @dlabad_(ptr noundef %119, ptr noundef %120)
  %213 = call double @dlamch_(ptr noundef @.str.1)
  store double %213, ptr %126, align 8, !tbaa !11
  %214 = load double, ptr %119, align 8, !tbaa !11
  %215 = load ptr, ptr %28, align 8, !tbaa !5
  %216 = load i32, ptr %215, align 4, !tbaa !9
  %217 = sitofp i32 %216 to double
  %218 = load double, ptr %126, align 8, !tbaa !11
  %219 = fdiv double %217, %218
  %220 = fmul double %214, %219
  store double %220, ptr %122, align 8, !tbaa !11
  %221 = load ptr, ptr %27, align 8, !tbaa !5
  %222 = load i32, ptr %221, align 4, !tbaa !9
  %223 = icmp eq i32 %222, 1
  br i1 %223, label %228, label %224

224:                                              ; preds = %203
  %225 = load ptr, ptr %27, align 8, !tbaa !5
  %226 = load i32, ptr %225, align 4, !tbaa !9
  %227 = icmp eq i32 %226, 2
  br label %228

228:                                              ; preds = %224, %203
  %229 = phi i1 [ true, %203 ], [ %227, %224 ]
  %230 = zext i1 %229 to i32
  store i32 %230, ptr %103, align 4, !tbaa !9
  %231 = load ptr, ptr %29, align 8, !tbaa !5
  %232 = load i32, ptr %231, align 4, !tbaa !9
  %233 = add nsw i32 %232, 2
  %234 = load ptr, ptr %30, align 8, !tbaa !5
  %235 = load i32, ptr %234, align 4, !tbaa !9
  %236 = icmp sle i32 %233, %235
  br i1 %236, label %237, label %256

237:                                              ; preds = %228
  %238 = load ptr, ptr %29, align 8, !tbaa !5
  %239 = load i32, ptr %238, align 4, !tbaa !9
  %240 = add nsw i32 %239, 2
  %241 = load ptr, ptr %29, align 8, !tbaa !5
  %242 = load i32, ptr %241, align 4, !tbaa !9
  %243 = load i32, ptr %49, align 4, !tbaa !9
  %244 = mul nsw i32 %242, %243
  %245 = add nsw i32 %240, %244
  store i32 %245, ptr %61, align 4, !tbaa !9
  %246 = load ptr, ptr %33, align 8, !tbaa !5
  %247 = load i32, ptr %61, align 4, !tbaa !9
  %248 = sext i32 %247 to i64
  %249 = getelementptr inbounds %struct.doublecomplex, ptr %246, i64 %248
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %249, i32 0, i32 0
  store double 0.000000e+00, ptr %250, align 8, !tbaa !13
  %251 = load ptr, ptr %33, align 8, !tbaa !5
  %252 = load i32, ptr %61, align 4, !tbaa !9
  %253 = sext i32 %252 to i64
  %254 = getelementptr inbounds %struct.doublecomplex, ptr %251, i64 %253
  %255 = getelementptr inbounds %struct.doublecomplex, ptr %254, i32 0, i32 1
  store double 0.000000e+00, ptr %255, align 8, !tbaa !15
  br label %256

256:                                              ; preds = %237, %228
  %257 = load i32, ptr %116, align 4, !tbaa !9
  %258 = sdiv i32 %257, 2
  store i32 %258, ptr %107, align 4, !tbaa !9
  %259 = load i32, ptr %107, align 4, !tbaa !9
  %260 = shl i32 %259, 2
  store i32 %260, ptr %124, align 4, !tbaa !9
  %261 = load ptr, ptr %30, align 8, !tbaa !5
  %262 = load i32, ptr %261, align 4, !tbaa !9
  %263 = sub nsw i32 %262, 2
  store i32 %263, ptr %61, align 4, !tbaa !9
  %264 = load i32, ptr %107, align 4, !tbaa !9
  %265 = shl i32 %264, 1
  store i32 %265, ptr %62, align 4, !tbaa !9
  %266 = load ptr, ptr %29, align 8, !tbaa !5
  %267 = load i32, ptr %266, align 4, !tbaa !9
  %268 = load i32, ptr %107, align 4, !tbaa !9
  %269 = shl i32 %268, 1
  %270 = sub nsw i32 %267, %269
  %271 = add nsw i32 %270, 1
  store i32 %271, ptr %105, align 4, !tbaa !9
  br label %272

272:                                              ; preds = %7625, %256
  %273 = load i32, ptr %62, align 4, !tbaa !9
  %274 = icmp slt i32 %273, 0
  br i1 %274, label %275, label %280

275:                                              ; preds = %272
  %276 = load i32, ptr %105, align 4, !tbaa !9
  %277 = load i32, ptr %61, align 4, !tbaa !9
  %278 = icmp sge i32 %276, %277
  %279 = zext i1 %278 to i32
  br label %285

280:                                              ; preds = %272
  %281 = load i32, ptr %105, align 4, !tbaa !9
  %282 = load i32, ptr %61, align 4, !tbaa !9
  %283 = icmp sle i32 %281, %282
  %284 = zext i1 %283 to i32
  br label %285

285:                                              ; preds = %280, %275
  %286 = phi i32 [ %279, %275 ], [ %284, %280 ]
  %287 = icmp ne i32 %286, 0
  br i1 %287, label %288, label %7629

288:                                              ; preds = %285
  %289 = load i32, ptr %103, align 4, !tbaa !9
  %290 = icmp ne i32 %289, 0
  br i1 %290, label %291, label %303

291:                                              ; preds = %288
  %292 = load ptr, ptr %29, align 8, !tbaa !5
  %293 = load i32, ptr %292, align 4, !tbaa !9
  %294 = load i32, ptr %105, align 4, !tbaa !9
  %295 = icmp sge i32 %293, %294
  br i1 %295, label %296, label %299

296:                                              ; preds = %291
  %297 = load ptr, ptr %29, align 8, !tbaa !5
  %298 = load i32, ptr %297, align 4, !tbaa !9
  br label %301

299:                                              ; preds = %291
  %300 = load i32, ptr %105, align 4, !tbaa !9
  br label %301

301:                                              ; preds = %299, %296
  %302 = phi i32 [ %298, %296 ], [ %300, %299 ]
  store i32 %302, ptr %96, align 4, !tbaa !9
  br label %312

303:                                              ; preds = %288
  %304 = load ptr, ptr %25, align 8, !tbaa !5
  %305 = load i32, ptr %304, align 4, !tbaa !9
  %306 = icmp ne i32 %305, 0
  br i1 %306, label %307, label %308

307:                                              ; preds = %303
  store i32 1, ptr %96, align 4, !tbaa !9
  br label %311

308:                                              ; preds = %303
  %309 = load ptr, ptr %29, align 8, !tbaa !5
  %310 = load i32, ptr %309, align 4, !tbaa !9
  store i32 %310, ptr %96, align 4, !tbaa !9
  br label %311

311:                                              ; preds = %308, %307
  br label %312

312:                                              ; preds = %311, %301
  %313 = load i32, ptr %105, align 4, !tbaa !9
  %314 = load i32, ptr %124, align 4, !tbaa !9
  %315 = add nsw i32 %313, %314
  store i32 %315, ptr %104, align 4, !tbaa !9
  %316 = load i32, ptr %103, align 4, !tbaa !9
  %317 = icmp ne i32 %316, 0
  br i1 %317, label %318, label %324

318:                                              ; preds = %312
  %319 = load ptr, ptr %41, align 8, !tbaa !5
  %320 = load i32, ptr %52, align 4, !tbaa !9
  %321 = sext i32 %320 to i64
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %319, i64 %321
  %323 = load ptr, ptr %42, align 8, !tbaa !5
  call void @zlaset_(ptr noundef @.str.2, ptr noundef %124, ptr noundef %124, ptr noundef @c_b1, ptr noundef @c_b2, ptr noundef %322, ptr noundef %323)
  br label %324

324:                                              ; preds = %318, %312
  %325 = load i32, ptr %105, align 4, !tbaa !9
  %326 = load i32, ptr %107, align 4, !tbaa !9
  %327 = shl i32 %326, 1
  %328 = add nsw i32 %325, %327
  %329 = sub nsw i32 %328, 1
  store i32 %329, ptr %64, align 4, !tbaa !9
  %330 = load ptr, ptr %30, align 8, !tbaa !5
  %331 = load i32, ptr %330, align 4, !tbaa !9
  %332 = sub nsw i32 %331, 2
  store i32 %332, ptr %65, align 4, !tbaa !9
  %333 = load i32, ptr %64, align 4, !tbaa !9
  %334 = load i32, ptr %65, align 4, !tbaa !9
  %335 = icmp sle i32 %333, %334
  br i1 %335, label %336, label %338

336:                                              ; preds = %324
  %337 = load i32, ptr %64, align 4, !tbaa !9
  br label %340

338:                                              ; preds = %324
  %339 = load i32, ptr %65, align 4, !tbaa !9
  br label %340

340:                                              ; preds = %338, %336
  %341 = phi i32 [ %337, %336 ], [ %339, %338 ]
  store i32 %341, ptr %63, align 4, !tbaa !9
  %342 = load i32, ptr %105, align 4, !tbaa !9
  store i32 %342, ptr %106, align 4, !tbaa !9
  br label %343

343:                                              ; preds = %7289, %340
  %344 = load i32, ptr %106, align 4, !tbaa !9
  %345 = load i32, ptr %63, align 4, !tbaa !9
  %346 = icmp sle i32 %344, %345
  br i1 %346, label %347, label %7292

347:                                              ; preds = %343
  store i32 1, ptr %64, align 4, !tbaa !9
  %348 = load ptr, ptr %29, align 8, !tbaa !5
  %349 = load i32, ptr %348, align 4, !tbaa !9
  %350 = load i32, ptr %106, align 4, !tbaa !9
  %351 = sub nsw i32 %349, %350
  %352 = sdiv i32 %351, 2
  %353 = add nsw i32 %352, 1
  store i32 %353, ptr %65, align 4, !tbaa !9
  %354 = load i32, ptr %64, align 4, !tbaa !9
  %355 = load i32, ptr %65, align 4, !tbaa !9
  %356 = icmp sge i32 %354, %355
  br i1 %356, label %357, label %359

357:                                              ; preds = %347
  %358 = load i32, ptr %64, align 4, !tbaa !9
  br label %361

359:                                              ; preds = %347
  %360 = load i32, ptr %65, align 4, !tbaa !9
  br label %361

361:                                              ; preds = %359, %357
  %362 = phi i32 [ %358, %357 ], [ %360, %359 ]
  store i32 %362, ptr %98, align 4, !tbaa !9
  %363 = load i32, ptr %107, align 4, !tbaa !9
  store i32 %363, ptr %64, align 4, !tbaa !9
  %364 = load ptr, ptr %30, align 8, !tbaa !5
  %365 = load i32, ptr %364, align 4, !tbaa !9
  %366 = load i32, ptr %106, align 4, !tbaa !9
  %367 = sub nsw i32 %365, %366
  %368 = sub nsw i32 %367, 1
  %369 = sdiv i32 %368, 2
  store i32 %369, ptr %65, align 4, !tbaa !9
  %370 = load i32, ptr %64, align 4, !tbaa !9
  %371 = load i32, ptr %65, align 4, !tbaa !9
  %372 = icmp sle i32 %370, %371
  br i1 %372, label %373, label %375

373:                                              ; preds = %361
  %374 = load i32, ptr %64, align 4, !tbaa !9
  br label %377

375:                                              ; preds = %361
  %376 = load i32, ptr %65, align 4, !tbaa !9
  br label %377

377:                                              ; preds = %375, %373
  %378 = phi i32 [ %374, %373 ], [ %376, %375 ]
  store i32 %378, ptr %95, align 4, !tbaa !9
  %379 = load i32, ptr %95, align 4, !tbaa !9
  %380 = add nsw i32 %379, 1
  store i32 %380, ptr %115, align 4, !tbaa !9
  %381 = load i32, ptr %95, align 4, !tbaa !9
  %382 = load i32, ptr %107, align 4, !tbaa !9
  %383 = icmp slt i32 %381, %382
  br i1 %383, label %384, label %394

384:                                              ; preds = %377
  %385 = load i32, ptr %106, align 4, !tbaa !9
  %386 = load i32, ptr %115, align 4, !tbaa !9
  %387 = sub nsw i32 %386, 1
  %388 = shl i32 %387, 1
  %389 = add nsw i32 %385, %388
  %390 = load ptr, ptr %30, align 8, !tbaa !5
  %391 = load i32, ptr %390, align 4, !tbaa !9
  %392 = sub nsw i32 %391, 2
  %393 = icmp eq i32 %389, %392
  br label %394

394:                                              ; preds = %384, %377
  %395 = phi i1 [ false, %377 ], [ %393, %384 ]
  %396 = zext i1 %395 to i32
  store i32 %396, ptr %91, align 4, !tbaa !9
  %397 = load i32, ptr %91, align 4, !tbaa !9
  %398 = icmp ne i32 %397, 0
  br i1 %398, label %399, label %2739

399:                                              ; preds = %394
  %400 = load i32, ptr %106, align 4, !tbaa !9
  %401 = load i32, ptr %115, align 4, !tbaa !9
  %402 = sub nsw i32 %401, 1
  %403 = shl i32 %402, 1
  %404 = add nsw i32 %400, %403
  store i32 %404, ptr %100, align 4, !tbaa !9
  %405 = load i32, ptr %100, align 4, !tbaa !9
  %406 = load ptr, ptr %29, align 8, !tbaa !5
  %407 = load i32, ptr %406, align 4, !tbaa !9
  %408 = sub nsw i32 %407, 1
  %409 = icmp eq i32 %405, %408
  br i1 %409, label %410, label %472

410:                                              ; preds = %399
  %411 = load ptr, ptr %33, align 8, !tbaa !5
  %412 = load i32, ptr %100, align 4, !tbaa !9
  %413 = add nsw i32 %412, 1
  %414 = load i32, ptr %100, align 4, !tbaa !9
  %415 = add nsw i32 %414, 1
  %416 = load i32, ptr %49, align 4, !tbaa !9
  %417 = mul nsw i32 %415, %416
  %418 = add nsw i32 %413, %417
  %419 = sext i32 %418 to i64
  %420 = getelementptr inbounds %struct.doublecomplex, ptr %411, i64 %419
  %421 = load ptr, ptr %34, align 8, !tbaa !5
  %422 = load ptr, ptr %32, align 8, !tbaa !5
  %423 = load i32, ptr %115, align 4, !tbaa !9
  %424 = shl i32 %423, 1
  %425 = sub nsw i32 %424, 1
  %426 = sext i32 %425 to i64
  %427 = getelementptr inbounds %struct.doublecomplex, ptr %422, i64 %426
  %428 = load ptr, ptr %32, align 8, !tbaa !5
  %429 = load i32, ptr %115, align 4, !tbaa !9
  %430 = mul nsw i32 %429, 2
  %431 = sext i32 %430 to i64
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %428, i64 %431
  %433 = load ptr, ptr %39, align 8, !tbaa !5
  %434 = load i32, ptr %115, align 4, !tbaa !9
  %435 = load i32, ptr %53, align 4, !tbaa !9
  %436 = mul nsw i32 %434, %435
  %437 = add nsw i32 %436, 1
  %438 = sext i32 %437 to i64
  %439 = getelementptr inbounds %struct.doublecomplex, ptr %433, i64 %438
  call void @zlaqr1_(ptr noundef @c__2, ptr noundef %420, ptr noundef %421, ptr noundef %427, ptr noundef %432, ptr noundef %439)
  %440 = load i32, ptr %115, align 4, !tbaa !9
  %441 = load i32, ptr %53, align 4, !tbaa !9
  %442 = mul nsw i32 %440, %441
  %443 = add nsw i32 %442, 1
  store i32 %443, ptr %64, align 4, !tbaa !9
  %444 = load ptr, ptr %39, align 8, !tbaa !5
  %445 = load i32, ptr %64, align 4, !tbaa !9
  %446 = sext i32 %445 to i64
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %444, i64 %446
  %448 = getelementptr inbounds %struct.doublecomplex, ptr %447, i32 0, i32 0
  %449 = load double, ptr %448, align 8, !tbaa !13
  %450 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  store double %449, ptr %450, align 8, !tbaa !13
  %451 = load ptr, ptr %39, align 8, !tbaa !5
  %452 = load i32, ptr %64, align 4, !tbaa !9
  %453 = sext i32 %452 to i64
  %454 = getelementptr inbounds %struct.doublecomplex, ptr %451, i64 %453
  %455 = getelementptr inbounds %struct.doublecomplex, ptr %454, i32 0, i32 1
  %456 = load double, ptr %455, align 8, !tbaa !15
  %457 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  store double %456, ptr %457, align 8, !tbaa !15
  %458 = load ptr, ptr %39, align 8, !tbaa !5
  %459 = load i32, ptr %115, align 4, !tbaa !9
  %460 = load i32, ptr %53, align 4, !tbaa !9
  %461 = mul nsw i32 %459, %460
  %462 = add nsw i32 %461, 2
  %463 = sext i32 %462 to i64
  %464 = getelementptr inbounds %struct.doublecomplex, ptr %458, i64 %463
  %465 = load ptr, ptr %39, align 8, !tbaa !5
  %466 = load i32, ptr %115, align 4, !tbaa !9
  %467 = load i32, ptr %53, align 4, !tbaa !9
  %468 = mul nsw i32 %466, %467
  %469 = add nsw i32 %468, 1
  %470 = sext i32 %469 to i64
  %471 = getelementptr inbounds %struct.doublecomplex, ptr %465, i64 %470
  call void @zlarfg_(ptr noundef @c__2, ptr noundef %90, ptr noundef %464, ptr noundef @c__1, ptr noundef %471)
  br label %575

472:                                              ; preds = %399
  %473 = load i32, ptr %100, align 4, !tbaa !9
  %474 = add nsw i32 %473, 1
  %475 = load i32, ptr %100, align 4, !tbaa !9
  %476 = load i32, ptr %49, align 4, !tbaa !9
  %477 = mul nsw i32 %475, %476
  %478 = add nsw i32 %474, %477
  store i32 %478, ptr %64, align 4, !tbaa !9
  %479 = load ptr, ptr %33, align 8, !tbaa !5
  %480 = load i32, ptr %64, align 4, !tbaa !9
  %481 = sext i32 %480 to i64
  %482 = getelementptr inbounds %struct.doublecomplex, ptr %479, i64 %481
  %483 = getelementptr inbounds %struct.doublecomplex, ptr %482, i32 0, i32 0
  %484 = load double, ptr %483, align 8, !tbaa !13
  %485 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  store double %484, ptr %485, align 8, !tbaa !13
  %486 = load ptr, ptr %33, align 8, !tbaa !5
  %487 = load i32, ptr %64, align 4, !tbaa !9
  %488 = sext i32 %487 to i64
  %489 = getelementptr inbounds %struct.doublecomplex, ptr %486, i64 %488
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %489, i32 0, i32 1
  %491 = load double, ptr %490, align 8, !tbaa !15
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  store double %491, ptr %492, align 8, !tbaa !15
  %493 = load i32, ptr %115, align 4, !tbaa !9
  %494 = load i32, ptr %53, align 4, !tbaa !9
  %495 = mul nsw i32 %493, %494
  %496 = add nsw i32 %495, 2
  store i32 %496, ptr %64, align 4, !tbaa !9
  %497 = load i32, ptr %100, align 4, !tbaa !9
  %498 = add nsw i32 %497, 2
  %499 = load i32, ptr %100, align 4, !tbaa !9
  %500 = load i32, ptr %49, align 4, !tbaa !9
  %501 = mul nsw i32 %499, %500
  %502 = add nsw i32 %498, %501
  store i32 %502, ptr %65, align 4, !tbaa !9
  %503 = load ptr, ptr %33, align 8, !tbaa !5
  %504 = load i32, ptr %65, align 4, !tbaa !9
  %505 = sext i32 %504 to i64
  %506 = getelementptr inbounds %struct.doublecomplex, ptr %503, i64 %505
  %507 = getelementptr inbounds %struct.doublecomplex, ptr %506, i32 0, i32 0
  %508 = load double, ptr %507, align 8, !tbaa !13
  %509 = load ptr, ptr %39, align 8, !tbaa !5
  %510 = load i32, ptr %64, align 4, !tbaa !9
  %511 = sext i32 %510 to i64
  %512 = getelementptr inbounds %struct.doublecomplex, ptr %509, i64 %511
  %513 = getelementptr inbounds %struct.doublecomplex, ptr %512, i32 0, i32 0
  store double %508, ptr %513, align 8, !tbaa !13
  %514 = load ptr, ptr %33, align 8, !tbaa !5
  %515 = load i32, ptr %65, align 4, !tbaa !9
  %516 = sext i32 %515 to i64
  %517 = getelementptr inbounds %struct.doublecomplex, ptr %514, i64 %516
  %518 = getelementptr inbounds %struct.doublecomplex, ptr %517, i32 0, i32 1
  %519 = load double, ptr %518, align 8, !tbaa !15
  %520 = load ptr, ptr %39, align 8, !tbaa !5
  %521 = load i32, ptr %64, align 4, !tbaa !9
  %522 = sext i32 %521 to i64
  %523 = getelementptr inbounds %struct.doublecomplex, ptr %520, i64 %522
  %524 = getelementptr inbounds %struct.doublecomplex, ptr %523, i32 0, i32 1
  store double %519, ptr %524, align 8, !tbaa !15
  %525 = load ptr, ptr %39, align 8, !tbaa !5
  %526 = load i32, ptr %115, align 4, !tbaa !9
  %527 = load i32, ptr %53, align 4, !tbaa !9
  %528 = mul nsw i32 %526, %527
  %529 = add nsw i32 %528, 2
  %530 = sext i32 %529 to i64
  %531 = getelementptr inbounds %struct.doublecomplex, ptr %525, i64 %530
  %532 = load ptr, ptr %39, align 8, !tbaa !5
  %533 = load i32, ptr %115, align 4, !tbaa !9
  %534 = load i32, ptr %53, align 4, !tbaa !9
  %535 = mul nsw i32 %533, %534
  %536 = add nsw i32 %535, 1
  %537 = sext i32 %536 to i64
  %538 = getelementptr inbounds %struct.doublecomplex, ptr %532, i64 %537
  call void @zlarfg_(ptr noundef @c__2, ptr noundef %90, ptr noundef %531, ptr noundef @c__1, ptr noundef %538)
  %539 = load i32, ptr %100, align 4, !tbaa !9
  %540 = add nsw i32 %539, 1
  %541 = load i32, ptr %100, align 4, !tbaa !9
  %542 = load i32, ptr %49, align 4, !tbaa !9
  %543 = mul nsw i32 %541, %542
  %544 = add nsw i32 %540, %543
  store i32 %544, ptr %64, align 4, !tbaa !9
  %545 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  %546 = load double, ptr %545, align 8, !tbaa !13
  %547 = load ptr, ptr %33, align 8, !tbaa !5
  %548 = load i32, ptr %64, align 4, !tbaa !9
  %549 = sext i32 %548 to i64
  %550 = getelementptr inbounds %struct.doublecomplex, ptr %547, i64 %549
  %551 = getelementptr inbounds %struct.doublecomplex, ptr %550, i32 0, i32 0
  store double %546, ptr %551, align 8, !tbaa !13
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  %553 = load double, ptr %552, align 8, !tbaa !15
  %554 = load ptr, ptr %33, align 8, !tbaa !5
  %555 = load i32, ptr %64, align 4, !tbaa !9
  %556 = sext i32 %555 to i64
  %557 = getelementptr inbounds %struct.doublecomplex, ptr %554, i64 %556
  %558 = getelementptr inbounds %struct.doublecomplex, ptr %557, i32 0, i32 1
  store double %553, ptr %558, align 8, !tbaa !15
  %559 = load i32, ptr %100, align 4, !tbaa !9
  %560 = add nsw i32 %559, 2
  %561 = load i32, ptr %100, align 4, !tbaa !9
  %562 = load i32, ptr %49, align 4, !tbaa !9
  %563 = mul nsw i32 %561, %562
  %564 = add nsw i32 %560, %563
  store i32 %564, ptr %64, align 4, !tbaa !9
  %565 = load ptr, ptr %33, align 8, !tbaa !5
  %566 = load i32, ptr %64, align 4, !tbaa !9
  %567 = sext i32 %566 to i64
  %568 = getelementptr inbounds %struct.doublecomplex, ptr %565, i64 %567
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %568, i32 0, i32 0
  store double 0.000000e+00, ptr %569, align 8, !tbaa !13
  %570 = load ptr, ptr %33, align 8, !tbaa !5
  %571 = load i32, ptr %64, align 4, !tbaa !9
  %572 = sext i32 %571 to i64
  %573 = getelementptr inbounds %struct.doublecomplex, ptr %570, i64 %572
  %574 = getelementptr inbounds %struct.doublecomplex, ptr %573, i32 0, i32 1
  store double 0.000000e+00, ptr %574, align 8, !tbaa !15
  br label %575

575:                                              ; preds = %472, %410
  %576 = load ptr, ptr %30, align 8, !tbaa !5
  %577 = load i32, ptr %576, align 4, !tbaa !9
  store i32 %577, ptr %65, align 4, !tbaa !9
  %578 = load i32, ptr %100, align 4, !tbaa !9
  %579 = add nsw i32 %578, 3
  store i32 %579, ptr %66, align 4, !tbaa !9
  %580 = load i32, ptr %65, align 4, !tbaa !9
  %581 = load i32, ptr %66, align 4, !tbaa !9
  %582 = icmp sle i32 %580, %581
  br i1 %582, label %583, label %585

583:                                              ; preds = %575
  %584 = load i32, ptr %65, align 4, !tbaa !9
  br label %587

585:                                              ; preds = %575
  %586 = load i32, ptr %66, align 4, !tbaa !9
  br label %587

587:                                              ; preds = %585, %583
  %588 = phi i32 [ %584, %583 ], [ %586, %585 ]
  store i32 %588, ptr %64, align 4, !tbaa !9
  %589 = load i32, ptr %96, align 4, !tbaa !9
  store i32 %589, ptr %99, align 4, !tbaa !9
  br label %590

590:                                              ; preds = %864, %587
  %591 = load i32, ptr %99, align 4, !tbaa !9
  %592 = load i32, ptr %64, align 4, !tbaa !9
  %593 = icmp sle i32 %591, %592
  br i1 %593, label %594, label %867

594:                                              ; preds = %590
  %595 = load i32, ptr %115, align 4, !tbaa !9
  %596 = load i32, ptr %53, align 4, !tbaa !9
  %597 = mul nsw i32 %595, %596
  %598 = add nsw i32 %597, 1
  store i32 %598, ptr %65, align 4, !tbaa !9
  %599 = load i32, ptr %99, align 4, !tbaa !9
  %600 = load i32, ptr %100, align 4, !tbaa !9
  %601 = add nsw i32 %600, 1
  %602 = load i32, ptr %49, align 4, !tbaa !9
  %603 = mul nsw i32 %601, %602
  %604 = add nsw i32 %599, %603
  store i32 %604, ptr %66, align 4, !tbaa !9
  %605 = load i32, ptr %115, align 4, !tbaa !9
  %606 = load i32, ptr %53, align 4, !tbaa !9
  %607 = mul nsw i32 %605, %606
  %608 = add nsw i32 %607, 2
  store i32 %608, ptr %67, align 4, !tbaa !9
  %609 = load i32, ptr %99, align 4, !tbaa !9
  %610 = load i32, ptr %100, align 4, !tbaa !9
  %611 = add nsw i32 %610, 2
  %612 = load i32, ptr %49, align 4, !tbaa !9
  %613 = mul nsw i32 %611, %612
  %614 = add nsw i32 %609, %613
  store i32 %614, ptr %68, align 4, !tbaa !9
  %615 = load ptr, ptr %39, align 8, !tbaa !5
  %616 = load i32, ptr %67, align 4, !tbaa !9
  %617 = sext i32 %616 to i64
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %615, i64 %617
  %619 = getelementptr inbounds %struct.doublecomplex, ptr %618, i32 0, i32 0
  %620 = load double, ptr %619, align 8, !tbaa !13
  %621 = load ptr, ptr %33, align 8, !tbaa !5
  %622 = load i32, ptr %68, align 4, !tbaa !9
  %623 = sext i32 %622 to i64
  %624 = getelementptr inbounds %struct.doublecomplex, ptr %621, i64 %623
  %625 = getelementptr inbounds %struct.doublecomplex, ptr %624, i32 0, i32 0
  %626 = load double, ptr %625, align 8, !tbaa !13
  %627 = load ptr, ptr %39, align 8, !tbaa !5
  %628 = load i32, ptr %67, align 4, !tbaa !9
  %629 = sext i32 %628 to i64
  %630 = getelementptr inbounds %struct.doublecomplex, ptr %627, i64 %629
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %630, i32 0, i32 1
  %632 = load double, ptr %631, align 8, !tbaa !15
  %633 = load ptr, ptr %33, align 8, !tbaa !5
  %634 = load i32, ptr %68, align 4, !tbaa !9
  %635 = sext i32 %634 to i64
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %633, i64 %635
  %637 = getelementptr inbounds %struct.doublecomplex, ptr %636, i32 0, i32 1
  %638 = load double, ptr %637, align 8, !tbaa !15
  %639 = fmul double %632, %638
  %640 = fneg double %639
  %641 = call double @llvm.fmuladd.f64(double %620, double %626, double %640)
  %642 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %641, ptr %642, align 8, !tbaa !13
  %643 = load ptr, ptr %39, align 8, !tbaa !5
  %644 = load i32, ptr %67, align 4, !tbaa !9
  %645 = sext i32 %644 to i64
  %646 = getelementptr inbounds %struct.doublecomplex, ptr %643, i64 %645
  %647 = getelementptr inbounds %struct.doublecomplex, ptr %646, i32 0, i32 0
  %648 = load double, ptr %647, align 8, !tbaa !13
  %649 = load ptr, ptr %33, align 8, !tbaa !5
  %650 = load i32, ptr %68, align 4, !tbaa !9
  %651 = sext i32 %650 to i64
  %652 = getelementptr inbounds %struct.doublecomplex, ptr %649, i64 %651
  %653 = getelementptr inbounds %struct.doublecomplex, ptr %652, i32 0, i32 1
  %654 = load double, ptr %653, align 8, !tbaa !15
  %655 = load ptr, ptr %39, align 8, !tbaa !5
  %656 = load i32, ptr %67, align 4, !tbaa !9
  %657 = sext i32 %656 to i64
  %658 = getelementptr inbounds %struct.doublecomplex, ptr %655, i64 %657
  %659 = getelementptr inbounds %struct.doublecomplex, ptr %658, i32 0, i32 1
  %660 = load double, ptr %659, align 8, !tbaa !15
  %661 = load ptr, ptr %33, align 8, !tbaa !5
  %662 = load i32, ptr %68, align 4, !tbaa !9
  %663 = sext i32 %662 to i64
  %664 = getelementptr inbounds %struct.doublecomplex, ptr %661, i64 %663
  %665 = getelementptr inbounds %struct.doublecomplex, ptr %664, i32 0, i32 0
  %666 = load double, ptr %665, align 8, !tbaa !13
  %667 = fmul double %660, %666
  %668 = call double @llvm.fmuladd.f64(double %648, double %654, double %667)
  %669 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %668, ptr %669, align 8, !tbaa !15
  %670 = load ptr, ptr %33, align 8, !tbaa !5
  %671 = load i32, ptr %66, align 4, !tbaa !9
  %672 = sext i32 %671 to i64
  %673 = getelementptr inbounds %struct.doublecomplex, ptr %670, i64 %672
  %674 = getelementptr inbounds %struct.doublecomplex, ptr %673, i32 0, i32 0
  %675 = load double, ptr %674, align 8, !tbaa !13
  %676 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %677 = load double, ptr %676, align 8, !tbaa !13
  %678 = fadd double %675, %677
  %679 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %678, ptr %679, align 8, !tbaa !13
  %680 = load ptr, ptr %33, align 8, !tbaa !5
  %681 = load i32, ptr %66, align 4, !tbaa !9
  %682 = sext i32 %681 to i64
  %683 = getelementptr inbounds %struct.doublecomplex, ptr %680, i64 %682
  %684 = getelementptr inbounds %struct.doublecomplex, ptr %683, i32 0, i32 1
  %685 = load double, ptr %684, align 8, !tbaa !15
  %686 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %687 = load double, ptr %686, align 8, !tbaa !15
  %688 = fadd double %685, %687
  %689 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %688, ptr %689, align 8, !tbaa !15
  %690 = load ptr, ptr %39, align 8, !tbaa !5
  %691 = load i32, ptr %65, align 4, !tbaa !9
  %692 = sext i32 %691 to i64
  %693 = getelementptr inbounds %struct.doublecomplex, ptr %690, i64 %692
  %694 = getelementptr inbounds %struct.doublecomplex, ptr %693, i32 0, i32 0
  %695 = load double, ptr %694, align 8, !tbaa !13
  %696 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %697 = load double, ptr %696, align 8, !tbaa !13
  %698 = load ptr, ptr %39, align 8, !tbaa !5
  %699 = load i32, ptr %65, align 4, !tbaa !9
  %700 = sext i32 %699 to i64
  %701 = getelementptr inbounds %struct.doublecomplex, ptr %698, i64 %700
  %702 = getelementptr inbounds %struct.doublecomplex, ptr %701, i32 0, i32 1
  %703 = load double, ptr %702, align 8, !tbaa !15
  %704 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %705 = load double, ptr %704, align 8, !tbaa !15
  %706 = fmul double %703, %705
  %707 = fneg double %706
  %708 = call double @llvm.fmuladd.f64(double %695, double %697, double %707)
  %709 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %708, ptr %709, align 8, !tbaa !13
  %710 = load ptr, ptr %39, align 8, !tbaa !5
  %711 = load i32, ptr %65, align 4, !tbaa !9
  %712 = sext i32 %711 to i64
  %713 = getelementptr inbounds %struct.doublecomplex, ptr %710, i64 %712
  %714 = getelementptr inbounds %struct.doublecomplex, ptr %713, i32 0, i32 0
  %715 = load double, ptr %714, align 8, !tbaa !13
  %716 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %717 = load double, ptr %716, align 8, !tbaa !15
  %718 = load ptr, ptr %39, align 8, !tbaa !5
  %719 = load i32, ptr %65, align 4, !tbaa !9
  %720 = sext i32 %719 to i64
  %721 = getelementptr inbounds %struct.doublecomplex, ptr %718, i64 %720
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %721, i32 0, i32 1
  %723 = load double, ptr %722, align 8, !tbaa !15
  %724 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %725 = load double, ptr %724, align 8, !tbaa !13
  %726 = fmul double %723, %725
  %727 = call double @llvm.fmuladd.f64(double %715, double %717, double %726)
  %728 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %727, ptr %728, align 8, !tbaa !15
  %729 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %730 = load double, ptr %729, align 8, !tbaa !13
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %730, ptr %731, align 8, !tbaa !13
  %732 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %733 = load double, ptr %732, align 8, !tbaa !15
  %734 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %733, ptr %734, align 8, !tbaa !15
  %735 = load i32, ptr %99, align 4, !tbaa !9
  %736 = load i32, ptr %100, align 4, !tbaa !9
  %737 = add nsw i32 %736, 1
  %738 = load i32, ptr %49, align 4, !tbaa !9
  %739 = mul nsw i32 %737, %738
  %740 = add nsw i32 %735, %739
  store i32 %740, ptr %65, align 4, !tbaa !9
  %741 = load i32, ptr %99, align 4, !tbaa !9
  %742 = load i32, ptr %100, align 4, !tbaa !9
  %743 = add nsw i32 %742, 1
  %744 = load i32, ptr %49, align 4, !tbaa !9
  %745 = mul nsw i32 %743, %744
  %746 = add nsw i32 %741, %745
  store i32 %746, ptr %66, align 4, !tbaa !9
  %747 = load ptr, ptr %33, align 8, !tbaa !5
  %748 = load i32, ptr %66, align 4, !tbaa !9
  %749 = sext i32 %748 to i64
  %750 = getelementptr inbounds %struct.doublecomplex, ptr %747, i64 %749
  %751 = getelementptr inbounds %struct.doublecomplex, ptr %750, i32 0, i32 0
  %752 = load double, ptr %751, align 8, !tbaa !13
  %753 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %754 = load double, ptr %753, align 8, !tbaa !13
  %755 = fsub double %752, %754
  %756 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %755, ptr %756, align 8, !tbaa !13
  %757 = load ptr, ptr %33, align 8, !tbaa !5
  %758 = load i32, ptr %66, align 4, !tbaa !9
  %759 = sext i32 %758 to i64
  %760 = getelementptr inbounds %struct.doublecomplex, ptr %757, i64 %759
  %761 = getelementptr inbounds %struct.doublecomplex, ptr %760, i32 0, i32 1
  %762 = load double, ptr %761, align 8, !tbaa !15
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %764 = load double, ptr %763, align 8, !tbaa !15
  %765 = fsub double %762, %764
  %766 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %765, ptr %766, align 8, !tbaa !15
  %767 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %768 = load double, ptr %767, align 8, !tbaa !13
  %769 = load ptr, ptr %33, align 8, !tbaa !5
  %770 = load i32, ptr %65, align 4, !tbaa !9
  %771 = sext i32 %770 to i64
  %772 = getelementptr inbounds %struct.doublecomplex, ptr %769, i64 %771
  %773 = getelementptr inbounds %struct.doublecomplex, ptr %772, i32 0, i32 0
  store double %768, ptr %773, align 8, !tbaa !13
  %774 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %775 = load double, ptr %774, align 8, !tbaa !15
  %776 = load ptr, ptr %33, align 8, !tbaa !5
  %777 = load i32, ptr %65, align 4, !tbaa !9
  %778 = sext i32 %777 to i64
  %779 = getelementptr inbounds %struct.doublecomplex, ptr %776, i64 %778
  %780 = getelementptr inbounds %struct.doublecomplex, ptr %779, i32 0, i32 1
  store double %775, ptr %780, align 8, !tbaa !15
  %781 = load i32, ptr %99, align 4, !tbaa !9
  %782 = load i32, ptr %100, align 4, !tbaa !9
  %783 = add nsw i32 %782, 2
  %784 = load i32, ptr %49, align 4, !tbaa !9
  %785 = mul nsw i32 %783, %784
  %786 = add nsw i32 %781, %785
  store i32 %786, ptr %65, align 4, !tbaa !9
  %787 = load i32, ptr %99, align 4, !tbaa !9
  %788 = load i32, ptr %100, align 4, !tbaa !9
  %789 = add nsw i32 %788, 2
  %790 = load i32, ptr %49, align 4, !tbaa !9
  %791 = mul nsw i32 %789, %790
  %792 = add nsw i32 %787, %791
  store i32 %792, ptr %66, align 4, !tbaa !9
  %793 = load ptr, ptr %39, align 8, !tbaa !5
  %794 = load i32, ptr %115, align 4, !tbaa !9
  %795 = load i32, ptr %53, align 4, !tbaa !9
  %796 = mul nsw i32 %794, %795
  %797 = add nsw i32 %796, 2
  %798 = sext i32 %797 to i64
  %799 = getelementptr inbounds %struct.doublecomplex, ptr %793, i64 %798
  %800 = call { double, double } @Cd(ptr noundef %799)
  %801 = extractvalue { double, double } %800, 0
  %802 = extractvalue { double, double } %800, 1
  %803 = fneg double %802
  %804 = call ptr @_pCd(ptr noundef %84)
  %805 = getelementptr inbounds { double, double }, ptr %804, i32 0, i32 0
  %806 = getelementptr inbounds { double, double }, ptr %804, i32 0, i32 1
  store double %801, ptr %805, align 8
  store double %803, ptr %806, align 8
  %807 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %808 = load double, ptr %807, align 8, !tbaa !13
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %810 = load double, ptr %809, align 8, !tbaa !13
  %811 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %812 = load double, ptr %811, align 8, !tbaa !15
  %813 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %814 = load double, ptr %813, align 8, !tbaa !15
  %815 = fmul double %812, %814
  %816 = fneg double %815
  %817 = call double @llvm.fmuladd.f64(double %808, double %810, double %816)
  %818 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %817, ptr %818, align 8, !tbaa !13
  %819 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %820 = load double, ptr %819, align 8, !tbaa !13
  %821 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %822 = load double, ptr %821, align 8, !tbaa !15
  %823 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %824 = load double, ptr %823, align 8, !tbaa !15
  %825 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %826 = load double, ptr %825, align 8, !tbaa !13
  %827 = fmul double %824, %826
  %828 = call double @llvm.fmuladd.f64(double %820, double %822, double %827)
  %829 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %828, ptr %829, align 8, !tbaa !15
  %830 = load ptr, ptr %33, align 8, !tbaa !5
  %831 = load i32, ptr %66, align 4, !tbaa !9
  %832 = sext i32 %831 to i64
  %833 = getelementptr inbounds %struct.doublecomplex, ptr %830, i64 %832
  %834 = getelementptr inbounds %struct.doublecomplex, ptr %833, i32 0, i32 0
  %835 = load double, ptr %834, align 8, !tbaa !13
  %836 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %837 = load double, ptr %836, align 8, !tbaa !13
  %838 = fsub double %835, %837
  %839 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %838, ptr %839, align 8, !tbaa !13
  %840 = load ptr, ptr %33, align 8, !tbaa !5
  %841 = load i32, ptr %66, align 4, !tbaa !9
  %842 = sext i32 %841 to i64
  %843 = getelementptr inbounds %struct.doublecomplex, ptr %840, i64 %842
  %844 = getelementptr inbounds %struct.doublecomplex, ptr %843, i32 0, i32 1
  %845 = load double, ptr %844, align 8, !tbaa !15
  %846 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %847 = load double, ptr %846, align 8, !tbaa !15
  %848 = fsub double %845, %847
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %848, ptr %849, align 8, !tbaa !15
  %850 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %851 = load double, ptr %850, align 8, !tbaa !13
  %852 = load ptr, ptr %33, align 8, !tbaa !5
  %853 = load i32, ptr %65, align 4, !tbaa !9
  %854 = sext i32 %853 to i64
  %855 = getelementptr inbounds %struct.doublecomplex, ptr %852, i64 %854
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %855, i32 0, i32 0
  store double %851, ptr %856, align 8, !tbaa !13
  %857 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %858 = load double, ptr %857, align 8, !tbaa !15
  %859 = load ptr, ptr %33, align 8, !tbaa !5
  %860 = load i32, ptr %65, align 4, !tbaa !9
  %861 = sext i32 %860 to i64
  %862 = getelementptr inbounds %struct.doublecomplex, ptr %859, i64 %861
  %863 = getelementptr inbounds %struct.doublecomplex, ptr %862, i32 0, i32 1
  store double %858, ptr %863, align 8, !tbaa !15
  br label %864

864:                                              ; preds = %594
  %865 = load i32, ptr %99, align 4, !tbaa !9
  %866 = add nsw i32 %865, 1
  store i32 %866, ptr %99, align 4, !tbaa !9
  br label %590, !llvm.loop !16

867:                                              ; preds = %590
  %868 = load i32, ptr %103, align 4, !tbaa !9
  %869 = icmp ne i32 %868, 0
  br i1 %869, label %870, label %882

870:                                              ; preds = %867
  %871 = load i32, ptr %104, align 4, !tbaa !9
  %872 = load ptr, ptr %30, align 8, !tbaa !5
  %873 = load i32, ptr %872, align 4, !tbaa !9
  %874 = icmp sle i32 %871, %873
  br i1 %874, label %875, label %877

875:                                              ; preds = %870
  %876 = load i32, ptr %104, align 4, !tbaa !9
  br label %880

877:                                              ; preds = %870
  %878 = load ptr, ptr %30, align 8, !tbaa !5
  %879 = load i32, ptr %878, align 4, !tbaa !9
  br label %880

880:                                              ; preds = %877, %875
  %881 = phi i32 [ %876, %875 ], [ %879, %877 ]
  store i32 %881, ptr %94, align 4, !tbaa !9
  br label %893

882:                                              ; preds = %867
  %883 = load ptr, ptr %25, align 8, !tbaa !5
  %884 = load i32, ptr %883, align 4, !tbaa !9
  %885 = icmp ne i32 %884, 0
  br i1 %885, label %886, label %889

886:                                              ; preds = %882
  %887 = load ptr, ptr %28, align 8, !tbaa !5
  %888 = load i32, ptr %887, align 4, !tbaa !9
  store i32 %888, ptr %94, align 4, !tbaa !9
  br label %892

889:                                              ; preds = %882
  %890 = load ptr, ptr %30, align 8, !tbaa !5
  %891 = load i32, ptr %890, align 4, !tbaa !9
  store i32 %891, ptr %94, align 4, !tbaa !9
  br label %892

892:                                              ; preds = %889, %886
  br label %893

893:                                              ; preds = %892, %880
  %894 = load i32, ptr %94, align 4, !tbaa !9
  store i32 %894, ptr %64, align 4, !tbaa !9
  %895 = load i32, ptr %100, align 4, !tbaa !9
  %896 = add nsw i32 %895, 1
  store i32 %896, ptr %99, align 4, !tbaa !9
  br label %897

897:                                              ; preds = %1165, %893
  %898 = load i32, ptr %99, align 4, !tbaa !9
  %899 = load i32, ptr %64, align 4, !tbaa !9
  %900 = icmp sle i32 %898, %899
  br i1 %900, label %901, label %1168

901:                                              ; preds = %897
  %902 = load ptr, ptr %39, align 8, !tbaa !5
  %903 = load i32, ptr %115, align 4, !tbaa !9
  %904 = load i32, ptr %53, align 4, !tbaa !9
  %905 = mul nsw i32 %903, %904
  %906 = add nsw i32 %905, 1
  %907 = sext i32 %906 to i64
  %908 = getelementptr inbounds %struct.doublecomplex, ptr %902, i64 %907
  %909 = call { double, double } @Cd(ptr noundef %908)
  %910 = extractvalue { double, double } %909, 0
  %911 = extractvalue { double, double } %909, 1
  %912 = fneg double %911
  %913 = call ptr @_pCd(ptr noundef %83)
  %914 = getelementptr inbounds { double, double }, ptr %913, i32 0, i32 0
  %915 = getelementptr inbounds { double, double }, ptr %913, i32 0, i32 1
  store double %910, ptr %914, align 8
  store double %912, ptr %915, align 8
  %916 = load i32, ptr %100, align 4, !tbaa !9
  %917 = add nsw i32 %916, 1
  %918 = load i32, ptr %99, align 4, !tbaa !9
  %919 = load i32, ptr %49, align 4, !tbaa !9
  %920 = mul nsw i32 %918, %919
  %921 = add nsw i32 %917, %920
  store i32 %921, ptr %65, align 4, !tbaa !9
  %922 = load ptr, ptr %39, align 8, !tbaa !5
  %923 = load i32, ptr %115, align 4, !tbaa !9
  %924 = load i32, ptr %53, align 4, !tbaa !9
  %925 = mul nsw i32 %923, %924
  %926 = add nsw i32 %925, 2
  %927 = sext i32 %926 to i64
  %928 = getelementptr inbounds %struct.doublecomplex, ptr %922, i64 %927
  %929 = call { double, double } @Cd(ptr noundef %928)
  %930 = extractvalue { double, double } %929, 0
  %931 = extractvalue { double, double } %929, 1
  %932 = fneg double %931
  %933 = call ptr @_pCd(ptr noundef %86)
  %934 = getelementptr inbounds { double, double }, ptr %933, i32 0, i32 0
  %935 = getelementptr inbounds { double, double }, ptr %933, i32 0, i32 1
  store double %930, ptr %934, align 8
  store double %932, ptr %935, align 8
  %936 = load i32, ptr %100, align 4, !tbaa !9
  %937 = add nsw i32 %936, 2
  %938 = load i32, ptr %99, align 4, !tbaa !9
  %939 = load i32, ptr %49, align 4, !tbaa !9
  %940 = mul nsw i32 %938, %939
  %941 = add nsw i32 %937, %940
  store i32 %941, ptr %66, align 4, !tbaa !9
  %942 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %943 = load double, ptr %942, align 8, !tbaa !13
  %944 = load ptr, ptr %33, align 8, !tbaa !5
  %945 = load i32, ptr %66, align 4, !tbaa !9
  %946 = sext i32 %945 to i64
  %947 = getelementptr inbounds %struct.doublecomplex, ptr %944, i64 %946
  %948 = getelementptr inbounds %struct.doublecomplex, ptr %947, i32 0, i32 0
  %949 = load double, ptr %948, align 8, !tbaa !13
  %950 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %951 = load double, ptr %950, align 8, !tbaa !15
  %952 = load ptr, ptr %33, align 8, !tbaa !5
  %953 = load i32, ptr %66, align 4, !tbaa !9
  %954 = sext i32 %953 to i64
  %955 = getelementptr inbounds %struct.doublecomplex, ptr %952, i64 %954
  %956 = getelementptr inbounds %struct.doublecomplex, ptr %955, i32 0, i32 1
  %957 = load double, ptr %956, align 8, !tbaa !15
  %958 = fmul double %951, %957
  %959 = fneg double %958
  %960 = call double @llvm.fmuladd.f64(double %943, double %949, double %959)
  %961 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %960, ptr %961, align 8, !tbaa !13
  %962 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %963 = load double, ptr %962, align 8, !tbaa !13
  %964 = load ptr, ptr %33, align 8, !tbaa !5
  %965 = load i32, ptr %66, align 4, !tbaa !9
  %966 = sext i32 %965 to i64
  %967 = getelementptr inbounds %struct.doublecomplex, ptr %964, i64 %966
  %968 = getelementptr inbounds %struct.doublecomplex, ptr %967, i32 0, i32 1
  %969 = load double, ptr %968, align 8, !tbaa !15
  %970 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %971 = load double, ptr %970, align 8, !tbaa !15
  %972 = load ptr, ptr %33, align 8, !tbaa !5
  %973 = load i32, ptr %66, align 4, !tbaa !9
  %974 = sext i32 %973 to i64
  %975 = getelementptr inbounds %struct.doublecomplex, ptr %972, i64 %974
  %976 = getelementptr inbounds %struct.doublecomplex, ptr %975, i32 0, i32 0
  %977 = load double, ptr %976, align 8, !tbaa !13
  %978 = fmul double %971, %977
  %979 = call double @llvm.fmuladd.f64(double %963, double %969, double %978)
  %980 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %979, ptr %980, align 8, !tbaa !15
  %981 = load ptr, ptr %33, align 8, !tbaa !5
  %982 = load i32, ptr %65, align 4, !tbaa !9
  %983 = sext i32 %982 to i64
  %984 = getelementptr inbounds %struct.doublecomplex, ptr %981, i64 %983
  %985 = getelementptr inbounds %struct.doublecomplex, ptr %984, i32 0, i32 0
  %986 = load double, ptr %985, align 8, !tbaa !13
  %987 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %988 = load double, ptr %987, align 8, !tbaa !13
  %989 = fadd double %986, %988
  %990 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %989, ptr %990, align 8, !tbaa !13
  %991 = load ptr, ptr %33, align 8, !tbaa !5
  %992 = load i32, ptr %65, align 4, !tbaa !9
  %993 = sext i32 %992 to i64
  %994 = getelementptr inbounds %struct.doublecomplex, ptr %991, i64 %993
  %995 = getelementptr inbounds %struct.doublecomplex, ptr %994, i32 0, i32 1
  %996 = load double, ptr %995, align 8, !tbaa !15
  %997 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %998 = load double, ptr %997, align 8, !tbaa !15
  %999 = fadd double %996, %998
  %1000 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %999, ptr %1000, align 8, !tbaa !15
  %1001 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %1002 = load double, ptr %1001, align 8, !tbaa !13
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1004 = load double, ptr %1003, align 8, !tbaa !13
  %1005 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %1006 = load double, ptr %1005, align 8, !tbaa !15
  %1007 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %1008 = load double, ptr %1007, align 8, !tbaa !15
  %1009 = fmul double %1006, %1008
  %1010 = fneg double %1009
  %1011 = call double @llvm.fmuladd.f64(double %1002, double %1004, double %1010)
  %1012 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %1011, ptr %1012, align 8, !tbaa !13
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %1014 = load double, ptr %1013, align 8, !tbaa !13
  %1015 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %1016 = load double, ptr %1015, align 8, !tbaa !15
  %1017 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %1018 = load double, ptr %1017, align 8, !tbaa !15
  %1019 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %1020 = load double, ptr %1019, align 8, !tbaa !13
  %1021 = fmul double %1018, %1020
  %1022 = call double @llvm.fmuladd.f64(double %1014, double %1016, double %1021)
  %1023 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %1022, ptr %1023, align 8, !tbaa !15
  %1024 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %1025 = load double, ptr %1024, align 8, !tbaa !13
  %1026 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %1025, ptr %1026, align 8, !tbaa !13
  %1027 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %1028 = load double, ptr %1027, align 8, !tbaa !15
  %1029 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %1028, ptr %1029, align 8, !tbaa !15
  %1030 = load i32, ptr %100, align 4, !tbaa !9
  %1031 = add nsw i32 %1030, 1
  %1032 = load i32, ptr %99, align 4, !tbaa !9
  %1033 = load i32, ptr %49, align 4, !tbaa !9
  %1034 = mul nsw i32 %1032, %1033
  %1035 = add nsw i32 %1031, %1034
  store i32 %1035, ptr %65, align 4, !tbaa !9
  %1036 = load i32, ptr %100, align 4, !tbaa !9
  %1037 = add nsw i32 %1036, 1
  %1038 = load i32, ptr %99, align 4, !tbaa !9
  %1039 = load i32, ptr %49, align 4, !tbaa !9
  %1040 = mul nsw i32 %1038, %1039
  %1041 = add nsw i32 %1037, %1040
  store i32 %1041, ptr %66, align 4, !tbaa !9
  %1042 = load ptr, ptr %33, align 8, !tbaa !5
  %1043 = load i32, ptr %66, align 4, !tbaa !9
  %1044 = sext i32 %1043 to i64
  %1045 = getelementptr inbounds %struct.doublecomplex, ptr %1042, i64 %1044
  %1046 = getelementptr inbounds %struct.doublecomplex, ptr %1045, i32 0, i32 0
  %1047 = load double, ptr %1046, align 8, !tbaa !13
  %1048 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %1049 = load double, ptr %1048, align 8, !tbaa !13
  %1050 = fsub double %1047, %1049
  %1051 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %1050, ptr %1051, align 8, !tbaa !13
  %1052 = load ptr, ptr %33, align 8, !tbaa !5
  %1053 = load i32, ptr %66, align 4, !tbaa !9
  %1054 = sext i32 %1053 to i64
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %1052, i64 %1054
  %1056 = getelementptr inbounds %struct.doublecomplex, ptr %1055, i32 0, i32 1
  %1057 = load double, ptr %1056, align 8, !tbaa !15
  %1058 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %1059 = load double, ptr %1058, align 8, !tbaa !15
  %1060 = fsub double %1057, %1059
  %1061 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %1060, ptr %1061, align 8, !tbaa !15
  %1062 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %1063 = load double, ptr %1062, align 8, !tbaa !13
  %1064 = load ptr, ptr %33, align 8, !tbaa !5
  %1065 = load i32, ptr %65, align 4, !tbaa !9
  %1066 = sext i32 %1065 to i64
  %1067 = getelementptr inbounds %struct.doublecomplex, ptr %1064, i64 %1066
  %1068 = getelementptr inbounds %struct.doublecomplex, ptr %1067, i32 0, i32 0
  store double %1063, ptr %1068, align 8, !tbaa !13
  %1069 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %1070 = load double, ptr %1069, align 8, !tbaa !15
  %1071 = load ptr, ptr %33, align 8, !tbaa !5
  %1072 = load i32, ptr %65, align 4, !tbaa !9
  %1073 = sext i32 %1072 to i64
  %1074 = getelementptr inbounds %struct.doublecomplex, ptr %1071, i64 %1073
  %1075 = getelementptr inbounds %struct.doublecomplex, ptr %1074, i32 0, i32 1
  store double %1070, ptr %1075, align 8, !tbaa !15
  %1076 = load i32, ptr %100, align 4, !tbaa !9
  %1077 = add nsw i32 %1076, 2
  %1078 = load i32, ptr %99, align 4, !tbaa !9
  %1079 = load i32, ptr %49, align 4, !tbaa !9
  %1080 = mul nsw i32 %1078, %1079
  %1081 = add nsw i32 %1077, %1080
  store i32 %1081, ptr %65, align 4, !tbaa !9
  %1082 = load i32, ptr %100, align 4, !tbaa !9
  %1083 = add nsw i32 %1082, 2
  %1084 = load i32, ptr %99, align 4, !tbaa !9
  %1085 = load i32, ptr %49, align 4, !tbaa !9
  %1086 = mul nsw i32 %1084, %1085
  %1087 = add nsw i32 %1083, %1086
  store i32 %1087, ptr %66, align 4, !tbaa !9
  %1088 = load i32, ptr %115, align 4, !tbaa !9
  %1089 = load i32, ptr %53, align 4, !tbaa !9
  %1090 = mul nsw i32 %1088, %1089
  %1091 = add nsw i32 %1090, 2
  store i32 %1091, ptr %67, align 4, !tbaa !9
  %1092 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %1093 = load double, ptr %1092, align 8, !tbaa !13
  %1094 = load ptr, ptr %39, align 8, !tbaa !5
  %1095 = load i32, ptr %67, align 4, !tbaa !9
  %1096 = sext i32 %1095 to i64
  %1097 = getelementptr inbounds %struct.doublecomplex, ptr %1094, i64 %1096
  %1098 = getelementptr inbounds %struct.doublecomplex, ptr %1097, i32 0, i32 0
  %1099 = load double, ptr %1098, align 8, !tbaa !13
  %1100 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %1101 = load double, ptr %1100, align 8, !tbaa !15
  %1102 = load ptr, ptr %39, align 8, !tbaa !5
  %1103 = load i32, ptr %67, align 4, !tbaa !9
  %1104 = sext i32 %1103 to i64
  %1105 = getelementptr inbounds %struct.doublecomplex, ptr %1102, i64 %1104
  %1106 = getelementptr inbounds %struct.doublecomplex, ptr %1105, i32 0, i32 1
  %1107 = load double, ptr %1106, align 8, !tbaa !15
  %1108 = fmul double %1101, %1107
  %1109 = fneg double %1108
  %1110 = call double @llvm.fmuladd.f64(double %1093, double %1099, double %1109)
  %1111 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %1110, ptr %1111, align 8, !tbaa !13
  %1112 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %1113 = load double, ptr %1112, align 8, !tbaa !13
  %1114 = load ptr, ptr %39, align 8, !tbaa !5
  %1115 = load i32, ptr %67, 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 !15
  %1120 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %1121 = load double, ptr %1120, align 8, !tbaa !15
  %1122 = load ptr, ptr %39, align 8, !tbaa !5
  %1123 = load i32, ptr %67, align 4, !tbaa !9
  %1124 = sext i32 %1123 to i64
  %1125 = getelementptr inbounds %struct.doublecomplex, ptr %1122, i64 %1124
  %1126 = getelementptr inbounds %struct.doublecomplex, ptr %1125, i32 0, i32 0
  %1127 = load double, ptr %1126, align 8, !tbaa !13
  %1128 = fmul double %1121, %1127
  %1129 = call double @llvm.fmuladd.f64(double %1113, double %1119, double %1128)
  %1130 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %1129, ptr %1130, align 8, !tbaa !15
  %1131 = load ptr, ptr %33, align 8, !tbaa !5
  %1132 = load i32, ptr %66, align 4, !tbaa !9
  %1133 = sext i32 %1132 to i64
  %1134 = getelementptr inbounds %struct.doublecomplex, ptr %1131, i64 %1133
  %1135 = getelementptr inbounds %struct.doublecomplex, ptr %1134, i32 0, i32 0
  %1136 = load double, ptr %1135, align 8, !tbaa !13
  %1137 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %1138 = load double, ptr %1137, align 8, !tbaa !13
  %1139 = fsub double %1136, %1138
  %1140 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %1139, ptr %1140, align 8, !tbaa !13
  %1141 = load ptr, ptr %33, align 8, !tbaa !5
  %1142 = load i32, ptr %66, align 4, !tbaa !9
  %1143 = sext i32 %1142 to i64
  %1144 = getelementptr inbounds %struct.doublecomplex, ptr %1141, i64 %1143
  %1145 = getelementptr inbounds %struct.doublecomplex, ptr %1144, i32 0, i32 1
  %1146 = load double, ptr %1145, align 8, !tbaa !15
  %1147 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %1148 = load double, ptr %1147, align 8, !tbaa !15
  %1149 = fsub double %1146, %1148
  %1150 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %1149, ptr %1150, align 8, !tbaa !15
  %1151 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %1152 = load double, ptr %1151, align 8, !tbaa !13
  %1153 = load ptr, ptr %33, align 8, !tbaa !5
  %1154 = load i32, ptr %65, align 4, !tbaa !9
  %1155 = sext i32 %1154 to i64
  %1156 = getelementptr inbounds %struct.doublecomplex, ptr %1153, i64 %1155
  %1157 = getelementptr inbounds %struct.doublecomplex, ptr %1156, i32 0, i32 0
  store double %1152, ptr %1157, align 8, !tbaa !13
  %1158 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %1159 = load double, ptr %1158, align 8, !tbaa !15
  %1160 = load ptr, ptr %33, align 8, !tbaa !5
  %1161 = load i32, ptr %65, align 4, !tbaa !9
  %1162 = sext i32 %1161 to i64
  %1163 = getelementptr inbounds %struct.doublecomplex, ptr %1160, i64 %1162
  %1164 = getelementptr inbounds %struct.doublecomplex, ptr %1163, i32 0, i32 1
  store double %1159, ptr %1164, align 8, !tbaa !15
  br label %1165

1165:                                             ; preds = %901
  %1166 = load i32, ptr %99, align 4, !tbaa !9
  %1167 = add nsw i32 %1166, 1
  store i32 %1167, ptr %99, align 4, !tbaa !9
  br label %897, !llvm.loop !18

1168:                                             ; preds = %897
  %1169 = load i32, ptr %100, align 4, !tbaa !9
  %1170 = load ptr, ptr %29, align 8, !tbaa !5
  %1171 = load i32, ptr %1170, align 4, !tbaa !9
  %1172 = icmp sge i32 %1169, %1171
  br i1 %1172, label %1173, label %2151

1173:                                             ; preds = %1168
  %1174 = load i32, ptr %100, align 4, !tbaa !9
  %1175 = add nsw i32 %1174, 1
  %1176 = load i32, ptr %100, align 4, !tbaa !9
  %1177 = load i32, ptr %49, align 4, !tbaa !9
  %1178 = mul nsw i32 %1176, %1177
  %1179 = add nsw i32 %1175, %1178
  store i32 %1179, ptr %64, align 4, !tbaa !9
  %1180 = load ptr, ptr %33, align 8, !tbaa !5
  %1181 = load i32, ptr %64, align 4, !tbaa !9
  %1182 = sext i32 %1181 to i64
  %1183 = getelementptr inbounds %struct.doublecomplex, ptr %1180, i64 %1182
  %1184 = getelementptr inbounds %struct.doublecomplex, ptr %1183, i32 0, i32 0
  %1185 = load double, ptr %1184, align 8, !tbaa !13
  %1186 = fcmp une double %1185, 0.000000e+00
  br i1 %1186, label %1195, label %1187

1187:                                             ; preds = %1173
  %1188 = load ptr, ptr %33, align 8, !tbaa !5
  %1189 = load i32, ptr %64, align 4, !tbaa !9
  %1190 = sext i32 %1189 to i64
  %1191 = getelementptr inbounds %struct.doublecomplex, ptr %1188, i64 %1190
  %1192 = getelementptr inbounds %struct.doublecomplex, ptr %1191, i32 0, i32 1
  %1193 = load double, ptr %1192, align 8, !tbaa !15
  %1194 = fcmp une double %1193, 0.000000e+00
  br i1 %1194, label %1195, label %2150

1195:                                             ; preds = %1187, %1173
  %1196 = load i32, ptr %100, align 4, !tbaa !9
  %1197 = load i32, ptr %100, align 4, !tbaa !9
  %1198 = load i32, ptr %49, align 4, !tbaa !9
  %1199 = mul nsw i32 %1197, %1198
  %1200 = add nsw i32 %1196, %1199
  store i32 %1200, ptr %64, align 4, !tbaa !9
  %1201 = load i32, ptr %100, align 4, !tbaa !9
  %1202 = add nsw i32 %1201, 1
  %1203 = load i32, ptr %100, align 4, !tbaa !9
  %1204 = add nsw i32 %1203, 1
  %1205 = load i32, ptr %49, align 4, !tbaa !9
  %1206 = mul nsw i32 %1204, %1205
  %1207 = add nsw i32 %1202, %1206
  store i32 %1207, ptr %65, align 4, !tbaa !9
  %1208 = load ptr, ptr %33, align 8, !tbaa !5
  %1209 = load i32, ptr %64, align 4, !tbaa !9
  %1210 = sext i32 %1209 to i64
  %1211 = getelementptr inbounds %struct.doublecomplex, ptr %1208, i64 %1210
  %1212 = getelementptr inbounds %struct.doublecomplex, ptr %1211, i32 0, i32 0
  %1213 = load double, ptr %1212, align 8, !tbaa !13
  store double %1213, ptr %72, align 8, !tbaa !11
  %1214 = load double, ptr %72, align 8, !tbaa !11
  %1215 = fcmp oge double %1214, 0.000000e+00
  br i1 %1215, label %1216, label %1218

1216:                                             ; preds = %1195
  %1217 = load double, ptr %72, align 8, !tbaa !11
  br label %1221

1218:                                             ; preds = %1195
  %1219 = load double, ptr %72, align 8, !tbaa !11
  %1220 = fneg double %1219
  br label %1221

1221:                                             ; preds = %1218, %1216
  %1222 = phi double [ %1217, %1216 ], [ %1220, %1218 ]
  %1223 = load ptr, ptr %33, align 8, !tbaa !5
  %1224 = load i32, ptr %100, align 4, !tbaa !9
  %1225 = load i32, ptr %100, align 4, !tbaa !9
  %1226 = load i32, ptr %49, align 4, !tbaa !9
  %1227 = mul nsw i32 %1225, %1226
  %1228 = add nsw i32 %1224, %1227
  %1229 = sext i32 %1228 to i64
  %1230 = getelementptr inbounds %struct.doublecomplex, ptr %1223, i64 %1229
  %1231 = call { double, double } @Cd(ptr noundef %1230)
  %1232 = extractvalue { double, double } %1231, 0
  %1233 = extractvalue { double, double } %1231, 1
  store double %1233, ptr %73, align 8, !tbaa !11
  %1234 = load double, ptr %73, align 8, !tbaa !11
  %1235 = fcmp oge double %1234, 0.000000e+00
  br i1 %1235, label %1236, label %1238

1236:                                             ; preds = %1221
  %1237 = load double, ptr %73, align 8, !tbaa !11
  br label %1241

1238:                                             ; preds = %1221
  %1239 = load double, ptr %73, align 8, !tbaa !11
  %1240 = fneg double %1239
  br label %1241

1241:                                             ; preds = %1238, %1236
  %1242 = phi double [ %1237, %1236 ], [ %1240, %1238 ]
  %1243 = fadd double %1222, %1242
  %1244 = load ptr, ptr %33, align 8, !tbaa !5
  %1245 = load i32, ptr %65, align 4, !tbaa !9
  %1246 = sext i32 %1245 to i64
  %1247 = getelementptr inbounds %struct.doublecomplex, ptr %1244, i64 %1246
  %1248 = getelementptr inbounds %struct.doublecomplex, ptr %1247, i32 0, i32 0
  %1249 = load double, ptr %1248, align 8, !tbaa !13
  store double %1249, ptr %74, align 8, !tbaa !11
  %1250 = load double, ptr %74, align 8, !tbaa !11
  %1251 = fcmp oge double %1250, 0.000000e+00
  br i1 %1251, label %1252, label %1254

1252:                                             ; preds = %1241
  %1253 = load double, ptr %74, align 8, !tbaa !11
  br label %1257

1254:                                             ; preds = %1241
  %1255 = load double, ptr %74, align 8, !tbaa !11
  %1256 = fneg double %1255
  br label %1257

1257:                                             ; preds = %1254, %1252
  %1258 = phi double [ %1253, %1252 ], [ %1256, %1254 ]
  %1259 = load ptr, ptr %33, align 8, !tbaa !5
  %1260 = load i32, ptr %100, align 4, !tbaa !9
  %1261 = add nsw i32 %1260, 1
  %1262 = load i32, ptr %100, align 4, !tbaa !9
  %1263 = add nsw i32 %1262, 1
  %1264 = load i32, ptr %49, align 4, !tbaa !9
  %1265 = mul nsw i32 %1263, %1264
  %1266 = add nsw i32 %1261, %1265
  %1267 = sext i32 %1266 to i64
  %1268 = getelementptr inbounds %struct.doublecomplex, ptr %1259, i64 %1267
  %1269 = call { double, double } @Cd(ptr noundef %1268)
  %1270 = extractvalue { double, double } %1269, 0
  %1271 = extractvalue { double, double } %1269, 1
  store double %1271, ptr %75, align 8, !tbaa !11
  %1272 = load double, ptr %75, align 8, !tbaa !11
  %1273 = fcmp oge double %1272, 0.000000e+00
  br i1 %1273, label %1274, label %1276

1274:                                             ; preds = %1257
  %1275 = load double, ptr %75, align 8, !tbaa !11
  br label %1279

1276:                                             ; preds = %1257
  %1277 = load double, ptr %75, align 8, !tbaa !11
  %1278 = fneg double %1277
  br label %1279

1279:                                             ; preds = %1276, %1274
  %1280 = phi double [ %1275, %1274 ], [ %1278, %1276 ]
  %1281 = fadd double %1258, %1280
  %1282 = fadd double %1243, %1281
  store double %1282, ptr %127, align 8, !tbaa !11
  %1283 = load double, ptr %127, align 8, !tbaa !11
  %1284 = fcmp oeq double %1283, 0.000000e+00
  br i1 %1284, label %1285, label %1604

1285:                                             ; preds = %1279
  %1286 = load i32, ptr %100, align 4, !tbaa !9
  %1287 = load ptr, ptr %29, align 8, !tbaa !5
  %1288 = load i32, ptr %1287, align 4, !tbaa !9
  %1289 = add nsw i32 %1288, 1
  %1290 = icmp sge i32 %1286, %1289
  br i1 %1290, label %1291, label %1337

1291:                                             ; preds = %1285
  %1292 = load i32, ptr %100, align 4, !tbaa !9
  %1293 = load i32, ptr %100, align 4, !tbaa !9
  %1294 = sub nsw i32 %1293, 1
  %1295 = load i32, ptr %49, align 4, !tbaa !9
  %1296 = mul nsw i32 %1294, %1295
  %1297 = add nsw i32 %1292, %1296
  store i32 %1297, ptr %64, align 4, !tbaa !9
  %1298 = load ptr, ptr %33, align 8, !tbaa !5
  %1299 = load i32, ptr %64, align 4, !tbaa !9
  %1300 = sext i32 %1299 to i64
  %1301 = getelementptr inbounds %struct.doublecomplex, ptr %1298, i64 %1300
  %1302 = getelementptr inbounds %struct.doublecomplex, ptr %1301, i32 0, i32 0
  %1303 = load double, ptr %1302, align 8, !tbaa !13
  store double %1303, ptr %72, align 8, !tbaa !11
  %1304 = load double, ptr %72, align 8, !tbaa !11
  %1305 = fcmp oge double %1304, 0.000000e+00
  br i1 %1305, label %1306, label %1308

1306:                                             ; preds = %1291
  %1307 = load double, ptr %72, align 8, !tbaa !11
  br label %1311

1308:                                             ; preds = %1291
  %1309 = load double, ptr %72, align 8, !tbaa !11
  %1310 = fneg double %1309
  br label %1311

1311:                                             ; preds = %1308, %1306
  %1312 = phi double [ %1307, %1306 ], [ %1310, %1308 ]
  %1313 = load ptr, ptr %33, align 8, !tbaa !5
  %1314 = load i32, ptr %100, align 4, !tbaa !9
  %1315 = load i32, ptr %100, align 4, !tbaa !9
  %1316 = sub nsw i32 %1315, 1
  %1317 = load i32, ptr %49, align 4, !tbaa !9
  %1318 = mul nsw i32 %1316, %1317
  %1319 = add nsw i32 %1314, %1318
  %1320 = sext i32 %1319 to i64
  %1321 = getelementptr inbounds %struct.doublecomplex, ptr %1313, i64 %1320
  %1322 = call { double, double } @Cd(ptr noundef %1321)
  %1323 = extractvalue { double, double } %1322, 0
  %1324 = extractvalue { double, double } %1322, 1
  store double %1324, ptr %73, align 8, !tbaa !11
  %1325 = load double, ptr %73, align 8, !tbaa !11
  %1326 = fcmp oge double %1325, 0.000000e+00
  br i1 %1326, label %1327, label %1329

1327:                                             ; preds = %1311
  %1328 = load double, ptr %73, align 8, !tbaa !11
  br label %1332

1329:                                             ; preds = %1311
  %1330 = load double, ptr %73, align 8, !tbaa !11
  %1331 = fneg double %1330
  br label %1332

1332:                                             ; preds = %1329, %1327
  %1333 = phi double [ %1328, %1327 ], [ %1331, %1329 ]
  %1334 = fadd double %1312, %1333
  %1335 = load double, ptr %127, align 8, !tbaa !11
  %1336 = fadd double %1335, %1334
  store double %1336, ptr %127, align 8, !tbaa !11
  br label %1337

1337:                                             ; preds = %1332, %1285
  %1338 = load i32, ptr %100, align 4, !tbaa !9
  %1339 = load ptr, ptr %29, align 8, !tbaa !5
  %1340 = load i32, ptr %1339, align 4, !tbaa !9
  %1341 = add nsw i32 %1340, 2
  %1342 = icmp sge i32 %1338, %1341
  br i1 %1342, label %1343, label %1389

1343:                                             ; preds = %1337
  %1344 = load i32, ptr %100, align 4, !tbaa !9
  %1345 = load i32, ptr %100, align 4, !tbaa !9
  %1346 = sub nsw i32 %1345, 2
  %1347 = load i32, ptr %49, align 4, !tbaa !9
  %1348 = mul nsw i32 %1346, %1347
  %1349 = add nsw i32 %1344, %1348
  store i32 %1349, ptr %64, align 4, !tbaa !9
  %1350 = load ptr, ptr %33, align 8, !tbaa !5
  %1351 = load i32, ptr %64, align 4, !tbaa !9
  %1352 = sext i32 %1351 to i64
  %1353 = getelementptr inbounds %struct.doublecomplex, ptr %1350, i64 %1352
  %1354 = getelementptr inbounds %struct.doublecomplex, ptr %1353, i32 0, i32 0
  %1355 = load double, ptr %1354, align 8, !tbaa !13
  store double %1355, ptr %72, align 8, !tbaa !11
  %1356 = load double, ptr %72, align 8, !tbaa !11
  %1357 = fcmp oge double %1356, 0.000000e+00
  br i1 %1357, label %1358, label %1360

1358:                                             ; preds = %1343
  %1359 = load double, ptr %72, align 8, !tbaa !11
  br label %1363

1360:                                             ; preds = %1343
  %1361 = load double, ptr %72, align 8, !tbaa !11
  %1362 = fneg double %1361
  br label %1363

1363:                                             ; preds = %1360, %1358
  %1364 = phi double [ %1359, %1358 ], [ %1362, %1360 ]
  %1365 = load ptr, ptr %33, align 8, !tbaa !5
  %1366 = load i32, ptr %100, align 4, !tbaa !9
  %1367 = load i32, ptr %100, align 4, !tbaa !9
  %1368 = sub nsw i32 %1367, 2
  %1369 = load i32, ptr %49, align 4, !tbaa !9
  %1370 = mul nsw i32 %1368, %1369
  %1371 = add nsw i32 %1366, %1370
  %1372 = sext i32 %1371 to i64
  %1373 = getelementptr inbounds %struct.doublecomplex, ptr %1365, i64 %1372
  %1374 = call { double, double } @Cd(ptr noundef %1373)
  %1375 = extractvalue { double, double } %1374, 0
  %1376 = extractvalue { double, double } %1374, 1
  store double %1376, ptr %73, align 8, !tbaa !11
  %1377 = load double, ptr %73, align 8, !tbaa !11
  %1378 = fcmp oge double %1377, 0.000000e+00
  br i1 %1378, label %1379, label %1381

1379:                                             ; preds = %1363
  %1380 = load double, ptr %73, align 8, !tbaa !11
  br label %1384

1381:                                             ; preds = %1363
  %1382 = load double, ptr %73, align 8, !tbaa !11
  %1383 = fneg double %1382
  br label %1384

1384:                                             ; preds = %1381, %1379
  %1385 = phi double [ %1380, %1379 ], [ %1383, %1381 ]
  %1386 = fadd double %1364, %1385
  %1387 = load double, ptr %127, align 8, !tbaa !11
  %1388 = fadd double %1387, %1386
  store double %1388, ptr %127, align 8, !tbaa !11
  br label %1389

1389:                                             ; preds = %1384, %1337
  %1390 = load i32, ptr %100, align 4, !tbaa !9
  %1391 = load ptr, ptr %29, align 8, !tbaa !5
  %1392 = load i32, ptr %1391, align 4, !tbaa !9
  %1393 = add nsw i32 %1392, 3
  %1394 = icmp sge i32 %1390, %1393
  br i1 %1394, label %1395, label %1441

1395:                                             ; preds = %1389
  %1396 = load i32, ptr %100, align 4, !tbaa !9
  %1397 = load i32, ptr %100, align 4, !tbaa !9
  %1398 = sub nsw i32 %1397, 3
  %1399 = load i32, ptr %49, align 4, !tbaa !9
  %1400 = mul nsw i32 %1398, %1399
  %1401 = add nsw i32 %1396, %1400
  store i32 %1401, ptr %64, align 4, !tbaa !9
  %1402 = load ptr, ptr %33, align 8, !tbaa !5
  %1403 = load i32, ptr %64, align 4, !tbaa !9
  %1404 = sext i32 %1403 to i64
  %1405 = getelementptr inbounds %struct.doublecomplex, ptr %1402, i64 %1404
  %1406 = getelementptr inbounds %struct.doublecomplex, ptr %1405, i32 0, i32 0
  %1407 = load double, ptr %1406, align 8, !tbaa !13
  store double %1407, ptr %72, align 8, !tbaa !11
  %1408 = load double, ptr %72, align 8, !tbaa !11
  %1409 = fcmp oge double %1408, 0.000000e+00
  br i1 %1409, label %1410, label %1412

1410:                                             ; preds = %1395
  %1411 = load double, ptr %72, align 8, !tbaa !11
  br label %1415

1412:                                             ; preds = %1395
  %1413 = load double, ptr %72, align 8, !tbaa !11
  %1414 = fneg double %1413
  br label %1415

1415:                                             ; preds = %1412, %1410
  %1416 = phi double [ %1411, %1410 ], [ %1414, %1412 ]
  %1417 = load ptr, ptr %33, align 8, !tbaa !5
  %1418 = load i32, ptr %100, align 4, !tbaa !9
  %1419 = load i32, ptr %100, align 4, !tbaa !9
  %1420 = sub nsw i32 %1419, 3
  %1421 = load i32, ptr %49, align 4, !tbaa !9
  %1422 = mul nsw i32 %1420, %1421
  %1423 = add nsw i32 %1418, %1422
  %1424 = sext i32 %1423 to i64
  %1425 = getelementptr inbounds %struct.doublecomplex, ptr %1417, i64 %1424
  %1426 = call { double, double } @Cd(ptr noundef %1425)
  %1427 = extractvalue { double, double } %1426, 0
  %1428 = extractvalue { double, double } %1426, 1
  store double %1428, ptr %73, align 8, !tbaa !11
  %1429 = load double, ptr %73, align 8, !tbaa !11
  %1430 = fcmp oge double %1429, 0.000000e+00
  br i1 %1430, label %1431, label %1433

1431:                                             ; preds = %1415
  %1432 = load double, ptr %73, align 8, !tbaa !11
  br label %1436

1433:                                             ; preds = %1415
  %1434 = load double, ptr %73, align 8, !tbaa !11
  %1435 = fneg double %1434
  br label %1436

1436:                                             ; preds = %1433, %1431
  %1437 = phi double [ %1432, %1431 ], [ %1435, %1433 ]
  %1438 = fadd double %1416, %1437
  %1439 = load double, ptr %127, align 8, !tbaa !11
  %1440 = fadd double %1439, %1438
  store double %1440, ptr %127, align 8, !tbaa !11
  br label %1441

1441:                                             ; preds = %1436, %1389
  %1442 = load i32, ptr %100, align 4, !tbaa !9
  %1443 = load ptr, ptr %30, align 8, !tbaa !5
  %1444 = load i32, ptr %1443, align 4, !tbaa !9
  %1445 = sub nsw i32 %1444, 2
  %1446 = icmp sle i32 %1442, %1445
  br i1 %1446, label %1447, label %1495

1447:                                             ; preds = %1441
  %1448 = load i32, ptr %100, align 4, !tbaa !9
  %1449 = add nsw i32 %1448, 2
  %1450 = load i32, ptr %100, align 4, !tbaa !9
  %1451 = add nsw i32 %1450, 1
  %1452 = load i32, ptr %49, align 4, !tbaa !9
  %1453 = mul nsw i32 %1451, %1452
  %1454 = add nsw i32 %1449, %1453
  store i32 %1454, ptr %64, align 4, !tbaa !9
  %1455 = load ptr, ptr %33, align 8, !tbaa !5
  %1456 = load i32, ptr %64, align 4, !tbaa !9
  %1457 = sext i32 %1456 to i64
  %1458 = getelementptr inbounds %struct.doublecomplex, ptr %1455, i64 %1457
  %1459 = getelementptr inbounds %struct.doublecomplex, ptr %1458, i32 0, i32 0
  %1460 = load double, ptr %1459, align 8, !tbaa !13
  store double %1460, ptr %72, align 8, !tbaa !11
  %1461 = load double, ptr %72, align 8, !tbaa !11
  %1462 = fcmp oge double %1461, 0.000000e+00
  br i1 %1462, label %1463, label %1465

1463:                                             ; preds = %1447
  %1464 = load double, ptr %72, align 8, !tbaa !11
  br label %1468

1465:                                             ; preds = %1447
  %1466 = load double, ptr %72, align 8, !tbaa !11
  %1467 = fneg double %1466
  br label %1468

1468:                                             ; preds = %1465, %1463
  %1469 = phi double [ %1464, %1463 ], [ %1467, %1465 ]
  %1470 = load ptr, ptr %33, align 8, !tbaa !5
  %1471 = load i32, ptr %100, align 4, !tbaa !9
  %1472 = add nsw i32 %1471, 2
  %1473 = load i32, ptr %100, align 4, !tbaa !9
  %1474 = add nsw i32 %1473, 1
  %1475 = load i32, ptr %49, align 4, !tbaa !9
  %1476 = mul nsw i32 %1474, %1475
  %1477 = add nsw i32 %1472, %1476
  %1478 = sext i32 %1477 to i64
  %1479 = getelementptr inbounds %struct.doublecomplex, ptr %1470, i64 %1478
  %1480 = call { double, double } @Cd(ptr noundef %1479)
  %1481 = extractvalue { double, double } %1480, 0
  %1482 = extractvalue { double, double } %1480, 1
  store double %1482, ptr %73, align 8, !tbaa !11
  %1483 = load double, ptr %73, align 8, !tbaa !11
  %1484 = fcmp oge double %1483, 0.000000e+00
  br i1 %1484, label %1485, label %1487

1485:                                             ; preds = %1468
  %1486 = load double, ptr %73, align 8, !tbaa !11
  br label %1490

1487:                                             ; preds = %1468
  %1488 = load double, ptr %73, align 8, !tbaa !11
  %1489 = fneg double %1488
  br label %1490

1490:                                             ; preds = %1487, %1485
  %1491 = phi double [ %1486, %1485 ], [ %1489, %1487 ]
  %1492 = fadd double %1469, %1491
  %1493 = load double, ptr %127, align 8, !tbaa !11
  %1494 = fadd double %1493, %1492
  store double %1494, ptr %127, align 8, !tbaa !11
  br label %1495

1495:                                             ; preds = %1490, %1441
  %1496 = load i32, ptr %100, align 4, !tbaa !9
  %1497 = load ptr, ptr %30, align 8, !tbaa !5
  %1498 = load i32, ptr %1497, align 4, !tbaa !9
  %1499 = sub nsw i32 %1498, 3
  %1500 = icmp sle i32 %1496, %1499
  br i1 %1500, label %1501, label %1549

1501:                                             ; preds = %1495
  %1502 = load i32, ptr %100, align 4, !tbaa !9
  %1503 = add nsw i32 %1502, 3
  %1504 = load i32, ptr %100, align 4, !tbaa !9
  %1505 = add nsw i32 %1504, 1
  %1506 = load i32, ptr %49, align 4, !tbaa !9
  %1507 = mul nsw i32 %1505, %1506
  %1508 = add nsw i32 %1503, %1507
  store i32 %1508, ptr %64, align 4, !tbaa !9
  %1509 = load ptr, ptr %33, align 8, !tbaa !5
  %1510 = load i32, ptr %64, align 4, !tbaa !9
  %1511 = sext i32 %1510 to i64
  %1512 = getelementptr inbounds %struct.doublecomplex, ptr %1509, i64 %1511
  %1513 = getelementptr inbounds %struct.doublecomplex, ptr %1512, i32 0, i32 0
  %1514 = load double, ptr %1513, align 8, !tbaa !13
  store double %1514, ptr %72, align 8, !tbaa !11
  %1515 = load double, ptr %72, align 8, !tbaa !11
  %1516 = fcmp oge double %1515, 0.000000e+00
  br i1 %1516, label %1517, label %1519

1517:                                             ; preds = %1501
  %1518 = load double, ptr %72, align 8, !tbaa !11
  br label %1522

1519:                                             ; preds = %1501
  %1520 = load double, ptr %72, align 8, !tbaa !11
  %1521 = fneg double %1520
  br label %1522

1522:                                             ; preds = %1519, %1517
  %1523 = phi double [ %1518, %1517 ], [ %1521, %1519 ]
  %1524 = load ptr, ptr %33, align 8, !tbaa !5
  %1525 = load i32, ptr %100, align 4, !tbaa !9
  %1526 = add nsw i32 %1525, 3
  %1527 = load i32, ptr %100, align 4, !tbaa !9
  %1528 = add nsw i32 %1527, 1
  %1529 = load i32, ptr %49, align 4, !tbaa !9
  %1530 = mul nsw i32 %1528, %1529
  %1531 = add nsw i32 %1526, %1530
  %1532 = sext i32 %1531 to i64
  %1533 = getelementptr inbounds %struct.doublecomplex, ptr %1524, i64 %1532
  %1534 = call { double, double } @Cd(ptr noundef %1533)
  %1535 = extractvalue { double, double } %1534, 0
  %1536 = extractvalue { double, double } %1534, 1
  store double %1536, ptr %73, align 8, !tbaa !11
  %1537 = load double, ptr %73, align 8, !tbaa !11
  %1538 = fcmp oge double %1537, 0.000000e+00
  br i1 %1538, label %1539, label %1541

1539:                                             ; preds = %1522
  %1540 = load double, ptr %73, align 8, !tbaa !11
  br label %1544

1541:                                             ; preds = %1522
  %1542 = load double, ptr %73, align 8, !tbaa !11
  %1543 = fneg double %1542
  br label %1544

1544:                                             ; preds = %1541, %1539
  %1545 = phi double [ %1540, %1539 ], [ %1543, %1541 ]
  %1546 = fadd double %1523, %1545
  %1547 = load double, ptr %127, align 8, !tbaa !11
  %1548 = fadd double %1547, %1546
  store double %1548, ptr %127, align 8, !tbaa !11
  br label %1549

1549:                                             ; preds = %1544, %1495
  %1550 = load i32, ptr %100, align 4, !tbaa !9
  %1551 = load ptr, ptr %30, align 8, !tbaa !5
  %1552 = load i32, ptr %1551, align 4, !tbaa !9
  %1553 = sub nsw i32 %1552, 4
  %1554 = icmp sle i32 %1550, %1553
  br i1 %1554, label %1555, label %1603

1555:                                             ; preds = %1549
  %1556 = load i32, ptr %100, align 4, !tbaa !9
  %1557 = add nsw i32 %1556, 4
  %1558 = load i32, ptr %100, align 4, !tbaa !9
  %1559 = add nsw i32 %1558, 1
  %1560 = load i32, ptr %49, align 4, !tbaa !9
  %1561 = mul nsw i32 %1559, %1560
  %1562 = add nsw i32 %1557, %1561
  store i32 %1562, ptr %64, align 4, !tbaa !9
  %1563 = load ptr, ptr %33, align 8, !tbaa !5
  %1564 = load i32, ptr %64, align 4, !tbaa !9
  %1565 = sext i32 %1564 to i64
  %1566 = getelementptr inbounds %struct.doublecomplex, ptr %1563, i64 %1565
  %1567 = getelementptr inbounds %struct.doublecomplex, ptr %1566, i32 0, i32 0
  %1568 = load double, ptr %1567, align 8, !tbaa !13
  store double %1568, ptr %72, align 8, !tbaa !11
  %1569 = load double, ptr %72, align 8, !tbaa !11
  %1570 = fcmp oge double %1569, 0.000000e+00
  br i1 %1570, label %1571, label %1573

1571:                                             ; preds = %1555
  %1572 = load double, ptr %72, align 8, !tbaa !11
  br label %1576

1573:                                             ; preds = %1555
  %1574 = load double, ptr %72, align 8, !tbaa !11
  %1575 = fneg double %1574
  br label %1576

1576:                                             ; preds = %1573, %1571
  %1577 = phi double [ %1572, %1571 ], [ %1575, %1573 ]
  %1578 = load ptr, ptr %33, align 8, !tbaa !5
  %1579 = load i32, ptr %100, align 4, !tbaa !9
  %1580 = add nsw i32 %1579, 4
  %1581 = load i32, ptr %100, align 4, !tbaa !9
  %1582 = add nsw i32 %1581, 1
  %1583 = load i32, ptr %49, align 4, !tbaa !9
  %1584 = mul nsw i32 %1582, %1583
  %1585 = add nsw i32 %1580, %1584
  %1586 = sext i32 %1585 to i64
  %1587 = getelementptr inbounds %struct.doublecomplex, ptr %1578, i64 %1586
  %1588 = call { double, double } @Cd(ptr noundef %1587)
  %1589 = extractvalue { double, double } %1588, 0
  %1590 = extractvalue { double, double } %1588, 1
  store double %1590, ptr %73, align 8, !tbaa !11
  %1591 = load double, ptr %73, align 8, !tbaa !11
  %1592 = fcmp oge double %1591, 0.000000e+00
  br i1 %1592, label %1593, label %1595

1593:                                             ; preds = %1576
  %1594 = load double, ptr %73, align 8, !tbaa !11
  br label %1598

1595:                                             ; preds = %1576
  %1596 = load double, ptr %73, align 8, !tbaa !11
  %1597 = fneg double %1596
  br label %1598

1598:                                             ; preds = %1595, %1593
  %1599 = phi double [ %1594, %1593 ], [ %1597, %1595 ]
  %1600 = fadd double %1577, %1599
  %1601 = load double, ptr %127, align 8, !tbaa !11
  %1602 = fadd double %1601, %1600
  store double %1602, ptr %127, align 8, !tbaa !11
  br label %1603

1603:                                             ; preds = %1598, %1549
  br label %1604

1604:                                             ; preds = %1603, %1279
  %1605 = load i32, ptr %100, align 4, !tbaa !9
  %1606 = add nsw i32 %1605, 1
  %1607 = load i32, ptr %100, align 4, !tbaa !9
  %1608 = load i32, ptr %49, align 4, !tbaa !9
  %1609 = mul nsw i32 %1607, %1608
  %1610 = add nsw i32 %1606, %1609
  store i32 %1610, ptr %64, align 4, !tbaa !9
  %1611 = load double, ptr %122, align 8, !tbaa !11
  store double %1611, ptr %74, align 8, !tbaa !11
  %1612 = load double, ptr %126, align 8, !tbaa !11
  %1613 = load double, ptr %127, align 8, !tbaa !11
  %1614 = fmul double %1612, %1613
  store double %1614, ptr %75, align 8, !tbaa !11
  %1615 = load ptr, ptr %33, align 8, !tbaa !5
  %1616 = load i32, ptr %64, align 4, !tbaa !9
  %1617 = sext i32 %1616 to i64
  %1618 = getelementptr inbounds %struct.doublecomplex, ptr %1615, i64 %1617
  %1619 = getelementptr inbounds %struct.doublecomplex, ptr %1618, i32 0, i32 0
  %1620 = load double, ptr %1619, align 8, !tbaa !13
  store double %1620, ptr %72, align 8, !tbaa !11
  %1621 = load double, ptr %72, align 8, !tbaa !11
  %1622 = fcmp oge double %1621, 0.000000e+00
  br i1 %1622, label %1623, label %1625

1623:                                             ; preds = %1604
  %1624 = load double, ptr %72, align 8, !tbaa !11
  br label %1628

1625:                                             ; preds = %1604
  %1626 = load double, ptr %72, align 8, !tbaa !11
  %1627 = fneg double %1626
  br label %1628

1628:                                             ; preds = %1625, %1623
  %1629 = phi double [ %1624, %1623 ], [ %1627, %1625 ]
  %1630 = load ptr, ptr %33, align 8, !tbaa !5
  %1631 = load i32, ptr %100, align 4, !tbaa !9
  %1632 = add nsw i32 %1631, 1
  %1633 = load i32, ptr %100, align 4, !tbaa !9
  %1634 = load i32, ptr %49, align 4, !tbaa !9
  %1635 = mul nsw i32 %1633, %1634
  %1636 = add nsw i32 %1632, %1635
  %1637 = sext i32 %1636 to i64
  %1638 = getelementptr inbounds %struct.doublecomplex, ptr %1630, i64 %1637
  %1639 = call { double, double } @Cd(ptr noundef %1638)
  %1640 = extractvalue { double, double } %1639, 0
  %1641 = extractvalue { double, double } %1639, 1
  store double %1641, ptr %73, align 8, !tbaa !11
  %1642 = load double, ptr %73, align 8, !tbaa !11
  %1643 = fcmp oge double %1642, 0.000000e+00
  br i1 %1643, label %1644, label %1646

1644:                                             ; preds = %1628
  %1645 = load double, ptr %73, align 8, !tbaa !11
  br label %1649

1646:                                             ; preds = %1628
  %1647 = load double, ptr %73, align 8, !tbaa !11
  %1648 = fneg double %1647
  br label %1649

1649:                                             ; preds = %1646, %1644
  %1650 = phi double [ %1645, %1644 ], [ %1648, %1646 ]
  %1651 = fadd double %1629, %1650
  %1652 = load double, ptr %74, align 8, !tbaa !11
  %1653 = load double, ptr %75, align 8, !tbaa !11
  %1654 = fcmp oge double %1652, %1653
  br i1 %1654, label %1655, label %1657

1655:                                             ; preds = %1649
  %1656 = load double, ptr %74, align 8, !tbaa !11
  br label %1659

1657:                                             ; preds = %1649
  %1658 = load double, ptr %75, align 8, !tbaa !11
  br label %1659

1659:                                             ; preds = %1657, %1655
  %1660 = phi double [ %1656, %1655 ], [ %1658, %1657 ]
  %1661 = fcmp ole double %1651, %1660
  br i1 %1661, label %1662, label %2149

1662:                                             ; preds = %1659
  %1663 = load i32, ptr %100, align 4, !tbaa !9
  %1664 = add nsw i32 %1663, 1
  %1665 = load i32, ptr %100, align 4, !tbaa !9
  %1666 = load i32, ptr %49, align 4, !tbaa !9
  %1667 = mul nsw i32 %1665, %1666
  %1668 = add nsw i32 %1664, %1667
  store i32 %1668, ptr %64, align 4, !tbaa !9
  %1669 = load i32, ptr %100, align 4, !tbaa !9
  %1670 = load i32, ptr %100, align 4, !tbaa !9
  %1671 = add nsw i32 %1670, 1
  %1672 = load i32, ptr %49, align 4, !tbaa !9
  %1673 = mul nsw i32 %1671, %1672
  %1674 = add nsw i32 %1669, %1673
  store i32 %1674, ptr %65, align 4, !tbaa !9
  %1675 = load ptr, ptr %33, align 8, !tbaa !5
  %1676 = load i32, ptr %64, align 4, !tbaa !9
  %1677 = sext i32 %1676 to i64
  %1678 = getelementptr inbounds %struct.doublecomplex, ptr %1675, i64 %1677
  %1679 = getelementptr inbounds %struct.doublecomplex, ptr %1678, i32 0, i32 0
  %1680 = load double, ptr %1679, align 8, !tbaa !13
  store double %1680, ptr %72, align 8, !tbaa !11
  %1681 = load double, ptr %72, align 8, !tbaa !11
  %1682 = fcmp oge double %1681, 0.000000e+00
  br i1 %1682, label %1683, label %1685

1683:                                             ; preds = %1662
  %1684 = load double, ptr %72, align 8, !tbaa !11
  br label %1688

1685:                                             ; preds = %1662
  %1686 = load double, ptr %72, align 8, !tbaa !11
  %1687 = fneg double %1686
  br label %1688

1688:                                             ; preds = %1685, %1683
  %1689 = phi double [ %1684, %1683 ], [ %1687, %1685 ]
  %1690 = load ptr, ptr %33, align 8, !tbaa !5
  %1691 = load i32, ptr %100, align 4, !tbaa !9
  %1692 = add nsw i32 %1691, 1
  %1693 = load i32, ptr %100, align 4, !tbaa !9
  %1694 = load i32, ptr %49, align 4, !tbaa !9
  %1695 = mul nsw i32 %1693, %1694
  %1696 = add nsw i32 %1692, %1695
  %1697 = sext i32 %1696 to i64
  %1698 = getelementptr inbounds %struct.doublecomplex, ptr %1690, i64 %1697
  %1699 = call { double, double } @Cd(ptr noundef %1698)
  %1700 = extractvalue { double, double } %1699, 0
  %1701 = extractvalue { double, double } %1699, 1
  store double %1701, ptr %73, align 8, !tbaa !11
  %1702 = load double, ptr %73, align 8, !tbaa !11
  %1703 = fcmp oge double %1702, 0.000000e+00
  br i1 %1703, label %1704, label %1706

1704:                                             ; preds = %1688
  %1705 = load double, ptr %73, align 8, !tbaa !11
  br label %1709

1706:                                             ; preds = %1688
  %1707 = load double, ptr %73, align 8, !tbaa !11
  %1708 = fneg double %1707
  br label %1709

1709:                                             ; preds = %1706, %1704
  %1710 = phi double [ %1705, %1704 ], [ %1708, %1706 ]
  %1711 = fadd double %1689, %1710
  store double %1711, ptr %76, align 8, !tbaa !11
  %1712 = load ptr, ptr %33, align 8, !tbaa !5
  %1713 = load i32, ptr %65, align 4, !tbaa !9
  %1714 = sext i32 %1713 to i64
  %1715 = getelementptr inbounds %struct.doublecomplex, ptr %1712, i64 %1714
  %1716 = getelementptr inbounds %struct.doublecomplex, ptr %1715, i32 0, i32 0
  %1717 = load double, ptr %1716, align 8, !tbaa !13
  store double %1717, ptr %74, align 8, !tbaa !11
  %1718 = load double, ptr %74, align 8, !tbaa !11
  %1719 = fcmp oge double %1718, 0.000000e+00
  br i1 %1719, label %1720, label %1722

1720:                                             ; preds = %1709
  %1721 = load double, ptr %74, align 8, !tbaa !11
  br label %1725

1722:                                             ; preds = %1709
  %1723 = load double, ptr %74, align 8, !tbaa !11
  %1724 = fneg double %1723
  br label %1725

1725:                                             ; preds = %1722, %1720
  %1726 = phi double [ %1721, %1720 ], [ %1724, %1722 ]
  %1727 = load ptr, ptr %33, align 8, !tbaa !5
  %1728 = load i32, ptr %100, align 4, !tbaa !9
  %1729 = load i32, ptr %100, align 4, !tbaa !9
  %1730 = add nsw i32 %1729, 1
  %1731 = load i32, ptr %49, align 4, !tbaa !9
  %1732 = mul nsw i32 %1730, %1731
  %1733 = add nsw i32 %1728, %1732
  %1734 = sext i32 %1733 to i64
  %1735 = getelementptr inbounds %struct.doublecomplex, ptr %1727, i64 %1734
  %1736 = call { double, double } @Cd(ptr noundef %1735)
  %1737 = extractvalue { double, double } %1736, 0
  %1738 = extractvalue { double, double } %1736, 1
  store double %1738, ptr %75, align 8, !tbaa !11
  %1739 = load double, ptr %75, align 8, !tbaa !11
  %1740 = fcmp oge double %1739, 0.000000e+00
  br i1 %1740, label %1741, label %1743

1741:                                             ; preds = %1725
  %1742 = load double, ptr %75, align 8, !tbaa !11
  br label %1746

1743:                                             ; preds = %1725
  %1744 = load double, ptr %75, align 8, !tbaa !11
  %1745 = fneg double %1744
  br label %1746

1746:                                             ; preds = %1743, %1741
  %1747 = phi double [ %1742, %1741 ], [ %1745, %1743 ]
  %1748 = fadd double %1726, %1747
  store double %1748, ptr %77, align 8, !tbaa !11
  %1749 = load double, ptr %76, align 8, !tbaa !11
  %1750 = load double, ptr %77, align 8, !tbaa !11
  %1751 = fcmp oge double %1749, %1750
  br i1 %1751, label %1752, label %1754

1752:                                             ; preds = %1746
  %1753 = load double, ptr %76, align 8, !tbaa !11
  br label %1756

1754:                                             ; preds = %1746
  %1755 = load double, ptr %77, align 8, !tbaa !11
  br label %1756

1756:                                             ; preds = %1754, %1752
  %1757 = phi double [ %1753, %1752 ], [ %1755, %1754 ]
  store double %1757, ptr %112, align 8, !tbaa !11
  %1758 = load i32, ptr %100, align 4, !tbaa !9
  %1759 = add nsw i32 %1758, 1
  %1760 = load i32, ptr %100, align 4, !tbaa !9
  %1761 = load i32, ptr %49, align 4, !tbaa !9
  %1762 = mul nsw i32 %1760, %1761
  %1763 = add nsw i32 %1759, %1762
  store i32 %1763, ptr %64, align 4, !tbaa !9
  %1764 = load i32, ptr %100, align 4, !tbaa !9
  %1765 = load i32, ptr %100, align 4, !tbaa !9
  %1766 = add nsw i32 %1765, 1
  %1767 = load i32, ptr %49, align 4, !tbaa !9
  %1768 = mul nsw i32 %1766, %1767
  %1769 = add nsw i32 %1764, %1768
  store i32 %1769, ptr %65, align 4, !tbaa !9
  %1770 = load ptr, ptr %33, align 8, !tbaa !5
  %1771 = load i32, ptr %64, align 4, !tbaa !9
  %1772 = sext i32 %1771 to i64
  %1773 = getelementptr inbounds %struct.doublecomplex, ptr %1770, i64 %1772
  %1774 = getelementptr inbounds %struct.doublecomplex, ptr %1773, i32 0, i32 0
  %1775 = load double, ptr %1774, align 8, !tbaa !13
  store double %1775, ptr %72, align 8, !tbaa !11
  %1776 = load double, ptr %72, align 8, !tbaa !11
  %1777 = fcmp oge double %1776, 0.000000e+00
  br i1 %1777, label %1778, label %1780

1778:                                             ; preds = %1756
  %1779 = load double, ptr %72, align 8, !tbaa !11
  br label %1783

1780:                                             ; preds = %1756
  %1781 = load double, ptr %72, align 8, !tbaa !11
  %1782 = fneg double %1781
  br label %1783

1783:                                             ; preds = %1780, %1778
  %1784 = phi double [ %1779, %1778 ], [ %1782, %1780 ]
  %1785 = load ptr, ptr %33, align 8, !tbaa !5
  %1786 = load i32, ptr %100, align 4, !tbaa !9
  %1787 = add nsw i32 %1786, 1
  %1788 = load i32, ptr %100, align 4, !tbaa !9
  %1789 = load i32, ptr %49, align 4, !tbaa !9
  %1790 = mul nsw i32 %1788, %1789
  %1791 = add nsw i32 %1787, %1790
  %1792 = sext i32 %1791 to i64
  %1793 = getelementptr inbounds %struct.doublecomplex, ptr %1785, i64 %1792
  %1794 = call { double, double } @Cd(ptr noundef %1793)
  %1795 = extractvalue { double, double } %1794, 0
  %1796 = extractvalue { double, double } %1794, 1
  store double %1796, ptr %73, align 8, !tbaa !11
  %1797 = load double, ptr %73, align 8, !tbaa !11
  %1798 = fcmp oge double %1797, 0.000000e+00
  br i1 %1798, label %1799, label %1801

1799:                                             ; preds = %1783
  %1800 = load double, ptr %73, align 8, !tbaa !11
  br label %1804

1801:                                             ; preds = %1783
  %1802 = load double, ptr %73, align 8, !tbaa !11
  %1803 = fneg double %1802
  br label %1804

1804:                                             ; preds = %1801, %1799
  %1805 = phi double [ %1800, %1799 ], [ %1803, %1801 ]
  %1806 = fadd double %1784, %1805
  store double %1806, ptr %76, align 8, !tbaa !11
  %1807 = load ptr, ptr %33, align 8, !tbaa !5
  %1808 = load i32, ptr %65, align 4, !tbaa !9
  %1809 = sext i32 %1808 to i64
  %1810 = getelementptr inbounds %struct.doublecomplex, ptr %1807, i64 %1809
  %1811 = getelementptr inbounds %struct.doublecomplex, ptr %1810, i32 0, i32 0
  %1812 = load double, ptr %1811, align 8, !tbaa !13
  store double %1812, ptr %74, align 8, !tbaa !11
  %1813 = load double, ptr %74, align 8, !tbaa !11
  %1814 = fcmp oge double %1813, 0.000000e+00
  br i1 %1814, label %1815, label %1817

1815:                                             ; preds = %1804
  %1816 = load double, ptr %74, align 8, !tbaa !11
  br label %1820

1817:                                             ; preds = %1804
  %1818 = load double, ptr %74, align 8, !tbaa !11
  %1819 = fneg double %1818
  br label %1820

1820:                                             ; preds = %1817, %1815
  %1821 = phi double [ %1816, %1815 ], [ %1819, %1817 ]
  %1822 = load ptr, ptr %33, align 8, !tbaa !5
  %1823 = load i32, ptr %100, align 4, !tbaa !9
  %1824 = load i32, ptr %100, align 4, !tbaa !9
  %1825 = add nsw i32 %1824, 1
  %1826 = load i32, ptr %49, align 4, !tbaa !9
  %1827 = mul nsw i32 %1825, %1826
  %1828 = add nsw i32 %1823, %1827
  %1829 = sext i32 %1828 to i64
  %1830 = getelementptr inbounds %struct.doublecomplex, ptr %1822, i64 %1829
  %1831 = call { double, double } @Cd(ptr noundef %1830)
  %1832 = extractvalue { double, double } %1831, 0
  %1833 = extractvalue { double, double } %1831, 1
  store double %1833, ptr %75, align 8, !tbaa !11
  %1834 = load double, ptr %75, align 8, !tbaa !11
  %1835 = fcmp oge double %1834, 0.000000e+00
  br i1 %1835, label %1836, label %1838

1836:                                             ; preds = %1820
  %1837 = load double, ptr %75, align 8, !tbaa !11
  br label %1841

1838:                                             ; preds = %1820
  %1839 = load double, ptr %75, align 8, !tbaa !11
  %1840 = fneg double %1839
  br label %1841

1841:                                             ; preds = %1838, %1836
  %1842 = phi double [ %1837, %1836 ], [ %1840, %1838 ]
  %1843 = fadd double %1821, %1842
  store double %1843, ptr %77, align 8, !tbaa !11
  %1844 = load double, ptr %76, align 8, !tbaa !11
  %1845 = load double, ptr %77, align 8, !tbaa !11
  %1846 = fcmp ole double %1844, %1845
  br i1 %1846, label %1847, label %1849

1847:                                             ; preds = %1841
  %1848 = load double, ptr %76, align 8, !tbaa !11
  br label %1851

1849:                                             ; preds = %1841
  %1850 = load double, ptr %77, align 8, !tbaa !11
  br label %1851

1851:                                             ; preds = %1849, %1847
  %1852 = phi double [ %1848, %1847 ], [ %1850, %1849 ]
  store double %1852, ptr %113, align 8, !tbaa !11
  %1853 = load i32, ptr %100, align 4, !tbaa !9
  %1854 = load i32, ptr %100, align 4, !tbaa !9
  %1855 = load i32, ptr %49, align 4, !tbaa !9
  %1856 = mul nsw i32 %1854, %1855
  %1857 = add nsw i32 %1853, %1856
  store i32 %1857, ptr %64, align 4, !tbaa !9
  %1858 = load i32, ptr %100, align 4, !tbaa !9
  %1859 = add nsw i32 %1858, 1
  %1860 = load i32, ptr %100, align 4, !tbaa !9
  %1861 = add nsw i32 %1860, 1
  %1862 = load i32, ptr %49, align 4, !tbaa !9
  %1863 = mul nsw i32 %1861, %1862
  %1864 = add nsw i32 %1859, %1863
  store i32 %1864, ptr %65, align 4, !tbaa !9
  %1865 = load ptr, ptr %33, align 8, !tbaa !5
  %1866 = load i32, ptr %64, align 4, !tbaa !9
  %1867 = sext i32 %1866 to i64
  %1868 = getelementptr inbounds %struct.doublecomplex, ptr %1865, i64 %1867
  %1869 = getelementptr inbounds %struct.doublecomplex, ptr %1868, i32 0, i32 0
  %1870 = load double, ptr %1869, align 8, !tbaa !13
  %1871 = load ptr, ptr %33, align 8, !tbaa !5
  %1872 = load i32, ptr %65, align 4, !tbaa !9
  %1873 = sext i32 %1872 to i64
  %1874 = getelementptr inbounds %struct.doublecomplex, ptr %1871, i64 %1873
  %1875 = getelementptr inbounds %struct.doublecomplex, ptr %1874, i32 0, i32 0
  %1876 = load double, ptr %1875, align 8, !tbaa !13
  %1877 = fsub double %1870, %1876
  %1878 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %1877, ptr %1878, align 8, !tbaa !13
  %1879 = load ptr, ptr %33, align 8, !tbaa !5
  %1880 = load i32, ptr %64, align 4, !tbaa !9
  %1881 = sext i32 %1880 to i64
  %1882 = getelementptr inbounds %struct.doublecomplex, ptr %1879, i64 %1881
  %1883 = getelementptr inbounds %struct.doublecomplex, ptr %1882, i32 0, i32 1
  %1884 = load double, ptr %1883, align 8, !tbaa !15
  %1885 = load ptr, ptr %33, align 8, !tbaa !5
  %1886 = load i32, ptr %65, align 4, !tbaa !9
  %1887 = sext i32 %1886 to i64
  %1888 = getelementptr inbounds %struct.doublecomplex, ptr %1885, i64 %1887
  %1889 = getelementptr inbounds %struct.doublecomplex, ptr %1888, i32 0, i32 1
  %1890 = load double, ptr %1889, align 8, !tbaa !15
  %1891 = fsub double %1884, %1890
  %1892 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %1891, ptr %1892, align 8, !tbaa !15
  %1893 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %1894 = load double, ptr %1893, align 8, !tbaa !13
  %1895 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %1894, ptr %1895, align 8, !tbaa !13
  %1896 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %1897 = load double, ptr %1896, align 8, !tbaa !15
  %1898 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %1897, ptr %1898, align 8, !tbaa !15
  %1899 = load i32, ptr %100, align 4, !tbaa !9
  %1900 = add nsw i32 %1899, 1
  %1901 = load i32, ptr %100, align 4, !tbaa !9
  %1902 = add nsw i32 %1901, 1
  %1903 = load i32, ptr %49, align 4, !tbaa !9
  %1904 = mul nsw i32 %1902, %1903
  %1905 = add nsw i32 %1900, %1904
  store i32 %1905, ptr %66, align 4, !tbaa !9
  %1906 = load ptr, ptr %33, align 8, !tbaa !5
  %1907 = load i32, ptr %66, align 4, !tbaa !9
  %1908 = sext i32 %1907 to i64
  %1909 = getelementptr inbounds %struct.doublecomplex, ptr %1906, i64 %1908
  %1910 = getelementptr inbounds %struct.doublecomplex, ptr %1909, i32 0, i32 0
  %1911 = load double, ptr %1910, align 8, !tbaa !13
  store double %1911, ptr %72, align 8, !tbaa !11
  %1912 = load double, ptr %72, align 8, !tbaa !11
  %1913 = fcmp oge double %1912, 0.000000e+00
  br i1 %1913, label %1914, label %1916

1914:                                             ; preds = %1851
  %1915 = load double, ptr %72, align 8, !tbaa !11
  br label %1919

1916:                                             ; preds = %1851
  %1917 = load double, ptr %72, align 8, !tbaa !11
  %1918 = fneg double %1917
  br label %1919

1919:                                             ; preds = %1916, %1914
  %1920 = phi double [ %1915, %1914 ], [ %1918, %1916 ]
  %1921 = load ptr, ptr %33, align 8, !tbaa !5
  %1922 = load i32, ptr %100, align 4, !tbaa !9
  %1923 = add nsw i32 %1922, 1
  %1924 = load i32, ptr %100, align 4, !tbaa !9
  %1925 = add nsw i32 %1924, 1
  %1926 = load i32, ptr %49, align 4, !tbaa !9
  %1927 = mul nsw i32 %1925, %1926
  %1928 = add nsw i32 %1923, %1927
  %1929 = sext i32 %1928 to i64
  %1930 = getelementptr inbounds %struct.doublecomplex, ptr %1921, i64 %1929
  %1931 = call { double, double } @Cd(ptr noundef %1930)
  %1932 = extractvalue { double, double } %1931, 0
  %1933 = extractvalue { double, double } %1931, 1
  store double %1933, ptr %73, align 8, !tbaa !11
  %1934 = load double, ptr %73, align 8, !tbaa !11
  %1935 = fcmp oge double %1934, 0.000000e+00
  br i1 %1935, label %1936, label %1938

1936:                                             ; preds = %1919
  %1937 = load double, ptr %73, align 8, !tbaa !11
  br label %1941

1938:                                             ; preds = %1919
  %1939 = load double, ptr %73, align 8, !tbaa !11
  %1940 = fneg double %1939
  br label %1941

1941:                                             ; preds = %1938, %1936
  %1942 = phi double [ %1937, %1936 ], [ %1940, %1938 ]
  %1943 = fadd double %1920, %1942
  store double %1943, ptr %76, align 8, !tbaa !11
  %1944 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %1945 = load double, ptr %1944, align 8, !tbaa !13
  store double %1945, ptr %74, align 8, !tbaa !11
  %1946 = load double, ptr %74, align 8, !tbaa !11
  %1947 = fcmp oge double %1946, 0.000000e+00
  br i1 %1947, label %1948, label %1950

1948:                                             ; preds = %1941
  %1949 = load double, ptr %74, align 8, !tbaa !11
  br label %1953

1950:                                             ; preds = %1941
  %1951 = load double, ptr %74, align 8, !tbaa !11
  %1952 = fneg double %1951
  br label %1953

1953:                                             ; preds = %1950, %1948
  %1954 = phi double [ %1949, %1948 ], [ %1952, %1950 ]
  %1955 = call { double, double } @Cd(ptr noundef %82)
  %1956 = extractvalue { double, double } %1955, 0
  %1957 = extractvalue { double, double } %1955, 1
  store double %1957, ptr %75, align 8, !tbaa !11
  %1958 = load double, ptr %75, align 8, !tbaa !11
  %1959 = fcmp oge double %1958, 0.000000e+00
  br i1 %1959, label %1960, label %1962

1960:                                             ; preds = %1953
  %1961 = load double, ptr %75, align 8, !tbaa !11
  br label %1965

1962:                                             ; preds = %1953
  %1963 = load double, ptr %75, align 8, !tbaa !11
  %1964 = fneg double %1963
  br label %1965

1965:                                             ; preds = %1962, %1960
  %1966 = phi double [ %1961, %1960 ], [ %1964, %1962 ]
  %1967 = fadd double %1954, %1966
  store double %1967, ptr %77, align 8, !tbaa !11
  %1968 = load double, ptr %76, align 8, !tbaa !11
  %1969 = load double, ptr %77, align 8, !tbaa !11
  %1970 = fcmp oge double %1968, %1969
  br i1 %1970, label %1971, label %1973

1971:                                             ; preds = %1965
  %1972 = load double, ptr %76, align 8, !tbaa !11
  br label %1975

1973:                                             ; preds = %1965
  %1974 = load double, ptr %77, align 8, !tbaa !11
  br label %1975

1975:                                             ; preds = %1973, %1971
  %1976 = phi double [ %1972, %1971 ], [ %1974, %1973 ]
  store double %1976, ptr %111, align 8, !tbaa !11
  %1977 = load i32, ptr %100, align 4, !tbaa !9
  %1978 = load i32, ptr %100, align 4, !tbaa !9
  %1979 = load i32, ptr %49, align 4, !tbaa !9
  %1980 = mul nsw i32 %1978, %1979
  %1981 = add nsw i32 %1977, %1980
  store i32 %1981, ptr %64, align 4, !tbaa !9
  %1982 = load i32, ptr %100, align 4, !tbaa !9
  %1983 = add nsw i32 %1982, 1
  %1984 = load i32, ptr %100, align 4, !tbaa !9
  %1985 = add nsw i32 %1984, 1
  %1986 = load i32, ptr %49, align 4, !tbaa !9
  %1987 = mul nsw i32 %1985, %1986
  %1988 = add nsw i32 %1983, %1987
  store i32 %1988, ptr %65, align 4, !tbaa !9
  %1989 = load ptr, ptr %33, align 8, !tbaa !5
  %1990 = load i32, ptr %64, align 4, !tbaa !9
  %1991 = sext i32 %1990 to i64
  %1992 = getelementptr inbounds %struct.doublecomplex, ptr %1989, i64 %1991
  %1993 = getelementptr inbounds %struct.doublecomplex, ptr %1992, i32 0, i32 0
  %1994 = load double, ptr %1993, align 8, !tbaa !13
  %1995 = load ptr, ptr %33, align 8, !tbaa !5
  %1996 = load i32, ptr %65, align 4, !tbaa !9
  %1997 = sext i32 %1996 to i64
  %1998 = getelementptr inbounds %struct.doublecomplex, ptr %1995, i64 %1997
  %1999 = getelementptr inbounds %struct.doublecomplex, ptr %1998, i32 0, i32 0
  %2000 = load double, ptr %1999, align 8, !tbaa !13
  %2001 = fsub double %1994, %2000
  %2002 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2001, ptr %2002, align 8, !tbaa !13
  %2003 = load ptr, ptr %33, align 8, !tbaa !5
  %2004 = load i32, ptr %64, align 4, !tbaa !9
  %2005 = sext i32 %2004 to i64
  %2006 = getelementptr inbounds %struct.doublecomplex, ptr %2003, i64 %2005
  %2007 = getelementptr inbounds %struct.doublecomplex, ptr %2006, i32 0, i32 1
  %2008 = load double, ptr %2007, align 8, !tbaa !15
  %2009 = load ptr, ptr %33, align 8, !tbaa !5
  %2010 = load i32, ptr %65, align 4, !tbaa !9
  %2011 = sext i32 %2010 to i64
  %2012 = getelementptr inbounds %struct.doublecomplex, ptr %2009, i64 %2011
  %2013 = getelementptr inbounds %struct.doublecomplex, ptr %2012, i32 0, i32 1
  %2014 = load double, ptr %2013, align 8, !tbaa !15
  %2015 = fsub double %2008, %2014
  %2016 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2015, ptr %2016, align 8, !tbaa !15
  %2017 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2018 = load double, ptr %2017, align 8, !tbaa !13
  %2019 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2018, ptr %2019, align 8, !tbaa !13
  %2020 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2021 = load double, ptr %2020, align 8, !tbaa !15
  %2022 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2021, ptr %2022, align 8, !tbaa !15
  %2023 = load i32, ptr %100, align 4, !tbaa !9
  %2024 = add nsw i32 %2023, 1
  %2025 = load i32, ptr %100, align 4, !tbaa !9
  %2026 = add nsw i32 %2025, 1
  %2027 = load i32, ptr %49, align 4, !tbaa !9
  %2028 = mul nsw i32 %2026, %2027
  %2029 = add nsw i32 %2024, %2028
  store i32 %2029, ptr %66, align 4, !tbaa !9
  %2030 = load ptr, ptr %33, align 8, !tbaa !5
  %2031 = load i32, ptr %66, align 4, !tbaa !9
  %2032 = sext i32 %2031 to i64
  %2033 = getelementptr inbounds %struct.doublecomplex, ptr %2030, i64 %2032
  %2034 = getelementptr inbounds %struct.doublecomplex, ptr %2033, i32 0, i32 0
  %2035 = load double, ptr %2034, align 8, !tbaa !13
  store double %2035, ptr %72, align 8, !tbaa !11
  %2036 = load double, ptr %72, align 8, !tbaa !11
  %2037 = fcmp oge double %2036, 0.000000e+00
  br i1 %2037, label %2038, label %2040

2038:                                             ; preds = %1975
  %2039 = load double, ptr %72, align 8, !tbaa !11
  br label %2043

2040:                                             ; preds = %1975
  %2041 = load double, ptr %72, align 8, !tbaa !11
  %2042 = fneg double %2041
  br label %2043

2043:                                             ; preds = %2040, %2038
  %2044 = phi double [ %2039, %2038 ], [ %2042, %2040 ]
  %2045 = load ptr, ptr %33, align 8, !tbaa !5
  %2046 = load i32, ptr %100, align 4, !tbaa !9
  %2047 = add nsw i32 %2046, 1
  %2048 = load i32, ptr %100, align 4, !tbaa !9
  %2049 = add nsw i32 %2048, 1
  %2050 = load i32, ptr %49, align 4, !tbaa !9
  %2051 = mul nsw i32 %2049, %2050
  %2052 = add nsw i32 %2047, %2051
  %2053 = sext i32 %2052 to i64
  %2054 = getelementptr inbounds %struct.doublecomplex, ptr %2045, i64 %2053
  %2055 = call { double, double } @Cd(ptr noundef %2054)
  %2056 = extractvalue { double, double } %2055, 0
  %2057 = extractvalue { double, double } %2055, 1
  store double %2057, ptr %73, align 8, !tbaa !11
  %2058 = load double, ptr %73, align 8, !tbaa !11
  %2059 = fcmp oge double %2058, 0.000000e+00
  br i1 %2059, label %2060, label %2062

2060:                                             ; preds = %2043
  %2061 = load double, ptr %73, align 8, !tbaa !11
  br label %2065

2062:                                             ; preds = %2043
  %2063 = load double, ptr %73, align 8, !tbaa !11
  %2064 = fneg double %2063
  br label %2065

2065:                                             ; preds = %2062, %2060
  %2066 = phi double [ %2061, %2060 ], [ %2064, %2062 ]
  %2067 = fadd double %2044, %2066
  store double %2067, ptr %76, align 8, !tbaa !11
  %2068 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2069 = load double, ptr %2068, align 8, !tbaa !13
  store double %2069, ptr %74, align 8, !tbaa !11
  %2070 = load double, ptr %74, align 8, !tbaa !11
  %2071 = fcmp oge double %2070, 0.000000e+00
  br i1 %2071, label %2072, label %2074

2072:                                             ; preds = %2065
  %2073 = load double, ptr %74, align 8, !tbaa !11
  br label %2077

2074:                                             ; preds = %2065
  %2075 = load double, ptr %74, align 8, !tbaa !11
  %2076 = fneg double %2075
  br label %2077

2077:                                             ; preds = %2074, %2072
  %2078 = phi double [ %2073, %2072 ], [ %2076, %2074 ]
  %2079 = call { double, double } @Cd(ptr noundef %82)
  %2080 = extractvalue { double, double } %2079, 0
  %2081 = extractvalue { double, double } %2079, 1
  store double %2081, ptr %75, align 8, !tbaa !11
  %2082 = load double, ptr %75, align 8, !tbaa !11
  %2083 = fcmp oge double %2082, 0.000000e+00
  br i1 %2083, label %2084, label %2086

2084:                                             ; preds = %2077
  %2085 = load double, ptr %75, align 8, !tbaa !11
  br label %2089

2086:                                             ; preds = %2077
  %2087 = load double, ptr %75, align 8, !tbaa !11
  %2088 = fneg double %2087
  br label %2089

2089:                                             ; preds = %2086, %2084
  %2090 = phi double [ %2085, %2084 ], [ %2088, %2086 ]
  %2091 = fadd double %2078, %2090
  store double %2091, ptr %77, align 8, !tbaa !11
  %2092 = load double, ptr %76, align 8, !tbaa !11
  %2093 = load double, ptr %77, align 8, !tbaa !11
  %2094 = fcmp ole double %2092, %2093
  br i1 %2094, label %2095, label %2097

2095:                                             ; preds = %2089
  %2096 = load double, ptr %76, align 8, !tbaa !11
  br label %2099

2097:                                             ; preds = %2089
  %2098 = load double, ptr %77, align 8, !tbaa !11
  br label %2099

2099:                                             ; preds = %2097, %2095
  %2100 = phi double [ %2096, %2095 ], [ %2098, %2097 ]
  store double %2100, ptr %114, align 8, !tbaa !11
  %2101 = load double, ptr %111, align 8, !tbaa !11
  %2102 = load double, ptr %112, align 8, !tbaa !11
  %2103 = fadd double %2101, %2102
  store double %2103, ptr %123, align 8, !tbaa !11
  %2104 = load double, ptr %114, align 8, !tbaa !11
  %2105 = load double, ptr %111, align 8, !tbaa !11
  %2106 = load double, ptr %123, align 8, !tbaa !11
  %2107 = fdiv double %2105, %2106
  %2108 = fmul double %2104, %2107
  store double %2108, ptr %128, align 8, !tbaa !11
  %2109 = load double, ptr %122, align 8, !tbaa !11
  store double %2109, ptr %72, align 8, !tbaa !11
  %2110 = load double, ptr %126, align 8, !tbaa !11
  %2111 = load double, ptr %128, align 8, !tbaa !11
  %2112 = fmul double %2110, %2111
  store double %2112, ptr %73, align 8, !tbaa !11
  %2113 = load double, ptr %128, align 8, !tbaa !11
  %2114 = fcmp oeq double %2113, 0.000000e+00
  br i1 %2114, label %2131, label %2115

2115:                                             ; preds = %2099
  %2116 = load double, ptr %113, align 8, !tbaa !11
  %2117 = load double, ptr %112, align 8, !tbaa !11
  %2118 = load double, ptr %123, align 8, !tbaa !11
  %2119 = fdiv double %2117, %2118
  %2120 = fmul double %2116, %2119
  %2121 = load double, ptr %72, align 8, !tbaa !11
  %2122 = load double, ptr %73, align 8, !tbaa !11
  %2123 = fcmp oge double %2121, %2122
  br i1 %2123, label %2124, label %2126

2124:                                             ; preds = %2115
  %2125 = load double, ptr %72, align 8, !tbaa !11
  br label %2128

2126:                                             ; preds = %2115
  %2127 = load double, ptr %73, align 8, !tbaa !11
  br label %2128

2128:                                             ; preds = %2126, %2124
  %2129 = phi double [ %2125, %2124 ], [ %2127, %2126 ]
  %2130 = fcmp ole double %2120, %2129
  br i1 %2130, label %2131, label %2148

2131:                                             ; preds = %2128, %2099
  %2132 = load i32, ptr %100, align 4, !tbaa !9
  %2133 = add nsw i32 %2132, 1
  %2134 = load i32, ptr %100, align 4, !tbaa !9
  %2135 = load i32, ptr %49, align 4, !tbaa !9
  %2136 = mul nsw i32 %2134, %2135
  %2137 = add nsw i32 %2133, %2136
  store i32 %2137, ptr %64, align 4, !tbaa !9
  %2138 = load ptr, ptr %33, align 8, !tbaa !5
  %2139 = load i32, ptr %64, align 4, !tbaa !9
  %2140 = sext i32 %2139 to i64
  %2141 = getelementptr inbounds %struct.doublecomplex, ptr %2138, i64 %2140
  %2142 = getelementptr inbounds %struct.doublecomplex, ptr %2141, i32 0, i32 0
  store double 0.000000e+00, ptr %2142, align 8, !tbaa !13
  %2143 = load ptr, ptr %33, align 8, !tbaa !5
  %2144 = load i32, ptr %64, align 4, !tbaa !9
  %2145 = sext i32 %2144 to i64
  %2146 = getelementptr inbounds %struct.doublecomplex, ptr %2143, i64 %2145
  %2147 = getelementptr inbounds %struct.doublecomplex, ptr %2146, i32 0, i32 1
  store double 0.000000e+00, ptr %2147, align 8, !tbaa !15
  br label %2148

2148:                                             ; preds = %2131, %2128
  br label %2149

2149:                                             ; preds = %2148, %1659
  br label %2150

2150:                                             ; preds = %2149, %1187
  br label %2151

2151:                                             ; preds = %2150, %1168
  %2152 = load i32, ptr %103, align 4, !tbaa !9
  %2153 = icmp ne i32 %2152, 0
  br i1 %2153, label %2154, label %2450

2154:                                             ; preds = %2151
  %2155 = load i32, ptr %100, align 4, !tbaa !9
  %2156 = load i32, ptr %105, align 4, !tbaa !9
  %2157 = sub nsw i32 %2155, %2156
  store i32 %2157, ptr %125, align 4, !tbaa !9
  store i32 1, ptr %64, align 4, !tbaa !9
  %2158 = load ptr, ptr %29, align 8, !tbaa !5
  %2159 = load i32, ptr %2158, align 4, !tbaa !9
  %2160 = load i32, ptr %105, align 4, !tbaa !9
  %2161 = sub nsw i32 %2159, %2160
  store i32 %2161, ptr %65, align 4, !tbaa !9
  %2162 = load i32, ptr %124, align 4, !tbaa !9
  store i32 %2162, ptr %66, align 4, !tbaa !9
  %2163 = load i32, ptr %64, align 4, !tbaa !9
  %2164 = load i32, ptr %65, align 4, !tbaa !9
  %2165 = icmp sge i32 %2163, %2164
  br i1 %2165, label %2166, label %2168

2166:                                             ; preds = %2154
  %2167 = load i32, ptr %64, align 4, !tbaa !9
  br label %2170

2168:                                             ; preds = %2154
  %2169 = load i32, ptr %65, align 4, !tbaa !9
  br label %2170

2170:                                             ; preds = %2168, %2166
  %2171 = phi i32 [ %2167, %2166 ], [ %2169, %2168 ]
  store i32 %2171, ptr %99, align 4, !tbaa !9
  br label %2172

2172:                                             ; preds = %2446, %2170
  %2173 = load i32, ptr %99, align 4, !tbaa !9
  %2174 = load i32, ptr %66, align 4, !tbaa !9
  %2175 = icmp sle i32 %2173, %2174
  br i1 %2175, label %2176, label %2449

2176:                                             ; preds = %2172
  %2177 = load i32, ptr %115, align 4, !tbaa !9
  %2178 = load i32, ptr %53, align 4, !tbaa !9
  %2179 = mul nsw i32 %2177, %2178
  %2180 = add nsw i32 %2179, 1
  store i32 %2180, ptr %64, align 4, !tbaa !9
  %2181 = load i32, ptr %99, align 4, !tbaa !9
  %2182 = load i32, ptr %125, align 4, !tbaa !9
  %2183 = add nsw i32 %2182, 1
  %2184 = load i32, ptr %51, align 4, !tbaa !9
  %2185 = mul nsw i32 %2183, %2184
  %2186 = add nsw i32 %2181, %2185
  store i32 %2186, ptr %65, align 4, !tbaa !9
  %2187 = load i32, ptr %115, align 4, !tbaa !9
  %2188 = load i32, ptr %53, align 4, !tbaa !9
  %2189 = mul nsw i32 %2187, %2188
  %2190 = add nsw i32 %2189, 2
  store i32 %2190, ptr %67, align 4, !tbaa !9
  %2191 = load i32, ptr %99, align 4, !tbaa !9
  %2192 = load i32, ptr %125, align 4, !tbaa !9
  %2193 = add nsw i32 %2192, 2
  %2194 = load i32, ptr %51, align 4, !tbaa !9
  %2195 = mul nsw i32 %2193, %2194
  %2196 = add nsw i32 %2191, %2195
  store i32 %2196, ptr %68, align 4, !tbaa !9
  %2197 = load ptr, ptr %39, align 8, !tbaa !5
  %2198 = load i32, ptr %67, align 4, !tbaa !9
  %2199 = sext i32 %2198 to i64
  %2200 = getelementptr inbounds %struct.doublecomplex, ptr %2197, i64 %2199
  %2201 = getelementptr inbounds %struct.doublecomplex, ptr %2200, i32 0, i32 0
  %2202 = load double, ptr %2201, align 8, !tbaa !13
  %2203 = load ptr, ptr %41, align 8, !tbaa !5
  %2204 = load i32, ptr %68, align 4, !tbaa !9
  %2205 = sext i32 %2204 to i64
  %2206 = getelementptr inbounds %struct.doublecomplex, ptr %2203, i64 %2205
  %2207 = getelementptr inbounds %struct.doublecomplex, ptr %2206, i32 0, i32 0
  %2208 = load double, ptr %2207, align 8, !tbaa !13
  %2209 = load ptr, ptr %39, align 8, !tbaa !5
  %2210 = load i32, ptr %67, align 4, !tbaa !9
  %2211 = sext i32 %2210 to i64
  %2212 = getelementptr inbounds %struct.doublecomplex, ptr %2209, i64 %2211
  %2213 = getelementptr inbounds %struct.doublecomplex, ptr %2212, i32 0, i32 1
  %2214 = load double, ptr %2213, align 8, !tbaa !15
  %2215 = load ptr, ptr %41, align 8, !tbaa !5
  %2216 = load i32, ptr %68, align 4, !tbaa !9
  %2217 = sext i32 %2216 to i64
  %2218 = getelementptr inbounds %struct.doublecomplex, ptr %2215, i64 %2217
  %2219 = getelementptr inbounds %struct.doublecomplex, ptr %2218, i32 0, i32 1
  %2220 = load double, ptr %2219, align 8, !tbaa !15
  %2221 = fmul double %2214, %2220
  %2222 = fneg double %2221
  %2223 = call double @llvm.fmuladd.f64(double %2202, double %2208, double %2222)
  %2224 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %2223, ptr %2224, align 8, !tbaa !13
  %2225 = load ptr, ptr %39, align 8, !tbaa !5
  %2226 = load i32, ptr %67, align 4, !tbaa !9
  %2227 = sext i32 %2226 to i64
  %2228 = getelementptr inbounds %struct.doublecomplex, ptr %2225, i64 %2227
  %2229 = getelementptr inbounds %struct.doublecomplex, ptr %2228, i32 0, i32 0
  %2230 = load double, ptr %2229, align 8, !tbaa !13
  %2231 = load ptr, ptr %41, align 8, !tbaa !5
  %2232 = load i32, ptr %68, align 4, !tbaa !9
  %2233 = sext i32 %2232 to i64
  %2234 = getelementptr inbounds %struct.doublecomplex, ptr %2231, i64 %2233
  %2235 = getelementptr inbounds %struct.doublecomplex, ptr %2234, i32 0, i32 1
  %2236 = load double, ptr %2235, align 8, !tbaa !15
  %2237 = load ptr, ptr %39, align 8, !tbaa !5
  %2238 = load i32, ptr %67, align 4, !tbaa !9
  %2239 = sext i32 %2238 to i64
  %2240 = getelementptr inbounds %struct.doublecomplex, ptr %2237, i64 %2239
  %2241 = getelementptr inbounds %struct.doublecomplex, ptr %2240, i32 0, i32 1
  %2242 = load double, ptr %2241, align 8, !tbaa !15
  %2243 = load ptr, ptr %41, align 8, !tbaa !5
  %2244 = load i32, ptr %68, 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
  %2248 = load double, ptr %2247, align 8, !tbaa !13
  %2249 = fmul double %2242, %2248
  %2250 = call double @llvm.fmuladd.f64(double %2230, double %2236, double %2249)
  %2251 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %2250, ptr %2251, align 8, !tbaa !15
  %2252 = load ptr, ptr %41, align 8, !tbaa !5
  %2253 = load i32, ptr %65, align 4, !tbaa !9
  %2254 = sext i32 %2253 to i64
  %2255 = getelementptr inbounds %struct.doublecomplex, ptr %2252, i64 %2254
  %2256 = getelementptr inbounds %struct.doublecomplex, ptr %2255, i32 0, i32 0
  %2257 = load double, ptr %2256, align 8, !tbaa !13
  %2258 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2259 = load double, ptr %2258, align 8, !tbaa !13
  %2260 = fadd double %2257, %2259
  %2261 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2260, ptr %2261, align 8, !tbaa !13
  %2262 = load ptr, ptr %41, align 8, !tbaa !5
  %2263 = load i32, ptr %65, align 4, !tbaa !9
  %2264 = sext i32 %2263 to i64
  %2265 = getelementptr inbounds %struct.doublecomplex, ptr %2262, i64 %2264
  %2266 = getelementptr inbounds %struct.doublecomplex, ptr %2265, i32 0, i32 1
  %2267 = load double, ptr %2266, align 8, !tbaa !15
  %2268 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2269 = load double, ptr %2268, align 8, !tbaa !15
  %2270 = fadd double %2267, %2269
  %2271 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2270, ptr %2271, align 8, !tbaa !15
  %2272 = load ptr, ptr %39, align 8, !tbaa !5
  %2273 = load i32, ptr %64, align 4, !tbaa !9
  %2274 = sext i32 %2273 to i64
  %2275 = getelementptr inbounds %struct.doublecomplex, ptr %2272, i64 %2274
  %2276 = getelementptr inbounds %struct.doublecomplex, ptr %2275, i32 0, i32 0
  %2277 = load double, ptr %2276, align 8, !tbaa !13
  %2278 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2279 = load double, ptr %2278, align 8, !tbaa !13
  %2280 = load ptr, ptr %39, align 8, !tbaa !5
  %2281 = load i32, ptr %64, align 4, !tbaa !9
  %2282 = sext i32 %2281 to i64
  %2283 = getelementptr inbounds %struct.doublecomplex, ptr %2280, i64 %2282
  %2284 = getelementptr inbounds %struct.doublecomplex, ptr %2283, i32 0, i32 1
  %2285 = load double, ptr %2284, align 8, !tbaa !15
  %2286 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2287 = load double, ptr %2286, align 8, !tbaa !15
  %2288 = fmul double %2285, %2287
  %2289 = fneg double %2288
  %2290 = call double @llvm.fmuladd.f64(double %2277, double %2279, double %2289)
  %2291 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2290, ptr %2291, align 8, !tbaa !13
  %2292 = load ptr, ptr %39, align 8, !tbaa !5
  %2293 = load i32, ptr %64, align 4, !tbaa !9
  %2294 = sext i32 %2293 to i64
  %2295 = getelementptr inbounds %struct.doublecomplex, ptr %2292, i64 %2294
  %2296 = getelementptr inbounds %struct.doublecomplex, ptr %2295, i32 0, i32 0
  %2297 = load double, ptr %2296, align 8, !tbaa !13
  %2298 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2299 = load double, ptr %2298, align 8, !tbaa !15
  %2300 = load ptr, ptr %39, align 8, !tbaa !5
  %2301 = load i32, ptr %64, align 4, !tbaa !9
  %2302 = sext i32 %2301 to i64
  %2303 = getelementptr inbounds %struct.doublecomplex, ptr %2300, i64 %2302
  %2304 = getelementptr inbounds %struct.doublecomplex, ptr %2303, i32 0, i32 1
  %2305 = load double, ptr %2304, align 8, !tbaa !15
  %2306 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2307 = load double, ptr %2306, align 8, !tbaa !13
  %2308 = fmul double %2305, %2307
  %2309 = call double @llvm.fmuladd.f64(double %2297, double %2299, double %2308)
  %2310 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2309, ptr %2310, align 8, !tbaa !15
  %2311 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2312 = load double, ptr %2311, align 8, !tbaa !13
  %2313 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %2312, ptr %2313, align 8, !tbaa !13
  %2314 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2315 = load double, ptr %2314, align 8, !tbaa !15
  %2316 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %2315, ptr %2316, align 8, !tbaa !15
  %2317 = load i32, ptr %99, align 4, !tbaa !9
  %2318 = load i32, ptr %125, align 4, !tbaa !9
  %2319 = add nsw i32 %2318, 1
  %2320 = load i32, ptr %51, align 4, !tbaa !9
  %2321 = mul nsw i32 %2319, %2320
  %2322 = add nsw i32 %2317, %2321
  store i32 %2322, ptr %64, align 4, !tbaa !9
  %2323 = load i32, ptr %99, align 4, !tbaa !9
  %2324 = load i32, ptr %125, align 4, !tbaa !9
  %2325 = add nsw i32 %2324, 1
  %2326 = load i32, ptr %51, align 4, !tbaa !9
  %2327 = mul nsw i32 %2325, %2326
  %2328 = add nsw i32 %2323, %2327
  store i32 %2328, ptr %65, align 4, !tbaa !9
  %2329 = load ptr, ptr %41, align 8, !tbaa !5
  %2330 = load i32, ptr %65, align 4, !tbaa !9
  %2331 = sext i32 %2330 to i64
  %2332 = getelementptr inbounds %struct.doublecomplex, ptr %2329, i64 %2331
  %2333 = getelementptr inbounds %struct.doublecomplex, ptr %2332, i32 0, i32 0
  %2334 = load double, ptr %2333, align 8, !tbaa !13
  %2335 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2336 = load double, ptr %2335, align 8, !tbaa !13
  %2337 = fsub double %2334, %2336
  %2338 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2337, ptr %2338, align 8, !tbaa !13
  %2339 = load ptr, ptr %41, align 8, !tbaa !5
  %2340 = load i32, ptr %65, align 4, !tbaa !9
  %2341 = sext i32 %2340 to i64
  %2342 = getelementptr inbounds %struct.doublecomplex, ptr %2339, i64 %2341
  %2343 = getelementptr inbounds %struct.doublecomplex, ptr %2342, i32 0, i32 1
  %2344 = load double, ptr %2343, align 8, !tbaa !15
  %2345 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2346 = load double, ptr %2345, align 8, !tbaa !15
  %2347 = fsub double %2344, %2346
  %2348 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2347, ptr %2348, align 8, !tbaa !15
  %2349 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2350 = load double, ptr %2349, align 8, !tbaa !13
  %2351 = load ptr, ptr %41, align 8, !tbaa !5
  %2352 = load i32, ptr %64, align 4, !tbaa !9
  %2353 = sext i32 %2352 to i64
  %2354 = getelementptr inbounds %struct.doublecomplex, ptr %2351, i64 %2353
  %2355 = getelementptr inbounds %struct.doublecomplex, ptr %2354, i32 0, i32 0
  store double %2350, ptr %2355, align 8, !tbaa !13
  %2356 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2357 = load double, ptr %2356, align 8, !tbaa !15
  %2358 = load ptr, ptr %41, align 8, !tbaa !5
  %2359 = load i32, ptr %64, align 4, !tbaa !9
  %2360 = sext i32 %2359 to i64
  %2361 = getelementptr inbounds %struct.doublecomplex, ptr %2358, i64 %2360
  %2362 = getelementptr inbounds %struct.doublecomplex, ptr %2361, i32 0, i32 1
  store double %2357, ptr %2362, align 8, !tbaa !15
  %2363 = load i32, ptr %99, align 4, !tbaa !9
  %2364 = load i32, ptr %125, align 4, !tbaa !9
  %2365 = add nsw i32 %2364, 2
  %2366 = load i32, ptr %51, align 4, !tbaa !9
  %2367 = mul nsw i32 %2365, %2366
  %2368 = add nsw i32 %2363, %2367
  store i32 %2368, ptr %64, align 4, !tbaa !9
  %2369 = load i32, ptr %99, align 4, !tbaa !9
  %2370 = load i32, ptr %125, align 4, !tbaa !9
  %2371 = add nsw i32 %2370, 2
  %2372 = load i32, ptr %51, align 4, !tbaa !9
  %2373 = mul nsw i32 %2371, %2372
  %2374 = add nsw i32 %2369, %2373
  store i32 %2374, ptr %65, align 4, !tbaa !9
  %2375 = load ptr, ptr %39, align 8, !tbaa !5
  %2376 = load i32, ptr %115, align 4, !tbaa !9
  %2377 = load i32, ptr %53, align 4, !tbaa !9
  %2378 = mul nsw i32 %2376, %2377
  %2379 = add nsw i32 %2378, 2
  %2380 = sext i32 %2379 to i64
  %2381 = getelementptr inbounds %struct.doublecomplex, ptr %2375, i64 %2380
  %2382 = call { double, double } @Cd(ptr noundef %2381)
  %2383 = extractvalue { double, double } %2382, 0
  %2384 = extractvalue { double, double } %2382, 1
  %2385 = fneg double %2384
  %2386 = call ptr @_pCd(ptr noundef %84)
  %2387 = getelementptr inbounds { double, double }, ptr %2386, i32 0, i32 0
  %2388 = getelementptr inbounds { double, double }, ptr %2386, i32 0, i32 1
  store double %2383, ptr %2387, align 8
  store double %2385, ptr %2388, align 8
  %2389 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2390 = load double, ptr %2389, align 8, !tbaa !13
  %2391 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2392 = load double, ptr %2391, align 8, !tbaa !13
  %2393 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2394 = load double, ptr %2393, align 8, !tbaa !15
  %2395 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2396 = load double, ptr %2395, align 8, !tbaa !15
  %2397 = fmul double %2394, %2396
  %2398 = fneg double %2397
  %2399 = call double @llvm.fmuladd.f64(double %2390, double %2392, double %2398)
  %2400 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2399, ptr %2400, align 8, !tbaa !13
  %2401 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2402 = load double, ptr %2401, align 8, !tbaa !13
  %2403 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2404 = load double, ptr %2403, align 8, !tbaa !15
  %2405 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2406 = load double, ptr %2405, align 8, !tbaa !15
  %2407 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2408 = load double, ptr %2407, align 8, !tbaa !13
  %2409 = fmul double %2406, %2408
  %2410 = call double @llvm.fmuladd.f64(double %2402, double %2404, double %2409)
  %2411 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2410, ptr %2411, align 8, !tbaa !15
  %2412 = load ptr, ptr %41, align 8, !tbaa !5
  %2413 = load i32, ptr %65, align 4, !tbaa !9
  %2414 = sext i32 %2413 to i64
  %2415 = getelementptr inbounds %struct.doublecomplex, ptr %2412, i64 %2414
  %2416 = getelementptr inbounds %struct.doublecomplex, ptr %2415, i32 0, i32 0
  %2417 = load double, ptr %2416, align 8, !tbaa !13
  %2418 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2419 = load double, ptr %2418, align 8, !tbaa !13
  %2420 = fsub double %2417, %2419
  %2421 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2420, ptr %2421, align 8, !tbaa !13
  %2422 = load ptr, ptr %41, align 8, !tbaa !5
  %2423 = load i32, ptr %65, align 4, !tbaa !9
  %2424 = sext i32 %2423 to i64
  %2425 = getelementptr inbounds %struct.doublecomplex, ptr %2422, i64 %2424
  %2426 = getelementptr inbounds %struct.doublecomplex, ptr %2425, i32 0, i32 1
  %2427 = load double, ptr %2426, align 8, !tbaa !15
  %2428 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2429 = load double, ptr %2428, align 8, !tbaa !15
  %2430 = fsub double %2427, %2429
  %2431 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2430, ptr %2431, align 8, !tbaa !15
  %2432 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2433 = load double, ptr %2432, align 8, !tbaa !13
  %2434 = load ptr, ptr %41, align 8, !tbaa !5
  %2435 = load i32, ptr %64, align 4, !tbaa !9
  %2436 = sext i32 %2435 to i64
  %2437 = getelementptr inbounds %struct.doublecomplex, ptr %2434, i64 %2436
  %2438 = getelementptr inbounds %struct.doublecomplex, ptr %2437, i32 0, i32 0
  store double %2433, ptr %2438, align 8, !tbaa !13
  %2439 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2440 = load double, ptr %2439, align 8, !tbaa !15
  %2441 = load ptr, ptr %41, align 8, !tbaa !5
  %2442 = load i32, ptr %64, align 4, !tbaa !9
  %2443 = sext i32 %2442 to i64
  %2444 = getelementptr inbounds %struct.doublecomplex, ptr %2441, i64 %2443
  %2445 = getelementptr inbounds %struct.doublecomplex, ptr %2444, i32 0, i32 1
  store double %2440, ptr %2445, align 8, !tbaa !15
  br label %2446

2446:                                             ; preds = %2176
  %2447 = load i32, ptr %99, align 4, !tbaa !9
  %2448 = add nsw i32 %2447, 1
  store i32 %2448, ptr %99, align 4, !tbaa !9
  br label %2172, !llvm.loop !19

2449:                                             ; preds = %2172
  br label %2738

2450:                                             ; preds = %2151
  %2451 = load ptr, ptr %26, align 8, !tbaa !5
  %2452 = load i32, ptr %2451, align 4, !tbaa !9
  %2453 = icmp ne i32 %2452, 0
  br i1 %2453, label %2454, label %2737

2454:                                             ; preds = %2450
  %2455 = load ptr, ptr %36, align 8, !tbaa !5
  %2456 = load i32, ptr %2455, align 4, !tbaa !9
  store i32 %2456, ptr %66, align 4, !tbaa !9
  %2457 = load ptr, ptr %35, align 8, !tbaa !5
  %2458 = load i32, ptr %2457, align 4, !tbaa !9
  store i32 %2458, ptr %99, align 4, !tbaa !9
  br label %2459

2459:                                             ; preds = %2733, %2454
  %2460 = load i32, ptr %99, align 4, !tbaa !9
  %2461 = load i32, ptr %66, align 4, !tbaa !9
  %2462 = icmp sle i32 %2460, %2461
  br i1 %2462, label %2463, label %2736

2463:                                             ; preds = %2459
  %2464 = load i32, ptr %115, align 4, !tbaa !9
  %2465 = load i32, ptr %53, align 4, !tbaa !9
  %2466 = mul nsw i32 %2464, %2465
  %2467 = add nsw i32 %2466, 1
  store i32 %2467, ptr %64, align 4, !tbaa !9
  %2468 = load i32, ptr %99, align 4, !tbaa !9
  %2469 = load i32, ptr %100, align 4, !tbaa !9
  %2470 = add nsw i32 %2469, 1
  %2471 = load i32, ptr %59, align 4, !tbaa !9
  %2472 = mul nsw i32 %2470, %2471
  %2473 = add nsw i32 %2468, %2472
  store i32 %2473, ptr %65, align 4, !tbaa !9
  %2474 = load i32, ptr %115, align 4, !tbaa !9
  %2475 = load i32, ptr %53, align 4, !tbaa !9
  %2476 = mul nsw i32 %2474, %2475
  %2477 = add nsw i32 %2476, 2
  store i32 %2477, ptr %67, align 4, !tbaa !9
  %2478 = load i32, ptr %99, align 4, !tbaa !9
  %2479 = load i32, ptr %100, align 4, !tbaa !9
  %2480 = add nsw i32 %2479, 2
  %2481 = load i32, ptr %59, align 4, !tbaa !9
  %2482 = mul nsw i32 %2480, %2481
  %2483 = add nsw i32 %2478, %2482
  store i32 %2483, ptr %68, align 4, !tbaa !9
  %2484 = load ptr, ptr %39, align 8, !tbaa !5
  %2485 = load i32, ptr %67, align 4, !tbaa !9
  %2486 = sext i32 %2485 to i64
  %2487 = getelementptr inbounds %struct.doublecomplex, ptr %2484, i64 %2486
  %2488 = getelementptr inbounds %struct.doublecomplex, ptr %2487, i32 0, i32 0
  %2489 = load double, ptr %2488, align 8, !tbaa !13
  %2490 = load ptr, ptr %37, align 8, !tbaa !5
  %2491 = load i32, ptr %68, align 4, !tbaa !9
  %2492 = sext i32 %2491 to i64
  %2493 = getelementptr inbounds %struct.doublecomplex, ptr %2490, i64 %2492
  %2494 = getelementptr inbounds %struct.doublecomplex, ptr %2493, i32 0, i32 0
  %2495 = load double, ptr %2494, align 8, !tbaa !13
  %2496 = load ptr, ptr %39, align 8, !tbaa !5
  %2497 = load i32, ptr %67, 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 !15
  %2502 = load ptr, ptr %37, align 8, !tbaa !5
  %2503 = load i32, ptr %68, align 4, !tbaa !9
  %2504 = sext i32 %2503 to i64
  %2505 = getelementptr inbounds %struct.doublecomplex, ptr %2502, i64 %2504
  %2506 = getelementptr inbounds %struct.doublecomplex, ptr %2505, i32 0, i32 1
  %2507 = load double, ptr %2506, align 8, !tbaa !15
  %2508 = fmul double %2501, %2507
  %2509 = fneg double %2508
  %2510 = call double @llvm.fmuladd.f64(double %2489, double %2495, double %2509)
  %2511 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %2510, ptr %2511, align 8, !tbaa !13
  %2512 = load ptr, ptr %39, align 8, !tbaa !5
  %2513 = load i32, ptr %67, align 4, !tbaa !9
  %2514 = sext i32 %2513 to i64
  %2515 = getelementptr inbounds %struct.doublecomplex, ptr %2512, i64 %2514
  %2516 = getelementptr inbounds %struct.doublecomplex, ptr %2515, i32 0, i32 0
  %2517 = load double, ptr %2516, align 8, !tbaa !13
  %2518 = load ptr, ptr %37, align 8, !tbaa !5
  %2519 = load i32, ptr %68, align 4, !tbaa !9
  %2520 = sext i32 %2519 to i64
  %2521 = getelementptr inbounds %struct.doublecomplex, ptr %2518, i64 %2520
  %2522 = getelementptr inbounds %struct.doublecomplex, ptr %2521, i32 0, i32 1
  %2523 = load double, ptr %2522, align 8, !tbaa !15
  %2524 = load ptr, ptr %39, align 8, !tbaa !5
  %2525 = load i32, ptr %67, align 4, !tbaa !9
  %2526 = sext i32 %2525 to i64
  %2527 = getelementptr inbounds %struct.doublecomplex, ptr %2524, i64 %2526
  %2528 = getelementptr inbounds %struct.doublecomplex, ptr %2527, i32 0, i32 1
  %2529 = load double, ptr %2528, align 8, !tbaa !15
  %2530 = load ptr, ptr %37, align 8, !tbaa !5
  %2531 = load i32, ptr %68, align 4, !tbaa !9
  %2532 = sext i32 %2531 to i64
  %2533 = getelementptr inbounds %struct.doublecomplex, ptr %2530, i64 %2532
  %2534 = getelementptr inbounds %struct.doublecomplex, ptr %2533, i32 0, i32 0
  %2535 = load double, ptr %2534, align 8, !tbaa !13
  %2536 = fmul double %2529, %2535
  %2537 = call double @llvm.fmuladd.f64(double %2517, double %2523, double %2536)
  %2538 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %2537, ptr %2538, align 8, !tbaa !15
  %2539 = load ptr, ptr %37, align 8, !tbaa !5
  %2540 = load i32, ptr %65, align 4, !tbaa !9
  %2541 = sext i32 %2540 to i64
  %2542 = getelementptr inbounds %struct.doublecomplex, ptr %2539, i64 %2541
  %2543 = getelementptr inbounds %struct.doublecomplex, ptr %2542, i32 0, i32 0
  %2544 = load double, ptr %2543, align 8, !tbaa !13
  %2545 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2546 = load double, ptr %2545, align 8, !tbaa !13
  %2547 = fadd double %2544, %2546
  %2548 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2547, ptr %2548, align 8, !tbaa !13
  %2549 = load ptr, ptr %37, align 8, !tbaa !5
  %2550 = load i32, ptr %65, align 4, !tbaa !9
  %2551 = sext i32 %2550 to i64
  %2552 = getelementptr inbounds %struct.doublecomplex, ptr %2549, i64 %2551
  %2553 = getelementptr inbounds %struct.doublecomplex, ptr %2552, i32 0, i32 1
  %2554 = load double, ptr %2553, align 8, !tbaa !15
  %2555 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2556 = load double, ptr %2555, align 8, !tbaa !15
  %2557 = fadd double %2554, %2556
  %2558 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2557, ptr %2558, align 8, !tbaa !15
  %2559 = load ptr, ptr %39, align 8, !tbaa !5
  %2560 = load i32, ptr %64, align 4, !tbaa !9
  %2561 = sext i32 %2560 to i64
  %2562 = getelementptr inbounds %struct.doublecomplex, ptr %2559, i64 %2561
  %2563 = getelementptr inbounds %struct.doublecomplex, ptr %2562, i32 0, i32 0
  %2564 = load double, ptr %2563, align 8, !tbaa !13
  %2565 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2566 = load double, ptr %2565, align 8, !tbaa !13
  %2567 = load ptr, ptr %39, align 8, !tbaa !5
  %2568 = load i32, ptr %64, align 4, !tbaa !9
  %2569 = sext i32 %2568 to i64
  %2570 = getelementptr inbounds %struct.doublecomplex, ptr %2567, i64 %2569
  %2571 = getelementptr inbounds %struct.doublecomplex, ptr %2570, i32 0, i32 1
  %2572 = load double, ptr %2571, align 8, !tbaa !15
  %2573 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2574 = load double, ptr %2573, align 8, !tbaa !15
  %2575 = fmul double %2572, %2574
  %2576 = fneg double %2575
  %2577 = call double @llvm.fmuladd.f64(double %2564, double %2566, double %2576)
  %2578 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2577, ptr %2578, align 8, !tbaa !13
  %2579 = load ptr, ptr %39, align 8, !tbaa !5
  %2580 = load i32, ptr %64, align 4, !tbaa !9
  %2581 = sext i32 %2580 to i64
  %2582 = getelementptr inbounds %struct.doublecomplex, ptr %2579, i64 %2581
  %2583 = getelementptr inbounds %struct.doublecomplex, ptr %2582, i32 0, i32 0
  %2584 = load double, ptr %2583, align 8, !tbaa !13
  %2585 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2586 = load double, ptr %2585, align 8, !tbaa !15
  %2587 = load ptr, ptr %39, align 8, !tbaa !5
  %2588 = load i32, ptr %64, align 4, !tbaa !9
  %2589 = sext i32 %2588 to i64
  %2590 = getelementptr inbounds %struct.doublecomplex, ptr %2587, i64 %2589
  %2591 = getelementptr inbounds %struct.doublecomplex, ptr %2590, i32 0, i32 1
  %2592 = load double, ptr %2591, align 8, !tbaa !15
  %2593 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2594 = load double, ptr %2593, align 8, !tbaa !13
  %2595 = fmul double %2592, %2594
  %2596 = call double @llvm.fmuladd.f64(double %2584, double %2586, double %2595)
  %2597 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2596, ptr %2597, align 8, !tbaa !15
  %2598 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2599 = load double, ptr %2598, align 8, !tbaa !13
  %2600 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %2599, ptr %2600, align 8, !tbaa !13
  %2601 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2602 = load double, ptr %2601, align 8, !tbaa !15
  %2603 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %2602, ptr %2603, align 8, !tbaa !15
  %2604 = load i32, ptr %99, align 4, !tbaa !9
  %2605 = load i32, ptr %100, align 4, !tbaa !9
  %2606 = add nsw i32 %2605, 1
  %2607 = load i32, ptr %59, align 4, !tbaa !9
  %2608 = mul nsw i32 %2606, %2607
  %2609 = add nsw i32 %2604, %2608
  store i32 %2609, ptr %64, align 4, !tbaa !9
  %2610 = load i32, ptr %99, align 4, !tbaa !9
  %2611 = load i32, ptr %100, align 4, !tbaa !9
  %2612 = add nsw i32 %2611, 1
  %2613 = load i32, ptr %59, align 4, !tbaa !9
  %2614 = mul nsw i32 %2612, %2613
  %2615 = add nsw i32 %2610, %2614
  store i32 %2615, ptr %65, align 4, !tbaa !9
  %2616 = load ptr, ptr %37, align 8, !tbaa !5
  %2617 = load i32, ptr %65, align 4, !tbaa !9
  %2618 = sext i32 %2617 to i64
  %2619 = getelementptr inbounds %struct.doublecomplex, ptr %2616, i64 %2618
  %2620 = getelementptr inbounds %struct.doublecomplex, ptr %2619, i32 0, i32 0
  %2621 = load double, ptr %2620, align 8, !tbaa !13
  %2622 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2623 = load double, ptr %2622, align 8, !tbaa !13
  %2624 = fsub double %2621, %2623
  %2625 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2624, ptr %2625, align 8, !tbaa !13
  %2626 = load ptr, ptr %37, align 8, !tbaa !5
  %2627 = load i32, ptr %65, align 4, !tbaa !9
  %2628 = sext i32 %2627 to i64
  %2629 = getelementptr inbounds %struct.doublecomplex, ptr %2626, i64 %2628
  %2630 = getelementptr inbounds %struct.doublecomplex, ptr %2629, i32 0, i32 1
  %2631 = load double, ptr %2630, align 8, !tbaa !15
  %2632 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2633 = load double, ptr %2632, align 8, !tbaa !15
  %2634 = fsub double %2631, %2633
  %2635 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2634, ptr %2635, align 8, !tbaa !15
  %2636 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2637 = load double, ptr %2636, align 8, !tbaa !13
  %2638 = load ptr, ptr %37, align 8, !tbaa !5
  %2639 = load i32, ptr %64, align 4, !tbaa !9
  %2640 = sext i32 %2639 to i64
  %2641 = getelementptr inbounds %struct.doublecomplex, ptr %2638, i64 %2640
  %2642 = getelementptr inbounds %struct.doublecomplex, ptr %2641, i32 0, i32 0
  store double %2637, ptr %2642, align 8, !tbaa !13
  %2643 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2644 = load double, ptr %2643, align 8, !tbaa !15
  %2645 = load ptr, ptr %37, align 8, !tbaa !5
  %2646 = load i32, ptr %64, align 4, !tbaa !9
  %2647 = sext i32 %2646 to i64
  %2648 = getelementptr inbounds %struct.doublecomplex, ptr %2645, i64 %2647
  %2649 = getelementptr inbounds %struct.doublecomplex, ptr %2648, i32 0, i32 1
  store double %2644, ptr %2649, align 8, !tbaa !15
  %2650 = load i32, ptr %99, align 4, !tbaa !9
  %2651 = load i32, ptr %100, align 4, !tbaa !9
  %2652 = add nsw i32 %2651, 2
  %2653 = load i32, ptr %59, align 4, !tbaa !9
  %2654 = mul nsw i32 %2652, %2653
  %2655 = add nsw i32 %2650, %2654
  store i32 %2655, ptr %64, align 4, !tbaa !9
  %2656 = load i32, ptr %99, align 4, !tbaa !9
  %2657 = load i32, ptr %100, align 4, !tbaa !9
  %2658 = add nsw i32 %2657, 2
  %2659 = load i32, ptr %59, align 4, !tbaa !9
  %2660 = mul nsw i32 %2658, %2659
  %2661 = add nsw i32 %2656, %2660
  store i32 %2661, ptr %65, align 4, !tbaa !9
  %2662 = load ptr, ptr %39, align 8, !tbaa !5
  %2663 = load i32, ptr %115, align 4, !tbaa !9
  %2664 = load i32, ptr %53, align 4, !tbaa !9
  %2665 = mul nsw i32 %2663, %2664
  %2666 = add nsw i32 %2665, 2
  %2667 = sext i32 %2666 to i64
  %2668 = getelementptr inbounds %struct.doublecomplex, ptr %2662, i64 %2667
  %2669 = call { double, double } @Cd(ptr noundef %2668)
  %2670 = extractvalue { double, double } %2669, 0
  %2671 = extractvalue { double, double } %2669, 1
  %2672 = fneg double %2671
  %2673 = call ptr @_pCd(ptr noundef %84)
  %2674 = getelementptr inbounds { double, double }, ptr %2673, i32 0, i32 0
  %2675 = getelementptr inbounds { double, double }, ptr %2673, i32 0, i32 1
  store double %2670, ptr %2674, align 8
  store double %2672, ptr %2675, align 8
  %2676 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2677 = load double, ptr %2676, align 8, !tbaa !13
  %2678 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2679 = load double, ptr %2678, align 8, !tbaa !13
  %2680 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2681 = load double, ptr %2680, align 8, !tbaa !15
  %2682 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2683 = load double, ptr %2682, align 8, !tbaa !15
  %2684 = fmul double %2681, %2683
  %2685 = fneg double %2684
  %2686 = call double @llvm.fmuladd.f64(double %2677, double %2679, double %2685)
  %2687 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2686, ptr %2687, align 8, !tbaa !13
  %2688 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2689 = load double, ptr %2688, align 8, !tbaa !13
  %2690 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2691 = load double, ptr %2690, align 8, !tbaa !15
  %2692 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2693 = load double, ptr %2692, align 8, !tbaa !15
  %2694 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2695 = load double, ptr %2694, align 8, !tbaa !13
  %2696 = fmul double %2693, %2695
  %2697 = call double @llvm.fmuladd.f64(double %2689, double %2691, double %2696)
  %2698 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2697, ptr %2698, align 8, !tbaa !15
  %2699 = load ptr, ptr %37, align 8, !tbaa !5
  %2700 = load i32, ptr %65, align 4, !tbaa !9
  %2701 = sext i32 %2700 to i64
  %2702 = getelementptr inbounds %struct.doublecomplex, ptr %2699, i64 %2701
  %2703 = getelementptr inbounds %struct.doublecomplex, ptr %2702, i32 0, i32 0
  %2704 = load double, ptr %2703, align 8, !tbaa !13
  %2705 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2706 = load double, ptr %2705, align 8, !tbaa !13
  %2707 = fsub double %2704, %2706
  %2708 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2707, ptr %2708, align 8, !tbaa !13
  %2709 = load ptr, ptr %37, align 8, !tbaa !5
  %2710 = load i32, ptr %65, align 4, !tbaa !9
  %2711 = sext i32 %2710 to i64
  %2712 = getelementptr inbounds %struct.doublecomplex, ptr %2709, i64 %2711
  %2713 = getelementptr inbounds %struct.doublecomplex, ptr %2712, i32 0, i32 1
  %2714 = load double, ptr %2713, align 8, !tbaa !15
  %2715 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2716 = load double, ptr %2715, align 8, !tbaa !15
  %2717 = fsub double %2714, %2716
  %2718 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2717, ptr %2718, align 8, !tbaa !15
  %2719 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2720 = load double, ptr %2719, align 8, !tbaa !13
  %2721 = load ptr, ptr %37, align 8, !tbaa !5
  %2722 = load i32, ptr %64, align 4, !tbaa !9
  %2723 = sext i32 %2722 to i64
  %2724 = getelementptr inbounds %struct.doublecomplex, ptr %2721, i64 %2723
  %2725 = getelementptr inbounds %struct.doublecomplex, ptr %2724, i32 0, i32 0
  store double %2720, ptr %2725, align 8, !tbaa !13
  %2726 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2727 = load double, ptr %2726, align 8, !tbaa !15
  %2728 = load ptr, ptr %37, align 8, !tbaa !5
  %2729 = load i32, ptr %64, align 4, !tbaa !9
  %2730 = sext i32 %2729 to i64
  %2731 = getelementptr inbounds %struct.doublecomplex, ptr %2728, i64 %2730
  %2732 = getelementptr inbounds %struct.doublecomplex, ptr %2731, i32 0, i32 1
  store double %2727, ptr %2732, align 8, !tbaa !15
  br label %2733

2733:                                             ; preds = %2463
  %2734 = load i32, ptr %99, align 4, !tbaa !9
  %2735 = add nsw i32 %2734, 1
  store i32 %2735, ptr %99, align 4, !tbaa !9
  br label %2459, !llvm.loop !20

2736:                                             ; preds = %2459
  br label %2737

2737:                                             ; preds = %2736, %2450
  br label %2738

2738:                                             ; preds = %2737, %2449
  br label %2739

2739:                                             ; preds = %2738, %394
  %2740 = load i32, ptr %98, align 4, !tbaa !9
  store i32 %2740, ptr %66, align 4, !tbaa !9
  %2741 = load i32, ptr %95, align 4, !tbaa !9
  store i32 %2741, ptr %101, align 4, !tbaa !9
  br label %2742

2742:                                             ; preds = %5821, %2739
  %2743 = load i32, ptr %101, align 4, !tbaa !9
  %2744 = load i32, ptr %66, align 4, !tbaa !9
  %2745 = icmp sge i32 %2743, %2744
  br i1 %2745, label %2746, label %5824

2746:                                             ; preds = %2742
  %2747 = load i32, ptr %106, align 4, !tbaa !9
  %2748 = load i32, ptr %101, align 4, !tbaa !9
  %2749 = sub nsw i32 %2748, 1
  %2750 = shl i32 %2749, 1
  %2751 = add nsw i32 %2747, %2750
  store i32 %2751, ptr %100, align 4, !tbaa !9
  %2752 = load i32, ptr %100, align 4, !tbaa !9
  %2753 = load ptr, ptr %29, align 8, !tbaa !5
  %2754 = load i32, ptr %2753, align 4, !tbaa !9
  %2755 = sub nsw i32 %2754, 1
  %2756 = icmp eq i32 %2752, %2755
  br i1 %2756, label %2757, label %2819

2757:                                             ; preds = %2746
  %2758 = load ptr, ptr %33, align 8, !tbaa !5
  %2759 = load ptr, ptr %29, align 8, !tbaa !5
  %2760 = load i32, ptr %2759, align 4, !tbaa !9
  %2761 = load ptr, ptr %29, align 8, !tbaa !5
  %2762 = load i32, ptr %2761, align 4, !tbaa !9
  %2763 = load i32, ptr %49, align 4, !tbaa !9
  %2764 = mul nsw i32 %2762, %2763
  %2765 = add nsw i32 %2760, %2764
  %2766 = sext i32 %2765 to i64
  %2767 = getelementptr inbounds %struct.doublecomplex, ptr %2758, i64 %2766
  %2768 = load ptr, ptr %34, align 8, !tbaa !5
  %2769 = load ptr, ptr %32, align 8, !tbaa !5
  %2770 = load i32, ptr %101, align 4, !tbaa !9
  %2771 = shl i32 %2770, 1
  %2772 = sub nsw i32 %2771, 1
  %2773 = sext i32 %2772 to i64
  %2774 = getelementptr inbounds %struct.doublecomplex, ptr %2769, i64 %2773
  %2775 = load ptr, ptr %32, align 8, !tbaa !5
  %2776 = load i32, ptr %101, align 4, !tbaa !9
  %2777 = mul nsw i32 %2776, 2
  %2778 = sext i32 %2777 to i64
  %2779 = getelementptr inbounds %struct.doublecomplex, ptr %2775, i64 %2778
  %2780 = load ptr, ptr %39, align 8, !tbaa !5
  %2781 = load i32, ptr %101, align 4, !tbaa !9
  %2782 = load i32, ptr %53, align 4, !tbaa !9
  %2783 = mul nsw i32 %2781, %2782
  %2784 = add nsw i32 %2783, 1
  %2785 = sext i32 %2784 to i64
  %2786 = getelementptr inbounds %struct.doublecomplex, ptr %2780, i64 %2785
  call void @zlaqr1_(ptr noundef @c__3, ptr noundef %2767, ptr noundef %2768, ptr noundef %2774, ptr noundef %2779, ptr noundef %2786)
  %2787 = load i32, ptr %101, align 4, !tbaa !9
  %2788 = load i32, ptr %53, align 4, !tbaa !9
  %2789 = mul nsw i32 %2787, %2788
  %2790 = add nsw i32 %2789, 1
  store i32 %2790, ptr %64, align 4, !tbaa !9
  %2791 = load ptr, ptr %39, align 8, !tbaa !5
  %2792 = load i32, ptr %64, 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 0
  %2796 = load double, ptr %2795, align 8, !tbaa !13
  %2797 = getelementptr inbounds %struct.doublecomplex, ptr %102, i32 0, i32 0
  store double %2796, ptr %2797, align 8, !tbaa !13
  %2798 = load ptr, ptr %39, align 8, !tbaa !5
  %2799 = load i32, ptr %64, align 4, !tbaa !9
  %2800 = sext i32 %2799 to i64
  %2801 = getelementptr inbounds %struct.doublecomplex, ptr %2798, i64 %2800
  %2802 = getelementptr inbounds %struct.doublecomplex, ptr %2801, i32 0, i32 1
  %2803 = load double, ptr %2802, align 8, !tbaa !15
  %2804 = getelementptr inbounds %struct.doublecomplex, ptr %102, i32 0, i32 1
  store double %2803, ptr %2804, align 8, !tbaa !15
  %2805 = load ptr, ptr %39, align 8, !tbaa !5
  %2806 = load i32, ptr %101, align 4, !tbaa !9
  %2807 = load i32, ptr %53, align 4, !tbaa !9
  %2808 = mul nsw i32 %2806, %2807
  %2809 = add nsw i32 %2808, 2
  %2810 = sext i32 %2809 to i64
  %2811 = getelementptr inbounds %struct.doublecomplex, ptr %2805, i64 %2810
  %2812 = load ptr, ptr %39, align 8, !tbaa !5
  %2813 = load i32, ptr %101, align 4, !tbaa !9
  %2814 = load i32, ptr %53, align 4, !tbaa !9
  %2815 = mul nsw i32 %2813, %2814
  %2816 = add nsw i32 %2815, 1
  %2817 = sext i32 %2816 to i64
  %2818 = getelementptr inbounds %struct.doublecomplex, ptr %2812, i64 %2817
  call void @zlarfg_(ptr noundef @c__3, ptr noundef %102, ptr noundef %2811, ptr noundef @c__1, ptr noundef %2818)
  br label %3953

2819:                                             ; preds = %2746
  %2820 = load i32, ptr %101, align 4, !tbaa !9
  %2821 = load i32, ptr %53, align 4, !tbaa !9
  %2822 = mul nsw i32 %2820, %2821
  %2823 = add nsw i32 %2822, 1
  store i32 %2823, ptr %64, align 4, !tbaa !9
  %2824 = load i32, ptr %101, align 4, !tbaa !9
  %2825 = load i32, ptr %53, align 4, !tbaa !9
  %2826 = mul nsw i32 %2824, %2825
  %2827 = add nsw i32 %2826, 3
  store i32 %2827, ptr %65, align 4, !tbaa !9
  %2828 = load ptr, ptr %39, align 8, !tbaa !5
  %2829 = load i32, ptr %64, align 4, !tbaa !9
  %2830 = sext i32 %2829 to i64
  %2831 = getelementptr inbounds %struct.doublecomplex, ptr %2828, i64 %2830
  %2832 = getelementptr inbounds %struct.doublecomplex, ptr %2831, i32 0, i32 0
  %2833 = load double, ptr %2832, align 8, !tbaa !13
  %2834 = load ptr, ptr %39, align 8, !tbaa !5
  %2835 = load i32, ptr %65, align 4, !tbaa !9
  %2836 = sext i32 %2835 to i64
  %2837 = getelementptr inbounds %struct.doublecomplex, ptr %2834, i64 %2836
  %2838 = getelementptr inbounds %struct.doublecomplex, ptr %2837, i32 0, i32 0
  %2839 = load double, ptr %2838, align 8, !tbaa !13
  %2840 = load ptr, ptr %39, align 8, !tbaa !5
  %2841 = load i32, ptr %64, align 4, !tbaa !9
  %2842 = sext i32 %2841 to i64
  %2843 = getelementptr inbounds %struct.doublecomplex, ptr %2840, i64 %2842
  %2844 = getelementptr inbounds %struct.doublecomplex, ptr %2843, i32 0, i32 1
  %2845 = load double, ptr %2844, align 8, !tbaa !15
  %2846 = load ptr, ptr %39, align 8, !tbaa !5
  %2847 = load i32, ptr %65, align 4, !tbaa !9
  %2848 = sext i32 %2847 to i64
  %2849 = getelementptr inbounds %struct.doublecomplex, ptr %2846, i64 %2848
  %2850 = getelementptr inbounds %struct.doublecomplex, ptr %2849, i32 0, i32 1
  %2851 = load double, ptr %2850, align 8, !tbaa !15
  %2852 = fmul double %2845, %2851
  %2853 = fneg double %2852
  %2854 = call double @llvm.fmuladd.f64(double %2833, double %2839, double %2853)
  %2855 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2854, ptr %2855, align 8, !tbaa !13
  %2856 = load ptr, ptr %39, align 8, !tbaa !5
  %2857 = load i32, ptr %64, align 4, !tbaa !9
  %2858 = sext i32 %2857 to i64
  %2859 = getelementptr inbounds %struct.doublecomplex, ptr %2856, i64 %2858
  %2860 = getelementptr inbounds %struct.doublecomplex, ptr %2859, i32 0, i32 0
  %2861 = load double, ptr %2860, align 8, !tbaa !13
  %2862 = load ptr, ptr %39, align 8, !tbaa !5
  %2863 = load i32, ptr %65, align 4, !tbaa !9
  %2864 = sext i32 %2863 to i64
  %2865 = getelementptr inbounds %struct.doublecomplex, ptr %2862, i64 %2864
  %2866 = getelementptr inbounds %struct.doublecomplex, ptr %2865, i32 0, i32 1
  %2867 = load double, ptr %2866, align 8, !tbaa !15
  %2868 = load ptr, ptr %39, align 8, !tbaa !5
  %2869 = load i32, ptr %64, align 4, !tbaa !9
  %2870 = sext i32 %2869 to i64
  %2871 = getelementptr inbounds %struct.doublecomplex, ptr %2868, i64 %2870
  %2872 = getelementptr inbounds %struct.doublecomplex, ptr %2871, i32 0, i32 1
  %2873 = load double, ptr %2872, align 8, !tbaa !15
  %2874 = load ptr, ptr %39, align 8, !tbaa !5
  %2875 = load i32, ptr %65, align 4, !tbaa !9
  %2876 = sext i32 %2875 to i64
  %2877 = getelementptr inbounds %struct.doublecomplex, ptr %2874, i64 %2876
  %2878 = getelementptr inbounds %struct.doublecomplex, ptr %2877, i32 0, i32 0
  %2879 = load double, ptr %2878, align 8, !tbaa !13
  %2880 = fmul double %2873, %2879
  %2881 = call double @llvm.fmuladd.f64(double %2861, double %2867, double %2880)
  %2882 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2881, ptr %2882, align 8, !tbaa !15
  %2883 = load i32, ptr %100, align 4, !tbaa !9
  %2884 = add nsw i32 %2883, 3
  %2885 = load i32, ptr %100, align 4, !tbaa !9
  %2886 = add nsw i32 %2885, 2
  %2887 = load i32, ptr %49, align 4, !tbaa !9
  %2888 = mul nsw i32 %2886, %2887
  %2889 = add nsw i32 %2884, %2888
  store i32 %2889, ptr %67, align 4, !tbaa !9
  %2890 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2891 = load double, ptr %2890, align 8, !tbaa !13
  %2892 = load ptr, ptr %33, align 8, !tbaa !5
  %2893 = load i32, ptr %67, align 4, !tbaa !9
  %2894 = sext i32 %2893 to i64
  %2895 = getelementptr inbounds %struct.doublecomplex, ptr %2892, i64 %2894
  %2896 = getelementptr inbounds %struct.doublecomplex, ptr %2895, i32 0, i32 0
  %2897 = load double, ptr %2896, align 8, !tbaa !13
  %2898 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2899 = load double, ptr %2898, align 8, !tbaa !15
  %2900 = load ptr, ptr %33, align 8, !tbaa !5
  %2901 = load i32, ptr %67, align 4, !tbaa !9
  %2902 = sext i32 %2901 to i64
  %2903 = getelementptr inbounds %struct.doublecomplex, ptr %2900, i64 %2902
  %2904 = getelementptr inbounds %struct.doublecomplex, ptr %2903, i32 0, i32 1
  %2905 = load double, ptr %2904, align 8, !tbaa !15
  %2906 = fmul double %2899, %2905
  %2907 = fneg double %2906
  %2908 = call double @llvm.fmuladd.f64(double %2891, double %2897, double %2907)
  %2909 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2908, ptr %2909, align 8, !tbaa !13
  %2910 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2911 = load double, ptr %2910, align 8, !tbaa !13
  %2912 = load ptr, ptr %33, align 8, !tbaa !5
  %2913 = load i32, ptr %67, align 4, !tbaa !9
  %2914 = sext i32 %2913 to i64
  %2915 = getelementptr inbounds %struct.doublecomplex, ptr %2912, i64 %2914
  %2916 = getelementptr inbounds %struct.doublecomplex, ptr %2915, i32 0, i32 1
  %2917 = load double, ptr %2916, align 8, !tbaa !15
  %2918 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2919 = load double, ptr %2918, align 8, !tbaa !15
  %2920 = load ptr, ptr %33, align 8, !tbaa !5
  %2921 = load i32, ptr %67, align 4, !tbaa !9
  %2922 = sext i32 %2921 to i64
  %2923 = getelementptr inbounds %struct.doublecomplex, ptr %2920, i64 %2922
  %2924 = getelementptr inbounds %struct.doublecomplex, ptr %2923, i32 0, i32 0
  %2925 = load double, ptr %2924, align 8, !tbaa !13
  %2926 = fmul double %2919, %2925
  %2927 = call double @llvm.fmuladd.f64(double %2911, double %2917, double %2926)
  %2928 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2927, ptr %2928, align 8, !tbaa !15
  %2929 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2930 = load double, ptr %2929, align 8, !tbaa !13
  %2931 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %2930, ptr %2931, align 8, !tbaa !13
  %2932 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2933 = load double, ptr %2932, align 8, !tbaa !15
  %2934 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %2933, ptr %2934, align 8, !tbaa !15
  %2935 = load i32, ptr %100, align 4, !tbaa !9
  %2936 = add nsw i32 %2935, 3
  %2937 = load i32, ptr %100, align 4, !tbaa !9
  %2938 = load i32, ptr %49, align 4, !tbaa !9
  %2939 = mul nsw i32 %2937, %2938
  %2940 = add nsw i32 %2936, %2939
  store i32 %2940, ptr %64, align 4, !tbaa !9
  %2941 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2942 = load double, ptr %2941, align 8, !tbaa !13
  %2943 = fneg double %2942
  %2944 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %2943, ptr %2944, align 8, !tbaa !13
  %2945 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2946 = load double, ptr %2945, align 8, !tbaa !15
  %2947 = fneg double %2946
  %2948 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %2947, ptr %2948, align 8, !tbaa !15
  %2949 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %2950 = load double, ptr %2949, align 8, !tbaa !13
  %2951 = load ptr, ptr %33, align 8, !tbaa !5
  %2952 = load i32, ptr %64, align 4, !tbaa !9
  %2953 = sext i32 %2952 to i64
  %2954 = getelementptr inbounds %struct.doublecomplex, ptr %2951, i64 %2953
  %2955 = getelementptr inbounds %struct.doublecomplex, ptr %2954, i32 0, i32 0
  store double %2950, ptr %2955, align 8, !tbaa !13
  %2956 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %2957 = load double, ptr %2956, align 8, !tbaa !15
  %2958 = load ptr, ptr %33, align 8, !tbaa !5
  %2959 = load i32, ptr %64, 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 1
  store double %2957, ptr %2962, align 8, !tbaa !15
  %2963 = load i32, ptr %100, align 4, !tbaa !9
  %2964 = add nsw i32 %2963, 3
  %2965 = load i32, ptr %100, align 4, !tbaa !9
  %2966 = add nsw i32 %2965, 1
  %2967 = load i32, ptr %49, align 4, !tbaa !9
  %2968 = mul nsw i32 %2966, %2967
  %2969 = add nsw i32 %2964, %2968
  store i32 %2969, ptr %64, align 4, !tbaa !9
  %2970 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %2971 = load double, ptr %2970, align 8, !tbaa !13
  %2972 = fneg double %2971
  %2973 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %2972, ptr %2973, align 8, !tbaa !13
  %2974 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %2975 = load double, ptr %2974, align 8, !tbaa !15
  %2976 = fneg double %2975
  %2977 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %2976, ptr %2977, align 8, !tbaa !15
  %2978 = load ptr, ptr %39, align 8, !tbaa !5
  %2979 = load i32, ptr %101, align 4, !tbaa !9
  %2980 = load i32, ptr %53, align 4, !tbaa !9
  %2981 = mul nsw i32 %2979, %2980
  %2982 = add nsw i32 %2981, 2
  %2983 = sext i32 %2982 to i64
  %2984 = getelementptr inbounds %struct.doublecomplex, ptr %2978, i64 %2983
  %2985 = call { double, double } @Cd(ptr noundef %2984)
  %2986 = extractvalue { double, double } %2985, 0
  %2987 = extractvalue { double, double } %2985, 1
  %2988 = fneg double %2987
  %2989 = call ptr @_pCd(ptr noundef %84)
  %2990 = getelementptr inbounds { double, double }, ptr %2989, i32 0, i32 0
  %2991 = getelementptr inbounds { double, double }, ptr %2989, i32 0, i32 1
  store double %2986, ptr %2990, align 8
  store double %2988, ptr %2991, align 8
  %2992 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %2993 = load double, ptr %2992, align 8, !tbaa !13
  %2994 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %2995 = load double, ptr %2994, align 8, !tbaa !13
  %2996 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %2997 = load double, ptr %2996, align 8, !tbaa !15
  %2998 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %2999 = load double, ptr %2998, align 8, !tbaa !15
  %3000 = fmul double %2997, %2999
  %3001 = fneg double %3000
  %3002 = call double @llvm.fmuladd.f64(double %2993, double %2995, double %3001)
  %3003 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %3002, ptr %3003, align 8, !tbaa !13
  %3004 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %3005 = load double, ptr %3004, align 8, !tbaa !13
  %3006 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3007 = load double, ptr %3006, align 8, !tbaa !15
  %3008 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %3009 = load double, ptr %3008, align 8, !tbaa !15
  %3010 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3011 = load double, ptr %3010, align 8, !tbaa !13
  %3012 = fmul double %3009, %3011
  %3013 = call double @llvm.fmuladd.f64(double %3005, double %3007, double %3012)
  %3014 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %3013, ptr %3014, align 8, !tbaa !15
  %3015 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %3016 = load double, ptr %3015, align 8, !tbaa !13
  %3017 = load ptr, ptr %33, align 8, !tbaa !5
  %3018 = load i32, ptr %64, align 4, !tbaa !9
  %3019 = sext i32 %3018 to i64
  %3020 = getelementptr inbounds %struct.doublecomplex, ptr %3017, i64 %3019
  %3021 = getelementptr inbounds %struct.doublecomplex, ptr %3020, i32 0, i32 0
  store double %3016, ptr %3021, align 8, !tbaa !13
  %3022 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %3023 = load double, ptr %3022, align 8, !tbaa !15
  %3024 = load ptr, ptr %33, align 8, !tbaa !5
  %3025 = load i32, ptr %64, align 4, !tbaa !9
  %3026 = sext i32 %3025 to i64
  %3027 = getelementptr inbounds %struct.doublecomplex, ptr %3024, i64 %3026
  %3028 = getelementptr inbounds %struct.doublecomplex, ptr %3027, i32 0, i32 1
  store double %3023, ptr %3028, align 8, !tbaa !15
  %3029 = load i32, ptr %100, align 4, !tbaa !9
  %3030 = add nsw i32 %3029, 3
  %3031 = load i32, ptr %100, align 4, !tbaa !9
  %3032 = add nsw i32 %3031, 2
  %3033 = load i32, ptr %49, align 4, !tbaa !9
  %3034 = mul nsw i32 %3032, %3033
  %3035 = add nsw i32 %3030, %3034
  store i32 %3035, ptr %64, align 4, !tbaa !9
  %3036 = load i32, ptr %100, align 4, !tbaa !9
  %3037 = add nsw i32 %3036, 3
  %3038 = load i32, ptr %100, align 4, !tbaa !9
  %3039 = add nsw i32 %3038, 2
  %3040 = load i32, ptr %49, align 4, !tbaa !9
  %3041 = mul nsw i32 %3039, %3040
  %3042 = add nsw i32 %3037, %3041
  store i32 %3042, ptr %65, align 4, !tbaa !9
  %3043 = load ptr, ptr %39, align 8, !tbaa !5
  %3044 = load i32, ptr %101, align 4, !tbaa !9
  %3045 = load i32, ptr %53, align 4, !tbaa !9
  %3046 = mul nsw i32 %3044, %3045
  %3047 = add nsw i32 %3046, 3
  %3048 = sext i32 %3047 to i64
  %3049 = getelementptr inbounds %struct.doublecomplex, ptr %3043, i64 %3048
  %3050 = call { double, double } @Cd(ptr noundef %3049)
  %3051 = extractvalue { double, double } %3050, 0
  %3052 = extractvalue { double, double } %3050, 1
  %3053 = fneg double %3052
  %3054 = call ptr @_pCd(ptr noundef %84)
  %3055 = getelementptr inbounds { double, double }, ptr %3054, i32 0, i32 0
  %3056 = getelementptr inbounds { double, double }, ptr %3054, i32 0, i32 1
  store double %3051, ptr %3055, align 8
  store double %3053, ptr %3056, align 8
  %3057 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3058 = load double, ptr %3057, align 8, !tbaa !13
  %3059 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3060 = load double, ptr %3059, align 8, !tbaa !13
  %3061 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3062 = load double, ptr %3061, align 8, !tbaa !15
  %3063 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3064 = load double, ptr %3063, align 8, !tbaa !15
  %3065 = fmul double %3062, %3064
  %3066 = fneg double %3065
  %3067 = call double @llvm.fmuladd.f64(double %3058, double %3060, double %3066)
  %3068 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %3067, ptr %3068, align 8, !tbaa !13
  %3069 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3070 = load double, ptr %3069, align 8, !tbaa !13
  %3071 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3072 = load double, ptr %3071, align 8, !tbaa !15
  %3073 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3074 = load double, ptr %3073, align 8, !tbaa !15
  %3075 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3076 = load double, ptr %3075, align 8, !tbaa !13
  %3077 = fmul double %3074, %3076
  %3078 = call double @llvm.fmuladd.f64(double %3070, double %3072, double %3077)
  %3079 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %3078, ptr %3079, align 8, !tbaa !15
  %3080 = load ptr, ptr %33, align 8, !tbaa !5
  %3081 = load i32, ptr %65, align 4, !tbaa !9
  %3082 = sext i32 %3081 to i64
  %3083 = getelementptr inbounds %struct.doublecomplex, ptr %3080, i64 %3082
  %3084 = getelementptr inbounds %struct.doublecomplex, ptr %3083, i32 0, i32 0
  %3085 = load double, ptr %3084, align 8, !tbaa !13
  %3086 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %3087 = load double, ptr %3086, align 8, !tbaa !13
  %3088 = fsub double %3085, %3087
  %3089 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %3088, ptr %3089, align 8, !tbaa !13
  %3090 = load ptr, ptr %33, align 8, !tbaa !5
  %3091 = load i32, ptr %65, 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
  %3095 = load double, ptr %3094, align 8, !tbaa !15
  %3096 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %3097 = load double, ptr %3096, align 8, !tbaa !15
  %3098 = fsub double %3095, %3097
  %3099 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %3098, ptr %3099, align 8, !tbaa !15
  %3100 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %3101 = load double, ptr %3100, align 8, !tbaa !13
  %3102 = load ptr, ptr %33, align 8, !tbaa !5
  %3103 = load i32, ptr %64, align 4, !tbaa !9
  %3104 = sext i32 %3103 to i64
  %3105 = getelementptr inbounds %struct.doublecomplex, ptr %3102, i64 %3104
  %3106 = getelementptr inbounds %struct.doublecomplex, ptr %3105, i32 0, i32 0
  store double %3101, ptr %3106, align 8, !tbaa !13
  %3107 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %3108 = load double, ptr %3107, align 8, !tbaa !15
  %3109 = load ptr, ptr %33, align 8, !tbaa !5
  %3110 = load i32, ptr %64, align 4, !tbaa !9
  %3111 = sext i32 %3110 to i64
  %3112 = getelementptr inbounds %struct.doublecomplex, ptr %3109, i64 %3111
  %3113 = getelementptr inbounds %struct.doublecomplex, ptr %3112, i32 0, i32 1
  store double %3108, ptr %3113, align 8, !tbaa !15
  %3114 = load i32, ptr %100, align 4, !tbaa !9
  %3115 = add nsw i32 %3114, 1
  %3116 = load i32, ptr %100, align 4, !tbaa !9
  %3117 = load i32, ptr %49, align 4, !tbaa !9
  %3118 = mul nsw i32 %3116, %3117
  %3119 = add nsw i32 %3115, %3118
  store i32 %3119, ptr %64, align 4, !tbaa !9
  %3120 = load ptr, ptr %33, align 8, !tbaa !5
  %3121 = load i32, ptr %64, align 4, !tbaa !9
  %3122 = sext i32 %3121 to i64
  %3123 = getelementptr inbounds %struct.doublecomplex, ptr %3120, i64 %3122
  %3124 = getelementptr inbounds %struct.doublecomplex, ptr %3123, i32 0, i32 0
  %3125 = load double, ptr %3124, align 8, !tbaa !13
  %3126 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  store double %3125, ptr %3126, align 8, !tbaa !13
  %3127 = load ptr, ptr %33, align 8, !tbaa !5
  %3128 = load i32, ptr %64, align 4, !tbaa !9
  %3129 = sext i32 %3128 to i64
  %3130 = getelementptr inbounds %struct.doublecomplex, ptr %3127, i64 %3129
  %3131 = getelementptr inbounds %struct.doublecomplex, ptr %3130, i32 0, i32 1
  %3132 = load double, ptr %3131, align 8, !tbaa !15
  %3133 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  store double %3132, ptr %3133, align 8, !tbaa !15
  %3134 = load i32, ptr %101, align 4, !tbaa !9
  %3135 = load i32, ptr %53, align 4, !tbaa !9
  %3136 = mul nsw i32 %3134, %3135
  %3137 = add nsw i32 %3136, 2
  store i32 %3137, ptr %64, align 4, !tbaa !9
  %3138 = load i32, ptr %100, align 4, !tbaa !9
  %3139 = add nsw i32 %3138, 2
  %3140 = load i32, ptr %100, align 4, !tbaa !9
  %3141 = load i32, ptr %49, align 4, !tbaa !9
  %3142 = mul nsw i32 %3140, %3141
  %3143 = add nsw i32 %3139, %3142
  store i32 %3143, ptr %65, align 4, !tbaa !9
  %3144 = load ptr, ptr %33, align 8, !tbaa !5
  %3145 = load i32, ptr %65, align 4, !tbaa !9
  %3146 = sext i32 %3145 to i64
  %3147 = getelementptr inbounds %struct.doublecomplex, ptr %3144, i64 %3146
  %3148 = getelementptr inbounds %struct.doublecomplex, ptr %3147, i32 0, i32 0
  %3149 = load double, ptr %3148, align 8, !tbaa !13
  %3150 = load ptr, ptr %39, align 8, !tbaa !5
  %3151 = load i32, ptr %64, align 4, !tbaa !9
  %3152 = sext i32 %3151 to i64
  %3153 = getelementptr inbounds %struct.doublecomplex, ptr %3150, i64 %3152
  %3154 = getelementptr inbounds %struct.doublecomplex, ptr %3153, i32 0, i32 0
  store double %3149, ptr %3154, align 8, !tbaa !13
  %3155 = load ptr, ptr %33, align 8, !tbaa !5
  %3156 = load i32, ptr %65, 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 1
  %3160 = load double, ptr %3159, align 8, !tbaa !15
  %3161 = load ptr, ptr %39, align 8, !tbaa !5
  %3162 = load i32, ptr %64, align 4, !tbaa !9
  %3163 = sext i32 %3162 to i64
  %3164 = getelementptr inbounds %struct.doublecomplex, ptr %3161, i64 %3163
  %3165 = getelementptr inbounds %struct.doublecomplex, ptr %3164, i32 0, i32 1
  store double %3160, ptr %3165, align 8, !tbaa !15
  %3166 = load i32, ptr %101, align 4, !tbaa !9
  %3167 = load i32, ptr %53, align 4, !tbaa !9
  %3168 = mul nsw i32 %3166, %3167
  %3169 = add nsw i32 %3168, 3
  store i32 %3169, ptr %64, align 4, !tbaa !9
  %3170 = load i32, ptr %100, align 4, !tbaa !9
  %3171 = add nsw i32 %3170, 3
  %3172 = load i32, ptr %100, align 4, !tbaa !9
  %3173 = load i32, ptr %49, align 4, !tbaa !9
  %3174 = mul nsw i32 %3172, %3173
  %3175 = add nsw i32 %3171, %3174
  store i32 %3175, ptr %65, align 4, !tbaa !9
  %3176 = load ptr, ptr %33, align 8, !tbaa !5
  %3177 = load i32, ptr %65, align 4, !tbaa !9
  %3178 = sext i32 %3177 to i64
  %3179 = getelementptr inbounds %struct.doublecomplex, ptr %3176, i64 %3178
  %3180 = getelementptr inbounds %struct.doublecomplex, ptr %3179, i32 0, i32 0
  %3181 = load double, ptr %3180, align 8, !tbaa !13
  %3182 = load ptr, ptr %39, align 8, !tbaa !5
  %3183 = load i32, ptr %64, align 4, !tbaa !9
  %3184 = sext i32 %3183 to i64
  %3185 = getelementptr inbounds %struct.doublecomplex, ptr %3182, i64 %3184
  %3186 = getelementptr inbounds %struct.doublecomplex, ptr %3185, i32 0, i32 0
  store double %3181, ptr %3186, align 8, !tbaa !13
  %3187 = load ptr, ptr %33, align 8, !tbaa !5
  %3188 = load i32, ptr %65, align 4, !tbaa !9
  %3189 = sext i32 %3188 to i64
  %3190 = getelementptr inbounds %struct.doublecomplex, ptr %3187, i64 %3189
  %3191 = getelementptr inbounds %struct.doublecomplex, ptr %3190, i32 0, i32 1
  %3192 = load double, ptr %3191, align 8, !tbaa !15
  %3193 = load ptr, ptr %39, align 8, !tbaa !5
  %3194 = load i32, ptr %64, align 4, !tbaa !9
  %3195 = sext i32 %3194 to i64
  %3196 = getelementptr inbounds %struct.doublecomplex, ptr %3193, i64 %3195
  %3197 = getelementptr inbounds %struct.doublecomplex, ptr %3196, i32 0, i32 1
  store double %3192, ptr %3197, align 8, !tbaa !15
  %3198 = load ptr, ptr %39, align 8, !tbaa !5
  %3199 = load i32, ptr %101, align 4, !tbaa !9
  %3200 = load i32, ptr %53, align 4, !tbaa !9
  %3201 = mul nsw i32 %3199, %3200
  %3202 = add nsw i32 %3201, 2
  %3203 = sext i32 %3202 to i64
  %3204 = getelementptr inbounds %struct.doublecomplex, ptr %3198, i64 %3203
  %3205 = load ptr, ptr %39, align 8, !tbaa !5
  %3206 = load i32, ptr %101, align 4, !tbaa !9
  %3207 = load i32, ptr %53, align 4, !tbaa !9
  %3208 = mul nsw i32 %3206, %3207
  %3209 = add nsw i32 %3208, 1
  %3210 = sext i32 %3209 to i64
  %3211 = getelementptr inbounds %struct.doublecomplex, ptr %3205, i64 %3210
  call void @zlarfg_(ptr noundef @c__3, ptr noundef %90, ptr noundef %3204, ptr noundef @c__1, ptr noundef %3211)
  %3212 = load i32, ptr %100, align 4, !tbaa !9
  %3213 = add nsw i32 %3212, 3
  %3214 = load i32, ptr %100, align 4, !tbaa !9
  %3215 = load i32, ptr %49, align 4, !tbaa !9
  %3216 = mul nsw i32 %3214, %3215
  %3217 = add nsw i32 %3213, %3216
  store i32 %3217, ptr %64, align 4, !tbaa !9
  %3218 = load i32, ptr %100, align 4, !tbaa !9
  %3219 = add nsw i32 %3218, 3
  %3220 = load i32, ptr %100, align 4, !tbaa !9
  %3221 = add nsw i32 %3220, 1
  %3222 = load i32, ptr %49, align 4, !tbaa !9
  %3223 = mul nsw i32 %3221, %3222
  %3224 = add nsw i32 %3219, %3223
  store i32 %3224, ptr %65, align 4, !tbaa !9
  %3225 = load i32, ptr %100, align 4, !tbaa !9
  %3226 = add nsw i32 %3225, 3
  %3227 = load i32, ptr %100, align 4, !tbaa !9
  %3228 = add nsw i32 %3227, 2
  %3229 = load i32, ptr %49, align 4, !tbaa !9
  %3230 = mul nsw i32 %3228, %3229
  %3231 = add nsw i32 %3226, %3230
  store i32 %3231, ptr %67, align 4, !tbaa !9
  %3232 = load ptr, ptr %33, align 8, !tbaa !5
  %3233 = load i32, ptr %64, align 4, !tbaa !9
  %3234 = sext i32 %3233 to i64
  %3235 = getelementptr inbounds %struct.doublecomplex, ptr %3232, i64 %3234
  %3236 = getelementptr inbounds %struct.doublecomplex, ptr %3235, i32 0, i32 0
  %3237 = load double, ptr %3236, align 8, !tbaa !13
  %3238 = fcmp une double %3237, 0.000000e+00
  br i1 %3238, label %3279, label %3239

3239:                                             ; preds = %2819
  %3240 = load ptr, ptr %33, align 8, !tbaa !5
  %3241 = load i32, ptr %64, align 4, !tbaa !9
  %3242 = sext i32 %3241 to i64
  %3243 = getelementptr inbounds %struct.doublecomplex, ptr %3240, i64 %3242
  %3244 = getelementptr inbounds %struct.doublecomplex, ptr %3243, i32 0, i32 1
  %3245 = load double, ptr %3244, align 8, !tbaa !15
  %3246 = fcmp une double %3245, 0.000000e+00
  br i1 %3246, label %3279, label %3247

3247:                                             ; preds = %3239
  %3248 = load ptr, ptr %33, align 8, !tbaa !5
  %3249 = load i32, ptr %65, align 4, !tbaa !9
  %3250 = sext i32 %3249 to i64
  %3251 = getelementptr inbounds %struct.doublecomplex, ptr %3248, i64 %3250
  %3252 = getelementptr inbounds %struct.doublecomplex, ptr %3251, i32 0, i32 0
  %3253 = load double, ptr %3252, align 8, !tbaa !13
  %3254 = fcmp une double %3253, 0.000000e+00
  br i1 %3254, label %3279, label %3255

3255:                                             ; preds = %3247
  %3256 = load ptr, ptr %33, align 8, !tbaa !5
  %3257 = load i32, ptr %65, align 4, !tbaa !9
  %3258 = sext i32 %3257 to i64
  %3259 = getelementptr inbounds %struct.doublecomplex, ptr %3256, i64 %3258
  %3260 = getelementptr inbounds %struct.doublecomplex, ptr %3259, i32 0, i32 1
  %3261 = load double, ptr %3260, align 8, !tbaa !15
  %3262 = fcmp une double %3261, 0.000000e+00
  br i1 %3262, label %3279, label %3263

3263:                                             ; preds = %3255
  %3264 = load ptr, ptr %33, align 8, !tbaa !5
  %3265 = load i32, ptr %67, align 4, !tbaa !9
  %3266 = sext i32 %3265 to i64
  %3267 = getelementptr inbounds %struct.doublecomplex, ptr %3264, i64 %3266
  %3268 = getelementptr inbounds %struct.doublecomplex, ptr %3267, i32 0, i32 0
  %3269 = load double, ptr %3268, align 8, !tbaa !13
  %3270 = fcmp oeq double %3269, 0.000000e+00
  br i1 %3270, label %3271, label %3332

3271:                                             ; preds = %3263
  %3272 = load ptr, ptr %33, align 8, !tbaa !5
  %3273 = load i32, ptr %67, align 4, !tbaa !9
  %3274 = sext i32 %3273 to i64
  %3275 = getelementptr inbounds %struct.doublecomplex, ptr %3272, i64 %3274
  %3276 = getelementptr inbounds %struct.doublecomplex, ptr %3275, i32 0, i32 1
  %3277 = load double, ptr %3276, align 8, !tbaa !15
  %3278 = fcmp oeq double %3277, 0.000000e+00
  br i1 %3278, label %3279, label %3332

3279:                                             ; preds = %3271, %3255, %3247, %3239, %2819
  %3280 = load i32, ptr %100, align 4, !tbaa !9
  %3281 = add nsw i32 %3280, 1
  %3282 = load i32, ptr %100, align 4, !tbaa !9
  %3283 = load i32, ptr %49, align 4, !tbaa !9
  %3284 = mul nsw i32 %3282, %3283
  %3285 = add nsw i32 %3281, %3284
  store i32 %3285, ptr %64, align 4, !tbaa !9
  %3286 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  %3287 = load double, ptr %3286, align 8, !tbaa !13
  %3288 = load ptr, ptr %33, align 8, !tbaa !5
  %3289 = load i32, ptr %64, align 4, !tbaa !9
  %3290 = sext i32 %3289 to i64
  %3291 = getelementptr inbounds %struct.doublecomplex, ptr %3288, i64 %3290
  %3292 = getelementptr inbounds %struct.doublecomplex, ptr %3291, i32 0, i32 0
  store double %3287, ptr %3292, align 8, !tbaa !13
  %3293 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  %3294 = load double, ptr %3293, align 8, !tbaa !15
  %3295 = load ptr, ptr %33, align 8, !tbaa !5
  %3296 = load i32, ptr %64, align 4, !tbaa !9
  %3297 = sext i32 %3296 to i64
  %3298 = getelementptr inbounds %struct.doublecomplex, ptr %3295, i64 %3297
  %3299 = getelementptr inbounds %struct.doublecomplex, ptr %3298, i32 0, i32 1
  store double %3294, ptr %3299, align 8, !tbaa !15
  %3300 = load i32, ptr %100, align 4, !tbaa !9
  %3301 = add nsw i32 %3300, 2
  %3302 = load i32, ptr %100, align 4, !tbaa !9
  %3303 = load i32, ptr %49, align 4, !tbaa !9
  %3304 = mul nsw i32 %3302, %3303
  %3305 = add nsw i32 %3301, %3304
  store i32 %3305, ptr %64, align 4, !tbaa !9
  %3306 = load ptr, ptr %33, align 8, !tbaa !5
  %3307 = load i32, ptr %64, align 4, !tbaa !9
  %3308 = sext i32 %3307 to i64
  %3309 = getelementptr inbounds %struct.doublecomplex, ptr %3306, i64 %3308
  %3310 = getelementptr inbounds %struct.doublecomplex, ptr %3309, i32 0, i32 0
  store double 0.000000e+00, ptr %3310, align 8, !tbaa !13
  %3311 = load ptr, ptr %33, align 8, !tbaa !5
  %3312 = load i32, ptr %64, align 4, !tbaa !9
  %3313 = sext i32 %3312 to i64
  %3314 = getelementptr inbounds %struct.doublecomplex, ptr %3311, i64 %3313
  %3315 = getelementptr inbounds %struct.doublecomplex, ptr %3314, i32 0, i32 1
  store double 0.000000e+00, ptr %3315, align 8, !tbaa !15
  %3316 = load i32, ptr %100, align 4, !tbaa !9
  %3317 = add nsw i32 %3316, 3
  %3318 = load i32, ptr %100, align 4, !tbaa !9
  %3319 = load i32, ptr %49, align 4, !tbaa !9
  %3320 = mul nsw i32 %3318, %3319
  %3321 = add nsw i32 %3317, %3320
  store i32 %3321, ptr %64, align 4, !tbaa !9
  %3322 = load ptr, ptr %33, align 8, !tbaa !5
  %3323 = load i32, ptr %64, align 4, !tbaa !9
  %3324 = sext i32 %3323 to i64
  %3325 = getelementptr inbounds %struct.doublecomplex, ptr %3322, i64 %3324
  %3326 = getelementptr inbounds %struct.doublecomplex, ptr %3325, i32 0, i32 0
  store double 0.000000e+00, ptr %3326, align 8, !tbaa !13
  %3327 = load ptr, ptr %33, align 8, !tbaa !5
  %3328 = load i32, ptr %64, align 4, !tbaa !9
  %3329 = sext i32 %3328 to i64
  %3330 = getelementptr inbounds %struct.doublecomplex, ptr %3327, i64 %3329
  %3331 = getelementptr inbounds %struct.doublecomplex, ptr %3330, i32 0, i32 1
  store double 0.000000e+00, ptr %3331, align 8, !tbaa !15
  br label %3952

3332:                                             ; preds = %3271, %3263
  %3333 = load ptr, ptr %33, align 8, !tbaa !5
  %3334 = load i32, ptr %100, align 4, !tbaa !9
  %3335 = add nsw i32 %3334, 1
  %3336 = load i32, ptr %100, align 4, !tbaa !9
  %3337 = add nsw i32 %3336, 1
  %3338 = load i32, ptr %49, align 4, !tbaa !9
  %3339 = mul nsw i32 %3337, %3338
  %3340 = add nsw i32 %3335, %3339
  %3341 = sext i32 %3340 to i64
  %3342 = getelementptr inbounds %struct.doublecomplex, ptr %3333, i64 %3341
  %3343 = load ptr, ptr %34, align 8, !tbaa !5
  %3344 = load ptr, ptr %32, align 8, !tbaa !5
  %3345 = load i32, ptr %101, align 4, !tbaa !9
  %3346 = shl i32 %3345, 1
  %3347 = sub nsw i32 %3346, 1
  %3348 = sext i32 %3347 to i64
  %3349 = getelementptr inbounds %struct.doublecomplex, ptr %3344, i64 %3348
  %3350 = load ptr, ptr %32, align 8, !tbaa !5
  %3351 = load i32, ptr %101, align 4, !tbaa !9
  %3352 = mul nsw i32 %3351, 2
  %3353 = sext i32 %3352 to i64
  %3354 = getelementptr inbounds %struct.doublecomplex, ptr %3350, i64 %3353
  %3355 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  call void @zlaqr1_(ptr noundef @c__3, ptr noundef %3342, ptr noundef %3343, ptr noundef %3349, ptr noundef %3354, ptr noundef %3355)
  %3356 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  %3357 = getelementptr inbounds %struct.doublecomplex, ptr %3356, i32 0, i32 0
  %3358 = load double, ptr %3357, align 16, !tbaa !13
  %3359 = getelementptr inbounds %struct.doublecomplex, ptr %102, i32 0, i32 0
  store double %3358, ptr %3359, align 8, !tbaa !13
  %3360 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  %3361 = getelementptr inbounds %struct.doublecomplex, ptr %3360, i32 0, i32 1
  %3362 = load double, ptr %3361, align 8, !tbaa !15
  %3363 = getelementptr inbounds %struct.doublecomplex, ptr %102, i32 0, i32 1
  store double %3362, ptr %3363, align 8, !tbaa !15
  %3364 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3365 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  call void @zlarfg_(ptr noundef @c__3, ptr noundef %102, ptr noundef %3364, ptr noundef @c__1, ptr noundef %3365)
  %3366 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  %3367 = call { double, double } @Cd(ptr noundef %3366)
  %3368 = extractvalue { double, double } %3367, 0
  %3369 = extractvalue { double, double } %3367, 1
  %3370 = fneg double %3369
  %3371 = call ptr @_pCd(ptr noundef %83)
  %3372 = getelementptr inbounds { double, double }, ptr %3371, i32 0, i32 0
  %3373 = getelementptr inbounds { double, double }, ptr %3371, i32 0, i32 1
  store double %3368, ptr %3372, align 8
  store double %3370, ptr %3373, align 8
  %3374 = load i32, ptr %100, align 4, !tbaa !9
  %3375 = add nsw i32 %3374, 1
  %3376 = load i32, ptr %100, align 4, !tbaa !9
  %3377 = load i32, ptr %49, align 4, !tbaa !9
  %3378 = mul nsw i32 %3376, %3377
  %3379 = add nsw i32 %3375, %3378
  store i32 %3379, ptr %64, align 4, !tbaa !9
  %3380 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3381 = call { double, double } @Cd(ptr noundef %3380)
  %3382 = extractvalue { double, double } %3381, 0
  %3383 = extractvalue { double, double } %3381, 1
  %3384 = fneg double %3383
  %3385 = call ptr @_pCd(ptr noundef %86)
  %3386 = getelementptr inbounds { double, double }, ptr %3385, i32 0, i32 0
  %3387 = getelementptr inbounds { double, double }, ptr %3385, i32 0, i32 1
  store double %3382, ptr %3386, align 8
  store double %3384, ptr %3387, align 8
  %3388 = load i32, ptr %100, align 4, !tbaa !9
  %3389 = add nsw i32 %3388, 2
  %3390 = load i32, ptr %100, align 4, !tbaa !9
  %3391 = load i32, ptr %49, align 4, !tbaa !9
  %3392 = mul nsw i32 %3390, %3391
  %3393 = add nsw i32 %3389, %3392
  store i32 %3393, ptr %65, align 4, !tbaa !9
  %3394 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %3395 = load double, ptr %3394, align 8, !tbaa !13
  %3396 = load ptr, ptr %33, align 8, !tbaa !5
  %3397 = load i32, ptr %65, 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 0
  %3401 = load double, ptr %3400, align 8, !tbaa !13
  %3402 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %3403 = load double, ptr %3402, align 8, !tbaa !15
  %3404 = load ptr, ptr %33, align 8, !tbaa !5
  %3405 = load i32, ptr %65, align 4, !tbaa !9
  %3406 = sext i32 %3405 to i64
  %3407 = getelementptr inbounds %struct.doublecomplex, ptr %3404, i64 %3406
  %3408 = getelementptr inbounds %struct.doublecomplex, ptr %3407, i32 0, i32 1
  %3409 = load double, ptr %3408, align 8, !tbaa !15
  %3410 = fmul double %3403, %3409
  %3411 = fneg double %3410
  %3412 = call double @llvm.fmuladd.f64(double %3395, double %3401, double %3411)
  %3413 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %3412, ptr %3413, align 8, !tbaa !13
  %3414 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %3415 = load double, ptr %3414, align 8, !tbaa !13
  %3416 = load ptr, ptr %33, align 8, !tbaa !5
  %3417 = load i32, ptr %65, align 4, !tbaa !9
  %3418 = sext i32 %3417 to i64
  %3419 = getelementptr inbounds %struct.doublecomplex, ptr %3416, i64 %3418
  %3420 = getelementptr inbounds %struct.doublecomplex, ptr %3419, i32 0, i32 1
  %3421 = load double, ptr %3420, align 8, !tbaa !15
  %3422 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %3423 = load double, ptr %3422, align 8, !tbaa !15
  %3424 = load ptr, ptr %33, align 8, !tbaa !5
  %3425 = load i32, ptr %65, align 4, !tbaa !9
  %3426 = sext i32 %3425 to i64
  %3427 = getelementptr inbounds %struct.doublecomplex, ptr %3424, i64 %3426
  %3428 = getelementptr inbounds %struct.doublecomplex, ptr %3427, i32 0, i32 0
  %3429 = load double, ptr %3428, align 8, !tbaa !13
  %3430 = fmul double %3423, %3429
  %3431 = call double @llvm.fmuladd.f64(double %3415, double %3421, double %3430)
  %3432 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %3431, ptr %3432, align 8, !tbaa !15
  %3433 = load ptr, ptr %33, align 8, !tbaa !5
  %3434 = load i32, ptr %64, align 4, !tbaa !9
  %3435 = sext i32 %3434 to i64
  %3436 = getelementptr inbounds %struct.doublecomplex, ptr %3433, i64 %3435
  %3437 = getelementptr inbounds %struct.doublecomplex, ptr %3436, i32 0, i32 0
  %3438 = load double, ptr %3437, align 8, !tbaa !13
  %3439 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %3440 = load double, ptr %3439, align 8, !tbaa !13
  %3441 = fadd double %3438, %3440
  %3442 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %3441, ptr %3442, align 8, !tbaa !13
  %3443 = load ptr, ptr %33, align 8, !tbaa !5
  %3444 = load i32, ptr %64, align 4, !tbaa !9
  %3445 = sext i32 %3444 to i64
  %3446 = getelementptr inbounds %struct.doublecomplex, ptr %3443, i64 %3445
  %3447 = getelementptr inbounds %struct.doublecomplex, ptr %3446, i32 0, i32 1
  %3448 = load double, ptr %3447, align 8, !tbaa !15
  %3449 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %3450 = load double, ptr %3449, align 8, !tbaa !15
  %3451 = fadd double %3448, %3450
  %3452 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %3451, ptr %3452, align 8, !tbaa !15
  %3453 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %3454 = load double, ptr %3453, align 8, !tbaa !13
  %3455 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3456 = load double, ptr %3455, align 8, !tbaa !13
  %3457 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %3458 = load double, ptr %3457, align 8, !tbaa !15
  %3459 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3460 = load double, ptr %3459, align 8, !tbaa !15
  %3461 = fmul double %3458, %3460
  %3462 = fneg double %3461
  %3463 = call double @llvm.fmuladd.f64(double %3454, double %3456, double %3462)
  %3464 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %3463, ptr %3464, align 8, !tbaa !13
  %3465 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %3466 = load double, ptr %3465, align 8, !tbaa !13
  %3467 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3468 = load double, ptr %3467, align 8, !tbaa !15
  %3469 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %3470 = load double, ptr %3469, align 8, !tbaa !15
  %3471 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3472 = load double, ptr %3471, align 8, !tbaa !13
  %3473 = fmul double %3470, %3472
  %3474 = call double @llvm.fmuladd.f64(double %3466, double %3468, double %3473)
  %3475 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %3474, ptr %3475, align 8, !tbaa !15
  %3476 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %3477 = load double, ptr %3476, align 8, !tbaa !13
  %3478 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %3477, ptr %3478, align 8, !tbaa !13
  %3479 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %3480 = load double, ptr %3479, align 8, !tbaa !15
  %3481 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %3480, ptr %3481, align 8, !tbaa !15
  %3482 = load i32, ptr %100, align 4, !tbaa !9
  %3483 = add nsw i32 %3482, 2
  %3484 = load i32, ptr %100, align 4, !tbaa !9
  %3485 = load i32, ptr %49, align 4, !tbaa !9
  %3486 = mul nsw i32 %3484, %3485
  %3487 = add nsw i32 %3483, %3486
  store i32 %3487, ptr %64, align 4, !tbaa !9
  %3488 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3489 = load double, ptr %3488, align 8, !tbaa !13
  %3490 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3491 = getelementptr inbounds %struct.doublecomplex, ptr %3490, i32 0, i32 0
  %3492 = load double, ptr %3491, align 16, !tbaa !13
  %3493 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3494 = load double, ptr %3493, align 8, !tbaa !15
  %3495 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3496 = getelementptr inbounds %struct.doublecomplex, ptr %3495, i32 0, i32 1
  %3497 = load double, ptr %3496, align 8, !tbaa !15
  %3498 = fmul double %3494, %3497
  %3499 = fneg double %3498
  %3500 = call double @llvm.fmuladd.f64(double %3489, double %3492, double %3499)
  %3501 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %3500, ptr %3501, align 8, !tbaa !13
  %3502 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3503 = load double, ptr %3502, align 8, !tbaa !13
  %3504 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3505 = getelementptr inbounds %struct.doublecomplex, ptr %3504, i32 0, i32 1
  %3506 = load double, ptr %3505, align 8, !tbaa !15
  %3507 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3508 = load double, ptr %3507, align 8, !tbaa !15
  %3509 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3510 = getelementptr inbounds %struct.doublecomplex, ptr %3509, i32 0, i32 0
  %3511 = load double, ptr %3510, align 16, !tbaa !13
  %3512 = fmul double %3508, %3511
  %3513 = call double @llvm.fmuladd.f64(double %3503, double %3506, double %3512)
  %3514 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %3513, ptr %3514, align 8, !tbaa !15
  %3515 = load ptr, ptr %33, align 8, !tbaa !5
  %3516 = load i32, ptr %64, align 4, !tbaa !9
  %3517 = sext i32 %3516 to i64
  %3518 = getelementptr inbounds %struct.doublecomplex, ptr %3515, i64 %3517
  %3519 = getelementptr inbounds %struct.doublecomplex, ptr %3518, i32 0, i32 0
  %3520 = load double, ptr %3519, align 8, !tbaa !13
  %3521 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %3522 = load double, ptr %3521, align 8, !tbaa !13
  %3523 = fsub double %3520, %3522
  %3524 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %3523, ptr %3524, align 8, !tbaa !13
  %3525 = load ptr, ptr %33, align 8, !tbaa !5
  %3526 = load i32, ptr %64, align 4, !tbaa !9
  %3527 = sext i32 %3526 to i64
  %3528 = getelementptr inbounds %struct.doublecomplex, ptr %3525, i64 %3527
  %3529 = getelementptr inbounds %struct.doublecomplex, ptr %3528, i32 0, i32 1
  %3530 = load double, ptr %3529, align 8, !tbaa !15
  %3531 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %3532 = load double, ptr %3531, align 8, !tbaa !15
  %3533 = fsub double %3530, %3532
  %3534 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %3533, ptr %3534, align 8, !tbaa !15
  %3535 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %3536 = load double, ptr %3535, align 8, !tbaa !13
  %3537 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %3536, ptr %3537, align 8, !tbaa !13
  %3538 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %3539 = load double, ptr %3538, align 8, !tbaa !15
  %3540 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %3539, ptr %3540, align 8, !tbaa !15
  %3541 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3542 = load double, ptr %3541, align 8, !tbaa !13
  %3543 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3544 = getelementptr inbounds %struct.doublecomplex, ptr %3543, i32 0, i32 0
  %3545 = load double, ptr %3544, align 16, !tbaa !13
  %3546 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3547 = load double, ptr %3546, align 8, !tbaa !15
  %3548 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3549 = getelementptr inbounds %struct.doublecomplex, ptr %3548, i32 0, i32 1
  %3550 = load double, ptr %3549, align 8, !tbaa !15
  %3551 = fmul double %3547, %3550
  %3552 = fneg double %3551
  %3553 = call double @llvm.fmuladd.f64(double %3542, double %3545, double %3552)
  %3554 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %3553, ptr %3554, align 8, !tbaa !13
  %3555 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3556 = load double, ptr %3555, align 8, !tbaa !13
  %3557 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3558 = getelementptr inbounds %struct.doublecomplex, ptr %3557, i32 0, i32 1
  %3559 = load double, ptr %3558, align 8, !tbaa !15
  %3560 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3561 = load double, ptr %3560, align 8, !tbaa !15
  %3562 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3563 = getelementptr inbounds %struct.doublecomplex, ptr %3562, i32 0, i32 0
  %3564 = load double, ptr %3563, align 16, !tbaa !13
  %3565 = fmul double %3561, %3564
  %3566 = call double @llvm.fmuladd.f64(double %3556, double %3559, double %3565)
  %3567 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %3566, ptr %3567, align 8, !tbaa !15
  %3568 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %3569 = load double, ptr %3568, align 8, !tbaa !13
  %3570 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %3569, ptr %3570, align 8, !tbaa !13
  %3571 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %3572 = load double, ptr %3571, align 8, !tbaa !15
  %3573 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %3572, ptr %3573, align 8, !tbaa !15
  %3574 = load i32, ptr %100, align 4, !tbaa !9
  %3575 = load i32, ptr %100, align 4, !tbaa !9
  %3576 = load i32, ptr %49, align 4, !tbaa !9
  %3577 = mul nsw i32 %3575, %3576
  %3578 = add nsw i32 %3574, %3577
  store i32 %3578, ptr %65, align 4, !tbaa !9
  %3579 = load i32, ptr %100, align 4, !tbaa !9
  %3580 = add nsw i32 %3579, 1
  %3581 = load i32, ptr %100, align 4, !tbaa !9
  %3582 = add nsw i32 %3581, 1
  %3583 = load i32, ptr %49, align 4, !tbaa !9
  %3584 = mul nsw i32 %3582, %3583
  %3585 = add nsw i32 %3580, %3584
  store i32 %3585, ptr %67, align 4, !tbaa !9
  %3586 = load i32, ptr %100, align 4, !tbaa !9
  %3587 = add nsw i32 %3586, 2
  %3588 = load i32, ptr %100, align 4, !tbaa !9
  %3589 = add nsw i32 %3588, 2
  %3590 = load i32, ptr %49, align 4, !tbaa !9
  %3591 = mul nsw i32 %3589, %3590
  %3592 = add nsw i32 %3587, %3591
  store i32 %3592, ptr %68, align 4, !tbaa !9
  %3593 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %3594 = load double, ptr %3593, align 8, !tbaa !13
  store double %3594, ptr %72, align 8, !tbaa !11
  %3595 = load double, ptr %72, align 8, !tbaa !11
  %3596 = fcmp oge double %3595, 0.000000e+00
  br i1 %3596, label %3597, label %3599

3597:                                             ; preds = %3332
  %3598 = load double, ptr %72, align 8, !tbaa !11
  br label %3602

3599:                                             ; preds = %3332
  %3600 = load double, ptr %72, align 8, !tbaa !11
  %3601 = fneg double %3600
  br label %3602

3602:                                             ; preds = %3599, %3597
  %3603 = phi double [ %3598, %3597 ], [ %3601, %3599 ]
  %3604 = call { double, double } @Cd(ptr noundef %82)
  %3605 = extractvalue { double, double } %3604, 0
  %3606 = extractvalue { double, double } %3604, 1
  store double %3606, ptr %73, align 8, !tbaa !11
  %3607 = load double, ptr %73, align 8, !tbaa !11
  %3608 = fcmp oge double %3607, 0.000000e+00
  br i1 %3608, label %3609, label %3611

3609:                                             ; preds = %3602
  %3610 = load double, ptr %73, align 8, !tbaa !11
  br label %3614

3611:                                             ; preds = %3602
  %3612 = load double, ptr %73, align 8, !tbaa !11
  %3613 = fneg double %3612
  br label %3614

3614:                                             ; preds = %3611, %3609
  %3615 = phi double [ %3610, %3609 ], [ %3613, %3611 ]
  %3616 = fadd double %3603, %3615
  %3617 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %3618 = load double, ptr %3617, align 8, !tbaa !13
  store double %3618, ptr %74, align 8, !tbaa !11
  %3619 = load double, ptr %74, align 8, !tbaa !11
  %3620 = fcmp oge double %3619, 0.000000e+00
  br i1 %3620, label %3621, label %3623

3621:                                             ; preds = %3614
  %3622 = load double, ptr %74, align 8, !tbaa !11
  br label %3626

3623:                                             ; preds = %3614
  %3624 = load double, ptr %74, align 8, !tbaa !11
  %3625 = fneg double %3624
  br label %3626

3626:                                             ; preds = %3623, %3621
  %3627 = phi double [ %3622, %3621 ], [ %3625, %3623 ]
  %3628 = call { double, double } @Cd(ptr noundef %85)
  %3629 = extractvalue { double, double } %3628, 0
  %3630 = extractvalue { double, double } %3628, 1
  store double %3630, ptr %75, align 8, !tbaa !11
  %3631 = load double, ptr %75, align 8, !tbaa !11
  %3632 = fcmp oge double %3631, 0.000000e+00
  br i1 %3632, label %3633, label %3635

3633:                                             ; preds = %3626
  %3634 = load double, ptr %75, align 8, !tbaa !11
  br label %3638

3635:                                             ; preds = %3626
  %3636 = load double, ptr %75, align 8, !tbaa !11
  %3637 = fneg double %3636
  br label %3638

3638:                                             ; preds = %3635, %3633
  %3639 = phi double [ %3634, %3633 ], [ %3637, %3635 ]
  %3640 = fadd double %3627, %3639
  %3641 = fadd double %3616, %3640
  %3642 = load double, ptr %126, align 8, !tbaa !11
  %3643 = load ptr, ptr %33, align 8, !tbaa !5
  %3644 = load i32, ptr %65, align 4, !tbaa !9
  %3645 = sext i32 %3644 to i64
  %3646 = getelementptr inbounds %struct.doublecomplex, ptr %3643, i64 %3645
  %3647 = getelementptr inbounds %struct.doublecomplex, ptr %3646, i32 0, i32 0
  %3648 = load double, ptr %3647, align 8, !tbaa !13
  store double %3648, ptr %76, align 8, !tbaa !11
  %3649 = load double, ptr %76, align 8, !tbaa !11
  %3650 = fcmp oge double %3649, 0.000000e+00
  br i1 %3650, label %3651, label %3653

3651:                                             ; preds = %3638
  %3652 = load double, ptr %76, align 8, !tbaa !11
  br label %3656

3653:                                             ; preds = %3638
  %3654 = load double, ptr %76, align 8, !tbaa !11
  %3655 = fneg double %3654
  br label %3656

3656:                                             ; preds = %3653, %3651
  %3657 = phi double [ %3652, %3651 ], [ %3655, %3653 ]
  %3658 = load ptr, ptr %33, align 8, !tbaa !5
  %3659 = load i32, ptr %100, align 4, !tbaa !9
  %3660 = load i32, ptr %100, align 4, !tbaa !9
  %3661 = load i32, ptr %49, align 4, !tbaa !9
  %3662 = mul nsw i32 %3660, %3661
  %3663 = add nsw i32 %3659, %3662
  %3664 = sext i32 %3663 to i64
  %3665 = getelementptr inbounds %struct.doublecomplex, ptr %3658, i64 %3664
  %3666 = call { double, double } @Cd(ptr noundef %3665)
  %3667 = extractvalue { double, double } %3666, 0
  %3668 = extractvalue { double, double } %3666, 1
  store double %3668, ptr %77, align 8, !tbaa !11
  %3669 = load double, ptr %77, align 8, !tbaa !11
  %3670 = fcmp oge double %3669, 0.000000e+00
  br i1 %3670, label %3671, label %3673

3671:                                             ; preds = %3656
  %3672 = load double, ptr %77, align 8, !tbaa !11
  br label %3676

3673:                                             ; preds = %3656
  %3674 = load double, ptr %77, align 8, !tbaa !11
  %3675 = fneg double %3674
  br label %3676

3676:                                             ; preds = %3673, %3671
  %3677 = phi double [ %3672, %3671 ], [ %3675, %3673 ]
  %3678 = fadd double %3657, %3677
  %3679 = load ptr, ptr %33, align 8, !tbaa !5
  %3680 = load i32, ptr %67, align 4, !tbaa !9
  %3681 = sext i32 %3680 to i64
  %3682 = getelementptr inbounds %struct.doublecomplex, ptr %3679, i64 %3681
  %3683 = getelementptr inbounds %struct.doublecomplex, ptr %3682, i32 0, i32 0
  %3684 = load double, ptr %3683, align 8, !tbaa !13
  store double %3684, ptr %78, align 8, !tbaa !11
  %3685 = load double, ptr %78, align 8, !tbaa !11
  %3686 = fcmp oge double %3685, 0.000000e+00
  br i1 %3686, label %3687, label %3689

3687:                                             ; preds = %3676
  %3688 = load double, ptr %78, align 8, !tbaa !11
  br label %3692

3689:                                             ; preds = %3676
  %3690 = load double, ptr %78, align 8, !tbaa !11
  %3691 = fneg double %3690
  br label %3692

3692:                                             ; preds = %3689, %3687
  %3693 = phi double [ %3688, %3687 ], [ %3691, %3689 ]
  %3694 = load ptr, ptr %33, align 8, !tbaa !5
  %3695 = load i32, ptr %100, align 4, !tbaa !9
  %3696 = add nsw i32 %3695, 1
  %3697 = load i32, ptr %100, align 4, !tbaa !9
  %3698 = add nsw i32 %3697, 1
  %3699 = load i32, ptr %49, align 4, !tbaa !9
  %3700 = mul nsw i32 %3698, %3699
  %3701 = add nsw i32 %3696, %3700
  %3702 = sext i32 %3701 to i64
  %3703 = getelementptr inbounds %struct.doublecomplex, ptr %3694, i64 %3702
  %3704 = call { double, double } @Cd(ptr noundef %3703)
  %3705 = extractvalue { double, double } %3704, 0
  %3706 = extractvalue { double, double } %3704, 1
  store double %3706, ptr %79, align 8, !tbaa !11
  %3707 = load double, ptr %79, align 8, !tbaa !11
  %3708 = fcmp oge double %3707, 0.000000e+00
  br i1 %3708, label %3709, label %3711

3709:                                             ; preds = %3692
  %3710 = load double, ptr %79, align 8, !tbaa !11
  br label %3714

3711:                                             ; preds = %3692
  %3712 = load double, ptr %79, align 8, !tbaa !11
  %3713 = fneg double %3712
  br label %3714

3714:                                             ; preds = %3711, %3709
  %3715 = phi double [ %3710, %3709 ], [ %3713, %3711 ]
  %3716 = fadd double %3693, %3715
  %3717 = fadd double %3678, %3716
  %3718 = load ptr, ptr %33, align 8, !tbaa !5
  %3719 = load i32, ptr %68, align 4, !tbaa !9
  %3720 = sext i32 %3719 to i64
  %3721 = getelementptr inbounds %struct.doublecomplex, ptr %3718, i64 %3720
  %3722 = getelementptr inbounds %struct.doublecomplex, ptr %3721, i32 0, i32 0
  %3723 = load double, ptr %3722, align 8, !tbaa !13
  store double %3723, ptr %80, align 8, !tbaa !11
  %3724 = load double, ptr %80, align 8, !tbaa !11
  %3725 = fcmp oge double %3724, 0.000000e+00
  br i1 %3725, label %3726, label %3728

3726:                                             ; preds = %3714
  %3727 = load double, ptr %80, align 8, !tbaa !11
  br label %3731

3728:                                             ; preds = %3714
  %3729 = load double, ptr %80, align 8, !tbaa !11
  %3730 = fneg double %3729
  br label %3731

3731:                                             ; preds = %3728, %3726
  %3732 = phi double [ %3727, %3726 ], [ %3730, %3728 ]
  %3733 = load ptr, ptr %33, align 8, !tbaa !5
  %3734 = load i32, ptr %100, align 4, !tbaa !9
  %3735 = add nsw i32 %3734, 2
  %3736 = load i32, ptr %100, align 4, !tbaa !9
  %3737 = add nsw i32 %3736, 2
  %3738 = load i32, ptr %49, align 4, !tbaa !9
  %3739 = mul nsw i32 %3737, %3738
  %3740 = add nsw i32 %3735, %3739
  %3741 = sext i32 %3740 to i64
  %3742 = getelementptr inbounds %struct.doublecomplex, ptr %3733, i64 %3741
  %3743 = call { double, double } @Cd(ptr noundef %3742)
  %3744 = extractvalue { double, double } %3743, 0
  %3745 = extractvalue { double, double } %3743, 1
  store double %3745, ptr %81, align 8, !tbaa !11
  %3746 = load double, ptr %81, align 8, !tbaa !11
  %3747 = fcmp oge double %3746, 0.000000e+00
  br i1 %3747, label %3748, label %3750

3748:                                             ; preds = %3731
  %3749 = load double, ptr %81, align 8, !tbaa !11
  br label %3753

3750:                                             ; preds = %3731
  %3751 = load double, ptr %81, align 8, !tbaa !11
  %3752 = fneg double %3751
  br label %3753

3753:                                             ; preds = %3750, %3748
  %3754 = phi double [ %3749, %3748 ], [ %3752, %3750 ]
  %3755 = fadd double %3732, %3754
  %3756 = fadd double %3717, %3755
  %3757 = fmul double %3642, %3756
  %3758 = fcmp ogt double %3641, %3757
  br i1 %3758, label %3759, label %3812

3759:                                             ; preds = %3753
  %3760 = load i32, ptr %100, align 4, !tbaa !9
  %3761 = add nsw i32 %3760, 1
  %3762 = load i32, ptr %100, align 4, !tbaa !9
  %3763 = load i32, ptr %49, align 4, !tbaa !9
  %3764 = mul nsw i32 %3762, %3763
  %3765 = add nsw i32 %3761, %3764
  store i32 %3765, ptr %64, align 4, !tbaa !9
  %3766 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  %3767 = load double, ptr %3766, align 8, !tbaa !13
  %3768 = load ptr, ptr %33, align 8, !tbaa !5
  %3769 = load i32, ptr %64, align 4, !tbaa !9
  %3770 = sext i32 %3769 to i64
  %3771 = getelementptr inbounds %struct.doublecomplex, ptr %3768, i64 %3770
  %3772 = getelementptr inbounds %struct.doublecomplex, ptr %3771, i32 0, i32 0
  store double %3767, ptr %3772, align 8, !tbaa !13
  %3773 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 1
  %3774 = load double, ptr %3773, align 8, !tbaa !15
  %3775 = load ptr, ptr %33, align 8, !tbaa !5
  %3776 = load i32, ptr %64, align 4, !tbaa !9
  %3777 = sext i32 %3776 to i64
  %3778 = getelementptr inbounds %struct.doublecomplex, ptr %3775, i64 %3777
  %3779 = getelementptr inbounds %struct.doublecomplex, ptr %3778, i32 0, i32 1
  store double %3774, ptr %3779, align 8, !tbaa !15
  %3780 = load i32, ptr %100, align 4, !tbaa !9
  %3781 = add nsw i32 %3780, 2
  %3782 = load i32, ptr %100, align 4, !tbaa !9
  %3783 = load i32, ptr %49, align 4, !tbaa !9
  %3784 = mul nsw i32 %3782, %3783
  %3785 = add nsw i32 %3781, %3784
  store i32 %3785, ptr %64, align 4, !tbaa !9
  %3786 = load ptr, ptr %33, align 8, !tbaa !5
  %3787 = load i32, ptr %64, align 4, !tbaa !9
  %3788 = sext i32 %3787 to i64
  %3789 = getelementptr inbounds %struct.doublecomplex, ptr %3786, i64 %3788
  %3790 = getelementptr inbounds %struct.doublecomplex, ptr %3789, i32 0, i32 0
  store double 0.000000e+00, ptr %3790, align 8, !tbaa !13
  %3791 = load ptr, ptr %33, align 8, !tbaa !5
  %3792 = load i32, ptr %64, align 4, !tbaa !9
  %3793 = sext i32 %3792 to i64
  %3794 = getelementptr inbounds %struct.doublecomplex, ptr %3791, i64 %3793
  %3795 = getelementptr inbounds %struct.doublecomplex, ptr %3794, i32 0, i32 1
  store double 0.000000e+00, ptr %3795, align 8, !tbaa !15
  %3796 = load i32, ptr %100, align 4, !tbaa !9
  %3797 = add nsw i32 %3796, 3
  %3798 = load i32, ptr %100, align 4, !tbaa !9
  %3799 = load i32, ptr %49, align 4, !tbaa !9
  %3800 = mul nsw i32 %3798, %3799
  %3801 = add nsw i32 %3797, %3800
  store i32 %3801, ptr %64, align 4, !tbaa !9
  %3802 = load ptr, ptr %33, align 8, !tbaa !5
  %3803 = load i32, ptr %64, align 4, !tbaa !9
  %3804 = sext i32 %3803 to i64
  %3805 = getelementptr inbounds %struct.doublecomplex, ptr %3802, i64 %3804
  %3806 = getelementptr inbounds %struct.doublecomplex, ptr %3805, i32 0, i32 0
  store double 0.000000e+00, ptr %3806, align 8, !tbaa !13
  %3807 = load ptr, ptr %33, align 8, !tbaa !5
  %3808 = load i32, ptr %64, align 4, !tbaa !9
  %3809 = sext i32 %3808 to i64
  %3810 = getelementptr inbounds %struct.doublecomplex, ptr %3807, i64 %3809
  %3811 = getelementptr inbounds %struct.doublecomplex, ptr %3810, i32 0, i32 1
  store double 0.000000e+00, ptr %3811, align 8, !tbaa !15
  br label %3951

3812:                                             ; preds = %3753
  %3813 = load i32, ptr %100, align 4, !tbaa !9
  %3814 = add nsw i32 %3813, 1
  %3815 = load i32, ptr %100, align 4, !tbaa !9
  %3816 = load i32, ptr %49, align 4, !tbaa !9
  %3817 = mul nsw i32 %3815, %3816
  %3818 = add nsw i32 %3814, %3817
  store i32 %3818, ptr %64, align 4, !tbaa !9
  %3819 = load i32, ptr %100, align 4, !tbaa !9
  %3820 = add nsw i32 %3819, 1
  %3821 = load i32, ptr %100, align 4, !tbaa !9
  %3822 = load i32, ptr %49, align 4, !tbaa !9
  %3823 = mul nsw i32 %3821, %3822
  %3824 = add nsw i32 %3820, %3823
  store i32 %3824, ptr %65, align 4, !tbaa !9
  %3825 = load ptr, ptr %33, align 8, !tbaa !5
  %3826 = load i32, ptr %65, align 4, !tbaa !9
  %3827 = sext i32 %3826 to i64
  %3828 = getelementptr inbounds %struct.doublecomplex, ptr %3825, i64 %3827
  %3829 = getelementptr inbounds %struct.doublecomplex, ptr %3828, i32 0, i32 0
  %3830 = load double, ptr %3829, align 8, !tbaa !13
  %3831 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %3832 = load double, ptr %3831, align 8, !tbaa !13
  %3833 = fsub double %3830, %3832
  %3834 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %3833, ptr %3834, align 8, !tbaa !13
  %3835 = load ptr, ptr %33, align 8, !tbaa !5
  %3836 = load i32, ptr %65, align 4, !tbaa !9
  %3837 = sext i32 %3836 to i64
  %3838 = getelementptr inbounds %struct.doublecomplex, ptr %3835, i64 %3837
  %3839 = getelementptr inbounds %struct.doublecomplex, ptr %3838, i32 0, i32 1
  %3840 = load double, ptr %3839, align 8, !tbaa !15
  %3841 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %3842 = load double, ptr %3841, align 8, !tbaa !15
  %3843 = fsub double %3840, %3842
  %3844 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %3843, ptr %3844, align 8, !tbaa !15
  %3845 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %3846 = load double, ptr %3845, align 8, !tbaa !13
  %3847 = load ptr, ptr %33, align 8, !tbaa !5
  %3848 = load i32, ptr %64, align 4, !tbaa !9
  %3849 = sext i32 %3848 to i64
  %3850 = getelementptr inbounds %struct.doublecomplex, ptr %3847, i64 %3849
  %3851 = getelementptr inbounds %struct.doublecomplex, ptr %3850, i32 0, i32 0
  store double %3846, ptr %3851, align 8, !tbaa !13
  %3852 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %3853 = load double, ptr %3852, align 8, !tbaa !15
  %3854 = load ptr, ptr %33, align 8, !tbaa !5
  %3855 = load i32, ptr %64, align 4, !tbaa !9
  %3856 = sext i32 %3855 to i64
  %3857 = getelementptr inbounds %struct.doublecomplex, ptr %3854, i64 %3856
  %3858 = getelementptr inbounds %struct.doublecomplex, ptr %3857, i32 0, i32 1
  store double %3853, ptr %3858, align 8, !tbaa !15
  %3859 = load i32, ptr %100, align 4, !tbaa !9
  %3860 = add nsw i32 %3859, 2
  %3861 = load i32, ptr %100, align 4, !tbaa !9
  %3862 = load i32, ptr %49, align 4, !tbaa !9
  %3863 = mul nsw i32 %3861, %3862
  %3864 = add nsw i32 %3860, %3863
  store i32 %3864, ptr %64, align 4, !tbaa !9
  %3865 = load ptr, ptr %33, align 8, !tbaa !5
  %3866 = load i32, ptr %64, align 4, !tbaa !9
  %3867 = sext i32 %3866 to i64
  %3868 = getelementptr inbounds %struct.doublecomplex, ptr %3865, i64 %3867
  %3869 = getelementptr inbounds %struct.doublecomplex, ptr %3868, i32 0, i32 0
  store double 0.000000e+00, ptr %3869, align 8, !tbaa !13
  %3870 = load ptr, ptr %33, align 8, !tbaa !5
  %3871 = load i32, ptr %64, align 4, !tbaa !9
  %3872 = sext i32 %3871 to i64
  %3873 = getelementptr inbounds %struct.doublecomplex, ptr %3870, i64 %3872
  %3874 = getelementptr inbounds %struct.doublecomplex, ptr %3873, i32 0, i32 1
  store double 0.000000e+00, ptr %3874, align 8, !tbaa !15
  %3875 = load i32, ptr %100, align 4, !tbaa !9
  %3876 = add nsw i32 %3875, 3
  %3877 = load i32, ptr %100, align 4, !tbaa !9
  %3878 = load i32, ptr %49, align 4, !tbaa !9
  %3879 = mul nsw i32 %3877, %3878
  %3880 = add nsw i32 %3876, %3879
  store i32 %3880, ptr %64, align 4, !tbaa !9
  %3881 = load ptr, ptr %33, align 8, !tbaa !5
  %3882 = load i32, ptr %64, align 4, !tbaa !9
  %3883 = sext i32 %3882 to i64
  %3884 = getelementptr inbounds %struct.doublecomplex, ptr %3881, i64 %3883
  %3885 = getelementptr inbounds %struct.doublecomplex, ptr %3884, i32 0, i32 0
  store double 0.000000e+00, ptr %3885, align 8, !tbaa !13
  %3886 = load ptr, ptr %33, align 8, !tbaa !5
  %3887 = load i32, ptr %64, align 4, !tbaa !9
  %3888 = sext i32 %3887 to i64
  %3889 = getelementptr inbounds %struct.doublecomplex, ptr %3886, i64 %3888
  %3890 = getelementptr inbounds %struct.doublecomplex, ptr %3889, i32 0, i32 1
  store double 0.000000e+00, ptr %3890, align 8, !tbaa !15
  %3891 = load i32, ptr %101, align 4, !tbaa !9
  %3892 = load i32, ptr %53, align 4, !tbaa !9
  %3893 = mul nsw i32 %3891, %3892
  %3894 = add nsw i32 %3893, 1
  store i32 %3894, ptr %64, align 4, !tbaa !9
  %3895 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  %3896 = getelementptr inbounds %struct.doublecomplex, ptr %3895, i32 0, i32 0
  %3897 = load double, ptr %3896, align 16, !tbaa !13
  %3898 = load ptr, ptr %39, align 8, !tbaa !5
  %3899 = load i32, ptr %64, align 4, !tbaa !9
  %3900 = sext i32 %3899 to i64
  %3901 = getelementptr inbounds %struct.doublecomplex, ptr %3898, i64 %3900
  %3902 = getelementptr inbounds %struct.doublecomplex, ptr %3901, i32 0, i32 0
  store double %3897, ptr %3902, align 8, !tbaa !13
  %3903 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 0
  %3904 = getelementptr inbounds %struct.doublecomplex, ptr %3903, i32 0, i32 1
  %3905 = load double, ptr %3904, align 8, !tbaa !15
  %3906 = load ptr, ptr %39, align 8, !tbaa !5
  %3907 = load i32, ptr %64, align 4, !tbaa !9
  %3908 = sext i32 %3907 to i64
  %3909 = getelementptr inbounds %struct.doublecomplex, ptr %3906, i64 %3908
  %3910 = getelementptr inbounds %struct.doublecomplex, ptr %3909, i32 0, i32 1
  store double %3905, ptr %3910, align 8, !tbaa !15
  %3911 = load i32, ptr %101, align 4, !tbaa !9
  %3912 = load i32, ptr %53, align 4, !tbaa !9
  %3913 = mul nsw i32 %3911, %3912
  %3914 = add nsw i32 %3913, 2
  store i32 %3914, ptr %64, align 4, !tbaa !9
  %3915 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3916 = getelementptr inbounds %struct.doublecomplex, ptr %3915, i32 0, i32 0
  %3917 = load double, ptr %3916, align 16, !tbaa !13
  %3918 = load ptr, ptr %39, align 8, !tbaa !5
  %3919 = load i32, ptr %64, align 4, !tbaa !9
  %3920 = sext i32 %3919 to i64
  %3921 = getelementptr inbounds %struct.doublecomplex, ptr %3918, i64 %3920
  %3922 = getelementptr inbounds %struct.doublecomplex, ptr %3921, i32 0, i32 0
  store double %3917, ptr %3922, align 8, !tbaa !13
  %3923 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 1
  %3924 = getelementptr inbounds %struct.doublecomplex, ptr %3923, i32 0, i32 1
  %3925 = load double, ptr %3924, align 8, !tbaa !15
  %3926 = load ptr, ptr %39, align 8, !tbaa !5
  %3927 = load i32, ptr %64, align 4, !tbaa !9
  %3928 = sext i32 %3927 to i64
  %3929 = getelementptr inbounds %struct.doublecomplex, ptr %3926, i64 %3928
  %3930 = getelementptr inbounds %struct.doublecomplex, ptr %3929, i32 0, i32 1
  store double %3925, ptr %3930, align 8, !tbaa !15
  %3931 = load i32, ptr %101, align 4, !tbaa !9
  %3932 = load i32, ptr %53, align 4, !tbaa !9
  %3933 = mul nsw i32 %3931, %3932
  %3934 = add nsw i32 %3933, 3
  store i32 %3934, ptr %64, align 4, !tbaa !9
  %3935 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3936 = getelementptr inbounds %struct.doublecomplex, ptr %3935, i32 0, i32 0
  %3937 = load double, ptr %3936, align 16, !tbaa !13
  %3938 = load ptr, ptr %39, align 8, !tbaa !5
  %3939 = load i32, ptr %64, align 4, !tbaa !9
  %3940 = sext i32 %3939 to i64
  %3941 = getelementptr inbounds %struct.doublecomplex, ptr %3938, i64 %3940
  %3942 = getelementptr inbounds %struct.doublecomplex, ptr %3941, i32 0, i32 0
  store double %3937, ptr %3942, align 8, !tbaa !13
  %3943 = getelementptr inbounds [3 x %struct.doublecomplex], ptr %118, i64 0, i64 2
  %3944 = getelementptr inbounds %struct.doublecomplex, ptr %3943, i32 0, i32 1
  %3945 = load double, ptr %3944, align 8, !tbaa !15
  %3946 = load ptr, ptr %39, align 8, !tbaa !5
  %3947 = load i32, ptr %64, align 4, !tbaa !9
  %3948 = sext i32 %3947 to i64
  %3949 = getelementptr inbounds %struct.doublecomplex, ptr %3946, i64 %3948
  %3950 = getelementptr inbounds %struct.doublecomplex, ptr %3949, i32 0, i32 1
  store double %3945, ptr %3950, align 8, !tbaa !15
  br label %3951

3951:                                             ; preds = %3812, %3759
  br label %3952

3952:                                             ; preds = %3951, %3279
  br label %3953

3953:                                             ; preds = %3952, %2757
  %3954 = load ptr, ptr %30, align 8, !tbaa !5
  %3955 = load i32, ptr %3954, align 4, !tbaa !9
  store i32 %3955, ptr %65, align 4, !tbaa !9
  %3956 = load i32, ptr %100, align 4, !tbaa !9
  %3957 = add nsw i32 %3956, 3
  store i32 %3957, ptr %67, align 4, !tbaa !9
  %3958 = load i32, ptr %65, align 4, !tbaa !9
  %3959 = load i32, ptr %67, align 4, !tbaa !9
  %3960 = icmp sle i32 %3958, %3959
  br i1 %3960, label %3961, label %3963

3961:                                             ; preds = %3953
  %3962 = load i32, ptr %65, align 4, !tbaa !9
  br label %3965

3963:                                             ; preds = %3953
  %3964 = load i32, ptr %67, align 4, !tbaa !9
  br label %3965

3965:                                             ; preds = %3963, %3961
  %3966 = phi i32 [ %3962, %3961 ], [ %3964, %3963 ]
  store i32 %3966, ptr %64, align 4, !tbaa !9
  %3967 = load i32, ptr %96, align 4, !tbaa !9
  store i32 %3967, ptr %99, align 4, !tbaa !9
  br label %3968

3968:                                             ; preds = %4402, %3965
  %3969 = load i32, ptr %99, align 4, !tbaa !9
  %3970 = load i32, ptr %64, align 4, !tbaa !9
  %3971 = icmp sle i32 %3969, %3970
  br i1 %3971, label %3972, label %4405

3972:                                             ; preds = %3968
  %3973 = load i32, ptr %101, align 4, !tbaa !9
  %3974 = load i32, ptr %53, align 4, !tbaa !9
  %3975 = mul nsw i32 %3973, %3974
  %3976 = add nsw i32 %3975, 1
  store i32 %3976, ptr %65, align 4, !tbaa !9
  %3977 = load i32, ptr %99, align 4, !tbaa !9
  %3978 = load i32, ptr %100, align 4, !tbaa !9
  %3979 = add nsw i32 %3978, 1
  %3980 = load i32, ptr %49, align 4, !tbaa !9
  %3981 = mul nsw i32 %3979, %3980
  %3982 = add nsw i32 %3977, %3981
  store i32 %3982, ptr %67, align 4, !tbaa !9
  %3983 = load i32, ptr %101, align 4, !tbaa !9
  %3984 = load i32, ptr %53, align 4, !tbaa !9
  %3985 = mul nsw i32 %3983, %3984
  %3986 = add nsw i32 %3985, 2
  store i32 %3986, ptr %68, align 4, !tbaa !9
  %3987 = load i32, ptr %99, align 4, !tbaa !9
  %3988 = load i32, ptr %100, align 4, !tbaa !9
  %3989 = add nsw i32 %3988, 2
  %3990 = load i32, ptr %49, align 4, !tbaa !9
  %3991 = mul nsw i32 %3989, %3990
  %3992 = add nsw i32 %3987, %3991
  store i32 %3992, ptr %69, align 4, !tbaa !9
  %3993 = load ptr, ptr %39, align 8, !tbaa !5
  %3994 = load i32, ptr %68, align 4, !tbaa !9
  %3995 = sext i32 %3994 to i64
  %3996 = getelementptr inbounds %struct.doublecomplex, ptr %3993, i64 %3995
  %3997 = getelementptr inbounds %struct.doublecomplex, ptr %3996, i32 0, i32 0
  %3998 = load double, ptr %3997, align 8, !tbaa !13
  %3999 = load ptr, ptr %33, align 8, !tbaa !5
  %4000 = load i32, ptr %69, align 4, !tbaa !9
  %4001 = sext i32 %4000 to i64
  %4002 = getelementptr inbounds %struct.doublecomplex, ptr %3999, i64 %4001
  %4003 = getelementptr inbounds %struct.doublecomplex, ptr %4002, i32 0, i32 0
  %4004 = load double, ptr %4003, align 8, !tbaa !13
  %4005 = load ptr, ptr %39, align 8, !tbaa !5
  %4006 = load i32, ptr %68, align 4, !tbaa !9
  %4007 = sext i32 %4006 to i64
  %4008 = getelementptr inbounds %struct.doublecomplex, ptr %4005, i64 %4007
  %4009 = getelementptr inbounds %struct.doublecomplex, ptr %4008, i32 0, i32 1
  %4010 = load double, ptr %4009, align 8, !tbaa !15
  %4011 = load ptr, ptr %33, align 8, !tbaa !5
  %4012 = load i32, ptr %69, align 4, !tbaa !9
  %4013 = sext i32 %4012 to i64
  %4014 = getelementptr inbounds %struct.doublecomplex, ptr %4011, i64 %4013
  %4015 = getelementptr inbounds %struct.doublecomplex, ptr %4014, i32 0, i32 1
  %4016 = load double, ptr %4015, align 8, !tbaa !15
  %4017 = fmul double %4010, %4016
  %4018 = fneg double %4017
  %4019 = call double @llvm.fmuladd.f64(double %3998, double %4004, double %4018)
  %4020 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %4019, ptr %4020, align 8, !tbaa !13
  %4021 = load ptr, ptr %39, align 8, !tbaa !5
  %4022 = load i32, ptr %68, align 4, !tbaa !9
  %4023 = sext i32 %4022 to i64
  %4024 = getelementptr inbounds %struct.doublecomplex, ptr %4021, i64 %4023
  %4025 = getelementptr inbounds %struct.doublecomplex, ptr %4024, i32 0, i32 0
  %4026 = load double, ptr %4025, align 8, !tbaa !13
  %4027 = load ptr, ptr %33, align 8, !tbaa !5
  %4028 = load i32, ptr %69, align 4, !tbaa !9
  %4029 = sext i32 %4028 to i64
  %4030 = getelementptr inbounds %struct.doublecomplex, ptr %4027, i64 %4029
  %4031 = getelementptr inbounds %struct.doublecomplex, ptr %4030, i32 0, i32 1
  %4032 = load double, ptr %4031, align 8, !tbaa !15
  %4033 = load ptr, ptr %39, align 8, !tbaa !5
  %4034 = load i32, ptr %68, align 4, !tbaa !9
  %4035 = sext i32 %4034 to i64
  %4036 = getelementptr inbounds %struct.doublecomplex, ptr %4033, i64 %4035
  %4037 = getelementptr inbounds %struct.doublecomplex, ptr %4036, i32 0, i32 1
  %4038 = load double, ptr %4037, align 8, !tbaa !15
  %4039 = load ptr, ptr %33, align 8, !tbaa !5
  %4040 = load i32, ptr %69, align 4, !tbaa !9
  %4041 = sext i32 %4040 to i64
  %4042 = getelementptr inbounds %struct.doublecomplex, ptr %4039, i64 %4041
  %4043 = getelementptr inbounds %struct.doublecomplex, ptr %4042, i32 0, i32 0
  %4044 = load double, ptr %4043, align 8, !tbaa !13
  %4045 = fmul double %4038, %4044
  %4046 = call double @llvm.fmuladd.f64(double %4026, double %4032, double %4045)
  %4047 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %4046, ptr %4047, align 8, !tbaa !15
  %4048 = load ptr, ptr %33, align 8, !tbaa !5
  %4049 = load i32, ptr %67, align 4, !tbaa !9
  %4050 = sext i32 %4049 to i64
  %4051 = getelementptr inbounds %struct.doublecomplex, ptr %4048, i64 %4050
  %4052 = getelementptr inbounds %struct.doublecomplex, ptr %4051, i32 0, i32 0
  %4053 = load double, ptr %4052, align 8, !tbaa !13
  %4054 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %4055 = load double, ptr %4054, align 8, !tbaa !13
  %4056 = fadd double %4053, %4055
  %4057 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %4056, ptr %4057, align 8, !tbaa !13
  %4058 = load ptr, ptr %33, align 8, !tbaa !5
  %4059 = load i32, ptr %67, align 4, !tbaa !9
  %4060 = sext i32 %4059 to i64
  %4061 = getelementptr inbounds %struct.doublecomplex, ptr %4058, i64 %4060
  %4062 = getelementptr inbounds %struct.doublecomplex, ptr %4061, i32 0, i32 1
  %4063 = load double, ptr %4062, align 8, !tbaa !15
  %4064 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %4065 = load double, ptr %4064, align 8, !tbaa !15
  %4066 = fadd double %4063, %4065
  %4067 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %4066, ptr %4067, align 8, !tbaa !15
  %4068 = load i32, ptr %101, align 4, !tbaa !9
  %4069 = load i32, ptr %53, align 4, !tbaa !9
  %4070 = mul nsw i32 %4068, %4069
  %4071 = add nsw i32 %4070, 3
  store i32 %4071, ptr %70, align 4, !tbaa !9
  %4072 = load i32, ptr %99, align 4, !tbaa !9
  %4073 = load i32, ptr %100, align 4, !tbaa !9
  %4074 = add nsw i32 %4073, 3
  %4075 = load i32, ptr %49, align 4, !tbaa !9
  %4076 = mul nsw i32 %4074, %4075
  %4077 = add nsw i32 %4072, %4076
  store i32 %4077, ptr %71, align 4, !tbaa !9
  %4078 = load ptr, ptr %39, align 8, !tbaa !5
  %4079 = load i32, ptr %70, align 4, !tbaa !9
  %4080 = sext i32 %4079 to i64
  %4081 = getelementptr inbounds %struct.doublecomplex, ptr %4078, i64 %4080
  %4082 = getelementptr inbounds %struct.doublecomplex, ptr %4081, i32 0, i32 0
  %4083 = load double, ptr %4082, align 8, !tbaa !13
  %4084 = load ptr, ptr %33, align 8, !tbaa !5
  %4085 = load i32, ptr %71, align 4, !tbaa !9
  %4086 = sext i32 %4085 to i64
  %4087 = getelementptr inbounds %struct.doublecomplex, ptr %4084, i64 %4086
  %4088 = getelementptr inbounds %struct.doublecomplex, ptr %4087, i32 0, i32 0
  %4089 = load double, ptr %4088, align 8, !tbaa !13
  %4090 = load ptr, ptr %39, align 8, !tbaa !5
  %4091 = load i32, ptr %70, align 4, !tbaa !9
  %4092 = sext i32 %4091 to i64
  %4093 = getelementptr inbounds %struct.doublecomplex, ptr %4090, i64 %4092
  %4094 = getelementptr inbounds %struct.doublecomplex, ptr %4093, i32 0, i32 1
  %4095 = load double, ptr %4094, align 8, !tbaa !15
  %4096 = load ptr, ptr %33, align 8, !tbaa !5
  %4097 = load i32, ptr %71, align 4, !tbaa !9
  %4098 = sext i32 %4097 to i64
  %4099 = getelementptr inbounds %struct.doublecomplex, ptr %4096, i64 %4098
  %4100 = getelementptr inbounds %struct.doublecomplex, ptr %4099, i32 0, i32 1
  %4101 = load double, ptr %4100, align 8, !tbaa !15
  %4102 = fmul double %4095, %4101
  %4103 = fneg double %4102
  %4104 = call double @llvm.fmuladd.f64(double %4083, double %4089, double %4103)
  %4105 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %4104, ptr %4105, align 8, !tbaa !13
  %4106 = load ptr, ptr %39, align 8, !tbaa !5
  %4107 = load i32, ptr %70, align 4, !tbaa !9
  %4108 = sext i32 %4107 to i64
  %4109 = getelementptr inbounds %struct.doublecomplex, ptr %4106, i64 %4108
  %4110 = getelementptr inbounds %struct.doublecomplex, ptr %4109, i32 0, i32 0
  %4111 = load double, ptr %4110, align 8, !tbaa !13
  %4112 = load ptr, ptr %33, align 8, !tbaa !5
  %4113 = load i32, ptr %71, align 4, !tbaa !9
  %4114 = sext i32 %4113 to i64
  %4115 = getelementptr inbounds %struct.doublecomplex, ptr %4112, i64 %4114
  %4116 = getelementptr inbounds %struct.doublecomplex, ptr %4115, i32 0, i32 1
  %4117 = load double, ptr %4116, align 8, !tbaa !15
  %4118 = load ptr, ptr %39, align 8, !tbaa !5
  %4119 = load i32, ptr %70, align 4, !tbaa !9
  %4120 = sext i32 %4119 to i64
  %4121 = getelementptr inbounds %struct.doublecomplex, ptr %4118, i64 %4120
  %4122 = getelementptr inbounds %struct.doublecomplex, ptr %4121, i32 0, i32 1
  %4123 = load double, ptr %4122, align 8, !tbaa !15
  %4124 = load ptr, ptr %33, align 8, !tbaa !5
  %4125 = load i32, ptr %71, align 4, !tbaa !9
  %4126 = sext i32 %4125 to i64
  %4127 = getelementptr inbounds %struct.doublecomplex, ptr %4124, i64 %4126
  %4128 = getelementptr inbounds %struct.doublecomplex, ptr %4127, i32 0, i32 0
  %4129 = load double, ptr %4128, align 8, !tbaa !13
  %4130 = fmul double %4123, %4129
  %4131 = call double @llvm.fmuladd.f64(double %4111, double %4117, double %4130)
  %4132 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %4131, ptr %4132, align 8, !tbaa !15
  %4133 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4134 = load double, ptr %4133, align 8, !tbaa !13
  %4135 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %4136 = load double, ptr %4135, align 8, !tbaa !13
  %4137 = fadd double %4134, %4136
  %4138 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %4137, ptr %4138, align 8, !tbaa !13
  %4139 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4140 = load double, ptr %4139, align 8, !tbaa !15
  %4141 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %4142 = load double, ptr %4141, align 8, !tbaa !15
  %4143 = fadd double %4140, %4142
  %4144 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %4143, ptr %4144, align 8, !tbaa !15
  %4145 = load ptr, ptr %39, align 8, !tbaa !5
  %4146 = load i32, ptr %65, align 4, !tbaa !9
  %4147 = sext i32 %4146 to i64
  %4148 = getelementptr inbounds %struct.doublecomplex, ptr %4145, i64 %4147
  %4149 = getelementptr inbounds %struct.doublecomplex, ptr %4148, i32 0, i32 0
  %4150 = load double, ptr %4149, align 8, !tbaa !13
  %4151 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4152 = load double, ptr %4151, align 8, !tbaa !13
  %4153 = load ptr, ptr %39, align 8, !tbaa !5
  %4154 = load i32, ptr %65, align 4, !tbaa !9
  %4155 = sext i32 %4154 to i64
  %4156 = getelementptr inbounds %struct.doublecomplex, ptr %4153, i64 %4155
  %4157 = getelementptr inbounds %struct.doublecomplex, ptr %4156, i32 0, i32 1
  %4158 = load double, ptr %4157, align 8, !tbaa !15
  %4159 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4160 = load double, ptr %4159, align 8, !tbaa !15
  %4161 = fmul double %4158, %4160
  %4162 = fneg double %4161
  %4163 = call double @llvm.fmuladd.f64(double %4150, double %4152, double %4162)
  %4164 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4163, ptr %4164, align 8, !tbaa !13
  %4165 = load ptr, ptr %39, align 8, !tbaa !5
  %4166 = load i32, ptr %65, align 4, !tbaa !9
  %4167 = sext i32 %4166 to i64
  %4168 = getelementptr inbounds %struct.doublecomplex, ptr %4165, i64 %4167
  %4169 = getelementptr inbounds %struct.doublecomplex, ptr %4168, i32 0, i32 0
  %4170 = load double, ptr %4169, align 8, !tbaa !13
  %4171 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4172 = load double, ptr %4171, align 8, !tbaa !15
  %4173 = load ptr, ptr %39, align 8, !tbaa !5
  %4174 = load i32, ptr %65, align 4, !tbaa !9
  %4175 = sext i32 %4174 to i64
  %4176 = getelementptr inbounds %struct.doublecomplex, ptr %4173, i64 %4175
  %4177 = getelementptr inbounds %struct.doublecomplex, ptr %4176, i32 0, i32 1
  %4178 = load double, ptr %4177, align 8, !tbaa !15
  %4179 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4180 = load double, ptr %4179, align 8, !tbaa !13
  %4181 = fmul double %4178, %4180
  %4182 = call double @llvm.fmuladd.f64(double %4170, double %4172, double %4181)
  %4183 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4182, ptr %4183, align 8, !tbaa !15
  %4184 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4185 = load double, ptr %4184, align 8, !tbaa !13
  %4186 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %4185, ptr %4186, align 8, !tbaa !13
  %4187 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4188 = load double, ptr %4187, align 8, !tbaa !15
  %4189 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %4188, ptr %4189, align 8, !tbaa !15
  %4190 = load i32, ptr %99, align 4, !tbaa !9
  %4191 = load i32, ptr %100, align 4, !tbaa !9
  %4192 = add nsw i32 %4191, 1
  %4193 = load i32, ptr %49, align 4, !tbaa !9
  %4194 = mul nsw i32 %4192, %4193
  %4195 = add nsw i32 %4190, %4194
  store i32 %4195, ptr %65, align 4, !tbaa !9
  %4196 = load i32, ptr %99, align 4, !tbaa !9
  %4197 = load i32, ptr %100, align 4, !tbaa !9
  %4198 = add nsw i32 %4197, 1
  %4199 = load i32, ptr %49, align 4, !tbaa !9
  %4200 = mul nsw i32 %4198, %4199
  %4201 = add nsw i32 %4196, %4200
  store i32 %4201, ptr %67, align 4, !tbaa !9
  %4202 = load ptr, ptr %33, align 8, !tbaa !5
  %4203 = load i32, ptr %67, align 4, !tbaa !9
  %4204 = sext i32 %4203 to i64
  %4205 = getelementptr inbounds %struct.doublecomplex, ptr %4202, i64 %4204
  %4206 = getelementptr inbounds %struct.doublecomplex, ptr %4205, i32 0, i32 0
  %4207 = load double, ptr %4206, align 8, !tbaa !13
  %4208 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4209 = load double, ptr %4208, align 8, !tbaa !13
  %4210 = fsub double %4207, %4209
  %4211 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4210, ptr %4211, align 8, !tbaa !13
  %4212 = load ptr, ptr %33, align 8, !tbaa !5
  %4213 = load i32, ptr %67, align 4, !tbaa !9
  %4214 = sext i32 %4213 to i64
  %4215 = getelementptr inbounds %struct.doublecomplex, ptr %4212, i64 %4214
  %4216 = getelementptr inbounds %struct.doublecomplex, ptr %4215, i32 0, i32 1
  %4217 = load double, ptr %4216, align 8, !tbaa !15
  %4218 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4219 = load double, ptr %4218, align 8, !tbaa !15
  %4220 = fsub double %4217, %4219
  %4221 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4220, ptr %4221, align 8, !tbaa !15
  %4222 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4223 = load double, ptr %4222, align 8, !tbaa !13
  %4224 = load ptr, ptr %33, align 8, !tbaa !5
  %4225 = load i32, ptr %65, align 4, !tbaa !9
  %4226 = sext i32 %4225 to i64
  %4227 = getelementptr inbounds %struct.doublecomplex, ptr %4224, i64 %4226
  %4228 = getelementptr inbounds %struct.doublecomplex, ptr %4227, i32 0, i32 0
  store double %4223, ptr %4228, align 8, !tbaa !13
  %4229 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4230 = load double, ptr %4229, align 8, !tbaa !15
  %4231 = load ptr, ptr %33, align 8, !tbaa !5
  %4232 = load i32, ptr %65, align 4, !tbaa !9
  %4233 = sext i32 %4232 to i64
  %4234 = getelementptr inbounds %struct.doublecomplex, ptr %4231, i64 %4233
  %4235 = getelementptr inbounds %struct.doublecomplex, ptr %4234, i32 0, i32 1
  store double %4230, ptr %4235, align 8, !tbaa !15
  %4236 = load i32, ptr %99, align 4, !tbaa !9
  %4237 = load i32, ptr %100, align 4, !tbaa !9
  %4238 = add nsw i32 %4237, 2
  %4239 = load i32, ptr %49, align 4, !tbaa !9
  %4240 = mul nsw i32 %4238, %4239
  %4241 = add nsw i32 %4236, %4240
  store i32 %4241, ptr %65, align 4, !tbaa !9
  %4242 = load i32, ptr %99, align 4, !tbaa !9
  %4243 = load i32, ptr %100, align 4, !tbaa !9
  %4244 = add nsw i32 %4243, 2
  %4245 = load i32, ptr %49, align 4, !tbaa !9
  %4246 = mul nsw i32 %4244, %4245
  %4247 = add nsw i32 %4242, %4246
  store i32 %4247, ptr %67, align 4, !tbaa !9
  %4248 = load ptr, ptr %39, align 8, !tbaa !5
  %4249 = load i32, ptr %101, align 4, !tbaa !9
  %4250 = load i32, ptr %53, align 4, !tbaa !9
  %4251 = mul nsw i32 %4249, %4250
  %4252 = add nsw i32 %4251, 2
  %4253 = sext i32 %4252 to i64
  %4254 = getelementptr inbounds %struct.doublecomplex, ptr %4248, i64 %4253
  %4255 = call { double, double } @Cd(ptr noundef %4254)
  %4256 = extractvalue { double, double } %4255, 0
  %4257 = extractvalue { double, double } %4255, 1
  %4258 = fneg double %4257
  %4259 = call ptr @_pCd(ptr noundef %84)
  %4260 = getelementptr inbounds { double, double }, ptr %4259, i32 0, i32 0
  %4261 = getelementptr inbounds { double, double }, ptr %4259, i32 0, i32 1
  store double %4256, ptr %4260, align 8
  store double %4258, ptr %4261, align 8
  %4262 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4263 = load double, ptr %4262, align 8, !tbaa !13
  %4264 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4265 = load double, ptr %4264, align 8, !tbaa !13
  %4266 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4267 = load double, ptr %4266, align 8, !tbaa !15
  %4268 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4269 = load double, ptr %4268, align 8, !tbaa !15
  %4270 = fmul double %4267, %4269
  %4271 = fneg double %4270
  %4272 = call double @llvm.fmuladd.f64(double %4263, double %4265, double %4271)
  %4273 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %4272, ptr %4273, align 8, !tbaa !13
  %4274 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4275 = load double, ptr %4274, align 8, !tbaa !13
  %4276 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4277 = load double, ptr %4276, align 8, !tbaa !15
  %4278 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4279 = load double, ptr %4278, align 8, !tbaa !15
  %4280 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4281 = load double, ptr %4280, align 8, !tbaa !13
  %4282 = fmul double %4279, %4281
  %4283 = call double @llvm.fmuladd.f64(double %4275, double %4277, double %4282)
  %4284 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %4283, ptr %4284, align 8, !tbaa !15
  %4285 = load ptr, ptr %33, align 8, !tbaa !5
  %4286 = load i32, ptr %67, align 4, !tbaa !9
  %4287 = sext i32 %4286 to i64
  %4288 = getelementptr inbounds %struct.doublecomplex, ptr %4285, i64 %4287
  %4289 = getelementptr inbounds %struct.doublecomplex, ptr %4288, i32 0, i32 0
  %4290 = load double, ptr %4289, align 8, !tbaa !13
  %4291 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4292 = load double, ptr %4291, align 8, !tbaa !13
  %4293 = fsub double %4290, %4292
  %4294 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4293, ptr %4294, align 8, !tbaa !13
  %4295 = load ptr, ptr %33, align 8, !tbaa !5
  %4296 = load i32, ptr %67, align 4, !tbaa !9
  %4297 = sext i32 %4296 to i64
  %4298 = getelementptr inbounds %struct.doublecomplex, ptr %4295, i64 %4297
  %4299 = getelementptr inbounds %struct.doublecomplex, ptr %4298, i32 0, i32 1
  %4300 = load double, ptr %4299, align 8, !tbaa !15
  %4301 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4302 = load double, ptr %4301, align 8, !tbaa !15
  %4303 = fsub double %4300, %4302
  %4304 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4303, ptr %4304, align 8, !tbaa !15
  %4305 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4306 = load double, ptr %4305, align 8, !tbaa !13
  %4307 = load ptr, ptr %33, align 8, !tbaa !5
  %4308 = load i32, ptr %65, align 4, !tbaa !9
  %4309 = sext i32 %4308 to i64
  %4310 = getelementptr inbounds %struct.doublecomplex, ptr %4307, i64 %4309
  %4311 = getelementptr inbounds %struct.doublecomplex, ptr %4310, i32 0, i32 0
  store double %4306, ptr %4311, align 8, !tbaa !13
  %4312 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4313 = load double, ptr %4312, align 8, !tbaa !15
  %4314 = load ptr, ptr %33, align 8, !tbaa !5
  %4315 = load i32, ptr %65, align 4, !tbaa !9
  %4316 = sext i32 %4315 to i64
  %4317 = getelementptr inbounds %struct.doublecomplex, ptr %4314, i64 %4316
  %4318 = getelementptr inbounds %struct.doublecomplex, ptr %4317, i32 0, i32 1
  store double %4313, ptr %4318, align 8, !tbaa !15
  %4319 = load i32, ptr %99, align 4, !tbaa !9
  %4320 = load i32, ptr %100, align 4, !tbaa !9
  %4321 = add nsw i32 %4320, 3
  %4322 = load i32, ptr %49, align 4, !tbaa !9
  %4323 = mul nsw i32 %4321, %4322
  %4324 = add nsw i32 %4319, %4323
  store i32 %4324, ptr %65, align 4, !tbaa !9
  %4325 = load i32, ptr %99, align 4, !tbaa !9
  %4326 = load i32, ptr %100, align 4, !tbaa !9
  %4327 = add nsw i32 %4326, 3
  %4328 = load i32, ptr %49, align 4, !tbaa !9
  %4329 = mul nsw i32 %4327, %4328
  %4330 = add nsw i32 %4325, %4329
  store i32 %4330, ptr %67, align 4, !tbaa !9
  %4331 = load ptr, ptr %39, align 8, !tbaa !5
  %4332 = load i32, ptr %101, align 4, !tbaa !9
  %4333 = load i32, ptr %53, align 4, !tbaa !9
  %4334 = mul nsw i32 %4332, %4333
  %4335 = add nsw i32 %4334, 3
  %4336 = sext i32 %4335 to i64
  %4337 = getelementptr inbounds %struct.doublecomplex, ptr %4331, i64 %4336
  %4338 = call { double, double } @Cd(ptr noundef %4337)
  %4339 = extractvalue { double, double } %4338, 0
  %4340 = extractvalue { double, double } %4338, 1
  %4341 = fneg double %4340
  %4342 = call ptr @_pCd(ptr noundef %84)
  %4343 = getelementptr inbounds { double, double }, ptr %4342, i32 0, i32 0
  %4344 = getelementptr inbounds { double, double }, ptr %4342, i32 0, i32 1
  store double %4339, ptr %4343, align 8
  store double %4341, ptr %4344, align 8
  %4345 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4346 = load double, ptr %4345, align 8, !tbaa !13
  %4347 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4348 = load double, ptr %4347, align 8, !tbaa !13
  %4349 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4350 = load double, ptr %4349, align 8, !tbaa !15
  %4351 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4352 = load double, ptr %4351, align 8, !tbaa !15
  %4353 = fmul double %4350, %4352
  %4354 = fneg double %4353
  %4355 = call double @llvm.fmuladd.f64(double %4346, double %4348, double %4354)
  %4356 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %4355, ptr %4356, align 8, !tbaa !13
  %4357 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4358 = load double, ptr %4357, align 8, !tbaa !13
  %4359 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4360 = load double, ptr %4359, align 8, !tbaa !15
  %4361 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4362 = load double, ptr %4361, align 8, !tbaa !15
  %4363 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4364 = load double, ptr %4363, align 8, !tbaa !13
  %4365 = fmul double %4362, %4364
  %4366 = call double @llvm.fmuladd.f64(double %4358, double %4360, double %4365)
  %4367 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %4366, ptr %4367, align 8, !tbaa !15
  %4368 = load ptr, ptr %33, align 8, !tbaa !5
  %4369 = load i32, ptr %67, align 4, !tbaa !9
  %4370 = sext i32 %4369 to i64
  %4371 = getelementptr inbounds %struct.doublecomplex, ptr %4368, i64 %4370
  %4372 = getelementptr inbounds %struct.doublecomplex, ptr %4371, i32 0, i32 0
  %4373 = load double, ptr %4372, align 8, !tbaa !13
  %4374 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4375 = load double, ptr %4374, align 8, !tbaa !13
  %4376 = fsub double %4373, %4375
  %4377 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4376, ptr %4377, align 8, !tbaa !13
  %4378 = load ptr, ptr %33, align 8, !tbaa !5
  %4379 = load i32, ptr %67, align 4, !tbaa !9
  %4380 = sext i32 %4379 to i64
  %4381 = getelementptr inbounds %struct.doublecomplex, ptr %4378, i64 %4380
  %4382 = getelementptr inbounds %struct.doublecomplex, ptr %4381, i32 0, i32 1
  %4383 = load double, ptr %4382, align 8, !tbaa !15
  %4384 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4385 = load double, ptr %4384, align 8, !tbaa !15
  %4386 = fsub double %4383, %4385
  %4387 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4386, ptr %4387, align 8, !tbaa !15
  %4388 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4389 = load double, ptr %4388, align 8, !tbaa !13
  %4390 = load ptr, ptr %33, align 8, !tbaa !5
  %4391 = load i32, ptr %65, align 4, !tbaa !9
  %4392 = sext i32 %4391 to i64
  %4393 = getelementptr inbounds %struct.doublecomplex, ptr %4390, i64 %4392
  %4394 = getelementptr inbounds %struct.doublecomplex, ptr %4393, i32 0, i32 0
  store double %4389, ptr %4394, align 8, !tbaa !13
  %4395 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4396 = load double, ptr %4395, align 8, !tbaa !15
  %4397 = load ptr, ptr %33, align 8, !tbaa !5
  %4398 = load i32, ptr %65, align 4, !tbaa !9
  %4399 = sext i32 %4398 to i64
  %4400 = getelementptr inbounds %struct.doublecomplex, ptr %4397, i64 %4399
  %4401 = getelementptr inbounds %struct.doublecomplex, ptr %4400, i32 0, i32 1
  store double %4396, ptr %4401, align 8, !tbaa !15
  br label %4402

4402:                                             ; preds = %3972
  %4403 = load i32, ptr %99, align 4, !tbaa !9
  %4404 = add nsw i32 %4403, 1
  store i32 %4404, ptr %99, align 4, !tbaa !9
  br label %3968, !llvm.loop !21

4405:                                             ; preds = %3968
  %4406 = load ptr, ptr %39, align 8, !tbaa !5
  %4407 = load i32, ptr %101, align 4, !tbaa !9
  %4408 = load i32, ptr %53, align 4, !tbaa !9
  %4409 = mul nsw i32 %4407, %4408
  %4410 = add nsw i32 %4409, 1
  %4411 = sext i32 %4410 to i64
  %4412 = getelementptr inbounds %struct.doublecomplex, ptr %4406, i64 %4411
  %4413 = call { double, double } @Cd(ptr noundef %4412)
  %4414 = extractvalue { double, double } %4413, 0
  %4415 = extractvalue { double, double } %4413, 1
  %4416 = fneg double %4415
  %4417 = call ptr @_pCd(ptr noundef %83)
  %4418 = getelementptr inbounds { double, double }, ptr %4417, i32 0, i32 0
  %4419 = getelementptr inbounds { double, double }, ptr %4417, i32 0, i32 1
  store double %4414, ptr %4418, align 8
  store double %4416, ptr %4419, align 8
  %4420 = load i32, ptr %100, align 4, !tbaa !9
  %4421 = add nsw i32 %4420, 1
  %4422 = load i32, ptr %100, align 4, !tbaa !9
  %4423 = add nsw i32 %4422, 1
  %4424 = load i32, ptr %49, align 4, !tbaa !9
  %4425 = mul nsw i32 %4423, %4424
  %4426 = add nsw i32 %4421, %4425
  store i32 %4426, ptr %64, align 4, !tbaa !9
  %4427 = load ptr, ptr %39, align 8, !tbaa !5
  %4428 = load i32, ptr %101, align 4, !tbaa !9
  %4429 = load i32, ptr %53, align 4, !tbaa !9
  %4430 = mul nsw i32 %4428, %4429
  %4431 = add nsw i32 %4430, 2
  %4432 = sext i32 %4431 to i64
  %4433 = getelementptr inbounds %struct.doublecomplex, ptr %4427, i64 %4432
  %4434 = call { double, double } @Cd(ptr noundef %4433)
  %4435 = extractvalue { double, double } %4434, 0
  %4436 = extractvalue { double, double } %4434, 1
  %4437 = fneg double %4436
  %4438 = call ptr @_pCd(ptr noundef %87)
  %4439 = getelementptr inbounds { double, double }, ptr %4438, i32 0, i32 0
  %4440 = getelementptr inbounds { double, double }, ptr %4438, i32 0, i32 1
  store double %4435, ptr %4439, align 8
  store double %4437, ptr %4440, align 8
  %4441 = load i32, ptr %100, align 4, !tbaa !9
  %4442 = add nsw i32 %4441, 2
  %4443 = load i32, ptr %100, align 4, !tbaa !9
  %4444 = add nsw i32 %4443, 1
  %4445 = load i32, ptr %49, align 4, !tbaa !9
  %4446 = mul nsw i32 %4444, %4445
  %4447 = add nsw i32 %4442, %4446
  store i32 %4447, ptr %65, align 4, !tbaa !9
  %4448 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 0
  %4449 = load double, ptr %4448, align 8, !tbaa !13
  %4450 = load ptr, ptr %33, align 8, !tbaa !5
  %4451 = load i32, ptr %65, align 4, !tbaa !9
  %4452 = sext i32 %4451 to i64
  %4453 = getelementptr inbounds %struct.doublecomplex, ptr %4450, i64 %4452
  %4454 = getelementptr inbounds %struct.doublecomplex, ptr %4453, i32 0, i32 0
  %4455 = load double, ptr %4454, align 8, !tbaa !13
  %4456 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 1
  %4457 = load double, ptr %4456, align 8, !tbaa !15
  %4458 = load ptr, ptr %33, align 8, !tbaa !5
  %4459 = load i32, ptr %65, align 4, !tbaa !9
  %4460 = sext i32 %4459 to i64
  %4461 = getelementptr inbounds %struct.doublecomplex, ptr %4458, i64 %4460
  %4462 = getelementptr inbounds %struct.doublecomplex, ptr %4461, i32 0, i32 1
  %4463 = load double, ptr %4462, align 8, !tbaa !15
  %4464 = fmul double %4457, %4463
  %4465 = fneg double %4464
  %4466 = call double @llvm.fmuladd.f64(double %4449, double %4455, double %4465)
  %4467 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %4466, ptr %4467, align 8, !tbaa !13
  %4468 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 0
  %4469 = load double, ptr %4468, align 8, !tbaa !13
  %4470 = load ptr, ptr %33, align 8, !tbaa !5
  %4471 = load i32, ptr %65, align 4, !tbaa !9
  %4472 = sext i32 %4471 to i64
  %4473 = getelementptr inbounds %struct.doublecomplex, ptr %4470, i64 %4472
  %4474 = getelementptr inbounds %struct.doublecomplex, ptr %4473, i32 0, i32 1
  %4475 = load double, ptr %4474, align 8, !tbaa !15
  %4476 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 1
  %4477 = load double, ptr %4476, align 8, !tbaa !15
  %4478 = load ptr, ptr %33, align 8, !tbaa !5
  %4479 = load i32, ptr %65, align 4, !tbaa !9
  %4480 = sext i32 %4479 to i64
  %4481 = getelementptr inbounds %struct.doublecomplex, ptr %4478, i64 %4480
  %4482 = getelementptr inbounds %struct.doublecomplex, ptr %4481, i32 0, i32 0
  %4483 = load double, ptr %4482, align 8, !tbaa !13
  %4484 = fmul double %4477, %4483
  %4485 = call double @llvm.fmuladd.f64(double %4469, double %4475, double %4484)
  %4486 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %4485, ptr %4486, align 8, !tbaa !15
  %4487 = load ptr, ptr %33, align 8, !tbaa !5
  %4488 = load i32, ptr %64, align 4, !tbaa !9
  %4489 = sext i32 %4488 to i64
  %4490 = getelementptr inbounds %struct.doublecomplex, ptr %4487, i64 %4489
  %4491 = getelementptr inbounds %struct.doublecomplex, ptr %4490, i32 0, i32 0
  %4492 = load double, ptr %4491, align 8, !tbaa !13
  %4493 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %4494 = load double, ptr %4493, align 8, !tbaa !13
  %4495 = fadd double %4492, %4494
  %4496 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %4495, ptr %4496, align 8, !tbaa !13
  %4497 = load ptr, ptr %33, align 8, !tbaa !5
  %4498 = load i32, ptr %64, align 4, !tbaa !9
  %4499 = sext i32 %4498 to i64
  %4500 = getelementptr inbounds %struct.doublecomplex, ptr %4497, i64 %4499
  %4501 = getelementptr inbounds %struct.doublecomplex, ptr %4500, i32 0, i32 1
  %4502 = load double, ptr %4501, align 8, !tbaa !15
  %4503 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %4504 = load double, ptr %4503, align 8, !tbaa !15
  %4505 = fadd double %4502, %4504
  %4506 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %4505, ptr %4506, align 8, !tbaa !15
  %4507 = load ptr, ptr %39, align 8, !tbaa !5
  %4508 = load i32, ptr %101, align 4, !tbaa !9
  %4509 = load i32, ptr %53, align 4, !tbaa !9
  %4510 = mul nsw i32 %4508, %4509
  %4511 = add nsw i32 %4510, 3
  %4512 = sext i32 %4511 to i64
  %4513 = getelementptr inbounds %struct.doublecomplex, ptr %4507, i64 %4512
  %4514 = call { double, double } @Cd(ptr noundef %4513)
  %4515 = extractvalue { double, double } %4514, 0
  %4516 = extractvalue { double, double } %4514, 1
  %4517 = fneg double %4516
  %4518 = call ptr @_pCd(ptr noundef %89)
  %4519 = getelementptr inbounds { double, double }, ptr %4518, i32 0, i32 0
  %4520 = getelementptr inbounds { double, double }, ptr %4518, i32 0, i32 1
  store double %4515, ptr %4519, align 8
  store double %4517, ptr %4520, align 8
  %4521 = load i32, ptr %100, align 4, !tbaa !9
  %4522 = add nsw i32 %4521, 3
  %4523 = load i32, ptr %100, align 4, !tbaa !9
  %4524 = add nsw i32 %4523, 1
  %4525 = load i32, ptr %49, align 4, !tbaa !9
  %4526 = mul nsw i32 %4524, %4525
  %4527 = add nsw i32 %4522, %4526
  store i32 %4527, ptr %67, align 4, !tbaa !9
  %4528 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 0
  %4529 = load double, ptr %4528, align 8, !tbaa !13
  %4530 = load ptr, ptr %33, align 8, !tbaa !5
  %4531 = load i32, ptr %67, align 4, !tbaa !9
  %4532 = sext i32 %4531 to i64
  %4533 = getelementptr inbounds %struct.doublecomplex, ptr %4530, i64 %4532
  %4534 = getelementptr inbounds %struct.doublecomplex, ptr %4533, i32 0, i32 0
  %4535 = load double, ptr %4534, align 8, !tbaa !13
  %4536 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 1
  %4537 = load double, ptr %4536, align 8, !tbaa !15
  %4538 = load ptr, ptr %33, align 8, !tbaa !5
  %4539 = load i32, ptr %67, align 4, !tbaa !9
  %4540 = sext i32 %4539 to i64
  %4541 = getelementptr inbounds %struct.doublecomplex, ptr %4538, i64 %4540
  %4542 = getelementptr inbounds %struct.doublecomplex, ptr %4541, i32 0, i32 1
  %4543 = load double, ptr %4542, align 8, !tbaa !15
  %4544 = fmul double %4537, %4543
  %4545 = fneg double %4544
  %4546 = call double @llvm.fmuladd.f64(double %4529, double %4535, double %4545)
  %4547 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  store double %4546, ptr %4547, align 8, !tbaa !13
  %4548 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 0
  %4549 = load double, ptr %4548, align 8, !tbaa !13
  %4550 = load ptr, ptr %33, align 8, !tbaa !5
  %4551 = load i32, ptr %67, align 4, !tbaa !9
  %4552 = sext i32 %4551 to i64
  %4553 = getelementptr inbounds %struct.doublecomplex, ptr %4550, i64 %4552
  %4554 = getelementptr inbounds %struct.doublecomplex, ptr %4553, i32 0, i32 1
  %4555 = load double, ptr %4554, align 8, !tbaa !15
  %4556 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 1
  %4557 = load double, ptr %4556, align 8, !tbaa !15
  %4558 = load ptr, ptr %33, align 8, !tbaa !5
  %4559 = load i32, ptr %67, align 4, !tbaa !9
  %4560 = sext i32 %4559 to i64
  %4561 = getelementptr inbounds %struct.doublecomplex, ptr %4558, i64 %4560
  %4562 = getelementptr inbounds %struct.doublecomplex, ptr %4561, i32 0, i32 0
  %4563 = load double, ptr %4562, align 8, !tbaa !13
  %4564 = fmul double %4557, %4563
  %4565 = call double @llvm.fmuladd.f64(double %4549, double %4555, double %4564)
  %4566 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  store double %4565, ptr %4566, align 8, !tbaa !15
  %4567 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %4568 = load double, ptr %4567, align 8, !tbaa !13
  %4569 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %4570 = load double, ptr %4569, align 8, !tbaa !13
  %4571 = fadd double %4568, %4570
  %4572 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %4571, ptr %4572, align 8, !tbaa !13
  %4573 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %4574 = load double, ptr %4573, align 8, !tbaa !15
  %4575 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %4576 = load double, ptr %4575, align 8, !tbaa !15
  %4577 = fadd double %4574, %4576
  %4578 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %4577, ptr %4578, align 8, !tbaa !15
  %4579 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4580 = load double, ptr %4579, align 8, !tbaa !13
  %4581 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4582 = load double, ptr %4581, align 8, !tbaa !13
  %4583 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4584 = load double, ptr %4583, align 8, !tbaa !15
  %4585 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4586 = load double, ptr %4585, align 8, !tbaa !15
  %4587 = fmul double %4584, %4586
  %4588 = fneg double %4587
  %4589 = call double @llvm.fmuladd.f64(double %4580, double %4582, double %4588)
  %4590 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4589, ptr %4590, align 8, !tbaa !13
  %4591 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4592 = load double, ptr %4591, align 8, !tbaa !13
  %4593 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %4594 = load double, ptr %4593, align 8, !tbaa !15
  %4595 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4596 = load double, ptr %4595, align 8, !tbaa !15
  %4597 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %4598 = load double, ptr %4597, align 8, !tbaa !13
  %4599 = fmul double %4596, %4598
  %4600 = call double @llvm.fmuladd.f64(double %4592, double %4594, double %4599)
  %4601 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4600, ptr %4601, align 8, !tbaa !15
  %4602 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4603 = load double, ptr %4602, align 8, !tbaa !13
  %4604 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %4603, ptr %4604, align 8, !tbaa !13
  %4605 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4606 = load double, ptr %4605, align 8, !tbaa !15
  %4607 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %4606, ptr %4607, align 8, !tbaa !15
  %4608 = load i32, ptr %100, align 4, !tbaa !9
  %4609 = add nsw i32 %4608, 1
  %4610 = load i32, ptr %100, align 4, !tbaa !9
  %4611 = add nsw i32 %4610, 1
  %4612 = load i32, ptr %49, align 4, !tbaa !9
  %4613 = mul nsw i32 %4611, %4612
  %4614 = add nsw i32 %4609, %4613
  store i32 %4614, ptr %64, align 4, !tbaa !9
  %4615 = load i32, ptr %100, align 4, !tbaa !9
  %4616 = add nsw i32 %4615, 1
  %4617 = load i32, ptr %100, align 4, !tbaa !9
  %4618 = add nsw i32 %4617, 1
  %4619 = load i32, ptr %49, align 4, !tbaa !9
  %4620 = mul nsw i32 %4618, %4619
  %4621 = add nsw i32 %4616, %4620
  store i32 %4621, ptr %65, align 4, !tbaa !9
  %4622 = load ptr, ptr %33, align 8, !tbaa !5
  %4623 = load i32, ptr %65, align 4, !tbaa !9
  %4624 = sext i32 %4623 to i64
  %4625 = getelementptr inbounds %struct.doublecomplex, ptr %4622, i64 %4624
  %4626 = getelementptr inbounds %struct.doublecomplex, ptr %4625, i32 0, i32 0
  %4627 = load double, ptr %4626, align 8, !tbaa !13
  %4628 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4629 = load double, ptr %4628, align 8, !tbaa !13
  %4630 = fsub double %4627, %4629
  %4631 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4630, ptr %4631, align 8, !tbaa !13
  %4632 = load ptr, ptr %33, align 8, !tbaa !5
  %4633 = load i32, ptr %65, align 4, !tbaa !9
  %4634 = sext i32 %4633 to i64
  %4635 = getelementptr inbounds %struct.doublecomplex, ptr %4632, i64 %4634
  %4636 = getelementptr inbounds %struct.doublecomplex, ptr %4635, i32 0, i32 1
  %4637 = load double, ptr %4636, align 8, !tbaa !15
  %4638 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4639 = load double, ptr %4638, align 8, !tbaa !15
  %4640 = fsub double %4637, %4639
  %4641 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4640, ptr %4641, align 8, !tbaa !15
  %4642 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4643 = load double, ptr %4642, align 8, !tbaa !13
  %4644 = load ptr, ptr %33, align 8, !tbaa !5
  %4645 = load i32, ptr %64, align 4, !tbaa !9
  %4646 = sext i32 %4645 to i64
  %4647 = getelementptr inbounds %struct.doublecomplex, ptr %4644, i64 %4646
  %4648 = getelementptr inbounds %struct.doublecomplex, ptr %4647, i32 0, i32 0
  store double %4643, ptr %4648, align 8, !tbaa !13
  %4649 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4650 = load double, ptr %4649, align 8, !tbaa !15
  %4651 = load ptr, ptr %33, align 8, !tbaa !5
  %4652 = load i32, ptr %64, align 4, !tbaa !9
  %4653 = sext i32 %4652 to i64
  %4654 = getelementptr inbounds %struct.doublecomplex, ptr %4651, i64 %4653
  %4655 = getelementptr inbounds %struct.doublecomplex, ptr %4654, i32 0, i32 1
  store double %4650, ptr %4655, align 8, !tbaa !15
  %4656 = load i32, ptr %100, align 4, !tbaa !9
  %4657 = add nsw i32 %4656, 2
  %4658 = load i32, ptr %100, align 4, !tbaa !9
  %4659 = add nsw i32 %4658, 1
  %4660 = load i32, ptr %49, align 4, !tbaa !9
  %4661 = mul nsw i32 %4659, %4660
  %4662 = add nsw i32 %4657, %4661
  store i32 %4662, ptr %64, align 4, !tbaa !9
  %4663 = load i32, ptr %100, align 4, !tbaa !9
  %4664 = add nsw i32 %4663, 2
  %4665 = load i32, ptr %100, align 4, !tbaa !9
  %4666 = add nsw i32 %4665, 1
  %4667 = load i32, ptr %49, align 4, !tbaa !9
  %4668 = mul nsw i32 %4666, %4667
  %4669 = add nsw i32 %4664, %4668
  store i32 %4669, ptr %65, align 4, !tbaa !9
  %4670 = load i32, ptr %101, align 4, !tbaa !9
  %4671 = load i32, ptr %53, align 4, !tbaa !9
  %4672 = mul nsw i32 %4670, %4671
  %4673 = add nsw i32 %4672, 2
  store i32 %4673, ptr %67, align 4, !tbaa !9
  %4674 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4675 = load double, ptr %4674, align 8, !tbaa !13
  %4676 = load ptr, ptr %39, align 8, !tbaa !5
  %4677 = load i32, ptr %67, align 4, !tbaa !9
  %4678 = sext i32 %4677 to i64
  %4679 = getelementptr inbounds %struct.doublecomplex, ptr %4676, i64 %4678
  %4680 = getelementptr inbounds %struct.doublecomplex, ptr %4679, i32 0, i32 0
  %4681 = load double, ptr %4680, align 8, !tbaa !13
  %4682 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4683 = load double, ptr %4682, align 8, !tbaa !15
  %4684 = load ptr, ptr %39, align 8, !tbaa !5
  %4685 = load i32, ptr %67, align 4, !tbaa !9
  %4686 = sext i32 %4685 to i64
  %4687 = getelementptr inbounds %struct.doublecomplex, ptr %4684, i64 %4686
  %4688 = getelementptr inbounds %struct.doublecomplex, ptr %4687, i32 0, i32 1
  %4689 = load double, ptr %4688, align 8, !tbaa !15
  %4690 = fmul double %4683, %4689
  %4691 = fneg double %4690
  %4692 = call double @llvm.fmuladd.f64(double %4675, double %4681, double %4691)
  %4693 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %4692, ptr %4693, align 8, !tbaa !13
  %4694 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4695 = load double, ptr %4694, align 8, !tbaa !13
  %4696 = load ptr, ptr %39, align 8, !tbaa !5
  %4697 = load i32, ptr %67, align 4, !tbaa !9
  %4698 = sext i32 %4697 to i64
  %4699 = getelementptr inbounds %struct.doublecomplex, ptr %4696, i64 %4698
  %4700 = getelementptr inbounds %struct.doublecomplex, ptr %4699, i32 0, i32 1
  %4701 = load double, ptr %4700, align 8, !tbaa !15
  %4702 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4703 = load double, ptr %4702, align 8, !tbaa !15
  %4704 = load ptr, ptr %39, align 8, !tbaa !5
  %4705 = load i32, ptr %67, align 4, !tbaa !9
  %4706 = sext i32 %4705 to i64
  %4707 = getelementptr inbounds %struct.doublecomplex, ptr %4704, i64 %4706
  %4708 = getelementptr inbounds %struct.doublecomplex, ptr %4707, i32 0, i32 0
  %4709 = load double, ptr %4708, align 8, !tbaa !13
  %4710 = fmul double %4703, %4709
  %4711 = call double @llvm.fmuladd.f64(double %4695, double %4701, double %4710)
  %4712 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %4711, ptr %4712, align 8, !tbaa !15
  %4713 = load ptr, ptr %33, align 8, !tbaa !5
  %4714 = load i32, ptr %65, align 4, !tbaa !9
  %4715 = sext i32 %4714 to i64
  %4716 = getelementptr inbounds %struct.doublecomplex, ptr %4713, i64 %4715
  %4717 = getelementptr inbounds %struct.doublecomplex, ptr %4716, i32 0, i32 0
  %4718 = load double, ptr %4717, align 8, !tbaa !13
  %4719 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4720 = load double, ptr %4719, align 8, !tbaa !13
  %4721 = fsub double %4718, %4720
  %4722 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4721, ptr %4722, align 8, !tbaa !13
  %4723 = load ptr, ptr %33, align 8, !tbaa !5
  %4724 = load i32, ptr %65, align 4, !tbaa !9
  %4725 = sext i32 %4724 to i64
  %4726 = getelementptr inbounds %struct.doublecomplex, ptr %4723, i64 %4725
  %4727 = getelementptr inbounds %struct.doublecomplex, ptr %4726, i32 0, i32 1
  %4728 = load double, ptr %4727, align 8, !tbaa !15
  %4729 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4730 = load double, ptr %4729, align 8, !tbaa !15
  %4731 = fsub double %4728, %4730
  %4732 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4731, ptr %4732, align 8, !tbaa !15
  %4733 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4734 = load double, ptr %4733, align 8, !tbaa !13
  %4735 = load ptr, ptr %33, align 8, !tbaa !5
  %4736 = load i32, ptr %64, align 4, !tbaa !9
  %4737 = sext i32 %4736 to i64
  %4738 = getelementptr inbounds %struct.doublecomplex, ptr %4735, i64 %4737
  %4739 = getelementptr inbounds %struct.doublecomplex, ptr %4738, i32 0, i32 0
  store double %4734, ptr %4739, align 8, !tbaa !13
  %4740 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4741 = load double, ptr %4740, align 8, !tbaa !15
  %4742 = load ptr, ptr %33, align 8, !tbaa !5
  %4743 = load i32, ptr %64, align 4, !tbaa !9
  %4744 = sext i32 %4743 to i64
  %4745 = getelementptr inbounds %struct.doublecomplex, ptr %4742, i64 %4744
  %4746 = getelementptr inbounds %struct.doublecomplex, ptr %4745, i32 0, i32 1
  store double %4741, ptr %4746, align 8, !tbaa !15
  %4747 = load i32, ptr %100, align 4, !tbaa !9
  %4748 = add nsw i32 %4747, 3
  %4749 = load i32, ptr %100, align 4, !tbaa !9
  %4750 = add nsw i32 %4749, 1
  %4751 = load i32, ptr %49, align 4, !tbaa !9
  %4752 = mul nsw i32 %4750, %4751
  %4753 = add nsw i32 %4748, %4752
  store i32 %4753, ptr %64, align 4, !tbaa !9
  %4754 = load i32, ptr %100, align 4, !tbaa !9
  %4755 = add nsw i32 %4754, 3
  %4756 = load i32, ptr %100, align 4, !tbaa !9
  %4757 = add nsw i32 %4756, 1
  %4758 = load i32, ptr %49, align 4, !tbaa !9
  %4759 = mul nsw i32 %4757, %4758
  %4760 = add nsw i32 %4755, %4759
  store i32 %4760, ptr %65, align 4, !tbaa !9
  %4761 = load i32, ptr %101, align 4, !tbaa !9
  %4762 = load i32, ptr %53, align 4, !tbaa !9
  %4763 = mul nsw i32 %4761, %4762
  %4764 = add nsw i32 %4763, 3
  store i32 %4764, ptr %67, align 4, !tbaa !9
  %4765 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4766 = load double, ptr %4765, align 8, !tbaa !13
  %4767 = load ptr, ptr %39, align 8, !tbaa !5
  %4768 = load i32, ptr %67, align 4, !tbaa !9
  %4769 = sext i32 %4768 to i64
  %4770 = getelementptr inbounds %struct.doublecomplex, ptr %4767, i64 %4769
  %4771 = getelementptr inbounds %struct.doublecomplex, ptr %4770, i32 0, i32 0
  %4772 = load double, ptr %4771, align 8, !tbaa !13
  %4773 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4774 = load double, ptr %4773, align 8, !tbaa !15
  %4775 = load ptr, ptr %39, align 8, !tbaa !5
  %4776 = load i32, ptr %67, align 4, !tbaa !9
  %4777 = sext i32 %4776 to i64
  %4778 = getelementptr inbounds %struct.doublecomplex, ptr %4775, i64 %4777
  %4779 = getelementptr inbounds %struct.doublecomplex, ptr %4778, i32 0, i32 1
  %4780 = load double, ptr %4779, align 8, !tbaa !15
  %4781 = fmul double %4774, %4780
  %4782 = fneg double %4781
  %4783 = call double @llvm.fmuladd.f64(double %4766, double %4772, double %4782)
  %4784 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %4783, ptr %4784, align 8, !tbaa !13
  %4785 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %4786 = load double, ptr %4785, align 8, !tbaa !13
  %4787 = load ptr, ptr %39, align 8, !tbaa !5
  %4788 = load i32, ptr %67, align 4, !tbaa !9
  %4789 = sext i32 %4788 to i64
  %4790 = getelementptr inbounds %struct.doublecomplex, ptr %4787, i64 %4789
  %4791 = getelementptr inbounds %struct.doublecomplex, ptr %4790, i32 0, i32 1
  %4792 = load double, ptr %4791, align 8, !tbaa !15
  %4793 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %4794 = load double, ptr %4793, align 8, !tbaa !15
  %4795 = load ptr, ptr %39, align 8, !tbaa !5
  %4796 = load i32, ptr %67, align 4, !tbaa !9
  %4797 = sext i32 %4796 to i64
  %4798 = getelementptr inbounds %struct.doublecomplex, ptr %4795, i64 %4797
  %4799 = getelementptr inbounds %struct.doublecomplex, ptr %4798, i32 0, i32 0
  %4800 = load double, ptr %4799, align 8, !tbaa !13
  %4801 = fmul double %4794, %4800
  %4802 = call double @llvm.fmuladd.f64(double %4786, double %4792, double %4801)
  %4803 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %4802, ptr %4803, align 8, !tbaa !15
  %4804 = load ptr, ptr %33, align 8, !tbaa !5
  %4805 = load i32, ptr %65, align 4, !tbaa !9
  %4806 = sext i32 %4805 to i64
  %4807 = getelementptr inbounds %struct.doublecomplex, ptr %4804, i64 %4806
  %4808 = getelementptr inbounds %struct.doublecomplex, ptr %4807, i32 0, i32 0
  %4809 = load double, ptr %4808, align 8, !tbaa !13
  %4810 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %4811 = load double, ptr %4810, align 8, !tbaa !13
  %4812 = fsub double %4809, %4811
  %4813 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %4812, ptr %4813, align 8, !tbaa !13
  %4814 = load ptr, ptr %33, align 8, !tbaa !5
  %4815 = load i32, ptr %65, align 4, !tbaa !9
  %4816 = sext i32 %4815 to i64
  %4817 = getelementptr inbounds %struct.doublecomplex, ptr %4814, i64 %4816
  %4818 = getelementptr inbounds %struct.doublecomplex, ptr %4817, i32 0, i32 1
  %4819 = load double, ptr %4818, align 8, !tbaa !15
  %4820 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %4821 = load double, ptr %4820, align 8, !tbaa !15
  %4822 = fsub double %4819, %4821
  %4823 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %4822, ptr %4823, align 8, !tbaa !15
  %4824 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %4825 = load double, ptr %4824, align 8, !tbaa !13
  %4826 = load ptr, ptr %33, align 8, !tbaa !5
  %4827 = load i32, ptr %64, align 4, !tbaa !9
  %4828 = sext i32 %4827 to i64
  %4829 = getelementptr inbounds %struct.doublecomplex, ptr %4826, i64 %4828
  %4830 = getelementptr inbounds %struct.doublecomplex, ptr %4829, i32 0, i32 0
  store double %4825, ptr %4830, align 8, !tbaa !13
  %4831 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %4832 = load double, ptr %4831, align 8, !tbaa !15
  %4833 = load ptr, ptr %33, align 8, !tbaa !5
  %4834 = load i32, ptr %64, align 4, !tbaa !9
  %4835 = sext i32 %4834 to i64
  %4836 = getelementptr inbounds %struct.doublecomplex, ptr %4833, i64 %4835
  %4837 = getelementptr inbounds %struct.doublecomplex, ptr %4836, i32 0, i32 1
  store double %4832, ptr %4837, align 8, !tbaa !15
  %4838 = load i32, ptr %100, align 4, !tbaa !9
  %4839 = load ptr, ptr %29, align 8, !tbaa !5
  %4840 = load i32, ptr %4839, align 4, !tbaa !9
  %4841 = icmp slt i32 %4838, %4840
  br i1 %4841, label %4842, label %4843

4842:                                             ; preds = %4405
  br label %5821

4843:                                             ; preds = %4405
  %4844 = load i32, ptr %100, align 4, !tbaa !9
  %4845 = add nsw i32 %4844, 1
  %4846 = load i32, ptr %100, align 4, !tbaa !9
  %4847 = load i32, ptr %49, align 4, !tbaa !9
  %4848 = mul nsw i32 %4846, %4847
  %4849 = add nsw i32 %4845, %4848
  store i32 %4849, ptr %64, align 4, !tbaa !9
  %4850 = load ptr, ptr %33, align 8, !tbaa !5
  %4851 = load i32, ptr %64, align 4, !tbaa !9
  %4852 = sext i32 %4851 to i64
  %4853 = getelementptr inbounds %struct.doublecomplex, ptr %4850, i64 %4852
  %4854 = getelementptr inbounds %struct.doublecomplex, ptr %4853, i32 0, i32 0
  %4855 = load double, ptr %4854, align 8, !tbaa !13
  %4856 = fcmp une double %4855, 0.000000e+00
  br i1 %4856, label %4865, label %4857

4857:                                             ; preds = %4843
  %4858 = load ptr, ptr %33, align 8, !tbaa !5
  %4859 = load i32, ptr %64, align 4, !tbaa !9
  %4860 = sext i32 %4859 to i64
  %4861 = getelementptr inbounds %struct.doublecomplex, ptr %4858, i64 %4860
  %4862 = getelementptr inbounds %struct.doublecomplex, ptr %4861, i32 0, i32 1
  %4863 = load double, ptr %4862, align 8, !tbaa !15
  %4864 = fcmp une double %4863, 0.000000e+00
  br i1 %4864, label %4865, label %5820

4865:                                             ; preds = %4857, %4843
  %4866 = load i32, ptr %100, align 4, !tbaa !9
  %4867 = load i32, ptr %100, align 4, !tbaa !9
  %4868 = load i32, ptr %49, align 4, !tbaa !9
  %4869 = mul nsw i32 %4867, %4868
  %4870 = add nsw i32 %4866, %4869
  store i32 %4870, ptr %64, align 4, !tbaa !9
  %4871 = load i32, ptr %100, align 4, !tbaa !9
  %4872 = add nsw i32 %4871, 1
  %4873 = load i32, ptr %100, align 4, !tbaa !9
  %4874 = add nsw i32 %4873, 1
  %4875 = load i32, ptr %49, align 4, !tbaa !9
  %4876 = mul nsw i32 %4874, %4875
  %4877 = add nsw i32 %4872, %4876
  store i32 %4877, ptr %65, align 4, !tbaa !9
  %4878 = load ptr, ptr %33, align 8, !tbaa !5
  %4879 = load i32, ptr %64, align 4, !tbaa !9
  %4880 = sext i32 %4879 to i64
  %4881 = getelementptr inbounds %struct.doublecomplex, ptr %4878, i64 %4880
  %4882 = getelementptr inbounds %struct.doublecomplex, ptr %4881, i32 0, i32 0
  %4883 = load double, ptr %4882, align 8, !tbaa !13
  store double %4883, ptr %72, align 8, !tbaa !11
  %4884 = load double, ptr %72, align 8, !tbaa !11
  %4885 = fcmp oge double %4884, 0.000000e+00
  br i1 %4885, label %4886, label %4888

4886:                                             ; preds = %4865
  %4887 = load double, ptr %72, align 8, !tbaa !11
  br label %4891

4888:                                             ; preds = %4865
  %4889 = load double, ptr %72, align 8, !tbaa !11
  %4890 = fneg double %4889
  br label %4891

4891:                                             ; preds = %4888, %4886
  %4892 = phi double [ %4887, %4886 ], [ %4890, %4888 ]
  %4893 = load ptr, ptr %33, align 8, !tbaa !5
  %4894 = load i32, ptr %100, align 4, !tbaa !9
  %4895 = load i32, ptr %100, align 4, !tbaa !9
  %4896 = load i32, ptr %49, align 4, !tbaa !9
  %4897 = mul nsw i32 %4895, %4896
  %4898 = add nsw i32 %4894, %4897
  %4899 = sext i32 %4898 to i64
  %4900 = getelementptr inbounds %struct.doublecomplex, ptr %4893, i64 %4899
  %4901 = call { double, double } @Cd(ptr noundef %4900)
  %4902 = extractvalue { double, double } %4901, 0
  %4903 = extractvalue { double, double } %4901, 1
  store double %4903, ptr %73, align 8, !tbaa !11
  %4904 = load double, ptr %73, align 8, !tbaa !11
  %4905 = fcmp oge double %4904, 0.000000e+00
  br i1 %4905, label %4906, label %4908

4906:                                             ; preds = %4891
  %4907 = load double, ptr %73, align 8, !tbaa !11
  br label %4911

4908:                                             ; preds = %4891
  %4909 = load double, ptr %73, align 8, !tbaa !11
  %4910 = fneg double %4909
  br label %4911

4911:                                             ; preds = %4908, %4906
  %4912 = phi double [ %4907, %4906 ], [ %4910, %4908 ]
  %4913 = fadd double %4892, %4912
  %4914 = load ptr, ptr %33, align 8, !tbaa !5
  %4915 = load i32, ptr %65, align 4, !tbaa !9
  %4916 = sext i32 %4915 to i64
  %4917 = getelementptr inbounds %struct.doublecomplex, ptr %4914, i64 %4916
  %4918 = getelementptr inbounds %struct.doublecomplex, ptr %4917, i32 0, i32 0
  %4919 = load double, ptr %4918, align 8, !tbaa !13
  store double %4919, ptr %74, align 8, !tbaa !11
  %4920 = load double, ptr %74, align 8, !tbaa !11
  %4921 = fcmp oge double %4920, 0.000000e+00
  br i1 %4921, label %4922, label %4924

4922:                                             ; preds = %4911
  %4923 = load double, ptr %74, align 8, !tbaa !11
  br label %4927

4924:                                             ; preds = %4911
  %4925 = load double, ptr %74, align 8, !tbaa !11
  %4926 = fneg double %4925
  br label %4927

4927:                                             ; preds = %4924, %4922
  %4928 = phi double [ %4923, %4922 ], [ %4926, %4924 ]
  %4929 = load ptr, ptr %33, align 8, !tbaa !5
  %4930 = load i32, ptr %100, align 4, !tbaa !9
  %4931 = add nsw i32 %4930, 1
  %4932 = load i32, ptr %100, align 4, !tbaa !9
  %4933 = add nsw i32 %4932, 1
  %4934 = load i32, ptr %49, align 4, !tbaa !9
  %4935 = mul nsw i32 %4933, %4934
  %4936 = add nsw i32 %4931, %4935
  %4937 = sext i32 %4936 to i64
  %4938 = getelementptr inbounds %struct.doublecomplex, ptr %4929, i64 %4937
  %4939 = call { double, double } @Cd(ptr noundef %4938)
  %4940 = extractvalue { double, double } %4939, 0
  %4941 = extractvalue { double, double } %4939, 1
  store double %4941, ptr %75, align 8, !tbaa !11
  %4942 = load double, ptr %75, align 8, !tbaa !11
  %4943 = fcmp oge double %4942, 0.000000e+00
  br i1 %4943, label %4944, label %4946

4944:                                             ; preds = %4927
  %4945 = load double, ptr %75, align 8, !tbaa !11
  br label %4949

4946:                                             ; preds = %4927
  %4947 = load double, ptr %75, align 8, !tbaa !11
  %4948 = fneg double %4947
  br label %4949

4949:                                             ; preds = %4946, %4944
  %4950 = phi double [ %4945, %4944 ], [ %4948, %4946 ]
  %4951 = fadd double %4928, %4950
  %4952 = fadd double %4913, %4951
  store double %4952, ptr %127, align 8, !tbaa !11
  %4953 = load double, ptr %127, align 8, !tbaa !11
  %4954 = fcmp oeq double %4953, 0.000000e+00
  br i1 %4954, label %4955, label %5274

4955:                                             ; preds = %4949
  %4956 = load i32, ptr %100, align 4, !tbaa !9
  %4957 = load ptr, ptr %29, align 8, !tbaa !5
  %4958 = load i32, ptr %4957, align 4, !tbaa !9
  %4959 = add nsw i32 %4958, 1
  %4960 = icmp sge i32 %4956, %4959
  br i1 %4960, label %4961, label %5007

4961:                                             ; preds = %4955
  %4962 = load i32, ptr %100, align 4, !tbaa !9
  %4963 = load i32, ptr %100, align 4, !tbaa !9
  %4964 = sub nsw i32 %4963, 1
  %4965 = load i32, ptr %49, align 4, !tbaa !9
  %4966 = mul nsw i32 %4964, %4965
  %4967 = add nsw i32 %4962, %4966
  store i32 %4967, ptr %64, align 4, !tbaa !9
  %4968 = load ptr, ptr %33, align 8, !tbaa !5
  %4969 = load i32, ptr %64, align 4, !tbaa !9
  %4970 = sext i32 %4969 to i64
  %4971 = getelementptr inbounds %struct.doublecomplex, ptr %4968, i64 %4970
  %4972 = getelementptr inbounds %struct.doublecomplex, ptr %4971, i32 0, i32 0
  %4973 = load double, ptr %4972, align 8, !tbaa !13
  store double %4973, ptr %72, align 8, !tbaa !11
  %4974 = load double, ptr %72, align 8, !tbaa !11
  %4975 = fcmp oge double %4974, 0.000000e+00
  br i1 %4975, label %4976, label %4978

4976:                                             ; preds = %4961
  %4977 = load double, ptr %72, align 8, !tbaa !11
  br label %4981

4978:                                             ; preds = %4961
  %4979 = load double, ptr %72, align 8, !tbaa !11
  %4980 = fneg double %4979
  br label %4981

4981:                                             ; preds = %4978, %4976
  %4982 = phi double [ %4977, %4976 ], [ %4980, %4978 ]
  %4983 = load ptr, ptr %33, align 8, !tbaa !5
  %4984 = load i32, ptr %100, align 4, !tbaa !9
  %4985 = load i32, ptr %100, align 4, !tbaa !9
  %4986 = sub nsw i32 %4985, 1
  %4987 = load i32, ptr %49, align 4, !tbaa !9
  %4988 = mul nsw i32 %4986, %4987
  %4989 = add nsw i32 %4984, %4988
  %4990 = sext i32 %4989 to i64
  %4991 = getelementptr inbounds %struct.doublecomplex, ptr %4983, i64 %4990
  %4992 = call { double, double } @Cd(ptr noundef %4991)
  %4993 = extractvalue { double, double } %4992, 0
  %4994 = extractvalue { double, double } %4992, 1
  store double %4994, ptr %73, align 8, !tbaa !11
  %4995 = load double, ptr %73, align 8, !tbaa !11
  %4996 = fcmp oge double %4995, 0.000000e+00
  br i1 %4996, label %4997, label %4999

4997:                                             ; preds = %4981
  %4998 = load double, ptr %73, align 8, !tbaa !11
  br label %5002

4999:                                             ; preds = %4981
  %5000 = load double, ptr %73, align 8, !tbaa !11
  %5001 = fneg double %5000
  br label %5002

5002:                                             ; preds = %4999, %4997
  %5003 = phi double [ %4998, %4997 ], [ %5001, %4999 ]
  %5004 = fadd double %4982, %5003
  %5005 = load double, ptr %127, align 8, !tbaa !11
  %5006 = fadd double %5005, %5004
  store double %5006, ptr %127, align 8, !tbaa !11
  br label %5007

5007:                                             ; preds = %5002, %4955
  %5008 = load i32, ptr %100, align 4, !tbaa !9
  %5009 = load ptr, ptr %29, align 8, !tbaa !5
  %5010 = load i32, ptr %5009, align 4, !tbaa !9
  %5011 = add nsw i32 %5010, 2
  %5012 = icmp sge i32 %5008, %5011
  br i1 %5012, label %5013, label %5059

5013:                                             ; preds = %5007
  %5014 = load i32, ptr %100, align 4, !tbaa !9
  %5015 = load i32, ptr %100, align 4, !tbaa !9
  %5016 = sub nsw i32 %5015, 2
  %5017 = load i32, ptr %49, align 4, !tbaa !9
  %5018 = mul nsw i32 %5016, %5017
  %5019 = add nsw i32 %5014, %5018
  store i32 %5019, ptr %64, align 4, !tbaa !9
  %5020 = load ptr, ptr %33, align 8, !tbaa !5
  %5021 = load i32, ptr %64, align 4, !tbaa !9
  %5022 = sext i32 %5021 to i64
  %5023 = getelementptr inbounds %struct.doublecomplex, ptr %5020, i64 %5022
  %5024 = getelementptr inbounds %struct.doublecomplex, ptr %5023, i32 0, i32 0
  %5025 = load double, ptr %5024, align 8, !tbaa !13
  store double %5025, ptr %72, align 8, !tbaa !11
  %5026 = load double, ptr %72, align 8, !tbaa !11
  %5027 = fcmp oge double %5026, 0.000000e+00
  br i1 %5027, label %5028, label %5030

5028:                                             ; preds = %5013
  %5029 = load double, ptr %72, align 8, !tbaa !11
  br label %5033

5030:                                             ; preds = %5013
  %5031 = load double, ptr %72, align 8, !tbaa !11
  %5032 = fneg double %5031
  br label %5033

5033:                                             ; preds = %5030, %5028
  %5034 = phi double [ %5029, %5028 ], [ %5032, %5030 ]
  %5035 = load ptr, ptr %33, align 8, !tbaa !5
  %5036 = load i32, ptr %100, align 4, !tbaa !9
  %5037 = load i32, ptr %100, align 4, !tbaa !9
  %5038 = sub nsw i32 %5037, 2
  %5039 = load i32, ptr %49, align 4, !tbaa !9
  %5040 = mul nsw i32 %5038, %5039
  %5041 = add nsw i32 %5036, %5040
  %5042 = sext i32 %5041 to i64
  %5043 = getelementptr inbounds %struct.doublecomplex, ptr %5035, i64 %5042
  %5044 = call { double, double } @Cd(ptr noundef %5043)
  %5045 = extractvalue { double, double } %5044, 0
  %5046 = extractvalue { double, double } %5044, 1
  store double %5046, ptr %73, align 8, !tbaa !11
  %5047 = load double, ptr %73, align 8, !tbaa !11
  %5048 = fcmp oge double %5047, 0.000000e+00
  br i1 %5048, label %5049, label %5051

5049:                                             ; preds = %5033
  %5050 = load double, ptr %73, align 8, !tbaa !11
  br label %5054

5051:                                             ; preds = %5033
  %5052 = load double, ptr %73, align 8, !tbaa !11
  %5053 = fneg double %5052
  br label %5054

5054:                                             ; preds = %5051, %5049
  %5055 = phi double [ %5050, %5049 ], [ %5053, %5051 ]
  %5056 = fadd double %5034, %5055
  %5057 = load double, ptr %127, align 8, !tbaa !11
  %5058 = fadd double %5057, %5056
  store double %5058, ptr %127, align 8, !tbaa !11
  br label %5059

5059:                                             ; preds = %5054, %5007
  %5060 = load i32, ptr %100, align 4, !tbaa !9
  %5061 = load ptr, ptr %29, align 8, !tbaa !5
  %5062 = load i32, ptr %5061, align 4, !tbaa !9
  %5063 = add nsw i32 %5062, 3
  %5064 = icmp sge i32 %5060, %5063
  br i1 %5064, label %5065, label %5111

5065:                                             ; preds = %5059
  %5066 = load i32, ptr %100, align 4, !tbaa !9
  %5067 = load i32, ptr %100, align 4, !tbaa !9
  %5068 = sub nsw i32 %5067, 3
  %5069 = load i32, ptr %49, align 4, !tbaa !9
  %5070 = mul nsw i32 %5068, %5069
  %5071 = add nsw i32 %5066, %5070
  store i32 %5071, ptr %64, align 4, !tbaa !9
  %5072 = load ptr, ptr %33, align 8, !tbaa !5
  %5073 = load i32, ptr %64, align 4, !tbaa !9
  %5074 = sext i32 %5073 to i64
  %5075 = getelementptr inbounds %struct.doublecomplex, ptr %5072, i64 %5074
  %5076 = getelementptr inbounds %struct.doublecomplex, ptr %5075, i32 0, i32 0
  %5077 = load double, ptr %5076, align 8, !tbaa !13
  store double %5077, ptr %72, align 8, !tbaa !11
  %5078 = load double, ptr %72, align 8, !tbaa !11
  %5079 = fcmp oge double %5078, 0.000000e+00
  br i1 %5079, label %5080, label %5082

5080:                                             ; preds = %5065
  %5081 = load double, ptr %72, align 8, !tbaa !11
  br label %5085

5082:                                             ; preds = %5065
  %5083 = load double, ptr %72, align 8, !tbaa !11
  %5084 = fneg double %5083
  br label %5085

5085:                                             ; preds = %5082, %5080
  %5086 = phi double [ %5081, %5080 ], [ %5084, %5082 ]
  %5087 = load ptr, ptr %33, align 8, !tbaa !5
  %5088 = load i32, ptr %100, align 4, !tbaa !9
  %5089 = load i32, ptr %100, align 4, !tbaa !9
  %5090 = sub nsw i32 %5089, 3
  %5091 = load i32, ptr %49, align 4, !tbaa !9
  %5092 = mul nsw i32 %5090, %5091
  %5093 = add nsw i32 %5088, %5092
  %5094 = sext i32 %5093 to i64
  %5095 = getelementptr inbounds %struct.doublecomplex, ptr %5087, i64 %5094
  %5096 = call { double, double } @Cd(ptr noundef %5095)
  %5097 = extractvalue { double, double } %5096, 0
  %5098 = extractvalue { double, double } %5096, 1
  store double %5098, ptr %73, align 8, !tbaa !11
  %5099 = load double, ptr %73, align 8, !tbaa !11
  %5100 = fcmp oge double %5099, 0.000000e+00
  br i1 %5100, label %5101, label %5103

5101:                                             ; preds = %5085
  %5102 = load double, ptr %73, align 8, !tbaa !11
  br label %5106

5103:                                             ; preds = %5085
  %5104 = load double, ptr %73, align 8, !tbaa !11
  %5105 = fneg double %5104
  br label %5106

5106:                                             ; preds = %5103, %5101
  %5107 = phi double [ %5102, %5101 ], [ %5105, %5103 ]
  %5108 = fadd double %5086, %5107
  %5109 = load double, ptr %127, align 8, !tbaa !11
  %5110 = fadd double %5109, %5108
  store double %5110, ptr %127, align 8, !tbaa !11
  br label %5111

5111:                                             ; preds = %5106, %5059
  %5112 = load i32, ptr %100, align 4, !tbaa !9
  %5113 = load ptr, ptr %30, align 8, !tbaa !5
  %5114 = load i32, ptr %5113, align 4, !tbaa !9
  %5115 = sub nsw i32 %5114, 2
  %5116 = icmp sle i32 %5112, %5115
  br i1 %5116, label %5117, label %5165

5117:                                             ; preds = %5111
  %5118 = load i32, ptr %100, align 4, !tbaa !9
  %5119 = add nsw i32 %5118, 2
  %5120 = load i32, ptr %100, align 4, !tbaa !9
  %5121 = add nsw i32 %5120, 1
  %5122 = load i32, ptr %49, align 4, !tbaa !9
  %5123 = mul nsw i32 %5121, %5122
  %5124 = add nsw i32 %5119, %5123
  store i32 %5124, ptr %64, align 4, !tbaa !9
  %5125 = load ptr, ptr %33, align 8, !tbaa !5
  %5126 = load i32, ptr %64, align 4, !tbaa !9
  %5127 = sext i32 %5126 to i64
  %5128 = getelementptr inbounds %struct.doublecomplex, ptr %5125, i64 %5127
  %5129 = getelementptr inbounds %struct.doublecomplex, ptr %5128, i32 0, i32 0
  %5130 = load double, ptr %5129, align 8, !tbaa !13
  store double %5130, ptr %72, align 8, !tbaa !11
  %5131 = load double, ptr %72, align 8, !tbaa !11
  %5132 = fcmp oge double %5131, 0.000000e+00
  br i1 %5132, label %5133, label %5135

5133:                                             ; preds = %5117
  %5134 = load double, ptr %72, align 8, !tbaa !11
  br label %5138

5135:                                             ; preds = %5117
  %5136 = load double, ptr %72, align 8, !tbaa !11
  %5137 = fneg double %5136
  br label %5138

5138:                                             ; preds = %5135, %5133
  %5139 = phi double [ %5134, %5133 ], [ %5137, %5135 ]
  %5140 = load ptr, ptr %33, align 8, !tbaa !5
  %5141 = load i32, ptr %100, align 4, !tbaa !9
  %5142 = add nsw i32 %5141, 2
  %5143 = load i32, ptr %100, align 4, !tbaa !9
  %5144 = add nsw i32 %5143, 1
  %5145 = load i32, ptr %49, align 4, !tbaa !9
  %5146 = mul nsw i32 %5144, %5145
  %5147 = add nsw i32 %5142, %5146
  %5148 = sext i32 %5147 to i64
  %5149 = getelementptr inbounds %struct.doublecomplex, ptr %5140, i64 %5148
  %5150 = call { double, double } @Cd(ptr noundef %5149)
  %5151 = extractvalue { double, double } %5150, 0
  %5152 = extractvalue { double, double } %5150, 1
  store double %5152, ptr %73, align 8, !tbaa !11
  %5153 = load double, ptr %73, align 8, !tbaa !11
  %5154 = fcmp oge double %5153, 0.000000e+00
  br i1 %5154, label %5155, label %5157

5155:                                             ; preds = %5138
  %5156 = load double, ptr %73, align 8, !tbaa !11
  br label %5160

5157:                                             ; preds = %5138
  %5158 = load double, ptr %73, align 8, !tbaa !11
  %5159 = fneg double %5158
  br label %5160

5160:                                             ; preds = %5157, %5155
  %5161 = phi double [ %5156, %5155 ], [ %5159, %5157 ]
  %5162 = fadd double %5139, %5161
  %5163 = load double, ptr %127, align 8, !tbaa !11
  %5164 = fadd double %5163, %5162
  store double %5164, ptr %127, align 8, !tbaa !11
  br label %5165

5165:                                             ; preds = %5160, %5111
  %5166 = load i32, ptr %100, align 4, !tbaa !9
  %5167 = load ptr, ptr %30, align 8, !tbaa !5
  %5168 = load i32, ptr %5167, align 4, !tbaa !9
  %5169 = sub nsw i32 %5168, 3
  %5170 = icmp sle i32 %5166, %5169
  br i1 %5170, label %5171, label %5219

5171:                                             ; preds = %5165
  %5172 = load i32, ptr %100, align 4, !tbaa !9
  %5173 = add nsw i32 %5172, 3
  %5174 = load i32, ptr %100, align 4, !tbaa !9
  %5175 = add nsw i32 %5174, 1
  %5176 = load i32, ptr %49, align 4, !tbaa !9
  %5177 = mul nsw i32 %5175, %5176
  %5178 = add nsw i32 %5173, %5177
  store i32 %5178, ptr %64, align 4, !tbaa !9
  %5179 = load ptr, ptr %33, align 8, !tbaa !5
  %5180 = load i32, ptr %64, align 4, !tbaa !9
  %5181 = sext i32 %5180 to i64
  %5182 = getelementptr inbounds %struct.doublecomplex, ptr %5179, i64 %5181
  %5183 = getelementptr inbounds %struct.doublecomplex, ptr %5182, i32 0, i32 0
  %5184 = load double, ptr %5183, align 8, !tbaa !13
  store double %5184, ptr %72, align 8, !tbaa !11
  %5185 = load double, ptr %72, align 8, !tbaa !11
  %5186 = fcmp oge double %5185, 0.000000e+00
  br i1 %5186, label %5187, label %5189

5187:                                             ; preds = %5171
  %5188 = load double, ptr %72, align 8, !tbaa !11
  br label %5192

5189:                                             ; preds = %5171
  %5190 = load double, ptr %72, align 8, !tbaa !11
  %5191 = fneg double %5190
  br label %5192

5192:                                             ; preds = %5189, %5187
  %5193 = phi double [ %5188, %5187 ], [ %5191, %5189 ]
  %5194 = load ptr, ptr %33, align 8, !tbaa !5
  %5195 = load i32, ptr %100, align 4, !tbaa !9
  %5196 = add nsw i32 %5195, 3
  %5197 = load i32, ptr %100, align 4, !tbaa !9
  %5198 = add nsw i32 %5197, 1
  %5199 = load i32, ptr %49, align 4, !tbaa !9
  %5200 = mul nsw i32 %5198, %5199
  %5201 = add nsw i32 %5196, %5200
  %5202 = sext i32 %5201 to i64
  %5203 = getelementptr inbounds %struct.doublecomplex, ptr %5194, i64 %5202
  %5204 = call { double, double } @Cd(ptr noundef %5203)
  %5205 = extractvalue { double, double } %5204, 0
  %5206 = extractvalue { double, double } %5204, 1
  store double %5206, ptr %73, align 8, !tbaa !11
  %5207 = load double, ptr %73, align 8, !tbaa !11
  %5208 = fcmp oge double %5207, 0.000000e+00
  br i1 %5208, label %5209, label %5211

5209:                                             ; preds = %5192
  %5210 = load double, ptr %73, align 8, !tbaa !11
  br label %5214

5211:                                             ; preds = %5192
  %5212 = load double, ptr %73, align 8, !tbaa !11
  %5213 = fneg double %5212
  br label %5214

5214:                                             ; preds = %5211, %5209
  %5215 = phi double [ %5210, %5209 ], [ %5213, %5211 ]
  %5216 = fadd double %5193, %5215
  %5217 = load double, ptr %127, align 8, !tbaa !11
  %5218 = fadd double %5217, %5216
  store double %5218, ptr %127, align 8, !tbaa !11
  br label %5219

5219:                                             ; preds = %5214, %5165
  %5220 = load i32, ptr %100, align 4, !tbaa !9
  %5221 = load ptr, ptr %30, align 8, !tbaa !5
  %5222 = load i32, ptr %5221, align 4, !tbaa !9
  %5223 = sub nsw i32 %5222, 4
  %5224 = icmp sle i32 %5220, %5223
  br i1 %5224, label %5225, label %5273

5225:                                             ; preds = %5219
  %5226 = load i32, ptr %100, align 4, !tbaa !9
  %5227 = add nsw i32 %5226, 4
  %5228 = load i32, ptr %100, align 4, !tbaa !9
  %5229 = add nsw i32 %5228, 1
  %5230 = load i32, ptr %49, align 4, !tbaa !9
  %5231 = mul nsw i32 %5229, %5230
  %5232 = add nsw i32 %5227, %5231
  store i32 %5232, ptr %64, align 4, !tbaa !9
  %5233 = load ptr, ptr %33, align 8, !tbaa !5
  %5234 = load i32, ptr %64, align 4, !tbaa !9
  %5235 = sext i32 %5234 to i64
  %5236 = getelementptr inbounds %struct.doublecomplex, ptr %5233, i64 %5235
  %5237 = getelementptr inbounds %struct.doublecomplex, ptr %5236, i32 0, i32 0
  %5238 = load double, ptr %5237, align 8, !tbaa !13
  store double %5238, ptr %72, align 8, !tbaa !11
  %5239 = load double, ptr %72, align 8, !tbaa !11
  %5240 = fcmp oge double %5239, 0.000000e+00
  br i1 %5240, label %5241, label %5243

5241:                                             ; preds = %5225
  %5242 = load double, ptr %72, align 8, !tbaa !11
  br label %5246

5243:                                             ; preds = %5225
  %5244 = load double, ptr %72, align 8, !tbaa !11
  %5245 = fneg double %5244
  br label %5246

5246:                                             ; preds = %5243, %5241
  %5247 = phi double [ %5242, %5241 ], [ %5245, %5243 ]
  %5248 = load ptr, ptr %33, align 8, !tbaa !5
  %5249 = load i32, ptr %100, align 4, !tbaa !9
  %5250 = add nsw i32 %5249, 4
  %5251 = load i32, ptr %100, align 4, !tbaa !9
  %5252 = add nsw i32 %5251, 1
  %5253 = load i32, ptr %49, align 4, !tbaa !9
  %5254 = mul nsw i32 %5252, %5253
  %5255 = add nsw i32 %5250, %5254
  %5256 = sext i32 %5255 to i64
  %5257 = getelementptr inbounds %struct.doublecomplex, ptr %5248, i64 %5256
  %5258 = call { double, double } @Cd(ptr noundef %5257)
  %5259 = extractvalue { double, double } %5258, 0
  %5260 = extractvalue { double, double } %5258, 1
  store double %5260, ptr %73, align 8, !tbaa !11
  %5261 = load double, ptr %73, align 8, !tbaa !11
  %5262 = fcmp oge double %5261, 0.000000e+00
  br i1 %5262, label %5263, label %5265

5263:                                             ; preds = %5246
  %5264 = load double, ptr %73, align 8, !tbaa !11
  br label %5268

5265:                                             ; preds = %5246
  %5266 = load double, ptr %73, align 8, !tbaa !11
  %5267 = fneg double %5266
  br label %5268

5268:                                             ; preds = %5265, %5263
  %5269 = phi double [ %5264, %5263 ], [ %5267, %5265 ]
  %5270 = fadd double %5247, %5269
  %5271 = load double, ptr %127, align 8, !tbaa !11
  %5272 = fadd double %5271, %5270
  store double %5272, ptr %127, align 8, !tbaa !11
  br label %5273

5273:                                             ; preds = %5268, %5219
  br label %5274

5274:                                             ; preds = %5273, %4949
  %5275 = load i32, ptr %100, align 4, !tbaa !9
  %5276 = add nsw i32 %5275, 1
  %5277 = load i32, ptr %100, align 4, !tbaa !9
  %5278 = load i32, ptr %49, align 4, !tbaa !9
  %5279 = mul nsw i32 %5277, %5278
  %5280 = add nsw i32 %5276, %5279
  store i32 %5280, ptr %64, align 4, !tbaa !9
  %5281 = load double, ptr %122, align 8, !tbaa !11
  store double %5281, ptr %74, align 8, !tbaa !11
  %5282 = load double, ptr %126, align 8, !tbaa !11
  %5283 = load double, ptr %127, align 8, !tbaa !11
  %5284 = fmul double %5282, %5283
  store double %5284, ptr %75, align 8, !tbaa !11
  %5285 = load ptr, ptr %33, align 8, !tbaa !5
  %5286 = load i32, ptr %64, align 4, !tbaa !9
  %5287 = sext i32 %5286 to i64
  %5288 = getelementptr inbounds %struct.doublecomplex, ptr %5285, i64 %5287
  %5289 = getelementptr inbounds %struct.doublecomplex, ptr %5288, i32 0, i32 0
  %5290 = load double, ptr %5289, align 8, !tbaa !13
  store double %5290, ptr %72, align 8, !tbaa !11
  %5291 = load double, ptr %72, align 8, !tbaa !11
  %5292 = fcmp oge double %5291, 0.000000e+00
  br i1 %5292, label %5293, label %5295

5293:                                             ; preds = %5274
  %5294 = load double, ptr %72, align 8, !tbaa !11
  br label %5298

5295:                                             ; preds = %5274
  %5296 = load double, ptr %72, align 8, !tbaa !11
  %5297 = fneg double %5296
  br label %5298

5298:                                             ; preds = %5295, %5293
  %5299 = phi double [ %5294, %5293 ], [ %5297, %5295 ]
  %5300 = load ptr, ptr %33, align 8, !tbaa !5
  %5301 = load i32, ptr %100, align 4, !tbaa !9
  %5302 = add nsw i32 %5301, 1
  %5303 = load i32, ptr %100, align 4, !tbaa !9
  %5304 = load i32, ptr %49, align 4, !tbaa !9
  %5305 = mul nsw i32 %5303, %5304
  %5306 = add nsw i32 %5302, %5305
  %5307 = sext i32 %5306 to i64
  %5308 = getelementptr inbounds %struct.doublecomplex, ptr %5300, i64 %5307
  %5309 = call { double, double } @Cd(ptr noundef %5308)
  %5310 = extractvalue { double, double } %5309, 0
  %5311 = extractvalue { double, double } %5309, 1
  store double %5311, ptr %73, align 8, !tbaa !11
  %5312 = load double, ptr %73, align 8, !tbaa !11
  %5313 = fcmp oge double %5312, 0.000000e+00
  br i1 %5313, label %5314, label %5316

5314:                                             ; preds = %5298
  %5315 = load double, ptr %73, align 8, !tbaa !11
  br label %5319

5316:                                             ; preds = %5298
  %5317 = load double, ptr %73, align 8, !tbaa !11
  %5318 = fneg double %5317
  br label %5319

5319:                                             ; preds = %5316, %5314
  %5320 = phi double [ %5315, %5314 ], [ %5318, %5316 ]
  %5321 = fadd double %5299, %5320
  %5322 = load double, ptr %74, align 8, !tbaa !11
  %5323 = load double, ptr %75, align 8, !tbaa !11
  %5324 = fcmp oge double %5322, %5323
  br i1 %5324, label %5325, label %5327

5325:                                             ; preds = %5319
  %5326 = load double, ptr %74, align 8, !tbaa !11
  br label %5329

5327:                                             ; preds = %5319
  %5328 = load double, ptr %75, align 8, !tbaa !11
  br label %5329

5329:                                             ; preds = %5327, %5325
  %5330 = phi double [ %5326, %5325 ], [ %5328, %5327 ]
  %5331 = fcmp ole double %5321, %5330
  br i1 %5331, label %5332, label %5819

5332:                                             ; preds = %5329
  %5333 = load i32, ptr %100, align 4, !tbaa !9
  %5334 = add nsw i32 %5333, 1
  %5335 = load i32, ptr %100, align 4, !tbaa !9
  %5336 = load i32, ptr %49, align 4, !tbaa !9
  %5337 = mul nsw i32 %5335, %5336
  %5338 = add nsw i32 %5334, %5337
  store i32 %5338, ptr %64, align 4, !tbaa !9
  %5339 = load i32, ptr %100, align 4, !tbaa !9
  %5340 = load i32, ptr %100, align 4, !tbaa !9
  %5341 = add nsw i32 %5340, 1
  %5342 = load i32, ptr %49, align 4, !tbaa !9
  %5343 = mul nsw i32 %5341, %5342
  %5344 = add nsw i32 %5339, %5343
  store i32 %5344, ptr %65, align 4, !tbaa !9
  %5345 = load ptr, ptr %33, align 8, !tbaa !5
  %5346 = load i32, ptr %64, align 4, !tbaa !9
  %5347 = sext i32 %5346 to i64
  %5348 = getelementptr inbounds %struct.doublecomplex, ptr %5345, i64 %5347
  %5349 = getelementptr inbounds %struct.doublecomplex, ptr %5348, i32 0, i32 0
  %5350 = load double, ptr %5349, align 8, !tbaa !13
  store double %5350, ptr %72, align 8, !tbaa !11
  %5351 = load double, ptr %72, align 8, !tbaa !11
  %5352 = fcmp oge double %5351, 0.000000e+00
  br i1 %5352, label %5353, label %5355

5353:                                             ; preds = %5332
  %5354 = load double, ptr %72, align 8, !tbaa !11
  br label %5358

5355:                                             ; preds = %5332
  %5356 = load double, ptr %72, align 8, !tbaa !11
  %5357 = fneg double %5356
  br label %5358

5358:                                             ; preds = %5355, %5353
  %5359 = phi double [ %5354, %5353 ], [ %5357, %5355 ]
  %5360 = load ptr, ptr %33, align 8, !tbaa !5
  %5361 = load i32, ptr %100, align 4, !tbaa !9
  %5362 = add nsw i32 %5361, 1
  %5363 = load i32, ptr %100, align 4, !tbaa !9
  %5364 = load i32, ptr %49, align 4, !tbaa !9
  %5365 = mul nsw i32 %5363, %5364
  %5366 = add nsw i32 %5362, %5365
  %5367 = sext i32 %5366 to i64
  %5368 = getelementptr inbounds %struct.doublecomplex, ptr %5360, i64 %5367
  %5369 = call { double, double } @Cd(ptr noundef %5368)
  %5370 = extractvalue { double, double } %5369, 0
  %5371 = extractvalue { double, double } %5369, 1
  store double %5371, ptr %73, align 8, !tbaa !11
  %5372 = load double, ptr %73, align 8, !tbaa !11
  %5373 = fcmp oge double %5372, 0.000000e+00
  br i1 %5373, label %5374, label %5376

5374:                                             ; preds = %5358
  %5375 = load double, ptr %73, align 8, !tbaa !11
  br label %5379

5376:                                             ; preds = %5358
  %5377 = load double, ptr %73, align 8, !tbaa !11
  %5378 = fneg double %5377
  br label %5379

5379:                                             ; preds = %5376, %5374
  %5380 = phi double [ %5375, %5374 ], [ %5378, %5376 ]
  %5381 = fadd double %5359, %5380
  store double %5381, ptr %76, align 8, !tbaa !11
  %5382 = load ptr, ptr %33, align 8, !tbaa !5
  %5383 = load i32, ptr %65, align 4, !tbaa !9
  %5384 = sext i32 %5383 to i64
  %5385 = getelementptr inbounds %struct.doublecomplex, ptr %5382, i64 %5384
  %5386 = getelementptr inbounds %struct.doublecomplex, ptr %5385, i32 0, i32 0
  %5387 = load double, ptr %5386, align 8, !tbaa !13
  store double %5387, ptr %74, align 8, !tbaa !11
  %5388 = load double, ptr %74, align 8, !tbaa !11
  %5389 = fcmp oge double %5388, 0.000000e+00
  br i1 %5389, label %5390, label %5392

5390:                                             ; preds = %5379
  %5391 = load double, ptr %74, align 8, !tbaa !11
  br label %5395

5392:                                             ; preds = %5379
  %5393 = load double, ptr %74, align 8, !tbaa !11
  %5394 = fneg double %5393
  br label %5395

5395:                                             ; preds = %5392, %5390
  %5396 = phi double [ %5391, %5390 ], [ %5394, %5392 ]
  %5397 = load ptr, ptr %33, align 8, !tbaa !5
  %5398 = load i32, ptr %100, align 4, !tbaa !9
  %5399 = load i32, ptr %100, align 4, !tbaa !9
  %5400 = add nsw i32 %5399, 1
  %5401 = load i32, ptr %49, align 4, !tbaa !9
  %5402 = mul nsw i32 %5400, %5401
  %5403 = add nsw i32 %5398, %5402
  %5404 = sext i32 %5403 to i64
  %5405 = getelementptr inbounds %struct.doublecomplex, ptr %5397, i64 %5404
  %5406 = call { double, double } @Cd(ptr noundef %5405)
  %5407 = extractvalue { double, double } %5406, 0
  %5408 = extractvalue { double, double } %5406, 1
  store double %5408, ptr %75, align 8, !tbaa !11
  %5409 = load double, ptr %75, align 8, !tbaa !11
  %5410 = fcmp oge double %5409, 0.000000e+00
  br i1 %5410, label %5411, label %5413

5411:                                             ; preds = %5395
  %5412 = load double, ptr %75, align 8, !tbaa !11
  br label %5416

5413:                                             ; preds = %5395
  %5414 = load double, ptr %75, align 8, !tbaa !11
  %5415 = fneg double %5414
  br label %5416

5416:                                             ; preds = %5413, %5411
  %5417 = phi double [ %5412, %5411 ], [ %5415, %5413 ]
  %5418 = fadd double %5396, %5417
  store double %5418, ptr %77, align 8, !tbaa !11
  %5419 = load double, ptr %76, align 8, !tbaa !11
  %5420 = load double, ptr %77, align 8, !tbaa !11
  %5421 = fcmp oge double %5419, %5420
  br i1 %5421, label %5422, label %5424

5422:                                             ; preds = %5416
  %5423 = load double, ptr %76, align 8, !tbaa !11
  br label %5426

5424:                                             ; preds = %5416
  %5425 = load double, ptr %77, align 8, !tbaa !11
  br label %5426

5426:                                             ; preds = %5424, %5422
  %5427 = phi double [ %5423, %5422 ], [ %5425, %5424 ]
  store double %5427, ptr %112, align 8, !tbaa !11
  %5428 = load i32, ptr %100, align 4, !tbaa !9
  %5429 = add nsw i32 %5428, 1
  %5430 = load i32, ptr %100, align 4, !tbaa !9
  %5431 = load i32, ptr %49, align 4, !tbaa !9
  %5432 = mul nsw i32 %5430, %5431
  %5433 = add nsw i32 %5429, %5432
  store i32 %5433, ptr %64, align 4, !tbaa !9
  %5434 = load i32, ptr %100, align 4, !tbaa !9
  %5435 = load i32, ptr %100, align 4, !tbaa !9
  %5436 = add nsw i32 %5435, 1
  %5437 = load i32, ptr %49, align 4, !tbaa !9
  %5438 = mul nsw i32 %5436, %5437
  %5439 = add nsw i32 %5434, %5438
  store i32 %5439, ptr %65, align 4, !tbaa !9
  %5440 = load ptr, ptr %33, align 8, !tbaa !5
  %5441 = load i32, ptr %64, align 4, !tbaa !9
  %5442 = sext i32 %5441 to i64
  %5443 = getelementptr inbounds %struct.doublecomplex, ptr %5440, i64 %5442
  %5444 = getelementptr inbounds %struct.doublecomplex, ptr %5443, i32 0, i32 0
  %5445 = load double, ptr %5444, align 8, !tbaa !13
  store double %5445, ptr %72, align 8, !tbaa !11
  %5446 = load double, ptr %72, align 8, !tbaa !11
  %5447 = fcmp oge double %5446, 0.000000e+00
  br i1 %5447, label %5448, label %5450

5448:                                             ; preds = %5426
  %5449 = load double, ptr %72, align 8, !tbaa !11
  br label %5453

5450:                                             ; preds = %5426
  %5451 = load double, ptr %72, align 8, !tbaa !11
  %5452 = fneg double %5451
  br label %5453

5453:                                             ; preds = %5450, %5448
  %5454 = phi double [ %5449, %5448 ], [ %5452, %5450 ]
  %5455 = load ptr, ptr %33, align 8, !tbaa !5
  %5456 = load i32, ptr %100, align 4, !tbaa !9
  %5457 = add nsw i32 %5456, 1
  %5458 = load i32, ptr %100, align 4, !tbaa !9
  %5459 = load i32, ptr %49, align 4, !tbaa !9
  %5460 = mul nsw i32 %5458, %5459
  %5461 = add nsw i32 %5457, %5460
  %5462 = sext i32 %5461 to i64
  %5463 = getelementptr inbounds %struct.doublecomplex, ptr %5455, i64 %5462
  %5464 = call { double, double } @Cd(ptr noundef %5463)
  %5465 = extractvalue { double, double } %5464, 0
  %5466 = extractvalue { double, double } %5464, 1
  store double %5466, ptr %73, align 8, !tbaa !11
  %5467 = load double, ptr %73, align 8, !tbaa !11
  %5468 = fcmp oge double %5467, 0.000000e+00
  br i1 %5468, label %5469, label %5471

5469:                                             ; preds = %5453
  %5470 = load double, ptr %73, align 8, !tbaa !11
  br label %5474

5471:                                             ; preds = %5453
  %5472 = load double, ptr %73, align 8, !tbaa !11
  %5473 = fneg double %5472
  br label %5474

5474:                                             ; preds = %5471, %5469
  %5475 = phi double [ %5470, %5469 ], [ %5473, %5471 ]
  %5476 = fadd double %5454, %5475
  store double %5476, ptr %76, align 8, !tbaa !11
  %5477 = load ptr, ptr %33, align 8, !tbaa !5
  %5478 = load i32, ptr %65, align 4, !tbaa !9
  %5479 = sext i32 %5478 to i64
  %5480 = getelementptr inbounds %struct.doublecomplex, ptr %5477, i64 %5479
  %5481 = getelementptr inbounds %struct.doublecomplex, ptr %5480, i32 0, i32 0
  %5482 = load double, ptr %5481, align 8, !tbaa !13
  store double %5482, ptr %74, align 8, !tbaa !11
  %5483 = load double, ptr %74, align 8, !tbaa !11
  %5484 = fcmp oge double %5483, 0.000000e+00
  br i1 %5484, label %5485, label %5487

5485:                                             ; preds = %5474
  %5486 = load double, ptr %74, align 8, !tbaa !11
  br label %5490

5487:                                             ; preds = %5474
  %5488 = load double, ptr %74, align 8, !tbaa !11
  %5489 = fneg double %5488
  br label %5490

5490:                                             ; preds = %5487, %5485
  %5491 = phi double [ %5486, %5485 ], [ %5489, %5487 ]
  %5492 = load ptr, ptr %33, align 8, !tbaa !5
  %5493 = load i32, ptr %100, align 4, !tbaa !9
  %5494 = load i32, ptr %100, align 4, !tbaa !9
  %5495 = add nsw i32 %5494, 1
  %5496 = load i32, ptr %49, align 4, !tbaa !9
  %5497 = mul nsw i32 %5495, %5496
  %5498 = add nsw i32 %5493, %5497
  %5499 = sext i32 %5498 to i64
  %5500 = getelementptr inbounds %struct.doublecomplex, ptr %5492, i64 %5499
  %5501 = call { double, double } @Cd(ptr noundef %5500)
  %5502 = extractvalue { double, double } %5501, 0
  %5503 = extractvalue { double, double } %5501, 1
  store double %5503, ptr %75, align 8, !tbaa !11
  %5504 = load double, ptr %75, align 8, !tbaa !11
  %5505 = fcmp oge double %5504, 0.000000e+00
  br i1 %5505, label %5506, label %5508

5506:                                             ; preds = %5490
  %5507 = load double, ptr %75, align 8, !tbaa !11
  br label %5511

5508:                                             ; preds = %5490
  %5509 = load double, ptr %75, align 8, !tbaa !11
  %5510 = fneg double %5509
  br label %5511

5511:                                             ; preds = %5508, %5506
  %5512 = phi double [ %5507, %5506 ], [ %5510, %5508 ]
  %5513 = fadd double %5491, %5512
  store double %5513, ptr %77, align 8, !tbaa !11
  %5514 = load double, ptr %76, align 8, !tbaa !11
  %5515 = load double, ptr %77, align 8, !tbaa !11
  %5516 = fcmp ole double %5514, %5515
  br i1 %5516, label %5517, label %5519

5517:                                             ; preds = %5511
  %5518 = load double, ptr %76, align 8, !tbaa !11
  br label %5521

5519:                                             ; preds = %5511
  %5520 = load double, ptr %77, align 8, !tbaa !11
  br label %5521

5521:                                             ; preds = %5519, %5517
  %5522 = phi double [ %5518, %5517 ], [ %5520, %5519 ]
  store double %5522, ptr %113, align 8, !tbaa !11
  %5523 = load i32, ptr %100, align 4, !tbaa !9
  %5524 = load i32, ptr %100, align 4, !tbaa !9
  %5525 = load i32, ptr %49, align 4, !tbaa !9
  %5526 = mul nsw i32 %5524, %5525
  %5527 = add nsw i32 %5523, %5526
  store i32 %5527, ptr %64, align 4, !tbaa !9
  %5528 = load i32, ptr %100, align 4, !tbaa !9
  %5529 = add nsw i32 %5528, 1
  %5530 = load i32, ptr %100, align 4, !tbaa !9
  %5531 = add nsw i32 %5530, 1
  %5532 = load i32, ptr %49, align 4, !tbaa !9
  %5533 = mul nsw i32 %5531, %5532
  %5534 = add nsw i32 %5529, %5533
  store i32 %5534, ptr %65, align 4, !tbaa !9
  %5535 = load ptr, ptr %33, align 8, !tbaa !5
  %5536 = load i32, ptr %64, align 4, !tbaa !9
  %5537 = sext i32 %5536 to i64
  %5538 = getelementptr inbounds %struct.doublecomplex, ptr %5535, i64 %5537
  %5539 = getelementptr inbounds %struct.doublecomplex, ptr %5538, i32 0, i32 0
  %5540 = load double, ptr %5539, align 8, !tbaa !13
  %5541 = load ptr, ptr %33, align 8, !tbaa !5
  %5542 = load i32, ptr %65, align 4, !tbaa !9
  %5543 = sext i32 %5542 to i64
  %5544 = getelementptr inbounds %struct.doublecomplex, ptr %5541, i64 %5543
  %5545 = getelementptr inbounds %struct.doublecomplex, ptr %5544, i32 0, i32 0
  %5546 = load double, ptr %5545, align 8, !tbaa !13
  %5547 = fsub double %5540, %5546
  %5548 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %5547, ptr %5548, align 8, !tbaa !13
  %5549 = load ptr, ptr %33, align 8, !tbaa !5
  %5550 = load i32, ptr %64, align 4, !tbaa !9
  %5551 = sext i32 %5550 to i64
  %5552 = getelementptr inbounds %struct.doublecomplex, ptr %5549, i64 %5551
  %5553 = getelementptr inbounds %struct.doublecomplex, ptr %5552, i32 0, i32 1
  %5554 = load double, ptr %5553, align 8, !tbaa !15
  %5555 = load ptr, ptr %33, align 8, !tbaa !5
  %5556 = load i32, ptr %65, align 4, !tbaa !9
  %5557 = sext i32 %5556 to i64
  %5558 = getelementptr inbounds %struct.doublecomplex, ptr %5555, i64 %5557
  %5559 = getelementptr inbounds %struct.doublecomplex, ptr %5558, i32 0, i32 1
  %5560 = load double, ptr %5559, align 8, !tbaa !15
  %5561 = fsub double %5554, %5560
  %5562 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %5561, ptr %5562, align 8, !tbaa !15
  %5563 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %5564 = load double, ptr %5563, align 8, !tbaa !13
  %5565 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %5564, ptr %5565, align 8, !tbaa !13
  %5566 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %5567 = load double, ptr %5566, align 8, !tbaa !15
  %5568 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %5567, ptr %5568, align 8, !tbaa !15
  %5569 = load i32, ptr %100, align 4, !tbaa !9
  %5570 = add nsw i32 %5569, 1
  %5571 = load i32, ptr %100, align 4, !tbaa !9
  %5572 = add nsw i32 %5571, 1
  %5573 = load i32, ptr %49, align 4, !tbaa !9
  %5574 = mul nsw i32 %5572, %5573
  %5575 = add nsw i32 %5570, %5574
  store i32 %5575, ptr %67, align 4, !tbaa !9
  %5576 = load ptr, ptr %33, align 8, !tbaa !5
  %5577 = load i32, ptr %67, align 4, !tbaa !9
  %5578 = sext i32 %5577 to i64
  %5579 = getelementptr inbounds %struct.doublecomplex, ptr %5576, i64 %5578
  %5580 = getelementptr inbounds %struct.doublecomplex, ptr %5579, i32 0, i32 0
  %5581 = load double, ptr %5580, align 8, !tbaa !13
  store double %5581, ptr %72, align 8, !tbaa !11
  %5582 = load double, ptr %72, align 8, !tbaa !11
  %5583 = fcmp oge double %5582, 0.000000e+00
  br i1 %5583, label %5584, label %5586

5584:                                             ; preds = %5521
  %5585 = load double, ptr %72, align 8, !tbaa !11
  br label %5589

5586:                                             ; preds = %5521
  %5587 = load double, ptr %72, align 8, !tbaa !11
  %5588 = fneg double %5587
  br label %5589

5589:                                             ; preds = %5586, %5584
  %5590 = phi double [ %5585, %5584 ], [ %5588, %5586 ]
  %5591 = load ptr, ptr %33, align 8, !tbaa !5
  %5592 = load i32, ptr %100, align 4, !tbaa !9
  %5593 = add nsw i32 %5592, 1
  %5594 = load i32, ptr %100, align 4, !tbaa !9
  %5595 = add nsw i32 %5594, 1
  %5596 = load i32, ptr %49, align 4, !tbaa !9
  %5597 = mul nsw i32 %5595, %5596
  %5598 = add nsw i32 %5593, %5597
  %5599 = sext i32 %5598 to i64
  %5600 = getelementptr inbounds %struct.doublecomplex, ptr %5591, i64 %5599
  %5601 = call { double, double } @Cd(ptr noundef %5600)
  %5602 = extractvalue { double, double } %5601, 0
  %5603 = extractvalue { double, double } %5601, 1
  store double %5603, ptr %73, align 8, !tbaa !11
  %5604 = load double, ptr %73, align 8, !tbaa !11
  %5605 = fcmp oge double %5604, 0.000000e+00
  br i1 %5605, label %5606, label %5608

5606:                                             ; preds = %5589
  %5607 = load double, ptr %73, align 8, !tbaa !11
  br label %5611

5608:                                             ; preds = %5589
  %5609 = load double, ptr %73, align 8, !tbaa !11
  %5610 = fneg double %5609
  br label %5611

5611:                                             ; preds = %5608, %5606
  %5612 = phi double [ %5607, %5606 ], [ %5610, %5608 ]
  %5613 = fadd double %5590, %5612
  store double %5613, ptr %76, align 8, !tbaa !11
  %5614 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %5615 = load double, ptr %5614, align 8, !tbaa !13
  store double %5615, ptr %74, align 8, !tbaa !11
  %5616 = load double, ptr %74, align 8, !tbaa !11
  %5617 = fcmp oge double %5616, 0.000000e+00
  br i1 %5617, label %5618, label %5620

5618:                                             ; preds = %5611
  %5619 = load double, ptr %74, align 8, !tbaa !11
  br label %5623

5620:                                             ; preds = %5611
  %5621 = load double, ptr %74, align 8, !tbaa !11
  %5622 = fneg double %5621
  br label %5623

5623:                                             ; preds = %5620, %5618
  %5624 = phi double [ %5619, %5618 ], [ %5622, %5620 ]
  %5625 = call { double, double } @Cd(ptr noundef %82)
  %5626 = extractvalue { double, double } %5625, 0
  %5627 = extractvalue { double, double } %5625, 1
  store double %5627, ptr %75, align 8, !tbaa !11
  %5628 = load double, ptr %75, align 8, !tbaa !11
  %5629 = fcmp oge double %5628, 0.000000e+00
  br i1 %5629, label %5630, label %5632

5630:                                             ; preds = %5623
  %5631 = load double, ptr %75, align 8, !tbaa !11
  br label %5635

5632:                                             ; preds = %5623
  %5633 = load double, ptr %75, align 8, !tbaa !11
  %5634 = fneg double %5633
  br label %5635

5635:                                             ; preds = %5632, %5630
  %5636 = phi double [ %5631, %5630 ], [ %5634, %5632 ]
  %5637 = fadd double %5624, %5636
  store double %5637, ptr %77, align 8, !tbaa !11
  %5638 = load double, ptr %76, align 8, !tbaa !11
  %5639 = load double, ptr %77, align 8, !tbaa !11
  %5640 = fcmp oge double %5638, %5639
  br i1 %5640, label %5641, label %5643

5641:                                             ; preds = %5635
  %5642 = load double, ptr %76, align 8, !tbaa !11
  br label %5645

5643:                                             ; preds = %5635
  %5644 = load double, ptr %77, align 8, !tbaa !11
  br label %5645

5645:                                             ; preds = %5643, %5641
  %5646 = phi double [ %5642, %5641 ], [ %5644, %5643 ]
  store double %5646, ptr %111, align 8, !tbaa !11
  %5647 = load i32, ptr %100, align 4, !tbaa !9
  %5648 = load i32, ptr %100, align 4, !tbaa !9
  %5649 = load i32, ptr %49, align 4, !tbaa !9
  %5650 = mul nsw i32 %5648, %5649
  %5651 = add nsw i32 %5647, %5650
  store i32 %5651, ptr %64, align 4, !tbaa !9
  %5652 = load i32, ptr %100, align 4, !tbaa !9
  %5653 = add nsw i32 %5652, 1
  %5654 = load i32, ptr %100, align 4, !tbaa !9
  %5655 = add nsw i32 %5654, 1
  %5656 = load i32, ptr %49, align 4, !tbaa !9
  %5657 = mul nsw i32 %5655, %5656
  %5658 = add nsw i32 %5653, %5657
  store i32 %5658, ptr %65, align 4, !tbaa !9
  %5659 = load ptr, ptr %33, align 8, !tbaa !5
  %5660 = load i32, ptr %64, align 4, !tbaa !9
  %5661 = sext i32 %5660 to i64
  %5662 = getelementptr inbounds %struct.doublecomplex, ptr %5659, i64 %5661
  %5663 = getelementptr inbounds %struct.doublecomplex, ptr %5662, i32 0, i32 0
  %5664 = load double, ptr %5663, align 8, !tbaa !13
  %5665 = load ptr, ptr %33, align 8, !tbaa !5
  %5666 = load i32, ptr %65, align 4, !tbaa !9
  %5667 = sext i32 %5666 to i64
  %5668 = getelementptr inbounds %struct.doublecomplex, ptr %5665, i64 %5667
  %5669 = getelementptr inbounds %struct.doublecomplex, ptr %5668, i32 0, i32 0
  %5670 = load double, ptr %5669, align 8, !tbaa !13
  %5671 = fsub double %5664, %5670
  %5672 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %5671, ptr %5672, align 8, !tbaa !13
  %5673 = load ptr, ptr %33, align 8, !tbaa !5
  %5674 = load i32, ptr %64, align 4, !tbaa !9
  %5675 = sext i32 %5674 to i64
  %5676 = getelementptr inbounds %struct.doublecomplex, ptr %5673, i64 %5675
  %5677 = getelementptr inbounds %struct.doublecomplex, ptr %5676, i32 0, i32 1
  %5678 = load double, ptr %5677, align 8, !tbaa !15
  %5679 = load ptr, ptr %33, align 8, !tbaa !5
  %5680 = load i32, ptr %65, align 4, !tbaa !9
  %5681 = sext i32 %5680 to i64
  %5682 = getelementptr inbounds %struct.doublecomplex, ptr %5679, i64 %5681
  %5683 = getelementptr inbounds %struct.doublecomplex, ptr %5682, i32 0, i32 1
  %5684 = load double, ptr %5683, align 8, !tbaa !15
  %5685 = fsub double %5678, %5684
  %5686 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %5685, ptr %5686, align 8, !tbaa !15
  %5687 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %5688 = load double, ptr %5687, align 8, !tbaa !13
  %5689 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %5688, ptr %5689, align 8, !tbaa !13
  %5690 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %5691 = load double, ptr %5690, align 8, !tbaa !15
  %5692 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %5691, ptr %5692, align 8, !tbaa !15
  %5693 = load i32, ptr %100, align 4, !tbaa !9
  %5694 = add nsw i32 %5693, 1
  %5695 = load i32, ptr %100, align 4, !tbaa !9
  %5696 = add nsw i32 %5695, 1
  %5697 = load i32, ptr %49, align 4, !tbaa !9
  %5698 = mul nsw i32 %5696, %5697
  %5699 = add nsw i32 %5694, %5698
  store i32 %5699, ptr %67, align 4, !tbaa !9
  %5700 = load ptr, ptr %33, align 8, !tbaa !5
  %5701 = load i32, ptr %67, align 4, !tbaa !9
  %5702 = sext i32 %5701 to i64
  %5703 = getelementptr inbounds %struct.doublecomplex, ptr %5700, i64 %5702
  %5704 = getelementptr inbounds %struct.doublecomplex, ptr %5703, i32 0, i32 0
  %5705 = load double, ptr %5704, align 8, !tbaa !13
  store double %5705, ptr %72, align 8, !tbaa !11
  %5706 = load double, ptr %72, align 8, !tbaa !11
  %5707 = fcmp oge double %5706, 0.000000e+00
  br i1 %5707, label %5708, label %5710

5708:                                             ; preds = %5645
  %5709 = load double, ptr %72, align 8, !tbaa !11
  br label %5713

5710:                                             ; preds = %5645
  %5711 = load double, ptr %72, align 8, !tbaa !11
  %5712 = fneg double %5711
  br label %5713

5713:                                             ; preds = %5710, %5708
  %5714 = phi double [ %5709, %5708 ], [ %5712, %5710 ]
  %5715 = load ptr, ptr %33, align 8, !tbaa !5
  %5716 = load i32, ptr %100, align 4, !tbaa !9
  %5717 = add nsw i32 %5716, 1
  %5718 = load i32, ptr %100, align 4, !tbaa !9
  %5719 = add nsw i32 %5718, 1
  %5720 = load i32, ptr %49, align 4, !tbaa !9
  %5721 = mul nsw i32 %5719, %5720
  %5722 = add nsw i32 %5717, %5721
  %5723 = sext i32 %5722 to i64
  %5724 = getelementptr inbounds %struct.doublecomplex, ptr %5715, i64 %5723
  %5725 = call { double, double } @Cd(ptr noundef %5724)
  %5726 = extractvalue { double, double } %5725, 0
  %5727 = extractvalue { double, double } %5725, 1
  store double %5727, ptr %73, align 8, !tbaa !11
  %5728 = load double, ptr %73, align 8, !tbaa !11
  %5729 = fcmp oge double %5728, 0.000000e+00
  br i1 %5729, label %5730, label %5732

5730:                                             ; preds = %5713
  %5731 = load double, ptr %73, align 8, !tbaa !11
  br label %5735

5732:                                             ; preds = %5713
  %5733 = load double, ptr %73, align 8, !tbaa !11
  %5734 = fneg double %5733
  br label %5735

5735:                                             ; preds = %5732, %5730
  %5736 = phi double [ %5731, %5730 ], [ %5734, %5732 ]
  %5737 = fadd double %5714, %5736
  store double %5737, ptr %76, align 8, !tbaa !11
  %5738 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %5739 = load double, ptr %5738, align 8, !tbaa !13
  store double %5739, ptr %74, align 8, !tbaa !11
  %5740 = load double, ptr %74, align 8, !tbaa !11
  %5741 = fcmp oge double %5740, 0.000000e+00
  br i1 %5741, label %5742, label %5744

5742:                                             ; preds = %5735
  %5743 = load double, ptr %74, align 8, !tbaa !11
  br label %5747

5744:                                             ; preds = %5735
  %5745 = load double, ptr %74, align 8, !tbaa !11
  %5746 = fneg double %5745
  br label %5747

5747:                                             ; preds = %5744, %5742
  %5748 = phi double [ %5743, %5742 ], [ %5746, %5744 ]
  %5749 = call { double, double } @Cd(ptr noundef %82)
  %5750 = extractvalue { double, double } %5749, 0
  %5751 = extractvalue { double, double } %5749, 1
  store double %5751, ptr %75, align 8, !tbaa !11
  %5752 = load double, ptr %75, align 8, !tbaa !11
  %5753 = fcmp oge double %5752, 0.000000e+00
  br i1 %5753, label %5754, label %5756

5754:                                             ; preds = %5747
  %5755 = load double, ptr %75, align 8, !tbaa !11
  br label %5759

5756:                                             ; preds = %5747
  %5757 = load double, ptr %75, align 8, !tbaa !11
  %5758 = fneg double %5757
  br label %5759

5759:                                             ; preds = %5756, %5754
  %5760 = phi double [ %5755, %5754 ], [ %5758, %5756 ]
  %5761 = fadd double %5748, %5760
  store double %5761, ptr %77, align 8, !tbaa !11
  %5762 = load double, ptr %76, align 8, !tbaa !11
  %5763 = load double, ptr %77, align 8, !tbaa !11
  %5764 = fcmp ole double %5762, %5763
  br i1 %5764, label %5765, label %5767

5765:                                             ; preds = %5759
  %5766 = load double, ptr %76, align 8, !tbaa !11
  br label %5769

5767:                                             ; preds = %5759
  %5768 = load double, ptr %77, align 8, !tbaa !11
  br label %5769

5769:                                             ; preds = %5767, %5765
  %5770 = phi double [ %5766, %5765 ], [ %5768, %5767 ]
  store double %5770, ptr %114, align 8, !tbaa !11
  %5771 = load double, ptr %111, align 8, !tbaa !11
  %5772 = load double, ptr %112, align 8, !tbaa !11
  %5773 = fadd double %5771, %5772
  store double %5773, ptr %123, align 8, !tbaa !11
  %5774 = load double, ptr %114, align 8, !tbaa !11
  %5775 = load double, ptr %111, align 8, !tbaa !11
  %5776 = load double, ptr %123, align 8, !tbaa !11
  %5777 = fdiv double %5775, %5776
  %5778 = fmul double %5774, %5777
  store double %5778, ptr %128, align 8, !tbaa !11
  %5779 = load double, ptr %122, align 8, !tbaa !11
  store double %5779, ptr %72, align 8, !tbaa !11
  %5780 = load double, ptr %126, align 8, !tbaa !11
  %5781 = load double, ptr %128, align 8, !tbaa !11
  %5782 = fmul double %5780, %5781
  store double %5782, ptr %73, align 8, !tbaa !11
  %5783 = load double, ptr %128, align 8, !tbaa !11
  %5784 = fcmp oeq double %5783, 0.000000e+00
  br i1 %5784, label %5801, label %5785

5785:                                             ; preds = %5769
  %5786 = load double, ptr %113, align 8, !tbaa !11
  %5787 = load double, ptr %112, align 8, !tbaa !11
  %5788 = load double, ptr %123, align 8, !tbaa !11
  %5789 = fdiv double %5787, %5788
  %5790 = fmul double %5786, %5789
  %5791 = load double, ptr %72, align 8, !tbaa !11
  %5792 = load double, ptr %73, align 8, !tbaa !11
  %5793 = fcmp oge double %5791, %5792
  br i1 %5793, label %5794, label %5796

5794:                                             ; preds = %5785
  %5795 = load double, ptr %72, align 8, !tbaa !11
  br label %5798

5796:                                             ; preds = %5785
  %5797 = load double, ptr %73, align 8, !tbaa !11
  br label %5798

5798:                                             ; preds = %5796, %5794
  %5799 = phi double [ %5795, %5794 ], [ %5797, %5796 ]
  %5800 = fcmp ole double %5790, %5799
  br i1 %5800, label %5801, label %5818

5801:                                             ; preds = %5798, %5769
  %5802 = load i32, ptr %100, align 4, !tbaa !9
  %5803 = add nsw i32 %5802, 1
  %5804 = load i32, ptr %100, align 4, !tbaa !9
  %5805 = load i32, ptr %49, align 4, !tbaa !9
  %5806 = mul nsw i32 %5804, %5805
  %5807 = add nsw i32 %5803, %5806
  store i32 %5807, ptr %64, align 4, !tbaa !9
  %5808 = load ptr, ptr %33, align 8, !tbaa !5
  %5809 = load i32, ptr %64, align 4, !tbaa !9
  %5810 = sext i32 %5809 to i64
  %5811 = getelementptr inbounds %struct.doublecomplex, ptr %5808, i64 %5810
  %5812 = getelementptr inbounds %struct.doublecomplex, ptr %5811, i32 0, i32 0
  store double 0.000000e+00, ptr %5812, align 8, !tbaa !13
  %5813 = load ptr, ptr %33, align 8, !tbaa !5
  %5814 = load i32, ptr %64, align 4, !tbaa !9
  %5815 = sext i32 %5814 to i64
  %5816 = getelementptr inbounds %struct.doublecomplex, ptr %5813, i64 %5815
  %5817 = getelementptr inbounds %struct.doublecomplex, ptr %5816, i32 0, i32 1
  store double 0.000000e+00, ptr %5817, align 8, !tbaa !15
  br label %5818

5818:                                             ; preds = %5801, %5798
  br label %5819

5819:                                             ; preds = %5818, %5329
  br label %5820

5820:                                             ; preds = %5819, %4857
  br label %5821

5821:                                             ; preds = %5820, %4842
  %5822 = load i32, ptr %101, align 4, !tbaa !9
  %5823 = add nsw i32 %5822, -1
  store i32 %5823, ptr %101, align 4, !tbaa !9
  br label %2742, !llvm.loop !22

5824:                                             ; preds = %2742
  %5825 = load i32, ptr %103, align 4, !tbaa !9
  %5826 = icmp ne i32 %5825, 0
  br i1 %5826, label %5827, label %5839

5827:                                             ; preds = %5824
  %5828 = load i32, ptr %104, align 4, !tbaa !9
  %5829 = load ptr, ptr %30, align 8, !tbaa !5
  %5830 = load i32, ptr %5829, align 4, !tbaa !9
  %5831 = icmp sle i32 %5828, %5830
  br i1 %5831, label %5832, label %5834

5832:                                             ; preds = %5827
  %5833 = load i32, ptr %104, align 4, !tbaa !9
  br label %5837

5834:                                             ; preds = %5827
  %5835 = load ptr, ptr %30, align 8, !tbaa !5
  %5836 = load i32, ptr %5835, align 4, !tbaa !9
  br label %5837

5837:                                             ; preds = %5834, %5832
  %5838 = phi i32 [ %5833, %5832 ], [ %5836, %5834 ]
  store i32 %5838, ptr %94, align 4, !tbaa !9
  br label %5850

5839:                                             ; preds = %5824
  %5840 = load ptr, ptr %25, align 8, !tbaa !5
  %5841 = load i32, ptr %5840, align 4, !tbaa !9
  %5842 = icmp ne i32 %5841, 0
  br i1 %5842, label %5843, label %5846

5843:                                             ; preds = %5839
  %5844 = load ptr, ptr %28, align 8, !tbaa !5
  %5845 = load i32, ptr %5844, align 4, !tbaa !9
  store i32 %5845, ptr %94, align 4, !tbaa !9
  br label %5849

5846:                                             ; preds = %5839
  %5847 = load ptr, ptr %30, align 8, !tbaa !5
  %5848 = load i32, ptr %5847, align 4, !tbaa !9
  store i32 %5848, ptr %94, align 4, !tbaa !9
  br label %5849

5849:                                             ; preds = %5846, %5843
  br label %5850

5850:                                             ; preds = %5849, %5837
  %5851 = load i32, ptr %98, align 4, !tbaa !9
  store i32 %5851, ptr %66, align 4, !tbaa !9
  %5852 = load i32, ptr %95, align 4, !tbaa !9
  store i32 %5852, ptr %101, align 4, !tbaa !9
  br label %5853

5853:                                             ; preds = %6311, %5850
  %5854 = load i32, ptr %101, align 4, !tbaa !9
  %5855 = load i32, ptr %66, align 4, !tbaa !9
  %5856 = icmp sge i32 %5854, %5855
  br i1 %5856, label %5857, label %6314

5857:                                             ; preds = %5853
  %5858 = load i32, ptr %106, align 4, !tbaa !9
  %5859 = load i32, ptr %101, align 4, !tbaa !9
  %5860 = sub nsw i32 %5859, 1
  %5861 = shl i32 %5860, 1
  %5862 = add nsw i32 %5858, %5861
  store i32 %5862, ptr %100, align 4, !tbaa !9
  %5863 = load ptr, ptr %29, align 8, !tbaa !5
  %5864 = load i32, ptr %5863, align 4, !tbaa !9
  store i32 %5864, ptr %64, align 4, !tbaa !9
  %5865 = load i32, ptr %106, align 4, !tbaa !9
  %5866 = load i32, ptr %101, align 4, !tbaa !9
  %5867 = shl i32 %5866, 1
  %5868 = add nsw i32 %5865, %5867
  store i32 %5868, ptr %65, align 4, !tbaa !9
  %5869 = load i32, ptr %94, align 4, !tbaa !9
  store i32 %5869, ptr %67, align 4, !tbaa !9
  %5870 = load i32, ptr %64, align 4, !tbaa !9
  %5871 = load i32, ptr %65, align 4, !tbaa !9
  %5872 = icmp sge i32 %5870, %5871
  br i1 %5872, label %5873, label %5875

5873:                                             ; preds = %5857
  %5874 = load i32, ptr %64, align 4, !tbaa !9
  br label %5877

5875:                                             ; preds = %5857
  %5876 = load i32, ptr %65, align 4, !tbaa !9
  br label %5877

5877:                                             ; preds = %5875, %5873
  %5878 = phi i32 [ %5874, %5873 ], [ %5876, %5875 ]
  store i32 %5878, ptr %99, align 4, !tbaa !9
  br label %5879

5879:                                             ; preds = %6307, %5877
  %5880 = load i32, ptr %99, align 4, !tbaa !9
  %5881 = load i32, ptr %67, align 4, !tbaa !9
  %5882 = icmp sle i32 %5880, %5881
  br i1 %5882, label %5883, label %6310

5883:                                             ; preds = %5879
  %5884 = load ptr, ptr %39, align 8, !tbaa !5
  %5885 = load i32, ptr %101, align 4, !tbaa !9
  %5886 = load i32, ptr %53, align 4, !tbaa !9
  %5887 = mul nsw i32 %5885, %5886
  %5888 = add nsw i32 %5887, 1
  %5889 = sext i32 %5888 to i64
  %5890 = getelementptr inbounds %struct.doublecomplex, ptr %5884, i64 %5889
  %5891 = call { double, double } @Cd(ptr noundef %5890)
  %5892 = extractvalue { double, double } %5891, 0
  %5893 = extractvalue { double, double } %5891, 1
  %5894 = fneg double %5893
  %5895 = call ptr @_pCd(ptr noundef %83)
  %5896 = getelementptr inbounds { double, double }, ptr %5895, i32 0, i32 0
  %5897 = getelementptr inbounds { double, double }, ptr %5895, i32 0, i32 1
  store double %5892, ptr %5896, align 8
  store double %5894, ptr %5897, align 8
  %5898 = load i32, ptr %100, align 4, !tbaa !9
  %5899 = add nsw i32 %5898, 1
  %5900 = load i32, ptr %99, align 4, !tbaa !9
  %5901 = load i32, ptr %49, align 4, !tbaa !9
  %5902 = mul nsw i32 %5900, %5901
  %5903 = add nsw i32 %5899, %5902
  store i32 %5903, ptr %64, align 4, !tbaa !9
  %5904 = load ptr, ptr %39, align 8, !tbaa !5
  %5905 = load i32, ptr %101, align 4, !tbaa !9
  %5906 = load i32, ptr %53, align 4, !tbaa !9
  %5907 = mul nsw i32 %5905, %5906
  %5908 = add nsw i32 %5907, 2
  %5909 = sext i32 %5908 to i64
  %5910 = getelementptr inbounds %struct.doublecomplex, ptr %5904, i64 %5909
  %5911 = call { double, double } @Cd(ptr noundef %5910)
  %5912 = extractvalue { double, double } %5911, 0
  %5913 = extractvalue { double, double } %5911, 1
  %5914 = fneg double %5913
  %5915 = call ptr @_pCd(ptr noundef %87)
  %5916 = getelementptr inbounds { double, double }, ptr %5915, i32 0, i32 0
  %5917 = getelementptr inbounds { double, double }, ptr %5915, i32 0, i32 1
  store double %5912, ptr %5916, align 8
  store double %5914, ptr %5917, align 8
  %5918 = load i32, ptr %100, align 4, !tbaa !9
  %5919 = add nsw i32 %5918, 2
  %5920 = load i32, ptr %99, align 4, !tbaa !9
  %5921 = load i32, ptr %49, align 4, !tbaa !9
  %5922 = mul nsw i32 %5920, %5921
  %5923 = add nsw i32 %5919, %5922
  store i32 %5923, ptr %65, align 4, !tbaa !9
  %5924 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 0
  %5925 = load double, ptr %5924, align 8, !tbaa !13
  %5926 = load ptr, ptr %33, align 8, !tbaa !5
  %5927 = load i32, ptr %65, align 4, !tbaa !9
  %5928 = sext i32 %5927 to i64
  %5929 = getelementptr inbounds %struct.doublecomplex, ptr %5926, i64 %5928
  %5930 = getelementptr inbounds %struct.doublecomplex, ptr %5929, i32 0, i32 0
  %5931 = load double, ptr %5930, align 8, !tbaa !13
  %5932 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 1
  %5933 = load double, ptr %5932, align 8, !tbaa !15
  %5934 = load ptr, ptr %33, align 8, !tbaa !5
  %5935 = load i32, ptr %65, align 4, !tbaa !9
  %5936 = sext i32 %5935 to i64
  %5937 = getelementptr inbounds %struct.doublecomplex, ptr %5934, i64 %5936
  %5938 = getelementptr inbounds %struct.doublecomplex, ptr %5937, i32 0, i32 1
  %5939 = load double, ptr %5938, align 8, !tbaa !15
  %5940 = fmul double %5933, %5939
  %5941 = fneg double %5940
  %5942 = call double @llvm.fmuladd.f64(double %5925, double %5931, double %5941)
  %5943 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %5942, ptr %5943, align 8, !tbaa !13
  %5944 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 0
  %5945 = load double, ptr %5944, align 8, !tbaa !13
  %5946 = load ptr, ptr %33, align 8, !tbaa !5
  %5947 = load i32, ptr %65, align 4, !tbaa !9
  %5948 = sext i32 %5947 to i64
  %5949 = getelementptr inbounds %struct.doublecomplex, ptr %5946, i64 %5948
  %5950 = getelementptr inbounds %struct.doublecomplex, ptr %5949, i32 0, i32 1
  %5951 = load double, ptr %5950, align 8, !tbaa !15
  %5952 = getelementptr inbounds %struct.doublecomplex, ptr %87, i32 0, i32 1
  %5953 = load double, ptr %5952, align 8, !tbaa !15
  %5954 = load ptr, ptr %33, align 8, !tbaa !5
  %5955 = load i32, ptr %65, align 4, !tbaa !9
  %5956 = sext i32 %5955 to i64
  %5957 = getelementptr inbounds %struct.doublecomplex, ptr %5954, i64 %5956
  %5958 = getelementptr inbounds %struct.doublecomplex, ptr %5957, i32 0, i32 0
  %5959 = load double, ptr %5958, align 8, !tbaa !13
  %5960 = fmul double %5953, %5959
  %5961 = call double @llvm.fmuladd.f64(double %5945, double %5951, double %5960)
  %5962 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %5961, ptr %5962, align 8, !tbaa !15
  %5963 = load ptr, ptr %33, align 8, !tbaa !5
  %5964 = load i32, ptr %64, align 4, !tbaa !9
  %5965 = sext i32 %5964 to i64
  %5966 = getelementptr inbounds %struct.doublecomplex, ptr %5963, i64 %5965
  %5967 = getelementptr inbounds %struct.doublecomplex, ptr %5966, i32 0, i32 0
  %5968 = load double, ptr %5967, align 8, !tbaa !13
  %5969 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %5970 = load double, ptr %5969, align 8, !tbaa !13
  %5971 = fadd double %5968, %5970
  %5972 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %5971, ptr %5972, align 8, !tbaa !13
  %5973 = load ptr, ptr %33, align 8, !tbaa !5
  %5974 = load i32, ptr %64, align 4, !tbaa !9
  %5975 = sext i32 %5974 to i64
  %5976 = getelementptr inbounds %struct.doublecomplex, ptr %5973, i64 %5975
  %5977 = getelementptr inbounds %struct.doublecomplex, ptr %5976, i32 0, i32 1
  %5978 = load double, ptr %5977, align 8, !tbaa !15
  %5979 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %5980 = load double, ptr %5979, align 8, !tbaa !15
  %5981 = fadd double %5978, %5980
  %5982 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %5981, ptr %5982, align 8, !tbaa !15
  %5983 = load ptr, ptr %39, align 8, !tbaa !5
  %5984 = load i32, ptr %101, align 4, !tbaa !9
  %5985 = load i32, ptr %53, align 4, !tbaa !9
  %5986 = mul nsw i32 %5984, %5985
  %5987 = add nsw i32 %5986, 3
  %5988 = sext i32 %5987 to i64
  %5989 = getelementptr inbounds %struct.doublecomplex, ptr %5983, i64 %5988
  %5990 = call { double, double } @Cd(ptr noundef %5989)
  %5991 = extractvalue { double, double } %5990, 0
  %5992 = extractvalue { double, double } %5990, 1
  %5993 = fneg double %5992
  %5994 = call ptr @_pCd(ptr noundef %89)
  %5995 = getelementptr inbounds { double, double }, ptr %5994, i32 0, i32 0
  %5996 = getelementptr inbounds { double, double }, ptr %5994, i32 0, i32 1
  store double %5991, ptr %5995, align 8
  store double %5993, ptr %5996, align 8
  %5997 = load i32, ptr %100, align 4, !tbaa !9
  %5998 = add nsw i32 %5997, 3
  %5999 = load i32, ptr %99, align 4, !tbaa !9
  %6000 = load i32, ptr %49, align 4, !tbaa !9
  %6001 = mul nsw i32 %5999, %6000
  %6002 = add nsw i32 %5998, %6001
  store i32 %6002, ptr %68, align 4, !tbaa !9
  %6003 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 0
  %6004 = load double, ptr %6003, align 8, !tbaa !13
  %6005 = load ptr, ptr %33, align 8, !tbaa !5
  %6006 = load i32, ptr %68, align 4, !tbaa !9
  %6007 = sext i32 %6006 to i64
  %6008 = getelementptr inbounds %struct.doublecomplex, ptr %6005, i64 %6007
  %6009 = getelementptr inbounds %struct.doublecomplex, ptr %6008, i32 0, i32 0
  %6010 = load double, ptr %6009, align 8, !tbaa !13
  %6011 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 1
  %6012 = load double, ptr %6011, align 8, !tbaa !15
  %6013 = load ptr, ptr %33, align 8, !tbaa !5
  %6014 = load i32, ptr %68, align 4, !tbaa !9
  %6015 = sext i32 %6014 to i64
  %6016 = getelementptr inbounds %struct.doublecomplex, ptr %6013, i64 %6015
  %6017 = getelementptr inbounds %struct.doublecomplex, ptr %6016, i32 0, i32 1
  %6018 = load double, ptr %6017, align 8, !tbaa !15
  %6019 = fmul double %6012, %6018
  %6020 = fneg double %6019
  %6021 = call double @llvm.fmuladd.f64(double %6004, double %6010, double %6020)
  %6022 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  store double %6021, ptr %6022, align 8, !tbaa !13
  %6023 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 0
  %6024 = load double, ptr %6023, align 8, !tbaa !13
  %6025 = load ptr, ptr %33, align 8, !tbaa !5
  %6026 = load i32, ptr %68, align 4, !tbaa !9
  %6027 = sext i32 %6026 to i64
  %6028 = getelementptr inbounds %struct.doublecomplex, ptr %6025, i64 %6027
  %6029 = getelementptr inbounds %struct.doublecomplex, ptr %6028, i32 0, i32 1
  %6030 = load double, ptr %6029, align 8, !tbaa !15
  %6031 = getelementptr inbounds %struct.doublecomplex, ptr %89, i32 0, i32 1
  %6032 = load double, ptr %6031, align 8, !tbaa !15
  %6033 = load ptr, ptr %33, align 8, !tbaa !5
  %6034 = load i32, ptr %68, align 4, !tbaa !9
  %6035 = sext i32 %6034 to i64
  %6036 = getelementptr inbounds %struct.doublecomplex, ptr %6033, i64 %6035
  %6037 = getelementptr inbounds %struct.doublecomplex, ptr %6036, i32 0, i32 0
  %6038 = load double, ptr %6037, align 8, !tbaa !13
  %6039 = fmul double %6032, %6038
  %6040 = call double @llvm.fmuladd.f64(double %6024, double %6030, double %6039)
  %6041 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  store double %6040, ptr %6041, align 8, !tbaa !15
  %6042 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %6043 = load double, ptr %6042, align 8, !tbaa !13
  %6044 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 0
  %6045 = load double, ptr %6044, align 8, !tbaa !13
  %6046 = fadd double %6043, %6045
  %6047 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %6046, ptr %6047, align 8, !tbaa !13
  %6048 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %6049 = load double, ptr %6048, align 8, !tbaa !15
  %6050 = getelementptr inbounds %struct.doublecomplex, ptr %88, i32 0, i32 1
  %6051 = load double, ptr %6050, align 8, !tbaa !15
  %6052 = fadd double %6049, %6051
  %6053 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %6052, ptr %6053, align 8, !tbaa !15
  %6054 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6055 = load double, ptr %6054, align 8, !tbaa !13
  %6056 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6057 = load double, ptr %6056, align 8, !tbaa !13
  %6058 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6059 = load double, ptr %6058, align 8, !tbaa !15
  %6060 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6061 = load double, ptr %6060, align 8, !tbaa !15
  %6062 = fmul double %6059, %6061
  %6063 = fneg double %6062
  %6064 = call double @llvm.fmuladd.f64(double %6055, double %6057, double %6063)
  %6065 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6064, ptr %6065, align 8, !tbaa !13
  %6066 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6067 = load double, ptr %6066, align 8, !tbaa !13
  %6068 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6069 = load double, ptr %6068, align 8, !tbaa !15
  %6070 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6071 = load double, ptr %6070, align 8, !tbaa !15
  %6072 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6073 = load double, ptr %6072, align 8, !tbaa !13
  %6074 = fmul double %6071, %6073
  %6075 = call double @llvm.fmuladd.f64(double %6067, double %6069, double %6074)
  %6076 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6075, ptr %6076, align 8, !tbaa !15
  %6077 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6078 = load double, ptr %6077, align 8, !tbaa !13
  %6079 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %6078, ptr %6079, align 8, !tbaa !13
  %6080 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6081 = load double, ptr %6080, align 8, !tbaa !15
  %6082 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %6081, ptr %6082, align 8, !tbaa !15
  %6083 = load i32, ptr %100, align 4, !tbaa !9
  %6084 = add nsw i32 %6083, 1
  %6085 = load i32, ptr %99, align 4, !tbaa !9
  %6086 = load i32, ptr %49, align 4, !tbaa !9
  %6087 = mul nsw i32 %6085, %6086
  %6088 = add nsw i32 %6084, %6087
  store i32 %6088, ptr %64, align 4, !tbaa !9
  %6089 = load i32, ptr %100, align 4, !tbaa !9
  %6090 = add nsw i32 %6089, 1
  %6091 = load i32, ptr %99, align 4, !tbaa !9
  %6092 = load i32, ptr %49, align 4, !tbaa !9
  %6093 = mul nsw i32 %6091, %6092
  %6094 = add nsw i32 %6090, %6093
  store i32 %6094, ptr %65, align 4, !tbaa !9
  %6095 = load ptr, ptr %33, align 8, !tbaa !5
  %6096 = load i32, ptr %65, align 4, !tbaa !9
  %6097 = sext i32 %6096 to i64
  %6098 = getelementptr inbounds %struct.doublecomplex, ptr %6095, i64 %6097
  %6099 = getelementptr inbounds %struct.doublecomplex, ptr %6098, i32 0, i32 0
  %6100 = load double, ptr %6099, align 8, !tbaa !13
  %6101 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6102 = load double, ptr %6101, align 8, !tbaa !13
  %6103 = fsub double %6100, %6102
  %6104 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6103, ptr %6104, align 8, !tbaa !13
  %6105 = load ptr, ptr %33, align 8, !tbaa !5
  %6106 = load i32, ptr %65, align 4, !tbaa !9
  %6107 = sext i32 %6106 to i64
  %6108 = getelementptr inbounds %struct.doublecomplex, ptr %6105, i64 %6107
  %6109 = getelementptr inbounds %struct.doublecomplex, ptr %6108, i32 0, i32 1
  %6110 = load double, ptr %6109, align 8, !tbaa !15
  %6111 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6112 = load double, ptr %6111, align 8, !tbaa !15
  %6113 = fsub double %6110, %6112
  %6114 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6113, ptr %6114, align 8, !tbaa !15
  %6115 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6116 = load double, ptr %6115, align 8, !tbaa !13
  %6117 = load ptr, ptr %33, align 8, !tbaa !5
  %6118 = load i32, ptr %64, align 4, !tbaa !9
  %6119 = sext i32 %6118 to i64
  %6120 = getelementptr inbounds %struct.doublecomplex, ptr %6117, i64 %6119
  %6121 = getelementptr inbounds %struct.doublecomplex, ptr %6120, i32 0, i32 0
  store double %6116, ptr %6121, align 8, !tbaa !13
  %6122 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6123 = load double, ptr %6122, align 8, !tbaa !15
  %6124 = load ptr, ptr %33, align 8, !tbaa !5
  %6125 = load i32, ptr %64, align 4, !tbaa !9
  %6126 = sext i32 %6125 to i64
  %6127 = getelementptr inbounds %struct.doublecomplex, ptr %6124, i64 %6126
  %6128 = getelementptr inbounds %struct.doublecomplex, ptr %6127, i32 0, i32 1
  store double %6123, ptr %6128, align 8, !tbaa !15
  %6129 = load i32, ptr %100, align 4, !tbaa !9
  %6130 = add nsw i32 %6129, 2
  %6131 = load i32, ptr %99, align 4, !tbaa !9
  %6132 = load i32, ptr %49, align 4, !tbaa !9
  %6133 = mul nsw i32 %6131, %6132
  %6134 = add nsw i32 %6130, %6133
  store i32 %6134, ptr %64, align 4, !tbaa !9
  %6135 = load i32, ptr %100, align 4, !tbaa !9
  %6136 = add nsw i32 %6135, 2
  %6137 = load i32, ptr %99, align 4, !tbaa !9
  %6138 = load i32, ptr %49, align 4, !tbaa !9
  %6139 = mul nsw i32 %6137, %6138
  %6140 = add nsw i32 %6136, %6139
  store i32 %6140, ptr %65, align 4, !tbaa !9
  %6141 = load i32, ptr %101, align 4, !tbaa !9
  %6142 = load i32, ptr %53, align 4, !tbaa !9
  %6143 = mul nsw i32 %6141, %6142
  %6144 = add nsw i32 %6143, 2
  store i32 %6144, ptr %68, align 4, !tbaa !9
  %6145 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6146 = load double, ptr %6145, align 8, !tbaa !13
  %6147 = load ptr, ptr %39, align 8, !tbaa !5
  %6148 = load i32, ptr %68, align 4, !tbaa !9
  %6149 = sext i32 %6148 to i64
  %6150 = getelementptr inbounds %struct.doublecomplex, ptr %6147, i64 %6149
  %6151 = getelementptr inbounds %struct.doublecomplex, ptr %6150, i32 0, i32 0
  %6152 = load double, ptr %6151, align 8, !tbaa !13
  %6153 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6154 = load double, ptr %6153, align 8, !tbaa !15
  %6155 = load ptr, ptr %39, align 8, !tbaa !5
  %6156 = load i32, ptr %68, align 4, !tbaa !9
  %6157 = sext i32 %6156 to i64
  %6158 = getelementptr inbounds %struct.doublecomplex, ptr %6155, i64 %6157
  %6159 = getelementptr inbounds %struct.doublecomplex, ptr %6158, i32 0, i32 1
  %6160 = load double, ptr %6159, align 8, !tbaa !15
  %6161 = fmul double %6154, %6160
  %6162 = fneg double %6161
  %6163 = call double @llvm.fmuladd.f64(double %6146, double %6152, double %6162)
  %6164 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %6163, ptr %6164, align 8, !tbaa !13
  %6165 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6166 = load double, ptr %6165, align 8, !tbaa !13
  %6167 = load ptr, ptr %39, align 8, !tbaa !5
  %6168 = load i32, ptr %68, align 4, !tbaa !9
  %6169 = sext i32 %6168 to i64
  %6170 = getelementptr inbounds %struct.doublecomplex, ptr %6167, i64 %6169
  %6171 = getelementptr inbounds %struct.doublecomplex, ptr %6170, i32 0, i32 1
  %6172 = load double, ptr %6171, align 8, !tbaa !15
  %6173 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6174 = load double, ptr %6173, align 8, !tbaa !15
  %6175 = load ptr, ptr %39, align 8, !tbaa !5
  %6176 = load i32, ptr %68, align 4, !tbaa !9
  %6177 = sext i32 %6176 to i64
  %6178 = getelementptr inbounds %struct.doublecomplex, ptr %6175, i64 %6177
  %6179 = getelementptr inbounds %struct.doublecomplex, ptr %6178, i32 0, i32 0
  %6180 = load double, ptr %6179, align 8, !tbaa !13
  %6181 = fmul double %6174, %6180
  %6182 = call double @llvm.fmuladd.f64(double %6166, double %6172, double %6181)
  %6183 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %6182, ptr %6183, align 8, !tbaa !15
  %6184 = load ptr, ptr %33, align 8, !tbaa !5
  %6185 = load i32, ptr %65, align 4, !tbaa !9
  %6186 = sext i32 %6185 to i64
  %6187 = getelementptr inbounds %struct.doublecomplex, ptr %6184, i64 %6186
  %6188 = getelementptr inbounds %struct.doublecomplex, ptr %6187, i32 0, i32 0
  %6189 = load double, ptr %6188, align 8, !tbaa !13
  %6190 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6191 = load double, ptr %6190, align 8, !tbaa !13
  %6192 = fsub double %6189, %6191
  %6193 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6192, ptr %6193, align 8, !tbaa !13
  %6194 = load ptr, ptr %33, align 8, !tbaa !5
  %6195 = load i32, ptr %65, align 4, !tbaa !9
  %6196 = sext i32 %6195 to i64
  %6197 = getelementptr inbounds %struct.doublecomplex, ptr %6194, i64 %6196
  %6198 = getelementptr inbounds %struct.doublecomplex, ptr %6197, i32 0, i32 1
  %6199 = load double, ptr %6198, align 8, !tbaa !15
  %6200 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6201 = load double, ptr %6200, align 8, !tbaa !15
  %6202 = fsub double %6199, %6201
  %6203 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6202, ptr %6203, align 8, !tbaa !15
  %6204 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6205 = load double, ptr %6204, align 8, !tbaa !13
  %6206 = load ptr, ptr %33, align 8, !tbaa !5
  %6207 = load i32, ptr %64, align 4, !tbaa !9
  %6208 = sext i32 %6207 to i64
  %6209 = getelementptr inbounds %struct.doublecomplex, ptr %6206, i64 %6208
  %6210 = getelementptr inbounds %struct.doublecomplex, ptr %6209, i32 0, i32 0
  store double %6205, ptr %6210, align 8, !tbaa !13
  %6211 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6212 = load double, ptr %6211, align 8, !tbaa !15
  %6213 = load ptr, ptr %33, align 8, !tbaa !5
  %6214 = load i32, ptr %64, align 4, !tbaa !9
  %6215 = sext i32 %6214 to i64
  %6216 = getelementptr inbounds %struct.doublecomplex, ptr %6213, i64 %6215
  %6217 = getelementptr inbounds %struct.doublecomplex, ptr %6216, i32 0, i32 1
  store double %6212, ptr %6217, align 8, !tbaa !15
  %6218 = load i32, ptr %100, align 4, !tbaa !9
  %6219 = add nsw i32 %6218, 3
  %6220 = load i32, ptr %99, align 4, !tbaa !9
  %6221 = load i32, ptr %49, align 4, !tbaa !9
  %6222 = mul nsw i32 %6220, %6221
  %6223 = add nsw i32 %6219, %6222
  store i32 %6223, ptr %64, align 4, !tbaa !9
  %6224 = load i32, ptr %100, align 4, !tbaa !9
  %6225 = add nsw i32 %6224, 3
  %6226 = load i32, ptr %99, align 4, !tbaa !9
  %6227 = load i32, ptr %49, align 4, !tbaa !9
  %6228 = mul nsw i32 %6226, %6227
  %6229 = add nsw i32 %6225, %6228
  store i32 %6229, ptr %65, align 4, !tbaa !9
  %6230 = load i32, ptr %101, align 4, !tbaa !9
  %6231 = load i32, ptr %53, align 4, !tbaa !9
  %6232 = mul nsw i32 %6230, %6231
  %6233 = add nsw i32 %6232, 3
  store i32 %6233, ptr %68, align 4, !tbaa !9
  %6234 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6235 = load double, ptr %6234, align 8, !tbaa !13
  %6236 = load ptr, ptr %39, align 8, !tbaa !5
  %6237 = load i32, ptr %68, align 4, !tbaa !9
  %6238 = sext i32 %6237 to i64
  %6239 = getelementptr inbounds %struct.doublecomplex, ptr %6236, i64 %6238
  %6240 = getelementptr inbounds %struct.doublecomplex, ptr %6239, i32 0, i32 0
  %6241 = load double, ptr %6240, align 8, !tbaa !13
  %6242 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6243 = load double, ptr %6242, align 8, !tbaa !15
  %6244 = load ptr, ptr %39, align 8, !tbaa !5
  %6245 = load i32, ptr %68, align 4, !tbaa !9
  %6246 = sext i32 %6245 to i64
  %6247 = getelementptr inbounds %struct.doublecomplex, ptr %6244, i64 %6246
  %6248 = getelementptr inbounds %struct.doublecomplex, ptr %6247, i32 0, i32 1
  %6249 = load double, ptr %6248, align 8, !tbaa !15
  %6250 = fmul double %6243, %6249
  %6251 = fneg double %6250
  %6252 = call double @llvm.fmuladd.f64(double %6235, double %6241, double %6251)
  %6253 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %6252, ptr %6253, align 8, !tbaa !13
  %6254 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6255 = load double, ptr %6254, align 8, !tbaa !13
  %6256 = load ptr, ptr %39, align 8, !tbaa !5
  %6257 = load i32, ptr %68, align 4, !tbaa !9
  %6258 = sext i32 %6257 to i64
  %6259 = getelementptr inbounds %struct.doublecomplex, ptr %6256, i64 %6258
  %6260 = getelementptr inbounds %struct.doublecomplex, ptr %6259, i32 0, i32 1
  %6261 = load double, ptr %6260, align 8, !tbaa !15
  %6262 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6263 = load double, ptr %6262, align 8, !tbaa !15
  %6264 = load ptr, ptr %39, align 8, !tbaa !5
  %6265 = load i32, ptr %68, align 4, !tbaa !9
  %6266 = sext i32 %6265 to i64
  %6267 = getelementptr inbounds %struct.doublecomplex, ptr %6264, i64 %6266
  %6268 = getelementptr inbounds %struct.doublecomplex, ptr %6267, i32 0, i32 0
  %6269 = load double, ptr %6268, align 8, !tbaa !13
  %6270 = fmul double %6263, %6269
  %6271 = call double @llvm.fmuladd.f64(double %6255, double %6261, double %6270)
  %6272 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %6271, ptr %6272, align 8, !tbaa !15
  %6273 = load ptr, ptr %33, align 8, !tbaa !5
  %6274 = load i32, ptr %65, align 4, !tbaa !9
  %6275 = sext i32 %6274 to i64
  %6276 = getelementptr inbounds %struct.doublecomplex, ptr %6273, i64 %6275
  %6277 = getelementptr inbounds %struct.doublecomplex, ptr %6276, i32 0, i32 0
  %6278 = load double, ptr %6277, align 8, !tbaa !13
  %6279 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6280 = load double, ptr %6279, align 8, !tbaa !13
  %6281 = fsub double %6278, %6280
  %6282 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6281, ptr %6282, align 8, !tbaa !13
  %6283 = load ptr, ptr %33, align 8, !tbaa !5
  %6284 = load i32, ptr %65, align 4, !tbaa !9
  %6285 = sext i32 %6284 to i64
  %6286 = getelementptr inbounds %struct.doublecomplex, ptr %6283, i64 %6285
  %6287 = getelementptr inbounds %struct.doublecomplex, ptr %6286, i32 0, i32 1
  %6288 = load double, ptr %6287, align 8, !tbaa !15
  %6289 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6290 = load double, ptr %6289, align 8, !tbaa !15
  %6291 = fsub double %6288, %6290
  %6292 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6291, ptr %6292, align 8, !tbaa !15
  %6293 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6294 = load double, ptr %6293, align 8, !tbaa !13
  %6295 = load ptr, ptr %33, align 8, !tbaa !5
  %6296 = load i32, ptr %64, align 4, !tbaa !9
  %6297 = sext i32 %6296 to i64
  %6298 = getelementptr inbounds %struct.doublecomplex, ptr %6295, i64 %6297
  %6299 = getelementptr inbounds %struct.doublecomplex, ptr %6298, i32 0, i32 0
  store double %6294, ptr %6299, align 8, !tbaa !13
  %6300 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6301 = load double, ptr %6300, align 8, !tbaa !15
  %6302 = load ptr, ptr %33, align 8, !tbaa !5
  %6303 = load i32, ptr %64, align 4, !tbaa !9
  %6304 = sext i32 %6303 to i64
  %6305 = getelementptr inbounds %struct.doublecomplex, ptr %6302, i64 %6304
  %6306 = getelementptr inbounds %struct.doublecomplex, ptr %6305, i32 0, i32 1
  store double %6301, ptr %6306, align 8, !tbaa !15
  br label %6307

6307:                                             ; preds = %5883
  %6308 = load i32, ptr %99, align 4, !tbaa !9
  %6309 = add nsw i32 %6308, 1
  store i32 %6309, ptr %99, align 4, !tbaa !9
  br label %5879, !llvm.loop !23

6310:                                             ; preds = %5879
  br label %6311

6311:                                             ; preds = %6310
  %6312 = load i32, ptr %101, align 4, !tbaa !9
  %6313 = add nsw i32 %6312, -1
  store i32 %6313, ptr %101, align 4, !tbaa !9
  br label %5853, !llvm.loop !24

6314:                                             ; preds = %5853
  %6315 = load i32, ptr %103, align 4, !tbaa !9
  %6316 = icmp ne i32 %6315, 0
  br i1 %6316, label %6317, label %6824

6317:                                             ; preds = %6314
  %6318 = load i32, ptr %98, align 4, !tbaa !9
  store i32 %6318, ptr %66, align 4, !tbaa !9
  %6319 = load i32, ptr %95, align 4, !tbaa !9
  store i32 %6319, ptr %101, align 4, !tbaa !9
  br label %6320

6320:                                             ; preds = %6820, %6317
  %6321 = load i32, ptr %101, align 4, !tbaa !9
  %6322 = load i32, ptr %66, align 4, !tbaa !9
  %6323 = icmp sge i32 %6321, %6322
  br i1 %6323, label %6324, label %6823

6324:                                             ; preds = %6320
  %6325 = load i32, ptr %106, align 4, !tbaa !9
  %6326 = load i32, ptr %101, align 4, !tbaa !9
  %6327 = sub nsw i32 %6326, 1
  %6328 = shl i32 %6327, 1
  %6329 = add nsw i32 %6325, %6328
  store i32 %6329, ptr %100, align 4, !tbaa !9
  %6330 = load i32, ptr %100, align 4, !tbaa !9
  %6331 = load i32, ptr %105, align 4, !tbaa !9
  %6332 = sub nsw i32 %6330, %6331
  store i32 %6332, ptr %125, align 4, !tbaa !9
  store i32 1, ptr %67, align 4, !tbaa !9
  %6333 = load ptr, ptr %29, align 8, !tbaa !5
  %6334 = load i32, ptr %6333, align 4, !tbaa !9
  %6335 = load i32, ptr %105, align 4, !tbaa !9
  %6336 = sub nsw i32 %6334, %6335
  store i32 %6336, ptr %64, align 4, !tbaa !9
  %6337 = load i32, ptr %67, align 4, !tbaa !9
  %6338 = load i32, ptr %64, align 4, !tbaa !9
  %6339 = icmp sge i32 %6337, %6338
  br i1 %6339, label %6340, label %6342

6340:                                             ; preds = %6324
  %6341 = load i32, ptr %67, align 4, !tbaa !9
  br label %6344

6342:                                             ; preds = %6324
  %6343 = load i32, ptr %64, align 4, !tbaa !9
  br label %6344

6344:                                             ; preds = %6342, %6340
  %6345 = phi i32 [ %6341, %6340 ], [ %6343, %6342 ]
  store i32 %6345, ptr %108, align 4, !tbaa !9
  %6346 = load i32, ptr %108, align 4, !tbaa !9
  store i32 %6346, ptr %67, align 4, !tbaa !9
  %6347 = load i32, ptr %125, align 4, !tbaa !9
  %6348 = load i32, ptr %106, align 4, !tbaa !9
  %6349 = load i32, ptr %105, align 4, !tbaa !9
  %6350 = sub nsw i32 %6348, %6349
  %6351 = sub nsw i32 %6347, %6350
  %6352 = add nsw i32 %6351, 1
  store i32 %6352, ptr %64, align 4, !tbaa !9
  %6353 = load i32, ptr %67, align 4, !tbaa !9
  %6354 = load i32, ptr %64, align 4, !tbaa !9
  %6355 = icmp sge i32 %6353, %6354
  br i1 %6355, label %6356, label %6358

6356:                                             ; preds = %6344
  %6357 = load i32, ptr %67, align 4, !tbaa !9
  br label %6360

6358:                                             ; preds = %6344
  %6359 = load i32, ptr %64, align 4, !tbaa !9
  br label %6360

6360:                                             ; preds = %6358, %6356
  %6361 = phi i32 [ %6357, %6356 ], [ %6359, %6358 ]
  store i32 %6361, ptr %108, align 4, !tbaa !9
  %6362 = load i32, ptr %124, align 4, !tbaa !9
  store i32 %6362, ptr %67, align 4, !tbaa !9
  %6363 = load i32, ptr %106, align 4, !tbaa !9
  %6364 = load i32, ptr %95, align 4, !tbaa !9
  %6365 = sub nsw i32 %6364, 1
  %6366 = shl i32 %6365, 1
  %6367 = add nsw i32 %6363, %6366
  %6368 = load i32, ptr %105, align 4, !tbaa !9
  %6369 = sub nsw i32 %6367, %6368
  %6370 = add nsw i32 %6369, 5
  store i32 %6370, ptr %64, align 4, !tbaa !9
  %6371 = load i32, ptr %67, align 4, !tbaa !9
  %6372 = load i32, ptr %64, align 4, !tbaa !9
  %6373 = icmp sle i32 %6371, %6372
  br i1 %6373, label %6374, label %6376

6374:                                             ; preds = %6360
  %6375 = load i32, ptr %67, align 4, !tbaa !9
  br label %6378

6376:                                             ; preds = %6360
  %6377 = load i32, ptr %64, align 4, !tbaa !9
  br label %6378

6378:                                             ; preds = %6376, %6374
  %6379 = phi i32 [ %6375, %6374 ], [ %6377, %6376 ]
  store i32 %6379, ptr %110, align 4, !tbaa !9
  %6380 = load i32, ptr %110, align 4, !tbaa !9
  store i32 %6380, ptr %67, align 4, !tbaa !9
  %6381 = load i32, ptr %108, align 4, !tbaa !9
  store i32 %6381, ptr %99, align 4, !tbaa !9
  br label %6382

6382:                                             ; preds = %6816, %6378
  %6383 = load i32, ptr %99, align 4, !tbaa !9
  %6384 = load i32, ptr %67, align 4, !tbaa !9
  %6385 = icmp sle i32 %6383, %6384
  br i1 %6385, label %6386, label %6819

6386:                                             ; preds = %6382
  %6387 = load i32, ptr %101, align 4, !tbaa !9
  %6388 = load i32, ptr %53, align 4, !tbaa !9
  %6389 = mul nsw i32 %6387, %6388
  %6390 = add nsw i32 %6389, 1
  store i32 %6390, ptr %64, align 4, !tbaa !9
  %6391 = load i32, ptr %99, align 4, !tbaa !9
  %6392 = load i32, ptr %125, align 4, !tbaa !9
  %6393 = add nsw i32 %6392, 1
  %6394 = load i32, ptr %51, align 4, !tbaa !9
  %6395 = mul nsw i32 %6393, %6394
  %6396 = add nsw i32 %6391, %6395
  store i32 %6396, ptr %65, align 4, !tbaa !9
  %6397 = load i32, ptr %101, align 4, !tbaa !9
  %6398 = load i32, ptr %53, align 4, !tbaa !9
  %6399 = mul nsw i32 %6397, %6398
  %6400 = add nsw i32 %6399, 2
  store i32 %6400, ptr %68, align 4, !tbaa !9
  %6401 = load i32, ptr %99, align 4, !tbaa !9
  %6402 = load i32, ptr %125, align 4, !tbaa !9
  %6403 = add nsw i32 %6402, 2
  %6404 = load i32, ptr %51, align 4, !tbaa !9
  %6405 = mul nsw i32 %6403, %6404
  %6406 = add nsw i32 %6401, %6405
  store i32 %6406, ptr %69, align 4, !tbaa !9
  %6407 = load ptr, ptr %39, align 8, !tbaa !5
  %6408 = load i32, ptr %68, align 4, !tbaa !9
  %6409 = sext i32 %6408 to i64
  %6410 = getelementptr inbounds %struct.doublecomplex, ptr %6407, i64 %6409
  %6411 = getelementptr inbounds %struct.doublecomplex, ptr %6410, i32 0, i32 0
  %6412 = load double, ptr %6411, align 8, !tbaa !13
  %6413 = load ptr, ptr %41, align 8, !tbaa !5
  %6414 = load i32, ptr %69, align 4, !tbaa !9
  %6415 = sext i32 %6414 to i64
  %6416 = getelementptr inbounds %struct.doublecomplex, ptr %6413, i64 %6415
  %6417 = getelementptr inbounds %struct.doublecomplex, ptr %6416, i32 0, i32 0
  %6418 = load double, ptr %6417, align 8, !tbaa !13
  %6419 = load ptr, ptr %39, align 8, !tbaa !5
  %6420 = load i32, ptr %68, align 4, !tbaa !9
  %6421 = sext i32 %6420 to i64
  %6422 = getelementptr inbounds %struct.doublecomplex, ptr %6419, i64 %6421
  %6423 = getelementptr inbounds %struct.doublecomplex, ptr %6422, i32 0, i32 1
  %6424 = load double, ptr %6423, align 8, !tbaa !15
  %6425 = load ptr, ptr %41, align 8, !tbaa !5
  %6426 = load i32, ptr %69, align 4, !tbaa !9
  %6427 = sext i32 %6426 to i64
  %6428 = getelementptr inbounds %struct.doublecomplex, ptr %6425, i64 %6427
  %6429 = getelementptr inbounds %struct.doublecomplex, ptr %6428, i32 0, i32 1
  %6430 = load double, ptr %6429, align 8, !tbaa !15
  %6431 = fmul double %6424, %6430
  %6432 = fneg double %6431
  %6433 = call double @llvm.fmuladd.f64(double %6412, double %6418, double %6432)
  %6434 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %6433, ptr %6434, align 8, !tbaa !13
  %6435 = load ptr, ptr %39, align 8, !tbaa !5
  %6436 = load i32, ptr %68, align 4, !tbaa !9
  %6437 = sext i32 %6436 to i64
  %6438 = getelementptr inbounds %struct.doublecomplex, ptr %6435, i64 %6437
  %6439 = getelementptr inbounds %struct.doublecomplex, ptr %6438, i32 0, i32 0
  %6440 = load double, ptr %6439, align 8, !tbaa !13
  %6441 = load ptr, ptr %41, align 8, !tbaa !5
  %6442 = load i32, ptr %69, align 4, !tbaa !9
  %6443 = sext i32 %6442 to i64
  %6444 = getelementptr inbounds %struct.doublecomplex, ptr %6441, i64 %6443
  %6445 = getelementptr inbounds %struct.doublecomplex, ptr %6444, i32 0, i32 1
  %6446 = load double, ptr %6445, align 8, !tbaa !15
  %6447 = load ptr, ptr %39, align 8, !tbaa !5
  %6448 = load i32, ptr %68, align 4, !tbaa !9
  %6449 = sext i32 %6448 to i64
  %6450 = getelementptr inbounds %struct.doublecomplex, ptr %6447, i64 %6449
  %6451 = getelementptr inbounds %struct.doublecomplex, ptr %6450, i32 0, i32 1
  %6452 = load double, ptr %6451, align 8, !tbaa !15
  %6453 = load ptr, ptr %41, align 8, !tbaa !5
  %6454 = load i32, ptr %69, align 4, !tbaa !9
  %6455 = sext i32 %6454 to i64
  %6456 = getelementptr inbounds %struct.doublecomplex, ptr %6453, i64 %6455
  %6457 = getelementptr inbounds %struct.doublecomplex, ptr %6456, i32 0, i32 0
  %6458 = load double, ptr %6457, align 8, !tbaa !13
  %6459 = fmul double %6452, %6458
  %6460 = call double @llvm.fmuladd.f64(double %6440, double %6446, double %6459)
  %6461 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %6460, ptr %6461, align 8, !tbaa !15
  %6462 = load ptr, ptr %41, align 8, !tbaa !5
  %6463 = load i32, ptr %65, align 4, !tbaa !9
  %6464 = sext i32 %6463 to i64
  %6465 = getelementptr inbounds %struct.doublecomplex, ptr %6462, i64 %6464
  %6466 = getelementptr inbounds %struct.doublecomplex, ptr %6465, i32 0, i32 0
  %6467 = load double, ptr %6466, align 8, !tbaa !13
  %6468 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %6469 = load double, ptr %6468, align 8, !tbaa !13
  %6470 = fadd double %6467, %6469
  %6471 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %6470, ptr %6471, align 8, !tbaa !13
  %6472 = load ptr, ptr %41, align 8, !tbaa !5
  %6473 = load i32, ptr %65, align 4, !tbaa !9
  %6474 = sext i32 %6473 to i64
  %6475 = getelementptr inbounds %struct.doublecomplex, ptr %6472, i64 %6474
  %6476 = getelementptr inbounds %struct.doublecomplex, ptr %6475, i32 0, i32 1
  %6477 = load double, ptr %6476, align 8, !tbaa !15
  %6478 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %6479 = load double, ptr %6478, align 8, !tbaa !15
  %6480 = fadd double %6477, %6479
  %6481 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %6480, ptr %6481, align 8, !tbaa !15
  %6482 = load i32, ptr %101, align 4, !tbaa !9
  %6483 = load i32, ptr %53, align 4, !tbaa !9
  %6484 = mul nsw i32 %6482, %6483
  %6485 = add nsw i32 %6484, 3
  store i32 %6485, ptr %70, align 4, !tbaa !9
  %6486 = load i32, ptr %99, align 4, !tbaa !9
  %6487 = load i32, ptr %125, align 4, !tbaa !9
  %6488 = add nsw i32 %6487, 3
  %6489 = load i32, ptr %51, align 4, !tbaa !9
  %6490 = mul nsw i32 %6488, %6489
  %6491 = add nsw i32 %6486, %6490
  store i32 %6491, ptr %71, align 4, !tbaa !9
  %6492 = load ptr, ptr %39, align 8, !tbaa !5
  %6493 = load i32, ptr %70, align 4, !tbaa !9
  %6494 = sext i32 %6493 to i64
  %6495 = getelementptr inbounds %struct.doublecomplex, ptr %6492, i64 %6494
  %6496 = getelementptr inbounds %struct.doublecomplex, ptr %6495, i32 0, i32 0
  %6497 = load double, ptr %6496, align 8, !tbaa !13
  %6498 = load ptr, ptr %41, align 8, !tbaa !5
  %6499 = load i32, ptr %71, align 4, !tbaa !9
  %6500 = sext i32 %6499 to i64
  %6501 = getelementptr inbounds %struct.doublecomplex, ptr %6498, i64 %6500
  %6502 = getelementptr inbounds %struct.doublecomplex, ptr %6501, i32 0, i32 0
  %6503 = load double, ptr %6502, align 8, !tbaa !13
  %6504 = load ptr, ptr %39, align 8, !tbaa !5
  %6505 = load i32, ptr %70, align 4, !tbaa !9
  %6506 = sext i32 %6505 to i64
  %6507 = getelementptr inbounds %struct.doublecomplex, ptr %6504, i64 %6506
  %6508 = getelementptr inbounds %struct.doublecomplex, ptr %6507, i32 0, i32 1
  %6509 = load double, ptr %6508, align 8, !tbaa !15
  %6510 = load ptr, ptr %41, align 8, !tbaa !5
  %6511 = load i32, ptr %71, align 4, !tbaa !9
  %6512 = sext i32 %6511 to i64
  %6513 = getelementptr inbounds %struct.doublecomplex, ptr %6510, i64 %6512
  %6514 = getelementptr inbounds %struct.doublecomplex, ptr %6513, i32 0, i32 1
  %6515 = load double, ptr %6514, align 8, !tbaa !15
  %6516 = fmul double %6509, %6515
  %6517 = fneg double %6516
  %6518 = call double @llvm.fmuladd.f64(double %6497, double %6503, double %6517)
  %6519 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %6518, ptr %6519, align 8, !tbaa !13
  %6520 = load ptr, ptr %39, align 8, !tbaa !5
  %6521 = load i32, ptr %70, align 4, !tbaa !9
  %6522 = sext i32 %6521 to i64
  %6523 = getelementptr inbounds %struct.doublecomplex, ptr %6520, i64 %6522
  %6524 = getelementptr inbounds %struct.doublecomplex, ptr %6523, i32 0, i32 0
  %6525 = load double, ptr %6524, align 8, !tbaa !13
  %6526 = load ptr, ptr %41, align 8, !tbaa !5
  %6527 = load i32, ptr %71, align 4, !tbaa !9
  %6528 = sext i32 %6527 to i64
  %6529 = getelementptr inbounds %struct.doublecomplex, ptr %6526, i64 %6528
  %6530 = getelementptr inbounds %struct.doublecomplex, ptr %6529, i32 0, i32 1
  %6531 = load double, ptr %6530, align 8, !tbaa !15
  %6532 = load ptr, ptr %39, align 8, !tbaa !5
  %6533 = load i32, ptr %70, align 4, !tbaa !9
  %6534 = sext i32 %6533 to i64
  %6535 = getelementptr inbounds %struct.doublecomplex, ptr %6532, i64 %6534
  %6536 = getelementptr inbounds %struct.doublecomplex, ptr %6535, i32 0, i32 1
  %6537 = load double, ptr %6536, align 8, !tbaa !15
  %6538 = load ptr, ptr %41, align 8, !tbaa !5
  %6539 = load i32, ptr %71, align 4, !tbaa !9
  %6540 = sext i32 %6539 to i64
  %6541 = getelementptr inbounds %struct.doublecomplex, ptr %6538, i64 %6540
  %6542 = getelementptr inbounds %struct.doublecomplex, ptr %6541, i32 0, i32 0
  %6543 = load double, ptr %6542, align 8, !tbaa !13
  %6544 = fmul double %6537, %6543
  %6545 = call double @llvm.fmuladd.f64(double %6525, double %6531, double %6544)
  %6546 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %6545, ptr %6546, align 8, !tbaa !15
  %6547 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6548 = load double, ptr %6547, align 8, !tbaa !13
  %6549 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %6550 = load double, ptr %6549, align 8, !tbaa !13
  %6551 = fadd double %6548, %6550
  %6552 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %6551, ptr %6552, align 8, !tbaa !13
  %6553 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6554 = load double, ptr %6553, align 8, !tbaa !15
  %6555 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %6556 = load double, ptr %6555, align 8, !tbaa !15
  %6557 = fadd double %6554, %6556
  %6558 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %6557, ptr %6558, align 8, !tbaa !15
  %6559 = load ptr, ptr %39, align 8, !tbaa !5
  %6560 = load i32, ptr %64, align 4, !tbaa !9
  %6561 = sext i32 %6560 to i64
  %6562 = getelementptr inbounds %struct.doublecomplex, ptr %6559, i64 %6561
  %6563 = getelementptr inbounds %struct.doublecomplex, ptr %6562, i32 0, i32 0
  %6564 = load double, ptr %6563, align 8, !tbaa !13
  %6565 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6566 = load double, ptr %6565, align 8, !tbaa !13
  %6567 = load ptr, ptr %39, align 8, !tbaa !5
  %6568 = load i32, ptr %64, align 4, !tbaa !9
  %6569 = sext i32 %6568 to i64
  %6570 = getelementptr inbounds %struct.doublecomplex, ptr %6567, i64 %6569
  %6571 = getelementptr inbounds %struct.doublecomplex, ptr %6570, i32 0, i32 1
  %6572 = load double, ptr %6571, align 8, !tbaa !15
  %6573 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6574 = load double, ptr %6573, align 8, !tbaa !15
  %6575 = fmul double %6572, %6574
  %6576 = fneg double %6575
  %6577 = call double @llvm.fmuladd.f64(double %6564, double %6566, double %6576)
  %6578 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6577, ptr %6578, align 8, !tbaa !13
  %6579 = load ptr, ptr %39, align 8, !tbaa !5
  %6580 = load i32, ptr %64, align 4, !tbaa !9
  %6581 = sext i32 %6580 to i64
  %6582 = getelementptr inbounds %struct.doublecomplex, ptr %6579, i64 %6581
  %6583 = getelementptr inbounds %struct.doublecomplex, ptr %6582, i32 0, i32 0
  %6584 = load double, ptr %6583, align 8, !tbaa !13
  %6585 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6586 = load double, ptr %6585, align 8, !tbaa !15
  %6587 = load ptr, ptr %39, align 8, !tbaa !5
  %6588 = load i32, ptr %64, align 4, !tbaa !9
  %6589 = sext i32 %6588 to i64
  %6590 = getelementptr inbounds %struct.doublecomplex, ptr %6587, i64 %6589
  %6591 = getelementptr inbounds %struct.doublecomplex, ptr %6590, i32 0, i32 1
  %6592 = load double, ptr %6591, align 8, !tbaa !15
  %6593 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6594 = load double, ptr %6593, align 8, !tbaa !13
  %6595 = fmul double %6592, %6594
  %6596 = call double @llvm.fmuladd.f64(double %6584, double %6586, double %6595)
  %6597 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6596, ptr %6597, align 8, !tbaa !15
  %6598 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6599 = load double, ptr %6598, align 8, !tbaa !13
  %6600 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %6599, ptr %6600, align 8, !tbaa !13
  %6601 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6602 = load double, ptr %6601, align 8, !tbaa !15
  %6603 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %6602, ptr %6603, align 8, !tbaa !15
  %6604 = load i32, ptr %99, align 4, !tbaa !9
  %6605 = load i32, ptr %125, align 4, !tbaa !9
  %6606 = add nsw i32 %6605, 1
  %6607 = load i32, ptr %51, align 4, !tbaa !9
  %6608 = mul nsw i32 %6606, %6607
  %6609 = add nsw i32 %6604, %6608
  store i32 %6609, ptr %64, align 4, !tbaa !9
  %6610 = load i32, ptr %99, align 4, !tbaa !9
  %6611 = load i32, ptr %125, align 4, !tbaa !9
  %6612 = add nsw i32 %6611, 1
  %6613 = load i32, ptr %51, align 4, !tbaa !9
  %6614 = mul nsw i32 %6612, %6613
  %6615 = add nsw i32 %6610, %6614
  store i32 %6615, ptr %65, align 4, !tbaa !9
  %6616 = load ptr, ptr %41, align 8, !tbaa !5
  %6617 = load i32, ptr %65, align 4, !tbaa !9
  %6618 = sext i32 %6617 to i64
  %6619 = getelementptr inbounds %struct.doublecomplex, ptr %6616, i64 %6618
  %6620 = getelementptr inbounds %struct.doublecomplex, ptr %6619, i32 0, i32 0
  %6621 = load double, ptr %6620, align 8, !tbaa !13
  %6622 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6623 = load double, ptr %6622, align 8, !tbaa !13
  %6624 = fsub double %6621, %6623
  %6625 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6624, ptr %6625, align 8, !tbaa !13
  %6626 = load ptr, ptr %41, align 8, !tbaa !5
  %6627 = load i32, ptr %65, align 4, !tbaa !9
  %6628 = sext i32 %6627 to i64
  %6629 = getelementptr inbounds %struct.doublecomplex, ptr %6626, i64 %6628
  %6630 = getelementptr inbounds %struct.doublecomplex, ptr %6629, i32 0, i32 1
  %6631 = load double, ptr %6630, align 8, !tbaa !15
  %6632 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6633 = load double, ptr %6632, align 8, !tbaa !15
  %6634 = fsub double %6631, %6633
  %6635 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6634, ptr %6635, align 8, !tbaa !15
  %6636 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6637 = load double, ptr %6636, align 8, !tbaa !13
  %6638 = load ptr, ptr %41, align 8, !tbaa !5
  %6639 = load i32, ptr %64, align 4, !tbaa !9
  %6640 = sext i32 %6639 to i64
  %6641 = getelementptr inbounds %struct.doublecomplex, ptr %6638, i64 %6640
  %6642 = getelementptr inbounds %struct.doublecomplex, ptr %6641, i32 0, i32 0
  store double %6637, ptr %6642, align 8, !tbaa !13
  %6643 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6644 = load double, ptr %6643, align 8, !tbaa !15
  %6645 = load ptr, ptr %41, align 8, !tbaa !5
  %6646 = load i32, ptr %64, align 4, !tbaa !9
  %6647 = sext i32 %6646 to i64
  %6648 = getelementptr inbounds %struct.doublecomplex, ptr %6645, i64 %6647
  %6649 = getelementptr inbounds %struct.doublecomplex, ptr %6648, i32 0, i32 1
  store double %6644, ptr %6649, align 8, !tbaa !15
  %6650 = load i32, ptr %99, align 4, !tbaa !9
  %6651 = load i32, ptr %125, align 4, !tbaa !9
  %6652 = add nsw i32 %6651, 2
  %6653 = load i32, ptr %51, align 4, !tbaa !9
  %6654 = mul nsw i32 %6652, %6653
  %6655 = add nsw i32 %6650, %6654
  store i32 %6655, ptr %64, align 4, !tbaa !9
  %6656 = load i32, ptr %99, align 4, !tbaa !9
  %6657 = load i32, ptr %125, align 4, !tbaa !9
  %6658 = add nsw i32 %6657, 2
  %6659 = load i32, ptr %51, align 4, !tbaa !9
  %6660 = mul nsw i32 %6658, %6659
  %6661 = add nsw i32 %6656, %6660
  store i32 %6661, ptr %65, align 4, !tbaa !9
  %6662 = load ptr, ptr %39, align 8, !tbaa !5
  %6663 = load i32, ptr %101, align 4, !tbaa !9
  %6664 = load i32, ptr %53, align 4, !tbaa !9
  %6665 = mul nsw i32 %6663, %6664
  %6666 = add nsw i32 %6665, 2
  %6667 = sext i32 %6666 to i64
  %6668 = getelementptr inbounds %struct.doublecomplex, ptr %6662, i64 %6667
  %6669 = call { double, double } @Cd(ptr noundef %6668)
  %6670 = extractvalue { double, double } %6669, 0
  %6671 = extractvalue { double, double } %6669, 1
  %6672 = fneg double %6671
  %6673 = call ptr @_pCd(ptr noundef %84)
  %6674 = getelementptr inbounds { double, double }, ptr %6673, i32 0, i32 0
  %6675 = getelementptr inbounds { double, double }, ptr %6673, i32 0, i32 1
  store double %6670, ptr %6674, align 8
  store double %6672, ptr %6675, align 8
  %6676 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6677 = load double, ptr %6676, align 8, !tbaa !13
  %6678 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6679 = load double, ptr %6678, align 8, !tbaa !13
  %6680 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6681 = load double, ptr %6680, align 8, !tbaa !15
  %6682 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6683 = load double, ptr %6682, align 8, !tbaa !15
  %6684 = fmul double %6681, %6683
  %6685 = fneg double %6684
  %6686 = call double @llvm.fmuladd.f64(double %6677, double %6679, double %6685)
  %6687 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %6686, ptr %6687, align 8, !tbaa !13
  %6688 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6689 = load double, ptr %6688, align 8, !tbaa !13
  %6690 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6691 = load double, ptr %6690, align 8, !tbaa !15
  %6692 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6693 = load double, ptr %6692, align 8, !tbaa !15
  %6694 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6695 = load double, ptr %6694, align 8, !tbaa !13
  %6696 = fmul double %6693, %6695
  %6697 = call double @llvm.fmuladd.f64(double %6689, double %6691, double %6696)
  %6698 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %6697, ptr %6698, align 8, !tbaa !15
  %6699 = load ptr, ptr %41, align 8, !tbaa !5
  %6700 = load i32, ptr %65, align 4, !tbaa !9
  %6701 = sext i32 %6700 to i64
  %6702 = getelementptr inbounds %struct.doublecomplex, ptr %6699, i64 %6701
  %6703 = getelementptr inbounds %struct.doublecomplex, ptr %6702, i32 0, i32 0
  %6704 = load double, ptr %6703, align 8, !tbaa !13
  %6705 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6706 = load double, ptr %6705, align 8, !tbaa !13
  %6707 = fsub double %6704, %6706
  %6708 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6707, ptr %6708, align 8, !tbaa !13
  %6709 = load ptr, ptr %41, align 8, !tbaa !5
  %6710 = load i32, ptr %65, align 4, !tbaa !9
  %6711 = sext i32 %6710 to i64
  %6712 = getelementptr inbounds %struct.doublecomplex, ptr %6709, i64 %6711
  %6713 = getelementptr inbounds %struct.doublecomplex, ptr %6712, i32 0, i32 1
  %6714 = load double, ptr %6713, align 8, !tbaa !15
  %6715 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6716 = load double, ptr %6715, align 8, !tbaa !15
  %6717 = fsub double %6714, %6716
  %6718 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6717, ptr %6718, align 8, !tbaa !15
  %6719 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6720 = load double, ptr %6719, align 8, !tbaa !13
  %6721 = load ptr, ptr %41, align 8, !tbaa !5
  %6722 = load i32, ptr %64, align 4, !tbaa !9
  %6723 = sext i32 %6722 to i64
  %6724 = getelementptr inbounds %struct.doublecomplex, ptr %6721, i64 %6723
  %6725 = getelementptr inbounds %struct.doublecomplex, ptr %6724, i32 0, i32 0
  store double %6720, ptr %6725, align 8, !tbaa !13
  %6726 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6727 = load double, ptr %6726, align 8, !tbaa !15
  %6728 = load ptr, ptr %41, align 8, !tbaa !5
  %6729 = load i32, ptr %64, align 4, !tbaa !9
  %6730 = sext i32 %6729 to i64
  %6731 = getelementptr inbounds %struct.doublecomplex, ptr %6728, i64 %6730
  %6732 = getelementptr inbounds %struct.doublecomplex, ptr %6731, i32 0, i32 1
  store double %6727, ptr %6732, align 8, !tbaa !15
  %6733 = load i32, ptr %99, align 4, !tbaa !9
  %6734 = load i32, ptr %125, align 4, !tbaa !9
  %6735 = add nsw i32 %6734, 3
  %6736 = load i32, ptr %51, align 4, !tbaa !9
  %6737 = mul nsw i32 %6735, %6736
  %6738 = add nsw i32 %6733, %6737
  store i32 %6738, ptr %64, align 4, !tbaa !9
  %6739 = load i32, ptr %99, align 4, !tbaa !9
  %6740 = load i32, ptr %125, align 4, !tbaa !9
  %6741 = add nsw i32 %6740, 3
  %6742 = load i32, ptr %51, align 4, !tbaa !9
  %6743 = mul nsw i32 %6741, %6742
  %6744 = add nsw i32 %6739, %6743
  store i32 %6744, ptr %65, align 4, !tbaa !9
  %6745 = load ptr, ptr %39, align 8, !tbaa !5
  %6746 = load i32, ptr %101, align 4, !tbaa !9
  %6747 = load i32, ptr %53, align 4, !tbaa !9
  %6748 = mul nsw i32 %6746, %6747
  %6749 = add nsw i32 %6748, 3
  %6750 = sext i32 %6749 to i64
  %6751 = getelementptr inbounds %struct.doublecomplex, ptr %6745, i64 %6750
  %6752 = call { double, double } @Cd(ptr noundef %6751)
  %6753 = extractvalue { double, double } %6752, 0
  %6754 = extractvalue { double, double } %6752, 1
  %6755 = fneg double %6754
  %6756 = call ptr @_pCd(ptr noundef %84)
  %6757 = getelementptr inbounds { double, double }, ptr %6756, i32 0, i32 0
  %6758 = getelementptr inbounds { double, double }, ptr %6756, i32 0, i32 1
  store double %6753, ptr %6757, align 8
  store double %6755, ptr %6758, align 8
  %6759 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6760 = load double, ptr %6759, align 8, !tbaa !13
  %6761 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6762 = load double, ptr %6761, align 8, !tbaa !13
  %6763 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6764 = load double, ptr %6763, align 8, !tbaa !15
  %6765 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6766 = load double, ptr %6765, align 8, !tbaa !15
  %6767 = fmul double %6764, %6766
  %6768 = fneg double %6767
  %6769 = call double @llvm.fmuladd.f64(double %6760, double %6762, double %6768)
  %6770 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %6769, ptr %6770, align 8, !tbaa !13
  %6771 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %6772 = load double, ptr %6771, align 8, !tbaa !13
  %6773 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %6774 = load double, ptr %6773, align 8, !tbaa !15
  %6775 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %6776 = load double, ptr %6775, align 8, !tbaa !15
  %6777 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %6778 = load double, ptr %6777, align 8, !tbaa !13
  %6779 = fmul double %6776, %6778
  %6780 = call double @llvm.fmuladd.f64(double %6772, double %6774, double %6779)
  %6781 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %6780, ptr %6781, align 8, !tbaa !15
  %6782 = load ptr, ptr %41, align 8, !tbaa !5
  %6783 = load i32, ptr %65, align 4, !tbaa !9
  %6784 = sext i32 %6783 to i64
  %6785 = getelementptr inbounds %struct.doublecomplex, ptr %6782, i64 %6784
  %6786 = getelementptr inbounds %struct.doublecomplex, ptr %6785, i32 0, i32 0
  %6787 = load double, ptr %6786, align 8, !tbaa !13
  %6788 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %6789 = load double, ptr %6788, align 8, !tbaa !13
  %6790 = fsub double %6787, %6789
  %6791 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %6790, ptr %6791, align 8, !tbaa !13
  %6792 = load ptr, ptr %41, align 8, !tbaa !5
  %6793 = load i32, ptr %65, align 4, !tbaa !9
  %6794 = sext i32 %6793 to i64
  %6795 = getelementptr inbounds %struct.doublecomplex, ptr %6792, i64 %6794
  %6796 = getelementptr inbounds %struct.doublecomplex, ptr %6795, i32 0, i32 1
  %6797 = load double, ptr %6796, align 8, !tbaa !15
  %6798 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %6799 = load double, ptr %6798, align 8, !tbaa !15
  %6800 = fsub double %6797, %6799
  %6801 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %6800, ptr %6801, align 8, !tbaa !15
  %6802 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %6803 = load double, ptr %6802, align 8, !tbaa !13
  %6804 = load ptr, ptr %41, align 8, !tbaa !5
  %6805 = load i32, ptr %64, align 4, !tbaa !9
  %6806 = sext i32 %6805 to i64
  %6807 = getelementptr inbounds %struct.doublecomplex, ptr %6804, i64 %6806
  %6808 = getelementptr inbounds %struct.doublecomplex, ptr %6807, i32 0, i32 0
  store double %6803, ptr %6808, align 8, !tbaa !13
  %6809 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %6810 = load double, ptr %6809, align 8, !tbaa !15
  %6811 = load ptr, ptr %41, align 8, !tbaa !5
  %6812 = load i32, ptr %64, align 4, !tbaa !9
  %6813 = sext i32 %6812 to i64
  %6814 = getelementptr inbounds %struct.doublecomplex, ptr %6811, i64 %6813
  %6815 = getelementptr inbounds %struct.doublecomplex, ptr %6814, i32 0, i32 1
  store double %6810, ptr %6815, align 8, !tbaa !15
  br label %6816

6816:                                             ; preds = %6386
  %6817 = load i32, ptr %99, align 4, !tbaa !9
  %6818 = add nsw i32 %6817, 1
  store i32 %6818, ptr %99, align 4, !tbaa !9
  br label %6382, !llvm.loop !25

6819:                                             ; preds = %6382
  br label %6820

6820:                                             ; preds = %6819
  %6821 = load i32, ptr %101, align 4, !tbaa !9
  %6822 = add nsw i32 %6821, -1
  store i32 %6822, ptr %101, align 4, !tbaa !9
  br label %6320, !llvm.loop !26

6823:                                             ; preds = %6320
  br label %7288

6824:                                             ; preds = %6314
  %6825 = load ptr, ptr %26, align 8, !tbaa !5
  %6826 = load i32, ptr %6825, align 4, !tbaa !9
  %6827 = icmp ne i32 %6826, 0
  br i1 %6827, label %6828, label %7287

6828:                                             ; preds = %6824
  %6829 = load i32, ptr %98, align 4, !tbaa !9
  store i32 %6829, ptr %66, align 4, !tbaa !9
  %6830 = load i32, ptr %95, align 4, !tbaa !9
  store i32 %6830, ptr %101, align 4, !tbaa !9
  br label %6831

6831:                                             ; preds = %7283, %6828
  %6832 = load i32, ptr %101, align 4, !tbaa !9
  %6833 = load i32, ptr %66, align 4, !tbaa !9
  %6834 = icmp sge i32 %6832, %6833
  br i1 %6834, label %6835, label %7286

6835:                                             ; preds = %6831
  %6836 = load i32, ptr %106, align 4, !tbaa !9
  %6837 = load i32, ptr %101, align 4, !tbaa !9
  %6838 = sub nsw i32 %6837, 1
  %6839 = shl i32 %6838, 1
  %6840 = add nsw i32 %6836, %6839
  store i32 %6840, ptr %100, align 4, !tbaa !9
  %6841 = load ptr, ptr %36, align 8, !tbaa !5
  %6842 = load i32, ptr %6841, align 4, !tbaa !9
  store i32 %6842, ptr %67, align 4, !tbaa !9
  %6843 = load ptr, ptr %35, align 8, !tbaa !5
  %6844 = load i32, ptr %6843, align 4, !tbaa !9
  store i32 %6844, ptr %99, align 4, !tbaa !9
  br label %6845

6845:                                             ; preds = %7279, %6835
  %6846 = load i32, ptr %99, align 4, !tbaa !9
  %6847 = load i32, ptr %67, align 4, !tbaa !9
  %6848 = icmp sle i32 %6846, %6847
  br i1 %6848, label %6849, label %7282

6849:                                             ; preds = %6845
  %6850 = load i32, ptr %101, align 4, !tbaa !9
  %6851 = load i32, ptr %53, align 4, !tbaa !9
  %6852 = mul nsw i32 %6850, %6851
  %6853 = add nsw i32 %6852, 1
  store i32 %6853, ptr %64, align 4, !tbaa !9
  %6854 = load i32, ptr %99, align 4, !tbaa !9
  %6855 = load i32, ptr %100, align 4, !tbaa !9
  %6856 = add nsw i32 %6855, 1
  %6857 = load i32, ptr %59, align 4, !tbaa !9
  %6858 = mul nsw i32 %6856, %6857
  %6859 = add nsw i32 %6854, %6858
  store i32 %6859, ptr %65, align 4, !tbaa !9
  %6860 = load i32, ptr %101, align 4, !tbaa !9
  %6861 = load i32, ptr %53, align 4, !tbaa !9
  %6862 = mul nsw i32 %6860, %6861
  %6863 = add nsw i32 %6862, 2
  store i32 %6863, ptr %68, align 4, !tbaa !9
  %6864 = load i32, ptr %99, align 4, !tbaa !9
  %6865 = load i32, ptr %100, align 4, !tbaa !9
  %6866 = add nsw i32 %6865, 2
  %6867 = load i32, ptr %59, align 4, !tbaa !9
  %6868 = mul nsw i32 %6866, %6867
  %6869 = add nsw i32 %6864, %6868
  store i32 %6869, ptr %69, align 4, !tbaa !9
  %6870 = load ptr, ptr %39, align 8, !tbaa !5
  %6871 = load i32, ptr %68, align 4, !tbaa !9
  %6872 = sext i32 %6871 to i64
  %6873 = getelementptr inbounds %struct.doublecomplex, ptr %6870, i64 %6872
  %6874 = getelementptr inbounds %struct.doublecomplex, ptr %6873, i32 0, i32 0
  %6875 = load double, ptr %6874, align 8, !tbaa !13
  %6876 = load ptr, ptr %37, align 8, !tbaa !5
  %6877 = load i32, ptr %69, align 4, !tbaa !9
  %6878 = sext i32 %6877 to i64
  %6879 = getelementptr inbounds %struct.doublecomplex, ptr %6876, i64 %6878
  %6880 = getelementptr inbounds %struct.doublecomplex, ptr %6879, i32 0, i32 0
  %6881 = load double, ptr %6880, align 8, !tbaa !13
  %6882 = load ptr, ptr %39, align 8, !tbaa !5
  %6883 = load i32, ptr %68, align 4, !tbaa !9
  %6884 = sext i32 %6883 to i64
  %6885 = getelementptr inbounds %struct.doublecomplex, ptr %6882, i64 %6884
  %6886 = getelementptr inbounds %struct.doublecomplex, ptr %6885, i32 0, i32 1
  %6887 = load double, ptr %6886, align 8, !tbaa !15
  %6888 = load ptr, ptr %37, align 8, !tbaa !5
  %6889 = load i32, ptr %69, align 4, !tbaa !9
  %6890 = sext i32 %6889 to i64
  %6891 = getelementptr inbounds %struct.doublecomplex, ptr %6888, i64 %6890
  %6892 = getelementptr inbounds %struct.doublecomplex, ptr %6891, i32 0, i32 1
  %6893 = load double, ptr %6892, align 8, !tbaa !15
  %6894 = fmul double %6887, %6893
  %6895 = fneg double %6894
  %6896 = call double @llvm.fmuladd.f64(double %6875, double %6881, double %6895)
  %6897 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  store double %6896, ptr %6897, align 8, !tbaa !13
  %6898 = load ptr, ptr %39, align 8, !tbaa !5
  %6899 = load i32, ptr %68, align 4, !tbaa !9
  %6900 = sext i32 %6899 to i64
  %6901 = getelementptr inbounds %struct.doublecomplex, ptr %6898, i64 %6900
  %6902 = getelementptr inbounds %struct.doublecomplex, ptr %6901, i32 0, i32 0
  %6903 = load double, ptr %6902, align 8, !tbaa !13
  %6904 = load ptr, ptr %37, align 8, !tbaa !5
  %6905 = load i32, ptr %69, align 4, !tbaa !9
  %6906 = sext i32 %6905 to i64
  %6907 = getelementptr inbounds %struct.doublecomplex, ptr %6904, i64 %6906
  %6908 = getelementptr inbounds %struct.doublecomplex, ptr %6907, i32 0, i32 1
  %6909 = load double, ptr %6908, align 8, !tbaa !15
  %6910 = load ptr, ptr %39, align 8, !tbaa !5
  %6911 = load i32, ptr %68, align 4, !tbaa !9
  %6912 = sext i32 %6911 to i64
  %6913 = getelementptr inbounds %struct.doublecomplex, ptr %6910, i64 %6912
  %6914 = getelementptr inbounds %struct.doublecomplex, ptr %6913, i32 0, i32 1
  %6915 = load double, ptr %6914, align 8, !tbaa !15
  %6916 = load ptr, ptr %37, align 8, !tbaa !5
  %6917 = load i32, ptr %69, align 4, !tbaa !9
  %6918 = sext i32 %6917 to i64
  %6919 = getelementptr inbounds %struct.doublecomplex, ptr %6916, i64 %6918
  %6920 = getelementptr inbounds %struct.doublecomplex, ptr %6919, i32 0, i32 0
  %6921 = load double, ptr %6920, align 8, !tbaa !13
  %6922 = fmul double %6915, %6921
  %6923 = call double @llvm.fmuladd.f64(double %6903, double %6909, double %6922)
  %6924 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  store double %6923, ptr %6924, align 8, !tbaa !15
  %6925 = load ptr, ptr %37, align 8, !tbaa !5
  %6926 = load i32, ptr %65, align 4, !tbaa !9
  %6927 = sext i32 %6926 to i64
  %6928 = getelementptr inbounds %struct.doublecomplex, ptr %6925, i64 %6927
  %6929 = getelementptr inbounds %struct.doublecomplex, ptr %6928, i32 0, i32 0
  %6930 = load double, ptr %6929, align 8, !tbaa !13
  %6931 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 0
  %6932 = load double, ptr %6931, align 8, !tbaa !13
  %6933 = fadd double %6930, %6932
  %6934 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  store double %6933, ptr %6934, align 8, !tbaa !13
  %6935 = load ptr, ptr %37, align 8, !tbaa !5
  %6936 = load i32, ptr %65, align 4, !tbaa !9
  %6937 = sext i32 %6936 to i64
  %6938 = getelementptr inbounds %struct.doublecomplex, ptr %6935, i64 %6937
  %6939 = getelementptr inbounds %struct.doublecomplex, ptr %6938, i32 0, i32 1
  %6940 = load double, ptr %6939, align 8, !tbaa !15
  %6941 = getelementptr inbounds %struct.doublecomplex, ptr %85, i32 0, i32 1
  %6942 = load double, ptr %6941, align 8, !tbaa !15
  %6943 = fadd double %6940, %6942
  %6944 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  store double %6943, ptr %6944, align 8, !tbaa !15
  %6945 = load i32, ptr %101, align 4, !tbaa !9
  %6946 = load i32, ptr %53, align 4, !tbaa !9
  %6947 = mul nsw i32 %6945, %6946
  %6948 = add nsw i32 %6947, 3
  store i32 %6948, ptr %70, align 4, !tbaa !9
  %6949 = load i32, ptr %99, align 4, !tbaa !9
  %6950 = load i32, ptr %100, align 4, !tbaa !9
  %6951 = add nsw i32 %6950, 3
  %6952 = load i32, ptr %59, align 4, !tbaa !9
  %6953 = mul nsw i32 %6951, %6952
  %6954 = add nsw i32 %6949, %6953
  store i32 %6954, ptr %71, align 4, !tbaa !9
  %6955 = load ptr, ptr %39, align 8, !tbaa !5
  %6956 = load i32, ptr %70, align 4, !tbaa !9
  %6957 = sext i32 %6956 to i64
  %6958 = getelementptr inbounds %struct.doublecomplex, ptr %6955, i64 %6957
  %6959 = getelementptr inbounds %struct.doublecomplex, ptr %6958, i32 0, i32 0
  %6960 = load double, ptr %6959, align 8, !tbaa !13
  %6961 = load ptr, ptr %37, align 8, !tbaa !5
  %6962 = load i32, ptr %71, align 4, !tbaa !9
  %6963 = sext i32 %6962 to i64
  %6964 = getelementptr inbounds %struct.doublecomplex, ptr %6961, i64 %6963
  %6965 = getelementptr inbounds %struct.doublecomplex, ptr %6964, i32 0, i32 0
  %6966 = load double, ptr %6965, align 8, !tbaa !13
  %6967 = load ptr, ptr %39, align 8, !tbaa !5
  %6968 = load i32, ptr %70, align 4, !tbaa !9
  %6969 = sext i32 %6968 to i64
  %6970 = getelementptr inbounds %struct.doublecomplex, ptr %6967, i64 %6969
  %6971 = getelementptr inbounds %struct.doublecomplex, ptr %6970, i32 0, i32 1
  %6972 = load double, ptr %6971, align 8, !tbaa !15
  %6973 = load ptr, ptr %37, align 8, !tbaa !5
  %6974 = load i32, ptr %71, align 4, !tbaa !9
  %6975 = sext i32 %6974 to i64
  %6976 = getelementptr inbounds %struct.doublecomplex, ptr %6973, i64 %6975
  %6977 = getelementptr inbounds %struct.doublecomplex, ptr %6976, i32 0, i32 1
  %6978 = load double, ptr %6977, align 8, !tbaa !15
  %6979 = fmul double %6972, %6978
  %6980 = fneg double %6979
  %6981 = call double @llvm.fmuladd.f64(double %6960, double %6966, double %6980)
  %6982 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  store double %6981, ptr %6982, align 8, !tbaa !13
  %6983 = load ptr, ptr %39, align 8, !tbaa !5
  %6984 = load i32, ptr %70, align 4, !tbaa !9
  %6985 = sext i32 %6984 to i64
  %6986 = getelementptr inbounds %struct.doublecomplex, ptr %6983, i64 %6985
  %6987 = getelementptr inbounds %struct.doublecomplex, ptr %6986, i32 0, i32 0
  %6988 = load double, ptr %6987, align 8, !tbaa !13
  %6989 = load ptr, ptr %37, align 8, !tbaa !5
  %6990 = load i32, ptr %71, align 4, !tbaa !9
  %6991 = sext i32 %6990 to i64
  %6992 = getelementptr inbounds %struct.doublecomplex, ptr %6989, i64 %6991
  %6993 = getelementptr inbounds %struct.doublecomplex, ptr %6992, i32 0, i32 1
  %6994 = load double, ptr %6993, align 8, !tbaa !15
  %6995 = load ptr, ptr %39, align 8, !tbaa !5
  %6996 = load i32, ptr %70, align 4, !tbaa !9
  %6997 = sext i32 %6996 to i64
  %6998 = getelementptr inbounds %struct.doublecomplex, ptr %6995, i64 %6997
  %6999 = getelementptr inbounds %struct.doublecomplex, ptr %6998, i32 0, i32 1
  %7000 = load double, ptr %6999, align 8, !tbaa !15
  %7001 = load ptr, ptr %37, align 8, !tbaa !5
  %7002 = load i32, ptr %71, align 4, !tbaa !9
  %7003 = sext i32 %7002 to i64
  %7004 = getelementptr inbounds %struct.doublecomplex, ptr %7001, i64 %7003
  %7005 = getelementptr inbounds %struct.doublecomplex, ptr %7004, i32 0, i32 0
  %7006 = load double, ptr %7005, align 8, !tbaa !13
  %7007 = fmul double %7000, %7006
  %7008 = call double @llvm.fmuladd.f64(double %6988, double %6994, double %7007)
  %7009 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  store double %7008, ptr %7009, align 8, !tbaa !15
  %7010 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %7011 = load double, ptr %7010, align 8, !tbaa !13
  %7012 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 0
  %7013 = load double, ptr %7012, align 8, !tbaa !13
  %7014 = fadd double %7011, %7013
  %7015 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %7014, ptr %7015, align 8, !tbaa !13
  %7016 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %7017 = load double, ptr %7016, align 8, !tbaa !15
  %7018 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %7019 = load double, ptr %7018, align 8, !tbaa !15
  %7020 = fadd double %7017, %7019
  %7021 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %7020, ptr %7021, align 8, !tbaa !15
  %7022 = load ptr, ptr %39, align 8, !tbaa !5
  %7023 = load i32, ptr %64, align 4, !tbaa !9
  %7024 = sext i32 %7023 to i64
  %7025 = getelementptr inbounds %struct.doublecomplex, ptr %7022, i64 %7024
  %7026 = getelementptr inbounds %struct.doublecomplex, ptr %7025, i32 0, i32 0
  %7027 = load double, ptr %7026, align 8, !tbaa !13
  %7028 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %7029 = load double, ptr %7028, align 8, !tbaa !13
  %7030 = load ptr, ptr %39, align 8, !tbaa !5
  %7031 = load i32, ptr %64, align 4, !tbaa !9
  %7032 = sext i32 %7031 to i64
  %7033 = getelementptr inbounds %struct.doublecomplex, ptr %7030, i64 %7032
  %7034 = getelementptr inbounds %struct.doublecomplex, ptr %7033, i32 0, i32 1
  %7035 = load double, ptr %7034, align 8, !tbaa !15
  %7036 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %7037 = load double, ptr %7036, align 8, !tbaa !15
  %7038 = fmul double %7035, %7037
  %7039 = fneg double %7038
  %7040 = call double @llvm.fmuladd.f64(double %7027, double %7029, double %7039)
  %7041 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %7040, ptr %7041, align 8, !tbaa !13
  %7042 = load ptr, ptr %39, align 8, !tbaa !5
  %7043 = load i32, ptr %64, align 4, !tbaa !9
  %7044 = sext i32 %7043 to i64
  %7045 = getelementptr inbounds %struct.doublecomplex, ptr %7042, i64 %7044
  %7046 = getelementptr inbounds %struct.doublecomplex, ptr %7045, i32 0, i32 0
  %7047 = load double, ptr %7046, align 8, !tbaa !13
  %7048 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %7049 = load double, ptr %7048, align 8, !tbaa !15
  %7050 = load ptr, ptr %39, align 8, !tbaa !5
  %7051 = load i32, ptr %64, align 4, !tbaa !9
  %7052 = sext i32 %7051 to i64
  %7053 = getelementptr inbounds %struct.doublecomplex, ptr %7050, i64 %7052
  %7054 = getelementptr inbounds %struct.doublecomplex, ptr %7053, i32 0, i32 1
  %7055 = load double, ptr %7054, align 8, !tbaa !15
  %7056 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %7057 = load double, ptr %7056, align 8, !tbaa !13
  %7058 = fmul double %7055, %7057
  %7059 = call double @llvm.fmuladd.f64(double %7047, double %7049, double %7058)
  %7060 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %7059, ptr %7060, align 8, !tbaa !15
  %7061 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %7062 = load double, ptr %7061, align 8, !tbaa !13
  %7063 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  store double %7062, ptr %7063, align 8, !tbaa !13
  %7064 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %7065 = load double, ptr %7064, align 8, !tbaa !15
  %7066 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  store double %7065, ptr %7066, align 8, !tbaa !15
  %7067 = load i32, ptr %99, align 4, !tbaa !9
  %7068 = load i32, ptr %100, align 4, !tbaa !9
  %7069 = add nsw i32 %7068, 1
  %7070 = load i32, ptr %59, align 4, !tbaa !9
  %7071 = mul nsw i32 %7069, %7070
  %7072 = add nsw i32 %7067, %7071
  store i32 %7072, ptr %64, align 4, !tbaa !9
  %7073 = load i32, ptr %99, align 4, !tbaa !9
  %7074 = load i32, ptr %100, align 4, !tbaa !9
  %7075 = add nsw i32 %7074, 1
  %7076 = load i32, ptr %59, align 4, !tbaa !9
  %7077 = mul nsw i32 %7075, %7076
  %7078 = add nsw i32 %7073, %7077
  store i32 %7078, ptr %65, align 4, !tbaa !9
  %7079 = load ptr, ptr %37, align 8, !tbaa !5
  %7080 = load i32, ptr %65, align 4, !tbaa !9
  %7081 = sext i32 %7080 to i64
  %7082 = getelementptr inbounds %struct.doublecomplex, ptr %7079, i64 %7081
  %7083 = getelementptr inbounds %struct.doublecomplex, ptr %7082, i32 0, i32 0
  %7084 = load double, ptr %7083, align 8, !tbaa !13
  %7085 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %7086 = load double, ptr %7085, align 8, !tbaa !13
  %7087 = fsub double %7084, %7086
  %7088 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %7087, ptr %7088, align 8, !tbaa !13
  %7089 = load ptr, ptr %37, align 8, !tbaa !5
  %7090 = load i32, ptr %65, align 4, !tbaa !9
  %7091 = sext i32 %7090 to i64
  %7092 = getelementptr inbounds %struct.doublecomplex, ptr %7089, i64 %7091
  %7093 = getelementptr inbounds %struct.doublecomplex, ptr %7092, i32 0, i32 1
  %7094 = load double, ptr %7093, align 8, !tbaa !15
  %7095 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %7096 = load double, ptr %7095, align 8, !tbaa !15
  %7097 = fsub double %7094, %7096
  %7098 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %7097, ptr %7098, align 8, !tbaa !15
  %7099 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %7100 = load double, ptr %7099, align 8, !tbaa !13
  %7101 = load ptr, ptr %37, align 8, !tbaa !5
  %7102 = load i32, ptr %64, align 4, !tbaa !9
  %7103 = sext i32 %7102 to i64
  %7104 = getelementptr inbounds %struct.doublecomplex, ptr %7101, i64 %7103
  %7105 = getelementptr inbounds %struct.doublecomplex, ptr %7104, i32 0, i32 0
  store double %7100, ptr %7105, align 8, !tbaa !13
  %7106 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %7107 = load double, ptr %7106, align 8, !tbaa !15
  %7108 = load ptr, ptr %37, align 8, !tbaa !5
  %7109 = load i32, ptr %64, align 4, !tbaa !9
  %7110 = sext i32 %7109 to i64
  %7111 = getelementptr inbounds %struct.doublecomplex, ptr %7108, i64 %7110
  %7112 = getelementptr inbounds %struct.doublecomplex, ptr %7111, i32 0, i32 1
  store double %7107, ptr %7112, align 8, !tbaa !15
  %7113 = load i32, ptr %99, align 4, !tbaa !9
  %7114 = load i32, ptr %100, align 4, !tbaa !9
  %7115 = add nsw i32 %7114, 2
  %7116 = load i32, ptr %59, align 4, !tbaa !9
  %7117 = mul nsw i32 %7115, %7116
  %7118 = add nsw i32 %7113, %7117
  store i32 %7118, ptr %64, align 4, !tbaa !9
  %7119 = load i32, ptr %99, align 4, !tbaa !9
  %7120 = load i32, ptr %100, align 4, !tbaa !9
  %7121 = add nsw i32 %7120, 2
  %7122 = load i32, ptr %59, align 4, !tbaa !9
  %7123 = mul nsw i32 %7121, %7122
  %7124 = add nsw i32 %7119, %7123
  store i32 %7124, ptr %65, align 4, !tbaa !9
  %7125 = load ptr, ptr %39, align 8, !tbaa !5
  %7126 = load i32, ptr %101, align 4, !tbaa !9
  %7127 = load i32, ptr %53, align 4, !tbaa !9
  %7128 = mul nsw i32 %7126, %7127
  %7129 = add nsw i32 %7128, 2
  %7130 = sext i32 %7129 to i64
  %7131 = getelementptr inbounds %struct.doublecomplex, ptr %7125, i64 %7130
  %7132 = call { double, double } @Cd(ptr noundef %7131)
  %7133 = extractvalue { double, double } %7132, 0
  %7134 = extractvalue { double, double } %7132, 1
  %7135 = fneg double %7134
  %7136 = call ptr @_pCd(ptr noundef %84)
  %7137 = getelementptr inbounds { double, double }, ptr %7136, i32 0, i32 0
  %7138 = getelementptr inbounds { double, double }, ptr %7136, i32 0, i32 1
  store double %7133, ptr %7137, align 8
  store double %7135, ptr %7138, align 8
  %7139 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %7140 = load double, ptr %7139, align 8, !tbaa !13
  %7141 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %7142 = load double, ptr %7141, align 8, !tbaa !13
  %7143 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %7144 = load double, ptr %7143, align 8, !tbaa !15
  %7145 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %7146 = load double, ptr %7145, align 8, !tbaa !15
  %7147 = fmul double %7144, %7146
  %7148 = fneg double %7147
  %7149 = call double @llvm.fmuladd.f64(double %7140, double %7142, double %7148)
  %7150 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %7149, ptr %7150, align 8, !tbaa !13
  %7151 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %7152 = load double, ptr %7151, align 8, !tbaa !13
  %7153 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %7154 = load double, ptr %7153, align 8, !tbaa !15
  %7155 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %7156 = load double, ptr %7155, align 8, !tbaa !15
  %7157 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %7158 = load double, ptr %7157, align 8, !tbaa !13
  %7159 = fmul double %7156, %7158
  %7160 = call double @llvm.fmuladd.f64(double %7152, double %7154, double %7159)
  %7161 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %7160, ptr %7161, align 8, !tbaa !15
  %7162 = load ptr, ptr %37, align 8, !tbaa !5
  %7163 = load i32, ptr %65, align 4, !tbaa !9
  %7164 = sext i32 %7163 to i64
  %7165 = getelementptr inbounds %struct.doublecomplex, ptr %7162, i64 %7164
  %7166 = getelementptr inbounds %struct.doublecomplex, ptr %7165, i32 0, i32 0
  %7167 = load double, ptr %7166, align 8, !tbaa !13
  %7168 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %7169 = load double, ptr %7168, align 8, !tbaa !13
  %7170 = fsub double %7167, %7169
  %7171 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %7170, ptr %7171, align 8, !tbaa !13
  %7172 = load ptr, ptr %37, align 8, !tbaa !5
  %7173 = load i32, ptr %65, align 4, !tbaa !9
  %7174 = sext i32 %7173 to i64
  %7175 = getelementptr inbounds %struct.doublecomplex, ptr %7172, i64 %7174
  %7176 = getelementptr inbounds %struct.doublecomplex, ptr %7175, i32 0, i32 1
  %7177 = load double, ptr %7176, align 8, !tbaa !15
  %7178 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %7179 = load double, ptr %7178, align 8, !tbaa !15
  %7180 = fsub double %7177, %7179
  %7181 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %7180, ptr %7181, align 8, !tbaa !15
  %7182 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %7183 = load double, ptr %7182, align 8, !tbaa !13
  %7184 = load ptr, ptr %37, align 8, !tbaa !5
  %7185 = load i32, ptr %64, align 4, !tbaa !9
  %7186 = sext i32 %7185 to i64
  %7187 = getelementptr inbounds %struct.doublecomplex, ptr %7184, i64 %7186
  %7188 = getelementptr inbounds %struct.doublecomplex, ptr %7187, i32 0, i32 0
  store double %7183, ptr %7188, align 8, !tbaa !13
  %7189 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %7190 = load double, ptr %7189, align 8, !tbaa !15
  %7191 = load ptr, ptr %37, align 8, !tbaa !5
  %7192 = load i32, ptr %64, align 4, !tbaa !9
  %7193 = sext i32 %7192 to i64
  %7194 = getelementptr inbounds %struct.doublecomplex, ptr %7191, i64 %7193
  %7195 = getelementptr inbounds %struct.doublecomplex, ptr %7194, i32 0, i32 1
  store double %7190, ptr %7195, align 8, !tbaa !15
  %7196 = load i32, ptr %99, align 4, !tbaa !9
  %7197 = load i32, ptr %100, align 4, !tbaa !9
  %7198 = add nsw i32 %7197, 3
  %7199 = load i32, ptr %59, align 4, !tbaa !9
  %7200 = mul nsw i32 %7198, %7199
  %7201 = add nsw i32 %7196, %7200
  store i32 %7201, ptr %64, align 4, !tbaa !9
  %7202 = load i32, ptr %99, align 4, !tbaa !9
  %7203 = load i32, ptr %100, align 4, !tbaa !9
  %7204 = add nsw i32 %7203, 3
  %7205 = load i32, ptr %59, align 4, !tbaa !9
  %7206 = mul nsw i32 %7204, %7205
  %7207 = add nsw i32 %7202, %7206
  store i32 %7207, ptr %65, align 4, !tbaa !9
  %7208 = load ptr, ptr %39, align 8, !tbaa !5
  %7209 = load i32, ptr %101, align 4, !tbaa !9
  %7210 = load i32, ptr %53, align 4, !tbaa !9
  %7211 = mul nsw i32 %7209, %7210
  %7212 = add nsw i32 %7211, 3
  %7213 = sext i32 %7212 to i64
  %7214 = getelementptr inbounds %struct.doublecomplex, ptr %7208, i64 %7213
  %7215 = call { double, double } @Cd(ptr noundef %7214)
  %7216 = extractvalue { double, double } %7215, 0
  %7217 = extractvalue { double, double } %7215, 1
  %7218 = fneg double %7217
  %7219 = call ptr @_pCd(ptr noundef %84)
  %7220 = getelementptr inbounds { double, double }, ptr %7219, i32 0, i32 0
  %7221 = getelementptr inbounds { double, double }, ptr %7219, i32 0, i32 1
  store double %7216, ptr %7220, align 8
  store double %7218, ptr %7221, align 8
  %7222 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %7223 = load double, ptr %7222, align 8, !tbaa !13
  %7224 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %7225 = load double, ptr %7224, align 8, !tbaa !13
  %7226 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %7227 = load double, ptr %7226, align 8, !tbaa !15
  %7228 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %7229 = load double, ptr %7228, align 8, !tbaa !15
  %7230 = fmul double %7227, %7229
  %7231 = fneg double %7230
  %7232 = call double @llvm.fmuladd.f64(double %7223, double %7225, double %7231)
  %7233 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  store double %7232, ptr %7233, align 8, !tbaa !13
  %7234 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %7235 = load double, ptr %7234, align 8, !tbaa !13
  %7236 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 1
  %7237 = load double, ptr %7236, align 8, !tbaa !15
  %7238 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 1
  %7239 = load double, ptr %7238, align 8, !tbaa !15
  %7240 = getelementptr inbounds %struct.doublecomplex, ptr %84, i32 0, i32 0
  %7241 = load double, ptr %7240, align 8, !tbaa !13
  %7242 = fmul double %7239, %7241
  %7243 = call double @llvm.fmuladd.f64(double %7235, double %7237, double %7242)
  %7244 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  store double %7243, ptr %7244, align 8, !tbaa !15
  %7245 = load ptr, ptr %37, align 8, !tbaa !5
  %7246 = load i32, ptr %65, align 4, !tbaa !9
  %7247 = sext i32 %7246 to i64
  %7248 = getelementptr inbounds %struct.doublecomplex, ptr %7245, i64 %7247
  %7249 = getelementptr inbounds %struct.doublecomplex, ptr %7248, i32 0, i32 0
  %7250 = load double, ptr %7249, align 8, !tbaa !13
  %7251 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 0
  %7252 = load double, ptr %7251, align 8, !tbaa !13
  %7253 = fsub double %7250, %7252
  %7254 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  store double %7253, ptr %7254, align 8, !tbaa !13
  %7255 = load ptr, ptr %37, align 8, !tbaa !5
  %7256 = load i32, ptr %65, align 4, !tbaa !9
  %7257 = sext i32 %7256 to i64
  %7258 = getelementptr inbounds %struct.doublecomplex, ptr %7255, i64 %7257
  %7259 = getelementptr inbounds %struct.doublecomplex, ptr %7258, i32 0, i32 1
  %7260 = load double, ptr %7259, align 8, !tbaa !15
  %7261 = getelementptr inbounds %struct.doublecomplex, ptr %83, i32 0, i32 1
  %7262 = load double, ptr %7261, align 8, !tbaa !15
  %7263 = fsub double %7260, %7262
  %7264 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  store double %7263, ptr %7264, align 8, !tbaa !15
  %7265 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 0
  %7266 = load double, ptr %7265, align 8, !tbaa !13
  %7267 = load ptr, ptr %37, align 8, !tbaa !5
  %7268 = load i32, ptr %64, align 4, !tbaa !9
  %7269 = sext i32 %7268 to i64
  %7270 = getelementptr inbounds %struct.doublecomplex, ptr %7267, i64 %7269
  %7271 = getelementptr inbounds %struct.doublecomplex, ptr %7270, i32 0, i32 0
  store double %7266, ptr %7271, align 8, !tbaa !13
  %7272 = getelementptr inbounds %struct.doublecomplex, ptr %82, i32 0, i32 1
  %7273 = load double, ptr %7272, align 8, !tbaa !15
  %7274 = load ptr, ptr %37, align 8, !tbaa !5
  %7275 = load i32, ptr %64, align 4, !tbaa !9
  %7276 = sext i32 %7275 to i64
  %7277 = getelementptr inbounds %struct.doublecomplex, ptr %7274, i64 %7276
  %7278 = getelementptr inbounds %struct.doublecomplex, ptr %7277, i32 0, i32 1
  store double %7273, ptr %7278, align 8, !tbaa !15
  br label %7279

7279:                                             ; preds = %6849
  %7280 = load i32, ptr %99, align 4, !tbaa !9
  %7281 = add nsw i32 %7280, 1
  store i32 %7281, ptr %99, align 4, !tbaa !9
  br label %6845, !llvm.loop !27

7282:                                             ; preds = %6845
  br label %7283

7283:                                             ; preds = %7282
  %7284 = load i32, ptr %101, align 4, !tbaa !9
  %7285 = add nsw i32 %7284, -1
  store i32 %7285, ptr %101, align 4, !tbaa !9
  br label %6831, !llvm.loop !28

7286:                                             ; preds = %6831
  br label %7287

7287:                                             ; preds = %7286, %6824
  br label %7288

7288:                                             ; preds = %7287, %6823
  br label %7289

7289:                                             ; preds = %7288
  %7290 = load i32, ptr %106, align 4, !tbaa !9
  %7291 = add nsw i32 %7290, 1
  store i32 %7291, ptr %106, align 4, !tbaa !9
  br label %343, !llvm.loop !29

7292:                                             ; preds = %343
  %7293 = load i32, ptr %103, align 4, !tbaa !9
  %7294 = icmp ne i32 %7293, 0
  br i1 %7294, label %7295, label %7624

7295:                                             ; preds = %7292
  %7296 = load ptr, ptr %25, align 8, !tbaa !5
  %7297 = load i32, ptr %7296, align 4, !tbaa !9
  %7298 = icmp ne i32 %7297, 0
  br i1 %7298, label %7299, label %7302

7299:                                             ; preds = %7295
  store i32 1, ptr %96, align 4, !tbaa !9
  %7300 = load ptr, ptr %28, align 8, !tbaa !5
  %7301 = load i32, ptr %7300, align 4, !tbaa !9
  store i32 %7301, ptr %94, align 4, !tbaa !9
  br label %7307

7302:                                             ; preds = %7295
  %7303 = load ptr, ptr %29, align 8, !tbaa !5
  %7304 = load i32, ptr %7303, align 4, !tbaa !9
  store i32 %7304, ptr %96, align 4, !tbaa !9
  %7305 = load ptr, ptr %30, align 8, !tbaa !5
  %7306 = load i32, ptr %7305, align 4, !tbaa !9
  store i32 %7306, ptr %94, align 4, !tbaa !9
  br label %7307

7307:                                             ; preds = %7302, %7299
  store i32 1, ptr %63, align 4, !tbaa !9
  %7308 = load ptr, ptr %29, align 8, !tbaa !5
  %7309 = load i32, ptr %7308, align 4, !tbaa !9
  %7310 = load i32, ptr %105, align 4, !tbaa !9
  %7311 = sub nsw i32 %7309, %7310
  store i32 %7311, ptr %66, align 4, !tbaa !9
  %7312 = load i32, ptr %63, align 4, !tbaa !9
  %7313 = load i32, ptr %66, align 4, !tbaa !9
  %7314 = icmp sge i32 %7312, %7313
  br i1 %7314, label %7315, label %7317

7315:                                             ; preds = %7307
  %7316 = load i32, ptr %63, align 4, !tbaa !9
  br label %7319

7317:                                             ; preds = %7307
  %7318 = load i32, ptr %66, align 4, !tbaa !9
  br label %7319

7319:                                             ; preds = %7317, %7315
  %7320 = phi i32 [ %7316, %7315 ], [ %7318, %7317 ]
  store i32 %7320, ptr %109, align 4, !tbaa !9
  store i32 0, ptr %63, align 4, !tbaa !9
  %7321 = load i32, ptr %104, align 4, !tbaa !9
  %7322 = load ptr, ptr %30, align 8, !tbaa !5
  %7323 = load i32, ptr %7322, align 4, !tbaa !9
  %7324 = sub nsw i32 %7321, %7323
  store i32 %7324, ptr %66, align 4, !tbaa !9
  %7325 = load i32, ptr %124, align 4, !tbaa !9
  %7326 = load i32, ptr %63, align 4, !tbaa !9
  %7327 = load i32, ptr %66, align 4, !tbaa !9
  %7328 = icmp sge i32 %7326, %7327
  br i1 %7328, label %7329, label %7331

7329:                                             ; preds = %7319
  %7330 = load i32, ptr %63, align 4, !tbaa !9
  br label %7333

7331:                                             ; preds = %7319
  %7332 = load i32, ptr %66, align 4, !tbaa !9
  br label %7333

7333:                                             ; preds = %7331, %7329
  %7334 = phi i32 [ %7330, %7329 ], [ %7332, %7331 ]
  %7335 = sub nsw i32 %7325, %7334
  %7336 = load i32, ptr %109, align 4, !tbaa !9
  %7337 = sub nsw i32 %7335, %7336
  %7338 = add nsw i32 %7337, 1
  store i32 %7338, ptr %117, align 4, !tbaa !9
  %7339 = load i32, ptr %94, align 4, !tbaa !9
  store i32 %7339, ptr %63, align 4, !tbaa !9
  %7340 = load ptr, ptr %46, align 8, !tbaa !5
  %7341 = load i32, ptr %7340, align 4, !tbaa !9
  store i32 %7341, ptr %66, align 4, !tbaa !9
  %7342 = load i32, ptr %104, align 4, !tbaa !9
  %7343 = load ptr, ptr %30, align 8, !tbaa !5
  %7344 = load i32, ptr %7343, align 4, !tbaa !9
  %7345 = icmp sle i32 %7342, %7344
  br i1 %7345, label %7346, label %7348

7346:                                             ; preds = %7333
  %7347 = load i32, ptr %104, align 4, !tbaa !9
  br label %7351

7348:                                             ; preds = %7333
  %7349 = load ptr, ptr %30, align 8, !tbaa !5
  %7350 = load i32, ptr %7349, align 4, !tbaa !9
  br label %7351

7351:                                             ; preds = %7348, %7346
  %7352 = phi i32 [ %7347, %7346 ], [ %7350, %7348 ]
  %7353 = add nsw i32 %7352, 1
  store i32 %7353, ptr %92, align 4, !tbaa !9
  br label %7354

7354:                                             ; preds = %7427, %7351
  %7355 = load i32, ptr %66, align 4, !tbaa !9
  %7356 = icmp slt i32 %7355, 0
  br i1 %7356, label %7357, label %7362

7357:                                             ; preds = %7354
  %7358 = load i32, ptr %92, align 4, !tbaa !9
  %7359 = load i32, ptr %63, align 4, !tbaa !9
  %7360 = icmp sge i32 %7358, %7359
  %7361 = zext i1 %7360 to i32
  br label %7367

7362:                                             ; preds = %7354
  %7363 = load i32, ptr %92, align 4, !tbaa !9
  %7364 = load i32, ptr %63, align 4, !tbaa !9
  %7365 = icmp sle i32 %7363, %7364
  %7366 = zext i1 %7365 to i32
  br label %7367

7367:                                             ; preds = %7362, %7357
  %7368 = phi i32 [ %7361, %7357 ], [ %7366, %7362 ]
  %7369 = icmp ne i32 %7368, 0
  br i1 %7369, label %7370, label %7431

7370:                                             ; preds = %7367
  %7371 = load ptr, ptr %46, align 8, !tbaa !5
  %7372 = load i32, ptr %7371, align 4, !tbaa !9
  store i32 %7372, ptr %67, align 4, !tbaa !9
  %7373 = load i32, ptr %94, align 4, !tbaa !9
  %7374 = load i32, ptr %92, align 4, !tbaa !9
  %7375 = sub nsw i32 %7373, %7374
  %7376 = add nsw i32 %7375, 1
  store i32 %7376, ptr %64, align 4, !tbaa !9
  %7377 = load i32, ptr %67, align 4, !tbaa !9
  %7378 = load i32, ptr %64, align 4, !tbaa !9
  %7379 = icmp sle i32 %7377, %7378
  br i1 %7379, label %7380, label %7382

7380:                                             ; preds = %7370
  %7381 = load i32, ptr %67, align 4, !tbaa !9
  br label %7384

7382:                                             ; preds = %7370
  %7383 = load i32, ptr %64, align 4, !tbaa !9
  br label %7384

7384:                                             ; preds = %7382, %7380
  %7385 = phi i32 [ %7381, %7380 ], [ %7383, %7382 ]
  store i32 %7385, ptr %93, align 4, !tbaa !9
  %7386 = load ptr, ptr %41, align 8, !tbaa !5
  %7387 = load i32, ptr %109, align 4, !tbaa !9
  %7388 = load i32, ptr %109, align 4, !tbaa !9
  %7389 = load i32, ptr %51, align 4, !tbaa !9
  %7390 = mul nsw i32 %7388, %7389
  %7391 = add nsw i32 %7387, %7390
  %7392 = sext i32 %7391 to i64
  %7393 = getelementptr inbounds %struct.doublecomplex, ptr %7386, i64 %7392
  %7394 = load ptr, ptr %42, align 8, !tbaa !5
  %7395 = load ptr, ptr %33, align 8, !tbaa !5
  %7396 = load i32, ptr %105, align 4, !tbaa !9
  %7397 = load i32, ptr %109, align 4, !tbaa !9
  %7398 = add nsw i32 %7396, %7397
  %7399 = load i32, ptr %92, align 4, !tbaa !9
  %7400 = load i32, ptr %49, align 4, !tbaa !9
  %7401 = mul nsw i32 %7399, %7400
  %7402 = add nsw i32 %7398, %7401
  %7403 = sext i32 %7402 to i64
  %7404 = getelementptr inbounds %struct.doublecomplex, ptr %7395, i64 %7403
  %7405 = load ptr, ptr %34, align 8, !tbaa !5
  %7406 = load ptr, ptr %47, align 8, !tbaa !5
  %7407 = load i32, ptr %56, align 4, !tbaa !9
  %7408 = sext i32 %7407 to i64
  %7409 = getelementptr inbounds %struct.doublecomplex, ptr %7406, i64 %7408
  %7410 = load ptr, ptr %48, align 8, !tbaa !5
  call void @zgemm_(ptr noundef @.str.3, ptr noundef @.str.4, ptr noundef %117, ptr noundef %93, ptr noundef %117, ptr noundef @c_b2, ptr noundef %7393, ptr noundef %7394, ptr noundef %7404, ptr noundef %7405, ptr noundef @c_b1, ptr noundef %7409, ptr noundef %7410)
  %7411 = load ptr, ptr %47, align 8, !tbaa !5
  %7412 = load i32, ptr %56, align 4, !tbaa !9
  %7413 = sext i32 %7412 to i64
  %7414 = getelementptr inbounds %struct.doublecomplex, ptr %7411, i64 %7413
  %7415 = load ptr, ptr %48, align 8, !tbaa !5
  %7416 = load ptr, ptr %33, align 8, !tbaa !5
  %7417 = load i32, ptr %105, align 4, !tbaa !9
  %7418 = load i32, ptr %109, align 4, !tbaa !9
  %7419 = add nsw i32 %7417, %7418
  %7420 = load i32, ptr %92, align 4, !tbaa !9
  %7421 = load i32, ptr %49, align 4, !tbaa !9
  %7422 = mul nsw i32 %7420, %7421
  %7423 = add nsw i32 %7419, %7422
  %7424 = sext i32 %7423 to i64
  %7425 = getelementptr inbounds %struct.doublecomplex, ptr %7416, i64 %7424
  %7426 = load ptr, ptr %34, align 8, !tbaa !5
  call void @zlacpy_(ptr noundef @.str.2, ptr noundef %117, ptr noundef %93, ptr noundef %7414, ptr noundef %7415, ptr noundef %7425, ptr noundef %7426)
  br label %7427

7427:                                             ; preds = %7384
  %7428 = load i32, ptr %66, align 4, !tbaa !9
  %7429 = load i32, ptr %92, align 4, !tbaa !9
  %7430 = add nsw i32 %7429, %7428
  store i32 %7430, ptr %92, align 4, !tbaa !9
  br label %7354, !llvm.loop !30

7431:                                             ; preds = %7367
  %7432 = load ptr, ptr %29, align 8, !tbaa !5
  %7433 = load i32, ptr %7432, align 4, !tbaa !9
  %7434 = load i32, ptr %105, align 4, !tbaa !9
  %7435 = icmp sge i32 %7433, %7434
  br i1 %7435, label %7436, label %7439

7436:                                             ; preds = %7431
  %7437 = load ptr, ptr %29, align 8, !tbaa !5
  %7438 = load i32, ptr %7437, align 4, !tbaa !9
  br label %7441

7439:                                             ; preds = %7431
  %7440 = load i32, ptr %105, align 4, !tbaa !9
  br label %7441

7441:                                             ; preds = %7439, %7436
  %7442 = phi i32 [ %7438, %7436 ], [ %7440, %7439 ]
  %7443 = sub nsw i32 %7442, 1
  store i32 %7443, ptr %66, align 4, !tbaa !9
  %7444 = load ptr, ptr %43, align 8, !tbaa !5
  %7445 = load i32, ptr %7444, align 4, !tbaa !9
  store i32 %7445, ptr %63, align 4, !tbaa !9
  %7446 = load i32, ptr %96, align 4, !tbaa !9
  store i32 %7446, ptr %97, align 4, !tbaa !9
  br label %7447

7447:                                             ; preds = %7529, %7441
  %7448 = load i32, ptr %63, align 4, !tbaa !9
  %7449 = icmp slt i32 %7448, 0
  br i1 %7449, label %7450, label %7455

7450:                                             ; preds = %7447
  %7451 = load i32, ptr %97, align 4, !tbaa !9
  %7452 = load i32, ptr %66, align 4, !tbaa !9
  %7453 = icmp sge i32 %7451, %7452
  %7454 = zext i1 %7453 to i32
  br label %7460

7455:                                             ; preds = %7447
  %7456 = load i32, ptr %97, align 4, !tbaa !9
  %7457 = load i32, ptr %66, align 4, !tbaa !9
  %7458 = icmp sle i32 %7456, %7457
  %7459 = zext i1 %7458 to i32
  br label %7460

7460:                                             ; preds = %7455, %7450
  %7461 = phi i32 [ %7454, %7450 ], [ %7459, %7455 ]
  %7462 = icmp ne i32 %7461, 0
  br i1 %7462, label %7463, label %7533

7463:                                             ; preds = %7460
  %7464 = load ptr, ptr %43, align 8, !tbaa !5
  %7465 = load i32, ptr %7464, align 4, !tbaa !9
  store i32 %7465, ptr %67, align 4, !tbaa !9
  %7466 = load ptr, ptr %29, align 8, !tbaa !5
  %7467 = load i32, ptr %7466, align 4, !tbaa !9
  %7468 = load i32, ptr %105, align 4, !tbaa !9
  %7469 = icmp sge i32 %7467, %7468
  br i1 %7469, label %7470, label %7473

7470:                                             ; preds = %7463
  %7471 = load ptr, ptr %29, align 8, !tbaa !5
  %7472 = load i32, ptr %7471, align 4, !tbaa !9
  br label %7475

7473:                                             ; preds = %7463
  %7474 = load i32, ptr %105, align 4, !tbaa !9
  br label %7475

7475:                                             ; preds = %7473, %7470
  %7476 = phi i32 [ %7472, %7470 ], [ %7474, %7473 ]
  %7477 = load i32, ptr %97, align 4, !tbaa !9
  %7478 = sub nsw i32 %7476, %7477
  store i32 %7478, ptr %64, align 4, !tbaa !9
  %7479 = load i32, ptr %67, align 4, !tbaa !9
  %7480 = load i32, ptr %64, align 4, !tbaa !9
  %7481 = icmp sle i32 %7479, %7480
  br i1 %7481, label %7482, label %7484

7482:                                             ; preds = %7475
  %7483 = load i32, ptr %67, align 4, !tbaa !9
  br label %7486

7484:                                             ; preds = %7475
  %7485 = load i32, ptr %64, align 4, !tbaa !9
  br label %7486

7486:                                             ; preds = %7484, %7482
  %7487 = phi i32 [ %7483, %7482 ], [ %7485, %7484 ]
  store i32 %7487, ptr %93, align 4, !tbaa !9
  %7488 = load ptr, ptr %33, align 8, !tbaa !5
  %7489 = load i32, ptr %97, align 4, !tbaa !9
  %7490 = load i32, ptr %105, align 4, !tbaa !9
  %7491 = load i32, ptr %109, align 4, !tbaa !9
  %7492 = add nsw i32 %7490, %7491
  %7493 = load i32, ptr %49, align 4, !tbaa !9
  %7494 = mul nsw i32 %7492, %7493
  %7495 = add nsw i32 %7489, %7494
  %7496 = sext i32 %7495 to i64
  %7497 = getelementptr inbounds %struct.doublecomplex, ptr %7488, i64 %7496
  %7498 = load ptr, ptr %34, align 8, !tbaa !5
  %7499 = load ptr, ptr %41, align 8, !tbaa !5
  %7500 = load i32, ptr %109, align 4, !tbaa !9
  %7501 = load i32, ptr %109, align 4, !tbaa !9
  %7502 = load i32, ptr %51, align 4, !tbaa !9
  %7503 = mul nsw i32 %7501, %7502
  %7504 = add nsw i32 %7500, %7503
  %7505 = sext i32 %7504 to i64
  %7506 = getelementptr inbounds %struct.doublecomplex, ptr %7499, i64 %7505
  %7507 = load ptr, ptr %42, align 8, !tbaa !5
  %7508 = load ptr, ptr %44, align 8, !tbaa !5
  %7509 = load i32, ptr %58, align 4, !tbaa !9
  %7510 = sext i32 %7509 to i64
  %7511 = getelementptr inbounds %struct.doublecomplex, ptr %7508, i64 %7510
  %7512 = load ptr, ptr %45, align 8, !tbaa !5
  call void @zgemm_(ptr noundef @.str.4, ptr noundef @.str.4, ptr noundef %93, ptr noundef %117, ptr noundef %117, ptr noundef @c_b2, ptr noundef %7497, ptr noundef %7498, ptr noundef %7506, ptr noundef %7507, ptr noundef @c_b1, ptr noundef %7511, ptr noundef %7512)
  %7513 = load ptr, ptr %44, align 8, !tbaa !5
  %7514 = load i32, ptr %58, align 4, !tbaa !9
  %7515 = sext i32 %7514 to i64
  %7516 = getelementptr inbounds %struct.doublecomplex, ptr %7513, i64 %7515
  %7517 = load ptr, ptr %45, align 8, !tbaa !5
  %7518 = load ptr, ptr %33, align 8, !tbaa !5
  %7519 = load i32, ptr %97, align 4, !tbaa !9
  %7520 = load i32, ptr %105, align 4, !tbaa !9
  %7521 = load i32, ptr %109, align 4, !tbaa !9
  %7522 = add nsw i32 %7520, %7521
  %7523 = load i32, ptr %49, align 4, !tbaa !9
  %7524 = mul nsw i32 %7522, %7523
  %7525 = add nsw i32 %7519, %7524
  %7526 = sext i32 %7525 to i64
  %7527 = getelementptr inbounds %struct.doublecomplex, ptr %7518, i64 %7526
  %7528 = load ptr, ptr %34, align 8, !tbaa !5
  call void @zlacpy_(ptr noundef @.str.2, ptr noundef %93, ptr noundef %117, ptr noundef %7516, ptr noundef %7517, ptr noundef %7527, ptr noundef %7528)
  br label %7529

7529:                                             ; preds = %7486
  %7530 = load i32, ptr %63, align 4, !tbaa !9
  %7531 = load i32, ptr %97, align 4, !tbaa !9
  %7532 = add nsw i32 %7531, %7530
  store i32 %7532, ptr %97, align 4, !tbaa !9
  br label %7447, !llvm.loop !31

7533:                                             ; preds = %7460
  %7534 = load ptr, ptr %26, align 8, !tbaa !5
  %7535 = load i32, ptr %7534, align 4, !tbaa !9
  %7536 = icmp ne i32 %7535, 0
  br i1 %7536, label %7537, label %7623

7537:                                             ; preds = %7533
  %7538 = load ptr, ptr %36, align 8, !tbaa !5
  %7539 = load i32, ptr %7538, align 4, !tbaa !9
  store i32 %7539, ptr %63, align 4, !tbaa !9
  %7540 = load ptr, ptr %43, align 8, !tbaa !5
  %7541 = load i32, ptr %7540, align 4, !tbaa !9
  store i32 %7541, ptr %66, align 4, !tbaa !9
  %7542 = load ptr, ptr %35, align 8, !tbaa !5
  %7543 = load i32, ptr %7542, align 4, !tbaa !9
  store i32 %7543, ptr %97, align 4, !tbaa !9
  br label %7544

7544:                                             ; preds = %7618, %7537
  %7545 = load i32, ptr %66, align 4, !tbaa !9
  %7546 = icmp slt i32 %7545, 0
  br i1 %7546, label %7547, label %7552

7547:                                             ; preds = %7544
  %7548 = load i32, ptr %97, align 4, !tbaa !9
  %7549 = load i32, ptr %63, align 4, !tbaa !9
  %7550 = icmp sge i32 %7548, %7549
  %7551 = zext i1 %7550 to i32
  br label %7557

7552:                                             ; preds = %7544
  %7553 = load i32, ptr %97, align 4, !tbaa !9
  %7554 = load i32, ptr %63, align 4, !tbaa !9
  %7555 = icmp sle i32 %7553, %7554
  %7556 = zext i1 %7555 to i32
  br label %7557

7557:                                             ; preds = %7552, %7547
  %7558 = phi i32 [ %7551, %7547 ], [ %7556, %7552 ]
  %7559 = icmp ne i32 %7558, 0
  br i1 %7559, label %7560, label %7622

7560:                                             ; preds = %7557
  %7561 = load ptr, ptr %43, align 8, !tbaa !5
  %7562 = load i32, ptr %7561, align 4, !tbaa !9
  store i32 %7562, ptr %67, align 4, !tbaa !9
  %7563 = load ptr, ptr %36, align 8, !tbaa !5
  %7564 = load i32, ptr %7563, align 4, !tbaa !9
  %7565 = load i32, ptr %97, align 4, !tbaa !9
  %7566 = sub nsw i32 %7564, %7565
  %7567 = add nsw i32 %7566, 1
  store i32 %7567, ptr %64, align 4, !tbaa !9
  %7568 = load i32, ptr %67, align 4, !tbaa !9
  %7569 = load i32, ptr %64, align 4, !tbaa !9
  %7570 = icmp sle i32 %7568, %7569
  br i1 %7570, label %7571, label %7573

7571:                                             ; preds = %7560
  %7572 = load i32, ptr %67, align 4, !tbaa !9
  br label %7575

7573:                                             ; preds = %7560
  %7574 = load i32, ptr %64, align 4, !tbaa !9
  br label %7575

7575:                                             ; preds = %7573, %7571
  %7576 = phi i32 [ %7572, %7571 ], [ %7574, %7573 ]
  store i32 %7576, ptr %93, align 4, !tbaa !9
  %7577 = load ptr, ptr %37, align 8, !tbaa !5
  %7578 = load i32, ptr %97, align 4, !tbaa !9
  %7579 = load i32, ptr %105, align 4, !tbaa !9
  %7580 = load i32, ptr %109, align 4, !tbaa !9
  %7581 = add nsw i32 %7579, %7580
  %7582 = load i32, ptr %59, align 4, !tbaa !9
  %7583 = mul nsw i32 %7581, %7582
  %7584 = add nsw i32 %7578, %7583
  %7585 = sext i32 %7584 to i64
  %7586 = getelementptr inbounds %struct.doublecomplex, ptr %7577, i64 %7585
  %7587 = load ptr, ptr %38, align 8, !tbaa !5
  %7588 = load ptr, ptr %41, align 8, !tbaa !5
  %7589 = load i32, ptr %109, align 4, !tbaa !9
  %7590 = load i32, ptr %109, align 4, !tbaa !9
  %7591 = load i32, ptr %51, align 4, !tbaa !9
  %7592 = mul nsw i32 %7590, %7591
  %7593 = add nsw i32 %7589, %7592
  %7594 = sext i32 %7593 to i64
  %7595 = getelementptr inbounds %struct.doublecomplex, ptr %7588, i64 %7594
  %7596 = load ptr, ptr %42, align 8, !tbaa !5
  %7597 = load ptr, ptr %44, align 8, !tbaa !5
  %7598 = load i32, ptr %58, align 4, !tbaa !9
  %7599 = sext i32 %7598 to i64
  %7600 = getelementptr inbounds %struct.doublecomplex, ptr %7597, i64 %7599
  %7601 = load ptr, ptr %45, align 8, !tbaa !5
  call void @zgemm_(ptr noundef @.str.4, ptr noundef @.str.4, ptr noundef %93, ptr noundef %117, ptr noundef %117, ptr noundef @c_b2, ptr noundef %7586, ptr noundef %7587, ptr noundef %7595, ptr noundef %7596, ptr noundef @c_b1, ptr noundef %7600, ptr noundef %7601)
  %7602 = load ptr, ptr %44, align 8, !tbaa !5
  %7603 = load i32, ptr %58, align 4, !tbaa !9
  %7604 = sext i32 %7603 to i64
  %7605 = getelementptr inbounds %struct.doublecomplex, ptr %7602, i64 %7604
  %7606 = load ptr, ptr %45, align 8, !tbaa !5
  %7607 = load ptr, ptr %37, align 8, !tbaa !5
  %7608 = load i32, ptr %97, align 4, !tbaa !9
  %7609 = load i32, ptr %105, align 4, !tbaa !9
  %7610 = load i32, ptr %109, align 4, !tbaa !9
  %7611 = add nsw i32 %7609, %7610
  %7612 = load i32, ptr %59, align 4, !tbaa !9
  %7613 = mul nsw i32 %7611, %7612
  %7614 = add nsw i32 %7608, %7613
  %7615 = sext i32 %7614 to i64
  %7616 = getelementptr inbounds %struct.doublecomplex, ptr %7607, i64 %7615
  %7617 = load ptr, ptr %38, align 8, !tbaa !5
  call void @zlacpy_(ptr noundef @.str.2, ptr noundef %93, ptr noundef %117, ptr noundef %7605, ptr noundef %7606, ptr noundef %7616, ptr noundef %7617)
  br label %7618

7618:                                             ; preds = %7575
  %7619 = load i32, ptr %66, align 4, !tbaa !9
  %7620 = load i32, ptr %97, align 4, !tbaa !9
  %7621 = add nsw i32 %7620, %7619
  store i32 %7621, ptr %97, align 4, !tbaa !9
  br label %7544, !llvm.loop !32

7622:                                             ; preds = %7557
  br label %7623

7623:                                             ; preds = %7622, %7533
  br label %7624

7624:                                             ; preds = %7623, %7292
  br label %7625

7625:                                             ; preds = %7624
  %7626 = load i32, ptr %62, align 4, !tbaa !9
  %7627 = load i32, ptr %105, align 4, !tbaa !9
  %7628 = add nsw i32 %7627, %7626
  store i32 %7628, ptr %105, align 4, !tbaa !9
  br label %272, !llvm.loop !33

7629:                                             ; preds = %285
  store i32 1, ptr %129, align 4
  br label %7630

7630:                                             ; preds = %7629, %202, %195
  call void @llvm.lifetime.end.p0(i64 8, ptr %128) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %127) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %126) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %125) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %124) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %123) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %122) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %121) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %120) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %119) #5
  call void @llvm.lifetime.end.p0(i64 48, ptr %118) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %117) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %116) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %115) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %114) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %113) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %112) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %111) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %110) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %108) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %102) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %101) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %93) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %90) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %89) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %88) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %87) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %86) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %85) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %84) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %83) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %82) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %78) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %77) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %76) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %74) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %59) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #5
  ret void
}

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

declare double @dlamch_(ptr noundef) #2

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

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

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

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

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

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

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

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

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

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

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

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

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


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

%struct.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [13 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [4 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@c_b2 = external hidden global %struct.doublecomplex, align 8
@c__2 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c__3 = external hidden global i32, align 4
@.str.3 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zlaqr5_(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 nocapture noundef readonly %5, ptr nocapture noundef readonly %6, ptr noundef %7, ptr noundef %8, ptr noundef %9, ptr nocapture noundef readonly %10, ptr nocapture noundef readonly %11, ptr noundef %12, ptr noundef %13, ptr noundef %14, ptr nocapture noundef readonly %15, ptr noundef %16, ptr noundef %17, ptr nocapture noundef readonly %18, ptr noundef %19, ptr noundef %20, ptr nocapture noundef readonly %21, ptr noundef %22, ptr noundef %23) local_unnamed_addr #0 {
  %25 = alloca %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 %struct.doublecomplex, align 16
  %35 = alloca i32, align 4
  %36 = alloca [3 x %struct.doublecomplex], align 16
  %37 = alloca double, align 8
  %38 = alloca double, align 8
  %39 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %25) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %26) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %27) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %28) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %29) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %30) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %31) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %32) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %33) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %34) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %35) #7
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %36) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %37) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %38) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %39) #7
  %40 = getelementptr inbounds i8, ptr %7, i64 -16
  %41 = load i32, ptr %9, align 4, !tbaa !5
  %narrow = xor i32 %41, -1
  %42 = sext i32 %narrow to i64
  %43 = getelementptr inbounds %struct.doublecomplex, ptr %8, i64 %42
  %44 = load i32, ptr %13, align 4, !tbaa !5
  %narrow2384 = xor i32 %44, -1
  %45 = sext i32 %narrow2384 to i64
  %46 = getelementptr inbounds %struct.doublecomplex, ptr %12, i64 %45
  %47 = load i32, ptr %15, align 4, !tbaa !5
  %narrow2385 = xor i32 %47, -1
  %48 = sext i32 %narrow2385 to i64
  %49 = getelementptr inbounds %struct.doublecomplex, ptr %14, i64 %48
  %50 = load i32, ptr %17, align 4, !tbaa !5
  %narrow2390 = xor i32 %50, -1
  %51 = sext i32 %narrow2390 to i64
  %52 = getelementptr inbounds %struct.doublecomplex, ptr %16, i64 %51
  %53 = load i32, ptr %6, align 4, !tbaa !5
  %54 = icmp slt i32 %53, 2
  br i1 %54, label %.loopexit2469, label %55

55:                                               ; preds = %24
  %56 = load i32, ptr %4, align 4, !tbaa !5
  %57 = load i32, ptr %5, align 4, !tbaa !5
  %.not = icmp slt i32 %56, %57
  br i1 %.not, label %58, label %.loopexit2469

58:                                               ; preds = %55
  %59 = tail call double @dlamch_(ptr noundef nonnull @.str) #7
  store double %59, ptr %37, align 8, !tbaa !9
  %60 = fdiv double 1.000000e+00, %59
  store double %60, ptr %38, align 8, !tbaa !9
  call void @dlabad_(ptr noundef nonnull %37, ptr noundef nonnull %38) #7
  %61 = call double @dlamch_(ptr noundef nonnull @.str.1) #7
  %62 = load double, ptr %37, align 8, !tbaa !9
  %63 = load i32, ptr %3, align 4, !tbaa !5
  %64 = sitofp i32 %63 to double
  %65 = fdiv double %64, %61
  %66 = fmul double %62, %65
  %67 = load i32, ptr %2, align 4, !tbaa !5
  %68 = load i32, ptr %4, align 4, !tbaa !5
  %69 = add i32 %68, 2
  %70 = load i32, ptr %5, align 4, !tbaa !5
  %.not2386 = icmp sgt i32 %69, %70
  br i1 %.not2386, label %76, label %71

71:                                               ; preds = %58
  %72 = mul nsw i32 %68, %41
  %73 = add nsw i32 %69, %72
  %74 = sext i32 %73 to i64
  %75 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %74
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %75, i8 0, i64 16, i1 false)
  br label %76

76:                                               ; preds = %71, %58
  %77 = lshr i32 %53, 1
  %78 = shl nuw i32 %77, 2
  store i32 %78, ptr %39, align 4, !tbaa !5
  %79 = add nsw i32 %70, -2
  %80 = and i32 %53, 2147483646
  %reass.sub = sub i32 %68, %80
  %81 = add i32 %reass.sub, 1
  %.not23872542 = icmp sgt i32 %81, %79
  br i1 %.not23872542, label %.loopexit2469, label %.lr.ph2546

.lr.ph2546:                                       ; preds = %76
  %.02340.neg2541 = xor i32 %reass.sub, -1
  %.off = add i32 %67, -1
  %switch = icmp ult i32 %.off, 2
  %82 = add i32 %41, 1
  %83 = getelementptr inbounds i8, ptr %26, i64 8
  %84 = getelementptr inbounds i8, ptr %29, i64 8
  %85 = getelementptr inbounds i8, ptr %36, i64 16
  %86 = getelementptr inbounds i8, ptr %36, i64 32
  %87 = getelementptr inbounds i8, ptr %30, i64 8
  %88 = getelementptr inbounds i8, ptr %31, i64 8
  %89 = add i32 %50, 1
  %90 = sub i32 %69, %80
  %91 = sext i32 %41 to i64
  %92 = lshr i32 %53, 1
  %93 = zext nneg i32 %92 to i64
  %94 = sext i32 %47 to i64
  %invariant.gep2719 = getelementptr i8, ptr %43, i64 32
  %invariant.gep2715 = getelementptr i8, ptr %43, i64 16
  %invariant.gep2717 = getelementptr i8, ptr %43, i64 48
  br label %95

95:                                               ; preds = %.lr.ph2546, %.loopexit2468
  %indvars.iv2562 = phi i32 [ %.02340.neg2541, %.lr.ph2546 ], [ %indvars.iv.next2563, %.loopexit2468 ]
  %indvars.iv2552 = phi i32 [ %90, %.lr.ph2546 ], [ %indvars.iv.next2553, %.loopexit2468 ]
  %.023402543 = phi i32 [ %81, %.lr.ph2546 ], [ %106, %.loopexit2468 ]
  br i1 %switch, label %101, label %96

96:                                               ; preds = %95
  %97 = load i32, ptr %0, align 4, !tbaa !5
  %.not2388 = icmp eq i32 %97, 0
  br i1 %.not2388, label %98, label %.thread

98:                                               ; preds = %96
  %99 = load i32, ptr %4, align 4, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %96, %98
  %.02355.ph = phi i32 [ 1, %96 ], [ %99, %98 ]
  %100 = load i32, ptr %39, align 4, !tbaa !5
  br label %104

101:                                              ; preds = %95
  %102 = load i32, ptr %4, align 4, !tbaa !5
  %.02340. = call i32 @llvm.smax.i32(i32 %102, i32 %.023402543)
  %103 = load i32, ptr %39, align 4, !tbaa !5
  call void @zlaset_(ptr noundef nonnull @.str.2, ptr noundef nonnull %39, ptr noundef nonnull %39, ptr noundef nonnull @c_b1, ptr noundef nonnull @c_b2, ptr noundef %16, ptr noundef nonnull %17) #7
  br label %104

104:                                              ; preds = %.thread, %101
  %.pn = phi i32 [ %100, %.thread ], [ %103, %101 ]
  %.023552459 = phi i32 [ %.02355.ph, %.thread ], [ %.02340., %101 ]
  %105 = add i32 %.pn, %.023402543
  %106 = add nsw i32 %.023402543, %80
  %107 = add nsw i32 %106, -1
  %108 = load i32, ptr %5, align 4, !tbaa !5
  %109 = add nsw i32 %108, -2
  %110 = call i32 @llvm.smin.i32(i32 %107, i32 %109)
  %.not23922521 = icmp sgt i32 %.023402543, %110
  br i1 %.not23922521, label %._crit_edge2526, label %.lr.ph2525

.lr.ph2525:                                       ; preds = %104
  %111 = add i32 %indvars.iv2562, -2
  %.neg = add nsw i32 %.023402543, 1
  %112 = add i32 %indvars.iv2562, 3
  %113 = sext i32 %.023552459 to i64
  br label %114

114:                                              ; preds = %.lr.ph2525, %.loopexit
  %indvars.iv2554 = phi i32 [ %indvars.iv2552, %.lr.ph2525 ], [ %indvars.iv.next2555, %.loopexit ]
  %.023392522 = phi i32 [ %.023402543, %.lr.ph2525 ], [ %1650, %.loopexit ]
  %115 = load i32, ptr %4, align 4, !tbaa !5
  %116 = sub nsw i32 %115, %.023392522
  %117 = sdiv i32 %116, 2
  %118 = add nsw i32 %117, 1
  %.inv = icmp sgt i32 %116, 1
  %119 = select i1 %.inv, i32 %118, i32 1
  %120 = load i32, ptr %5, align 4, !tbaa !5
  %121 = xor i32 %.023392522, -1
  %122 = add i32 %120, %121
  %123 = sdiv i32 %122, 2
  %124 = call i32 @llvm.smin.i32(i32 %77, i32 %123)
  %125 = add nsw i32 %124, 1
  %126 = icmp slt i32 %123, %77
  %127 = shl nsw i32 %124, 1
  %128 = add i32 %127, %.023392522
  %129 = add nsw i32 %120, -2
  %130 = icmp eq i32 %128, %129
  %131 = select i1 %126, i1 %130, i1 false
  br i1 %131, label %132, label %.loopexit2466

132:                                              ; preds = %114
  %133 = add nsw i32 %115, -1
  %134 = icmp eq i32 %128, %133
  %135 = add nsw i32 %128, 1
  br i1 %134, label %136, label %150

136:                                              ; preds = %132
  %137 = mul i32 %135, %82
  %138 = sext i32 %137 to i64
  %139 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %138
  %140 = shl i32 %125, 1
  %141 = sext i32 %140 to i64
  %142 = getelementptr %struct.doublecomplex, ptr %40, i64 %141
  %143 = getelementptr i8, ptr %142, i64 -16
  %144 = mul nsw i32 %125, %47
  %145 = sext i32 %144 to i64
  %146 = getelementptr %struct.doublecomplex, ptr %49, i64 %145
  %147 = getelementptr i8, ptr %146, i64 16
  call void @zlaqr1_(ptr noundef nonnull @c__2, ptr noundef %139, ptr noundef nonnull %9, ptr noundef %143, ptr noundef nonnull %142, ptr noundef %147) #7
  %148 = load <2 x double>, ptr %147, align 8, !tbaa !9
  store <2 x double> %148, ptr %32, align 16, !tbaa !9
  %149 = getelementptr i8, ptr %146, i64 32
  call void @zlarfg_(ptr noundef nonnull @c__2, ptr noundef nonnull %32, ptr noundef %149, ptr noundef nonnull @c__1, ptr noundef nonnull %147) #7
  br label %167

150:                                              ; preds = %132
  %151 = mul nsw i32 %128, %41
  %152 = add nsw i32 %135, %151
  %153 = sext i32 %152 to i64
  %154 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %153
  %155 = load <2 x double>, ptr %154, align 8, !tbaa !9
  store <2 x double> %155, ptr %32, align 16, !tbaa !9
  %156 = mul nsw i32 %125, %47
  %157 = add nsw i32 %128, 2
  %158 = add nsw i32 %157, %151
  %159 = sext i32 %158 to i64
  %160 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %159
  %161 = sext i32 %156 to i64
  %162 = getelementptr %struct.doublecomplex, ptr %49, i64 %161
  %163 = getelementptr i8, ptr %162, i64 32
  %164 = load <2 x double>, ptr %160, align 8, !tbaa !9
  store <2 x double> %164, ptr %163, align 8, !tbaa !9
  %165 = getelementptr i8, ptr %162, i64 16
  call void @zlarfg_(ptr noundef nonnull @c__2, ptr noundef nonnull %32, ptr noundef nonnull %163, ptr noundef nonnull @c__1, ptr noundef %165) #7
  %166 = load <2 x double>, ptr %32, align 16, !tbaa !9
  store <2 x double> %166, ptr %154, align 8, !tbaa !9
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %160, i8 0, i64 16, i1 false)
  br label %167

167:                                              ; preds = %150, %136
  %168 = load i32, ptr %5, align 4, !tbaa !5
  %169 = add nsw i32 %128, 3
  %170 = call i32 @llvm.smin.i32(i32 %168, i32 %169)
  %.not24052470 = icmp sgt i32 %.023552459, %170
  br i1 %.not24052470, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %167
  %171 = mul nsw i32 %125, %47
  %172 = add nsw i32 %128, 1
  %173 = mul nsw i32 %172, %41
  %174 = add nsw i32 %128, 2
  %175 = mul nsw i32 %174, %41
  %176 = sext i32 %171 to i64
  %177 = getelementptr %struct.doublecomplex, ptr %49, i64 %176
  %178 = getelementptr i8, ptr %177, i64 32
  %179 = getelementptr i8, ptr %177, i64 40
  %180 = getelementptr i8, ptr %177, i64 16
  %181 = getelementptr i8, ptr %177, i64 24
  %182 = sext i32 %173 to i64
  %183 = sext i32 %175 to i64
  %184 = sext i32 %170 to i64
  %invariant.gep = getelementptr %struct.doublecomplex, ptr %43, i64 %183
  %invariant.gep2641 = getelementptr %struct.doublecomplex, ptr %43, i64 %182
  br label %185

185:                                              ; preds = %.lr.ph, %185
  %indvars.iv = phi i64 [ %113, %.lr.ph ], [ %indvars.iv.next, %185 ]
  %186 = load double, ptr %178, align 8, !tbaa !11
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %indvars.iv
  %187 = load double, ptr %179, align 8, !tbaa !13
  %188 = fneg double %187
  %189 = load <2 x double>, ptr %gep, align 8, !tbaa !9
  %190 = insertelement <2 x double> poison, double %187, i64 0
  %191 = insertelement <2 x double> %190, double %188, i64 1
  %192 = fmul <2 x double> %189, %191
  %193 = shufflevector <2 x double> %192, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %194 = insertelement <2 x double> poison, double %186, i64 0
  %195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> zeroinitializer
  %196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %195, <2 x double> %189, <2 x double> %193)
  store <2 x double> %196, ptr %27, align 16, !tbaa !9
  %gep2642 = getelementptr %struct.doublecomplex, ptr %invariant.gep2641, i64 %indvars.iv
  %197 = load <2 x double>, ptr %gep2642, align 8, !tbaa !9
  %198 = fadd <2 x double> %196, %197
  store <2 x double> %198, ptr %26, align 16, !tbaa !9
  %199 = load double, ptr %180, align 8, !tbaa !11
  %200 = load double, ptr %181, align 8, !tbaa !13
  %201 = fneg double %200
  %202 = insertelement <2 x double> poison, double %200, i64 0
  %203 = insertelement <2 x double> %202, double %201, i64 1
  %204 = fmul <2 x double> %198, %203
  %205 = shufflevector <2 x double> %204, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %206 = insertelement <2 x double> poison, double %199, i64 0
  %207 = shufflevector <2 x double> %206, <2 x double> poison, <2 x i32> zeroinitializer
  %208 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %207, <2 x double> %198, <2 x double> %205)
  %209 = fsub <2 x double> %197, %208
  store <2 x double> %209, ptr %25, align 16, !tbaa !9
  store <2 x double> %209, ptr %gep2642, align 8, !tbaa !9
  %210 = call { double, double } @Cd(ptr noundef nonnull %178)
  %211 = extractvalue { double, double } %210, 0
  %212 = extractvalue { double, double } %210, 1
  %213 = fneg double %212
  %214 = call ptr @_pCd(ptr noundef nonnull %27)
  %215 = getelementptr inbounds i8, ptr %214, i64 8
  store double %211, ptr %214, align 8
  store double %213, ptr %215, align 8
  %216 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %217 = shufflevector <2 x double> %208, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %218 = fneg <2 x double> %208
  %219 = shufflevector <2 x double> %217, <2 x double> %218, <2 x i32> <i32 0, i32 3>
  %220 = fmul <2 x double> %216, %219
  %221 = shufflevector <2 x double> %220, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %222 = shufflevector <2 x double> %208, <2 x double> poison, <2 x i32> zeroinitializer
  %223 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %222, <2 x double> %216, <2 x double> %221)
  store <2 x double> %223, ptr %26, align 16, !tbaa !9
  %224 = load <2 x double>, ptr %gep, align 8, !tbaa !9
  %225 = fsub <2 x double> %224, %223
  store <2 x double> %225, ptr %25, align 16, !tbaa !9
  store <2 x double> %225, ptr %gep, align 8, !tbaa !9
  %indvars.iv.next = add nsw i64 %indvars.iv, 1
  %.not2405.not = icmp slt i64 %indvars.iv, %184
  br i1 %.not2405.not, label %185, label %._crit_edge, !llvm.loop !14

._crit_edge:                                      ; preds = %185, %167
  br i1 %switch, label %226, label %228

226:                                              ; preds = %._crit_edge
  %227 = load i32, ptr %5, align 4, !tbaa !5
  %. = call i32 @llvm.smin.i32(i32 %105, i32 %227)
  br label %234

228:                                              ; preds = %._crit_edge
  %229 = load i32, ptr %0, align 4, !tbaa !5
  %.not2406 = icmp eq i32 %229, 0
  br i1 %.not2406, label %232, label %230

230:                                              ; preds = %228
  %231 = load i32, ptr %3, align 4, !tbaa !5
  br label %234

232:                                              ; preds = %228
  %233 = load i32, ptr %5, align 4, !tbaa !5
  br label %234

234:                                              ; preds = %230, %232, %226
  %.02357 = phi i32 [ %., %226 ], [ %231, %230 ], [ %233, %232 ]
  %235 = add nsw i32 %128, 1
  %.not24082472.not = icmp slt i32 %128, %.02357
  br i1 %.not24082472.not, label %.lr.ph2475, label %._crit_edge2476

.lr.ph2475:                                       ; preds = %234
  %236 = mul nsw i32 %125, %47
  %237 = sext i32 %236 to i64
  %238 = getelementptr %struct.doublecomplex, ptr %49, i64 %237
  %239 = getelementptr i8, ptr %238, i64 16
  %240 = getelementptr i8, ptr %238, i64 32
  %241 = add i32 %indvars.iv2554, %127
  %242 = sext i32 %241 to i64
  %243 = sext i32 %235 to i64
  %244 = sext i32 %.02357 to i64
  %245 = sext i32 %128 to i64
  %invariant.gep2645 = getelementptr %struct.doublecomplex, ptr %43, i64 %243
  %gep2720 = getelementptr %struct.doublecomplex, ptr %invariant.gep2719, i64 %245
  br label %246

246:                                              ; preds = %.lr.ph2475, %246
  %indvars.iv2556 = phi i64 [ %242, %.lr.ph2475 ], [ %indvars.iv.next2557, %246 ]
  %247 = call { double, double } @Cd(ptr noundef %239)
  %248 = extractvalue { double, double } %247, 0
  %249 = extractvalue { double, double } %247, 1
  %250 = fneg double %249
  %251 = call ptr @_pCd(ptr noundef nonnull %26)
  %252 = getelementptr inbounds i8, ptr %251, i64 8
  store double %248, ptr %251, align 8
  store double %250, ptr %252, align 8
  %253 = mul nsw i64 %indvars.iv2556, %91
  %254 = call { double, double } @Cd(ptr noundef %240)
  %255 = extractvalue { double, double } %254, 0
  %256 = extractvalue { double, double } %254, 1
  %257 = fneg double %256
  %258 = call ptr @_pCd(ptr noundef nonnull %29)
  %259 = getelementptr inbounds i8, ptr %258, i64 8
  store double %255, ptr %258, align 8
  store double %257, ptr %259, align 8
  %260 = load <2 x double>, ptr %29, align 16
  %gep2710 = getelementptr %struct.doublecomplex, ptr %gep2720, i64 %253
  %261 = load double, ptr %84, align 8, !tbaa !13
  %262 = fneg double %261
  %263 = load <2 x double>, ptr %gep2710, align 8, !tbaa !9
  %264 = insertelement <2 x double> poison, double %261, i64 0
  %265 = insertelement <2 x double> %264, double %262, i64 1
  %266 = fmul <2 x double> %263, %265
  %267 = shufflevector <2 x double> %266, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %268 = shufflevector <2 x double> %260, <2 x double> poison, <2 x i32> zeroinitializer
  %269 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %268, <2 x double> %263, <2 x double> %267)
  store <2 x double> %269, ptr %28, align 16, !tbaa !9
  %gep2646 = getelementptr %struct.doublecomplex, ptr %invariant.gep2645, i64 %253
  %270 = load <2 x double>, ptr %gep2646, align 8, !tbaa !9
  %271 = fadd <2 x double> %269, %270
  store <2 x double> %271, ptr %27, align 16, !tbaa !9
  %272 = load <2 x double>, ptr %26, align 16
  %273 = load double, ptr %83, align 8, !tbaa !13
  %274 = fneg double %273
  %275 = insertelement <2 x double> poison, double %273, i64 0
  %276 = insertelement <2 x double> %275, double %274, i64 1
  %277 = fmul <2 x double> %271, %276
  %278 = shufflevector <2 x double> %277, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %279 = shufflevector <2 x double> %272, <2 x double> poison, <2 x i32> zeroinitializer
  %280 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %279, <2 x double> %271, <2 x double> %278)
  %281 = fsub <2 x double> %270, %280
  store <2 x double> %281, ptr %gep2646, align 8, !tbaa !9
  %282 = load <2 x double>, ptr %240, align 8, !tbaa !9
  %283 = shufflevector <2 x double> %280, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %284 = fneg <2 x double> %280
  %285 = shufflevector <2 x double> %283, <2 x double> %284, <2 x i32> <i32 0, i32 3>
  %286 = fmul <2 x double> %282, %285
  %287 = shufflevector <2 x double> %286, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %288 = shufflevector <2 x double> %280, <2 x double> poison, <2 x i32> zeroinitializer
  %289 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %288, <2 x double> %282, <2 x double> %287)
  store <2 x double> %289, ptr %26, align 16, !tbaa !9
  %290 = fsub <2 x double> %263, %289
  store <2 x double> %290, ptr %25, align 16, !tbaa !9
  store <2 x double> %290, ptr %gep2710, align 8, !tbaa !9
  %indvars.iv.next2557 = add nsw i64 %indvars.iv2556, 1
  %.not2408.not = icmp slt i64 %indvars.iv2556, %244
  br i1 %.not2408.not, label %246, label %._crit_edge2476, !llvm.loop !16

._crit_edge2476:                                  ; preds = %246, %234
  %291 = load i32, ptr %4, align 4, !tbaa !5
  %.not2409 = icmp slt i32 %128, %291
  br i1 %.not2409, label %564, label %292

292:                                              ; preds = %._crit_edge2476
  %293 = mul nsw i32 %128, %41
  %294 = add nsw i32 %235, %293
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %295
  %297 = load double, ptr %296, align 8, !tbaa !11
  %298 = fcmp une double %297, 0.000000e+00
  br i1 %298, label %303, label %299

299:                                              ; preds = %292
  %300 = getelementptr inbounds i8, ptr %296, i64 8
  %301 = load double, ptr %300, align 8, !tbaa !13
  %302 = fcmp une double %301, 0.000000e+00
  br i1 %302, label %303, label %564

303:                                              ; preds = %299, %292
  %304 = add nsw i32 %293, %128
  %305 = mul nsw i32 %235, %41
  %306 = add nsw i32 %305, %235
  %307 = sext i32 %304 to i64
  %308 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %307
  %309 = load double, ptr %308, align 8, !tbaa !11
  %310 = call { double, double } @Cd(ptr noundef nonnull %308)
  %311 = extractvalue { double, double } %310, 1
  %312 = sext i32 %306 to i64
  %313 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %312
  %314 = load double, ptr %313, align 8, !tbaa !11
  %315 = call { double, double } @Cd(ptr noundef nonnull %313)
  %316 = extractvalue { double, double } %315, 1
  %317 = insertelement <2 x double> poison, double %309, i64 0
  %318 = insertelement <2 x double> %317, double %314, i64 1
  %319 = fcmp oge <2 x double> %318, zeroinitializer
  %320 = fneg <2 x double> %318
  %321 = select <2 x i1> %319, <2 x double> %318, <2 x double> %320
  %322 = insertelement <2 x double> poison, double %311, i64 0
  %323 = insertelement <2 x double> %322, double %316, i64 1
  %324 = fcmp oge <2 x double> %323, zeroinitializer
  %325 = fneg <2 x double> %323
  %326 = select <2 x i1> %324, <2 x double> %323, <2 x double> %325
  %327 = fadd <2 x double> %321, %326
  %shift = shufflevector <2 x double> %327, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %328 = fadd <2 x double> %327, %shift
  %329 = extractelement <2 x double> %328, i64 0
  %330 = fcmp oeq double %329, 0.000000e+00
  br i1 %330, label %331, label %446

331:                                              ; preds = %303
  %332 = load i32, ptr %4, align 4, !tbaa !5
  %.not2410.not = icmp sgt i32 %128, %332
  br i1 %.not2410.not, label %333, label %350

333:                                              ; preds = %331
  %334 = add nsw i32 %128, -1
  %335 = mul nsw i32 %334, %41
  %336 = add nsw i32 %335, %128
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %337
  %339 = load double, ptr %338, align 8, !tbaa !11
  %340 = call { double, double } @Cd(ptr noundef nonnull %338)
  %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
  %shift2689 = shufflevector <2 x double> %346, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %347 = fadd <2 x double> %346, %shift2689
  %348 = fadd <2 x double> %328, %347
  %349 = extractelement <2 x double> %348, i64 0
  %.pre = load i32, ptr %4, align 4, !tbaa !5
  br label %350

350:                                              ; preds = %333, %331
  %351 = phi i32 [ %.pre, %333 ], [ %332, %331 ]
  %.0 = phi double [ %349, %333 ], [ %329, %331 ]
  %352 = add nsw i32 %351, 2
  %.not2411 = icmp slt i32 %128, %352
  br i1 %.not2411, label %370, label %353

353:                                              ; preds = %350
  %354 = add nsw i32 %128, -2
  %355 = mul nsw i32 %354, %41
  %356 = add nsw i32 %355, %128
  %357 = sext i32 %356 to i64
  %358 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %357
  %359 = load double, ptr %358, align 8, !tbaa !11
  %360 = call { double, double } @Cd(ptr noundef nonnull %358)
  %361 = extractvalue { double, double } %360, 1
  %362 = insertelement <2 x double> poison, double %359, i64 0
  %363 = insertelement <2 x double> %362, double %361, i64 1
  %364 = fcmp oge <2 x double> %363, zeroinitializer
  %365 = fneg <2 x double> %363
  %366 = select <2 x i1> %364, <2 x double> %363, <2 x double> %365
  %shift2690 = shufflevector <2 x double> %366, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %367 = fadd <2 x double> %366, %shift2690
  %368 = extractelement <2 x double> %367, i64 0
  %369 = fadd double %.0, %368
  %.pre2608 = load i32, ptr %4, align 4, !tbaa !5
  br label %370

370:                                              ; preds = %353, %350
  %371 = phi i32 [ %.pre2608, %353 ], [ %351, %350 ]
  %.1 = phi double [ %369, %353 ], [ %.0, %350 ]
  %372 = add nsw i32 %371, 3
  %.not2412 = icmp slt i32 %128, %372
  br i1 %.not2412, label %390, label %373

373:                                              ; preds = %370
  %374 = add nsw i32 %128, -3
  %375 = mul nsw i32 %374, %41
  %376 = add nsw i32 %375, %128
  %377 = sext i32 %376 to i64
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %377
  %379 = load double, ptr %378, align 8, !tbaa !11
  %380 = call { double, double } @Cd(ptr noundef nonnull %378)
  %381 = extractvalue { double, double } %380, 1
  %382 = insertelement <2 x double> poison, double %379, i64 0
  %383 = insertelement <2 x double> %382, double %381, i64 1
  %384 = fcmp oge <2 x double> %383, zeroinitializer
  %385 = fneg <2 x double> %383
  %386 = select <2 x i1> %384, <2 x double> %383, <2 x double> %385
  %shift2691 = shufflevector <2 x double> %386, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %387 = fadd <2 x double> %386, %shift2691
  %388 = extractelement <2 x double> %387, i64 0
  %389 = fadd double %.1, %388
  br label %390

390:                                              ; preds = %373, %370
  %.2 = phi double [ %389, %373 ], [ %.1, %370 ]
  %391 = load i32, ptr %5, align 4, !tbaa !5
  %392 = add nsw i32 %391, -2
  %.not2413 = icmp sgt i32 %128, %392
  br i1 %.not2413, label %409, label %393

393:                                              ; preds = %390
  %394 = add nsw i32 %128, 2
  %395 = add nsw i32 %394, %305
  %396 = sext i32 %395 to i64
  %397 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %396
  %398 = load double, ptr %397, align 8, !tbaa !11
  %399 = call { double, double } @Cd(ptr noundef nonnull %397)
  %400 = extractvalue { double, double } %399, 1
  %401 = insertelement <2 x double> poison, double %398, i64 0
  %402 = insertelement <2 x double> %401, double %400, i64 1
  %403 = fcmp oge <2 x double> %402, zeroinitializer
  %404 = fneg <2 x double> %402
  %405 = select <2 x i1> %403, <2 x double> %402, <2 x double> %404
  %shift2692 = shufflevector <2 x double> %405, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %406 = fadd <2 x double> %405, %shift2692
  %407 = extractelement <2 x double> %406, i64 0
  %408 = fadd double %.2, %407
  %.pre2609 = load i32, ptr %5, align 4, !tbaa !5
  br label %409

409:                                              ; preds = %393, %390
  %410 = phi i32 [ %.pre2609, %393 ], [ %391, %390 ]
  %.3 = phi double [ %408, %393 ], [ %.2, %390 ]
  %411 = add nsw i32 %410, -3
  %.not2414 = icmp sgt i32 %128, %411
  br i1 %.not2414, label %427, label %412

412:                                              ; preds = %409
  %413 = add nsw i32 %305, %169
  %414 = sext i32 %413 to i64
  %415 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %414
  %416 = load double, ptr %415, align 8, !tbaa !11
  %417 = call { double, double } @Cd(ptr noundef nonnull %415)
  %418 = extractvalue { double, double } %417, 1
  %419 = insertelement <2 x double> poison, double %416, i64 0
  %420 = insertelement <2 x double> %419, double %418, i64 1
  %421 = fcmp oge <2 x double> %420, zeroinitializer
  %422 = fneg <2 x double> %420
  %423 = select <2 x i1> %421, <2 x double> %420, <2 x double> %422
  %shift2693 = shufflevector <2 x double> %423, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %424 = fadd <2 x double> %423, %shift2693
  %425 = extractelement <2 x double> %424, i64 0
  %426 = fadd double %.3, %425
  %.pre2610 = load i32, ptr %5, align 4, !tbaa !5
  br label %427

427:                                              ; preds = %412, %409
  %428 = phi i32 [ %.pre2610, %412 ], [ %410, %409 ]
  %.4 = phi double [ %426, %412 ], [ %.3, %409 ]
  %429 = add nsw i32 %428, -4
  %.not2415 = icmp sgt i32 %128, %429
  br i1 %.not2415, label %446, label %430

430:                                              ; preds = %427
  %431 = add nsw i32 %128, 4
  %432 = add nsw i32 %431, %305
  %433 = sext i32 %432 to i64
  %434 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %433
  %435 = load double, ptr %434, align 8, !tbaa !11
  %436 = call { double, double } @Cd(ptr noundef nonnull %434)
  %437 = extractvalue { double, double } %436, 1
  %438 = insertelement <2 x double> poison, double %435, i64 0
  %439 = insertelement <2 x double> %438, double %437, i64 1
  %440 = fcmp oge <2 x double> %439, zeroinitializer
  %441 = fneg <2 x double> %439
  %442 = select <2 x i1> %440, <2 x double> %439, <2 x double> %441
  %shift2694 = shufflevector <2 x double> %442, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %443 = fadd <2 x double> %442, %shift2694
  %444 = extractelement <2 x double> %443, i64 0
  %445 = fadd double %.4, %444
  br label %446

446:                                              ; preds = %427, %430, %303
  %.5 = phi double [ %445, %430 ], [ %.4, %427 ], [ %329, %303 ]
  %447 = fmul double %61, %.5
  %448 = load double, ptr %296, align 8, !tbaa !11
  %449 = call { double, double } @Cd(ptr noundef nonnull %296)
  %450 = extractvalue { double, double } %449, 1
  %451 = insertelement <2 x double> poison, double %448, i64 0
  %452 = insertelement <2 x double> %451, double %450, i64 1
  %453 = fcmp oge <2 x double> %452, zeroinitializer
  %454 = fneg <2 x double> %452
  %455 = select <2 x i1> %453, <2 x double> %452, <2 x double> %454
  %shift2695 = shufflevector <2 x double> %455, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %456 = fadd <2 x double> %455, %shift2695
  %457 = extractelement <2 x double> %456, i64 0
  %458 = fcmp oge double %66, %447
  %459 = select i1 %458, double %66, double %447
  %460 = fcmp ugt double %457, %459
  br i1 %460, label %564, label %461

461:                                              ; preds = %446
  %462 = add nsw i32 %305, %128
  %463 = load double, ptr %296, align 8, !tbaa !11
  %464 = call { double, double } @Cd(ptr noundef nonnull %296)
  %465 = extractvalue { double, double } %464, 1
  %466 = sext i32 %462 to i64
  %467 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %466
  %468 = load double, ptr %467, align 8, !tbaa !11
  %469 = call { double, double } @Cd(ptr noundef nonnull %467)
  %470 = extractvalue { double, double } %469, 1
  %471 = load double, ptr %296, align 8, !tbaa !11
  %472 = call { double, double } @Cd(ptr noundef nonnull %296)
  %473 = load double, ptr %467, align 8, !tbaa !11
  %474 = call { double, double } @Cd(ptr noundef nonnull %467)
  %475 = load <2 x double>, ptr %308, align 8, !tbaa !9
  %476 = load <2 x double>, ptr %313, align 8, !tbaa !9
  %477 = fsub <2 x double> %475, %476
  store <2 x double> %477, ptr %26, align 16, !tbaa !9
  store <2 x double> %477, ptr %25, align 16, !tbaa !9
  %478 = call { double, double } @Cd(ptr noundef nonnull %313)
  %479 = extractvalue { double, double } %478, 1
  %480 = load double, ptr %25, align 16, !tbaa !11
  %481 = call { double, double } @Cd(ptr noundef nonnull %25)
  %482 = extractvalue { double, double } %481, 1
  %483 = shufflevector <2 x double> %476, <2 x double> poison, <2 x i32> <i32 poison, i32 0>
  %484 = insertelement <2 x double> %483, double %463, i64 0
  %485 = fcmp oge <2 x double> %484, zeroinitializer
  %486 = fneg <2 x double> %484
  %487 = select <2 x i1> %485, <2 x double> %484, <2 x double> %486
  %488 = insertelement <2 x double> poison, double %465, i64 0
  %489 = insertelement <2 x double> %488, double %479, i64 1
  %490 = fcmp oge <2 x double> %489, zeroinitializer
  %491 = fneg <2 x double> %489
  %492 = select <2 x i1> %490, <2 x double> %489, <2 x double> %491
  %493 = fadd <2 x double> %487, %492
  %494 = insertelement <2 x double> poison, double %468, i64 0
  %495 = insertelement <2 x double> %494, double %480, i64 1
  %496 = fcmp oge <2 x double> %495, zeroinitializer
  %497 = fneg <2 x double> %495
  %498 = select <2 x i1> %496, <2 x double> %495, <2 x double> %497
  %499 = insertelement <2 x double> poison, double %470, i64 0
  %500 = insertelement <2 x double> %499, double %482, i64 1
  %501 = fcmp oge <2 x double> %500, zeroinitializer
  %502 = fneg <2 x double> %500
  %503 = select <2 x i1> %501, <2 x double> %500, <2 x double> %502
  %504 = fadd <2 x double> %498, %503
  %505 = fcmp oge <2 x double> %493, %504
  %506 = select <2 x i1> %505, <2 x double> %493, <2 x double> %504
  %507 = load <2 x double>, ptr %308, align 8, !tbaa !9
  %508 = load <2 x double>, ptr %313, align 8, !tbaa !9
  %509 = fsub <2 x double> %507, %508
  store <2 x double> %509, ptr %26, align 16, !tbaa !9
  store <2 x double> %509, ptr %25, align 16, !tbaa !9
  %510 = extractelement <2 x double> %508, 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 %313)
  %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 %25, align 16
  %521 = call { double, double } @Cd(ptr noundef nonnull %25)
  %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
  %shift2696 = shufflevector <2 x double> %526, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %527 = fadd <2 x double> %526, %shift2696
  %528 = extractelement <2 x double> %527, i64 0
  %529 = fcmp ole double %519, %528
  %530 = select i1 %529, double %519, double %528
  %531 = extractelement <2 x double> %506, i64 0
  %532 = extractelement <2 x double> %506, i64 1
  %533 = fadd double %531, %532
  %534 = fdiv double %532, %533
  %535 = fmul double %534, %530
  %536 = fcmp oeq double %535, 0.000000e+00
  br i1 %536, label %563, label %537

537:                                              ; preds = %461
  %538 = fmul double %61, %535
  %539 = extractvalue { double, double } %472, 1
  %540 = insertelement <2 x double> poison, double %471, i64 0
  %541 = insertelement <2 x double> %540, double %539, i64 1
  %542 = fcmp oge <2 x double> %541, zeroinitializer
  %543 = fneg <2 x double> %541
  %544 = select <2 x i1> %542, <2 x double> %541, <2 x double> %543
  %545 = extractvalue { double, double } %474, 1
  %546 = insertelement <2 x double> poison, double %473, i64 0
  %547 = insertelement <2 x double> %546, double %545, i64 1
  %548 = fcmp oge <2 x double> %547, zeroinitializer
  %549 = fneg <2 x double> %547
  %550 = select <2 x i1> %548, <2 x double> %547, <2 x double> %549
  %551 = shufflevector <2 x double> %544, <2 x double> %550, <2 x i32> <i32 0, i32 2>
  %552 = shufflevector <2 x double> %544, <2 x double> %550, <2 x i32> <i32 1, i32 3>
  %553 = fadd <2 x double> %551, %552
  %554 = extractelement <2 x double> %553, i64 0
  %555 = extractelement <2 x double> %553, i64 1
  %556 = fcmp ole double %554, %555
  %557 = select i1 %556, double %554, double %555
  %558 = fdiv double %531, %533
  %559 = fmul double %557, %558
  %560 = fcmp oge double %66, %538
  %561 = select i1 %560, double %66, double %538
  %562 = fcmp ugt double %559, %561
  br i1 %562, label %564, label %563

563:                                              ; preds = %537, %461
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %296, i8 0, i64 16, i1 false)
  br label %564

564:                                              ; preds = %299, %537, %563, %446, %._crit_edge2476
  br i1 %switch, label %565, label %628

565:                                              ; preds = %564
  %566 = load i32, ptr %4, align 4, !tbaa !5
  %567 = sub nsw i32 %566, %.023402543
  %568 = load i32, ptr %39, align 4, !tbaa !5
  %569 = call i32 @llvm.smax.i32(i32 %567, i32 1)
  %.not24192481 = icmp sgt i32 %569, %568
  br i1 %.not24192481, label %.loopexit2466.thread, label %.lr.ph2484

.lr.ph2484:                                       ; preds = %565
  %570 = sub nsw i32 %128, %.023402543
  %571 = mul nsw i32 %125, %47
  %572 = add nsw i32 %570, 1
  %573 = mul nsw i32 %572, %50
  %574 = add nsw i32 %570, 2
  %575 = mul nsw i32 %574, %50
  %576 = sext i32 %571 to i64
  %577 = getelementptr %struct.doublecomplex, ptr %49, i64 %576
  %578 = getelementptr i8, ptr %577, i64 32
  %579 = getelementptr i8, ptr %577, i64 40
  %580 = getelementptr i8, ptr %577, i64 16
  %581 = getelementptr i8, ptr %577, i64 24
  %582 = add i32 %indvars.iv2562, %566
  %smax = call i32 @llvm.smax.i32(i32 %582, i32 1)
  %583 = zext nneg i32 %smax to i64
  %584 = sext i32 %573 to i64
  %585 = sext i32 %575 to i64
  %586 = zext nneg i32 %568 to i64
  %invariant.gep2651 = getelementptr %struct.doublecomplex, ptr %52, i64 %585
  %invariant.gep2653 = getelementptr %struct.doublecomplex, ptr %52, i64 %584
  br label %587

587:                                              ; preds = %.lr.ph2484, %587
  %indvars.iv2564 = phi i64 [ %583, %.lr.ph2484 ], [ %indvars.iv.next2565, %587 ]
  %588 = load double, ptr %578, align 8, !tbaa !11
  %gep2652 = getelementptr %struct.doublecomplex, ptr %invariant.gep2651, i64 %indvars.iv2564
  %589 = load double, ptr %579, align 8, !tbaa !13
  %590 = fneg double %589
  %591 = load <2 x double>, ptr %gep2652, align 8, !tbaa !9
  %592 = insertelement <2 x double> poison, double %589, i64 0
  %593 = insertelement <2 x double> %592, double %590, i64 1
  %594 = fmul <2 x double> %591, %593
  %595 = shufflevector <2 x double> %594, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %596 = insertelement <2 x double> poison, double %588, i64 0
  %597 = shufflevector <2 x double> %596, <2 x double> poison, <2 x i32> zeroinitializer
  %598 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %597, <2 x double> %591, <2 x double> %595)
  store <2 x double> %598, ptr %27, align 16, !tbaa !9
  %gep2654 = getelementptr %struct.doublecomplex, ptr %invariant.gep2653, i64 %indvars.iv2564
  %599 = load <2 x double>, ptr %gep2654, align 8, !tbaa !9
  %600 = fadd <2 x double> %598, %599
  store <2 x double> %600, ptr %26, align 16, !tbaa !9
  %601 = load double, ptr %580, align 8, !tbaa !11
  %602 = load double, ptr %581, align 8, !tbaa !13
  %603 = fneg double %602
  %604 = insertelement <2 x double> poison, double %602, i64 0
  %605 = insertelement <2 x double> %604, double %603, i64 1
  %606 = fmul <2 x double> %600, %605
  %607 = shufflevector <2 x double> %606, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %608 = insertelement <2 x double> poison, double %601, i64 0
  %609 = shufflevector <2 x double> %608, <2 x double> poison, <2 x i32> zeroinitializer
  %610 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %609, <2 x double> %600, <2 x double> %607)
  %611 = fsub <2 x double> %599, %610
  store <2 x double> %611, ptr %25, align 16, !tbaa !9
  store <2 x double> %611, ptr %gep2654, align 8, !tbaa !9
  %612 = call { double, double } @Cd(ptr noundef nonnull %578)
  %613 = extractvalue { double, double } %612, 0
  %614 = extractvalue { double, double } %612, 1
  %615 = fneg double %614
  %616 = call ptr @_pCd(ptr noundef nonnull %27)
  %617 = getelementptr inbounds i8, ptr %616, i64 8
  store double %613, ptr %616, align 8
  store double %615, ptr %617, align 8
  %618 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %619 = shufflevector <2 x double> %610, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %620 = fneg <2 x double> %610
  %621 = shufflevector <2 x double> %619, <2 x double> %620, <2 x i32> <i32 0, i32 3>
  %622 = fmul <2 x double> %618, %621
  %623 = shufflevector <2 x double> %622, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %624 = shufflevector <2 x double> %610, <2 x double> poison, <2 x i32> zeroinitializer
  %625 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %624, <2 x double> %618, <2 x double> %623)
  store <2 x double> %625, ptr %26, align 16, !tbaa !9
  %626 = load <2 x double>, ptr %gep2652, align 8, !tbaa !9
  %627 = fsub <2 x double> %626, %625
  store <2 x double> %627, ptr %25, align 16, !tbaa !9
  store <2 x double> %627, ptr %gep2652, align 8, !tbaa !9
  %indvars.iv.next2565 = add nuw nsw i64 %indvars.iv2564, 1
  %.not2419.not = icmp ult i64 %indvars.iv2564, %586
  br i1 %.not2419.not, label %587, label %.loopexit2466, !llvm.loop !17

628:                                              ; preds = %564
  %629 = load i32, ptr %1, align 4, !tbaa !5
  %.not2416 = icmp eq i32 %629, 0
  br i1 %.not2416, label %.loopexit2466, label %630

630:                                              ; preds = %628
  %631 = load i32, ptr %11, align 4, !tbaa !5
  %632 = load i32, ptr %10, align 4, !tbaa !5
  %.not24172477 = icmp sgt i32 %632, %631
  br i1 %.not24172477, label %.loopexit2466, label %.lr.ph2480

.lr.ph2480:                                       ; preds = %630
  %633 = mul nsw i32 %125, %47
  %634 = mul nsw i32 %235, %44
  %635 = add nsw i32 %128, 2
  %636 = mul nsw i32 %635, %44
  %637 = sext i32 %633 to i64
  %638 = getelementptr %struct.doublecomplex, ptr %49, i64 %637
  %639 = getelementptr i8, ptr %638, i64 32
  %640 = getelementptr i8, ptr %638, i64 40
  %641 = getelementptr i8, ptr %638, i64 16
  %642 = getelementptr i8, ptr %638, i64 24
  %643 = sext i32 %632 to i64
  %644 = sext i32 %634 to i64
  %645 = sext i32 %636 to i64
  %646 = add i32 %631, 1
  %invariant.gep2647 = getelementptr %struct.doublecomplex, ptr %46, i64 %645
  %invariant.gep2649 = getelementptr %struct.doublecomplex, ptr %46, i64 %644
  br label %647

647:                                              ; preds = %.lr.ph2480, %647
  %indvars.iv2559 = phi i64 [ %643, %.lr.ph2480 ], [ %indvars.iv.next2560, %647 ]
  %648 = load double, ptr %639, align 8, !tbaa !11
  %gep2648 = getelementptr %struct.doublecomplex, ptr %invariant.gep2647, i64 %indvars.iv2559
  %649 = load double, ptr %640, align 8, !tbaa !13
  %650 = fneg double %649
  %651 = load <2 x double>, ptr %gep2648, align 8, !tbaa !9
  %652 = insertelement <2 x double> poison, double %649, i64 0
  %653 = insertelement <2 x double> %652, double %650, i64 1
  %654 = fmul <2 x double> %651, %653
  %655 = shufflevector <2 x double> %654, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %656 = insertelement <2 x double> poison, double %648, i64 0
  %657 = shufflevector <2 x double> %656, <2 x double> poison, <2 x i32> zeroinitializer
  %658 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %657, <2 x double> %651, <2 x double> %655)
  store <2 x double> %658, ptr %27, align 16, !tbaa !9
  %gep2650 = getelementptr %struct.doublecomplex, ptr %invariant.gep2649, i64 %indvars.iv2559
  %659 = load <2 x double>, ptr %gep2650, align 8, !tbaa !9
  %660 = fadd <2 x double> %658, %659
  store <2 x double> %660, ptr %26, align 16, !tbaa !9
  %661 = load double, ptr %641, align 8, !tbaa !11
  %662 = load double, ptr %642, align 8, !tbaa !13
  %663 = fneg double %662
  %664 = insertelement <2 x double> poison, double %662, i64 0
  %665 = insertelement <2 x double> %664, double %663, i64 1
  %666 = fmul <2 x double> %660, %665
  %667 = shufflevector <2 x double> %666, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %668 = insertelement <2 x double> poison, double %661, i64 0
  %669 = shufflevector <2 x double> %668, <2 x double> poison, <2 x i32> zeroinitializer
  %670 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %669, <2 x double> %660, <2 x double> %667)
  %671 = fsub <2 x double> %659, %670
  store <2 x double> %671, ptr %25, align 16, !tbaa !9
  store <2 x double> %671, ptr %gep2650, align 8, !tbaa !9
  %672 = call { double, double } @Cd(ptr noundef nonnull %639)
  %673 = extractvalue { double, double } %672, 0
  %674 = extractvalue { double, double } %672, 1
  %675 = fneg double %674
  %676 = call ptr @_pCd(ptr noundef nonnull %27)
  %677 = getelementptr inbounds i8, ptr %676, i64 8
  store double %673, ptr %676, align 8
  store double %675, ptr %677, align 8
  %678 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %679 = shufflevector <2 x double> %670, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %680 = fneg <2 x double> %670
  %681 = shufflevector <2 x double> %679, <2 x double> %680, <2 x i32> <i32 0, i32 3>
  %682 = fmul <2 x double> %678, %681
  %683 = shufflevector <2 x double> %682, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %684 = shufflevector <2 x double> %670, <2 x double> poison, <2 x i32> zeroinitializer
  %685 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %684, <2 x double> %678, <2 x double> %683)
  store <2 x double> %685, ptr %26, align 16, !tbaa !9
  %686 = load <2 x double>, ptr %gep2648, align 8, !tbaa !9
  %687 = fsub <2 x double> %686, %685
  store <2 x double> %687, ptr %25, align 16, !tbaa !9
  store <2 x double> %687, ptr %gep2648, align 8, !tbaa !9
  %indvars.iv.next2560 = add nsw i64 %indvars.iv2559, 1
  %lftr.wideiv = trunc i64 %indvars.iv.next2560 to i32
  %exitcond.not = icmp eq i32 %646, %lftr.wideiv
  br i1 %exitcond.not, label %.loopexit2466, label %647, !llvm.loop !18

.loopexit2466:                                    ; preds = %647, %587, %630, %628, %114
  %.not24202490 = icmp slt i32 %124, %119
  br i1 %.not24202490, label %._crit_edge2494.thread, label %.lr.ph2493

.loopexit2466.thread:                             ; preds = %565
  %.not242024902633 = icmp slt i32 %124, %119
  br i1 %.not242024902633, label %.loopexit, label %.lr.ph2493

.lr.ph2493:                                       ; preds = %.loopexit2466.thread, %.loopexit2466
  %688 = add i32 %.023392522, -2
  %689 = sext i32 %123 to i64
  %smin = call i64 @llvm.smin.i64(i64 %93, i64 %689)
  %690 = sext i32 %119 to i64
  br label %691

691:                                              ; preds = %.lr.ph2493, %1356
  %indvars.iv2570 = phi i64 [ %smin, %.lr.ph2493 ], [ %indvars.iv.next2571, %1356 ]
  %692 = trunc nsw i64 %indvars.iv2570 to i32
  %693 = shl i32 %692, 1
  %694 = add i32 %688, %693
  %695 = load i32, ptr %4, align 4, !tbaa !5
  %696 = add nsw i32 %695, -1
  %697 = icmp eq i32 %694, %696
  br i1 %697, label %698, label %710

698:                                              ; preds = %691
  %699 = mul i32 %695, %82
  %700 = sext i32 %699 to i64
  %701 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %700
  %702 = sext i32 %693 to i64
  %703 = getelementptr %struct.doublecomplex, ptr %40, i64 %702
  %704 = getelementptr i8, ptr %703, i64 -16
  %705 = mul nsw i64 %indvars.iv2570, %94
  %706 = getelementptr %struct.doublecomplex, ptr %49, i64 %705
  %707 = getelementptr i8, ptr %706, i64 16
  call void @zlaqr1_(ptr noundef nonnull @c__3, ptr noundef %701, ptr noundef nonnull %9, ptr noundef %704, ptr noundef nonnull %703, ptr noundef %707) #7
  %708 = load <2 x double>, ptr %707, align 8, !tbaa !9
  store <2 x double> %708, ptr %34, align 16, !tbaa !9
  %709 = getelementptr i8, ptr %706, i64 32
  call void @zlarfg_(ptr noundef nonnull @c__3, ptr noundef nonnull %34, ptr noundef %709, ptr noundef nonnull @c__1, ptr noundef nonnull %707) #7
  %.pre2617 = add nsw i32 %694, 3
  br label %930

710:                                              ; preds = %691
  %711 = mul nsw i64 %indvars.iv2570, %94
  %712 = getelementptr %struct.doublecomplex, ptr %49, i64 %711
  %713 = getelementptr i8, ptr %712, i64 16
  %714 = load double, ptr %713, align 8, !tbaa !11
  %715 = getelementptr i8, ptr %712, i64 48
  %716 = load double, ptr %715, align 8, !tbaa !11
  %717 = getelementptr i8, ptr %712, i64 24
  %718 = load double, ptr %717, align 8, !tbaa !13
  %719 = getelementptr i8, ptr %712, i64 56
  %720 = load double, ptr %719, align 8, !tbaa !13
  %721 = fneg double %718
  %722 = fmul double %720, %721
  %723 = call double @llvm.fmuladd.f64(double %714, double %716, double %722)
  %724 = fmul double %716, %718
  %725 = call double @llvm.fmuladd.f64(double %714, double %720, double %724)
  %726 = add nsw i32 %694, 3
  %727 = add i32 %693, %.023392522
  %728 = mul nsw i32 %727, %41
  %729 = add nsw i32 %726, %728
  %730 = sext i32 %729 to i64
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %730
  %732 = getelementptr inbounds i8, ptr %731, i64 8
  %733 = fneg double %725
  %734 = mul nsw i32 %694, %41
  %735 = add nsw i32 %726, %734
  %736 = load <2 x double>, ptr %731, align 8, !tbaa !9
  %737 = insertelement <2 x double> poison, double %725, i64 0
  %738 = insertelement <2 x double> %737, double %733, i64 1
  %739 = fmul <2 x double> %736, %738
  %740 = shufflevector <2 x double> %739, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %741 = insertelement <2 x double> poison, double %723, i64 0
  %742 = shufflevector <2 x double> %741, <2 x double> poison, <2 x i32> zeroinitializer
  %743 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %742, <2 x double> %736, <2 x double> %740)
  %744 = fneg <2 x double> %743
  store <2 x double> %744, ptr %25, align 16, !tbaa !9
  %745 = sext i32 %735 to i64
  %746 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %745
  store <2 x double> %744, ptr %746, align 8, !tbaa !9
  %747 = add nsw i32 %694, 1
  %748 = mul nsw i32 %747, %41
  %749 = add nsw i32 %748, %726
  store <2 x double> %744, ptr %26, align 16, !tbaa !9
  %750 = getelementptr i8, ptr %712, i64 32
  %751 = call { double, double } @Cd(ptr noundef %750)
  %752 = extractvalue { double, double } %751, 0
  %753 = extractvalue { double, double } %751, 1
  %754 = fneg double %753
  %755 = call ptr @_pCd(ptr noundef nonnull %27)
  %756 = getelementptr inbounds i8, ptr %755, i64 8
  store double %752, ptr %755, align 8
  store double %754, ptr %756, align 8
  %757 = load <2 x double>, ptr %26, align 16
  %758 = load double, ptr %83, align 8, !tbaa !13
  %759 = fneg double %758
  %760 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %761 = insertelement <2 x double> poison, double %758, i64 0
  %762 = insertelement <2 x double> %761, double %759, i64 1
  %763 = fmul <2 x double> %760, %762
  %764 = shufflevector <2 x double> %763, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %765 = shufflevector <2 x double> %757, <2 x double> poison, <2 x i32> zeroinitializer
  %766 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %765, <2 x double> %760, <2 x double> %764)
  store <2 x double> %766, ptr %25, align 16, !tbaa !9
  %767 = sext i32 %749 to i64
  %768 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %767
  %769 = getelementptr inbounds i8, ptr %768, i64 8
  store <2 x double> %766, ptr %768, align 8, !tbaa !9
  %770 = call { double, double } @Cd(ptr noundef nonnull %715)
  %771 = extractvalue { double, double } %770, 0
  %772 = extractvalue { double, double } %770, 1
  %773 = fneg double %772
  %774 = call ptr @_pCd(ptr noundef nonnull %27)
  %775 = getelementptr inbounds i8, ptr %774, i64 8
  store double %771, ptr %774, align 8
  store double %773, ptr %775, align 8
  %776 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %777 = shufflevector <2 x double> %743, <2 x double> %744, <2 x i32> <i32 1, i32 3>
  %778 = fmul <2 x double> %776, %777
  %779 = shufflevector <2 x double> %778, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %780 = shufflevector <2 x double> %743, <2 x double> poison, <2 x i32> zeroinitializer
  %781 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %780, <2 x double> %776, <2 x double> %779)
  store <2 x double> %781, ptr %26, align 16, !tbaa !9
  %782 = load <2 x double>, ptr %731, align 8, !tbaa !9
  %783 = fsub <2 x double> %782, %781
  store <2 x double> %783, ptr %25, align 16, !tbaa !9
  store <2 x double> %783, ptr %731, align 8, !tbaa !9
  %784 = add nsw i32 %747, %734
  %785 = sext i32 %784 to i64
  %786 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %785
  %787 = load <2 x double>, ptr %786, align 8, !tbaa !9
  store <2 x double> %787, ptr %32, align 16, !tbaa !9
  %788 = add nsw i32 %734, %727
  %789 = sext i32 %788 to i64
  %790 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %789
  %791 = load <2 x double>, ptr %790, align 8, !tbaa !9
  store <2 x double> %791, ptr %750, align 8, !tbaa !9
  %792 = load <2 x double>, ptr %746, align 8, !tbaa !9
  store <2 x double> %792, ptr %715, align 8, !tbaa !9
  call void @zlarfg_(ptr noundef nonnull @c__3, ptr noundef nonnull %32, ptr noundef nonnull %750, ptr noundef nonnull @c__1, ptr noundef nonnull %713) #7
  %793 = load double, ptr %746, align 8, !tbaa !11
  %794 = fcmp une double %793, 0.000000e+00
  br i1 %794, label %811, label %795

795:                                              ; preds = %710
  %796 = getelementptr inbounds i8, ptr %746, i64 8
  %797 = load double, ptr %796, align 8, !tbaa !13
  %798 = fcmp une double %797, 0.000000e+00
  br i1 %798, label %811, label %799

799:                                              ; preds = %795
  %800 = load double, ptr %768, align 8, !tbaa !11
  %801 = fcmp une double %800, 0.000000e+00
  br i1 %801, label %811, label %802

802:                                              ; preds = %799
  %803 = load double, ptr %769, align 8, !tbaa !13
  %804 = fcmp une double %803, 0.000000e+00
  br i1 %804, label %811, label %805

805:                                              ; preds = %802
  %806 = load double, ptr %731, align 8, !tbaa !11
  %807 = fcmp oeq double %806, 0.000000e+00
  br i1 %807, label %808, label %813

808:                                              ; preds = %805
  %809 = load double, ptr %732, align 8, !tbaa !13
  %810 = fcmp oeq double %809, 0.000000e+00
  br i1 %810, label %811, label %813

811:                                              ; preds = %808, %802, %799, %795, %710
  %812 = load <2 x double>, ptr %32, align 16, !tbaa !9
  store <2 x double> %812, ptr %786, align 8, !tbaa !9
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %790, i8 0, i64 16, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %746, i8 0, i64 16, i1 false)
  br label %930

813:                                              ; preds = %808, %805
  %814 = add nsw i32 %748, %747
  %815 = sext i32 %814 to i64
  %816 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %815
  %817 = sext i32 %693 to i64
  %818 = getelementptr %struct.doublecomplex, ptr %40, i64 %817
  %819 = getelementptr i8, ptr %818, i64 -16
  call void @zlaqr1_(ptr noundef nonnull @c__3, ptr noundef %816, ptr noundef nonnull %9, ptr noundef %819, ptr noundef nonnull %818, ptr noundef nonnull %36) #7
  %820 = load <2 x double>, ptr %36, align 16, !tbaa !9
  store <2 x double> %820, ptr %34, align 16, !tbaa !9
  call void @zlarfg_(ptr noundef nonnull @c__3, ptr noundef nonnull %34, ptr noundef nonnull %85, ptr noundef nonnull @c__1, ptr noundef nonnull %36) #7
  %821 = call { double, double } @Cd(ptr noundef nonnull %36)
  %822 = extractvalue { double, double } %821, 0
  %823 = extractvalue { double, double } %821, 1
  %824 = fneg double %823
  %825 = call ptr @_pCd(ptr noundef nonnull %26)
  %826 = getelementptr inbounds i8, ptr %825, i64 8
  store double %822, ptr %825, align 8
  store double %824, ptr %826, align 8
  %827 = call { double, double } @Cd(ptr noundef nonnull %85)
  %828 = extractvalue { double, double } %827, 0
  %829 = extractvalue { double, double } %827, 1
  %830 = fneg double %829
  %831 = call ptr @_pCd(ptr noundef nonnull %29)
  %832 = getelementptr inbounds i8, ptr %831, i64 8
  store double %828, ptr %831, align 8
  store double %830, ptr %832, align 8
  %833 = load <2 x double>, ptr %29, align 16
  %834 = load double, ptr %84, align 8, !tbaa !13
  %835 = fneg double %834
  %836 = load <2 x double>, ptr %26, align 16
  %837 = load double, ptr %83, align 8, !tbaa !13
  %838 = fneg double %837
  %839 = load <2 x double>, ptr %790, align 8, !tbaa !9
  %840 = insertelement <2 x double> poison, double %834, i64 0
  %841 = insertelement <2 x double> %840, double %835, i64 1
  %842 = fmul <2 x double> %839, %841
  %843 = shufflevector <2 x double> %842, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %844 = shufflevector <2 x double> %833, <2 x double> poison, <2 x i32> zeroinitializer
  %845 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %844, <2 x double> %839, <2 x double> %843)
  %846 = load <2 x double>, ptr %786, align 8, !tbaa !9
  %847 = fadd <2 x double> %845, %846
  %848 = insertelement <2 x double> poison, double %837, i64 0
  %849 = insertelement <2 x double> %848, double %838, i64 1
  %850 = fmul <2 x double> %847, %849
  %851 = shufflevector <2 x double> %850, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %852 = shufflevector <2 x double> %836, <2 x double> poison, <2 x i32> zeroinitializer
  %853 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %852, <2 x double> %847, <2 x double> %851)
  %854 = load <2 x double>, ptr %85, align 16, !tbaa !9
  %855 = shufflevector <2 x double> %853, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %856 = fneg <2 x double> %853
  %857 = shufflevector <2 x double> %855, <2 x double> %856, <2 x i32> <i32 0, i32 3>
  %858 = fmul <2 x double> %854, %857
  %859 = shufflevector <2 x double> %858, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %860 = shufflevector <2 x double> %853, <2 x double> poison, <2 x i32> zeroinitializer
  %861 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %860, <2 x double> %854, <2 x double> %859)
  store <2 x double> %861, ptr %27, align 16, !tbaa !9
  %862 = fsub <2 x double> %839, %861
  store <2 x double> %862, ptr %26, align 16, !tbaa !9
  store <2 x double> %862, ptr %25, align 16, !tbaa !9
  %863 = load <2 x double>, ptr %86, align 16, !tbaa !9
  %864 = fmul <2 x double> %863, %857
  %865 = shufflevector <2 x double> %864, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %866 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %860, <2 x double> %863, <2 x double> %865)
  store <2 x double> %866, ptr %29, align 16, !tbaa !9
  store <2 x double> %866, ptr %28, align 16, !tbaa !9
  %867 = add nsw i32 %734, %694
  %868 = add nsw i32 %728, %727
  %869 = call { double, double } @Cd(ptr noundef nonnull %25)
  %870 = extractvalue { double, double } %869, 1
  %871 = load double, ptr %28, align 16, !tbaa !11
  %872 = call { double, double } @Cd(ptr noundef nonnull %28)
  %873 = extractvalue { double, double } %872, 1
  %874 = insertelement <2 x double> %862, double %871, i64 1
  %875 = fcmp oge <2 x double> %874, zeroinitializer
  %876 = fneg <2 x double> %874
  %877 = select <2 x i1> %875, <2 x double> %874, <2 x double> %876
  %878 = insertelement <2 x double> poison, double %870, i64 0
  %879 = insertelement <2 x double> %878, double %873, i64 1
  %880 = fcmp oge <2 x double> %879, zeroinitializer
  %881 = fneg <2 x double> %879
  %882 = select <2 x i1> %880, <2 x double> %879, <2 x double> %881
  %883 = fadd <2 x double> %877, %882
  %884 = sext i32 %867 to i64
  %885 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %884
  %886 = load double, ptr %885, align 8, !tbaa !11
  %887 = call { double, double } @Cd(ptr noundef nonnull %885)
  %888 = extractvalue { double, double } %887, 1
  %889 = load double, ptr %816, align 8, !tbaa !11
  %890 = call { double, double } @Cd(ptr noundef nonnull %816)
  %891 = extractvalue { double, double } %890, 1
  %892 = insertelement <2 x double> poison, double %889, i64 0
  %893 = insertelement <2 x double> %892, double %891, i64 1
  %894 = fcmp oge <2 x double> %893, zeroinitializer
  %895 = fneg <2 x double> %893
  %896 = select <2 x i1> %894, <2 x double> %893, <2 x double> %895
  %shift2697 = shufflevector <2 x double> %896, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %897 = fadd <2 x double> %896, %shift2697
  %898 = sext i32 %868 to i64
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %898
  %900 = load double, ptr %899, align 8, !tbaa !11
  %901 = call { double, double } @Cd(ptr noundef nonnull %899)
  %902 = extractvalue { double, double } %901, 1
  %903 = insertelement <2 x double> poison, double %886, i64 0
  %904 = insertelement <2 x double> %903, double %900, i64 1
  %905 = fcmp oge <2 x double> %904, zeroinitializer
  %906 = fneg <2 x double> %904
  %907 = select <2 x i1> %905, <2 x double> %904, <2 x double> %906
  %908 = insertelement <2 x double> poison, double %888, i64 0
  %909 = insertelement <2 x double> %908, double %902, i64 1
  %910 = fcmp oge <2 x double> %909, zeroinitializer
  %911 = fneg <2 x double> %909
  %912 = select <2 x i1> %910, <2 x double> %909, <2 x double> %911
  %913 = fadd <2 x double> %907, %912
  %914 = fadd <2 x double> %913, %897
  %915 = shufflevector <2 x double> %883, <2 x double> %914, <2 x i32> <i32 0, i32 2>
  %916 = shufflevector <2 x double> %883, <2 x double> %913, <2 x i32> <i32 1, i32 3>
  %917 = fadd <2 x double> %915, %916
  %918 = extractelement <2 x double> %917, i64 1
  %919 = fmul double %61, %918
  %920 = extractelement <2 x double> %917, i64 0
  %921 = fcmp ogt double %920, %919
  br i1 %921, label %922, label %924

922:                                              ; preds = %813
  %923 = load <2 x double>, ptr %32, align 16, !tbaa !9
  store <2 x double> %923, ptr %786, align 8, !tbaa !9
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %790, i8 0, i64 16, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %746, i8 0, i64 16, i1 false)
  br label %930

924:                                              ; preds = %813
  %925 = load <2 x double>, ptr %786, align 8, !tbaa !9
  %926 = fsub <2 x double> %925, %853
  store <2 x double> %926, ptr %25, align 16, !tbaa !9
  store <2 x double> %926, ptr %786, align 8, !tbaa !9
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %790, i8 0, i64 16, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %746, i8 0, i64 16, i1 false)
  %927 = load <2 x double>, ptr %36, align 16, !tbaa !9
  store <2 x double> %927, ptr %713, align 8, !tbaa !9
  %928 = load <2 x double>, ptr %85, align 16, !tbaa !9
  store <2 x double> %928, ptr %750, align 8, !tbaa !9
  %929 = load <2 x double>, ptr %86, align 16, !tbaa !9
  store <2 x double> %929, ptr %715, align 8, !tbaa !9
  br label %930

930:                                              ; preds = %811, %924, %922, %698
  %.pre-phi = phi i32 [ %726, %811 ], [ %726, %924 ], [ %726, %922 ], [ %.pre2617, %698 ]
  %931 = load i32, ptr %5, align 4, !tbaa !5
  %932 = call i32 @llvm.smin.i32(i32 %931, i32 %.pre-phi)
  %.not24352485 = icmp sgt i32 %.023552459, %932
  %.pre2618 = mul nsw i64 %indvars.iv2570, %94
  %.pre2620 = add nsw i32 %694, 1
  %.pre2622 = mul nsw i32 %.pre2620, %41
  %.pre2624 = add i32 %693, %.023392522
  br i1 %.not24352485, label %._crit_edge2489, label %.lr.ph2488

.lr.ph2488:                                       ; preds = %930
  %933 = mul nsw i32 %.pre2624, %41
  %934 = getelementptr %struct.doublecomplex, ptr %49, i64 %.pre2618
  %935 = getelementptr i8, ptr %934, i64 32
  %936 = getelementptr i8, ptr %934, i64 40
  %937 = mul nsw i32 %.pre-phi, %41
  %938 = getelementptr i8, ptr %934, i64 48
  %939 = getelementptr i8, ptr %934, i64 56
  %940 = getelementptr i8, ptr %934, i64 16
  %941 = getelementptr i8, ptr %934, i64 24
  %942 = sext i32 %.pre2622 to i64
  %943 = sext i32 %933 to i64
  %944 = sext i32 %937 to i64
  %945 = sext i32 %932 to i64
  %invariant.gep2655 = getelementptr %struct.doublecomplex, ptr %43, i64 %943
  %invariant.gep2657 = getelementptr %struct.doublecomplex, ptr %43, i64 %942
  %invariant.gep2659 = getelementptr %struct.doublecomplex, ptr %43, i64 %944
  br label %946

946:                                              ; preds = %.lr.ph2488, %946
  %indvars.iv2567 = phi i64 [ %113, %.lr.ph2488 ], [ %indvars.iv.next2568, %946 ]
  %947 = load double, ptr %935, align 8, !tbaa !11
  %gep2656 = getelementptr %struct.doublecomplex, ptr %invariant.gep2655, i64 %indvars.iv2567
  %948 = load double, ptr %936, align 8, !tbaa !13
  %949 = fneg double %948
  %950 = load <2 x double>, ptr %gep2656, align 8, !tbaa !9
  %951 = insertelement <2 x double> poison, double %948, i64 0
  %952 = insertelement <2 x double> %951, double %949, i64 1
  %953 = fmul <2 x double> %950, %952
  %954 = shufflevector <2 x double> %953, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %955 = insertelement <2 x double> poison, double %947, i64 0
  %956 = shufflevector <2 x double> %955, <2 x double> poison, <2 x i32> zeroinitializer
  %957 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %956, <2 x double> %950, <2 x double> %954)
  store <2 x double> %957, ptr %28, align 16, !tbaa !9
  %gep2658 = getelementptr %struct.doublecomplex, ptr %invariant.gep2657, i64 %indvars.iv2567
  %958 = load <2 x double>, ptr %gep2658, align 8, !tbaa !9
  %959 = fadd <2 x double> %957, %958
  store <2 x double> %959, ptr %27, align 16, !tbaa !9
  %960 = load double, ptr %938, align 8, !tbaa !11
  %gep2660 = getelementptr %struct.doublecomplex, ptr %invariant.gep2659, i64 %indvars.iv2567
  %961 = load double, ptr %939, align 8, !tbaa !13
  %962 = fneg double %961
  %963 = load <2 x double>, ptr %gep2660, align 8, !tbaa !9
  %964 = insertelement <2 x double> poison, double %961, i64 0
  %965 = insertelement <2 x double> %964, double %962, i64 1
  %966 = fmul <2 x double> %963, %965
  %967 = shufflevector <2 x double> %966, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %968 = insertelement <2 x double> poison, double %960, i64 0
  %969 = shufflevector <2 x double> %968, <2 x double> poison, <2 x i32> zeroinitializer
  %970 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %969, <2 x double> %963, <2 x double> %967)
  store <2 x double> %970, ptr %29, align 16, !tbaa !9
  %971 = fadd <2 x double> %959, %970
  store <2 x double> %971, ptr %26, align 16, !tbaa !9
  %972 = load double, ptr %940, align 8, !tbaa !11
  %973 = load double, ptr %941, align 8, !tbaa !13
  %974 = fneg double %973
  %975 = insertelement <2 x double> poison, double %973, i64 0
  %976 = insertelement <2 x double> %975, double %974, i64 1
  %977 = fmul <2 x double> %971, %976
  %978 = shufflevector <2 x double> %977, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %979 = insertelement <2 x double> poison, double %972, i64 0
  %980 = shufflevector <2 x double> %979, <2 x double> poison, <2 x i32> zeroinitializer
  %981 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %980, <2 x double> %971, <2 x double> %978)
  %982 = fsub <2 x double> %958, %981
  store <2 x double> %982, ptr %25, align 16, !tbaa !9
  store <2 x double> %982, ptr %gep2658, align 8, !tbaa !9
  %983 = call { double, double } @Cd(ptr noundef nonnull %935)
  %984 = extractvalue { double, double } %983, 0
  %985 = extractvalue { double, double } %983, 1
  %986 = fneg double %985
  %987 = call ptr @_pCd(ptr noundef nonnull %27)
  %988 = getelementptr inbounds i8, ptr %987, i64 8
  store double %984, ptr %987, align 8
  store double %986, ptr %988, align 8
  %989 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %990 = shufflevector <2 x double> %981, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %991 = fneg <2 x double> %981
  %992 = shufflevector <2 x double> %990, <2 x double> %991, <2 x i32> <i32 0, i32 3>
  %993 = fmul <2 x double> %989, %992
  %994 = shufflevector <2 x double> %993, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %995 = shufflevector <2 x double> %981, <2 x double> poison, <2 x i32> zeroinitializer
  %996 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %995, <2 x double> %989, <2 x double> %994)
  store <2 x double> %996, ptr %26, align 16, !tbaa !9
  %997 = load <2 x double>, ptr %gep2656, align 8, !tbaa !9
  %998 = fsub <2 x double> %997, %996
  store <2 x double> %998, ptr %25, align 16, !tbaa !9
  store <2 x double> %998, ptr %gep2656, align 8, !tbaa !9
  %999 = call { double, double } @Cd(ptr noundef nonnull %938)
  %1000 = extractvalue { double, double } %999, 0
  %1001 = extractvalue { double, double } %999, 1
  %1002 = fneg double %1001
  %1003 = call ptr @_pCd(ptr noundef nonnull %27)
  %1004 = getelementptr inbounds i8, ptr %1003, i64 8
  store double %1000, ptr %1003, align 8
  store double %1002, ptr %1004, align 8
  %1005 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %1006 = fmul <2 x double> %1005, %992
  %1007 = shufflevector <2 x double> %1006, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1008 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %995, <2 x double> %1005, <2 x double> %1007)
  store <2 x double> %1008, ptr %26, align 16, !tbaa !9
  %1009 = load <2 x double>, ptr %gep2660, align 8, !tbaa !9
  %1010 = fsub <2 x double> %1009, %1008
  store <2 x double> %1010, ptr %25, align 16, !tbaa !9
  store <2 x double> %1010, ptr %gep2660, align 8, !tbaa !9
  %indvars.iv.next2568 = add nsw i64 %indvars.iv2567, 1
  %.not2435.not = icmp slt i64 %indvars.iv2567, %945
  br i1 %.not2435.not, label %946, label %._crit_edge2489, !llvm.loop !19

._crit_edge2489:                                  ; preds = %946, %930
  %1011 = getelementptr %struct.doublecomplex, ptr %49, i64 %.pre2618
  %1012 = getelementptr i8, ptr %1011, i64 16
  %1013 = call { double, double } @Cd(ptr noundef %1012)
  %1014 = extractvalue { double, double } %1013, 0
  %1015 = extractvalue { double, double } %1013, 1
  %1016 = fneg double %1015
  %1017 = call ptr @_pCd(ptr noundef nonnull %26)
  %1018 = getelementptr inbounds i8, ptr %1017, i64 8
  store double %1014, ptr %1017, align 8
  store double %1016, ptr %1018, align 8
  %1019 = add nsw i32 %.pre2622, %.pre2620
  %1020 = getelementptr i8, ptr %1011, i64 32
  %1021 = call { double, double } @Cd(ptr noundef %1020)
  %1022 = extractvalue { double, double } %1021, 0
  %1023 = extractvalue { double, double } %1021, 1
  %1024 = fneg double %1023
  %1025 = call ptr @_pCd(ptr noundef nonnull %30)
  %1026 = getelementptr inbounds i8, ptr %1025, i64 8
  store double %1022, ptr %1025, align 8
  store double %1024, ptr %1026, align 8
  %1027 = add nsw i32 %.pre2624, %.pre2622
  %1028 = load <2 x double>, ptr %30, align 16
  %1029 = sext i32 %1027 to i64
  %1030 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1029
  %1031 = load double, ptr %87, align 8, !tbaa !13
  %1032 = fneg double %1031
  %1033 = load <2 x double>, ptr %1030, align 8, !tbaa !9
  %1034 = insertelement <2 x double> poison, double %1031, i64 0
  %1035 = insertelement <2 x double> %1034, double %1032, i64 1
  %1036 = fmul <2 x double> %1033, %1035
  %1037 = shufflevector <2 x double> %1036, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1038 = shufflevector <2 x double> %1028, <2 x double> poison, <2 x i32> zeroinitializer
  %1039 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1038, <2 x double> %1033, <2 x double> %1037)
  store <2 x double> %1039, ptr %29, align 16, !tbaa !9
  %1040 = sext i32 %1019 to i64
  %1041 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1040
  %1042 = load <2 x double>, ptr %1041, align 8, !tbaa !9
  %1043 = fadd <2 x double> %1039, %1042
  store <2 x double> %1043, ptr %28, align 16, !tbaa !9
  %1044 = getelementptr i8, ptr %1011, i64 48
  %1045 = call { double, double } @Cd(ptr noundef %1044)
  %1046 = extractvalue { double, double } %1045, 0
  %1047 = extractvalue { double, double } %1045, 1
  %1048 = fneg double %1047
  %1049 = call ptr @_pCd(ptr noundef nonnull %31)
  %1050 = getelementptr inbounds i8, ptr %1049, i64 8
  store double %1046, ptr %1049, align 8
  store double %1048, ptr %1050, align 8
  %1051 = add nsw i32 %.pre2622, %.pre-phi
  %1052 = load <2 x double>, ptr %31, align 16
  %1053 = sext i32 %1051 to i64
  %1054 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1053
  %1055 = load double, ptr %88, align 8, !tbaa !13
  %1056 = fneg double %1055
  %1057 = load <2 x double>, ptr %1054, align 8, !tbaa !9
  %1058 = insertelement <2 x double> poison, double %1055, i64 0
  %1059 = insertelement <2 x double> %1058, double %1056, i64 1
  %1060 = fmul <2 x double> %1057, %1059
  %1061 = shufflevector <2 x double> %1060, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1062 = shufflevector <2 x double> %1052, <2 x double> poison, <2 x i32> zeroinitializer
  %1063 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1062, <2 x double> %1057, <2 x double> %1061)
  %1064 = load <2 x double>, ptr %28, align 16, !tbaa !9
  %1065 = fadd <2 x double> %1064, %1063
  store <2 x double> %1065, ptr %27, align 16, !tbaa !9
  %1066 = load <2 x double>, ptr %26, align 16
  %1067 = load double, ptr %83, align 8, !tbaa !13
  %1068 = fneg double %1067
  %1069 = insertelement <2 x double> poison, double %1067, i64 0
  %1070 = insertelement <2 x double> %1069, double %1068, i64 1
  %1071 = fmul <2 x double> %1065, %1070
  %1072 = shufflevector <2 x double> %1071, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1073 = shufflevector <2 x double> %1066, <2 x double> poison, <2 x i32> zeroinitializer
  %1074 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1073, <2 x double> %1065, <2 x double> %1072)
  %1075 = load <2 x double>, ptr %1041, align 8, !tbaa !9
  %1076 = fsub <2 x double> %1075, %1074
  store <2 x double> %1076, ptr %1041, align 8, !tbaa !9
  %1077 = load <2 x double>, ptr %1020, align 8, !tbaa !9
  %1078 = shufflevector <2 x double> %1074, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1079 = fneg <2 x double> %1074
  %1080 = shufflevector <2 x double> %1078, <2 x double> %1079, <2 x i32> <i32 0, i32 3>
  %1081 = fmul <2 x double> %1077, %1080
  %1082 = shufflevector <2 x double> %1081, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1083 = shufflevector <2 x double> %1074, <2 x double> poison, <2 x i32> zeroinitializer
  %1084 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1083, <2 x double> %1077, <2 x double> %1082)
  %1085 = load <2 x double>, ptr %1030, align 8, !tbaa !9
  %1086 = fsub <2 x double> %1085, %1084
  store <2 x double> %1086, ptr %1030, align 8, !tbaa !9
  %1087 = load <2 x double>, ptr %1044, align 8, !tbaa !9
  %1088 = fmul <2 x double> %1087, %1080
  %1089 = shufflevector <2 x double> %1088, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1090 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1083, <2 x double> %1087, <2 x double> %1089)
  store <2 x double> %1090, ptr %26, align 16, !tbaa !9
  %1091 = load <2 x double>, ptr %1054, align 8, !tbaa !9
  %1092 = fsub <2 x double> %1091, %1090
  store <2 x double> %1092, ptr %25, align 16, !tbaa !9
  store <2 x double> %1092, ptr %1054, align 8, !tbaa !9
  %1093 = load i32, ptr %4, align 4, !tbaa !5
  %1094 = icmp slt i32 %694, %1093
  br i1 %1094, label %1356, label %1095

1095:                                             ; preds = %._crit_edge2489
  %1096 = mul nsw i32 %694, %41
  %1097 = add nsw i32 %.pre2620, %1096
  %1098 = sext i32 %1097 to i64
  %1099 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1098
  %1100 = load double, ptr %1099, align 8, !tbaa !11
  %1101 = fcmp une double %1100, 0.000000e+00
  br i1 %1101, label %1106, label %1102

1102:                                             ; preds = %1095
  %1103 = getelementptr inbounds i8, ptr %1099, i64 8
  %1104 = load double, ptr %1103, align 8, !tbaa !13
  %1105 = fcmp une double %1104, 0.000000e+00
  br i1 %1105, label %1106, label %1356

1106:                                             ; preds = %1102, %1095
  %1107 = add nsw i32 %1096, %694
  %1108 = sext i32 %1107 to i64
  %1109 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1108
  %1110 = load double, ptr %1109, align 8, !tbaa !11
  %1111 = call { double, double } @Cd(ptr noundef nonnull %1109)
  %1112 = extractvalue { double, double } %1111, 1
  %1113 = load double, ptr %1041, align 8, !tbaa !11
  %1114 = call { double, double } @Cd(ptr noundef nonnull %1041)
  %1115 = extractvalue { double, double } %1114, 1
  %1116 = insertelement <2 x double> poison, double %1110, i64 0
  %1117 = insertelement <2 x double> %1116, double %1113, i64 1
  %1118 = fcmp oge <2 x double> %1117, zeroinitializer
  %1119 = fneg <2 x double> %1117
  %1120 = select <2 x i1> %1118, <2 x double> %1117, <2 x double> %1119
  %1121 = insertelement <2 x double> poison, double %1112, i64 0
  %1122 = insertelement <2 x double> %1121, double %1115, i64 1
  %1123 = fcmp oge <2 x double> %1122, zeroinitializer
  %1124 = fneg <2 x double> %1122
  %1125 = select <2 x i1> %1123, <2 x double> %1122, <2 x double> %1124
  %1126 = fadd <2 x double> %1120, %1125
  %shift2698 = shufflevector <2 x double> %1126, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1127 = fadd <2 x double> %1126, %shift2698
  %1128 = extractelement <2 x double> %1127, i64 0
  %1129 = fcmp oeq double %1128, 0.000000e+00
  br i1 %1129, label %1130, label %1238

1130:                                             ; preds = %1106
  %1131 = load i32, ptr %4, align 4, !tbaa !5
  %.not2436.not = icmp sgt i32 %694, %1131
  br i1 %.not2436.not, label %1132, label %1149

1132:                                             ; preds = %1130
  %1133 = add nsw i32 %694, -1
  %1134 = mul nsw i32 %1133, %41
  %1135 = add nsw i32 %1134, %694
  %1136 = sext i32 %1135 to i64
  %1137 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1136
  %1138 = load double, ptr %1137, align 8, !tbaa !11
  %1139 = call { double, double } @Cd(ptr noundef nonnull %1137)
  %1140 = extractvalue { double, double } %1139, 1
  %1141 = insertelement <2 x double> poison, double %1138, i64 0
  %1142 = insertelement <2 x double> %1141, double %1140, i64 1
  %1143 = fcmp oge <2 x double> %1142, zeroinitializer
  %1144 = fneg <2 x double> %1142
  %1145 = select <2 x i1> %1143, <2 x double> %1142, <2 x double> %1144
  %shift2699 = shufflevector <2 x double> %1145, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1146 = fadd <2 x double> %1145, %shift2699
  %1147 = fadd <2 x double> %1127, %1146
  %1148 = extractelement <2 x double> %1147, i64 0
  %.pre2611 = load i32, ptr %4, align 4, !tbaa !5
  br label %1149

1149:                                             ; preds = %1132, %1130
  %1150 = phi i32 [ %.pre2611, %1132 ], [ %1131, %1130 ]
  %.6 = phi double [ %1148, %1132 ], [ %1128, %1130 ]
  %1151 = add nsw i32 %1150, 2
  %.not2437 = icmp slt i32 %694, %1151
  br i1 %.not2437, label %1169, label %1152

1152:                                             ; preds = %1149
  %1153 = add nsw i32 %694, -2
  %1154 = mul nsw i32 %1153, %41
  %1155 = add nsw i32 %1154, %694
  %1156 = sext i32 %1155 to i64
  %1157 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1156
  %1158 = load double, ptr %1157, align 8, !tbaa !11
  %1159 = call { double, double } @Cd(ptr noundef nonnull %1157)
  %1160 = extractvalue { double, double } %1159, 1
  %1161 = insertelement <2 x double> poison, double %1158, i64 0
  %1162 = insertelement <2 x double> %1161, double %1160, i64 1
  %1163 = fcmp oge <2 x double> %1162, zeroinitializer
  %1164 = fneg <2 x double> %1162
  %1165 = select <2 x i1> %1163, <2 x double> %1162, <2 x double> %1164
  %shift2700 = shufflevector <2 x double> %1165, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1166 = fadd <2 x double> %1165, %shift2700
  %1167 = extractelement <2 x double> %1166, i64 0
  %1168 = fadd double %.6, %1167
  %.pre2612 = load i32, ptr %4, align 4, !tbaa !5
  br label %1169

1169:                                             ; preds = %1152, %1149
  %1170 = phi i32 [ %.pre2612, %1152 ], [ %1150, %1149 ]
  %.7 = phi double [ %1168, %1152 ], [ %.6, %1149 ]
  %1171 = add nsw i32 %1170, 3
  %.not2438 = icmp slt i32 %694, %1171
  br i1 %.not2438, label %1189, label %1172

1172:                                             ; preds = %1169
  %1173 = add nsw i32 %694, -3
  %1174 = mul nsw i32 %1173, %41
  %1175 = add nsw i32 %1174, %694
  %1176 = sext i32 %1175 to i64
  %1177 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1176
  %1178 = load double, ptr %1177, align 8, !tbaa !11
  %1179 = call { double, double } @Cd(ptr noundef nonnull %1177)
  %1180 = extractvalue { double, double } %1179, 1
  %1181 = insertelement <2 x double> poison, double %1178, i64 0
  %1182 = insertelement <2 x double> %1181, double %1180, i64 1
  %1183 = fcmp oge <2 x double> %1182, zeroinitializer
  %1184 = fneg <2 x double> %1182
  %1185 = select <2 x i1> %1183, <2 x double> %1182, <2 x double> %1184
  %shift2701 = shufflevector <2 x double> %1185, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1186 = fadd <2 x double> %1185, %shift2701
  %1187 = extractelement <2 x double> %1186, i64 0
  %1188 = fadd double %.7, %1187
  br label %1189

1189:                                             ; preds = %1172, %1169
  %.8 = phi double [ %1188, %1172 ], [ %.7, %1169 ]
  %1190 = load i32, ptr %5, align 4, !tbaa !5
  %1191 = add nsw i32 %1190, -2
  %.not2439 = icmp sgt i32 %694, %1191
  br i1 %.not2439, label %1204, label %1192

1192:                                             ; preds = %1189
  %1193 = load double, ptr %1030, align 8, !tbaa !11
  %1194 = call { double, double } @Cd(ptr noundef nonnull %1030)
  %1195 = extractvalue { double, double } %1194, 1
  %1196 = insertelement <2 x double> poison, double %1193, i64 0
  %1197 = insertelement <2 x double> %1196, double %1195, i64 1
  %1198 = fcmp oge <2 x double> %1197, zeroinitializer
  %1199 = fneg <2 x double> %1197
  %1200 = select <2 x i1> %1198, <2 x double> %1197, <2 x double> %1199
  %shift2702 = shufflevector <2 x double> %1200, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1201 = fadd <2 x double> %1200, %shift2702
  %1202 = extractelement <2 x double> %1201, i64 0
  %1203 = fadd double %.8, %1202
  %.pre2613 = load i32, ptr %5, align 4, !tbaa !5
  br label %1204

1204:                                             ; preds = %1192, %1189
  %1205 = phi i32 [ %.pre2613, %1192 ], [ %1190, %1189 ]
  %.9 = phi double [ %1203, %1192 ], [ %.8, %1189 ]
  %1206 = add nsw i32 %1205, -3
  %.not2440 = icmp sgt i32 %694, %1206
  br i1 %.not2440, label %1219, label %1207

1207:                                             ; preds = %1204
  %1208 = load double, ptr %1054, align 8, !tbaa !11
  %1209 = call { double, double } @Cd(ptr noundef nonnull %1054)
  %1210 = extractvalue { double, double } %1209, 1
  %1211 = insertelement <2 x double> poison, double %1208, i64 0
  %1212 = insertelement <2 x double> %1211, double %1210, i64 1
  %1213 = fcmp oge <2 x double> %1212, zeroinitializer
  %1214 = fneg <2 x double> %1212
  %1215 = select <2 x i1> %1213, <2 x double> %1212, <2 x double> %1214
  %shift2703 = shufflevector <2 x double> %1215, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1216 = fadd <2 x double> %1215, %shift2703
  %1217 = extractelement <2 x double> %1216, i64 0
  %1218 = fadd double %.9, %1217
  %.pre2614 = load i32, ptr %5, align 4, !tbaa !5
  br label %1219

1219:                                             ; preds = %1207, %1204
  %1220 = phi i32 [ %.pre2614, %1207 ], [ %1205, %1204 ]
  %.10 = phi double [ %1218, %1207 ], [ %.9, %1204 ]
  %1221 = add nsw i32 %1220, -4
  %.not2441 = icmp sgt i32 %694, %1221
  br i1 %.not2441, label %1238, label %1222

1222:                                             ; preds = %1219
  %1223 = add nsw i32 %694, 4
  %1224 = add nsw i32 %1223, %.pre2622
  %1225 = sext i32 %1224 to i64
  %1226 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1225
  %1227 = load double, ptr %1226, align 8, !tbaa !11
  %1228 = call { double, double } @Cd(ptr noundef nonnull %1226)
  %1229 = extractvalue { double, double } %1228, 1
  %1230 = insertelement <2 x double> poison, double %1227, i64 0
  %1231 = insertelement <2 x double> %1230, double %1229, i64 1
  %1232 = fcmp oge <2 x double> %1231, zeroinitializer
  %1233 = fneg <2 x double> %1231
  %1234 = select <2 x i1> %1232, <2 x double> %1231, <2 x double> %1233
  %shift2704 = shufflevector <2 x double> %1234, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1235 = fadd <2 x double> %1234, %shift2704
  %1236 = extractelement <2 x double> %1235, i64 0
  %1237 = fadd double %.10, %1236
  br label %1238

1238:                                             ; preds = %1219, %1222, %1106
  %.11 = phi double [ %1237, %1222 ], [ %.10, %1219 ], [ %1128, %1106 ]
  %1239 = fmul double %61, %.11
  %1240 = load double, ptr %1099, align 8, !tbaa !11
  %1241 = call { double, double } @Cd(ptr noundef nonnull %1099)
  %1242 = extractvalue { double, double } %1241, 1
  %1243 = insertelement <2 x double> poison, double %1240, i64 0
  %1244 = insertelement <2 x double> %1243, double %1242, i64 1
  %1245 = fcmp oge <2 x double> %1244, zeroinitializer
  %1246 = fneg <2 x double> %1244
  %1247 = select <2 x i1> %1245, <2 x double> %1244, <2 x double> %1246
  %shift2705 = shufflevector <2 x double> %1247, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1248 = fadd <2 x double> %1247, %shift2705
  %1249 = extractelement <2 x double> %1248, i64 0
  %1250 = fcmp oge double %66, %1239
  %1251 = select i1 %1250, double %66, double %1239
  %1252 = fcmp ugt double %1249, %1251
  br i1 %1252, label %1356, label %1253

1253:                                             ; preds = %1238
  %1254 = add nsw i32 %.pre2622, %694
  %1255 = load double, ptr %1099, align 8, !tbaa !11
  %1256 = call { double, double } @Cd(ptr noundef nonnull %1099)
  %1257 = extractvalue { double, double } %1256, 1
  %1258 = sext i32 %1254 to i64
  %1259 = getelementptr inbounds %struct.doublecomplex, ptr %43, i64 %1258
  %1260 = load double, ptr %1259, align 8, !tbaa !11
  %1261 = call { double, double } @Cd(ptr noundef nonnull %1259)
  %1262 = extractvalue { double, double } %1261, 1
  %1263 = load double, ptr %1099, align 8, !tbaa !11
  %1264 = call { double, double } @Cd(ptr noundef nonnull %1099)
  %1265 = load double, ptr %1259, align 8, !tbaa !11
  %1266 = call { double, double } @Cd(ptr noundef nonnull %1259)
  %1267 = load <2 x double>, ptr %1109, align 8, !tbaa !9
  %1268 = load <2 x double>, ptr %1041, align 8, !tbaa !9
  %1269 = fsub <2 x double> %1267, %1268
  store <2 x double> %1269, ptr %26, align 16, !tbaa !9
  store <2 x double> %1269, ptr %25, align 16, !tbaa !9
  %1270 = call { double, double } @Cd(ptr noundef nonnull %1041)
  %1271 = extractvalue { double, double } %1270, 1
  %1272 = load double, ptr %25, align 16, !tbaa !11
  %1273 = call { double, double } @Cd(ptr noundef nonnull %25)
  %1274 = extractvalue { double, double } %1273, 1
  %1275 = shufflevector <2 x double> %1268, <2 x double> poison, <2 x i32> <i32 poison, i32 0>
  %1276 = insertelement <2 x double> %1275, double %1255, i64 0
  %1277 = fcmp oge <2 x double> %1276, zeroinitializer
  %1278 = fneg <2 x double> %1276
  %1279 = select <2 x i1> %1277, <2 x double> %1276, <2 x double> %1278
  %1280 = insertelement <2 x double> poison, double %1257, i64 0
  %1281 = insertelement <2 x double> %1280, double %1271, i64 1
  %1282 = fcmp oge <2 x double> %1281, zeroinitializer
  %1283 = fneg <2 x double> %1281
  %1284 = select <2 x i1> %1282, <2 x double> %1281, <2 x double> %1283
  %1285 = fadd <2 x double> %1279, %1284
  %1286 = insertelement <2 x double> poison, double %1260, i64 0
  %1287 = insertelement <2 x double> %1286, double %1272, i64 1
  %1288 = fcmp oge <2 x double> %1287, zeroinitializer
  %1289 = fneg <2 x double> %1287
  %1290 = select <2 x i1> %1288, <2 x double> %1287, <2 x double> %1289
  %1291 = insertelement <2 x double> poison, double %1262, i64 0
  %1292 = insertelement <2 x double> %1291, double %1274, i64 1
  %1293 = fcmp oge <2 x double> %1292, zeroinitializer
  %1294 = fneg <2 x double> %1292
  %1295 = select <2 x i1> %1293, <2 x double> %1292, <2 x double> %1294
  %1296 = fadd <2 x double> %1290, %1295
  %1297 = fcmp oge <2 x double> %1285, %1296
  %1298 = select <2 x i1> %1297, <2 x double> %1285, <2 x double> %1296
  %1299 = load <2 x double>, ptr %1109, align 8, !tbaa !9
  %1300 = load <2 x double>, ptr %1041, align 8, !tbaa !9
  %1301 = fsub <2 x double> %1299, %1300
  store <2 x double> %1301, ptr %26, align 16, !tbaa !9
  store <2 x double> %1301, ptr %25, align 16, !tbaa !9
  %1302 = extractelement <2 x double> %1300, i64 0
  %1303 = fcmp oge double %1302, 0.000000e+00
  %1304 = fneg double %1302
  %1305 = select i1 %1303, double %1302, double %1304
  %1306 = call { double, double } @Cd(ptr noundef nonnull %1041)
  %1307 = extractvalue { double, double } %1306, 1
  %1308 = fcmp oge double %1307, 0.000000e+00
  %1309 = fneg double %1307
  %1310 = select i1 %1308, double %1307, double %1309
  %1311 = fadd double %1305, %1310
  %1312 = load <2 x double>, ptr %25, align 16
  %1313 = call { double, double } @Cd(ptr noundef nonnull %25)
  %1314 = extractvalue { double, double } %1313, 1
  %1315 = insertelement <2 x double> %1312, double %1314, i64 1
  %1316 = fcmp oge <2 x double> %1315, zeroinitializer
  %1317 = fneg <2 x double> %1315
  %1318 = select <2 x i1> %1316, <2 x double> %1315, <2 x double> %1317
  %shift2706 = shufflevector <2 x double> %1318, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1319 = fadd <2 x double> %1318, %shift2706
  %1320 = extractelement <2 x double> %1319, i64 0
  %1321 = fcmp ole double %1311, %1320
  %1322 = select i1 %1321, double %1311, double %1320
  %1323 = extractelement <2 x double> %1298, i64 0
  %1324 = extractelement <2 x double> %1298, i64 1
  %1325 = fadd double %1323, %1324
  %1326 = fdiv double %1324, %1325
  %1327 = fmul double %1326, %1322
  %1328 = fcmp oeq double %1327, 0.000000e+00
  br i1 %1328, label %1355, label %1329

1329:                                             ; preds = %1253
  %1330 = fmul double %61, %1327
  %1331 = extractvalue { double, double } %1264, 1
  %1332 = insertelement <2 x double> poison, double %1263, i64 0
  %1333 = insertelement <2 x double> %1332, double %1331, i64 1
  %1334 = fcmp oge <2 x double> %1333, zeroinitializer
  %1335 = fneg <2 x double> %1333
  %1336 = select <2 x i1> %1334, <2 x double> %1333, <2 x double> %1335
  %1337 = extractvalue { double, double } %1266, 1
  %1338 = insertelement <2 x double> poison, double %1265, i64 0
  %1339 = insertelement <2 x double> %1338, double %1337, i64 1
  %1340 = fcmp oge <2 x double> %1339, zeroinitializer
  %1341 = fneg <2 x double> %1339
  %1342 = select <2 x i1> %1340, <2 x double> %1339, <2 x double> %1341
  %1343 = shufflevector <2 x double> %1336, <2 x double> %1342, <2 x i32> <i32 0, i32 2>
  %1344 = shufflevector <2 x double> %1336, <2 x double> %1342, <2 x i32> <i32 1, i32 3>
  %1345 = fadd <2 x double> %1343, %1344
  %1346 = extractelement <2 x double> %1345, i64 0
  %1347 = extractelement <2 x double> %1345, i64 1
  %1348 = fcmp ole double %1346, %1347
  %1349 = select i1 %1348, double %1346, double %1347
  %1350 = fdiv double %1323, %1325
  %1351 = fmul double %1349, %1350
  %1352 = fcmp oge double %66, %1330
  %1353 = select i1 %1352, double %66, double %1330
  %1354 = fcmp ugt double %1351, %1353
  br i1 %1354, label %1356, label %1355

1355:                                             ; preds = %1329, %1253
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %1099, i8 0, i64 16, i1 false)
  br label %1356

1356:                                             ; preds = %1102, %1329, %1355, %1238, %._crit_edge2489
  %indvars.iv.next2571 = add nsw i64 %indvars.iv2570, -1
  %.not2420.not = icmp sgt i64 %indvars.iv2570, %690
  br i1 %.not2420.not, label %691, label %._crit_edge2494, !llvm.loop !20

._crit_edge2494:                                  ; preds = %1356
  br i1 %switch, label %.thread2629, label %1357

._crit_edge2494.thread:                           ; preds = %.loopexit2466
  br i1 %switch, label %.loopexit, label %1357

1357:                                             ; preds = %._crit_edge2494.thread, %._crit_edge2494
  %.not242024902634 = phi i1 [ true, %._crit_edge2494.thread ], [ false, %._crit_edge2494 ]
  %1358 = load i32, ptr %0, align 4, !tbaa !5
  %.not2421 = icmp eq i32 %1358, 0
  %.2686 = select i1 %.not2421, ptr %5, ptr %3
  %1359 = load i32, ptr %.2686, align 4, !tbaa !5
  br i1 %.not242024902634, label %.loopexit, label %.lr.ph2503

.thread2629:                                      ; preds = %._crit_edge2494
  %1360 = load i32, ptr %5, align 4, !tbaa !5
  %.2442 = call i32 @llvm.smin.i32(i32 %105, i32 %1360)
  br label %.lr.ph2503

.lr.ph2503:                                       ; preds = %.thread2629, %1357
  %.123582631 = phi i32 [ %.2442, %.thread2629 ], [ %1359, %1357 ]
  %1361 = add i32 %.023392522, -2
  %1362 = sext i32 %.123582631 to i64
  %1363 = sext i32 %123 to i64
  %smin2577 = call i64 @llvm.smin.i64(i64 %93, i64 %1363)
  %1364 = sext i32 %119 to i64
  br label %1365

1365:                                             ; preds = %.lr.ph2503, %._crit_edge2499
  %indvars.iv2578 = phi i64 [ %smin2577, %.lr.ph2503 ], [ %indvars.iv.next2579, %._crit_edge2499 ]
  %indvars.iv2572 = phi i32 [ %128, %.lr.ph2503 ], [ %indvars.iv.next2573, %._crit_edge2499 ]
  %1366 = trunc nsw i64 %indvars.iv2578 to i32
  %1367 = shl i32 %1366, 1
  %1368 = load i32, ptr %4, align 4, !tbaa !5
  %1369 = add i32 %1367, %.023392522
  %1370 = call i32 @llvm.smax.i32(i32 %1368, i32 %1369)
  %.not24332495 = icmp sgt i32 %1370, %.123582631
  br i1 %.not24332495, label %._crit_edge2499, label %.lr.ph2498

.lr.ph2498:                                       ; preds = %1365
  %1371 = add i32 %1361, %1367
  %1372 = mul nsw i64 %indvars.iv2578, %94
  %1373 = getelementptr %struct.doublecomplex, ptr %49, i64 %1372
  %1374 = getelementptr i8, ptr %1373, i64 16
  %1375 = getelementptr i8, ptr %1373, i64 32
  %1376 = getelementptr i8, ptr %1373, i64 48
  %1377 = call i32 @llvm.smax.i32(i32 %1368, i32 %indvars.iv2572)
  %smax2574 = sext i32 %1377 to i64
  %1378 = sext i32 %1369 to i64
  %invariant.gep2661 = getelementptr %struct.doublecomplex, ptr %43, i64 %1378
  %1379 = sext i32 %1371 to i64
  %1380 = sext i32 %1371 to i64
  %gep2716 = getelementptr %struct.doublecomplex, ptr %invariant.gep2715, i64 %1379
  %gep2718 = getelementptr %struct.doublecomplex, ptr %invariant.gep2717, i64 %1380
  br label %1381

1381:                                             ; preds = %.lr.ph2498, %1381
  %indvars.iv2575 = phi i64 [ %smax2574, %.lr.ph2498 ], [ %indvars.iv.next2576, %1381 ]
  %1382 = call { double, double } @Cd(ptr noundef %1374)
  %1383 = extractvalue { double, double } %1382, 0
  %1384 = extractvalue { double, double } %1382, 1
  %1385 = fneg double %1384
  %1386 = call ptr @_pCd(ptr noundef nonnull %26)
  %1387 = getelementptr inbounds i8, ptr %1386, i64 8
  store double %1383, ptr %1386, align 8
  store double %1385, ptr %1387, align 8
  %1388 = mul nsw i64 %indvars.iv2575, %91
  %1389 = call { double, double } @Cd(ptr noundef %1375)
  %1390 = extractvalue { double, double } %1389, 0
  %1391 = extractvalue { double, double } %1389, 1
  %1392 = fneg double %1391
  %1393 = call ptr @_pCd(ptr noundef nonnull %30)
  %1394 = getelementptr inbounds i8, ptr %1393, i64 8
  store double %1390, ptr %1393, align 8
  store double %1392, ptr %1394, align 8
  %1395 = load <2 x double>, ptr %30, align 16
  %gep2662 = getelementptr %struct.doublecomplex, ptr %invariant.gep2661, i64 %1388
  %1396 = load double, ptr %87, align 8, !tbaa !13
  %1397 = fneg double %1396
  %1398 = load <2 x double>, ptr %gep2662, align 8, !tbaa !9
  %1399 = insertelement <2 x double> poison, double %1396, i64 0
  %1400 = insertelement <2 x double> %1399, double %1397, i64 1
  %1401 = fmul <2 x double> %1398, %1400
  %1402 = shufflevector <2 x double> %1401, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1403 = shufflevector <2 x double> %1395, <2 x double> poison, <2 x i32> zeroinitializer
  %1404 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1403, <2 x double> %1398, <2 x double> %1402)
  store <2 x double> %1404, ptr %29, align 16, !tbaa !9
  %gep2712 = getelementptr %struct.doublecomplex, ptr %gep2716, i64 %1388
  %1405 = load <2 x double>, ptr %gep2712, align 8, !tbaa !9
  %1406 = fadd <2 x double> %1404, %1405
  store <2 x double> %1406, ptr %28, align 16, !tbaa !9
  %1407 = call { double, double } @Cd(ptr noundef %1376)
  %1408 = extractvalue { double, double } %1407, 0
  %1409 = extractvalue { double, double } %1407, 1
  %1410 = fneg double %1409
  %1411 = call ptr @_pCd(ptr noundef nonnull %31)
  %1412 = getelementptr inbounds i8, ptr %1411, i64 8
  store double %1408, ptr %1411, align 8
  store double %1410, ptr %1412, align 8
  %1413 = load <2 x double>, ptr %31, align 16
  %gep2714 = getelementptr %struct.doublecomplex, ptr %gep2718, i64 %1388
  %1414 = load double, ptr %88, align 8, !tbaa !13
  %1415 = fneg double %1414
  %1416 = load <2 x double>, ptr %gep2714, align 8, !tbaa !9
  %1417 = insertelement <2 x double> poison, double %1414, i64 0
  %1418 = insertelement <2 x double> %1417, double %1415, i64 1
  %1419 = fmul <2 x double> %1416, %1418
  %1420 = shufflevector <2 x double> %1419, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1421 = shufflevector <2 x double> %1413, <2 x double> poison, <2 x i32> zeroinitializer
  %1422 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1421, <2 x double> %1416, <2 x double> %1420)
  %1423 = load <2 x double>, ptr %28, align 16, !tbaa !9
  %1424 = fadd <2 x double> %1423, %1422
  store <2 x double> %1424, ptr %27, align 16, !tbaa !9
  %1425 = load <2 x double>, ptr %26, align 16
  %1426 = load double, ptr %83, align 8, !tbaa !13
  %1427 = fneg double %1426
  %1428 = insertelement <2 x double> poison, double %1426, i64 0
  %1429 = insertelement <2 x double> %1428, double %1427, i64 1
  %1430 = fmul <2 x double> %1424, %1429
  %1431 = shufflevector <2 x double> %1430, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1432 = shufflevector <2 x double> %1425, <2 x double> poison, <2 x i32> zeroinitializer
  %1433 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1432, <2 x double> %1424, <2 x double> %1431)
  %1434 = load <2 x double>, ptr %gep2712, align 8, !tbaa !9
  %1435 = fsub <2 x double> %1434, %1433
  store <2 x double> %1435, ptr %gep2712, align 8, !tbaa !9
  %1436 = load <2 x double>, ptr %1375, align 8, !tbaa !9
  %1437 = shufflevector <2 x double> %1433, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1438 = fneg <2 x double> %1433
  %1439 = shufflevector <2 x double> %1437, <2 x double> %1438, <2 x i32> <i32 0, i32 3>
  %1440 = fmul <2 x double> %1436, %1439
  %1441 = shufflevector <2 x double> %1440, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1442 = shufflevector <2 x double> %1433, <2 x double> poison, <2 x i32> zeroinitializer
  %1443 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1442, <2 x double> %1436, <2 x double> %1441)
  %1444 = load <2 x double>, ptr %gep2662, align 8, !tbaa !9
  %1445 = fsub <2 x double> %1444, %1443
  store <2 x double> %1445, ptr %gep2662, align 8, !tbaa !9
  %1446 = load <2 x double>, ptr %1376, align 8, !tbaa !9
  %1447 = fmul <2 x double> %1446, %1439
  %1448 = shufflevector <2 x double> %1447, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1449 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1442, <2 x double> %1446, <2 x double> %1448)
  store <2 x double> %1449, ptr %26, align 16, !tbaa !9
  %1450 = load <2 x double>, ptr %gep2714, align 8, !tbaa !9
  %1451 = fsub <2 x double> %1450, %1449
  store <2 x double> %1451, ptr %25, align 16, !tbaa !9
  store <2 x double> %1451, ptr %gep2714, align 8, !tbaa !9
  %indvars.iv.next2576 = add nsw i64 %indvars.iv2575, 1
  %.not2433.not = icmp slt i64 %indvars.iv2575, %1362
  br i1 %.not2433.not, label %1381, label %._crit_edge2499, !llvm.loop !21

._crit_edge2499:                                  ; preds = %1381, %1365
  %indvars.iv.next2579 = add nsw i64 %indvars.iv2578, -1
  %.not2423.not = icmp sgt i64 %indvars.iv2578, %1364
  %indvars.iv.next2573 = add i32 %indvars.iv2572, -2
  br i1 %.not2423.not, label %1365, label %._crit_edge2504, !llvm.loop !22

._crit_edge2504:                                  ; preds = %._crit_edge2499
  br i1 %switch, label %.lr.ph2520, label %1555

.lr.ph2520:                                       ; preds = %._crit_edge2504
  %1452 = add i32 %111, %.023392522
  %1453 = sub i32 %.neg, %.023392522
  %1454 = add i32 %112, %.023392522
  %1455 = add i32 %1454, %127
  %1456 = add i32 %127, -1
  %1457 = sext i32 %123 to i64
  %smin2595 = call i64 @llvm.smin.i64(i64 %93, i64 %1457)
  %1458 = sext i32 %119 to i64
  br label %1459

1459:                                             ; preds = %.lr.ph2520, %._crit_edge2517
  %indvars.iv2596 = phi i64 [ %smin2595, %.lr.ph2520 ], [ %indvars.iv.next2597, %._crit_edge2517 ]
  %indvars.iv2588 = phi i32 [ %1456, %.lr.ph2520 ], [ %indvars.iv.next2589, %._crit_edge2517 ]
  %1460 = trunc nsw i64 %indvars.iv2596 to i32
  %1461 = shl i32 %1460, 1
  %1462 = add i32 %1452, %1461
  %1463 = load i32, ptr %4, align 4, !tbaa !5
  %1464 = sub nsw i32 %1463, %.023402543
  %1465 = add i32 %1453, %1462
  %1466 = call i32 @llvm.smax.i32(i32 %1464, i32 %1465)
  %1467 = call i32 @llvm.smax.i32(i32 %1466, i32 1)
  %1468 = load i32, ptr %39, align 4, !tbaa !5
  %1469 = call i32 @llvm.smin.i32(i32 %1468, i32 %1455)
  %.not24312513 = icmp sgt i32 %1467, %1469
  br i1 %.not24312513, label %._crit_edge2517, label %.lr.ph2516

.lr.ph2516:                                       ; preds = %1459
  %1470 = mul nsw i64 %indvars.iv2596, %94
  %1471 = add nsw i32 %1462, 1
  %1472 = mul nsw i32 %1471, %50
  %1473 = add nsw i32 %1462, 2
  %1474 = mul nsw i32 %1473, %50
  %1475 = getelementptr %struct.doublecomplex, ptr %49, i64 %1470
  %1476 = getelementptr i8, ptr %1475, i64 32
  %1477 = getelementptr i8, ptr %1475, i64 40
  %1478 = add nsw i32 %1462, 3
  %1479 = mul nsw i32 %1478, %50
  %1480 = getelementptr i8, ptr %1475, i64 48
  %1481 = getelementptr i8, ptr %1475, i64 56
  %1482 = getelementptr i8, ptr %1475, i64 16
  %1483 = getelementptr i8, ptr %1475, i64 24
  %1484 = add i32 %indvars.iv2562, %1463
  %smax2590 = call i32 @llvm.smax.i32(i32 %indvars.iv2588, i32 %1484)
  %smax2591 = call i32 @llvm.smax.i32(i32 %smax2590, i32 1)
  %1485 = zext nneg i32 %smax2591 to i64
  %1486 = sext i32 %1472 to i64
  %1487 = sext i32 %1474 to i64
  %1488 = sext i32 %1479 to i64
  %1489 = zext nneg i32 %1469 to i64
  %invariant.gep2673 = getelementptr %struct.doublecomplex, ptr %52, i64 %1487
  %invariant.gep2675 = getelementptr %struct.doublecomplex, ptr %52, i64 %1486
  %invariant.gep2677 = getelementptr %struct.doublecomplex, ptr %52, i64 %1488
  br label %1490

1490:                                             ; preds = %.lr.ph2516, %1490
  %indvars.iv2592 = phi i64 [ %1485, %.lr.ph2516 ], [ %indvars.iv.next2593, %1490 ]
  %1491 = load double, ptr %1476, align 8, !tbaa !11
  %gep2674 = getelementptr %struct.doublecomplex, ptr %invariant.gep2673, i64 %indvars.iv2592
  %1492 = load double, ptr %1477, align 8, !tbaa !13
  %1493 = fneg double %1492
  %1494 = load <2 x double>, ptr %gep2674, align 8, !tbaa !9
  %1495 = insertelement <2 x double> poison, double %1492, i64 0
  %1496 = insertelement <2 x double> %1495, double %1493, i64 1
  %1497 = fmul <2 x double> %1494, %1496
  %1498 = shufflevector <2 x double> %1497, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1499 = insertelement <2 x double> poison, double %1491, i64 0
  %1500 = shufflevector <2 x double> %1499, <2 x double> poison, <2 x i32> zeroinitializer
  %1501 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1500, <2 x double> %1494, <2 x double> %1498)
  store <2 x double> %1501, ptr %28, align 16, !tbaa !9
  %gep2676 = getelementptr %struct.doublecomplex, ptr %invariant.gep2675, i64 %indvars.iv2592
  %1502 = load <2 x double>, ptr %gep2676, align 8, !tbaa !9
  %1503 = fadd <2 x double> %1501, %1502
  store <2 x double> %1503, ptr %27, align 16, !tbaa !9
  %1504 = load double, ptr %1480, align 8, !tbaa !11
  %gep2678 = getelementptr %struct.doublecomplex, ptr %invariant.gep2677, i64 %indvars.iv2592
  %1505 = load double, ptr %1481, align 8, !tbaa !13
  %1506 = fneg double %1505
  %1507 = load <2 x double>, ptr %gep2678, align 8, !tbaa !9
  %1508 = insertelement <2 x double> poison, double %1505, i64 0
  %1509 = insertelement <2 x double> %1508, double %1506, i64 1
  %1510 = fmul <2 x double> %1507, %1509
  %1511 = shufflevector <2 x double> %1510, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1512 = insertelement <2 x double> poison, double %1504, i64 0
  %1513 = shufflevector <2 x double> %1512, <2 x double> poison, <2 x i32> zeroinitializer
  %1514 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1513, <2 x double> %1507, <2 x double> %1511)
  store <2 x double> %1514, ptr %29, align 16, !tbaa !9
  %1515 = fadd <2 x double> %1503, %1514
  store <2 x double> %1515, ptr %26, align 16, !tbaa !9
  %1516 = load double, ptr %1482, align 8, !tbaa !11
  %1517 = load double, ptr %1483, align 8, !tbaa !13
  %1518 = fneg double %1517
  %1519 = insertelement <2 x double> poison, double %1517, i64 0
  %1520 = insertelement <2 x double> %1519, double %1518, i64 1
  %1521 = fmul <2 x double> %1515, %1520
  %1522 = shufflevector <2 x double> %1521, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1523 = insertelement <2 x double> poison, double %1516, i64 0
  %1524 = shufflevector <2 x double> %1523, <2 x double> poison, <2 x i32> zeroinitializer
  %1525 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1524, <2 x double> %1515, <2 x double> %1522)
  %1526 = fsub <2 x double> %1502, %1525
  store <2 x double> %1526, ptr %25, align 16, !tbaa !9
  store <2 x double> %1526, ptr %gep2676, align 8, !tbaa !9
  %1527 = call { double, double } @Cd(ptr noundef nonnull %1476)
  %1528 = extractvalue { double, double } %1527, 0
  %1529 = extractvalue { double, double } %1527, 1
  %1530 = fneg double %1529
  %1531 = call ptr @_pCd(ptr noundef nonnull %27)
  %1532 = getelementptr inbounds i8, ptr %1531, i64 8
  store double %1528, ptr %1531, align 8
  store double %1530, ptr %1532, align 8
  %1533 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %1534 = shufflevector <2 x double> %1525, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1535 = fneg <2 x double> %1525
  %1536 = shufflevector <2 x double> %1534, <2 x double> %1535, <2 x i32> <i32 0, i32 3>
  %1537 = fmul <2 x double> %1533, %1536
  %1538 = shufflevector <2 x double> %1537, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1539 = shufflevector <2 x double> %1525, <2 x double> poison, <2 x i32> zeroinitializer
  %1540 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1539, <2 x double> %1533, <2 x double> %1538)
  store <2 x double> %1540, ptr %26, align 16, !tbaa !9
  %1541 = load <2 x double>, ptr %gep2674, align 8, !tbaa !9
  %1542 = fsub <2 x double> %1541, %1540
  store <2 x double> %1542, ptr %25, align 16, !tbaa !9
  store <2 x double> %1542, ptr %gep2674, align 8, !tbaa !9
  %1543 = call { double, double } @Cd(ptr noundef nonnull %1480)
  %1544 = extractvalue { double, double } %1543, 0
  %1545 = extractvalue { double, double } %1543, 1
  %1546 = fneg double %1545
  %1547 = call ptr @_pCd(ptr noundef nonnull %27)
  %1548 = getelementptr inbounds i8, ptr %1547, i64 8
  store double %1544, ptr %1547, align 8
  store double %1546, ptr %1548, align 8
  %1549 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %1550 = fmul <2 x double> %1549, %1536
  %1551 = shufflevector <2 x double> %1550, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1552 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1539, <2 x double> %1549, <2 x double> %1551)
  store <2 x double> %1552, ptr %26, align 16, !tbaa !9
  %1553 = load <2 x double>, ptr %gep2678, align 8, !tbaa !9
  %1554 = fsub <2 x double> %1553, %1552
  store <2 x double> %1554, ptr %25, align 16, !tbaa !9
  store <2 x double> %1554, ptr %gep2678, align 8, !tbaa !9
  %indvars.iv.next2593 = add nuw nsw i64 %indvars.iv2592, 1
  %.not2431.not = icmp ult i64 %indvars.iv2592, %1489
  br i1 %.not2431.not, label %1490, label %._crit_edge2517, !llvm.loop !23

._crit_edge2517:                                  ; preds = %1490, %1459
  %indvars.iv.next2597 = add nsw i64 %indvars.iv2596, -1
  %.not2427.not = icmp sgt i64 %indvars.iv2596, %1458
  %indvars.iv.next2589 = add i32 %indvars.iv2588, -2
  br i1 %.not2427.not, label %1459, label %.loopexit, !llvm.loop !24

1555:                                             ; preds = %._crit_edge2504
  %1556 = load i32, ptr %1, align 4, !tbaa !5
  %.not2424 = icmp eq i32 %1556, 0
  br i1 %.not2424, label %.loopexit, label %.lr.ph2512

.lr.ph2512:                                       ; preds = %1555
  %1557 = add i32 %.023392522, -2
  %1558 = sext i32 %123 to i64
  %smin2585 = call i64 @llvm.smin.i64(i64 %93, i64 %1558)
  %1559 = sext i32 %119 to i64
  br label %1560

1560:                                             ; preds = %.lr.ph2512, %._crit_edge2509
  %indvars.iv2586 = phi i64 [ %smin2585, %.lr.ph2512 ], [ %indvars.iv.next2587, %._crit_edge2509 ]
  %1561 = load i32, ptr %11, align 4, !tbaa !5
  %1562 = load i32, ptr %10, align 4, !tbaa !5
  %.not24262505 = icmp sgt i32 %1562, %1561
  br i1 %.not24262505, label %._crit_edge2509, label %.lr.ph2508

.lr.ph2508:                                       ; preds = %1560
  %1563 = trunc nsw i64 %indvars.iv2586 to i32
  %1564 = shl i32 %1563, 1
  %1565 = add i32 %1557, %1564
  %1566 = mul nsw i64 %indvars.iv2586, %94
  %1567 = add nsw i32 %1565, 1
  %1568 = mul nsw i32 %1567, %44
  %1569 = add i32 %1564, %.023392522
  %1570 = mul nsw i32 %1569, %44
  %1571 = getelementptr %struct.doublecomplex, ptr %49, i64 %1566
  %1572 = getelementptr i8, ptr %1571, i64 32
  %1573 = getelementptr i8, ptr %1571, i64 40
  %1574 = add nsw i32 %1565, 3
  %1575 = mul nsw i32 %1574, %44
  %1576 = getelementptr i8, ptr %1571, i64 48
  %1577 = getelementptr i8, ptr %1571, i64 56
  %1578 = getelementptr i8, ptr %1571, i64 16
  %1579 = getelementptr i8, ptr %1571, i64 24
  %1580 = sext i32 %1562 to i64
  %1581 = sext i32 %1568 to i64
  %1582 = sext i32 %1570 to i64
  %1583 = sext i32 %1575 to i64
  %1584 = add i32 %1561, 1
  %invariant.gep2667 = getelementptr %struct.doublecomplex, ptr %46, i64 %1582
  %invariant.gep2669 = getelementptr %struct.doublecomplex, ptr %46, i64 %1581
  %invariant.gep2671 = getelementptr %struct.doublecomplex, ptr %46, i64 %1583
  br label %1585

1585:                                             ; preds = %.lr.ph2508, %1585
  %indvars.iv2580 = phi i64 [ %1580, %.lr.ph2508 ], [ %indvars.iv.next2581, %1585 ]
  %1586 = load double, ptr %1572, align 8, !tbaa !11
  %gep2668 = getelementptr %struct.doublecomplex, ptr %invariant.gep2667, i64 %indvars.iv2580
  %1587 = load double, ptr %1573, align 8, !tbaa !13
  %1588 = fneg double %1587
  %1589 = load <2 x double>, ptr %gep2668, align 8, !tbaa !9
  %1590 = insertelement <2 x double> poison, double %1587, i64 0
  %1591 = insertelement <2 x double> %1590, double %1588, i64 1
  %1592 = fmul <2 x double> %1589, %1591
  %1593 = shufflevector <2 x double> %1592, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1594 = insertelement <2 x double> poison, double %1586, i64 0
  %1595 = shufflevector <2 x double> %1594, <2 x double> poison, <2 x i32> zeroinitializer
  %1596 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1595, <2 x double> %1589, <2 x double> %1593)
  store <2 x double> %1596, ptr %28, align 16, !tbaa !9
  %gep2670 = getelementptr %struct.doublecomplex, ptr %invariant.gep2669, i64 %indvars.iv2580
  %1597 = load <2 x double>, ptr %gep2670, align 8, !tbaa !9
  %1598 = fadd <2 x double> %1596, %1597
  store <2 x double> %1598, ptr %27, align 16, !tbaa !9
  %1599 = load double, ptr %1576, align 8, !tbaa !11
  %gep2672 = getelementptr %struct.doublecomplex, ptr %invariant.gep2671, i64 %indvars.iv2580
  %1600 = load double, ptr %1577, align 8, !tbaa !13
  %1601 = fneg double %1600
  %1602 = load <2 x double>, ptr %gep2672, align 8, !tbaa !9
  %1603 = insertelement <2 x double> poison, double %1600, i64 0
  %1604 = insertelement <2 x double> %1603, double %1601, i64 1
  %1605 = fmul <2 x double> %1602, %1604
  %1606 = shufflevector <2 x double> %1605, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1607 = insertelement <2 x double> poison, double %1599, i64 0
  %1608 = shufflevector <2 x double> %1607, <2 x double> poison, <2 x i32> zeroinitializer
  %1609 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1608, <2 x double> %1602, <2 x double> %1606)
  store <2 x double> %1609, ptr %29, align 16, !tbaa !9
  %1610 = fadd <2 x double> %1598, %1609
  store <2 x double> %1610, ptr %26, align 16, !tbaa !9
  %1611 = load double, ptr %1578, align 8, !tbaa !11
  %1612 = load double, ptr %1579, align 8, !tbaa !13
  %1613 = fneg double %1612
  %1614 = insertelement <2 x double> poison, double %1612, i64 0
  %1615 = insertelement <2 x double> %1614, double %1613, i64 1
  %1616 = fmul <2 x double> %1610, %1615
  %1617 = shufflevector <2 x double> %1616, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1618 = insertelement <2 x double> poison, double %1611, i64 0
  %1619 = shufflevector <2 x double> %1618, <2 x double> poison, <2 x i32> zeroinitializer
  %1620 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1619, <2 x double> %1610, <2 x double> %1617)
  %1621 = fsub <2 x double> %1597, %1620
  store <2 x double> %1621, ptr %25, align 16, !tbaa !9
  store <2 x double> %1621, ptr %gep2670, align 8, !tbaa !9
  %1622 = call { double, double } @Cd(ptr noundef nonnull %1572)
  %1623 = extractvalue { double, double } %1622, 0
  %1624 = extractvalue { double, double } %1622, 1
  %1625 = fneg double %1624
  %1626 = call ptr @_pCd(ptr noundef nonnull %27)
  %1627 = getelementptr inbounds i8, ptr %1626, i64 8
  store double %1623, ptr %1626, align 8
  store double %1625, ptr %1627, align 8
  %1628 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %1629 = shufflevector <2 x double> %1620, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %1630 = fneg <2 x double> %1620
  %1631 = shufflevector <2 x double> %1629, <2 x double> %1630, <2 x i32> <i32 0, i32 3>
  %1632 = fmul <2 x double> %1628, %1631
  %1633 = shufflevector <2 x double> %1632, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1634 = shufflevector <2 x double> %1620, <2 x double> poison, <2 x i32> zeroinitializer
  %1635 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1634, <2 x double> %1628, <2 x double> %1633)
  store <2 x double> %1635, ptr %26, align 16, !tbaa !9
  %1636 = load <2 x double>, ptr %gep2668, align 8, !tbaa !9
  %1637 = fsub <2 x double> %1636, %1635
  store <2 x double> %1637, ptr %25, align 16, !tbaa !9
  store <2 x double> %1637, ptr %gep2668, align 8, !tbaa !9
  %1638 = call { double, double } @Cd(ptr noundef nonnull %1576)
  %1639 = extractvalue { double, double } %1638, 0
  %1640 = extractvalue { double, double } %1638, 1
  %1641 = fneg double %1640
  %1642 = call ptr @_pCd(ptr noundef nonnull %27)
  %1643 = getelementptr inbounds i8, ptr %1642, i64 8
  store double %1639, ptr %1642, align 8
  store double %1641, ptr %1643, align 8
  %1644 = load <2 x double>, ptr %27, align 16, !tbaa !9
  %1645 = fmul <2 x double> %1644, %1631
  %1646 = shufflevector <2 x double> %1645, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1647 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1634, <2 x double> %1644, <2 x double> %1646)
  store <2 x double> %1647, ptr %26, align 16, !tbaa !9
  %1648 = load <2 x double>, ptr %gep2672, align 8, !tbaa !9
  %1649 = fsub <2 x double> %1648, %1647
  store <2 x double> %1649, ptr %25, align 16, !tbaa !9
  store <2 x double> %1649, ptr %gep2672, align 8, !tbaa !9
  %indvars.iv.next2581 = add nsw i64 %indvars.iv2580, 1
  %lftr.wideiv2583 = trunc i64 %indvars.iv.next2581 to i32
  %exitcond2584.not = icmp eq i32 %1584, %lftr.wideiv2583
  br i1 %exitcond2584.not, label %._crit_edge2509, label %1585, !llvm.loop !25

._crit_edge2509:                                  ; preds = %1585, %1560
  %indvars.iv.next2587 = add nsw i64 %indvars.iv2586, -1
  %.not2425.not = icmp sgt i64 %indvars.iv2586, %1559
  br i1 %.not2425.not, label %1560, label %.loopexit, !llvm.loop !26

.loopexit:                                        ; preds = %._crit_edge2509, %._crit_edge2517, %1357, %.loopexit2466.thread, %._crit_edge2494.thread, %1555
  %1650 = add nsw i32 %.023392522, 1
  %.not2392.not = icmp slt i32 %.023392522, %110
  %indvars.iv.next2555 = add i32 %indvars.iv2554, 1
  br i1 %.not2392.not, label %114, label %._crit_edge2526, !llvm.loop !27

._crit_edge2526:                                  ; preds = %.loopexit, %104
  br i1 %switch, label %1651, label %.loopexit2468

1651:                                             ; preds = %._crit_edge2526
  %1652 = load i32, ptr %0, align 4, !tbaa !5
  %.not2393 = icmp eq i32 %1652, 0
  %.pre2615 = load i32, ptr %4, align 4, !tbaa !5
  %spec.select = select i1 %.not2393, ptr %5, ptr %3
  %spec.select2685 = select i1 %.not2393, i32 %.pre2615, i32 1
  %.22359 = load i32, ptr %spec.select, align 4, !tbaa !5
  %1653 = sub nsw i32 %.pre2615, %.023402543
  %1654 = call i32 @llvm.smax.i32(i32 %1653, i32 1)
  %1655 = load i32, ptr %5, align 4, !tbaa !5
  %1656 = sub nsw i32 %105, %1655
  %1657 = load i32, ptr %39, align 4, !tbaa !5
  %1658 = call i32 @llvm.smax.i32(i32 %1656, i32 0)
  %1659 = add i32 %1657, 1
  %1660 = add nuw i32 %1654, %1658
  %1661 = sub i32 %1659, %1660
  store i32 %1661, ptr %35, align 4, !tbaa !5
  %1662 = load i32, ptr %21, align 4, !tbaa !5
  %.2443 = call i32 @llvm.smin.i32(i32 %105, i32 %1655)
  %1663 = add i32 %.2443, 1
  %1664 = icmp slt i32 %1662, 0
  %1665 = icmp sge i32 %1663, %.22359
  %1666 = icmp slt i32 %.2443, %.22359
  %.in2527 = select i1 %1664, i1 %1665, i1 %1666
  br i1 %.in2527, label %.lr.ph2530, label %._crit_edge2531

.lr.ph2530:                                       ; preds = %1651
  %1667 = add i32 %.22359, 1
  %1668 = mul i32 %1654, %89
  %1669 = sext i32 %1668 to i64
  %1670 = getelementptr inbounds %struct.doublecomplex, ptr %52, i64 %1669
  %1671 = add nsw i32 %1654, %.023402543
  %1672 = sext i32 %1663 to i64
  %1673 = sext i32 %1662 to i64
  %1674 = sext i32 %.22359 to i64
  %1675 = sext i32 %1671 to i64
  %invariant.gep2679 = getelementptr %struct.doublecomplex, ptr %43, i64 %1675
  br label %1676

1676:                                             ; preds = %.lr.ph2530, %1676
  %indvars.iv2599 = phi i64 [ %1672, %.lr.ph2530 ], [ %indvars.iv.next2600, %1676 ]
  %1677 = load i32, ptr %21, align 4, !tbaa !5
  %1678 = trunc nsw i64 %indvars.iv2599 to i32
  %1679 = sub i32 %1667, %1678
  %1680 = call i32 @llvm.smin.i32(i32 %1677, i32 %1679)
  store i32 %1680, ptr %33, align 4, !tbaa !5
  %1681 = mul nsw i64 %indvars.iv2599, %91
  %gep2680 = getelementptr %struct.doublecomplex, ptr %invariant.gep2679, i64 %1681
  call void @zgemm_(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.4, ptr noundef nonnull %35, ptr noundef nonnull %33, ptr noundef nonnull %35, ptr noundef nonnull @c_b2, ptr noundef %1670, ptr noundef nonnull %17, ptr noundef %gep2680, ptr noundef nonnull %9, ptr noundef nonnull @c_b1, ptr noundef %22, ptr noundef %23) #7
  call void @zlacpy_(ptr noundef nonnull @.str.2, ptr noundef nonnull %35, ptr noundef nonnull %33, ptr noundef %22, ptr noundef %23, ptr noundef %gep2680, ptr noundef nonnull %9) #7
  %indvars.iv.next2600 = add nsw i64 %indvars.iv2599, %1673
  %1682 = icmp sge i64 %indvars.iv.next2600, %1674
  %1683 = icmp sle i64 %indvars.iv.next2600, %1674
  %.in = select i1 %1664, i1 %1682, i1 %1683
  br i1 %.in, label %1676, label %._crit_edge2531.loopexit, !llvm.loop !28

._crit_edge2531.loopexit:                         ; preds = %1676
  %.pre2616 = load i32, ptr %4, align 4, !tbaa !5
  br label %._crit_edge2531

._crit_edge2531:                                  ; preds = %._crit_edge2531.loopexit, %1651
  %1684 = phi i32 [ %.pre2616, %._crit_edge2531.loopexit ], [ %.pre2615, %1651 ]
  %.02340.2444 = call i32 @llvm.smax.i32(i32 %1684, i32 %.023402543)
  %1685 = add nsw i32 %.02340.2444, -1
  %1686 = load i32, ptr %18, align 4, !tbaa !5
  %1687 = icmp slt i32 %1686, 0
  %1688 = icmp sge i32 %spec.select2685, %1685
  %1689 = icmp slt i32 %spec.select2685, %.02340.2444
  %.in23962532 = select i1 %1687, i1 %1688, i1 %1689
  br i1 %.in23962532, label %.lr.ph2535, label %._crit_edge2536

.lr.ph2535:                                       ; preds = %._crit_edge2531
  %1690 = add nsw i32 %1654, %.023402543
  %1691 = mul nsw i32 %1690, %41
  %1692 = mul i32 %1654, %89
  %1693 = sext i32 %1692 to i64
  %1694 = getelementptr inbounds %struct.doublecomplex, ptr %52, i64 %1693
  %1695 = sext i32 %spec.select2685 to i64
  %1696 = sext i32 %1686 to i64
  %1697 = sext i32 %.02340.2444 to i64
  %1698 = sext i32 %1685 to i64
  %1699 = sext i32 %1691 to i64
  %invariant.gep2681 = getelementptr %struct.doublecomplex, ptr %43, i64 %1699
  br label %1700

1700:                                             ; preds = %.lr.ph2535, %1700
  %indvars.iv2602 = phi i64 [ %1695, %.lr.ph2535 ], [ %indvars.iv.next2603, %1700 ]
  %1701 = load i32, ptr %18, align 4, !tbaa !5
  %1702 = load i32, ptr %4, align 4, !tbaa !5
  %.02340.2445 = call i32 @llvm.smax.i32(i32 %1702, i32 %.023402543)
  %1703 = trunc nsw i64 %indvars.iv2602 to i32
  %1704 = sub nsw i32 %.02340.2445, %1703
  %1705 = call i32 @llvm.smin.i32(i32 %1701, i32 %1704)
  store i32 %1705, ptr %33, align 4, !tbaa !5
  %gep2682 = getelementptr %struct.doublecomplex, ptr %invariant.gep2681, i64 %indvars.iv2602
  call void @zgemm_(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.4, ptr noundef nonnull %33, ptr noundef nonnull %35, ptr noundef nonnull %35, ptr noundef nonnull @c_b2, ptr noundef %gep2682, ptr noundef nonnull %9, ptr noundef %1694, ptr noundef nonnull %17, ptr noundef nonnull @c_b1, ptr noundef %19, ptr noundef %20) #7
  call void @zlacpy_(ptr noundef nonnull @.str.2, ptr noundef nonnull %33, ptr noundef nonnull %35, ptr noundef %19, ptr noundef %20, ptr noundef %gep2682, ptr noundef nonnull %9) #7
  %indvars.iv.next2603 = add nsw i64 %indvars.iv2602, %1696
  %1706 = icmp sge i64 %indvars.iv.next2603, %1698
  %1707 = icmp slt i64 %indvars.iv.next2603, %1697
  %.in2396 = select i1 %1687, i1 %1706, i1 %1707
  br i1 %.in2396, label %1700, label %._crit_edge2536, !llvm.loop !29

._crit_edge2536:                                  ; preds = %1700, %._crit_edge2531
  %1708 = load i32, ptr %1, align 4, !tbaa !5
  %.not2397 = icmp eq i32 %1708, 0
  br i1 %.not2397, label %.loopexit2468, label %1709

1709:                                             ; preds = %._crit_edge2536
  %1710 = load i32, ptr %11, align 4, !tbaa !5
  %1711 = load i32, ptr %18, align 4, !tbaa !5
  %1712 = load i32, ptr %10, align 4, !tbaa !5
  %1713 = icmp slt i32 %1711, 0
  %1714 = icmp sge i32 %1712, %1710
  %1715 = icmp sle i32 %1712, %1710
  %.in23982537 = select i1 %1713, i1 %1714, i1 %1715
  br i1 %.in23982537, label %.lr.ph2540, label %.loopexit2468

.lr.ph2540:                                       ; preds = %1709
  %1716 = add nsw i32 %1654, %.023402543
  %1717 = mul nsw i32 %1716, %44
  %1718 = mul i32 %1654, %89
  %1719 = sext i32 %1718 to i64
  %1720 = getelementptr inbounds %struct.doublecomplex, ptr %52, i64 %1719
  %1721 = sext i32 %1712 to i64
  %1722 = sext i32 %1711 to i64
  %1723 = sext i32 %1710 to i64
  %1724 = sext i32 %1717 to i64
  %invariant.gep2683 = getelementptr %struct.doublecomplex, ptr %46, i64 %1724
  br label %1725

1725:                                             ; preds = %.lr.ph2540, %1725
  %indvars.iv2605 = phi i64 [ %1721, %.lr.ph2540 ], [ %indvars.iv.next2606, %1725 ]
  %1726 = load i32, ptr %18, align 4, !tbaa !5
  %1727 = load i32, ptr %11, align 4, !tbaa !5
  %1728 = trunc nsw i64 %indvars.iv2605 to i32
  %reass.sub2548 = sub i32 %1727, %1728
  %1729 = add i32 %reass.sub2548, 1
  %1730 = call i32 @llvm.smin.i32(i32 %1726, i32 %1729)
  store i32 %1730, ptr %33, align 4, !tbaa !5
  %gep2684 = getelementptr %struct.doublecomplex, ptr %invariant.gep2683, i64 %indvars.iv2605
  call void @zgemm_(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.4, ptr noundef nonnull %33, ptr noundef nonnull %35, ptr noundef nonnull %35, ptr noundef nonnull @c_b2, ptr noundef %gep2684, ptr noundef nonnull %13, ptr noundef %1720, ptr noundef nonnull %17, ptr noundef nonnull @c_b1, ptr noundef %19, ptr noundef nonnull %20) #7
  call void @zlacpy_(ptr noundef nonnull @.str.2, ptr noundef nonnull %33, ptr noundef nonnull %35, ptr noundef %19, ptr noundef nonnull %20, ptr noundef %gep2684, ptr noundef nonnull %13) #7
  %indvars.iv.next2606 = add nsw i64 %indvars.iv2605, %1722
  %1731 = icmp sge i64 %indvars.iv.next2606, %1723
  %1732 = icmp sle i64 %indvars.iv.next2606, %1723
  %.in2398 = select i1 %1713, i1 %1731, i1 %1732
  br i1 %.in2398, label %1725, label %.loopexit2468, !llvm.loop !30

.loopexit2468:                                    ; preds = %1725, %1709, %._crit_edge2526, %._crit_edge2536
  %indvars.iv.next2563 = sub i32 %indvars.iv2562, %80
  %.not2387 = icmp sgt i32 %106, %79
  %indvars.iv.next2553 = add i32 %indvars.iv2552, %80
  br i1 %.not2387, label %.loopexit2469, label %95, !llvm.loop !31

.loopexit2469:                                    ; preds = %.loopexit2468, %76, %55, %24
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %39) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %38) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %37) #7
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %36) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %35) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %34) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %33) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %32) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %31) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %30) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %29) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %28) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %27) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %26) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %25) #7
  ret void
}

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

declare double @dlamch_(ptr noundef) local_unnamed_addr #2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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