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

; 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 [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1

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

80:                                               ; preds = %12
  store i32 1, ptr %50, align 4
  br label %4491

81:                                               ; preds = %12
  %82 = load ptr, ptr %22, align 8, !tbaa !5
  %83 = load double, ptr %82, align 8, !tbaa !11
  %84 = fcmp oeq double %83, 0.000000e+00
  br i1 %84, label %85, label %123

85:                                               ; preds = %81
  %86 = load ptr, ptr %15, align 8, !tbaa !5
  %87 = load i32, ptr %86, align 4, !tbaa !9
  store i32 %87, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %88

88:                                               ; preds = %119, %85
  %89 = load i32, ptr %49, align 4, !tbaa !9
  %90 = load i32, ptr %29, align 4, !tbaa !9
  %91 = icmp sle i32 %89, %90
  br i1 %91, label %92, label %122

92:                                               ; preds = %88
  %93 = load ptr, ptr %14, align 8, !tbaa !5
  %94 = load i32, ptr %93, align 4, !tbaa !9
  store i32 %94, ptr %30, align 4, !tbaa !9
  store i32 1, ptr %48, align 4, !tbaa !9
  br label %95

95:                                               ; preds = %115, %92
  %96 = load i32, ptr %48, align 4, !tbaa !9
  %97 = load i32, ptr %30, align 4, !tbaa !9
  %98 = icmp sle i32 %96, %97
  br i1 %98, label %99, label %118

99:                                               ; preds = %95
  %100 = load i32, ptr %48, align 4, !tbaa !9
  %101 = load i32, ptr %49, align 4, !tbaa !9
  %102 = load i32, ptr %25, align 4, !tbaa !9
  %103 = mul nsw i32 %101, %102
  %104 = add nsw i32 %100, %103
  store i32 %104, ptr %31, align 4, !tbaa !9
  %105 = load ptr, ptr %23, align 8, !tbaa !5
  %106 = load i32, ptr %31, align 4, !tbaa !9
  %107 = sext i32 %106 to i64
  %108 = getelementptr inbounds %struct.doublecomplex, ptr %105, i64 %107
  %109 = getelementptr inbounds %struct.doublecomplex, ptr %108, i32 0, i32 0
  store double 0.000000e+00, ptr %109, align 8, !tbaa !13
  %110 = load ptr, ptr %23, align 8, !tbaa !5
  %111 = load i32, ptr %31, align 4, !tbaa !9
  %112 = sext i32 %111 to i64
  %113 = getelementptr inbounds %struct.doublecomplex, ptr %110, i64 %112
  %114 = getelementptr inbounds %struct.doublecomplex, ptr %113, i32 0, i32 1
  store double 0.000000e+00, ptr %114, align 8, !tbaa !15
  br label %115

115:                                              ; preds = %99
  %116 = load i32, ptr %48, align 4, !tbaa !9
  %117 = add nsw i32 %116, 1
  store i32 %117, ptr %48, align 4, !tbaa !9
  br label %95, !llvm.loop !16

118:                                              ; preds = %95
  br label %119

119:                                              ; preds = %118
  %120 = load i32, ptr %49, align 4, !tbaa !9
  %121 = add nsw i32 %120, 1
  store i32 %121, ptr %49, align 4, !tbaa !9
  br label %88, !llvm.loop !18

122:                                              ; preds = %88
  br label %191

123:                                              ; preds = %81
  %124 = load ptr, ptr %22, align 8, !tbaa !5
  %125 = load double, ptr %124, align 8, !tbaa !11
  %126 = fcmp oeq double %125, -1.000000e+00
  br i1 %126, label %127, label %190

127:                                              ; preds = %123
  %128 = load ptr, ptr %15, align 8, !tbaa !5
  %129 = load i32, ptr %128, align 4, !tbaa !9
  store i32 %129, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %130

130:                                              ; preds = %186, %127
  %131 = load i32, ptr %49, align 4, !tbaa !9
  %132 = load i32, ptr %29, align 4, !tbaa !9
  %133 = icmp sle i32 %131, %132
  br i1 %133, label %134, label %189

134:                                              ; preds = %130
  %135 = load ptr, ptr %14, align 8, !tbaa !5
  %136 = load i32, ptr %135, align 4, !tbaa !9
  store i32 %136, ptr %30, align 4, !tbaa !9
  store i32 1, ptr %48, align 4, !tbaa !9
  br label %137

137:                                              ; preds = %182, %134
  %138 = load i32, ptr %48, align 4, !tbaa !9
  %139 = load i32, ptr %30, align 4, !tbaa !9
  %140 = icmp sle i32 %138, %139
  br i1 %140, label %141, label %185

141:                                              ; preds = %137
  %142 = load i32, ptr %48, align 4, !tbaa !9
  %143 = load i32, ptr %49, align 4, !tbaa !9
  %144 = load i32, ptr %25, align 4, !tbaa !9
  %145 = mul nsw i32 %143, %144
  %146 = add nsw i32 %142, %145
  store i32 %146, ptr %31, align 4, !tbaa !9
  %147 = load i32, ptr %48, align 4, !tbaa !9
  %148 = load i32, ptr %49, align 4, !tbaa !9
  %149 = load i32, ptr %25, align 4, !tbaa !9
  %150 = mul nsw i32 %148, %149
  %151 = add nsw i32 %147, %150
  store i32 %151, ptr %32, align 4, !tbaa !9
  %152 = load ptr, ptr %23, align 8, !tbaa !5
  %153 = load i32, ptr %32, align 4, !tbaa !9
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds %struct.doublecomplex, ptr %152, i64 %154
  %156 = getelementptr inbounds %struct.doublecomplex, ptr %155, i32 0, i32 0
  %157 = load double, ptr %156, align 8, !tbaa !13
  %158 = fneg double %157
  %159 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %158, ptr %159, align 8, !tbaa !13
  %160 = load ptr, ptr %23, align 8, !tbaa !5
  %161 = load i32, ptr %32, align 4, !tbaa !9
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds %struct.doublecomplex, ptr %160, i64 %162
  %164 = getelementptr inbounds %struct.doublecomplex, ptr %163, i32 0, i32 1
  %165 = load double, ptr %164, align 8, !tbaa !15
  %166 = fneg double %165
  %167 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %166, ptr %167, align 8, !tbaa !15
  %168 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %169 = load double, ptr %168, align 8, !tbaa !13
  %170 = load ptr, ptr %23, align 8, !tbaa !5
  %171 = load i32, ptr %31, align 4, !tbaa !9
  %172 = sext i32 %171 to i64
  %173 = getelementptr inbounds %struct.doublecomplex, ptr %170, i64 %172
  %174 = getelementptr inbounds %struct.doublecomplex, ptr %173, i32 0, i32 0
  store double %169, ptr %174, align 8, !tbaa !13
  %175 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %176 = load double, ptr %175, align 8, !tbaa !15
  %177 = load ptr, ptr %23, align 8, !tbaa !5
  %178 = load i32, ptr %31, align 4, !tbaa !9
  %179 = sext i32 %178 to i64
  %180 = getelementptr inbounds %struct.doublecomplex, ptr %177, i64 %179
  %181 = getelementptr inbounds %struct.doublecomplex, ptr %180, i32 0, i32 1
  store double %176, ptr %181, align 8, !tbaa !15
  br label %182

182:                                              ; preds = %141
  %183 = load i32, ptr %48, align 4, !tbaa !9
  %184 = add nsw i32 %183, 1
  store i32 %184, ptr %48, align 4, !tbaa !9
  br label %137, !llvm.loop !19

185:                                              ; preds = %137
  br label %186

186:                                              ; preds = %185
  %187 = load i32, ptr %49, align 4, !tbaa !9
  %188 = add nsw i32 %187, 1
  store i32 %188, ptr %49, align 4, !tbaa !9
  br label %130, !llvm.loop !20

189:                                              ; preds = %130
  br label %190

190:                                              ; preds = %189, %123
  br label %191

191:                                              ; preds = %190, %122
  %192 = load ptr, ptr %16, align 8, !tbaa !5
  %193 = load double, ptr %192, align 8, !tbaa !11
  %194 = fcmp oeq double %193, 1.000000e+00
  br i1 %194, label %195, label %2340

195:                                              ; preds = %191
  %196 = load ptr, ptr %13, align 8, !tbaa !5
  %197 = call i32 @lsame_(ptr noundef %196, ptr noundef @.str)
  %198 = icmp ne i32 %197, 0
  br i1 %198, label %199, label %918

199:                                              ; preds = %195
  %200 = load ptr, ptr %15, align 8, !tbaa !5
  %201 = load i32, ptr %200, align 4, !tbaa !9
  store i32 %201, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %202

202:                                              ; preds = %914, %199
  %203 = load i32, ptr %49, align 4, !tbaa !9
  %204 = load i32, ptr %29, align 4, !tbaa !9
  %205 = icmp sle i32 %203, %204
  br i1 %205, label %206, label %917

206:                                              ; preds = %202
  %207 = load ptr, ptr %14, align 8, !tbaa !5
  %208 = load i32, ptr %207, align 4, !tbaa !9
  %209 = icmp eq i32 %208, 1
  br i1 %209, label %210, label %304

210:                                              ; preds = %206
  %211 = load i32, ptr %49, align 4, !tbaa !9
  %212 = load i32, ptr %25, align 4, !tbaa !9
  %213 = mul nsw i32 %211, %212
  %214 = add nsw i32 %213, 1
  store i32 %214, ptr %30, align 4, !tbaa !9
  %215 = load i32, ptr %49, align 4, !tbaa !9
  %216 = load i32, ptr %25, align 4, !tbaa !9
  %217 = mul nsw i32 %215, %216
  %218 = add nsw i32 %217, 1
  store i32 %218, ptr %31, align 4, !tbaa !9
  %219 = load i32, ptr %49, align 4, !tbaa !9
  %220 = load i32, ptr %27, align 4, !tbaa !9
  %221 = mul nsw i32 %219, %220
  %222 = add nsw i32 %221, 1
  store i32 %222, ptr %32, align 4, !tbaa !9
  %223 = load ptr, ptr %18, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.doublecomplex, ptr %223, i64 1
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %224, i32 0, i32 0
  %226 = load double, ptr %225, align 8, !tbaa !13
  %227 = load ptr, ptr %20, align 8, !tbaa !5
  %228 = load i32, ptr %32, align 4, !tbaa !9
  %229 = sext i32 %228 to i64
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %227, i64 %229
  %231 = getelementptr inbounds %struct.doublecomplex, ptr %230, i32 0, i32 0
  %232 = load double, ptr %231, align 8, !tbaa !13
  %233 = load ptr, ptr %18, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.doublecomplex, ptr %233, i64 1
  %235 = getelementptr inbounds %struct.doublecomplex, ptr %234, i32 0, i32 1
  %236 = load double, ptr %235, align 8, !tbaa !15
  %237 = load ptr, ptr %20, align 8, !tbaa !5
  %238 = load i32, ptr %32, align 4, !tbaa !9
  %239 = sext i32 %238 to i64
  %240 = getelementptr inbounds %struct.doublecomplex, ptr %237, i64 %239
  %241 = getelementptr inbounds %struct.doublecomplex, ptr %240, i32 0, i32 1
  %242 = load double, ptr %241, align 8, !tbaa !15
  %243 = fmul double %236, %242
  %244 = fneg double %243
  %245 = call double @llvm.fmuladd.f64(double %226, double %232, double %244)
  %246 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %245, ptr %246, align 8, !tbaa !13
  %247 = load ptr, ptr %18, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.doublecomplex, ptr %247, i64 1
  %249 = getelementptr inbounds %struct.doublecomplex, ptr %248, i32 0, i32 0
  %250 = load double, ptr %249, align 8, !tbaa !13
  %251 = load ptr, ptr %20, align 8, !tbaa !5
  %252 = load i32, ptr %32, 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
  %256 = load double, ptr %255, align 8, !tbaa !15
  %257 = load ptr, ptr %18, align 8, !tbaa !5
  %258 = getelementptr inbounds %struct.doublecomplex, ptr %257, i64 1
  %259 = getelementptr inbounds %struct.doublecomplex, ptr %258, i32 0, i32 1
  %260 = load double, ptr %259, align 8, !tbaa !15
  %261 = load ptr, ptr %20, align 8, !tbaa !5
  %262 = load i32, ptr %32, align 4, !tbaa !9
  %263 = sext i32 %262 to i64
  %264 = getelementptr inbounds %struct.doublecomplex, ptr %261, i64 %263
  %265 = getelementptr inbounds %struct.doublecomplex, ptr %264, i32 0, i32 0
  %266 = load double, ptr %265, align 8, !tbaa !13
  %267 = fmul double %260, %266
  %268 = call double @llvm.fmuladd.f64(double %250, double %256, double %267)
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %268, ptr %269, align 8, !tbaa !15
  %270 = load ptr, ptr %23, align 8, !tbaa !5
  %271 = load i32, ptr %31, align 4, !tbaa !9
  %272 = sext i32 %271 to i64
  %273 = getelementptr inbounds %struct.doublecomplex, ptr %270, i64 %272
  %274 = getelementptr inbounds %struct.doublecomplex, ptr %273, i32 0, i32 0
  %275 = load double, ptr %274, align 8, !tbaa !13
  %276 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %277 = load double, ptr %276, align 8, !tbaa !13
  %278 = fadd double %275, %277
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %278, ptr %279, align 8, !tbaa !13
  %280 = load ptr, ptr %23, align 8, !tbaa !5
  %281 = load i32, ptr %31, align 4, !tbaa !9
  %282 = sext i32 %281 to i64
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %280, i64 %282
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %283, i32 0, i32 1
  %285 = load double, ptr %284, align 8, !tbaa !15
  %286 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %287 = load double, ptr %286, align 8, !tbaa !15
  %288 = fadd double %285, %287
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %288, ptr %289, align 8, !tbaa !15
  %290 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %291 = load double, ptr %290, align 8, !tbaa !13
  %292 = load ptr, ptr %23, align 8, !tbaa !5
  %293 = load i32, ptr %30, align 4, !tbaa !9
  %294 = sext i32 %293 to i64
  %295 = getelementptr inbounds %struct.doublecomplex, ptr %292, i64 %294
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %295, i32 0, i32 0
  store double %291, ptr %296, align 8, !tbaa !13
  %297 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %298 = load double, ptr %297, align 8, !tbaa !15
  %299 = load ptr, ptr %23, align 8, !tbaa !5
  %300 = load i32, ptr %30, align 4, !tbaa !9
  %301 = sext i32 %300 to i64
  %302 = getelementptr inbounds %struct.doublecomplex, ptr %299, i64 %301
  %303 = getelementptr inbounds %struct.doublecomplex, ptr %302, i32 0, i32 1
  store double %298, ptr %303, align 8, !tbaa !15
  br label %913

304:                                              ; preds = %206
  %305 = load i32, ptr %49, align 4, !tbaa !9
  %306 = load i32, ptr %25, align 4, !tbaa !9
  %307 = mul nsw i32 %305, %306
  %308 = add nsw i32 %307, 1
  store i32 %308, ptr %30, align 4, !tbaa !9
  %309 = load i32, ptr %49, align 4, !tbaa !9
  %310 = load i32, ptr %25, align 4, !tbaa !9
  %311 = mul nsw i32 %309, %310
  %312 = add nsw i32 %311, 1
  store i32 %312, ptr %31, align 4, !tbaa !9
  %313 = load i32, ptr %49, align 4, !tbaa !9
  %314 = load i32, ptr %27, align 4, !tbaa !9
  %315 = mul nsw i32 %313, %314
  %316 = add nsw i32 %315, 1
  store i32 %316, ptr %32, align 4, !tbaa !9
  %317 = load ptr, ptr %18, align 8, !tbaa !5
  %318 = getelementptr inbounds %struct.doublecomplex, ptr %317, i64 1
  %319 = getelementptr inbounds %struct.doublecomplex, ptr %318, i32 0, i32 0
  %320 = load double, ptr %319, align 8, !tbaa !13
  %321 = load ptr, ptr %20, align 8, !tbaa !5
  %322 = load i32, ptr %32, align 4, !tbaa !9
  %323 = sext i32 %322 to i64
  %324 = getelementptr inbounds %struct.doublecomplex, ptr %321, i64 %323
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %324, i32 0, i32 0
  %326 = load double, ptr %325, align 8, !tbaa !13
  %327 = load ptr, ptr %18, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.doublecomplex, ptr %327, i64 1
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %328, i32 0, i32 1
  %330 = load double, ptr %329, align 8, !tbaa !15
  %331 = load ptr, ptr %20, align 8, !tbaa !5
  %332 = load i32, ptr %32, align 4, !tbaa !9
  %333 = sext i32 %332 to i64
  %334 = getelementptr inbounds %struct.doublecomplex, ptr %331, i64 %333
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %334, i32 0, i32 1
  %336 = load double, ptr %335, align 8, !tbaa !15
  %337 = fmul double %330, %336
  %338 = fneg double %337
  %339 = call double @llvm.fmuladd.f64(double %320, double %326, double %338)
  %340 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %339, ptr %340, align 8, !tbaa !13
  %341 = load ptr, ptr %18, align 8, !tbaa !5
  %342 = getelementptr inbounds %struct.doublecomplex, ptr %341, i64 1
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %342, i32 0, i32 0
  %344 = load double, ptr %343, align 8, !tbaa !13
  %345 = load ptr, ptr %20, align 8, !tbaa !5
  %346 = load i32, ptr %32, align 4, !tbaa !9
  %347 = sext i32 %346 to i64
  %348 = getelementptr inbounds %struct.doublecomplex, ptr %345, i64 %347
  %349 = getelementptr inbounds %struct.doublecomplex, ptr %348, i32 0, i32 1
  %350 = load double, ptr %349, align 8, !tbaa !15
  %351 = load ptr, ptr %18, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.doublecomplex, ptr %351, i64 1
  %353 = getelementptr inbounds %struct.doublecomplex, ptr %352, i32 0, i32 1
  %354 = load double, ptr %353, align 8, !tbaa !15
  %355 = load ptr, ptr %20, align 8, !tbaa !5
  %356 = load i32, ptr %32, align 4, !tbaa !9
  %357 = sext i32 %356 to i64
  %358 = getelementptr inbounds %struct.doublecomplex, ptr %355, i64 %357
  %359 = getelementptr inbounds %struct.doublecomplex, ptr %358, i32 0, i32 0
  %360 = load double, ptr %359, align 8, !tbaa !13
  %361 = fmul double %354, %360
  %362 = call double @llvm.fmuladd.f64(double %344, double %350, double %361)
  %363 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %362, ptr %363, align 8, !tbaa !15
  %364 = load ptr, ptr %23, align 8, !tbaa !5
  %365 = load i32, ptr %31, align 4, !tbaa !9
  %366 = sext i32 %365 to i64
  %367 = getelementptr inbounds %struct.doublecomplex, ptr %364, i64 %366
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %367, i32 0, i32 0
  %369 = load double, ptr %368, align 8, !tbaa !13
  %370 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %371 = load double, ptr %370, align 8, !tbaa !13
  %372 = fadd double %369, %371
  %373 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %372, ptr %373, align 8, !tbaa !13
  %374 = load ptr, ptr %23, align 8, !tbaa !5
  %375 = load i32, ptr %31, align 4, !tbaa !9
  %376 = sext i32 %375 to i64
  %377 = getelementptr inbounds %struct.doublecomplex, ptr %374, i64 %376
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %377, i32 0, i32 1
  %379 = load double, ptr %378, align 8, !tbaa !15
  %380 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %381 = load double, ptr %380, align 8, !tbaa !15
  %382 = fadd double %379, %381
  %383 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %382, ptr %383, align 8, !tbaa !15
  %384 = load i32, ptr %49, align 4, !tbaa !9
  %385 = load i32, ptr %27, align 4, !tbaa !9
  %386 = mul nsw i32 %384, %385
  %387 = add nsw i32 %386, 2
  store i32 %387, ptr %33, align 4, !tbaa !9
  %388 = load ptr, ptr %19, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %388, i64 1
  %390 = getelementptr inbounds %struct.doublecomplex, ptr %389, i32 0, i32 0
  %391 = load double, ptr %390, align 8, !tbaa !13
  %392 = load ptr, ptr %20, align 8, !tbaa !5
  %393 = load i32, ptr %33, align 4, !tbaa !9
  %394 = sext i32 %393 to i64
  %395 = getelementptr inbounds %struct.doublecomplex, ptr %392, i64 %394
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %395, i32 0, i32 0
  %397 = load double, ptr %396, align 8, !tbaa !13
  %398 = load ptr, ptr %19, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.doublecomplex, ptr %398, i64 1
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %399, i32 0, i32 1
  %401 = load double, ptr %400, align 8, !tbaa !15
  %402 = load ptr, ptr %20, align 8, !tbaa !5
  %403 = load i32, ptr %33, align 4, !tbaa !9
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds %struct.doublecomplex, ptr %402, i64 %404
  %406 = getelementptr inbounds %struct.doublecomplex, ptr %405, i32 0, i32 1
  %407 = load double, ptr %406, align 8, !tbaa !15
  %408 = fmul double %401, %407
  %409 = fneg double %408
  %410 = call double @llvm.fmuladd.f64(double %391, double %397, double %409)
  %411 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %410, ptr %411, align 8, !tbaa !13
  %412 = load ptr, ptr %19, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.doublecomplex, ptr %412, i64 1
  %414 = getelementptr inbounds %struct.doublecomplex, ptr %413, i32 0, i32 0
  %415 = load double, ptr %414, align 8, !tbaa !13
  %416 = load ptr, ptr %20, align 8, !tbaa !5
  %417 = load i32, ptr %33, align 4, !tbaa !9
  %418 = sext i32 %417 to i64
  %419 = getelementptr inbounds %struct.doublecomplex, ptr %416, i64 %418
  %420 = getelementptr inbounds %struct.doublecomplex, ptr %419, i32 0, i32 1
  %421 = load double, ptr %420, align 8, !tbaa !15
  %422 = load ptr, ptr %19, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.doublecomplex, ptr %422, i64 1
  %424 = getelementptr inbounds %struct.doublecomplex, ptr %423, i32 0, i32 1
  %425 = load double, ptr %424, align 8, !tbaa !15
  %426 = load ptr, ptr %20, align 8, !tbaa !5
  %427 = load i32, ptr %33, align 4, !tbaa !9
  %428 = sext i32 %427 to i64
  %429 = getelementptr inbounds %struct.doublecomplex, ptr %426, i64 %428
  %430 = getelementptr inbounds %struct.doublecomplex, ptr %429, i32 0, i32 0
  %431 = load double, ptr %430, align 8, !tbaa !13
  %432 = fmul double %425, %431
  %433 = call double @llvm.fmuladd.f64(double %415, double %421, double %432)
  %434 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %433, ptr %434, align 8, !tbaa !15
  %435 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %436 = load double, ptr %435, align 8, !tbaa !13
  %437 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %438 = load double, ptr %437, align 8, !tbaa !13
  %439 = fadd double %436, %438
  %440 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %439, ptr %440, align 8, !tbaa !13
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %442 = load double, ptr %441, align 8, !tbaa !15
  %443 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %444 = load double, ptr %443, align 8, !tbaa !15
  %445 = fadd double %442, %444
  %446 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %445, ptr %446, align 8, !tbaa !15
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %448 = load double, ptr %447, align 8, !tbaa !13
  %449 = load ptr, ptr %23, align 8, !tbaa !5
  %450 = load i32, ptr %30, align 4, !tbaa !9
  %451 = sext i32 %450 to i64
  %452 = getelementptr inbounds %struct.doublecomplex, ptr %449, i64 %451
  %453 = getelementptr inbounds %struct.doublecomplex, ptr %452, i32 0, i32 0
  store double %448, ptr %453, align 8, !tbaa !13
  %454 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %455 = load double, ptr %454, align 8, !tbaa !15
  %456 = load ptr, ptr %23, align 8, !tbaa !5
  %457 = load i32, ptr %30, align 4, !tbaa !9
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %456, i64 %458
  %460 = getelementptr inbounds %struct.doublecomplex, ptr %459, i32 0, i32 1
  store double %455, ptr %460, align 8, !tbaa !15
  %461 = load ptr, ptr %14, align 8, !tbaa !5
  %462 = load i32, ptr %461, align 4, !tbaa !9
  %463 = load i32, ptr %49, align 4, !tbaa !9
  %464 = load i32, ptr %25, align 4, !tbaa !9
  %465 = mul nsw i32 %463, %464
  %466 = add nsw i32 %462, %465
  store i32 %466, ptr %30, align 4, !tbaa !9
  %467 = load ptr, ptr %14, align 8, !tbaa !5
  %468 = load i32, ptr %467, align 4, !tbaa !9
  %469 = load i32, ptr %49, align 4, !tbaa !9
  %470 = load i32, ptr %25, align 4, !tbaa !9
  %471 = mul nsw i32 %469, %470
  %472 = add nsw i32 %468, %471
  store i32 %472, ptr %31, align 4, !tbaa !9
  %473 = load ptr, ptr %14, align 8, !tbaa !5
  %474 = load i32, ptr %473, align 4, !tbaa !9
  %475 = sub nsw i32 %474, 1
  store i32 %475, ptr %32, align 4, !tbaa !9
  %476 = load ptr, ptr %14, align 8, !tbaa !5
  %477 = load i32, ptr %476, align 4, !tbaa !9
  %478 = sub nsw i32 %477, 1
  %479 = load i32, ptr %49, align 4, !tbaa !9
  %480 = load i32, ptr %27, align 4, !tbaa !9
  %481 = mul nsw i32 %479, %480
  %482 = add nsw i32 %478, %481
  store i32 %482, ptr %33, align 4, !tbaa !9
  %483 = load ptr, ptr %17, align 8, !tbaa !5
  %484 = load i32, ptr %32, align 4, !tbaa !9
  %485 = sext i32 %484 to i64
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %483, i64 %485
  %487 = getelementptr inbounds %struct.doublecomplex, ptr %486, i32 0, i32 0
  %488 = load double, ptr %487, align 8, !tbaa !13
  %489 = load ptr, ptr %20, align 8, !tbaa !5
  %490 = load i32, ptr %33, align 4, !tbaa !9
  %491 = sext i32 %490 to i64
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %489, i64 %491
  %493 = getelementptr inbounds %struct.doublecomplex, ptr %492, i32 0, i32 0
  %494 = load double, ptr %493, align 8, !tbaa !13
  %495 = load ptr, ptr %17, align 8, !tbaa !5
  %496 = load i32, ptr %32, align 4, !tbaa !9
  %497 = sext i32 %496 to i64
  %498 = getelementptr inbounds %struct.doublecomplex, ptr %495, i64 %497
  %499 = getelementptr inbounds %struct.doublecomplex, ptr %498, i32 0, i32 1
  %500 = load double, ptr %499, align 8, !tbaa !15
  %501 = load ptr, ptr %20, align 8, !tbaa !5
  %502 = load i32, ptr %33, align 4, !tbaa !9
  %503 = sext i32 %502 to i64
  %504 = getelementptr inbounds %struct.doublecomplex, ptr %501, i64 %503
  %505 = getelementptr inbounds %struct.doublecomplex, ptr %504, i32 0, i32 1
  %506 = load double, ptr %505, align 8, !tbaa !15
  %507 = fmul double %500, %506
  %508 = fneg double %507
  %509 = call double @llvm.fmuladd.f64(double %488, double %494, double %508)
  %510 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %509, ptr %510, align 8, !tbaa !13
  %511 = load ptr, ptr %17, align 8, !tbaa !5
  %512 = load i32, ptr %32, align 4, !tbaa !9
  %513 = sext i32 %512 to i64
  %514 = getelementptr inbounds %struct.doublecomplex, ptr %511, i64 %513
  %515 = getelementptr inbounds %struct.doublecomplex, ptr %514, i32 0, i32 0
  %516 = load double, ptr %515, align 8, !tbaa !13
  %517 = load ptr, ptr %20, align 8, !tbaa !5
  %518 = load i32, ptr %33, align 4, !tbaa !9
  %519 = sext i32 %518 to i64
  %520 = getelementptr inbounds %struct.doublecomplex, ptr %517, i64 %519
  %521 = getelementptr inbounds %struct.doublecomplex, ptr %520, i32 0, i32 1
  %522 = load double, ptr %521, align 8, !tbaa !15
  %523 = load ptr, ptr %17, align 8, !tbaa !5
  %524 = load i32, ptr %32, align 4, !tbaa !9
  %525 = sext i32 %524 to i64
  %526 = getelementptr inbounds %struct.doublecomplex, ptr %523, i64 %525
  %527 = getelementptr inbounds %struct.doublecomplex, ptr %526, i32 0, i32 1
  %528 = load double, ptr %527, align 8, !tbaa !15
  %529 = load ptr, ptr %20, align 8, !tbaa !5
  %530 = load i32, ptr %33, align 4, !tbaa !9
  %531 = sext i32 %530 to i64
  %532 = getelementptr inbounds %struct.doublecomplex, ptr %529, i64 %531
  %533 = getelementptr inbounds %struct.doublecomplex, ptr %532, i32 0, i32 0
  %534 = load double, ptr %533, align 8, !tbaa !13
  %535 = fmul double %528, %534
  %536 = call double @llvm.fmuladd.f64(double %516, double %522, double %535)
  %537 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %536, ptr %537, align 8, !tbaa !15
  %538 = load ptr, ptr %23, align 8, !tbaa !5
  %539 = load i32, ptr %31, align 4, !tbaa !9
  %540 = sext i32 %539 to i64
  %541 = getelementptr inbounds %struct.doublecomplex, ptr %538, i64 %540
  %542 = getelementptr inbounds %struct.doublecomplex, ptr %541, i32 0, i32 0
  %543 = load double, ptr %542, align 8, !tbaa !13
  %544 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %545 = load double, ptr %544, align 8, !tbaa !13
  %546 = fadd double %543, %545
  %547 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %546, ptr %547, align 8, !tbaa !13
  %548 = load ptr, ptr %23, align 8, !tbaa !5
  %549 = load i32, ptr %31, align 4, !tbaa !9
  %550 = sext i32 %549 to i64
  %551 = getelementptr inbounds %struct.doublecomplex, ptr %548, i64 %550
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %551, i32 0, i32 1
  %553 = load double, ptr %552, align 8, !tbaa !15
  %554 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %555 = load double, ptr %554, align 8, !tbaa !15
  %556 = fadd double %553, %555
  %557 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %556, ptr %557, align 8, !tbaa !15
  %558 = load ptr, ptr %14, align 8, !tbaa !5
  %559 = load i32, ptr %558, align 4, !tbaa !9
  store i32 %559, ptr %34, align 4, !tbaa !9
  %560 = load ptr, ptr %14, align 8, !tbaa !5
  %561 = load i32, ptr %560, align 4, !tbaa !9
  %562 = load i32, ptr %49, align 4, !tbaa !9
  %563 = load i32, ptr %27, align 4, !tbaa !9
  %564 = mul nsw i32 %562, %563
  %565 = add nsw i32 %561, %564
  store i32 %565, ptr %35, align 4, !tbaa !9
  %566 = load ptr, ptr %18, align 8, !tbaa !5
  %567 = load i32, ptr %34, align 4, !tbaa !9
  %568 = sext i32 %567 to i64
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %566, i64 %568
  %570 = getelementptr inbounds %struct.doublecomplex, ptr %569, i32 0, i32 0
  %571 = load double, ptr %570, align 8, !tbaa !13
  %572 = load ptr, ptr %20, align 8, !tbaa !5
  %573 = load i32, ptr %35, align 4, !tbaa !9
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %572, i64 %574
  %576 = getelementptr inbounds %struct.doublecomplex, ptr %575, i32 0, i32 0
  %577 = load double, ptr %576, align 8, !tbaa !13
  %578 = load ptr, ptr %18, align 8, !tbaa !5
  %579 = load i32, ptr %34, align 4, !tbaa !9
  %580 = sext i32 %579 to i64
  %581 = getelementptr inbounds %struct.doublecomplex, ptr %578, i64 %580
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %581, i32 0, i32 1
  %583 = load double, ptr %582, align 8, !tbaa !15
  %584 = load ptr, ptr %20, align 8, !tbaa !5
  %585 = load i32, ptr %35, align 4, !tbaa !9
  %586 = sext i32 %585 to i64
  %587 = getelementptr inbounds %struct.doublecomplex, ptr %584, i64 %586
  %588 = getelementptr inbounds %struct.doublecomplex, ptr %587, i32 0, i32 1
  %589 = load double, ptr %588, align 8, !tbaa !15
  %590 = fmul double %583, %589
  %591 = fneg double %590
  %592 = call double @llvm.fmuladd.f64(double %571, double %577, double %591)
  %593 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %592, ptr %593, align 8, !tbaa !13
  %594 = load ptr, ptr %18, align 8, !tbaa !5
  %595 = load i32, ptr %34, align 4, !tbaa !9
  %596 = sext i32 %595 to i64
  %597 = getelementptr inbounds %struct.doublecomplex, ptr %594, i64 %596
  %598 = getelementptr inbounds %struct.doublecomplex, ptr %597, i32 0, i32 0
  %599 = load double, ptr %598, align 8, !tbaa !13
  %600 = load ptr, ptr %20, align 8, !tbaa !5
  %601 = load i32, ptr %35, align 4, !tbaa !9
  %602 = sext i32 %601 to i64
  %603 = getelementptr inbounds %struct.doublecomplex, ptr %600, i64 %602
  %604 = getelementptr inbounds %struct.doublecomplex, ptr %603, i32 0, i32 1
  %605 = load double, ptr %604, align 8, !tbaa !15
  %606 = load ptr, ptr %18, align 8, !tbaa !5
  %607 = load i32, ptr %34, align 4, !tbaa !9
  %608 = sext i32 %607 to i64
  %609 = getelementptr inbounds %struct.doublecomplex, ptr %606, i64 %608
  %610 = getelementptr inbounds %struct.doublecomplex, ptr %609, i32 0, i32 1
  %611 = load double, ptr %610, align 8, !tbaa !15
  %612 = load ptr, ptr %20, align 8, !tbaa !5
  %613 = load i32, ptr %35, align 4, !tbaa !9
  %614 = sext i32 %613 to i64
  %615 = getelementptr inbounds %struct.doublecomplex, ptr %612, i64 %614
  %616 = getelementptr inbounds %struct.doublecomplex, ptr %615, i32 0, i32 0
  %617 = load double, ptr %616, align 8, !tbaa !13
  %618 = fmul double %611, %617
  %619 = call double @llvm.fmuladd.f64(double %599, double %605, double %618)
  %620 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %619, ptr %620, align 8, !tbaa !15
  %621 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %622 = load double, ptr %621, align 8, !tbaa !13
  %623 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %624 = load double, ptr %623, align 8, !tbaa !13
  %625 = fadd double %622, %624
  %626 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %625, ptr %626, align 8, !tbaa !13
  %627 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %628 = load double, ptr %627, align 8, !tbaa !15
  %629 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %630 = load double, ptr %629, align 8, !tbaa !15
  %631 = fadd double %628, %630
  %632 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %631, ptr %632, align 8, !tbaa !15
  %633 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %634 = load double, ptr %633, align 8, !tbaa !13
  %635 = load ptr, ptr %23, align 8, !tbaa !5
  %636 = load i32, ptr %30, align 4, !tbaa !9
  %637 = sext i32 %636 to i64
  %638 = getelementptr inbounds %struct.doublecomplex, ptr %635, i64 %637
  %639 = getelementptr inbounds %struct.doublecomplex, ptr %638, i32 0, i32 0
  store double %634, ptr %639, align 8, !tbaa !13
  %640 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %641 = load double, ptr %640, align 8, !tbaa !15
  %642 = load ptr, ptr %23, align 8, !tbaa !5
  %643 = load i32, ptr %30, align 4, !tbaa !9
  %644 = sext i32 %643 to i64
  %645 = getelementptr inbounds %struct.doublecomplex, ptr %642, i64 %644
  %646 = getelementptr inbounds %struct.doublecomplex, ptr %645, i32 0, i32 1
  store double %641, ptr %646, align 8, !tbaa !15
  %647 = load ptr, ptr %14, align 8, !tbaa !5
  %648 = load i32, ptr %647, align 4, !tbaa !9
  %649 = sub nsw i32 %648, 1
  store i32 %649, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %650

650:                                              ; preds = %909, %304
  %651 = load i32, ptr %48, align 4, !tbaa !9
  %652 = load i32, ptr %30, align 4, !tbaa !9
  %653 = icmp sle i32 %651, %652
  br i1 %653, label %654, label %912

654:                                              ; preds = %650
  %655 = load i32, ptr %48, align 4, !tbaa !9
  %656 = load i32, ptr %49, align 4, !tbaa !9
  %657 = load i32, ptr %25, align 4, !tbaa !9
  %658 = mul nsw i32 %656, %657
  %659 = add nsw i32 %655, %658
  store i32 %659, ptr %31, align 4, !tbaa !9
  %660 = load i32, ptr %48, align 4, !tbaa !9
  %661 = load i32, ptr %49, align 4, !tbaa !9
  %662 = load i32, ptr %25, align 4, !tbaa !9
  %663 = mul nsw i32 %661, %662
  %664 = add nsw i32 %660, %663
  store i32 %664, ptr %32, align 4, !tbaa !9
  %665 = load i32, ptr %48, align 4, !tbaa !9
  %666 = sub nsw i32 %665, 1
  store i32 %666, ptr %33, align 4, !tbaa !9
  %667 = load i32, ptr %48, align 4, !tbaa !9
  %668 = sub nsw i32 %667, 1
  %669 = load i32, ptr %49, align 4, !tbaa !9
  %670 = load i32, ptr %27, align 4, !tbaa !9
  %671 = mul nsw i32 %669, %670
  %672 = add nsw i32 %668, %671
  store i32 %672, ptr %34, align 4, !tbaa !9
  %673 = load ptr, ptr %17, align 8, !tbaa !5
  %674 = load i32, ptr %33, align 4, !tbaa !9
  %675 = sext i32 %674 to i64
  %676 = getelementptr inbounds %struct.doublecomplex, ptr %673, i64 %675
  %677 = getelementptr inbounds %struct.doublecomplex, ptr %676, i32 0, i32 0
  %678 = load double, ptr %677, align 8, !tbaa !13
  %679 = load ptr, ptr %20, align 8, !tbaa !5
  %680 = load i32, ptr %34, align 4, !tbaa !9
  %681 = sext i32 %680 to i64
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %679, i64 %681
  %683 = getelementptr inbounds %struct.doublecomplex, ptr %682, i32 0, i32 0
  %684 = load double, ptr %683, align 8, !tbaa !13
  %685 = load ptr, ptr %17, align 8, !tbaa !5
  %686 = load i32, ptr %33, align 4, !tbaa !9
  %687 = sext i32 %686 to i64
  %688 = getelementptr inbounds %struct.doublecomplex, ptr %685, i64 %687
  %689 = getelementptr inbounds %struct.doublecomplex, ptr %688, i32 0, i32 1
  %690 = load double, ptr %689, align 8, !tbaa !15
  %691 = load ptr, ptr %20, align 8, !tbaa !5
  %692 = load i32, ptr %34, align 4, !tbaa !9
  %693 = sext i32 %692 to i64
  %694 = getelementptr inbounds %struct.doublecomplex, ptr %691, i64 %693
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %694, i32 0, i32 1
  %696 = load double, ptr %695, align 8, !tbaa !15
  %697 = fmul double %690, %696
  %698 = fneg double %697
  %699 = call double @llvm.fmuladd.f64(double %678, double %684, double %698)
  %700 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %699, ptr %700, align 8, !tbaa !13
  %701 = load ptr, ptr %17, align 8, !tbaa !5
  %702 = load i32, ptr %33, align 4, !tbaa !9
  %703 = sext i32 %702 to i64
  %704 = getelementptr inbounds %struct.doublecomplex, ptr %701, i64 %703
  %705 = getelementptr inbounds %struct.doublecomplex, ptr %704, i32 0, i32 0
  %706 = load double, ptr %705, align 8, !tbaa !13
  %707 = load ptr, ptr %20, align 8, !tbaa !5
  %708 = load i32, ptr %34, align 4, !tbaa !9
  %709 = sext i32 %708 to i64
  %710 = getelementptr inbounds %struct.doublecomplex, ptr %707, i64 %709
  %711 = getelementptr inbounds %struct.doublecomplex, ptr %710, i32 0, i32 1
  %712 = load double, ptr %711, align 8, !tbaa !15
  %713 = load ptr, ptr %17, align 8, !tbaa !5
  %714 = load i32, ptr %33, align 4, !tbaa !9
  %715 = sext i32 %714 to i64
  %716 = getelementptr inbounds %struct.doublecomplex, ptr %713, i64 %715
  %717 = getelementptr inbounds %struct.doublecomplex, ptr %716, i32 0, i32 1
  %718 = load double, ptr %717, align 8, !tbaa !15
  %719 = load ptr, ptr %20, align 8, !tbaa !5
  %720 = load i32, ptr %34, align 4, !tbaa !9
  %721 = sext i32 %720 to i64
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %719, i64 %721
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %722, i32 0, i32 0
  %724 = load double, ptr %723, align 8, !tbaa !13
  %725 = fmul double %718, %724
  %726 = call double @llvm.fmuladd.f64(double %706, double %712, double %725)
  %727 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %726, ptr %727, align 8, !tbaa !15
  %728 = load ptr, ptr %23, align 8, !tbaa !5
  %729 = load i32, ptr %32, align 4, !tbaa !9
  %730 = sext i32 %729 to i64
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %728, i64 %730
  %732 = getelementptr inbounds %struct.doublecomplex, ptr %731, i32 0, i32 0
  %733 = load double, ptr %732, align 8, !tbaa !13
  %734 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %735 = load double, ptr %734, align 8, !tbaa !13
  %736 = fadd double %733, %735
  %737 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %736, ptr %737, align 8, !tbaa !13
  %738 = load ptr, ptr %23, align 8, !tbaa !5
  %739 = load i32, ptr %32, align 4, !tbaa !9
  %740 = sext i32 %739 to i64
  %741 = getelementptr inbounds %struct.doublecomplex, ptr %738, i64 %740
  %742 = getelementptr inbounds %struct.doublecomplex, ptr %741, i32 0, i32 1
  %743 = load double, ptr %742, align 8, !tbaa !15
  %744 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %745 = load double, ptr %744, align 8, !tbaa !15
  %746 = fadd double %743, %745
  %747 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %746, ptr %747, align 8, !tbaa !15
  %748 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %748, ptr %35, align 4, !tbaa !9
  %749 = load i32, ptr %48, align 4, !tbaa !9
  %750 = load i32, ptr %49, align 4, !tbaa !9
  %751 = load i32, ptr %27, align 4, !tbaa !9
  %752 = mul nsw i32 %750, %751
  %753 = add nsw i32 %749, %752
  store i32 %753, ptr %36, align 4, !tbaa !9
  %754 = load ptr, ptr %18, align 8, !tbaa !5
  %755 = load i32, ptr %35, align 4, !tbaa !9
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds %struct.doublecomplex, ptr %754, i64 %756
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %757, i32 0, i32 0
  %759 = load double, ptr %758, align 8, !tbaa !13
  %760 = load ptr, ptr %20, align 8, !tbaa !5
  %761 = load i32, ptr %36, align 4, !tbaa !9
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %760, i64 %762
  %764 = getelementptr inbounds %struct.doublecomplex, ptr %763, i32 0, i32 0
  %765 = load double, ptr %764, align 8, !tbaa !13
  %766 = load ptr, ptr %18, align 8, !tbaa !5
  %767 = load i32, ptr %35, align 4, !tbaa !9
  %768 = sext i32 %767 to i64
  %769 = getelementptr inbounds %struct.doublecomplex, ptr %766, i64 %768
  %770 = getelementptr inbounds %struct.doublecomplex, ptr %769, i32 0, i32 1
  %771 = load double, ptr %770, align 8, !tbaa !15
  %772 = load ptr, ptr %20, align 8, !tbaa !5
  %773 = load i32, ptr %36, align 4, !tbaa !9
  %774 = sext i32 %773 to i64
  %775 = getelementptr inbounds %struct.doublecomplex, ptr %772, i64 %774
  %776 = getelementptr inbounds %struct.doublecomplex, ptr %775, i32 0, i32 1
  %777 = load double, ptr %776, align 8, !tbaa !15
  %778 = fmul double %771, %777
  %779 = fneg double %778
  %780 = call double @llvm.fmuladd.f64(double %759, double %765, double %779)
  %781 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %780, ptr %781, align 8, !tbaa !13
  %782 = load ptr, ptr %18, align 8, !tbaa !5
  %783 = load i32, ptr %35, align 4, !tbaa !9
  %784 = sext i32 %783 to i64
  %785 = getelementptr inbounds %struct.doublecomplex, ptr %782, i64 %784
  %786 = getelementptr inbounds %struct.doublecomplex, ptr %785, i32 0, i32 0
  %787 = load double, ptr %786, align 8, !tbaa !13
  %788 = load ptr, ptr %20, align 8, !tbaa !5
  %789 = load i32, ptr %36, align 4, !tbaa !9
  %790 = sext i32 %789 to i64
  %791 = getelementptr inbounds %struct.doublecomplex, ptr %788, i64 %790
  %792 = getelementptr inbounds %struct.doublecomplex, ptr %791, i32 0, i32 1
  %793 = load double, ptr %792, align 8, !tbaa !15
  %794 = load ptr, ptr %18, align 8, !tbaa !5
  %795 = load i32, ptr %35, align 4, !tbaa !9
  %796 = sext i32 %795 to i64
  %797 = getelementptr inbounds %struct.doublecomplex, ptr %794, i64 %796
  %798 = getelementptr inbounds %struct.doublecomplex, ptr %797, i32 0, i32 1
  %799 = load double, ptr %798, align 8, !tbaa !15
  %800 = load ptr, ptr %20, align 8, !tbaa !5
  %801 = load i32, ptr %36, align 4, !tbaa !9
  %802 = sext i32 %801 to i64
  %803 = getelementptr inbounds %struct.doublecomplex, ptr %800, i64 %802
  %804 = getelementptr inbounds %struct.doublecomplex, ptr %803, i32 0, i32 0
  %805 = load double, ptr %804, align 8, !tbaa !13
  %806 = fmul double %799, %805
  %807 = call double @llvm.fmuladd.f64(double %787, double %793, double %806)
  %808 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %807, ptr %808, align 8, !tbaa !15
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %810 = load double, ptr %809, align 8, !tbaa !13
  %811 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %812 = load double, ptr %811, align 8, !tbaa !13
  %813 = fadd double %810, %812
  %814 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %813, ptr %814, align 8, !tbaa !13
  %815 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %816 = load double, ptr %815, align 8, !tbaa !15
  %817 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %818 = load double, ptr %817, align 8, !tbaa !15
  %819 = fadd double %816, %818
  %820 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %819, ptr %820, align 8, !tbaa !15
  %821 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %821, ptr %37, align 4, !tbaa !9
  %822 = load i32, ptr %48, align 4, !tbaa !9
  %823 = add nsw i32 %822, 1
  %824 = load i32, ptr %49, align 4, !tbaa !9
  %825 = load i32, ptr %27, align 4, !tbaa !9
  %826 = mul nsw i32 %824, %825
  %827 = add nsw i32 %823, %826
  store i32 %827, ptr %38, align 4, !tbaa !9
  %828 = load ptr, ptr %19, align 8, !tbaa !5
  %829 = load i32, ptr %37, align 4, !tbaa !9
  %830 = sext i32 %829 to i64
  %831 = getelementptr inbounds %struct.doublecomplex, ptr %828, i64 %830
  %832 = getelementptr inbounds %struct.doublecomplex, ptr %831, i32 0, i32 0
  %833 = load double, ptr %832, align 8, !tbaa !13
  %834 = load ptr, ptr %20, align 8, !tbaa !5
  %835 = load i32, ptr %38, align 4, !tbaa !9
  %836 = sext i32 %835 to i64
  %837 = getelementptr inbounds %struct.doublecomplex, ptr %834, i64 %836
  %838 = getelementptr inbounds %struct.doublecomplex, ptr %837, i32 0, i32 0
  %839 = load double, ptr %838, align 8, !tbaa !13
  %840 = load ptr, ptr %19, align 8, !tbaa !5
  %841 = load i32, ptr %37, 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 = load ptr, ptr %20, align 8, !tbaa !5
  %847 = load i32, ptr %38, align 4, !tbaa !9
  %848 = sext i32 %847 to i64
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %846, i64 %848
  %850 = getelementptr inbounds %struct.doublecomplex, ptr %849, i32 0, i32 1
  %851 = load double, ptr %850, align 8, !tbaa !15
  %852 = fmul double %845, %851
  %853 = fneg double %852
  %854 = call double @llvm.fmuladd.f64(double %833, double %839, double %853)
  %855 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %854, ptr %855, align 8, !tbaa !13
  %856 = load ptr, ptr %19, align 8, !tbaa !5
  %857 = load i32, ptr %37, align 4, !tbaa !9
  %858 = sext i32 %857 to i64
  %859 = getelementptr inbounds %struct.doublecomplex, ptr %856, i64 %858
  %860 = getelementptr inbounds %struct.doublecomplex, ptr %859, i32 0, i32 0
  %861 = load double, ptr %860, align 8, !tbaa !13
  %862 = load ptr, ptr %20, align 8, !tbaa !5
  %863 = load i32, ptr %38, align 4, !tbaa !9
  %864 = sext i32 %863 to i64
  %865 = getelementptr inbounds %struct.doublecomplex, ptr %862, i64 %864
  %866 = getelementptr inbounds %struct.doublecomplex, ptr %865, i32 0, i32 1
  %867 = load double, ptr %866, align 8, !tbaa !15
  %868 = load ptr, ptr %19, align 8, !tbaa !5
  %869 = load i32, ptr %37, align 4, !tbaa !9
  %870 = sext i32 %869 to i64
  %871 = getelementptr inbounds %struct.doublecomplex, ptr %868, i64 %870
  %872 = getelementptr inbounds %struct.doublecomplex, ptr %871, i32 0, i32 1
  %873 = load double, ptr %872, align 8, !tbaa !15
  %874 = load ptr, ptr %20, align 8, !tbaa !5
  %875 = load i32, ptr %38, align 4, !tbaa !9
  %876 = sext i32 %875 to i64
  %877 = getelementptr inbounds %struct.doublecomplex, ptr %874, i64 %876
  %878 = getelementptr inbounds %struct.doublecomplex, ptr %877, i32 0, i32 0
  %879 = load double, ptr %878, align 8, !tbaa !13
  %880 = fmul double %873, %879
  %881 = call double @llvm.fmuladd.f64(double %861, double %867, double %880)
  %882 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %881, ptr %882, align 8, !tbaa !15
  %883 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %884 = load double, ptr %883, align 8, !tbaa !13
  %885 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %886 = load double, ptr %885, align 8, !tbaa !13
  %887 = fadd double %884, %886
  %888 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %887, ptr %888, align 8, !tbaa !13
  %889 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %890 = load double, ptr %889, align 8, !tbaa !15
  %891 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %892 = load double, ptr %891, align 8, !tbaa !15
  %893 = fadd double %890, %892
  %894 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %893, ptr %894, align 8, !tbaa !15
  %895 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %896 = load double, ptr %895, align 8, !tbaa !13
  %897 = load ptr, ptr %23, align 8, !tbaa !5
  %898 = load i32, ptr %31, align 4, !tbaa !9
  %899 = sext i32 %898 to i64
  %900 = getelementptr inbounds %struct.doublecomplex, ptr %897, i64 %899
  %901 = getelementptr inbounds %struct.doublecomplex, ptr %900, i32 0, i32 0
  store double %896, ptr %901, align 8, !tbaa !13
  %902 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %903 = load double, ptr %902, align 8, !tbaa !15
  %904 = load ptr, ptr %23, align 8, !tbaa !5
  %905 = load i32, ptr %31, align 4, !tbaa !9
  %906 = sext i32 %905 to i64
  %907 = getelementptr inbounds %struct.doublecomplex, ptr %904, i64 %906
  %908 = getelementptr inbounds %struct.doublecomplex, ptr %907, i32 0, i32 1
  store double %903, ptr %908, align 8, !tbaa !15
  br label %909

909:                                              ; preds = %654
  %910 = load i32, ptr %48, align 4, !tbaa !9
  %911 = add nsw i32 %910, 1
  store i32 %911, ptr %48, align 4, !tbaa !9
  br label %650, !llvm.loop !21

912:                                              ; preds = %650
  br label %913

913:                                              ; preds = %912, %210
  br label %914

914:                                              ; preds = %913
  %915 = load i32, ptr %49, align 4, !tbaa !9
  %916 = add nsw i32 %915, 1
  store i32 %916, ptr %49, align 4, !tbaa !9
  br label %202, !llvm.loop !22

917:                                              ; preds = %202
  br label %2339

918:                                              ; preds = %195
  %919 = load ptr, ptr %13, align 8, !tbaa !5
  %920 = call i32 @lsame_(ptr noundef %919, ptr noundef @.str.1)
  %921 = icmp ne i32 %920, 0
  br i1 %921, label %922, label %1641

922:                                              ; preds = %918
  %923 = load ptr, ptr %15, align 8, !tbaa !5
  %924 = load i32, ptr %923, align 4, !tbaa !9
  store i32 %924, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %925

925:                                              ; preds = %1637, %922
  %926 = load i32, ptr %49, align 4, !tbaa !9
  %927 = load i32, ptr %29, align 4, !tbaa !9
  %928 = icmp sle i32 %926, %927
  br i1 %928, label %929, label %1640

929:                                              ; preds = %925
  %930 = load ptr, ptr %14, align 8, !tbaa !5
  %931 = load i32, ptr %930, align 4, !tbaa !9
  %932 = icmp eq i32 %931, 1
  br i1 %932, label %933, label %1027

933:                                              ; preds = %929
  %934 = load i32, ptr %49, align 4, !tbaa !9
  %935 = load i32, ptr %25, align 4, !tbaa !9
  %936 = mul nsw i32 %934, %935
  %937 = add nsw i32 %936, 1
  store i32 %937, ptr %30, align 4, !tbaa !9
  %938 = load i32, ptr %49, align 4, !tbaa !9
  %939 = load i32, ptr %25, align 4, !tbaa !9
  %940 = mul nsw i32 %938, %939
  %941 = add nsw i32 %940, 1
  store i32 %941, ptr %31, align 4, !tbaa !9
  %942 = load i32, ptr %49, align 4, !tbaa !9
  %943 = load i32, ptr %27, align 4, !tbaa !9
  %944 = mul nsw i32 %942, %943
  %945 = add nsw i32 %944, 1
  store i32 %945, ptr %32, align 4, !tbaa !9
  %946 = load ptr, ptr %18, align 8, !tbaa !5
  %947 = getelementptr inbounds %struct.doublecomplex, ptr %946, i64 1
  %948 = getelementptr inbounds %struct.doublecomplex, ptr %947, i32 0, i32 0
  %949 = load double, ptr %948, align 8, !tbaa !13
  %950 = load ptr, ptr %20, align 8, !tbaa !5
  %951 = load i32, ptr %32, align 4, !tbaa !9
  %952 = sext i32 %951 to i64
  %953 = getelementptr inbounds %struct.doublecomplex, ptr %950, i64 %952
  %954 = getelementptr inbounds %struct.doublecomplex, ptr %953, i32 0, i32 0
  %955 = load double, ptr %954, align 8, !tbaa !13
  %956 = load ptr, ptr %18, align 8, !tbaa !5
  %957 = getelementptr inbounds %struct.doublecomplex, ptr %956, i64 1
  %958 = getelementptr inbounds %struct.doublecomplex, ptr %957, i32 0, i32 1
  %959 = load double, ptr %958, align 8, !tbaa !15
  %960 = load ptr, ptr %20, align 8, !tbaa !5
  %961 = load i32, ptr %32, align 4, !tbaa !9
  %962 = sext i32 %961 to i64
  %963 = getelementptr inbounds %struct.doublecomplex, ptr %960, i64 %962
  %964 = getelementptr inbounds %struct.doublecomplex, ptr %963, i32 0, i32 1
  %965 = load double, ptr %964, align 8, !tbaa !15
  %966 = fmul double %959, %965
  %967 = fneg double %966
  %968 = call double @llvm.fmuladd.f64(double %949, double %955, double %967)
  %969 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %968, ptr %969, align 8, !tbaa !13
  %970 = load ptr, ptr %18, align 8, !tbaa !5
  %971 = getelementptr inbounds %struct.doublecomplex, ptr %970, i64 1
  %972 = getelementptr inbounds %struct.doublecomplex, ptr %971, i32 0, i32 0
  %973 = load double, ptr %972, align 8, !tbaa !13
  %974 = load ptr, ptr %20, align 8, !tbaa !5
  %975 = load i32, ptr %32, align 4, !tbaa !9
  %976 = sext i32 %975 to i64
  %977 = getelementptr inbounds %struct.doublecomplex, ptr %974, i64 %976
  %978 = getelementptr inbounds %struct.doublecomplex, ptr %977, i32 0, i32 1
  %979 = load double, ptr %978, align 8, !tbaa !15
  %980 = load ptr, ptr %18, align 8, !tbaa !5
  %981 = getelementptr inbounds %struct.doublecomplex, ptr %980, i64 1
  %982 = getelementptr inbounds %struct.doublecomplex, ptr %981, i32 0, i32 1
  %983 = load double, ptr %982, align 8, !tbaa !15
  %984 = load ptr, ptr %20, align 8, !tbaa !5
  %985 = load i32, ptr %32, align 4, !tbaa !9
  %986 = sext i32 %985 to i64
  %987 = getelementptr inbounds %struct.doublecomplex, ptr %984, i64 %986
  %988 = getelementptr inbounds %struct.doublecomplex, ptr %987, i32 0, i32 0
  %989 = load double, ptr %988, align 8, !tbaa !13
  %990 = fmul double %983, %989
  %991 = call double @llvm.fmuladd.f64(double %973, double %979, double %990)
  %992 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %991, ptr %992, align 8, !tbaa !15
  %993 = load ptr, ptr %23, align 8, !tbaa !5
  %994 = load i32, ptr %31, align 4, !tbaa !9
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds %struct.doublecomplex, ptr %993, i64 %995
  %997 = getelementptr inbounds %struct.doublecomplex, ptr %996, i32 0, i32 0
  %998 = load double, ptr %997, align 8, !tbaa !13
  %999 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1000 = load double, ptr %999, align 8, !tbaa !13
  %1001 = fadd double %998, %1000
  %1002 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1001, ptr %1002, align 8, !tbaa !13
  %1003 = load ptr, ptr %23, align 8, !tbaa !5
  %1004 = load i32, ptr %31, align 4, !tbaa !9
  %1005 = sext i32 %1004 to i64
  %1006 = getelementptr inbounds %struct.doublecomplex, ptr %1003, i64 %1005
  %1007 = getelementptr inbounds %struct.doublecomplex, ptr %1006, i32 0, i32 1
  %1008 = load double, ptr %1007, align 8, !tbaa !15
  %1009 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1010 = load double, ptr %1009, align 8, !tbaa !15
  %1011 = fadd double %1008, %1010
  %1012 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1011, ptr %1012, align 8, !tbaa !15
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1014 = load double, ptr %1013, align 8, !tbaa !13
  %1015 = load ptr, ptr %23, align 8, !tbaa !5
  %1016 = load i32, ptr %30, align 4, !tbaa !9
  %1017 = sext i32 %1016 to i64
  %1018 = getelementptr inbounds %struct.doublecomplex, ptr %1015, i64 %1017
  %1019 = getelementptr inbounds %struct.doublecomplex, ptr %1018, i32 0, i32 0
  store double %1014, ptr %1019, align 8, !tbaa !13
  %1020 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1021 = load double, ptr %1020, align 8, !tbaa !15
  %1022 = load ptr, ptr %23, align 8, !tbaa !5
  %1023 = load i32, ptr %30, align 4, !tbaa !9
  %1024 = sext i32 %1023 to i64
  %1025 = getelementptr inbounds %struct.doublecomplex, ptr %1022, i64 %1024
  %1026 = getelementptr inbounds %struct.doublecomplex, ptr %1025, i32 0, i32 1
  store double %1021, ptr %1026, align 8, !tbaa !15
  br label %1636

1027:                                             ; preds = %929
  %1028 = load i32, ptr %49, align 4, !tbaa !9
  %1029 = load i32, ptr %25, align 4, !tbaa !9
  %1030 = mul nsw i32 %1028, %1029
  %1031 = add nsw i32 %1030, 1
  store i32 %1031, ptr %30, align 4, !tbaa !9
  %1032 = load i32, ptr %49, align 4, !tbaa !9
  %1033 = load i32, ptr %25, align 4, !tbaa !9
  %1034 = mul nsw i32 %1032, %1033
  %1035 = add nsw i32 %1034, 1
  store i32 %1035, ptr %31, align 4, !tbaa !9
  %1036 = load i32, ptr %49, align 4, !tbaa !9
  %1037 = load i32, ptr %27, align 4, !tbaa !9
  %1038 = mul nsw i32 %1036, %1037
  %1039 = add nsw i32 %1038, 1
  store i32 %1039, ptr %32, align 4, !tbaa !9
  %1040 = load ptr, ptr %18, align 8, !tbaa !5
  %1041 = getelementptr inbounds %struct.doublecomplex, ptr %1040, i64 1
  %1042 = getelementptr inbounds %struct.doublecomplex, ptr %1041, i32 0, i32 0
  %1043 = load double, ptr %1042, align 8, !tbaa !13
  %1044 = load ptr, ptr %20, align 8, !tbaa !5
  %1045 = load i32, ptr %32, align 4, !tbaa !9
  %1046 = sext i32 %1045 to i64
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %1044, i64 %1046
  %1048 = getelementptr inbounds %struct.doublecomplex, ptr %1047, i32 0, i32 0
  %1049 = load double, ptr %1048, align 8, !tbaa !13
  %1050 = load ptr, ptr %18, align 8, !tbaa !5
  %1051 = getelementptr inbounds %struct.doublecomplex, ptr %1050, i64 1
  %1052 = getelementptr inbounds %struct.doublecomplex, ptr %1051, i32 0, i32 1
  %1053 = load double, ptr %1052, align 8, !tbaa !15
  %1054 = load ptr, ptr %20, align 8, !tbaa !5
  %1055 = load i32, ptr %32, align 4, !tbaa !9
  %1056 = sext i32 %1055 to i64
  %1057 = getelementptr inbounds %struct.doublecomplex, ptr %1054, i64 %1056
  %1058 = getelementptr inbounds %struct.doublecomplex, ptr %1057, i32 0, i32 1
  %1059 = load double, ptr %1058, align 8, !tbaa !15
  %1060 = fmul double %1053, %1059
  %1061 = fneg double %1060
  %1062 = call double @llvm.fmuladd.f64(double %1043, double %1049, double %1061)
  %1063 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %1062, ptr %1063, align 8, !tbaa !13
  %1064 = load ptr, ptr %18, align 8, !tbaa !5
  %1065 = getelementptr inbounds %struct.doublecomplex, ptr %1064, i64 1
  %1066 = getelementptr inbounds %struct.doublecomplex, ptr %1065, i32 0, i32 0
  %1067 = load double, ptr %1066, align 8, !tbaa !13
  %1068 = load ptr, ptr %20, align 8, !tbaa !5
  %1069 = load i32, ptr %32, align 4, !tbaa !9
  %1070 = sext i32 %1069 to i64
  %1071 = getelementptr inbounds %struct.doublecomplex, ptr %1068, i64 %1070
  %1072 = getelementptr inbounds %struct.doublecomplex, ptr %1071, i32 0, i32 1
  %1073 = load double, ptr %1072, align 8, !tbaa !15
  %1074 = load ptr, ptr %18, align 8, !tbaa !5
  %1075 = getelementptr inbounds %struct.doublecomplex, ptr %1074, i64 1
  %1076 = getelementptr inbounds %struct.doublecomplex, ptr %1075, i32 0, i32 1
  %1077 = load double, ptr %1076, align 8, !tbaa !15
  %1078 = load ptr, ptr %20, align 8, !tbaa !5
  %1079 = load i32, ptr %32, align 4, !tbaa !9
  %1080 = sext i32 %1079 to i64
  %1081 = getelementptr inbounds %struct.doublecomplex, ptr %1078, i64 %1080
  %1082 = getelementptr inbounds %struct.doublecomplex, ptr %1081, i32 0, i32 0
  %1083 = load double, ptr %1082, align 8, !tbaa !13
  %1084 = fmul double %1077, %1083
  %1085 = call double @llvm.fmuladd.f64(double %1067, double %1073, double %1084)
  %1086 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %1085, ptr %1086, align 8, !tbaa !15
  %1087 = load ptr, ptr %23, align 8, !tbaa !5
  %1088 = load i32, ptr %31, align 4, !tbaa !9
  %1089 = sext i32 %1088 to i64
  %1090 = getelementptr inbounds %struct.doublecomplex, ptr %1087, i64 %1089
  %1091 = getelementptr inbounds %struct.doublecomplex, ptr %1090, i32 0, i32 0
  %1092 = load double, ptr %1091, align 8, !tbaa !13
  %1093 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1094 = load double, ptr %1093, align 8, !tbaa !13
  %1095 = fadd double %1092, %1094
  %1096 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1095, ptr %1096, align 8, !tbaa !13
  %1097 = load ptr, ptr %23, align 8, !tbaa !5
  %1098 = load i32, ptr %31, align 4, !tbaa !9
  %1099 = sext i32 %1098 to i64
  %1100 = getelementptr inbounds %struct.doublecomplex, ptr %1097, i64 %1099
  %1101 = getelementptr inbounds %struct.doublecomplex, ptr %1100, i32 0, i32 1
  %1102 = load double, ptr %1101, align 8, !tbaa !15
  %1103 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1104 = load double, ptr %1103, align 8, !tbaa !15
  %1105 = fadd double %1102, %1104
  %1106 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1105, ptr %1106, align 8, !tbaa !15
  %1107 = load i32, ptr %49, align 4, !tbaa !9
  %1108 = load i32, ptr %27, align 4, !tbaa !9
  %1109 = mul nsw i32 %1107, %1108
  %1110 = add nsw i32 %1109, 2
  store i32 %1110, ptr %33, align 4, !tbaa !9
  %1111 = load ptr, ptr %17, align 8, !tbaa !5
  %1112 = getelementptr inbounds %struct.doublecomplex, ptr %1111, i64 1
  %1113 = getelementptr inbounds %struct.doublecomplex, ptr %1112, i32 0, i32 0
  %1114 = load double, ptr %1113, align 8, !tbaa !13
  %1115 = load ptr, ptr %20, align 8, !tbaa !5
  %1116 = load i32, ptr %33, align 4, !tbaa !9
  %1117 = sext i32 %1116 to i64
  %1118 = getelementptr inbounds %struct.doublecomplex, ptr %1115, i64 %1117
  %1119 = getelementptr inbounds %struct.doublecomplex, ptr %1118, i32 0, i32 0
  %1120 = load double, ptr %1119, align 8, !tbaa !13
  %1121 = load ptr, ptr %17, align 8, !tbaa !5
  %1122 = getelementptr inbounds %struct.doublecomplex, ptr %1121, i64 1
  %1123 = getelementptr inbounds %struct.doublecomplex, ptr %1122, i32 0, i32 1
  %1124 = load double, ptr %1123, align 8, !tbaa !15
  %1125 = load ptr, ptr %20, align 8, !tbaa !5
  %1126 = load i32, ptr %33, align 4, !tbaa !9
  %1127 = sext i32 %1126 to i64
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %1125, i64 %1127
  %1129 = getelementptr inbounds %struct.doublecomplex, ptr %1128, i32 0, i32 1
  %1130 = load double, ptr %1129, align 8, !tbaa !15
  %1131 = fmul double %1124, %1130
  %1132 = fneg double %1131
  %1133 = call double @llvm.fmuladd.f64(double %1114, double %1120, double %1132)
  %1134 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1133, ptr %1134, align 8, !tbaa !13
  %1135 = load ptr, ptr %17, align 8, !tbaa !5
  %1136 = getelementptr inbounds %struct.doublecomplex, ptr %1135, i64 1
  %1137 = getelementptr inbounds %struct.doublecomplex, ptr %1136, i32 0, i32 0
  %1138 = load double, ptr %1137, align 8, !tbaa !13
  %1139 = load ptr, ptr %20, align 8, !tbaa !5
  %1140 = load i32, ptr %33, align 4, !tbaa !9
  %1141 = sext i32 %1140 to i64
  %1142 = getelementptr inbounds %struct.doublecomplex, ptr %1139, i64 %1141
  %1143 = getelementptr inbounds %struct.doublecomplex, ptr %1142, i32 0, i32 1
  %1144 = load double, ptr %1143, align 8, !tbaa !15
  %1145 = load ptr, ptr %17, align 8, !tbaa !5
  %1146 = getelementptr inbounds %struct.doublecomplex, ptr %1145, i64 1
  %1147 = getelementptr inbounds %struct.doublecomplex, ptr %1146, i32 0, i32 1
  %1148 = load double, ptr %1147, align 8, !tbaa !15
  %1149 = load ptr, ptr %20, align 8, !tbaa !5
  %1150 = load i32, ptr %33, align 4, !tbaa !9
  %1151 = sext i32 %1150 to i64
  %1152 = getelementptr inbounds %struct.doublecomplex, ptr %1149, i64 %1151
  %1153 = getelementptr inbounds %struct.doublecomplex, ptr %1152, i32 0, i32 0
  %1154 = load double, ptr %1153, align 8, !tbaa !13
  %1155 = fmul double %1148, %1154
  %1156 = call double @llvm.fmuladd.f64(double %1138, double %1144, double %1155)
  %1157 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1156, ptr %1157, align 8, !tbaa !15
  %1158 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1159 = load double, ptr %1158, align 8, !tbaa !13
  %1160 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1161 = load double, ptr %1160, align 8, !tbaa !13
  %1162 = fadd double %1159, %1161
  %1163 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1162, ptr %1163, align 8, !tbaa !13
  %1164 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1165 = load double, ptr %1164, align 8, !tbaa !15
  %1166 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1167 = load double, ptr %1166, align 8, !tbaa !15
  %1168 = fadd double %1165, %1167
  %1169 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1168, ptr %1169, align 8, !tbaa !15
  %1170 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1171 = load double, ptr %1170, align 8, !tbaa !13
  %1172 = load ptr, ptr %23, align 8, !tbaa !5
  %1173 = load i32, ptr %30, align 4, !tbaa !9
  %1174 = sext i32 %1173 to i64
  %1175 = getelementptr inbounds %struct.doublecomplex, ptr %1172, i64 %1174
  %1176 = getelementptr inbounds %struct.doublecomplex, ptr %1175, i32 0, i32 0
  store double %1171, ptr %1176, align 8, !tbaa !13
  %1177 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1178 = load double, ptr %1177, align 8, !tbaa !15
  %1179 = load ptr, ptr %23, align 8, !tbaa !5
  %1180 = load i32, ptr %30, align 4, !tbaa !9
  %1181 = sext i32 %1180 to i64
  %1182 = getelementptr inbounds %struct.doublecomplex, ptr %1179, i64 %1181
  %1183 = getelementptr inbounds %struct.doublecomplex, ptr %1182, i32 0, i32 1
  store double %1178, ptr %1183, align 8, !tbaa !15
  %1184 = load ptr, ptr %14, align 8, !tbaa !5
  %1185 = load i32, ptr %1184, align 4, !tbaa !9
  %1186 = load i32, ptr %49, align 4, !tbaa !9
  %1187 = load i32, ptr %25, align 4, !tbaa !9
  %1188 = mul nsw i32 %1186, %1187
  %1189 = add nsw i32 %1185, %1188
  store i32 %1189, ptr %30, align 4, !tbaa !9
  %1190 = load ptr, ptr %14, align 8, !tbaa !5
  %1191 = load i32, ptr %1190, align 4, !tbaa !9
  %1192 = load i32, ptr %49, align 4, !tbaa !9
  %1193 = load i32, ptr %25, align 4, !tbaa !9
  %1194 = mul nsw i32 %1192, %1193
  %1195 = add nsw i32 %1191, %1194
  store i32 %1195, ptr %31, align 4, !tbaa !9
  %1196 = load ptr, ptr %14, align 8, !tbaa !5
  %1197 = load i32, ptr %1196, align 4, !tbaa !9
  %1198 = sub nsw i32 %1197, 1
  store i32 %1198, ptr %32, align 4, !tbaa !9
  %1199 = load ptr, ptr %14, align 8, !tbaa !5
  %1200 = load i32, ptr %1199, align 4, !tbaa !9
  %1201 = sub nsw i32 %1200, 1
  %1202 = load i32, ptr %49, align 4, !tbaa !9
  %1203 = load i32, ptr %27, align 4, !tbaa !9
  %1204 = mul nsw i32 %1202, %1203
  %1205 = add nsw i32 %1201, %1204
  store i32 %1205, ptr %33, align 4, !tbaa !9
  %1206 = load ptr, ptr %19, align 8, !tbaa !5
  %1207 = load i32, ptr %32, align 4, !tbaa !9
  %1208 = sext i32 %1207 to i64
  %1209 = getelementptr inbounds %struct.doublecomplex, ptr %1206, i64 %1208
  %1210 = getelementptr inbounds %struct.doublecomplex, ptr %1209, i32 0, i32 0
  %1211 = load double, ptr %1210, align 8, !tbaa !13
  %1212 = load ptr, ptr %20, align 8, !tbaa !5
  %1213 = load i32, ptr %33, align 4, !tbaa !9
  %1214 = sext i32 %1213 to i64
  %1215 = getelementptr inbounds %struct.doublecomplex, ptr %1212, i64 %1214
  %1216 = getelementptr inbounds %struct.doublecomplex, ptr %1215, i32 0, i32 0
  %1217 = load double, ptr %1216, align 8, !tbaa !13
  %1218 = load ptr, ptr %19, align 8, !tbaa !5
  %1219 = load i32, ptr %32, align 4, !tbaa !9
  %1220 = sext i32 %1219 to i64
  %1221 = getelementptr inbounds %struct.doublecomplex, ptr %1218, i64 %1220
  %1222 = getelementptr inbounds %struct.doublecomplex, ptr %1221, i32 0, i32 1
  %1223 = load double, ptr %1222, align 8, !tbaa !15
  %1224 = load ptr, ptr %20, align 8, !tbaa !5
  %1225 = load i32, ptr %33, align 4, !tbaa !9
  %1226 = sext i32 %1225 to i64
  %1227 = getelementptr inbounds %struct.doublecomplex, ptr %1224, i64 %1226
  %1228 = getelementptr inbounds %struct.doublecomplex, ptr %1227, i32 0, i32 1
  %1229 = load double, ptr %1228, align 8, !tbaa !15
  %1230 = fmul double %1223, %1229
  %1231 = fneg double %1230
  %1232 = call double @llvm.fmuladd.f64(double %1211, double %1217, double %1231)
  %1233 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %1232, ptr %1233, align 8, !tbaa !13
  %1234 = load ptr, ptr %19, align 8, !tbaa !5
  %1235 = load i32, ptr %32, align 4, !tbaa !9
  %1236 = sext i32 %1235 to i64
  %1237 = getelementptr inbounds %struct.doublecomplex, ptr %1234, i64 %1236
  %1238 = getelementptr inbounds %struct.doublecomplex, ptr %1237, i32 0, i32 0
  %1239 = load double, ptr %1238, align 8, !tbaa !13
  %1240 = load ptr, ptr %20, align 8, !tbaa !5
  %1241 = load i32, ptr %33, align 4, !tbaa !9
  %1242 = sext i32 %1241 to i64
  %1243 = getelementptr inbounds %struct.doublecomplex, ptr %1240, i64 %1242
  %1244 = getelementptr inbounds %struct.doublecomplex, ptr %1243, i32 0, i32 1
  %1245 = load double, ptr %1244, align 8, !tbaa !15
  %1246 = load ptr, ptr %19, align 8, !tbaa !5
  %1247 = load i32, ptr %32, align 4, !tbaa !9
  %1248 = sext i32 %1247 to i64
  %1249 = getelementptr inbounds %struct.doublecomplex, ptr %1246, i64 %1248
  %1250 = getelementptr inbounds %struct.doublecomplex, ptr %1249, i32 0, i32 1
  %1251 = load double, ptr %1250, align 8, !tbaa !15
  %1252 = load ptr, ptr %20, align 8, !tbaa !5
  %1253 = load i32, ptr %33, align 4, !tbaa !9
  %1254 = sext i32 %1253 to i64
  %1255 = getelementptr inbounds %struct.doublecomplex, ptr %1252, i64 %1254
  %1256 = getelementptr inbounds %struct.doublecomplex, ptr %1255, i32 0, i32 0
  %1257 = load double, ptr %1256, align 8, !tbaa !13
  %1258 = fmul double %1251, %1257
  %1259 = call double @llvm.fmuladd.f64(double %1239, double %1245, double %1258)
  %1260 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %1259, ptr %1260, align 8, !tbaa !15
  %1261 = load ptr, ptr %23, align 8, !tbaa !5
  %1262 = load i32, ptr %31, align 4, !tbaa !9
  %1263 = sext i32 %1262 to i64
  %1264 = getelementptr inbounds %struct.doublecomplex, ptr %1261, i64 %1263
  %1265 = getelementptr inbounds %struct.doublecomplex, ptr %1264, i32 0, i32 0
  %1266 = load double, ptr %1265, align 8, !tbaa !13
  %1267 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1268 = load double, ptr %1267, align 8, !tbaa !13
  %1269 = fadd double %1266, %1268
  %1270 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1269, ptr %1270, align 8, !tbaa !13
  %1271 = load ptr, ptr %23, align 8, !tbaa !5
  %1272 = load i32, ptr %31, align 4, !tbaa !9
  %1273 = sext i32 %1272 to i64
  %1274 = getelementptr inbounds %struct.doublecomplex, ptr %1271, i64 %1273
  %1275 = getelementptr inbounds %struct.doublecomplex, ptr %1274, i32 0, i32 1
  %1276 = load double, ptr %1275, align 8, !tbaa !15
  %1277 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1278 = load double, ptr %1277, align 8, !tbaa !15
  %1279 = fadd double %1276, %1278
  %1280 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1279, ptr %1280, align 8, !tbaa !15
  %1281 = load ptr, ptr %14, align 8, !tbaa !5
  %1282 = load i32, ptr %1281, align 4, !tbaa !9
  store i32 %1282, ptr %34, align 4, !tbaa !9
  %1283 = load ptr, ptr %14, align 8, !tbaa !5
  %1284 = load i32, ptr %1283, align 4, !tbaa !9
  %1285 = load i32, ptr %49, align 4, !tbaa !9
  %1286 = load i32, ptr %27, align 4, !tbaa !9
  %1287 = mul nsw i32 %1285, %1286
  %1288 = add nsw i32 %1284, %1287
  store i32 %1288, ptr %35, align 4, !tbaa !9
  %1289 = load ptr, ptr %18, align 8, !tbaa !5
  %1290 = load i32, ptr %34, align 4, !tbaa !9
  %1291 = sext i32 %1290 to i64
  %1292 = getelementptr inbounds %struct.doublecomplex, ptr %1289, i64 %1291
  %1293 = getelementptr inbounds %struct.doublecomplex, ptr %1292, i32 0, i32 0
  %1294 = load double, ptr %1293, align 8, !tbaa !13
  %1295 = load ptr, ptr %20, align 8, !tbaa !5
  %1296 = load i32, ptr %35, align 4, !tbaa !9
  %1297 = sext i32 %1296 to i64
  %1298 = getelementptr inbounds %struct.doublecomplex, ptr %1295, i64 %1297
  %1299 = getelementptr inbounds %struct.doublecomplex, ptr %1298, i32 0, i32 0
  %1300 = load double, ptr %1299, align 8, !tbaa !13
  %1301 = load ptr, ptr %18, align 8, !tbaa !5
  %1302 = load i32, ptr %34, align 4, !tbaa !9
  %1303 = sext i32 %1302 to i64
  %1304 = getelementptr inbounds %struct.doublecomplex, ptr %1301, i64 %1303
  %1305 = getelementptr inbounds %struct.doublecomplex, ptr %1304, i32 0, i32 1
  %1306 = load double, ptr %1305, align 8, !tbaa !15
  %1307 = load ptr, ptr %20, align 8, !tbaa !5
  %1308 = load i32, ptr %35, align 4, !tbaa !9
  %1309 = sext i32 %1308 to i64
  %1310 = getelementptr inbounds %struct.doublecomplex, ptr %1307, i64 %1309
  %1311 = getelementptr inbounds %struct.doublecomplex, ptr %1310, i32 0, i32 1
  %1312 = load double, ptr %1311, align 8, !tbaa !15
  %1313 = fmul double %1306, %1312
  %1314 = fneg double %1313
  %1315 = call double @llvm.fmuladd.f64(double %1294, double %1300, double %1314)
  %1316 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1315, ptr %1316, align 8, !tbaa !13
  %1317 = load ptr, ptr %18, align 8, !tbaa !5
  %1318 = load i32, ptr %34, align 4, !tbaa !9
  %1319 = sext i32 %1318 to i64
  %1320 = getelementptr inbounds %struct.doublecomplex, ptr %1317, i64 %1319
  %1321 = getelementptr inbounds %struct.doublecomplex, ptr %1320, i32 0, i32 0
  %1322 = load double, ptr %1321, align 8, !tbaa !13
  %1323 = load ptr, ptr %20, align 8, !tbaa !5
  %1324 = load i32, ptr %35, align 4, !tbaa !9
  %1325 = sext i32 %1324 to i64
  %1326 = getelementptr inbounds %struct.doublecomplex, ptr %1323, i64 %1325
  %1327 = getelementptr inbounds %struct.doublecomplex, ptr %1326, i32 0, i32 1
  %1328 = load double, ptr %1327, align 8, !tbaa !15
  %1329 = load ptr, ptr %18, align 8, !tbaa !5
  %1330 = load i32, ptr %34, align 4, !tbaa !9
  %1331 = sext i32 %1330 to i64
  %1332 = getelementptr inbounds %struct.doublecomplex, ptr %1329, i64 %1331
  %1333 = getelementptr inbounds %struct.doublecomplex, ptr %1332, i32 0, i32 1
  %1334 = load double, ptr %1333, align 8, !tbaa !15
  %1335 = load ptr, ptr %20, align 8, !tbaa !5
  %1336 = load i32, ptr %35, align 4, !tbaa !9
  %1337 = sext i32 %1336 to i64
  %1338 = getelementptr inbounds %struct.doublecomplex, ptr %1335, i64 %1337
  %1339 = getelementptr inbounds %struct.doublecomplex, ptr %1338, i32 0, i32 0
  %1340 = load double, ptr %1339, align 8, !tbaa !13
  %1341 = fmul double %1334, %1340
  %1342 = call double @llvm.fmuladd.f64(double %1322, double %1328, double %1341)
  %1343 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1342, ptr %1343, align 8, !tbaa !15
  %1344 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1345 = load double, ptr %1344, align 8, !tbaa !13
  %1346 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1347 = load double, ptr %1346, align 8, !tbaa !13
  %1348 = fadd double %1345, %1347
  %1349 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1348, ptr %1349, align 8, !tbaa !13
  %1350 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1351 = load double, ptr %1350, align 8, !tbaa !15
  %1352 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1353 = load double, ptr %1352, align 8, !tbaa !15
  %1354 = fadd double %1351, %1353
  %1355 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1354, ptr %1355, align 8, !tbaa !15
  %1356 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1357 = load double, ptr %1356, align 8, !tbaa !13
  %1358 = load ptr, ptr %23, align 8, !tbaa !5
  %1359 = load i32, ptr %30, align 4, !tbaa !9
  %1360 = sext i32 %1359 to i64
  %1361 = getelementptr inbounds %struct.doublecomplex, ptr %1358, i64 %1360
  %1362 = getelementptr inbounds %struct.doublecomplex, ptr %1361, i32 0, i32 0
  store double %1357, ptr %1362, align 8, !tbaa !13
  %1363 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1364 = load double, ptr %1363, align 8, !tbaa !15
  %1365 = load ptr, ptr %23, align 8, !tbaa !5
  %1366 = load i32, ptr %30, align 4, !tbaa !9
  %1367 = sext i32 %1366 to i64
  %1368 = getelementptr inbounds %struct.doublecomplex, ptr %1365, i64 %1367
  %1369 = getelementptr inbounds %struct.doublecomplex, ptr %1368, i32 0, i32 1
  store double %1364, ptr %1369, align 8, !tbaa !15
  %1370 = load ptr, ptr %14, align 8, !tbaa !5
  %1371 = load i32, ptr %1370, align 4, !tbaa !9
  %1372 = sub nsw i32 %1371, 1
  store i32 %1372, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %1373

1373:                                             ; preds = %1632, %1027
  %1374 = load i32, ptr %48, align 4, !tbaa !9
  %1375 = load i32, ptr %30, align 4, !tbaa !9
  %1376 = icmp sle i32 %1374, %1375
  br i1 %1376, label %1377, label %1635

1377:                                             ; preds = %1373
  %1378 = load i32, ptr %48, align 4, !tbaa !9
  %1379 = load i32, ptr %49, align 4, !tbaa !9
  %1380 = load i32, ptr %25, align 4, !tbaa !9
  %1381 = mul nsw i32 %1379, %1380
  %1382 = add nsw i32 %1378, %1381
  store i32 %1382, ptr %31, align 4, !tbaa !9
  %1383 = load i32, ptr %48, align 4, !tbaa !9
  %1384 = load i32, ptr %49, align 4, !tbaa !9
  %1385 = load i32, ptr %25, align 4, !tbaa !9
  %1386 = mul nsw i32 %1384, %1385
  %1387 = add nsw i32 %1383, %1386
  store i32 %1387, ptr %32, align 4, !tbaa !9
  %1388 = load i32, ptr %48, align 4, !tbaa !9
  %1389 = sub nsw i32 %1388, 1
  store i32 %1389, ptr %33, align 4, !tbaa !9
  %1390 = load i32, ptr %48, align 4, !tbaa !9
  %1391 = sub nsw i32 %1390, 1
  %1392 = load i32, ptr %49, align 4, !tbaa !9
  %1393 = load i32, ptr %27, align 4, !tbaa !9
  %1394 = mul nsw i32 %1392, %1393
  %1395 = add nsw i32 %1391, %1394
  store i32 %1395, ptr %34, align 4, !tbaa !9
  %1396 = load ptr, ptr %19, align 8, !tbaa !5
  %1397 = load i32, ptr %33, align 4, !tbaa !9
  %1398 = sext i32 %1397 to i64
  %1399 = getelementptr inbounds %struct.doublecomplex, ptr %1396, i64 %1398
  %1400 = getelementptr inbounds %struct.doublecomplex, ptr %1399, i32 0, i32 0
  %1401 = load double, ptr %1400, align 8, !tbaa !13
  %1402 = load ptr, ptr %20, align 8, !tbaa !5
  %1403 = load i32, ptr %34, 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
  %1408 = load ptr, ptr %19, align 8, !tbaa !5
  %1409 = load i32, ptr %33, align 4, !tbaa !9
  %1410 = sext i32 %1409 to i64
  %1411 = getelementptr inbounds %struct.doublecomplex, ptr %1408, i64 %1410
  %1412 = getelementptr inbounds %struct.doublecomplex, ptr %1411, i32 0, i32 1
  %1413 = load double, ptr %1412, align 8, !tbaa !15
  %1414 = load ptr, ptr %20, align 8, !tbaa !5
  %1415 = load i32, ptr %34, align 4, !tbaa !9
  %1416 = sext i32 %1415 to i64
  %1417 = getelementptr inbounds %struct.doublecomplex, ptr %1414, i64 %1416
  %1418 = getelementptr inbounds %struct.doublecomplex, ptr %1417, i32 0, i32 1
  %1419 = load double, ptr %1418, align 8, !tbaa !15
  %1420 = fmul double %1413, %1419
  %1421 = fneg double %1420
  %1422 = call double @llvm.fmuladd.f64(double %1401, double %1407, double %1421)
  %1423 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %1422, ptr %1423, align 8, !tbaa !13
  %1424 = load ptr, ptr %19, align 8, !tbaa !5
  %1425 = load i32, ptr %33, align 4, !tbaa !9
  %1426 = sext i32 %1425 to i64
  %1427 = getelementptr inbounds %struct.doublecomplex, ptr %1424, i64 %1426
  %1428 = getelementptr inbounds %struct.doublecomplex, ptr %1427, i32 0, i32 0
  %1429 = load double, ptr %1428, align 8, !tbaa !13
  %1430 = load ptr, ptr %20, align 8, !tbaa !5
  %1431 = load i32, ptr %34, align 4, !tbaa !9
  %1432 = sext i32 %1431 to i64
  %1433 = getelementptr inbounds %struct.doublecomplex, ptr %1430, i64 %1432
  %1434 = getelementptr inbounds %struct.doublecomplex, ptr %1433, i32 0, i32 1
  %1435 = load double, ptr %1434, align 8, !tbaa !15
  %1436 = load ptr, ptr %19, align 8, !tbaa !5
  %1437 = load i32, ptr %33, align 4, !tbaa !9
  %1438 = sext i32 %1437 to i64
  %1439 = getelementptr inbounds %struct.doublecomplex, ptr %1436, i64 %1438
  %1440 = getelementptr inbounds %struct.doublecomplex, ptr %1439, i32 0, i32 1
  %1441 = load double, ptr %1440, align 8, !tbaa !15
  %1442 = load ptr, ptr %20, align 8, !tbaa !5
  %1443 = load i32, ptr %34, align 4, !tbaa !9
  %1444 = sext i32 %1443 to i64
  %1445 = getelementptr inbounds %struct.doublecomplex, ptr %1442, i64 %1444
  %1446 = getelementptr inbounds %struct.doublecomplex, ptr %1445, i32 0, i32 0
  %1447 = load double, ptr %1446, align 8, !tbaa !13
  %1448 = fmul double %1441, %1447
  %1449 = call double @llvm.fmuladd.f64(double %1429, double %1435, double %1448)
  %1450 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %1449, ptr %1450, align 8, !tbaa !15
  %1451 = load ptr, ptr %23, align 8, !tbaa !5
  %1452 = load i32, ptr %32, align 4, !tbaa !9
  %1453 = sext i32 %1452 to i64
  %1454 = getelementptr inbounds %struct.doublecomplex, ptr %1451, i64 %1453
  %1455 = getelementptr inbounds %struct.doublecomplex, ptr %1454, i32 0, i32 0
  %1456 = load double, ptr %1455, align 8, !tbaa !13
  %1457 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1458 = load double, ptr %1457, align 8, !tbaa !13
  %1459 = fadd double %1456, %1458
  %1460 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %1459, ptr %1460, align 8, !tbaa !13
  %1461 = load ptr, ptr %23, align 8, !tbaa !5
  %1462 = load i32, ptr %32, align 4, !tbaa !9
  %1463 = sext i32 %1462 to i64
  %1464 = getelementptr inbounds %struct.doublecomplex, ptr %1461, i64 %1463
  %1465 = getelementptr inbounds %struct.doublecomplex, ptr %1464, i32 0, i32 1
  %1466 = load double, ptr %1465, align 8, !tbaa !15
  %1467 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1468 = load double, ptr %1467, align 8, !tbaa !15
  %1469 = fadd double %1466, %1468
  %1470 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %1469, ptr %1470, align 8, !tbaa !15
  %1471 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %1471, ptr %35, align 4, !tbaa !9
  %1472 = load i32, ptr %48, align 4, !tbaa !9
  %1473 = load i32, ptr %49, align 4, !tbaa !9
  %1474 = load i32, ptr %27, align 4, !tbaa !9
  %1475 = mul nsw i32 %1473, %1474
  %1476 = add nsw i32 %1472, %1475
  store i32 %1476, ptr %36, align 4, !tbaa !9
  %1477 = load ptr, ptr %18, align 8, !tbaa !5
  %1478 = load i32, ptr %35, align 4, !tbaa !9
  %1479 = sext i32 %1478 to i64
  %1480 = getelementptr inbounds %struct.doublecomplex, ptr %1477, i64 %1479
  %1481 = getelementptr inbounds %struct.doublecomplex, ptr %1480, i32 0, i32 0
  %1482 = load double, ptr %1481, align 8, !tbaa !13
  %1483 = load ptr, ptr %20, align 8, !tbaa !5
  %1484 = load i32, ptr %36, align 4, !tbaa !9
  %1485 = sext i32 %1484 to i64
  %1486 = getelementptr inbounds %struct.doublecomplex, ptr %1483, i64 %1485
  %1487 = getelementptr inbounds %struct.doublecomplex, ptr %1486, i32 0, i32 0
  %1488 = load double, ptr %1487, align 8, !tbaa !13
  %1489 = load ptr, ptr %18, align 8, !tbaa !5
  %1490 = load i32, ptr %35, align 4, !tbaa !9
  %1491 = sext i32 %1490 to i64
  %1492 = getelementptr inbounds %struct.doublecomplex, ptr %1489, i64 %1491
  %1493 = getelementptr inbounds %struct.doublecomplex, ptr %1492, i32 0, i32 1
  %1494 = load double, ptr %1493, align 8, !tbaa !15
  %1495 = load ptr, ptr %20, align 8, !tbaa !5
  %1496 = load i32, ptr %36, align 4, !tbaa !9
  %1497 = sext i32 %1496 to i64
  %1498 = getelementptr inbounds %struct.doublecomplex, ptr %1495, i64 %1497
  %1499 = getelementptr inbounds %struct.doublecomplex, ptr %1498, i32 0, i32 1
  %1500 = load double, ptr %1499, align 8, !tbaa !15
  %1501 = fmul double %1494, %1500
  %1502 = fneg double %1501
  %1503 = call double @llvm.fmuladd.f64(double %1482, double %1488, double %1502)
  %1504 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1503, ptr %1504, align 8, !tbaa !13
  %1505 = load ptr, ptr %18, align 8, !tbaa !5
  %1506 = load i32, ptr %35, align 4, !tbaa !9
  %1507 = sext i32 %1506 to i64
  %1508 = getelementptr inbounds %struct.doublecomplex, ptr %1505, i64 %1507
  %1509 = getelementptr inbounds %struct.doublecomplex, ptr %1508, i32 0, i32 0
  %1510 = load double, ptr %1509, align 8, !tbaa !13
  %1511 = load ptr, ptr %20, align 8, !tbaa !5
  %1512 = load i32, ptr %36, align 4, !tbaa !9
  %1513 = sext i32 %1512 to i64
  %1514 = getelementptr inbounds %struct.doublecomplex, ptr %1511, i64 %1513
  %1515 = getelementptr inbounds %struct.doublecomplex, ptr %1514, i32 0, i32 1
  %1516 = load double, ptr %1515, align 8, !tbaa !15
  %1517 = load ptr, ptr %18, align 8, !tbaa !5
  %1518 = load i32, ptr %35, align 4, !tbaa !9
  %1519 = sext i32 %1518 to i64
  %1520 = getelementptr inbounds %struct.doublecomplex, ptr %1517, i64 %1519
  %1521 = getelementptr inbounds %struct.doublecomplex, ptr %1520, i32 0, i32 1
  %1522 = load double, ptr %1521, align 8, !tbaa !15
  %1523 = load ptr, ptr %20, align 8, !tbaa !5
  %1524 = load i32, ptr %36, align 4, !tbaa !9
  %1525 = sext i32 %1524 to i64
  %1526 = getelementptr inbounds %struct.doublecomplex, ptr %1523, i64 %1525
  %1527 = getelementptr inbounds %struct.doublecomplex, ptr %1526, i32 0, i32 0
  %1528 = load double, ptr %1527, align 8, !tbaa !13
  %1529 = fmul double %1522, %1528
  %1530 = call double @llvm.fmuladd.f64(double %1510, double %1516, double %1529)
  %1531 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1530, ptr %1531, align 8, !tbaa !15
  %1532 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1533 = load double, ptr %1532, align 8, !tbaa !13
  %1534 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1535 = load double, ptr %1534, align 8, !tbaa !13
  %1536 = fadd double %1533, %1535
  %1537 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1536, ptr %1537, align 8, !tbaa !13
  %1538 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1539 = load double, ptr %1538, align 8, !tbaa !15
  %1540 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1541 = load double, ptr %1540, align 8, !tbaa !15
  %1542 = fadd double %1539, %1541
  %1543 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1542, ptr %1543, align 8, !tbaa !15
  %1544 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %1544, ptr %37, align 4, !tbaa !9
  %1545 = load i32, ptr %48, align 4, !tbaa !9
  %1546 = add nsw i32 %1545, 1
  %1547 = load i32, ptr %49, align 4, !tbaa !9
  %1548 = load i32, ptr %27, align 4, !tbaa !9
  %1549 = mul nsw i32 %1547, %1548
  %1550 = add nsw i32 %1546, %1549
  store i32 %1550, ptr %38, align 4, !tbaa !9
  %1551 = load ptr, ptr %17, align 8, !tbaa !5
  %1552 = load i32, ptr %37, align 4, !tbaa !9
  %1553 = sext i32 %1552 to i64
  %1554 = getelementptr inbounds %struct.doublecomplex, ptr %1551, i64 %1553
  %1555 = getelementptr inbounds %struct.doublecomplex, ptr %1554, i32 0, i32 0
  %1556 = load double, ptr %1555, align 8, !tbaa !13
  %1557 = load ptr, ptr %20, align 8, !tbaa !5
  %1558 = load i32, ptr %38, align 4, !tbaa !9
  %1559 = sext i32 %1558 to i64
  %1560 = getelementptr inbounds %struct.doublecomplex, ptr %1557, i64 %1559
  %1561 = getelementptr inbounds %struct.doublecomplex, ptr %1560, i32 0, i32 0
  %1562 = load double, ptr %1561, align 8, !tbaa !13
  %1563 = load ptr, ptr %17, align 8, !tbaa !5
  %1564 = load i32, ptr %37, 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 1
  %1568 = load double, ptr %1567, align 8, !tbaa !15
  %1569 = load ptr, ptr %20, align 8, !tbaa !5
  %1570 = load i32, ptr %38, align 4, !tbaa !9
  %1571 = sext i32 %1570 to i64
  %1572 = getelementptr inbounds %struct.doublecomplex, ptr %1569, i64 %1571
  %1573 = getelementptr inbounds %struct.doublecomplex, ptr %1572, i32 0, i32 1
  %1574 = load double, ptr %1573, align 8, !tbaa !15
  %1575 = fmul double %1568, %1574
  %1576 = fneg double %1575
  %1577 = call double @llvm.fmuladd.f64(double %1556, double %1562, double %1576)
  %1578 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %1577, ptr %1578, align 8, !tbaa !13
  %1579 = load ptr, ptr %17, align 8, !tbaa !5
  %1580 = load i32, ptr %37, align 4, !tbaa !9
  %1581 = sext i32 %1580 to i64
  %1582 = getelementptr inbounds %struct.doublecomplex, ptr %1579, i64 %1581
  %1583 = getelementptr inbounds %struct.doublecomplex, ptr %1582, i32 0, i32 0
  %1584 = load double, ptr %1583, align 8, !tbaa !13
  %1585 = load ptr, ptr %20, align 8, !tbaa !5
  %1586 = load i32, ptr %38, align 4, !tbaa !9
  %1587 = sext i32 %1586 to i64
  %1588 = getelementptr inbounds %struct.doublecomplex, ptr %1585, i64 %1587
  %1589 = getelementptr inbounds %struct.doublecomplex, ptr %1588, i32 0, i32 1
  %1590 = load double, ptr %1589, align 8, !tbaa !15
  %1591 = load ptr, ptr %17, align 8, !tbaa !5
  %1592 = load i32, ptr %37, align 4, !tbaa !9
  %1593 = sext i32 %1592 to i64
  %1594 = getelementptr inbounds %struct.doublecomplex, ptr %1591, i64 %1593
  %1595 = getelementptr inbounds %struct.doublecomplex, ptr %1594, i32 0, i32 1
  %1596 = load double, ptr %1595, align 8, !tbaa !15
  %1597 = load ptr, ptr %20, align 8, !tbaa !5
  %1598 = load i32, ptr %38, align 4, !tbaa !9
  %1599 = sext i32 %1598 to i64
  %1600 = getelementptr inbounds %struct.doublecomplex, ptr %1597, i64 %1599
  %1601 = getelementptr inbounds %struct.doublecomplex, ptr %1600, i32 0, i32 0
  %1602 = load double, ptr %1601, align 8, !tbaa !13
  %1603 = fmul double %1596, %1602
  %1604 = call double @llvm.fmuladd.f64(double %1584, double %1590, double %1603)
  %1605 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %1604, ptr %1605, align 8, !tbaa !15
  %1606 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1607 = load double, ptr %1606, align 8, !tbaa !13
  %1608 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1609 = load double, ptr %1608, align 8, !tbaa !13
  %1610 = fadd double %1607, %1609
  %1611 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1610, ptr %1611, align 8, !tbaa !13
  %1612 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1613 = load double, ptr %1612, align 8, !tbaa !15
  %1614 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1615 = load double, ptr %1614, align 8, !tbaa !15
  %1616 = fadd double %1613, %1615
  %1617 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1616, ptr %1617, align 8, !tbaa !15
  %1618 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1619 = load double, ptr %1618, align 8, !tbaa !13
  %1620 = load ptr, ptr %23, align 8, !tbaa !5
  %1621 = load i32, ptr %31, align 4, !tbaa !9
  %1622 = sext i32 %1621 to i64
  %1623 = getelementptr inbounds %struct.doublecomplex, ptr %1620, i64 %1622
  %1624 = getelementptr inbounds %struct.doublecomplex, ptr %1623, i32 0, i32 0
  store double %1619, ptr %1624, align 8, !tbaa !13
  %1625 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1626 = load double, ptr %1625, align 8, !tbaa !15
  %1627 = load ptr, ptr %23, align 8, !tbaa !5
  %1628 = load i32, ptr %31, align 4, !tbaa !9
  %1629 = sext i32 %1628 to i64
  %1630 = getelementptr inbounds %struct.doublecomplex, ptr %1627, i64 %1629
  %1631 = getelementptr inbounds %struct.doublecomplex, ptr %1630, i32 0, i32 1
  store double %1626, ptr %1631, align 8, !tbaa !15
  br label %1632

1632:                                             ; preds = %1377
  %1633 = load i32, ptr %48, align 4, !tbaa !9
  %1634 = add nsw i32 %1633, 1
  store i32 %1634, ptr %48, align 4, !tbaa !9
  br label %1373, !llvm.loop !23

1635:                                             ; preds = %1373
  br label %1636

1636:                                             ; preds = %1635, %933
  br label %1637

1637:                                             ; preds = %1636
  %1638 = load i32, ptr %49, align 4, !tbaa !9
  %1639 = add nsw i32 %1638, 1
  store i32 %1639, ptr %49, align 4, !tbaa !9
  br label %925, !llvm.loop !24

1640:                                             ; preds = %925
  br label %2338

1641:                                             ; preds = %918
  %1642 = load ptr, ptr %13, align 8, !tbaa !5
  %1643 = call i32 @lsame_(ptr noundef %1642, ptr noundef @.str.2)
  %1644 = icmp ne i32 %1643, 0
  br i1 %1644, label %1645, label %2337

1645:                                             ; preds = %1641
  %1646 = load ptr, ptr %15, align 8, !tbaa !5
  %1647 = load i32, ptr %1646, align 4, !tbaa !9
  store i32 %1647, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %1648

1648:                                             ; preds = %2333, %1645
  %1649 = load i32, ptr %49, align 4, !tbaa !9
  %1650 = load i32, ptr %29, align 4, !tbaa !9
  %1651 = icmp sle i32 %1649, %1650
  br i1 %1651, label %1652, label %2336

1652:                                             ; preds = %1648
  %1653 = load ptr, ptr %14, align 8, !tbaa !5
  %1654 = load i32, ptr %1653, align 4, !tbaa !9
  %1655 = icmp eq i32 %1654, 1
  br i1 %1655, label %1656, label %1751

1656:                                             ; preds = %1652
  %1657 = load i32, ptr %49, align 4, !tbaa !9
  %1658 = load i32, ptr %25, align 4, !tbaa !9
  %1659 = mul nsw i32 %1657, %1658
  %1660 = add nsw i32 %1659, 1
  store i32 %1660, ptr %30, align 4, !tbaa !9
  %1661 = load i32, ptr %49, align 4, !tbaa !9
  %1662 = load i32, ptr %25, align 4, !tbaa !9
  %1663 = mul nsw i32 %1661, %1662
  %1664 = add nsw i32 %1663, 1
  store i32 %1664, ptr %31, align 4, !tbaa !9
  %1665 = load ptr, ptr %18, align 8, !tbaa !5
  %1666 = getelementptr inbounds %struct.doublecomplex, ptr %1665, i64 1
  %1667 = call { double, double } @Cd(ptr noundef %1666)
  %1668 = extractvalue { double, double } %1667, 0
  %1669 = extractvalue { double, double } %1667, 1
  %1670 = fneg double %1669
  %1671 = call ptr @_pCd(ptr noundef %41)
  %1672 = getelementptr inbounds { double, double }, ptr %1671, i32 0, i32 0
  %1673 = getelementptr inbounds { double, double }, ptr %1671, i32 0, i32 1
  store double %1668, ptr %1672, align 8
  store double %1670, ptr %1673, align 8
  %1674 = load i32, ptr %49, align 4, !tbaa !9
  %1675 = load i32, ptr %27, align 4, !tbaa !9
  %1676 = mul nsw i32 %1674, %1675
  %1677 = add nsw i32 %1676, 1
  store i32 %1677, ptr %32, align 4, !tbaa !9
  %1678 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1679 = load double, ptr %1678, align 8, !tbaa !13
  %1680 = load ptr, ptr %20, align 8, !tbaa !5
  %1681 = load i32, ptr %32, align 4, !tbaa !9
  %1682 = sext i32 %1681 to i64
  %1683 = getelementptr inbounds %struct.doublecomplex, ptr %1680, i64 %1682
  %1684 = getelementptr inbounds %struct.doublecomplex, ptr %1683, i32 0, i32 0
  %1685 = load double, ptr %1684, align 8, !tbaa !13
  %1686 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1687 = load double, ptr %1686, align 8, !tbaa !15
  %1688 = load ptr, ptr %20, align 8, !tbaa !5
  %1689 = load i32, ptr %32, align 4, !tbaa !9
  %1690 = sext i32 %1689 to i64
  %1691 = getelementptr inbounds %struct.doublecomplex, ptr %1688, i64 %1690
  %1692 = getelementptr inbounds %struct.doublecomplex, ptr %1691, i32 0, i32 1
  %1693 = load double, ptr %1692, align 8, !tbaa !15
  %1694 = fmul double %1687, %1693
  %1695 = fneg double %1694
  %1696 = call double @llvm.fmuladd.f64(double %1679, double %1685, double %1695)
  %1697 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1696, ptr %1697, align 8, !tbaa !13
  %1698 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1699 = load double, ptr %1698, align 8, !tbaa !13
  %1700 = load ptr, ptr %20, align 8, !tbaa !5
  %1701 = load i32, ptr %32, align 4, !tbaa !9
  %1702 = sext i32 %1701 to i64
  %1703 = getelementptr inbounds %struct.doublecomplex, ptr %1700, i64 %1702
  %1704 = getelementptr inbounds %struct.doublecomplex, ptr %1703, i32 0, i32 1
  %1705 = load double, ptr %1704, align 8, !tbaa !15
  %1706 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1707 = load double, ptr %1706, align 8, !tbaa !15
  %1708 = load ptr, ptr %20, align 8, !tbaa !5
  %1709 = load i32, ptr %32, align 4, !tbaa !9
  %1710 = sext i32 %1709 to i64
  %1711 = getelementptr inbounds %struct.doublecomplex, ptr %1708, i64 %1710
  %1712 = getelementptr inbounds %struct.doublecomplex, ptr %1711, i32 0, i32 0
  %1713 = load double, ptr %1712, align 8, !tbaa !13
  %1714 = fmul double %1707, %1713
  %1715 = call double @llvm.fmuladd.f64(double %1699, double %1705, double %1714)
  %1716 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1715, ptr %1716, align 8, !tbaa !15
  %1717 = load ptr, ptr %23, align 8, !tbaa !5
  %1718 = load i32, ptr %31, align 4, !tbaa !9
  %1719 = sext i32 %1718 to i64
  %1720 = getelementptr inbounds %struct.doublecomplex, ptr %1717, i64 %1719
  %1721 = getelementptr inbounds %struct.doublecomplex, ptr %1720, i32 0, i32 0
  %1722 = load double, ptr %1721, align 8, !tbaa !13
  %1723 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1724 = load double, ptr %1723, align 8, !tbaa !13
  %1725 = fadd double %1722, %1724
  %1726 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1725, ptr %1726, align 8, !tbaa !13
  %1727 = load ptr, ptr %23, align 8, !tbaa !5
  %1728 = load i32, ptr %31, align 4, !tbaa !9
  %1729 = sext i32 %1728 to i64
  %1730 = getelementptr inbounds %struct.doublecomplex, ptr %1727, i64 %1729
  %1731 = getelementptr inbounds %struct.doublecomplex, ptr %1730, i32 0, i32 1
  %1732 = load double, ptr %1731, align 8, !tbaa !15
  %1733 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1734 = load double, ptr %1733, align 8, !tbaa !15
  %1735 = fadd double %1732, %1734
  %1736 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1735, ptr %1736, align 8, !tbaa !15
  %1737 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1738 = load double, ptr %1737, align 8, !tbaa !13
  %1739 = load ptr, ptr %23, align 8, !tbaa !5
  %1740 = load i32, ptr %30, align 4, !tbaa !9
  %1741 = sext i32 %1740 to i64
  %1742 = getelementptr inbounds %struct.doublecomplex, ptr %1739, i64 %1741
  %1743 = getelementptr inbounds %struct.doublecomplex, ptr %1742, i32 0, i32 0
  store double %1738, ptr %1743, align 8, !tbaa !13
  %1744 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1745 = load double, ptr %1744, align 8, !tbaa !15
  %1746 = load ptr, ptr %23, align 8, !tbaa !5
  %1747 = load i32, ptr %30, align 4, !tbaa !9
  %1748 = sext i32 %1747 to i64
  %1749 = getelementptr inbounds %struct.doublecomplex, ptr %1746, i64 %1748
  %1750 = getelementptr inbounds %struct.doublecomplex, ptr %1749, i32 0, i32 1
  store double %1745, ptr %1750, align 8, !tbaa !15
  br label %2332

1751:                                             ; preds = %1652
  %1752 = load i32, ptr %49, align 4, !tbaa !9
  %1753 = load i32, ptr %25, align 4, !tbaa !9
  %1754 = mul nsw i32 %1752, %1753
  %1755 = add nsw i32 %1754, 1
  store i32 %1755, ptr %30, align 4, !tbaa !9
  %1756 = load i32, ptr %49, align 4, !tbaa !9
  %1757 = load i32, ptr %25, align 4, !tbaa !9
  %1758 = mul nsw i32 %1756, %1757
  %1759 = add nsw i32 %1758, 1
  store i32 %1759, ptr %31, align 4, !tbaa !9
  %1760 = load ptr, ptr %18, align 8, !tbaa !5
  %1761 = getelementptr inbounds %struct.doublecomplex, ptr %1760, i64 1
  %1762 = call { double, double } @Cd(ptr noundef %1761)
  %1763 = extractvalue { double, double } %1762, 0
  %1764 = extractvalue { double, double } %1762, 1
  %1765 = fneg double %1764
  %1766 = call ptr @_pCd(ptr noundef %42)
  %1767 = getelementptr inbounds { double, double }, ptr %1766, i32 0, i32 0
  %1768 = getelementptr inbounds { double, double }, ptr %1766, i32 0, i32 1
  store double %1763, ptr %1767, align 8
  store double %1765, ptr %1768, align 8
  %1769 = load i32, ptr %49, align 4, !tbaa !9
  %1770 = load i32, ptr %27, align 4, !tbaa !9
  %1771 = mul nsw i32 %1769, %1770
  %1772 = add nsw i32 %1771, 1
  store i32 %1772, ptr %32, align 4, !tbaa !9
  %1773 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1774 = load double, ptr %1773, align 8, !tbaa !13
  %1775 = load ptr, ptr %20, align 8, !tbaa !5
  %1776 = load i32, ptr %32, align 4, !tbaa !9
  %1777 = sext i32 %1776 to i64
  %1778 = getelementptr inbounds %struct.doublecomplex, ptr %1775, i64 %1777
  %1779 = getelementptr inbounds %struct.doublecomplex, ptr %1778, i32 0, i32 0
  %1780 = load double, ptr %1779, align 8, !tbaa !13
  %1781 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1782 = load double, ptr %1781, align 8, !tbaa !15
  %1783 = load ptr, ptr %20, align 8, !tbaa !5
  %1784 = load i32, ptr %32, align 4, !tbaa !9
  %1785 = sext i32 %1784 to i64
  %1786 = getelementptr inbounds %struct.doublecomplex, ptr %1783, i64 %1785
  %1787 = getelementptr inbounds %struct.doublecomplex, ptr %1786, i32 0, i32 1
  %1788 = load double, ptr %1787, align 8, !tbaa !15
  %1789 = fmul double %1782, %1788
  %1790 = fneg double %1789
  %1791 = call double @llvm.fmuladd.f64(double %1774, double %1780, double %1790)
  %1792 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %1791, ptr %1792, align 8, !tbaa !13
  %1793 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1794 = load double, ptr %1793, align 8, !tbaa !13
  %1795 = load ptr, ptr %20, align 8, !tbaa !5
  %1796 = load i32, ptr %32, align 4, !tbaa !9
  %1797 = sext i32 %1796 to i64
  %1798 = getelementptr inbounds %struct.doublecomplex, ptr %1795, i64 %1797
  %1799 = getelementptr inbounds %struct.doublecomplex, ptr %1798, i32 0, i32 1
  %1800 = load double, ptr %1799, align 8, !tbaa !15
  %1801 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1802 = load double, ptr %1801, align 8, !tbaa !15
  %1803 = load ptr, ptr %20, align 8, !tbaa !5
  %1804 = load i32, ptr %32, align 4, !tbaa !9
  %1805 = sext i32 %1804 to i64
  %1806 = getelementptr inbounds %struct.doublecomplex, ptr %1803, i64 %1805
  %1807 = getelementptr inbounds %struct.doublecomplex, ptr %1806, i32 0, i32 0
  %1808 = load double, ptr %1807, align 8, !tbaa !13
  %1809 = fmul double %1802, %1808
  %1810 = call double @llvm.fmuladd.f64(double %1794, double %1800, double %1809)
  %1811 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %1810, ptr %1811, align 8, !tbaa !15
  %1812 = load ptr, ptr %23, align 8, !tbaa !5
  %1813 = load i32, ptr %31, align 4, !tbaa !9
  %1814 = sext i32 %1813 to i64
  %1815 = getelementptr inbounds %struct.doublecomplex, ptr %1812, i64 %1814
  %1816 = getelementptr inbounds %struct.doublecomplex, ptr %1815, i32 0, i32 0
  %1817 = load double, ptr %1816, align 8, !tbaa !13
  %1818 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1819 = load double, ptr %1818, align 8, !tbaa !13
  %1820 = fadd double %1817, %1819
  %1821 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1820, ptr %1821, align 8, !tbaa !13
  %1822 = load ptr, ptr %23, align 8, !tbaa !5
  %1823 = load i32, ptr %31, align 4, !tbaa !9
  %1824 = sext i32 %1823 to i64
  %1825 = getelementptr inbounds %struct.doublecomplex, ptr %1822, i64 %1824
  %1826 = getelementptr inbounds %struct.doublecomplex, ptr %1825, i32 0, i32 1
  %1827 = load double, ptr %1826, align 8, !tbaa !15
  %1828 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1829 = load double, ptr %1828, align 8, !tbaa !15
  %1830 = fadd double %1827, %1829
  %1831 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1830, ptr %1831, align 8, !tbaa !15
  %1832 = load ptr, ptr %17, align 8, !tbaa !5
  %1833 = getelementptr inbounds %struct.doublecomplex, ptr %1832, i64 1
  %1834 = call { double, double } @Cd(ptr noundef %1833)
  %1835 = extractvalue { double, double } %1834, 0
  %1836 = extractvalue { double, double } %1834, 1
  %1837 = fneg double %1836
  %1838 = call ptr @_pCd(ptr noundef %44)
  %1839 = getelementptr inbounds { double, double }, ptr %1838, i32 0, i32 0
  %1840 = getelementptr inbounds { double, double }, ptr %1838, i32 0, i32 1
  store double %1835, ptr %1839, align 8
  store double %1837, ptr %1840, align 8
  %1841 = load i32, ptr %49, align 4, !tbaa !9
  %1842 = load i32, ptr %27, align 4, !tbaa !9
  %1843 = mul nsw i32 %1841, %1842
  %1844 = add nsw i32 %1843, 2
  store i32 %1844, ptr %33, align 4, !tbaa !9
  %1845 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1846 = load double, ptr %1845, align 8, !tbaa !13
  %1847 = load ptr, ptr %20, align 8, !tbaa !5
  %1848 = load i32, ptr %33, align 4, !tbaa !9
  %1849 = sext i32 %1848 to i64
  %1850 = getelementptr inbounds %struct.doublecomplex, ptr %1847, i64 %1849
  %1851 = getelementptr inbounds %struct.doublecomplex, ptr %1850, i32 0, i32 0
  %1852 = load double, ptr %1851, align 8, !tbaa !13
  %1853 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1854 = load double, ptr %1853, align 8, !tbaa !15
  %1855 = load ptr, ptr %20, align 8, !tbaa !5
  %1856 = load i32, ptr %33, align 4, !tbaa !9
  %1857 = sext i32 %1856 to i64
  %1858 = getelementptr inbounds %struct.doublecomplex, ptr %1855, i64 %1857
  %1859 = getelementptr inbounds %struct.doublecomplex, ptr %1858, i32 0, i32 1
  %1860 = load double, ptr %1859, align 8, !tbaa !15
  %1861 = fmul double %1854, %1860
  %1862 = fneg double %1861
  %1863 = call double @llvm.fmuladd.f64(double %1846, double %1852, double %1862)
  %1864 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %1863, ptr %1864, align 8, !tbaa !13
  %1865 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %1866 = load double, ptr %1865, align 8, !tbaa !13
  %1867 = load ptr, ptr %20, align 8, !tbaa !5
  %1868 = load i32, ptr %33, align 4, !tbaa !9
  %1869 = sext i32 %1868 to i64
  %1870 = getelementptr inbounds %struct.doublecomplex, ptr %1867, i64 %1869
  %1871 = getelementptr inbounds %struct.doublecomplex, ptr %1870, i32 0, i32 1
  %1872 = load double, ptr %1871, align 8, !tbaa !15
  %1873 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %1874 = load double, ptr %1873, align 8, !tbaa !15
  %1875 = load ptr, ptr %20, align 8, !tbaa !5
  %1876 = load i32, ptr %33, align 4, !tbaa !9
  %1877 = sext i32 %1876 to i64
  %1878 = getelementptr inbounds %struct.doublecomplex, ptr %1875, i64 %1877
  %1879 = getelementptr inbounds %struct.doublecomplex, ptr %1878, i32 0, i32 0
  %1880 = load double, ptr %1879, align 8, !tbaa !13
  %1881 = fmul double %1874, %1880
  %1882 = call double @llvm.fmuladd.f64(double %1866, double %1872, double %1881)
  %1883 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %1882, ptr %1883, align 8, !tbaa !15
  %1884 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %1885 = load double, ptr %1884, align 8, !tbaa !13
  %1886 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %1887 = load double, ptr %1886, align 8, !tbaa !13
  %1888 = fadd double %1885, %1887
  %1889 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %1888, ptr %1889, align 8, !tbaa !13
  %1890 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %1891 = load double, ptr %1890, align 8, !tbaa !15
  %1892 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %1893 = load double, ptr %1892, align 8, !tbaa !15
  %1894 = fadd double %1891, %1893
  %1895 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %1894, ptr %1895, align 8, !tbaa !15
  %1896 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %1897 = load double, ptr %1896, align 8, !tbaa !13
  %1898 = load ptr, ptr %23, align 8, !tbaa !5
  %1899 = load i32, ptr %30, align 4, !tbaa !9
  %1900 = sext i32 %1899 to i64
  %1901 = getelementptr inbounds %struct.doublecomplex, ptr %1898, i64 %1900
  %1902 = getelementptr inbounds %struct.doublecomplex, ptr %1901, i32 0, i32 0
  store double %1897, ptr %1902, align 8, !tbaa !13
  %1903 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %1904 = load double, ptr %1903, align 8, !tbaa !15
  %1905 = load ptr, ptr %23, align 8, !tbaa !5
  %1906 = load i32, ptr %30, align 4, !tbaa !9
  %1907 = sext i32 %1906 to i64
  %1908 = getelementptr inbounds %struct.doublecomplex, ptr %1905, i64 %1907
  %1909 = getelementptr inbounds %struct.doublecomplex, ptr %1908, i32 0, i32 1
  store double %1904, ptr %1909, align 8, !tbaa !15
  %1910 = load ptr, ptr %14, align 8, !tbaa !5
  %1911 = load i32, ptr %1910, align 4, !tbaa !9
  %1912 = load i32, ptr %49, align 4, !tbaa !9
  %1913 = load i32, ptr %25, align 4, !tbaa !9
  %1914 = mul nsw i32 %1912, %1913
  %1915 = add nsw i32 %1911, %1914
  store i32 %1915, ptr %30, align 4, !tbaa !9
  %1916 = load ptr, ptr %14, align 8, !tbaa !5
  %1917 = load i32, ptr %1916, align 4, !tbaa !9
  %1918 = load i32, ptr %49, align 4, !tbaa !9
  %1919 = load i32, ptr %25, align 4, !tbaa !9
  %1920 = mul nsw i32 %1918, %1919
  %1921 = add nsw i32 %1917, %1920
  store i32 %1921, ptr %31, align 4, !tbaa !9
  %1922 = load ptr, ptr %19, align 8, !tbaa !5
  %1923 = load ptr, ptr %14, align 8, !tbaa !5
  %1924 = load i32, ptr %1923, align 4, !tbaa !9
  %1925 = sub nsw i32 %1924, 1
  %1926 = sext i32 %1925 to i64
  %1927 = getelementptr inbounds %struct.doublecomplex, ptr %1922, i64 %1926
  %1928 = call { double, double } @Cd(ptr noundef %1927)
  %1929 = extractvalue { double, double } %1928, 0
  %1930 = extractvalue { double, double } %1928, 1
  %1931 = fneg double %1930
  %1932 = call ptr @_pCd(ptr noundef %42)
  %1933 = getelementptr inbounds { double, double }, ptr %1932, i32 0, i32 0
  %1934 = getelementptr inbounds { double, double }, ptr %1932, i32 0, i32 1
  store double %1929, ptr %1933, align 8
  store double %1931, ptr %1934, align 8
  %1935 = load ptr, ptr %14, align 8, !tbaa !5
  %1936 = load i32, ptr %1935, align 4, !tbaa !9
  %1937 = sub nsw i32 %1936, 1
  %1938 = load i32, ptr %49, align 4, !tbaa !9
  %1939 = load i32, ptr %27, align 4, !tbaa !9
  %1940 = mul nsw i32 %1938, %1939
  %1941 = add nsw i32 %1937, %1940
  store i32 %1941, ptr %32, align 4, !tbaa !9
  %1942 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1943 = load double, ptr %1942, align 8, !tbaa !13
  %1944 = load ptr, ptr %20, align 8, !tbaa !5
  %1945 = load i32, ptr %32, align 4, !tbaa !9
  %1946 = sext i32 %1945 to i64
  %1947 = getelementptr inbounds %struct.doublecomplex, ptr %1944, i64 %1946
  %1948 = getelementptr inbounds %struct.doublecomplex, ptr %1947, i32 0, i32 0
  %1949 = load double, ptr %1948, align 8, !tbaa !13
  %1950 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1951 = load double, ptr %1950, align 8, !tbaa !15
  %1952 = load ptr, ptr %20, align 8, !tbaa !5
  %1953 = load i32, ptr %32, align 4, !tbaa !9
  %1954 = sext i32 %1953 to i64
  %1955 = getelementptr inbounds %struct.doublecomplex, ptr %1952, i64 %1954
  %1956 = getelementptr inbounds %struct.doublecomplex, ptr %1955, i32 0, i32 1
  %1957 = load double, ptr %1956, align 8, !tbaa !15
  %1958 = fmul double %1951, %1957
  %1959 = fneg double %1958
  %1960 = call double @llvm.fmuladd.f64(double %1943, double %1949, double %1959)
  %1961 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %1960, ptr %1961, align 8, !tbaa !13
  %1962 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %1963 = load double, ptr %1962, align 8, !tbaa !13
  %1964 = load ptr, ptr %20, align 8, !tbaa !5
  %1965 = load i32, ptr %32, align 4, !tbaa !9
  %1966 = sext i32 %1965 to i64
  %1967 = getelementptr inbounds %struct.doublecomplex, ptr %1964, i64 %1966
  %1968 = getelementptr inbounds %struct.doublecomplex, ptr %1967, i32 0, i32 1
  %1969 = load double, ptr %1968, align 8, !tbaa !15
  %1970 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %1971 = load double, ptr %1970, align 8, !tbaa !15
  %1972 = load ptr, ptr %20, align 8, !tbaa !5
  %1973 = load i32, ptr %32, align 4, !tbaa !9
  %1974 = sext i32 %1973 to i64
  %1975 = getelementptr inbounds %struct.doublecomplex, ptr %1972, i64 %1974
  %1976 = getelementptr inbounds %struct.doublecomplex, ptr %1975, i32 0, i32 0
  %1977 = load double, ptr %1976, align 8, !tbaa !13
  %1978 = fmul double %1971, %1977
  %1979 = call double @llvm.fmuladd.f64(double %1963, double %1969, double %1978)
  %1980 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %1979, ptr %1980, align 8, !tbaa !15
  %1981 = load ptr, ptr %23, align 8, !tbaa !5
  %1982 = load i32, ptr %31, align 4, !tbaa !9
  %1983 = sext i32 %1982 to i64
  %1984 = getelementptr inbounds %struct.doublecomplex, ptr %1981, i64 %1983
  %1985 = getelementptr inbounds %struct.doublecomplex, ptr %1984, i32 0, i32 0
  %1986 = load double, ptr %1985, align 8, !tbaa !13
  %1987 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1988 = load double, ptr %1987, align 8, !tbaa !13
  %1989 = fadd double %1986, %1988
  %1990 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %1989, ptr %1990, align 8, !tbaa !13
  %1991 = load ptr, ptr %23, align 8, !tbaa !5
  %1992 = load i32, ptr %31, align 4, !tbaa !9
  %1993 = sext i32 %1992 to i64
  %1994 = getelementptr inbounds %struct.doublecomplex, ptr %1991, i64 %1993
  %1995 = getelementptr inbounds %struct.doublecomplex, ptr %1994, i32 0, i32 1
  %1996 = load double, ptr %1995, align 8, !tbaa !15
  %1997 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1998 = load double, ptr %1997, align 8, !tbaa !15
  %1999 = fadd double %1996, %1998
  %2000 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %1999, ptr %2000, align 8, !tbaa !15
  %2001 = load ptr, ptr %18, align 8, !tbaa !5
  %2002 = load ptr, ptr %14, align 8, !tbaa !5
  %2003 = load i32, ptr %2002, align 4, !tbaa !9
  %2004 = sext i32 %2003 to i64
  %2005 = getelementptr inbounds %struct.doublecomplex, ptr %2001, i64 %2004
  %2006 = call { double, double } @Cd(ptr noundef %2005)
  %2007 = extractvalue { double, double } %2006, 0
  %2008 = extractvalue { double, double } %2006, 1
  %2009 = fneg double %2008
  %2010 = call ptr @_pCd(ptr noundef %44)
  %2011 = getelementptr inbounds { double, double }, ptr %2010, i32 0, i32 0
  %2012 = getelementptr inbounds { double, double }, ptr %2010, i32 0, i32 1
  store double %2007, ptr %2011, align 8
  store double %2009, ptr %2012, align 8
  %2013 = load ptr, ptr %14, align 8, !tbaa !5
  %2014 = load i32, ptr %2013, align 4, !tbaa !9
  %2015 = load i32, ptr %49, align 4, !tbaa !9
  %2016 = load i32, ptr %27, align 4, !tbaa !9
  %2017 = mul nsw i32 %2015, %2016
  %2018 = add nsw i32 %2014, %2017
  store i32 %2018, ptr %33, align 4, !tbaa !9
  %2019 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2020 = load double, ptr %2019, align 8, !tbaa !13
  %2021 = load ptr, ptr %20, align 8, !tbaa !5
  %2022 = load i32, ptr %33, align 4, !tbaa !9
  %2023 = sext i32 %2022 to i64
  %2024 = getelementptr inbounds %struct.doublecomplex, ptr %2021, i64 %2023
  %2025 = getelementptr inbounds %struct.doublecomplex, ptr %2024, i32 0, i32 0
  %2026 = load double, ptr %2025, align 8, !tbaa !13
  %2027 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2028 = load double, ptr %2027, align 8, !tbaa !15
  %2029 = load ptr, ptr %20, align 8, !tbaa !5
  %2030 = load i32, ptr %33, align 4, !tbaa !9
  %2031 = sext i32 %2030 to i64
  %2032 = getelementptr inbounds %struct.doublecomplex, ptr %2029, i64 %2031
  %2033 = getelementptr inbounds %struct.doublecomplex, ptr %2032, i32 0, i32 1
  %2034 = load double, ptr %2033, align 8, !tbaa !15
  %2035 = fmul double %2028, %2034
  %2036 = fneg double %2035
  %2037 = call double @llvm.fmuladd.f64(double %2020, double %2026, double %2036)
  %2038 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2037, ptr %2038, align 8, !tbaa !13
  %2039 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2040 = load double, ptr %2039, align 8, !tbaa !13
  %2041 = load ptr, ptr %20, align 8, !tbaa !5
  %2042 = load i32, ptr %33, align 4, !tbaa !9
  %2043 = sext i32 %2042 to i64
  %2044 = getelementptr inbounds %struct.doublecomplex, ptr %2041, i64 %2043
  %2045 = getelementptr inbounds %struct.doublecomplex, ptr %2044, i32 0, i32 1
  %2046 = load double, ptr %2045, align 8, !tbaa !15
  %2047 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2048 = load double, ptr %2047, align 8, !tbaa !15
  %2049 = load ptr, ptr %20, align 8, !tbaa !5
  %2050 = load i32, ptr %33, align 4, !tbaa !9
  %2051 = sext i32 %2050 to i64
  %2052 = getelementptr inbounds %struct.doublecomplex, ptr %2049, i64 %2051
  %2053 = getelementptr inbounds %struct.doublecomplex, ptr %2052, i32 0, i32 0
  %2054 = load double, ptr %2053, align 8, !tbaa !13
  %2055 = fmul double %2048, %2054
  %2056 = call double @llvm.fmuladd.f64(double %2040, double %2046, double %2055)
  %2057 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2056, ptr %2057, align 8, !tbaa !15
  %2058 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %2059 = load double, ptr %2058, align 8, !tbaa !13
  %2060 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2061 = load double, ptr %2060, align 8, !tbaa !13
  %2062 = fadd double %2059, %2061
  %2063 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2062, ptr %2063, align 8, !tbaa !13
  %2064 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %2065 = load double, ptr %2064, align 8, !tbaa !15
  %2066 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2067 = load double, ptr %2066, align 8, !tbaa !15
  %2068 = fadd double %2065, %2067
  %2069 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2068, ptr %2069, align 8, !tbaa !15
  %2070 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2071 = load double, ptr %2070, align 8, !tbaa !13
  %2072 = load ptr, ptr %23, align 8, !tbaa !5
  %2073 = load i32, ptr %30, align 4, !tbaa !9
  %2074 = sext i32 %2073 to i64
  %2075 = getelementptr inbounds %struct.doublecomplex, ptr %2072, i64 %2074
  %2076 = getelementptr inbounds %struct.doublecomplex, ptr %2075, i32 0, i32 0
  store double %2071, ptr %2076, align 8, !tbaa !13
  %2077 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2078 = load double, ptr %2077, align 8, !tbaa !15
  %2079 = load ptr, ptr %23, align 8, !tbaa !5
  %2080 = load i32, ptr %30, align 4, !tbaa !9
  %2081 = sext i32 %2080 to i64
  %2082 = getelementptr inbounds %struct.doublecomplex, ptr %2079, i64 %2081
  %2083 = getelementptr inbounds %struct.doublecomplex, ptr %2082, i32 0, i32 1
  store double %2078, ptr %2083, align 8, !tbaa !15
  %2084 = load ptr, ptr %14, align 8, !tbaa !5
  %2085 = load i32, ptr %2084, align 4, !tbaa !9
  %2086 = sub nsw i32 %2085, 1
  store i32 %2086, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %2087

2087:                                             ; preds = %2328, %1751
  %2088 = load i32, ptr %48, align 4, !tbaa !9
  %2089 = load i32, ptr %30, align 4, !tbaa !9
  %2090 = icmp sle i32 %2088, %2089
  br i1 %2090, label %2091, label %2331

2091:                                             ; preds = %2087
  %2092 = load i32, ptr %48, align 4, !tbaa !9
  %2093 = load i32, ptr %49, align 4, !tbaa !9
  %2094 = load i32, ptr %25, align 4, !tbaa !9
  %2095 = mul nsw i32 %2093, %2094
  %2096 = add nsw i32 %2092, %2095
  store i32 %2096, ptr %31, align 4, !tbaa !9
  %2097 = load i32, ptr %48, align 4, !tbaa !9
  %2098 = load i32, ptr %49, align 4, !tbaa !9
  %2099 = load i32, ptr %25, align 4, !tbaa !9
  %2100 = mul nsw i32 %2098, %2099
  %2101 = add nsw i32 %2097, %2100
  store i32 %2101, ptr %32, align 4, !tbaa !9
  %2102 = load ptr, ptr %19, align 8, !tbaa !5
  %2103 = load i32, ptr %48, align 4, !tbaa !9
  %2104 = sub nsw i32 %2103, 1
  %2105 = sext i32 %2104 to i64
  %2106 = getelementptr inbounds %struct.doublecomplex, ptr %2102, i64 %2105
  %2107 = call { double, double } @Cd(ptr noundef %2106)
  %2108 = extractvalue { double, double } %2107, 0
  %2109 = extractvalue { double, double } %2107, 1
  %2110 = fneg double %2109
  %2111 = call ptr @_pCd(ptr noundef %43)
  %2112 = getelementptr inbounds { double, double }, ptr %2111, i32 0, i32 0
  %2113 = getelementptr inbounds { double, double }, ptr %2111, i32 0, i32 1
  store double %2108, ptr %2112, align 8
  store double %2110, ptr %2113, align 8
  %2114 = load i32, ptr %48, align 4, !tbaa !9
  %2115 = sub nsw i32 %2114, 1
  %2116 = load i32, ptr %49, align 4, !tbaa !9
  %2117 = load i32, ptr %27, align 4, !tbaa !9
  %2118 = mul nsw i32 %2116, %2117
  %2119 = add nsw i32 %2115, %2118
  store i32 %2119, ptr %33, align 4, !tbaa !9
  %2120 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2121 = load double, ptr %2120, align 8, !tbaa !13
  %2122 = load ptr, ptr %20, align 8, !tbaa !5
  %2123 = load i32, ptr %33, align 4, !tbaa !9
  %2124 = sext i32 %2123 to i64
  %2125 = getelementptr inbounds %struct.doublecomplex, ptr %2122, i64 %2124
  %2126 = getelementptr inbounds %struct.doublecomplex, ptr %2125, i32 0, i32 0
  %2127 = load double, ptr %2126, align 8, !tbaa !13
  %2128 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2129 = load double, ptr %2128, align 8, !tbaa !15
  %2130 = load ptr, ptr %20, align 8, !tbaa !5
  %2131 = load i32, ptr %33, align 4, !tbaa !9
  %2132 = sext i32 %2131 to i64
  %2133 = getelementptr inbounds %struct.doublecomplex, ptr %2130, i64 %2132
  %2134 = getelementptr inbounds %struct.doublecomplex, ptr %2133, i32 0, i32 1
  %2135 = load double, ptr %2134, align 8, !tbaa !15
  %2136 = fmul double %2129, %2135
  %2137 = fneg double %2136
  %2138 = call double @llvm.fmuladd.f64(double %2121, double %2127, double %2137)
  %2139 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2138, ptr %2139, align 8, !tbaa !13
  %2140 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2141 = load double, ptr %2140, align 8, !tbaa !13
  %2142 = load ptr, ptr %20, align 8, !tbaa !5
  %2143 = load i32, ptr %33, align 4, !tbaa !9
  %2144 = sext i32 %2143 to i64
  %2145 = getelementptr inbounds %struct.doublecomplex, ptr %2142, i64 %2144
  %2146 = getelementptr inbounds %struct.doublecomplex, ptr %2145, i32 0, i32 1
  %2147 = load double, ptr %2146, align 8, !tbaa !15
  %2148 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2149 = load double, ptr %2148, align 8, !tbaa !15
  %2150 = load ptr, ptr %20, align 8, !tbaa !5
  %2151 = load i32, ptr %33, align 4, !tbaa !9
  %2152 = sext i32 %2151 to i64
  %2153 = getelementptr inbounds %struct.doublecomplex, ptr %2150, i64 %2152
  %2154 = getelementptr inbounds %struct.doublecomplex, ptr %2153, i32 0, i32 0
  %2155 = load double, ptr %2154, align 8, !tbaa !13
  %2156 = fmul double %2149, %2155
  %2157 = call double @llvm.fmuladd.f64(double %2141, double %2147, double %2156)
  %2158 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2157, ptr %2158, align 8, !tbaa !15
  %2159 = load ptr, ptr %23, align 8, !tbaa !5
  %2160 = load i32, ptr %32, align 4, !tbaa !9
  %2161 = sext i32 %2160 to i64
  %2162 = getelementptr inbounds %struct.doublecomplex, ptr %2159, i64 %2161
  %2163 = getelementptr inbounds %struct.doublecomplex, ptr %2162, i32 0, i32 0
  %2164 = load double, ptr %2163, align 8, !tbaa !13
  %2165 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2166 = load double, ptr %2165, align 8, !tbaa !13
  %2167 = fadd double %2164, %2166
  %2168 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %2167, ptr %2168, align 8, !tbaa !13
  %2169 = load ptr, ptr %23, align 8, !tbaa !5
  %2170 = load i32, ptr %32, align 4, !tbaa !9
  %2171 = sext i32 %2170 to i64
  %2172 = getelementptr inbounds %struct.doublecomplex, ptr %2169, i64 %2171
  %2173 = getelementptr inbounds %struct.doublecomplex, ptr %2172, i32 0, i32 1
  %2174 = load double, ptr %2173, align 8, !tbaa !15
  %2175 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2176 = load double, ptr %2175, align 8, !tbaa !15
  %2177 = fadd double %2174, %2176
  %2178 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %2177, ptr %2178, align 8, !tbaa !15
  %2179 = load ptr, ptr %18, align 8, !tbaa !5
  %2180 = load i32, ptr %48, align 4, !tbaa !9
  %2181 = sext i32 %2180 to i64
  %2182 = getelementptr inbounds %struct.doublecomplex, ptr %2179, i64 %2181
  %2183 = call { double, double } @Cd(ptr noundef %2182)
  %2184 = extractvalue { double, double } %2183, 0
  %2185 = extractvalue { double, double } %2183, 1
  %2186 = fneg double %2185
  %2187 = call ptr @_pCd(ptr noundef %45)
  %2188 = getelementptr inbounds { double, double }, ptr %2187, i32 0, i32 0
  %2189 = getelementptr inbounds { double, double }, ptr %2187, i32 0, i32 1
  store double %2184, ptr %2188, align 8
  store double %2186, ptr %2189, align 8
  %2190 = load i32, ptr %48, align 4, !tbaa !9
  %2191 = load i32, ptr %49, align 4, !tbaa !9
  %2192 = load i32, ptr %27, align 4, !tbaa !9
  %2193 = mul nsw i32 %2191, %2192
  %2194 = add nsw i32 %2190, %2193
  store i32 %2194, ptr %34, align 4, !tbaa !9
  %2195 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %2196 = load double, ptr %2195, align 8, !tbaa !13
  %2197 = load ptr, ptr %20, align 8, !tbaa !5
  %2198 = load i32, ptr %34, 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 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %2204 = load double, ptr %2203, align 8, !tbaa !15
  %2205 = load ptr, ptr %20, align 8, !tbaa !5
  %2206 = load i32, ptr %34, align 4, !tbaa !9
  %2207 = sext i32 %2206 to i64
  %2208 = getelementptr inbounds %struct.doublecomplex, ptr %2205, i64 %2207
  %2209 = getelementptr inbounds %struct.doublecomplex, ptr %2208, i32 0, i32 1
  %2210 = load double, ptr %2209, align 8, !tbaa !15
  %2211 = fmul double %2204, %2210
  %2212 = fneg double %2211
  %2213 = call double @llvm.fmuladd.f64(double %2196, double %2202, double %2212)
  %2214 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %2213, ptr %2214, align 8, !tbaa !13
  %2215 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %2216 = load double, ptr %2215, align 8, !tbaa !13
  %2217 = load ptr, ptr %20, align 8, !tbaa !5
  %2218 = load i32, ptr %34, align 4, !tbaa !9
  %2219 = sext i32 %2218 to i64
  %2220 = getelementptr inbounds %struct.doublecomplex, ptr %2217, i64 %2219
  %2221 = getelementptr inbounds %struct.doublecomplex, ptr %2220, i32 0, i32 1
  %2222 = load double, ptr %2221, align 8, !tbaa !15
  %2223 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %2224 = load double, ptr %2223, align 8, !tbaa !15
  %2225 = load ptr, ptr %20, align 8, !tbaa !5
  %2226 = load i32, ptr %34, 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 = fmul double %2224, %2230
  %2232 = call double @llvm.fmuladd.f64(double %2216, double %2222, double %2231)
  %2233 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %2232, ptr %2233, align 8, !tbaa !15
  %2234 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %2235 = load double, ptr %2234, align 8, !tbaa !13
  %2236 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %2237 = load double, ptr %2236, align 8, !tbaa !13
  %2238 = fadd double %2235, %2237
  %2239 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %2238, ptr %2239, align 8, !tbaa !13
  %2240 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %2241 = load double, ptr %2240, align 8, !tbaa !15
  %2242 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %2243 = load double, ptr %2242, align 8, !tbaa !15
  %2244 = fadd double %2241, %2243
  %2245 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %2244, ptr %2245, align 8, !tbaa !15
  %2246 = load ptr, ptr %17, align 8, !tbaa !5
  %2247 = load i32, ptr %48, align 4, !tbaa !9
  %2248 = sext i32 %2247 to i64
  %2249 = getelementptr inbounds %struct.doublecomplex, ptr %2246, i64 %2248
  %2250 = call { double, double } @Cd(ptr noundef %2249)
  %2251 = extractvalue { double, double } %2250, 0
  %2252 = extractvalue { double, double } %2250, 1
  %2253 = fneg double %2252
  %2254 = call ptr @_pCd(ptr noundef %47)
  %2255 = getelementptr inbounds { double, double }, ptr %2254, i32 0, i32 0
  %2256 = getelementptr inbounds { double, double }, ptr %2254, i32 0, i32 1
  store double %2251, ptr %2255, align 8
  store double %2253, ptr %2256, align 8
  %2257 = load i32, ptr %48, align 4, !tbaa !9
  %2258 = add nsw i32 %2257, 1
  %2259 = load i32, ptr %49, align 4, !tbaa !9
  %2260 = load i32, ptr %27, align 4, !tbaa !9
  %2261 = mul nsw i32 %2259, %2260
  %2262 = add nsw i32 %2258, %2261
  store i32 %2262, ptr %35, align 4, !tbaa !9
  %2263 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %2264 = load double, ptr %2263, align 8, !tbaa !13
  %2265 = load ptr, ptr %20, align 8, !tbaa !5
  %2266 = load i32, ptr %35, align 4, !tbaa !9
  %2267 = sext i32 %2266 to i64
  %2268 = getelementptr inbounds %struct.doublecomplex, ptr %2265, i64 %2267
  %2269 = getelementptr inbounds %struct.doublecomplex, ptr %2268, i32 0, i32 0
  %2270 = load double, ptr %2269, align 8, !tbaa !13
  %2271 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %2272 = load double, ptr %2271, align 8, !tbaa !15
  %2273 = load ptr, ptr %20, align 8, !tbaa !5
  %2274 = load i32, ptr %35, align 4, !tbaa !9
  %2275 = sext i32 %2274 to i64
  %2276 = getelementptr inbounds %struct.doublecomplex, ptr %2273, i64 %2275
  %2277 = getelementptr inbounds %struct.doublecomplex, ptr %2276, i32 0, i32 1
  %2278 = load double, ptr %2277, align 8, !tbaa !15
  %2279 = fmul double %2272, %2278
  %2280 = fneg double %2279
  %2281 = call double @llvm.fmuladd.f64(double %2264, double %2270, double %2280)
  %2282 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 0
  store double %2281, ptr %2282, align 8, !tbaa !13
  %2283 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %2284 = load double, ptr %2283, align 8, !tbaa !13
  %2285 = load ptr, ptr %20, align 8, !tbaa !5
  %2286 = load i32, ptr %35, align 4, !tbaa !9
  %2287 = sext i32 %2286 to i64
  %2288 = getelementptr inbounds %struct.doublecomplex, ptr %2285, i64 %2287
  %2289 = getelementptr inbounds %struct.doublecomplex, ptr %2288, i32 0, i32 1
  %2290 = load double, ptr %2289, align 8, !tbaa !15
  %2291 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %2292 = load double, ptr %2291, align 8, !tbaa !15
  %2293 = load ptr, ptr %20, align 8, !tbaa !5
  %2294 = load i32, ptr %35, align 4, !tbaa !9
  %2295 = sext i32 %2294 to i64
  %2296 = getelementptr inbounds %struct.doublecomplex, ptr %2293, i64 %2295
  %2297 = getelementptr inbounds %struct.doublecomplex, ptr %2296, i32 0, i32 0
  %2298 = load double, ptr %2297, align 8, !tbaa !13
  %2299 = fmul double %2292, %2298
  %2300 = call double @llvm.fmuladd.f64(double %2284, double %2290, double %2299)
  %2301 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 1
  store double %2300, ptr %2301, align 8, !tbaa !15
  %2302 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %2303 = load double, ptr %2302, align 8, !tbaa !13
  %2304 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 0
  %2305 = load double, ptr %2304, align 8, !tbaa !13
  %2306 = fadd double %2303, %2305
  %2307 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2306, ptr %2307, align 8, !tbaa !13
  %2308 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %2309 = load double, ptr %2308, align 8, !tbaa !15
  %2310 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 1
  %2311 = load double, ptr %2310, align 8, !tbaa !15
  %2312 = fadd double %2309, %2311
  %2313 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2312, ptr %2313, align 8, !tbaa !15
  %2314 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2315 = load double, ptr %2314, align 8, !tbaa !13
  %2316 = load ptr, ptr %23, align 8, !tbaa !5
  %2317 = load i32, ptr %31, align 4, !tbaa !9
  %2318 = sext i32 %2317 to i64
  %2319 = getelementptr inbounds %struct.doublecomplex, ptr %2316, i64 %2318
  %2320 = getelementptr inbounds %struct.doublecomplex, ptr %2319, i32 0, i32 0
  store double %2315, ptr %2320, align 8, !tbaa !13
  %2321 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2322 = load double, ptr %2321, align 8, !tbaa !15
  %2323 = load ptr, ptr %23, align 8, !tbaa !5
  %2324 = load i32, ptr %31, align 4, !tbaa !9
  %2325 = sext i32 %2324 to i64
  %2326 = getelementptr inbounds %struct.doublecomplex, ptr %2323, i64 %2325
  %2327 = getelementptr inbounds %struct.doublecomplex, ptr %2326, i32 0, i32 1
  store double %2322, ptr %2327, align 8, !tbaa !15
  br label %2328

2328:                                             ; preds = %2091
  %2329 = load i32, ptr %48, align 4, !tbaa !9
  %2330 = add nsw i32 %2329, 1
  store i32 %2330, ptr %48, align 4, !tbaa !9
  br label %2087, !llvm.loop !25

2331:                                             ; preds = %2087
  br label %2332

2332:                                             ; preds = %2331, %1656
  br label %2333

2333:                                             ; preds = %2332
  %2334 = load i32, ptr %49, align 4, !tbaa !9
  %2335 = add nsw i32 %2334, 1
  store i32 %2335, ptr %49, align 4, !tbaa !9
  br label %1648, !llvm.loop !26

2336:                                             ; preds = %1648
  br label %2337

2337:                                             ; preds = %2336, %1641
  br label %2338

2338:                                             ; preds = %2337, %1640
  br label %2339

2339:                                             ; preds = %2338, %917
  br label %4490

2340:                                             ; preds = %191
  %2341 = load ptr, ptr %16, align 8, !tbaa !5
  %2342 = load double, ptr %2341, align 8, !tbaa !11
  %2343 = fcmp oeq double %2342, -1.000000e+00
  br i1 %2343, label %2344, label %4489

2344:                                             ; preds = %2340
  %2345 = load ptr, ptr %13, align 8, !tbaa !5
  %2346 = call i32 @lsame_(ptr noundef %2345, ptr noundef @.str)
  %2347 = icmp ne i32 %2346, 0
  br i1 %2347, label %2348, label %3067

2348:                                             ; preds = %2344
  %2349 = load ptr, ptr %15, align 8, !tbaa !5
  %2350 = load i32, ptr %2349, align 4, !tbaa !9
  store i32 %2350, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %2351

2351:                                             ; preds = %3063, %2348
  %2352 = load i32, ptr %49, align 4, !tbaa !9
  %2353 = load i32, ptr %29, align 4, !tbaa !9
  %2354 = icmp sle i32 %2352, %2353
  br i1 %2354, label %2355, label %3066

2355:                                             ; preds = %2351
  %2356 = load ptr, ptr %14, align 8, !tbaa !5
  %2357 = load i32, ptr %2356, align 4, !tbaa !9
  %2358 = icmp eq i32 %2357, 1
  br i1 %2358, label %2359, label %2453

2359:                                             ; preds = %2355
  %2360 = load i32, ptr %49, align 4, !tbaa !9
  %2361 = load i32, ptr %25, align 4, !tbaa !9
  %2362 = mul nsw i32 %2360, %2361
  %2363 = add nsw i32 %2362, 1
  store i32 %2363, ptr %30, align 4, !tbaa !9
  %2364 = load i32, ptr %49, align 4, !tbaa !9
  %2365 = load i32, ptr %25, align 4, !tbaa !9
  %2366 = mul nsw i32 %2364, %2365
  %2367 = add nsw i32 %2366, 1
  store i32 %2367, ptr %31, align 4, !tbaa !9
  %2368 = load i32, ptr %49, align 4, !tbaa !9
  %2369 = load i32, ptr %27, align 4, !tbaa !9
  %2370 = mul nsw i32 %2368, %2369
  %2371 = add nsw i32 %2370, 1
  store i32 %2371, ptr %32, align 4, !tbaa !9
  %2372 = load ptr, ptr %18, align 8, !tbaa !5
  %2373 = getelementptr inbounds %struct.doublecomplex, ptr %2372, i64 1
  %2374 = getelementptr inbounds %struct.doublecomplex, ptr %2373, i32 0, i32 0
  %2375 = load double, ptr %2374, align 8, !tbaa !13
  %2376 = load ptr, ptr %20, align 8, !tbaa !5
  %2377 = load i32, ptr %32, align 4, !tbaa !9
  %2378 = sext i32 %2377 to i64
  %2379 = getelementptr inbounds %struct.doublecomplex, ptr %2376, i64 %2378
  %2380 = getelementptr inbounds %struct.doublecomplex, ptr %2379, i32 0, i32 0
  %2381 = load double, ptr %2380, align 8, !tbaa !13
  %2382 = load ptr, ptr %18, align 8, !tbaa !5
  %2383 = getelementptr inbounds %struct.doublecomplex, ptr %2382, i64 1
  %2384 = getelementptr inbounds %struct.doublecomplex, ptr %2383, i32 0, i32 1
  %2385 = load double, ptr %2384, align 8, !tbaa !15
  %2386 = load ptr, ptr %20, align 8, !tbaa !5
  %2387 = load i32, ptr %32, align 4, !tbaa !9
  %2388 = sext i32 %2387 to i64
  %2389 = getelementptr inbounds %struct.doublecomplex, ptr %2386, i64 %2388
  %2390 = getelementptr inbounds %struct.doublecomplex, ptr %2389, i32 0, i32 1
  %2391 = load double, ptr %2390, align 8, !tbaa !15
  %2392 = fmul double %2385, %2391
  %2393 = fneg double %2392
  %2394 = call double @llvm.fmuladd.f64(double %2375, double %2381, double %2393)
  %2395 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %2394, ptr %2395, align 8, !tbaa !13
  %2396 = load ptr, ptr %18, align 8, !tbaa !5
  %2397 = getelementptr inbounds %struct.doublecomplex, ptr %2396, i64 1
  %2398 = getelementptr inbounds %struct.doublecomplex, ptr %2397, i32 0, i32 0
  %2399 = load double, ptr %2398, align 8, !tbaa !13
  %2400 = load ptr, ptr %20, align 8, !tbaa !5
  %2401 = load i32, ptr %32, align 4, !tbaa !9
  %2402 = sext i32 %2401 to i64
  %2403 = getelementptr inbounds %struct.doublecomplex, ptr %2400, i64 %2402
  %2404 = getelementptr inbounds %struct.doublecomplex, ptr %2403, i32 0, i32 1
  %2405 = load double, ptr %2404, align 8, !tbaa !15
  %2406 = load ptr, ptr %18, align 8, !tbaa !5
  %2407 = getelementptr inbounds %struct.doublecomplex, ptr %2406, i64 1
  %2408 = getelementptr inbounds %struct.doublecomplex, ptr %2407, i32 0, i32 1
  %2409 = load double, ptr %2408, align 8, !tbaa !15
  %2410 = load ptr, ptr %20, align 8, !tbaa !5
  %2411 = load i32, ptr %32, align 4, !tbaa !9
  %2412 = sext i32 %2411 to i64
  %2413 = getelementptr inbounds %struct.doublecomplex, ptr %2410, i64 %2412
  %2414 = getelementptr inbounds %struct.doublecomplex, ptr %2413, i32 0, i32 0
  %2415 = load double, ptr %2414, align 8, !tbaa !13
  %2416 = fmul double %2409, %2415
  %2417 = call double @llvm.fmuladd.f64(double %2399, double %2405, double %2416)
  %2418 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %2417, ptr %2418, align 8, !tbaa !15
  %2419 = load ptr, ptr %23, align 8, !tbaa !5
  %2420 = load i32, ptr %31, align 4, !tbaa !9
  %2421 = sext i32 %2420 to i64
  %2422 = getelementptr inbounds %struct.doublecomplex, ptr %2419, i64 %2421
  %2423 = getelementptr inbounds %struct.doublecomplex, ptr %2422, i32 0, i32 0
  %2424 = load double, ptr %2423, align 8, !tbaa !13
  %2425 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %2426 = load double, ptr %2425, align 8, !tbaa !13
  %2427 = fsub double %2424, %2426
  %2428 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2427, ptr %2428, align 8, !tbaa !13
  %2429 = load ptr, ptr %23, align 8, !tbaa !5
  %2430 = load i32, ptr %31, align 4, !tbaa !9
  %2431 = sext i32 %2430 to i64
  %2432 = getelementptr inbounds %struct.doublecomplex, ptr %2429, i64 %2431
  %2433 = getelementptr inbounds %struct.doublecomplex, ptr %2432, i32 0, i32 1
  %2434 = load double, ptr %2433, align 8, !tbaa !15
  %2435 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %2436 = load double, ptr %2435, align 8, !tbaa !15
  %2437 = fsub double %2434, %2436
  %2438 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2437, ptr %2438, align 8, !tbaa !15
  %2439 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2440 = load double, ptr %2439, align 8, !tbaa !13
  %2441 = load ptr, ptr %23, align 8, !tbaa !5
  %2442 = load i32, ptr %30, 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 0
  store double %2440, ptr %2445, align 8, !tbaa !13
  %2446 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2447 = load double, ptr %2446, align 8, !tbaa !15
  %2448 = load ptr, ptr %23, align 8, !tbaa !5
  %2449 = load i32, ptr %30, align 4, !tbaa !9
  %2450 = sext i32 %2449 to i64
  %2451 = getelementptr inbounds %struct.doublecomplex, ptr %2448, i64 %2450
  %2452 = getelementptr inbounds %struct.doublecomplex, ptr %2451, i32 0, i32 1
  store double %2447, ptr %2452, align 8, !tbaa !15
  br label %3062

2453:                                             ; preds = %2355
  %2454 = load i32, ptr %49, align 4, !tbaa !9
  %2455 = load i32, ptr %25, align 4, !tbaa !9
  %2456 = mul nsw i32 %2454, %2455
  %2457 = add nsw i32 %2456, 1
  store i32 %2457, ptr %30, align 4, !tbaa !9
  %2458 = load i32, ptr %49, align 4, !tbaa !9
  %2459 = load i32, ptr %25, align 4, !tbaa !9
  %2460 = mul nsw i32 %2458, %2459
  %2461 = add nsw i32 %2460, 1
  store i32 %2461, ptr %31, align 4, !tbaa !9
  %2462 = load i32, ptr %49, align 4, !tbaa !9
  %2463 = load i32, ptr %27, align 4, !tbaa !9
  %2464 = mul nsw i32 %2462, %2463
  %2465 = add nsw i32 %2464, 1
  store i32 %2465, ptr %32, align 4, !tbaa !9
  %2466 = load ptr, ptr %18, align 8, !tbaa !5
  %2467 = getelementptr inbounds %struct.doublecomplex, ptr %2466, i64 1
  %2468 = getelementptr inbounds %struct.doublecomplex, ptr %2467, i32 0, i32 0
  %2469 = load double, ptr %2468, align 8, !tbaa !13
  %2470 = load ptr, ptr %20, align 8, !tbaa !5
  %2471 = load i32, ptr %32, align 4, !tbaa !9
  %2472 = sext i32 %2471 to i64
  %2473 = getelementptr inbounds %struct.doublecomplex, ptr %2470, i64 %2472
  %2474 = getelementptr inbounds %struct.doublecomplex, ptr %2473, i32 0, i32 0
  %2475 = load double, ptr %2474, align 8, !tbaa !13
  %2476 = load ptr, ptr %18, align 8, !tbaa !5
  %2477 = getelementptr inbounds %struct.doublecomplex, ptr %2476, i64 1
  %2478 = getelementptr inbounds %struct.doublecomplex, ptr %2477, i32 0, i32 1
  %2479 = load double, ptr %2478, align 8, !tbaa !15
  %2480 = load ptr, ptr %20, align 8, !tbaa !5
  %2481 = load i32, ptr %32, align 4, !tbaa !9
  %2482 = sext i32 %2481 to i64
  %2483 = getelementptr inbounds %struct.doublecomplex, ptr %2480, i64 %2482
  %2484 = getelementptr inbounds %struct.doublecomplex, ptr %2483, i32 0, i32 1
  %2485 = load double, ptr %2484, align 8, !tbaa !15
  %2486 = fmul double %2479, %2485
  %2487 = fneg double %2486
  %2488 = call double @llvm.fmuladd.f64(double %2469, double %2475, double %2487)
  %2489 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %2488, ptr %2489, align 8, !tbaa !13
  %2490 = load ptr, ptr %18, align 8, !tbaa !5
  %2491 = getelementptr inbounds %struct.doublecomplex, ptr %2490, i64 1
  %2492 = getelementptr inbounds %struct.doublecomplex, ptr %2491, i32 0, i32 0
  %2493 = load double, ptr %2492, align 8, !tbaa !13
  %2494 = load ptr, ptr %20, align 8, !tbaa !5
  %2495 = load i32, ptr %32, align 4, !tbaa !9
  %2496 = sext i32 %2495 to i64
  %2497 = getelementptr inbounds %struct.doublecomplex, ptr %2494, i64 %2496
  %2498 = getelementptr inbounds %struct.doublecomplex, ptr %2497, i32 0, i32 1
  %2499 = load double, ptr %2498, align 8, !tbaa !15
  %2500 = load ptr, ptr %18, align 8, !tbaa !5
  %2501 = getelementptr inbounds %struct.doublecomplex, ptr %2500, i64 1
  %2502 = getelementptr inbounds %struct.doublecomplex, ptr %2501, i32 0, i32 1
  %2503 = load double, ptr %2502, align 8, !tbaa !15
  %2504 = load ptr, ptr %20, align 8, !tbaa !5
  %2505 = load i32, ptr %32, align 4, !tbaa !9
  %2506 = sext i32 %2505 to i64
  %2507 = getelementptr inbounds %struct.doublecomplex, ptr %2504, i64 %2506
  %2508 = getelementptr inbounds %struct.doublecomplex, ptr %2507, i32 0, i32 0
  %2509 = load double, ptr %2508, align 8, !tbaa !13
  %2510 = fmul double %2503, %2509
  %2511 = call double @llvm.fmuladd.f64(double %2493, double %2499, double %2510)
  %2512 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %2511, ptr %2512, align 8, !tbaa !15
  %2513 = load ptr, ptr %23, align 8, !tbaa !5
  %2514 = load i32, ptr %31, align 4, !tbaa !9
  %2515 = sext i32 %2514 to i64
  %2516 = getelementptr inbounds %struct.doublecomplex, ptr %2513, i64 %2515
  %2517 = getelementptr inbounds %struct.doublecomplex, ptr %2516, i32 0, i32 0
  %2518 = load double, ptr %2517, align 8, !tbaa !13
  %2519 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %2520 = load double, ptr %2519, align 8, !tbaa !13
  %2521 = fsub double %2518, %2520
  %2522 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %2521, ptr %2522, align 8, !tbaa !13
  %2523 = load ptr, ptr %23, align 8, !tbaa !5
  %2524 = load i32, ptr %31, align 4, !tbaa !9
  %2525 = sext i32 %2524 to i64
  %2526 = getelementptr inbounds %struct.doublecomplex, ptr %2523, i64 %2525
  %2527 = getelementptr inbounds %struct.doublecomplex, ptr %2526, i32 0, i32 1
  %2528 = load double, ptr %2527, align 8, !tbaa !15
  %2529 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %2530 = load double, ptr %2529, align 8, !tbaa !15
  %2531 = fsub double %2528, %2530
  %2532 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %2531, ptr %2532, align 8, !tbaa !15
  %2533 = load i32, ptr %49, align 4, !tbaa !9
  %2534 = load i32, ptr %27, align 4, !tbaa !9
  %2535 = mul nsw i32 %2533, %2534
  %2536 = add nsw i32 %2535, 2
  store i32 %2536, ptr %33, align 4, !tbaa !9
  %2537 = load ptr, ptr %19, align 8, !tbaa !5
  %2538 = getelementptr inbounds %struct.doublecomplex, ptr %2537, i64 1
  %2539 = getelementptr inbounds %struct.doublecomplex, ptr %2538, i32 0, i32 0
  %2540 = load double, ptr %2539, align 8, !tbaa !13
  %2541 = load ptr, ptr %20, align 8, !tbaa !5
  %2542 = load i32, ptr %33, align 4, !tbaa !9
  %2543 = sext i32 %2542 to i64
  %2544 = getelementptr inbounds %struct.doublecomplex, ptr %2541, i64 %2543
  %2545 = getelementptr inbounds %struct.doublecomplex, ptr %2544, i32 0, i32 0
  %2546 = load double, ptr %2545, align 8, !tbaa !13
  %2547 = load ptr, ptr %19, align 8, !tbaa !5
  %2548 = getelementptr inbounds %struct.doublecomplex, ptr %2547, i64 1
  %2549 = getelementptr inbounds %struct.doublecomplex, ptr %2548, i32 0, i32 1
  %2550 = load double, ptr %2549, align 8, !tbaa !15
  %2551 = load ptr, ptr %20, align 8, !tbaa !5
  %2552 = load i32, ptr %33, align 4, !tbaa !9
  %2553 = sext i32 %2552 to i64
  %2554 = getelementptr inbounds %struct.doublecomplex, ptr %2551, i64 %2553
  %2555 = getelementptr inbounds %struct.doublecomplex, ptr %2554, i32 0, i32 1
  %2556 = load double, ptr %2555, align 8, !tbaa !15
  %2557 = fmul double %2550, %2556
  %2558 = fneg double %2557
  %2559 = call double @llvm.fmuladd.f64(double %2540, double %2546, double %2558)
  %2560 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2559, ptr %2560, align 8, !tbaa !13
  %2561 = load ptr, ptr %19, align 8, !tbaa !5
  %2562 = getelementptr inbounds %struct.doublecomplex, ptr %2561, i64 1
  %2563 = getelementptr inbounds %struct.doublecomplex, ptr %2562, i32 0, i32 0
  %2564 = load double, ptr %2563, align 8, !tbaa !13
  %2565 = load ptr, ptr %20, align 8, !tbaa !5
  %2566 = load i32, ptr %33, align 4, !tbaa !9
  %2567 = sext i32 %2566 to i64
  %2568 = getelementptr inbounds %struct.doublecomplex, ptr %2565, i64 %2567
  %2569 = getelementptr inbounds %struct.doublecomplex, ptr %2568, i32 0, i32 1
  %2570 = load double, ptr %2569, align 8, !tbaa !15
  %2571 = load ptr, ptr %19, align 8, !tbaa !5
  %2572 = getelementptr inbounds %struct.doublecomplex, ptr %2571, i64 1
  %2573 = getelementptr inbounds %struct.doublecomplex, ptr %2572, i32 0, i32 1
  %2574 = load double, ptr %2573, align 8, !tbaa !15
  %2575 = load ptr, ptr %20, align 8, !tbaa !5
  %2576 = load i32, ptr %33, align 4, !tbaa !9
  %2577 = sext i32 %2576 to i64
  %2578 = getelementptr inbounds %struct.doublecomplex, ptr %2575, i64 %2577
  %2579 = getelementptr inbounds %struct.doublecomplex, ptr %2578, i32 0, i32 0
  %2580 = load double, ptr %2579, align 8, !tbaa !13
  %2581 = fmul double %2574, %2580
  %2582 = call double @llvm.fmuladd.f64(double %2564, double %2570, double %2581)
  %2583 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2582, ptr %2583, align 8, !tbaa !15
  %2584 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %2585 = load double, ptr %2584, align 8, !tbaa !13
  %2586 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2587 = load double, ptr %2586, align 8, !tbaa !13
  %2588 = fsub double %2585, %2587
  %2589 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2588, ptr %2589, align 8, !tbaa !13
  %2590 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %2591 = load double, ptr %2590, align 8, !tbaa !15
  %2592 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2593 = load double, ptr %2592, align 8, !tbaa !15
  %2594 = fsub double %2591, %2593
  %2595 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2594, ptr %2595, align 8, !tbaa !15
  %2596 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2597 = load double, ptr %2596, align 8, !tbaa !13
  %2598 = load ptr, ptr %23, align 8, !tbaa !5
  %2599 = load i32, ptr %30, align 4, !tbaa !9
  %2600 = sext i32 %2599 to i64
  %2601 = getelementptr inbounds %struct.doublecomplex, ptr %2598, i64 %2600
  %2602 = getelementptr inbounds %struct.doublecomplex, ptr %2601, i32 0, i32 0
  store double %2597, ptr %2602, align 8, !tbaa !13
  %2603 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2604 = load double, ptr %2603, align 8, !tbaa !15
  %2605 = load ptr, ptr %23, align 8, !tbaa !5
  %2606 = load i32, ptr %30, align 4, !tbaa !9
  %2607 = sext i32 %2606 to i64
  %2608 = getelementptr inbounds %struct.doublecomplex, ptr %2605, i64 %2607
  %2609 = getelementptr inbounds %struct.doublecomplex, ptr %2608, i32 0, i32 1
  store double %2604, ptr %2609, align 8, !tbaa !15
  %2610 = load ptr, ptr %14, align 8, !tbaa !5
  %2611 = load i32, ptr %2610, align 4, !tbaa !9
  %2612 = load i32, ptr %49, align 4, !tbaa !9
  %2613 = load i32, ptr %25, align 4, !tbaa !9
  %2614 = mul nsw i32 %2612, %2613
  %2615 = add nsw i32 %2611, %2614
  store i32 %2615, ptr %30, align 4, !tbaa !9
  %2616 = load ptr, ptr %14, align 8, !tbaa !5
  %2617 = load i32, ptr %2616, align 4, !tbaa !9
  %2618 = load i32, ptr %49, align 4, !tbaa !9
  %2619 = load i32, ptr %25, align 4, !tbaa !9
  %2620 = mul nsw i32 %2618, %2619
  %2621 = add nsw i32 %2617, %2620
  store i32 %2621, ptr %31, align 4, !tbaa !9
  %2622 = load ptr, ptr %14, align 8, !tbaa !5
  %2623 = load i32, ptr %2622, align 4, !tbaa !9
  %2624 = sub nsw i32 %2623, 1
  store i32 %2624, ptr %32, align 4, !tbaa !9
  %2625 = load ptr, ptr %14, align 8, !tbaa !5
  %2626 = load i32, ptr %2625, align 4, !tbaa !9
  %2627 = sub nsw i32 %2626, 1
  %2628 = load i32, ptr %49, align 4, !tbaa !9
  %2629 = load i32, ptr %27, align 4, !tbaa !9
  %2630 = mul nsw i32 %2628, %2629
  %2631 = add nsw i32 %2627, %2630
  store i32 %2631, ptr %33, align 4, !tbaa !9
  %2632 = load ptr, ptr %17, align 8, !tbaa !5
  %2633 = load i32, ptr %32, align 4, !tbaa !9
  %2634 = sext i32 %2633 to i64
  %2635 = getelementptr inbounds %struct.doublecomplex, ptr %2632, i64 %2634
  %2636 = getelementptr inbounds %struct.doublecomplex, ptr %2635, i32 0, i32 0
  %2637 = load double, ptr %2636, align 8, !tbaa !13
  %2638 = load ptr, ptr %20, align 8, !tbaa !5
  %2639 = load i32, ptr %33, 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
  %2643 = load double, ptr %2642, align 8, !tbaa !13
  %2644 = load ptr, ptr %17, align 8, !tbaa !5
  %2645 = load i32, ptr %32, align 4, !tbaa !9
  %2646 = sext i32 %2645 to i64
  %2647 = getelementptr inbounds %struct.doublecomplex, ptr %2644, i64 %2646
  %2648 = getelementptr inbounds %struct.doublecomplex, ptr %2647, i32 0, i32 1
  %2649 = load double, ptr %2648, align 8, !tbaa !15
  %2650 = load ptr, ptr %20, align 8, !tbaa !5
  %2651 = load i32, ptr %33, align 4, !tbaa !9
  %2652 = sext i32 %2651 to i64
  %2653 = getelementptr inbounds %struct.doublecomplex, ptr %2650, i64 %2652
  %2654 = getelementptr inbounds %struct.doublecomplex, ptr %2653, i32 0, i32 1
  %2655 = load double, ptr %2654, align 8, !tbaa !15
  %2656 = fmul double %2649, %2655
  %2657 = fneg double %2656
  %2658 = call double @llvm.fmuladd.f64(double %2637, double %2643, double %2657)
  %2659 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %2658, ptr %2659, align 8, !tbaa !13
  %2660 = load ptr, ptr %17, align 8, !tbaa !5
  %2661 = load i32, ptr %32, align 4, !tbaa !9
  %2662 = sext i32 %2661 to i64
  %2663 = getelementptr inbounds %struct.doublecomplex, ptr %2660, i64 %2662
  %2664 = getelementptr inbounds %struct.doublecomplex, ptr %2663, i32 0, i32 0
  %2665 = load double, ptr %2664, align 8, !tbaa !13
  %2666 = load ptr, ptr %20, align 8, !tbaa !5
  %2667 = load i32, ptr %33, align 4, !tbaa !9
  %2668 = sext i32 %2667 to i64
  %2669 = getelementptr inbounds %struct.doublecomplex, ptr %2666, i64 %2668
  %2670 = getelementptr inbounds %struct.doublecomplex, ptr %2669, i32 0, i32 1
  %2671 = load double, ptr %2670, align 8, !tbaa !15
  %2672 = load ptr, ptr %17, align 8, !tbaa !5
  %2673 = load i32, ptr %32, align 4, !tbaa !9
  %2674 = sext i32 %2673 to i64
  %2675 = getelementptr inbounds %struct.doublecomplex, ptr %2672, i64 %2674
  %2676 = getelementptr inbounds %struct.doublecomplex, ptr %2675, i32 0, i32 1
  %2677 = load double, ptr %2676, align 8, !tbaa !15
  %2678 = load ptr, ptr %20, align 8, !tbaa !5
  %2679 = load i32, ptr %33, align 4, !tbaa !9
  %2680 = sext i32 %2679 to i64
  %2681 = getelementptr inbounds %struct.doublecomplex, ptr %2678, i64 %2680
  %2682 = getelementptr inbounds %struct.doublecomplex, ptr %2681, i32 0, i32 0
  %2683 = load double, ptr %2682, align 8, !tbaa !13
  %2684 = fmul double %2677, %2683
  %2685 = call double @llvm.fmuladd.f64(double %2665, double %2671, double %2684)
  %2686 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %2685, ptr %2686, align 8, !tbaa !15
  %2687 = load ptr, ptr %23, align 8, !tbaa !5
  %2688 = load i32, ptr %31, align 4, !tbaa !9
  %2689 = sext i32 %2688 to i64
  %2690 = getelementptr inbounds %struct.doublecomplex, ptr %2687, i64 %2689
  %2691 = getelementptr inbounds %struct.doublecomplex, ptr %2690, i32 0, i32 0
  %2692 = load double, ptr %2691, align 8, !tbaa !13
  %2693 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %2694 = load double, ptr %2693, align 8, !tbaa !13
  %2695 = fsub double %2692, %2694
  %2696 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %2695, ptr %2696, align 8, !tbaa !13
  %2697 = load ptr, ptr %23, align 8, !tbaa !5
  %2698 = load i32, ptr %31, align 4, !tbaa !9
  %2699 = sext i32 %2698 to i64
  %2700 = getelementptr inbounds %struct.doublecomplex, ptr %2697, i64 %2699
  %2701 = getelementptr inbounds %struct.doublecomplex, ptr %2700, i32 0, i32 1
  %2702 = load double, ptr %2701, align 8, !tbaa !15
  %2703 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %2704 = load double, ptr %2703, align 8, !tbaa !15
  %2705 = fsub double %2702, %2704
  %2706 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %2705, ptr %2706, align 8, !tbaa !15
  %2707 = load ptr, ptr %14, align 8, !tbaa !5
  %2708 = load i32, ptr %2707, align 4, !tbaa !9
  store i32 %2708, ptr %34, align 4, !tbaa !9
  %2709 = load ptr, ptr %14, align 8, !tbaa !5
  %2710 = load i32, ptr %2709, align 4, !tbaa !9
  %2711 = load i32, ptr %49, align 4, !tbaa !9
  %2712 = load i32, ptr %27, align 4, !tbaa !9
  %2713 = mul nsw i32 %2711, %2712
  %2714 = add nsw i32 %2710, %2713
  store i32 %2714, ptr %35, align 4, !tbaa !9
  %2715 = load ptr, ptr %18, align 8, !tbaa !5
  %2716 = load i32, ptr %34, align 4, !tbaa !9
  %2717 = sext i32 %2716 to i64
  %2718 = getelementptr inbounds %struct.doublecomplex, ptr %2715, i64 %2717
  %2719 = getelementptr inbounds %struct.doublecomplex, ptr %2718, i32 0, i32 0
  %2720 = load double, ptr %2719, align 8, !tbaa !13
  %2721 = load ptr, ptr %20, align 8, !tbaa !5
  %2722 = load i32, ptr %35, 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
  %2726 = load double, ptr %2725, align 8, !tbaa !13
  %2727 = load ptr, ptr %18, align 8, !tbaa !5
  %2728 = load i32, ptr %34, align 4, !tbaa !9
  %2729 = sext i32 %2728 to i64
  %2730 = getelementptr inbounds %struct.doublecomplex, ptr %2727, i64 %2729
  %2731 = getelementptr inbounds %struct.doublecomplex, ptr %2730, i32 0, i32 1
  %2732 = load double, ptr %2731, align 8, !tbaa !15
  %2733 = load ptr, ptr %20, align 8, !tbaa !5
  %2734 = load i32, ptr %35, align 4, !tbaa !9
  %2735 = sext i32 %2734 to i64
  %2736 = getelementptr inbounds %struct.doublecomplex, ptr %2733, i64 %2735
  %2737 = getelementptr inbounds %struct.doublecomplex, ptr %2736, i32 0, i32 1
  %2738 = load double, ptr %2737, align 8, !tbaa !15
  %2739 = fmul double %2732, %2738
  %2740 = fneg double %2739
  %2741 = call double @llvm.fmuladd.f64(double %2720, double %2726, double %2740)
  %2742 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2741, ptr %2742, align 8, !tbaa !13
  %2743 = load ptr, ptr %18, align 8, !tbaa !5
  %2744 = load i32, ptr %34, align 4, !tbaa !9
  %2745 = sext i32 %2744 to i64
  %2746 = getelementptr inbounds %struct.doublecomplex, ptr %2743, i64 %2745
  %2747 = getelementptr inbounds %struct.doublecomplex, ptr %2746, i32 0, i32 0
  %2748 = load double, ptr %2747, align 8, !tbaa !13
  %2749 = load ptr, ptr %20, align 8, !tbaa !5
  %2750 = load i32, ptr %35, align 4, !tbaa !9
  %2751 = sext i32 %2750 to i64
  %2752 = getelementptr inbounds %struct.doublecomplex, ptr %2749, i64 %2751
  %2753 = getelementptr inbounds %struct.doublecomplex, ptr %2752, i32 0, i32 1
  %2754 = load double, ptr %2753, align 8, !tbaa !15
  %2755 = load ptr, ptr %18, align 8, !tbaa !5
  %2756 = load i32, ptr %34, align 4, !tbaa !9
  %2757 = sext i32 %2756 to i64
  %2758 = getelementptr inbounds %struct.doublecomplex, ptr %2755, i64 %2757
  %2759 = getelementptr inbounds %struct.doublecomplex, ptr %2758, i32 0, i32 1
  %2760 = load double, ptr %2759, align 8, !tbaa !15
  %2761 = load ptr, ptr %20, align 8, !tbaa !5
  %2762 = load i32, ptr %35, align 4, !tbaa !9
  %2763 = sext i32 %2762 to i64
  %2764 = getelementptr inbounds %struct.doublecomplex, ptr %2761, i64 %2763
  %2765 = getelementptr inbounds %struct.doublecomplex, ptr %2764, i32 0, i32 0
  %2766 = load double, ptr %2765, align 8, !tbaa !13
  %2767 = fmul double %2760, %2766
  %2768 = call double @llvm.fmuladd.f64(double %2748, double %2754, double %2767)
  %2769 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2768, ptr %2769, align 8, !tbaa !15
  %2770 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %2771 = load double, ptr %2770, align 8, !tbaa !13
  %2772 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2773 = load double, ptr %2772, align 8, !tbaa !13
  %2774 = fsub double %2771, %2773
  %2775 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %2774, ptr %2775, align 8, !tbaa !13
  %2776 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %2777 = load double, ptr %2776, align 8, !tbaa !15
  %2778 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2779 = load double, ptr %2778, align 8, !tbaa !15
  %2780 = fsub double %2777, %2779
  %2781 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %2780, ptr %2781, align 8, !tbaa !15
  %2782 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %2783 = load double, ptr %2782, align 8, !tbaa !13
  %2784 = load ptr, ptr %23, align 8, !tbaa !5
  %2785 = load i32, ptr %30, align 4, !tbaa !9
  %2786 = sext i32 %2785 to i64
  %2787 = getelementptr inbounds %struct.doublecomplex, ptr %2784, i64 %2786
  %2788 = getelementptr inbounds %struct.doublecomplex, ptr %2787, i32 0, i32 0
  store double %2783, ptr %2788, align 8, !tbaa !13
  %2789 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %2790 = load double, ptr %2789, align 8, !tbaa !15
  %2791 = load ptr, ptr %23, align 8, !tbaa !5
  %2792 = load i32, ptr %30, align 4, !tbaa !9
  %2793 = sext i32 %2792 to i64
  %2794 = getelementptr inbounds %struct.doublecomplex, ptr %2791, i64 %2793
  %2795 = getelementptr inbounds %struct.doublecomplex, ptr %2794, i32 0, i32 1
  store double %2790, ptr %2795, align 8, !tbaa !15
  %2796 = load ptr, ptr %14, align 8, !tbaa !5
  %2797 = load i32, ptr %2796, align 4, !tbaa !9
  %2798 = sub nsw i32 %2797, 1
  store i32 %2798, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %2799

2799:                                             ; preds = %3058, %2453
  %2800 = load i32, ptr %48, align 4, !tbaa !9
  %2801 = load i32, ptr %30, align 4, !tbaa !9
  %2802 = icmp sle i32 %2800, %2801
  br i1 %2802, label %2803, label %3061

2803:                                             ; preds = %2799
  %2804 = load i32, ptr %48, align 4, !tbaa !9
  %2805 = load i32, ptr %49, align 4, !tbaa !9
  %2806 = load i32, ptr %25, align 4, !tbaa !9
  %2807 = mul nsw i32 %2805, %2806
  %2808 = add nsw i32 %2804, %2807
  store i32 %2808, ptr %31, align 4, !tbaa !9
  %2809 = load i32, ptr %48, align 4, !tbaa !9
  %2810 = load i32, ptr %49, align 4, !tbaa !9
  %2811 = load i32, ptr %25, align 4, !tbaa !9
  %2812 = mul nsw i32 %2810, %2811
  %2813 = add nsw i32 %2809, %2812
  store i32 %2813, ptr %32, align 4, !tbaa !9
  %2814 = load i32, ptr %48, align 4, !tbaa !9
  %2815 = sub nsw i32 %2814, 1
  store i32 %2815, ptr %33, align 4, !tbaa !9
  %2816 = load i32, ptr %48, align 4, !tbaa !9
  %2817 = sub nsw i32 %2816, 1
  %2818 = load i32, ptr %49, align 4, !tbaa !9
  %2819 = load i32, ptr %27, align 4, !tbaa !9
  %2820 = mul nsw i32 %2818, %2819
  %2821 = add nsw i32 %2817, %2820
  store i32 %2821, ptr %34, align 4, !tbaa !9
  %2822 = load ptr, ptr %17, align 8, !tbaa !5
  %2823 = load i32, ptr %33, align 4, !tbaa !9
  %2824 = sext i32 %2823 to i64
  %2825 = getelementptr inbounds %struct.doublecomplex, ptr %2822, i64 %2824
  %2826 = getelementptr inbounds %struct.doublecomplex, ptr %2825, i32 0, i32 0
  %2827 = load double, ptr %2826, align 8, !tbaa !13
  %2828 = load ptr, ptr %20, align 8, !tbaa !5
  %2829 = load i32, ptr %34, 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 %17, align 8, !tbaa !5
  %2835 = load i32, ptr %33, 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 1
  %2839 = load double, ptr %2838, align 8, !tbaa !15
  %2840 = load ptr, ptr %20, align 8, !tbaa !5
  %2841 = load i32, ptr %34, 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 = fmul double %2839, %2845
  %2847 = fneg double %2846
  %2848 = call double @llvm.fmuladd.f64(double %2827, double %2833, double %2847)
  %2849 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %2848, ptr %2849, align 8, !tbaa !13
  %2850 = load ptr, ptr %17, align 8, !tbaa !5
  %2851 = load i32, ptr %33, align 4, !tbaa !9
  %2852 = sext i32 %2851 to i64
  %2853 = getelementptr inbounds %struct.doublecomplex, ptr %2850, i64 %2852
  %2854 = getelementptr inbounds %struct.doublecomplex, ptr %2853, i32 0, i32 0
  %2855 = load double, ptr %2854, align 8, !tbaa !13
  %2856 = load ptr, ptr %20, align 8, !tbaa !5
  %2857 = load i32, ptr %34, 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 1
  %2861 = load double, ptr %2860, align 8, !tbaa !15
  %2862 = load ptr, ptr %17, align 8, !tbaa !5
  %2863 = load i32, ptr %33, 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 %20, align 8, !tbaa !5
  %2869 = load i32, ptr %34, 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 0
  %2873 = load double, ptr %2872, align 8, !tbaa !13
  %2874 = fmul double %2867, %2873
  %2875 = call double @llvm.fmuladd.f64(double %2855, double %2861, double %2874)
  %2876 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %2875, ptr %2876, align 8, !tbaa !15
  %2877 = load ptr, ptr %23, align 8, !tbaa !5
  %2878 = load i32, ptr %32, align 4, !tbaa !9
  %2879 = sext i32 %2878 to i64
  %2880 = getelementptr inbounds %struct.doublecomplex, ptr %2877, i64 %2879
  %2881 = getelementptr inbounds %struct.doublecomplex, ptr %2880, i32 0, i32 0
  %2882 = load double, ptr %2881, align 8, !tbaa !13
  %2883 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %2884 = load double, ptr %2883, align 8, !tbaa !13
  %2885 = fsub double %2882, %2884
  %2886 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %2885, ptr %2886, align 8, !tbaa !13
  %2887 = load ptr, ptr %23, align 8, !tbaa !5
  %2888 = load i32, ptr %32, align 4, !tbaa !9
  %2889 = sext i32 %2888 to i64
  %2890 = getelementptr inbounds %struct.doublecomplex, ptr %2887, i64 %2889
  %2891 = getelementptr inbounds %struct.doublecomplex, ptr %2890, i32 0, i32 1
  %2892 = load double, ptr %2891, align 8, !tbaa !15
  %2893 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %2894 = load double, ptr %2893, align 8, !tbaa !15
  %2895 = fsub double %2892, %2894
  %2896 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %2895, ptr %2896, align 8, !tbaa !15
  %2897 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %2897, ptr %35, align 4, !tbaa !9
  %2898 = load i32, ptr %48, align 4, !tbaa !9
  %2899 = load i32, ptr %49, align 4, !tbaa !9
  %2900 = load i32, ptr %27, align 4, !tbaa !9
  %2901 = mul nsw i32 %2899, %2900
  %2902 = add nsw i32 %2898, %2901
  store i32 %2902, ptr %36, align 4, !tbaa !9
  %2903 = load ptr, ptr %18, align 8, !tbaa !5
  %2904 = load i32, ptr %35, align 4, !tbaa !9
  %2905 = sext i32 %2904 to i64
  %2906 = getelementptr inbounds %struct.doublecomplex, ptr %2903, i64 %2905
  %2907 = getelementptr inbounds %struct.doublecomplex, ptr %2906, i32 0, i32 0
  %2908 = load double, ptr %2907, align 8, !tbaa !13
  %2909 = load ptr, ptr %20, align 8, !tbaa !5
  %2910 = load i32, ptr %36, align 4, !tbaa !9
  %2911 = sext i32 %2910 to i64
  %2912 = getelementptr inbounds %struct.doublecomplex, ptr %2909, i64 %2911
  %2913 = getelementptr inbounds %struct.doublecomplex, ptr %2912, i32 0, i32 0
  %2914 = load double, ptr %2913, align 8, !tbaa !13
  %2915 = load ptr, ptr %18, align 8, !tbaa !5
  %2916 = load i32, ptr %35, align 4, !tbaa !9
  %2917 = sext i32 %2916 to i64
  %2918 = getelementptr inbounds %struct.doublecomplex, ptr %2915, i64 %2917
  %2919 = getelementptr inbounds %struct.doublecomplex, ptr %2918, i32 0, i32 1
  %2920 = load double, ptr %2919, align 8, !tbaa !15
  %2921 = load ptr, ptr %20, align 8, !tbaa !5
  %2922 = load i32, ptr %36, align 4, !tbaa !9
  %2923 = sext i32 %2922 to i64
  %2924 = getelementptr inbounds %struct.doublecomplex, ptr %2921, i64 %2923
  %2925 = getelementptr inbounds %struct.doublecomplex, ptr %2924, i32 0, i32 1
  %2926 = load double, ptr %2925, align 8, !tbaa !15
  %2927 = fmul double %2920, %2926
  %2928 = fneg double %2927
  %2929 = call double @llvm.fmuladd.f64(double %2908, double %2914, double %2928)
  %2930 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %2929, ptr %2930, align 8, !tbaa !13
  %2931 = load ptr, ptr %18, align 8, !tbaa !5
  %2932 = load i32, ptr %35, align 4, !tbaa !9
  %2933 = sext i32 %2932 to i64
  %2934 = getelementptr inbounds %struct.doublecomplex, ptr %2931, i64 %2933
  %2935 = getelementptr inbounds %struct.doublecomplex, ptr %2934, i32 0, i32 0
  %2936 = load double, ptr %2935, align 8, !tbaa !13
  %2937 = load ptr, ptr %20, align 8, !tbaa !5
  %2938 = load i32, ptr %36, align 4, !tbaa !9
  %2939 = sext i32 %2938 to i64
  %2940 = getelementptr inbounds %struct.doublecomplex, ptr %2937, i64 %2939
  %2941 = getelementptr inbounds %struct.doublecomplex, ptr %2940, i32 0, i32 1
  %2942 = load double, ptr %2941, align 8, !tbaa !15
  %2943 = load ptr, ptr %18, align 8, !tbaa !5
  %2944 = load i32, ptr %35, align 4, !tbaa !9
  %2945 = sext i32 %2944 to i64
  %2946 = getelementptr inbounds %struct.doublecomplex, ptr %2943, i64 %2945
  %2947 = getelementptr inbounds %struct.doublecomplex, ptr %2946, i32 0, i32 1
  %2948 = load double, ptr %2947, align 8, !tbaa !15
  %2949 = load ptr, ptr %20, align 8, !tbaa !5
  %2950 = load i32, ptr %36, align 4, !tbaa !9
  %2951 = sext i32 %2950 to i64
  %2952 = getelementptr inbounds %struct.doublecomplex, ptr %2949, i64 %2951
  %2953 = getelementptr inbounds %struct.doublecomplex, ptr %2952, i32 0, i32 0
  %2954 = load double, ptr %2953, align 8, !tbaa !13
  %2955 = fmul double %2948, %2954
  %2956 = call double @llvm.fmuladd.f64(double %2936, double %2942, double %2955)
  %2957 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %2956, ptr %2957, align 8, !tbaa !15
  %2958 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %2959 = load double, ptr %2958, align 8, !tbaa !13
  %2960 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %2961 = load double, ptr %2960, align 8, !tbaa !13
  %2962 = fsub double %2959, %2961
  %2963 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %2962, ptr %2963, align 8, !tbaa !13
  %2964 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %2965 = load double, ptr %2964, align 8, !tbaa !15
  %2966 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %2967 = load double, ptr %2966, align 8, !tbaa !15
  %2968 = fsub double %2965, %2967
  %2969 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %2968, ptr %2969, align 8, !tbaa !15
  %2970 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %2970, ptr %37, align 4, !tbaa !9
  %2971 = load i32, ptr %48, align 4, !tbaa !9
  %2972 = add nsw i32 %2971, 1
  %2973 = load i32, ptr %49, align 4, !tbaa !9
  %2974 = load i32, ptr %27, align 4, !tbaa !9
  %2975 = mul nsw i32 %2973, %2974
  %2976 = add nsw i32 %2972, %2975
  store i32 %2976, ptr %38, align 4, !tbaa !9
  %2977 = load ptr, ptr %19, align 8, !tbaa !5
  %2978 = load i32, ptr %37, align 4, !tbaa !9
  %2979 = sext i32 %2978 to i64
  %2980 = getelementptr inbounds %struct.doublecomplex, ptr %2977, i64 %2979
  %2981 = getelementptr inbounds %struct.doublecomplex, ptr %2980, i32 0, i32 0
  %2982 = load double, ptr %2981, align 8, !tbaa !13
  %2983 = load ptr, ptr %20, align 8, !tbaa !5
  %2984 = load i32, ptr %38, align 4, !tbaa !9
  %2985 = sext i32 %2984 to i64
  %2986 = getelementptr inbounds %struct.doublecomplex, ptr %2983, i64 %2985
  %2987 = getelementptr inbounds %struct.doublecomplex, ptr %2986, i32 0, i32 0
  %2988 = load double, ptr %2987, align 8, !tbaa !13
  %2989 = load ptr, ptr %19, align 8, !tbaa !5
  %2990 = load i32, ptr %37, align 4, !tbaa !9
  %2991 = sext i32 %2990 to i64
  %2992 = getelementptr inbounds %struct.doublecomplex, ptr %2989, i64 %2991
  %2993 = getelementptr inbounds %struct.doublecomplex, ptr %2992, i32 0, i32 1
  %2994 = load double, ptr %2993, align 8, !tbaa !15
  %2995 = load ptr, ptr %20, align 8, !tbaa !5
  %2996 = load i32, ptr %38, align 4, !tbaa !9
  %2997 = sext i32 %2996 to i64
  %2998 = getelementptr inbounds %struct.doublecomplex, ptr %2995, i64 %2997
  %2999 = getelementptr inbounds %struct.doublecomplex, ptr %2998, i32 0, i32 1
  %3000 = load double, ptr %2999, align 8, !tbaa !15
  %3001 = fmul double %2994, %3000
  %3002 = fneg double %3001
  %3003 = call double @llvm.fmuladd.f64(double %2982, double %2988, double %3002)
  %3004 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %3003, ptr %3004, align 8, !tbaa !13
  %3005 = load ptr, ptr %19, align 8, !tbaa !5
  %3006 = load i32, ptr %37, align 4, !tbaa !9
  %3007 = sext i32 %3006 to i64
  %3008 = getelementptr inbounds %struct.doublecomplex, ptr %3005, i64 %3007
  %3009 = getelementptr inbounds %struct.doublecomplex, ptr %3008, i32 0, i32 0
  %3010 = load double, ptr %3009, align 8, !tbaa !13
  %3011 = load ptr, ptr %20, align 8, !tbaa !5
  %3012 = load i32, ptr %38, align 4, !tbaa !9
  %3013 = sext i32 %3012 to i64
  %3014 = getelementptr inbounds %struct.doublecomplex, ptr %3011, i64 %3013
  %3015 = getelementptr inbounds %struct.doublecomplex, ptr %3014, i32 0, i32 1
  %3016 = load double, ptr %3015, align 8, !tbaa !15
  %3017 = load ptr, ptr %19, align 8, !tbaa !5
  %3018 = load i32, ptr %37, 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 1
  %3022 = load double, ptr %3021, align 8, !tbaa !15
  %3023 = load ptr, ptr %20, align 8, !tbaa !5
  %3024 = load i32, ptr %38, align 4, !tbaa !9
  %3025 = sext i32 %3024 to i64
  %3026 = getelementptr inbounds %struct.doublecomplex, ptr %3023, i64 %3025
  %3027 = getelementptr inbounds %struct.doublecomplex, ptr %3026, i32 0, i32 0
  %3028 = load double, ptr %3027, align 8, !tbaa !13
  %3029 = fmul double %3022, %3028
  %3030 = call double @llvm.fmuladd.f64(double %3010, double %3016, double %3029)
  %3031 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %3030, ptr %3031, align 8, !tbaa !15
  %3032 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3033 = load double, ptr %3032, align 8, !tbaa !13
  %3034 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %3035 = load double, ptr %3034, align 8, !tbaa !13
  %3036 = fsub double %3033, %3035
  %3037 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3036, ptr %3037, align 8, !tbaa !13
  %3038 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3039 = load double, ptr %3038, align 8, !tbaa !15
  %3040 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %3041 = load double, ptr %3040, align 8, !tbaa !15
  %3042 = fsub double %3039, %3041
  %3043 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3042, ptr %3043, align 8, !tbaa !15
  %3044 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3045 = load double, ptr %3044, align 8, !tbaa !13
  %3046 = load ptr, ptr %23, align 8, !tbaa !5
  %3047 = load i32, ptr %31, align 4, !tbaa !9
  %3048 = sext i32 %3047 to i64
  %3049 = getelementptr inbounds %struct.doublecomplex, ptr %3046, i64 %3048
  %3050 = getelementptr inbounds %struct.doublecomplex, ptr %3049, i32 0, i32 0
  store double %3045, ptr %3050, align 8, !tbaa !13
  %3051 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3052 = load double, ptr %3051, align 8, !tbaa !15
  %3053 = load ptr, ptr %23, align 8, !tbaa !5
  %3054 = load i32, ptr %31, align 4, !tbaa !9
  %3055 = sext i32 %3054 to i64
  %3056 = getelementptr inbounds %struct.doublecomplex, ptr %3053, i64 %3055
  %3057 = getelementptr inbounds %struct.doublecomplex, ptr %3056, i32 0, i32 1
  store double %3052, ptr %3057, align 8, !tbaa !15
  br label %3058

3058:                                             ; preds = %2803
  %3059 = load i32, ptr %48, align 4, !tbaa !9
  %3060 = add nsw i32 %3059, 1
  store i32 %3060, ptr %48, align 4, !tbaa !9
  br label %2799, !llvm.loop !27

3061:                                             ; preds = %2799
  br label %3062

3062:                                             ; preds = %3061, %2359
  br label %3063

3063:                                             ; preds = %3062
  %3064 = load i32, ptr %49, align 4, !tbaa !9
  %3065 = add nsw i32 %3064, 1
  store i32 %3065, ptr %49, align 4, !tbaa !9
  br label %2351, !llvm.loop !28

3066:                                             ; preds = %2351
  br label %4488

3067:                                             ; preds = %2344
  %3068 = load ptr, ptr %13, align 8, !tbaa !5
  %3069 = call i32 @lsame_(ptr noundef %3068, ptr noundef @.str.1)
  %3070 = icmp ne i32 %3069, 0
  br i1 %3070, label %3071, label %3790

3071:                                             ; preds = %3067
  %3072 = load ptr, ptr %15, align 8, !tbaa !5
  %3073 = load i32, ptr %3072, align 4, !tbaa !9
  store i32 %3073, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %3074

3074:                                             ; preds = %3786, %3071
  %3075 = load i32, ptr %49, align 4, !tbaa !9
  %3076 = load i32, ptr %29, align 4, !tbaa !9
  %3077 = icmp sle i32 %3075, %3076
  br i1 %3077, label %3078, label %3789

3078:                                             ; preds = %3074
  %3079 = load ptr, ptr %14, align 8, !tbaa !5
  %3080 = load i32, ptr %3079, align 4, !tbaa !9
  %3081 = icmp eq i32 %3080, 1
  br i1 %3081, label %3082, label %3176

3082:                                             ; preds = %3078
  %3083 = load i32, ptr %49, align 4, !tbaa !9
  %3084 = load i32, ptr %25, align 4, !tbaa !9
  %3085 = mul nsw i32 %3083, %3084
  %3086 = add nsw i32 %3085, 1
  store i32 %3086, ptr %30, align 4, !tbaa !9
  %3087 = load i32, ptr %49, align 4, !tbaa !9
  %3088 = load i32, ptr %25, align 4, !tbaa !9
  %3089 = mul nsw i32 %3087, %3088
  %3090 = add nsw i32 %3089, 1
  store i32 %3090, ptr %31, align 4, !tbaa !9
  %3091 = load i32, ptr %49, align 4, !tbaa !9
  %3092 = load i32, ptr %27, align 4, !tbaa !9
  %3093 = mul nsw i32 %3091, %3092
  %3094 = add nsw i32 %3093, 1
  store i32 %3094, ptr %32, align 4, !tbaa !9
  %3095 = load ptr, ptr %18, align 8, !tbaa !5
  %3096 = getelementptr inbounds %struct.doublecomplex, ptr %3095, i64 1
  %3097 = getelementptr inbounds %struct.doublecomplex, ptr %3096, i32 0, i32 0
  %3098 = load double, ptr %3097, align 8, !tbaa !13
  %3099 = load ptr, ptr %20, align 8, !tbaa !5
  %3100 = load i32, ptr %32, align 4, !tbaa !9
  %3101 = sext i32 %3100 to i64
  %3102 = getelementptr inbounds %struct.doublecomplex, ptr %3099, i64 %3101
  %3103 = getelementptr inbounds %struct.doublecomplex, ptr %3102, i32 0, i32 0
  %3104 = load double, ptr %3103, align 8, !tbaa !13
  %3105 = load ptr, ptr %18, align 8, !tbaa !5
  %3106 = getelementptr inbounds %struct.doublecomplex, ptr %3105, i64 1
  %3107 = getelementptr inbounds %struct.doublecomplex, ptr %3106, i32 0, i32 1
  %3108 = load double, ptr %3107, align 8, !tbaa !15
  %3109 = load ptr, ptr %20, align 8, !tbaa !5
  %3110 = load i32, ptr %32, 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
  %3114 = load double, ptr %3113, align 8, !tbaa !15
  %3115 = fmul double %3108, %3114
  %3116 = fneg double %3115
  %3117 = call double @llvm.fmuladd.f64(double %3098, double %3104, double %3116)
  %3118 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3117, ptr %3118, align 8, !tbaa !13
  %3119 = load ptr, ptr %18, align 8, !tbaa !5
  %3120 = getelementptr inbounds %struct.doublecomplex, ptr %3119, i64 1
  %3121 = getelementptr inbounds %struct.doublecomplex, ptr %3120, i32 0, i32 0
  %3122 = load double, ptr %3121, align 8, !tbaa !13
  %3123 = load ptr, ptr %20, align 8, !tbaa !5
  %3124 = load i32, ptr %32, align 4, !tbaa !9
  %3125 = sext i32 %3124 to i64
  %3126 = getelementptr inbounds %struct.doublecomplex, ptr %3123, i64 %3125
  %3127 = getelementptr inbounds %struct.doublecomplex, ptr %3126, i32 0, i32 1
  %3128 = load double, ptr %3127, align 8, !tbaa !15
  %3129 = load ptr, ptr %18, align 8, !tbaa !5
  %3130 = getelementptr inbounds %struct.doublecomplex, ptr %3129, i64 1
  %3131 = getelementptr inbounds %struct.doublecomplex, ptr %3130, i32 0, i32 1
  %3132 = load double, ptr %3131, align 8, !tbaa !15
  %3133 = load ptr, ptr %20, align 8, !tbaa !5
  %3134 = load i32, ptr %32, align 4, !tbaa !9
  %3135 = sext i32 %3134 to i64
  %3136 = getelementptr inbounds %struct.doublecomplex, ptr %3133, i64 %3135
  %3137 = getelementptr inbounds %struct.doublecomplex, ptr %3136, i32 0, i32 0
  %3138 = load double, ptr %3137, align 8, !tbaa !13
  %3139 = fmul double %3132, %3138
  %3140 = call double @llvm.fmuladd.f64(double %3122, double %3128, double %3139)
  %3141 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3140, ptr %3141, align 8, !tbaa !15
  %3142 = load ptr, ptr %23, align 8, !tbaa !5
  %3143 = load i32, ptr %31, align 4, !tbaa !9
  %3144 = sext i32 %3143 to i64
  %3145 = getelementptr inbounds %struct.doublecomplex, ptr %3142, i64 %3144
  %3146 = getelementptr inbounds %struct.doublecomplex, ptr %3145, i32 0, i32 0
  %3147 = load double, ptr %3146, align 8, !tbaa !13
  %3148 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3149 = load double, ptr %3148, align 8, !tbaa !13
  %3150 = fsub double %3147, %3149
  %3151 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3150, ptr %3151, align 8, !tbaa !13
  %3152 = load ptr, ptr %23, align 8, !tbaa !5
  %3153 = load i32, ptr %31, align 4, !tbaa !9
  %3154 = sext i32 %3153 to i64
  %3155 = getelementptr inbounds %struct.doublecomplex, ptr %3152, i64 %3154
  %3156 = getelementptr inbounds %struct.doublecomplex, ptr %3155, i32 0, i32 1
  %3157 = load double, ptr %3156, align 8, !tbaa !15
  %3158 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3159 = load double, ptr %3158, align 8, !tbaa !15
  %3160 = fsub double %3157, %3159
  %3161 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3160, ptr %3161, align 8, !tbaa !15
  %3162 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3163 = load double, ptr %3162, align 8, !tbaa !13
  %3164 = load ptr, ptr %23, align 8, !tbaa !5
  %3165 = load i32, ptr %30, align 4, !tbaa !9
  %3166 = sext i32 %3165 to i64
  %3167 = getelementptr inbounds %struct.doublecomplex, ptr %3164, i64 %3166
  %3168 = getelementptr inbounds %struct.doublecomplex, ptr %3167, i32 0, i32 0
  store double %3163, ptr %3168, align 8, !tbaa !13
  %3169 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3170 = load double, ptr %3169, align 8, !tbaa !15
  %3171 = load ptr, ptr %23, align 8, !tbaa !5
  %3172 = load i32, ptr %30, align 4, !tbaa !9
  %3173 = sext i32 %3172 to i64
  %3174 = getelementptr inbounds %struct.doublecomplex, ptr %3171, i64 %3173
  %3175 = getelementptr inbounds %struct.doublecomplex, ptr %3174, i32 0, i32 1
  store double %3170, ptr %3175, align 8, !tbaa !15
  br label %3785

3176:                                             ; preds = %3078
  %3177 = load i32, ptr %49, align 4, !tbaa !9
  %3178 = load i32, ptr %25, align 4, !tbaa !9
  %3179 = mul nsw i32 %3177, %3178
  %3180 = add nsw i32 %3179, 1
  store i32 %3180, ptr %30, align 4, !tbaa !9
  %3181 = load i32, ptr %49, align 4, !tbaa !9
  %3182 = load i32, ptr %25, align 4, !tbaa !9
  %3183 = mul nsw i32 %3181, %3182
  %3184 = add nsw i32 %3183, 1
  store i32 %3184, ptr %31, align 4, !tbaa !9
  %3185 = load i32, ptr %49, align 4, !tbaa !9
  %3186 = load i32, ptr %27, align 4, !tbaa !9
  %3187 = mul nsw i32 %3185, %3186
  %3188 = add nsw i32 %3187, 1
  store i32 %3188, ptr %32, align 4, !tbaa !9
  %3189 = load ptr, ptr %18, align 8, !tbaa !5
  %3190 = getelementptr inbounds %struct.doublecomplex, ptr %3189, i64 1
  %3191 = getelementptr inbounds %struct.doublecomplex, ptr %3190, i32 0, i32 0
  %3192 = load double, ptr %3191, align 8, !tbaa !13
  %3193 = load ptr, ptr %20, align 8, !tbaa !5
  %3194 = load i32, ptr %32, 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 0
  %3198 = load double, ptr %3197, align 8, !tbaa !13
  %3199 = load ptr, ptr %18, align 8, !tbaa !5
  %3200 = getelementptr inbounds %struct.doublecomplex, ptr %3199, i64 1
  %3201 = getelementptr inbounds %struct.doublecomplex, ptr %3200, i32 0, i32 1
  %3202 = load double, ptr %3201, align 8, !tbaa !15
  %3203 = load ptr, ptr %20, align 8, !tbaa !5
  %3204 = load i32, ptr %32, align 4, !tbaa !9
  %3205 = sext i32 %3204 to i64
  %3206 = getelementptr inbounds %struct.doublecomplex, ptr %3203, i64 %3205
  %3207 = getelementptr inbounds %struct.doublecomplex, ptr %3206, i32 0, i32 1
  %3208 = load double, ptr %3207, align 8, !tbaa !15
  %3209 = fmul double %3202, %3208
  %3210 = fneg double %3209
  %3211 = call double @llvm.fmuladd.f64(double %3192, double %3198, double %3210)
  %3212 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %3211, ptr %3212, align 8, !tbaa !13
  %3213 = load ptr, ptr %18, align 8, !tbaa !5
  %3214 = getelementptr inbounds %struct.doublecomplex, ptr %3213, i64 1
  %3215 = getelementptr inbounds %struct.doublecomplex, ptr %3214, i32 0, i32 0
  %3216 = load double, ptr %3215, align 8, !tbaa !13
  %3217 = load ptr, ptr %20, align 8, !tbaa !5
  %3218 = load i32, ptr %32, align 4, !tbaa !9
  %3219 = sext i32 %3218 to i64
  %3220 = getelementptr inbounds %struct.doublecomplex, ptr %3217, i64 %3219
  %3221 = getelementptr inbounds %struct.doublecomplex, ptr %3220, i32 0, i32 1
  %3222 = load double, ptr %3221, align 8, !tbaa !15
  %3223 = load ptr, ptr %18, align 8, !tbaa !5
  %3224 = getelementptr inbounds %struct.doublecomplex, ptr %3223, i64 1
  %3225 = getelementptr inbounds %struct.doublecomplex, ptr %3224, i32 0, i32 1
  %3226 = load double, ptr %3225, align 8, !tbaa !15
  %3227 = load ptr, ptr %20, align 8, !tbaa !5
  %3228 = load i32, ptr %32, align 4, !tbaa !9
  %3229 = sext i32 %3228 to i64
  %3230 = getelementptr inbounds %struct.doublecomplex, ptr %3227, i64 %3229
  %3231 = getelementptr inbounds %struct.doublecomplex, ptr %3230, i32 0, i32 0
  %3232 = load double, ptr %3231, align 8, !tbaa !13
  %3233 = fmul double %3226, %3232
  %3234 = call double @llvm.fmuladd.f64(double %3216, double %3222, double %3233)
  %3235 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %3234, ptr %3235, align 8, !tbaa !15
  %3236 = load ptr, ptr %23, align 8, !tbaa !5
  %3237 = load i32, ptr %31, align 4, !tbaa !9
  %3238 = sext i32 %3237 to i64
  %3239 = getelementptr inbounds %struct.doublecomplex, ptr %3236, i64 %3238
  %3240 = getelementptr inbounds %struct.doublecomplex, ptr %3239, i32 0, i32 0
  %3241 = load double, ptr %3240, align 8, !tbaa !13
  %3242 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3243 = load double, ptr %3242, align 8, !tbaa !13
  %3244 = fsub double %3241, %3243
  %3245 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3244, ptr %3245, align 8, !tbaa !13
  %3246 = load ptr, ptr %23, align 8, !tbaa !5
  %3247 = load i32, ptr %31, align 4, !tbaa !9
  %3248 = sext i32 %3247 to i64
  %3249 = getelementptr inbounds %struct.doublecomplex, ptr %3246, i64 %3248
  %3250 = getelementptr inbounds %struct.doublecomplex, ptr %3249, i32 0, i32 1
  %3251 = load double, ptr %3250, align 8, !tbaa !15
  %3252 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3253 = load double, ptr %3252, align 8, !tbaa !15
  %3254 = fsub double %3251, %3253
  %3255 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3254, ptr %3255, align 8, !tbaa !15
  %3256 = load i32, ptr %49, align 4, !tbaa !9
  %3257 = load i32, ptr %27, align 4, !tbaa !9
  %3258 = mul nsw i32 %3256, %3257
  %3259 = add nsw i32 %3258, 2
  store i32 %3259, ptr %33, align 4, !tbaa !9
  %3260 = load ptr, ptr %17, align 8, !tbaa !5
  %3261 = getelementptr inbounds %struct.doublecomplex, ptr %3260, i64 1
  %3262 = getelementptr inbounds %struct.doublecomplex, ptr %3261, i32 0, i32 0
  %3263 = load double, ptr %3262, align 8, !tbaa !13
  %3264 = load ptr, ptr %20, align 8, !tbaa !5
  %3265 = load i32, ptr %33, 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 = load ptr, ptr %17, align 8, !tbaa !5
  %3271 = getelementptr inbounds %struct.doublecomplex, ptr %3270, i64 1
  %3272 = getelementptr inbounds %struct.doublecomplex, ptr %3271, i32 0, i32 1
  %3273 = load double, ptr %3272, align 8, !tbaa !15
  %3274 = load ptr, ptr %20, align 8, !tbaa !5
  %3275 = load i32, ptr %33, align 4, !tbaa !9
  %3276 = sext i32 %3275 to i64
  %3277 = getelementptr inbounds %struct.doublecomplex, ptr %3274, i64 %3276
  %3278 = getelementptr inbounds %struct.doublecomplex, ptr %3277, i32 0, i32 1
  %3279 = load double, ptr %3278, align 8, !tbaa !15
  %3280 = fmul double %3273, %3279
  %3281 = fneg double %3280
  %3282 = call double @llvm.fmuladd.f64(double %3263, double %3269, double %3281)
  %3283 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3282, ptr %3283, align 8, !tbaa !13
  %3284 = load ptr, ptr %17, align 8, !tbaa !5
  %3285 = getelementptr inbounds %struct.doublecomplex, ptr %3284, i64 1
  %3286 = getelementptr inbounds %struct.doublecomplex, ptr %3285, i32 0, i32 0
  %3287 = load double, ptr %3286, align 8, !tbaa !13
  %3288 = load ptr, ptr %20, align 8, !tbaa !5
  %3289 = load i32, ptr %33, 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 1
  %3293 = load double, ptr %3292, align 8, !tbaa !15
  %3294 = load ptr, ptr %17, align 8, !tbaa !5
  %3295 = getelementptr inbounds %struct.doublecomplex, ptr %3294, i64 1
  %3296 = getelementptr inbounds %struct.doublecomplex, ptr %3295, i32 0, i32 1
  %3297 = load double, ptr %3296, align 8, !tbaa !15
  %3298 = load ptr, ptr %20, align 8, !tbaa !5
  %3299 = load i32, ptr %33, align 4, !tbaa !9
  %3300 = sext i32 %3299 to i64
  %3301 = getelementptr inbounds %struct.doublecomplex, ptr %3298, i64 %3300
  %3302 = getelementptr inbounds %struct.doublecomplex, ptr %3301, i32 0, i32 0
  %3303 = load double, ptr %3302, align 8, !tbaa !13
  %3304 = fmul double %3297, %3303
  %3305 = call double @llvm.fmuladd.f64(double %3287, double %3293, double %3304)
  %3306 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3305, ptr %3306, align 8, !tbaa !15
  %3307 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3308 = load double, ptr %3307, align 8, !tbaa !13
  %3309 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3310 = load double, ptr %3309, align 8, !tbaa !13
  %3311 = fsub double %3308, %3310
  %3312 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3311, ptr %3312, align 8, !tbaa !13
  %3313 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3314 = load double, ptr %3313, align 8, !tbaa !15
  %3315 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3316 = load double, ptr %3315, align 8, !tbaa !15
  %3317 = fsub double %3314, %3316
  %3318 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3317, ptr %3318, align 8, !tbaa !15
  %3319 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3320 = load double, ptr %3319, align 8, !tbaa !13
  %3321 = load ptr, ptr %23, align 8, !tbaa !5
  %3322 = load i32, ptr %30, align 4, !tbaa !9
  %3323 = sext i32 %3322 to i64
  %3324 = getelementptr inbounds %struct.doublecomplex, ptr %3321, i64 %3323
  %3325 = getelementptr inbounds %struct.doublecomplex, ptr %3324, i32 0, i32 0
  store double %3320, ptr %3325, align 8, !tbaa !13
  %3326 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3327 = load double, ptr %3326, align 8, !tbaa !15
  %3328 = load ptr, ptr %23, align 8, !tbaa !5
  %3329 = load i32, ptr %30, align 4, !tbaa !9
  %3330 = sext i32 %3329 to i64
  %3331 = getelementptr inbounds %struct.doublecomplex, ptr %3328, i64 %3330
  %3332 = getelementptr inbounds %struct.doublecomplex, ptr %3331, i32 0, i32 1
  store double %3327, ptr %3332, align 8, !tbaa !15
  %3333 = load ptr, ptr %14, align 8, !tbaa !5
  %3334 = load i32, ptr %3333, align 4, !tbaa !9
  %3335 = load i32, ptr %49, align 4, !tbaa !9
  %3336 = load i32, ptr %25, align 4, !tbaa !9
  %3337 = mul nsw i32 %3335, %3336
  %3338 = add nsw i32 %3334, %3337
  store i32 %3338, ptr %30, align 4, !tbaa !9
  %3339 = load ptr, ptr %14, align 8, !tbaa !5
  %3340 = load i32, ptr %3339, align 4, !tbaa !9
  %3341 = load i32, ptr %49, align 4, !tbaa !9
  %3342 = load i32, ptr %25, align 4, !tbaa !9
  %3343 = mul nsw i32 %3341, %3342
  %3344 = add nsw i32 %3340, %3343
  store i32 %3344, ptr %31, align 4, !tbaa !9
  %3345 = load ptr, ptr %14, align 8, !tbaa !5
  %3346 = load i32, ptr %3345, align 4, !tbaa !9
  %3347 = sub nsw i32 %3346, 1
  store i32 %3347, ptr %32, align 4, !tbaa !9
  %3348 = load ptr, ptr %14, align 8, !tbaa !5
  %3349 = load i32, ptr %3348, align 4, !tbaa !9
  %3350 = sub nsw i32 %3349, 1
  %3351 = load i32, ptr %49, align 4, !tbaa !9
  %3352 = load i32, ptr %27, align 4, !tbaa !9
  %3353 = mul nsw i32 %3351, %3352
  %3354 = add nsw i32 %3350, %3353
  store i32 %3354, ptr %33, align 4, !tbaa !9
  %3355 = load ptr, ptr %19, align 8, !tbaa !5
  %3356 = load i32, ptr %32, align 4, !tbaa !9
  %3357 = sext i32 %3356 to i64
  %3358 = getelementptr inbounds %struct.doublecomplex, ptr %3355, i64 %3357
  %3359 = getelementptr inbounds %struct.doublecomplex, ptr %3358, i32 0, i32 0
  %3360 = load double, ptr %3359, align 8, !tbaa !13
  %3361 = load ptr, ptr %20, align 8, !tbaa !5
  %3362 = load i32, ptr %33, align 4, !tbaa !9
  %3363 = sext i32 %3362 to i64
  %3364 = getelementptr inbounds %struct.doublecomplex, ptr %3361, i64 %3363
  %3365 = getelementptr inbounds %struct.doublecomplex, ptr %3364, i32 0, i32 0
  %3366 = load double, ptr %3365, align 8, !tbaa !13
  %3367 = load ptr, ptr %19, align 8, !tbaa !5
  %3368 = load i32, ptr %32, align 4, !tbaa !9
  %3369 = sext i32 %3368 to i64
  %3370 = getelementptr inbounds %struct.doublecomplex, ptr %3367, i64 %3369
  %3371 = getelementptr inbounds %struct.doublecomplex, ptr %3370, i32 0, i32 1
  %3372 = load double, ptr %3371, align 8, !tbaa !15
  %3373 = load ptr, ptr %20, align 8, !tbaa !5
  %3374 = load i32, ptr %33, align 4, !tbaa !9
  %3375 = sext i32 %3374 to i64
  %3376 = getelementptr inbounds %struct.doublecomplex, ptr %3373, i64 %3375
  %3377 = getelementptr inbounds %struct.doublecomplex, ptr %3376, i32 0, i32 1
  %3378 = load double, ptr %3377, align 8, !tbaa !15
  %3379 = fmul double %3372, %3378
  %3380 = fneg double %3379
  %3381 = call double @llvm.fmuladd.f64(double %3360, double %3366, double %3380)
  %3382 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %3381, ptr %3382, align 8, !tbaa !13
  %3383 = load ptr, ptr %19, align 8, !tbaa !5
  %3384 = load i32, ptr %32, align 4, !tbaa !9
  %3385 = sext i32 %3384 to i64
  %3386 = getelementptr inbounds %struct.doublecomplex, ptr %3383, i64 %3385
  %3387 = getelementptr inbounds %struct.doublecomplex, ptr %3386, i32 0, i32 0
  %3388 = load double, ptr %3387, align 8, !tbaa !13
  %3389 = load ptr, ptr %20, align 8, !tbaa !5
  %3390 = load i32, ptr %33, align 4, !tbaa !9
  %3391 = sext i32 %3390 to i64
  %3392 = getelementptr inbounds %struct.doublecomplex, ptr %3389, i64 %3391
  %3393 = getelementptr inbounds %struct.doublecomplex, ptr %3392, i32 0, i32 1
  %3394 = load double, ptr %3393, align 8, !tbaa !15
  %3395 = load ptr, ptr %19, align 8, !tbaa !5
  %3396 = load i32, ptr %32, align 4, !tbaa !9
  %3397 = sext i32 %3396 to i64
  %3398 = getelementptr inbounds %struct.doublecomplex, ptr %3395, i64 %3397
  %3399 = getelementptr inbounds %struct.doublecomplex, ptr %3398, i32 0, i32 1
  %3400 = load double, ptr %3399, align 8, !tbaa !15
  %3401 = load ptr, ptr %20, align 8, !tbaa !5
  %3402 = load i32, ptr %33, align 4, !tbaa !9
  %3403 = sext i32 %3402 to i64
  %3404 = getelementptr inbounds %struct.doublecomplex, ptr %3401, i64 %3403
  %3405 = getelementptr inbounds %struct.doublecomplex, ptr %3404, i32 0, i32 0
  %3406 = load double, ptr %3405, align 8, !tbaa !13
  %3407 = fmul double %3400, %3406
  %3408 = call double @llvm.fmuladd.f64(double %3388, double %3394, double %3407)
  %3409 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %3408, ptr %3409, align 8, !tbaa !15
  %3410 = load ptr, ptr %23, align 8, !tbaa !5
  %3411 = load i32, ptr %31, align 4, !tbaa !9
  %3412 = sext i32 %3411 to i64
  %3413 = getelementptr inbounds %struct.doublecomplex, ptr %3410, i64 %3412
  %3414 = getelementptr inbounds %struct.doublecomplex, ptr %3413, i32 0, i32 0
  %3415 = load double, ptr %3414, align 8, !tbaa !13
  %3416 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3417 = load double, ptr %3416, align 8, !tbaa !13
  %3418 = fsub double %3415, %3417
  %3419 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3418, ptr %3419, align 8, !tbaa !13
  %3420 = load ptr, ptr %23, align 8, !tbaa !5
  %3421 = load i32, ptr %31, align 4, !tbaa !9
  %3422 = sext i32 %3421 to i64
  %3423 = getelementptr inbounds %struct.doublecomplex, ptr %3420, i64 %3422
  %3424 = getelementptr inbounds %struct.doublecomplex, ptr %3423, i32 0, i32 1
  %3425 = load double, ptr %3424, align 8, !tbaa !15
  %3426 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3427 = load double, ptr %3426, align 8, !tbaa !15
  %3428 = fsub double %3425, %3427
  %3429 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3428, ptr %3429, align 8, !tbaa !15
  %3430 = load ptr, ptr %14, align 8, !tbaa !5
  %3431 = load i32, ptr %3430, align 4, !tbaa !9
  store i32 %3431, ptr %34, align 4, !tbaa !9
  %3432 = load ptr, ptr %14, align 8, !tbaa !5
  %3433 = load i32, ptr %3432, align 4, !tbaa !9
  %3434 = load i32, ptr %49, align 4, !tbaa !9
  %3435 = load i32, ptr %27, align 4, !tbaa !9
  %3436 = mul nsw i32 %3434, %3435
  %3437 = add nsw i32 %3433, %3436
  store i32 %3437, ptr %35, align 4, !tbaa !9
  %3438 = load ptr, ptr %18, align 8, !tbaa !5
  %3439 = load i32, ptr %34, align 4, !tbaa !9
  %3440 = sext i32 %3439 to i64
  %3441 = getelementptr inbounds %struct.doublecomplex, ptr %3438, i64 %3440
  %3442 = getelementptr inbounds %struct.doublecomplex, ptr %3441, i32 0, i32 0
  %3443 = load double, ptr %3442, align 8, !tbaa !13
  %3444 = load ptr, ptr %20, align 8, !tbaa !5
  %3445 = load i32, ptr %35, align 4, !tbaa !9
  %3446 = sext i32 %3445 to i64
  %3447 = getelementptr inbounds %struct.doublecomplex, ptr %3444, i64 %3446
  %3448 = getelementptr inbounds %struct.doublecomplex, ptr %3447, i32 0, i32 0
  %3449 = load double, ptr %3448, align 8, !tbaa !13
  %3450 = load ptr, ptr %18, align 8, !tbaa !5
  %3451 = load i32, ptr %34, align 4, !tbaa !9
  %3452 = sext i32 %3451 to i64
  %3453 = getelementptr inbounds %struct.doublecomplex, ptr %3450, i64 %3452
  %3454 = getelementptr inbounds %struct.doublecomplex, ptr %3453, i32 0, i32 1
  %3455 = load double, ptr %3454, align 8, !tbaa !15
  %3456 = load ptr, ptr %20, align 8, !tbaa !5
  %3457 = load i32, ptr %35, align 4, !tbaa !9
  %3458 = sext i32 %3457 to i64
  %3459 = getelementptr inbounds %struct.doublecomplex, ptr %3456, i64 %3458
  %3460 = getelementptr inbounds %struct.doublecomplex, ptr %3459, i32 0, i32 1
  %3461 = load double, ptr %3460, align 8, !tbaa !15
  %3462 = fmul double %3455, %3461
  %3463 = fneg double %3462
  %3464 = call double @llvm.fmuladd.f64(double %3443, double %3449, double %3463)
  %3465 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3464, ptr %3465, align 8, !tbaa !13
  %3466 = load ptr, ptr %18, align 8, !tbaa !5
  %3467 = load i32, ptr %34, align 4, !tbaa !9
  %3468 = sext i32 %3467 to i64
  %3469 = getelementptr inbounds %struct.doublecomplex, ptr %3466, i64 %3468
  %3470 = getelementptr inbounds %struct.doublecomplex, ptr %3469, i32 0, i32 0
  %3471 = load double, ptr %3470, align 8, !tbaa !13
  %3472 = load ptr, ptr %20, align 8, !tbaa !5
  %3473 = load i32, ptr %35, align 4, !tbaa !9
  %3474 = sext i32 %3473 to i64
  %3475 = getelementptr inbounds %struct.doublecomplex, ptr %3472, i64 %3474
  %3476 = getelementptr inbounds %struct.doublecomplex, ptr %3475, i32 0, i32 1
  %3477 = load double, ptr %3476, align 8, !tbaa !15
  %3478 = load ptr, ptr %18, align 8, !tbaa !5
  %3479 = load i32, ptr %34, align 4, !tbaa !9
  %3480 = sext i32 %3479 to i64
  %3481 = getelementptr inbounds %struct.doublecomplex, ptr %3478, i64 %3480
  %3482 = getelementptr inbounds %struct.doublecomplex, ptr %3481, i32 0, i32 1
  %3483 = load double, ptr %3482, align 8, !tbaa !15
  %3484 = load ptr, ptr %20, align 8, !tbaa !5
  %3485 = load i32, ptr %35, align 4, !tbaa !9
  %3486 = sext i32 %3485 to i64
  %3487 = getelementptr inbounds %struct.doublecomplex, ptr %3484, i64 %3486
  %3488 = getelementptr inbounds %struct.doublecomplex, ptr %3487, i32 0, i32 0
  %3489 = load double, ptr %3488, align 8, !tbaa !13
  %3490 = fmul double %3483, %3489
  %3491 = call double @llvm.fmuladd.f64(double %3471, double %3477, double %3490)
  %3492 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3491, ptr %3492, align 8, !tbaa !15
  %3493 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3494 = load double, ptr %3493, align 8, !tbaa !13
  %3495 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3496 = load double, ptr %3495, align 8, !tbaa !13
  %3497 = fsub double %3494, %3496
  %3498 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3497, ptr %3498, align 8, !tbaa !13
  %3499 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3500 = load double, ptr %3499, align 8, !tbaa !15
  %3501 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3502 = load double, ptr %3501, align 8, !tbaa !15
  %3503 = fsub double %3500, %3502
  %3504 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3503, ptr %3504, align 8, !tbaa !15
  %3505 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3506 = load double, ptr %3505, align 8, !tbaa !13
  %3507 = load ptr, ptr %23, align 8, !tbaa !5
  %3508 = load i32, ptr %30, align 4, !tbaa !9
  %3509 = sext i32 %3508 to i64
  %3510 = getelementptr inbounds %struct.doublecomplex, ptr %3507, i64 %3509
  %3511 = getelementptr inbounds %struct.doublecomplex, ptr %3510, i32 0, i32 0
  store double %3506, ptr %3511, align 8, !tbaa !13
  %3512 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3513 = load double, ptr %3512, align 8, !tbaa !15
  %3514 = load ptr, ptr %23, align 8, !tbaa !5
  %3515 = load i32, ptr %30, align 4, !tbaa !9
  %3516 = sext i32 %3515 to i64
  %3517 = getelementptr inbounds %struct.doublecomplex, ptr %3514, i64 %3516
  %3518 = getelementptr inbounds %struct.doublecomplex, ptr %3517, i32 0, i32 1
  store double %3513, ptr %3518, align 8, !tbaa !15
  %3519 = load ptr, ptr %14, align 8, !tbaa !5
  %3520 = load i32, ptr %3519, align 4, !tbaa !9
  %3521 = sub nsw i32 %3520, 1
  store i32 %3521, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %3522

3522:                                             ; preds = %3781, %3176
  %3523 = load i32, ptr %48, align 4, !tbaa !9
  %3524 = load i32, ptr %30, align 4, !tbaa !9
  %3525 = icmp sle i32 %3523, %3524
  br i1 %3525, label %3526, label %3784

3526:                                             ; preds = %3522
  %3527 = load i32, ptr %48, align 4, !tbaa !9
  %3528 = load i32, ptr %49, align 4, !tbaa !9
  %3529 = load i32, ptr %25, align 4, !tbaa !9
  %3530 = mul nsw i32 %3528, %3529
  %3531 = add nsw i32 %3527, %3530
  store i32 %3531, ptr %31, align 4, !tbaa !9
  %3532 = load i32, ptr %48, align 4, !tbaa !9
  %3533 = load i32, ptr %49, align 4, !tbaa !9
  %3534 = load i32, ptr %25, align 4, !tbaa !9
  %3535 = mul nsw i32 %3533, %3534
  %3536 = add nsw i32 %3532, %3535
  store i32 %3536, ptr %32, align 4, !tbaa !9
  %3537 = load i32, ptr %48, align 4, !tbaa !9
  %3538 = sub nsw i32 %3537, 1
  store i32 %3538, ptr %33, align 4, !tbaa !9
  %3539 = load i32, ptr %48, align 4, !tbaa !9
  %3540 = sub nsw i32 %3539, 1
  %3541 = load i32, ptr %49, align 4, !tbaa !9
  %3542 = load i32, ptr %27, align 4, !tbaa !9
  %3543 = mul nsw i32 %3541, %3542
  %3544 = add nsw i32 %3540, %3543
  store i32 %3544, ptr %34, align 4, !tbaa !9
  %3545 = load ptr, ptr %19, align 8, !tbaa !5
  %3546 = load i32, ptr %33, align 4, !tbaa !9
  %3547 = sext i32 %3546 to i64
  %3548 = getelementptr inbounds %struct.doublecomplex, ptr %3545, i64 %3547
  %3549 = getelementptr inbounds %struct.doublecomplex, ptr %3548, i32 0, i32 0
  %3550 = load double, ptr %3549, align 8, !tbaa !13
  %3551 = load ptr, ptr %20, align 8, !tbaa !5
  %3552 = load i32, ptr %34, align 4, !tbaa !9
  %3553 = sext i32 %3552 to i64
  %3554 = getelementptr inbounds %struct.doublecomplex, ptr %3551, i64 %3553
  %3555 = getelementptr inbounds %struct.doublecomplex, ptr %3554, i32 0, i32 0
  %3556 = load double, ptr %3555, align 8, !tbaa !13
  %3557 = load ptr, ptr %19, align 8, !tbaa !5
  %3558 = load i32, ptr %33, align 4, !tbaa !9
  %3559 = sext i32 %3558 to i64
  %3560 = getelementptr inbounds %struct.doublecomplex, ptr %3557, i64 %3559
  %3561 = getelementptr inbounds %struct.doublecomplex, ptr %3560, i32 0, i32 1
  %3562 = load double, ptr %3561, align 8, !tbaa !15
  %3563 = load ptr, ptr %20, align 8, !tbaa !5
  %3564 = load i32, ptr %34, align 4, !tbaa !9
  %3565 = sext i32 %3564 to i64
  %3566 = getelementptr inbounds %struct.doublecomplex, ptr %3563, i64 %3565
  %3567 = getelementptr inbounds %struct.doublecomplex, ptr %3566, i32 0, i32 1
  %3568 = load double, ptr %3567, align 8, !tbaa !15
  %3569 = fmul double %3562, %3568
  %3570 = fneg double %3569
  %3571 = call double @llvm.fmuladd.f64(double %3550, double %3556, double %3570)
  %3572 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %3571, ptr %3572, align 8, !tbaa !13
  %3573 = load ptr, ptr %19, align 8, !tbaa !5
  %3574 = load i32, ptr %33, align 4, !tbaa !9
  %3575 = sext i32 %3574 to i64
  %3576 = getelementptr inbounds %struct.doublecomplex, ptr %3573, i64 %3575
  %3577 = getelementptr inbounds %struct.doublecomplex, ptr %3576, i32 0, i32 0
  %3578 = load double, ptr %3577, align 8, !tbaa !13
  %3579 = load ptr, ptr %20, align 8, !tbaa !5
  %3580 = load i32, ptr %34, align 4, !tbaa !9
  %3581 = sext i32 %3580 to i64
  %3582 = getelementptr inbounds %struct.doublecomplex, ptr %3579, i64 %3581
  %3583 = getelementptr inbounds %struct.doublecomplex, ptr %3582, i32 0, i32 1
  %3584 = load double, ptr %3583, align 8, !tbaa !15
  %3585 = load ptr, ptr %19, align 8, !tbaa !5
  %3586 = load i32, ptr %33, align 4, !tbaa !9
  %3587 = sext i32 %3586 to i64
  %3588 = getelementptr inbounds %struct.doublecomplex, ptr %3585, i64 %3587
  %3589 = getelementptr inbounds %struct.doublecomplex, ptr %3588, i32 0, i32 1
  %3590 = load double, ptr %3589, align 8, !tbaa !15
  %3591 = load ptr, ptr %20, align 8, !tbaa !5
  %3592 = load i32, ptr %34, align 4, !tbaa !9
  %3593 = sext i32 %3592 to i64
  %3594 = getelementptr inbounds %struct.doublecomplex, ptr %3591, i64 %3593
  %3595 = getelementptr inbounds %struct.doublecomplex, ptr %3594, i32 0, i32 0
  %3596 = load double, ptr %3595, align 8, !tbaa !13
  %3597 = fmul double %3590, %3596
  %3598 = call double @llvm.fmuladd.f64(double %3578, double %3584, double %3597)
  %3599 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %3598, ptr %3599, align 8, !tbaa !15
  %3600 = load ptr, ptr %23, align 8, !tbaa !5
  %3601 = load i32, ptr %32, align 4, !tbaa !9
  %3602 = sext i32 %3601 to i64
  %3603 = getelementptr inbounds %struct.doublecomplex, ptr %3600, i64 %3602
  %3604 = getelementptr inbounds %struct.doublecomplex, ptr %3603, i32 0, i32 0
  %3605 = load double, ptr %3604, align 8, !tbaa !13
  %3606 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3607 = load double, ptr %3606, align 8, !tbaa !13
  %3608 = fsub double %3605, %3607
  %3609 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %3608, ptr %3609, align 8, !tbaa !13
  %3610 = load ptr, ptr %23, align 8, !tbaa !5
  %3611 = load i32, ptr %32, align 4, !tbaa !9
  %3612 = sext i32 %3611 to i64
  %3613 = getelementptr inbounds %struct.doublecomplex, ptr %3610, i64 %3612
  %3614 = getelementptr inbounds %struct.doublecomplex, ptr %3613, i32 0, i32 1
  %3615 = load double, ptr %3614, align 8, !tbaa !15
  %3616 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3617 = load double, ptr %3616, align 8, !tbaa !15
  %3618 = fsub double %3615, %3617
  %3619 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %3618, ptr %3619, align 8, !tbaa !15
  %3620 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %3620, ptr %35, align 4, !tbaa !9
  %3621 = load i32, ptr %48, align 4, !tbaa !9
  %3622 = load i32, ptr %49, align 4, !tbaa !9
  %3623 = load i32, ptr %27, align 4, !tbaa !9
  %3624 = mul nsw i32 %3622, %3623
  %3625 = add nsw i32 %3621, %3624
  store i32 %3625, ptr %36, align 4, !tbaa !9
  %3626 = load ptr, ptr %18, align 8, !tbaa !5
  %3627 = load i32, ptr %35, align 4, !tbaa !9
  %3628 = sext i32 %3627 to i64
  %3629 = getelementptr inbounds %struct.doublecomplex, ptr %3626, i64 %3628
  %3630 = getelementptr inbounds %struct.doublecomplex, ptr %3629, i32 0, i32 0
  %3631 = load double, ptr %3630, align 8, !tbaa !13
  %3632 = load ptr, ptr %20, align 8, !tbaa !5
  %3633 = load i32, ptr %36, align 4, !tbaa !9
  %3634 = sext i32 %3633 to i64
  %3635 = getelementptr inbounds %struct.doublecomplex, ptr %3632, i64 %3634
  %3636 = getelementptr inbounds %struct.doublecomplex, ptr %3635, i32 0, i32 0
  %3637 = load double, ptr %3636, align 8, !tbaa !13
  %3638 = load ptr, ptr %18, align 8, !tbaa !5
  %3639 = load i32, ptr %35, align 4, !tbaa !9
  %3640 = sext i32 %3639 to i64
  %3641 = getelementptr inbounds %struct.doublecomplex, ptr %3638, i64 %3640
  %3642 = getelementptr inbounds %struct.doublecomplex, ptr %3641, i32 0, i32 1
  %3643 = load double, ptr %3642, align 8, !tbaa !15
  %3644 = load ptr, ptr %20, align 8, !tbaa !5
  %3645 = load i32, ptr %36, align 4, !tbaa !9
  %3646 = sext i32 %3645 to i64
  %3647 = getelementptr inbounds %struct.doublecomplex, ptr %3644, i64 %3646
  %3648 = getelementptr inbounds %struct.doublecomplex, ptr %3647, i32 0, i32 1
  %3649 = load double, ptr %3648, align 8, !tbaa !15
  %3650 = fmul double %3643, %3649
  %3651 = fneg double %3650
  %3652 = call double @llvm.fmuladd.f64(double %3631, double %3637, double %3651)
  %3653 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %3652, ptr %3653, align 8, !tbaa !13
  %3654 = load ptr, ptr %18, align 8, !tbaa !5
  %3655 = load i32, ptr %35, align 4, !tbaa !9
  %3656 = sext i32 %3655 to i64
  %3657 = getelementptr inbounds %struct.doublecomplex, ptr %3654, i64 %3656
  %3658 = getelementptr inbounds %struct.doublecomplex, ptr %3657, i32 0, i32 0
  %3659 = load double, ptr %3658, align 8, !tbaa !13
  %3660 = load ptr, ptr %20, align 8, !tbaa !5
  %3661 = load i32, ptr %36, align 4, !tbaa !9
  %3662 = sext i32 %3661 to i64
  %3663 = getelementptr inbounds %struct.doublecomplex, ptr %3660, i64 %3662
  %3664 = getelementptr inbounds %struct.doublecomplex, ptr %3663, i32 0, i32 1
  %3665 = load double, ptr %3664, align 8, !tbaa !15
  %3666 = load ptr, ptr %18, align 8, !tbaa !5
  %3667 = load i32, ptr %35, align 4, !tbaa !9
  %3668 = sext i32 %3667 to i64
  %3669 = getelementptr inbounds %struct.doublecomplex, ptr %3666, i64 %3668
  %3670 = getelementptr inbounds %struct.doublecomplex, ptr %3669, i32 0, i32 1
  %3671 = load double, ptr %3670, align 8, !tbaa !15
  %3672 = load ptr, ptr %20, align 8, !tbaa !5
  %3673 = load i32, ptr %36, align 4, !tbaa !9
  %3674 = sext i32 %3673 to i64
  %3675 = getelementptr inbounds %struct.doublecomplex, ptr %3672, i64 %3674
  %3676 = getelementptr inbounds %struct.doublecomplex, ptr %3675, i32 0, i32 0
  %3677 = load double, ptr %3676, align 8, !tbaa !13
  %3678 = fmul double %3671, %3677
  %3679 = call double @llvm.fmuladd.f64(double %3659, double %3665, double %3678)
  %3680 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %3679, ptr %3680, align 8, !tbaa !15
  %3681 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3682 = load double, ptr %3681, align 8, !tbaa !13
  %3683 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %3684 = load double, ptr %3683, align 8, !tbaa !13
  %3685 = fsub double %3682, %3684
  %3686 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3685, ptr %3686, align 8, !tbaa !13
  %3687 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3688 = load double, ptr %3687, align 8, !tbaa !15
  %3689 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %3690 = load double, ptr %3689, align 8, !tbaa !15
  %3691 = fsub double %3688, %3690
  %3692 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3691, ptr %3692, align 8, !tbaa !15
  %3693 = load i32, ptr %48, align 4, !tbaa !9
  store i32 %3693, ptr %37, align 4, !tbaa !9
  %3694 = load i32, ptr %48, align 4, !tbaa !9
  %3695 = add nsw i32 %3694, 1
  %3696 = load i32, ptr %49, align 4, !tbaa !9
  %3697 = load i32, ptr %27, align 4, !tbaa !9
  %3698 = mul nsw i32 %3696, %3697
  %3699 = add nsw i32 %3695, %3698
  store i32 %3699, ptr %38, align 4, !tbaa !9
  %3700 = load ptr, ptr %17, align 8, !tbaa !5
  %3701 = load i32, ptr %37, align 4, !tbaa !9
  %3702 = sext i32 %3701 to i64
  %3703 = getelementptr inbounds %struct.doublecomplex, ptr %3700, i64 %3702
  %3704 = getelementptr inbounds %struct.doublecomplex, ptr %3703, i32 0, i32 0
  %3705 = load double, ptr %3704, align 8, !tbaa !13
  %3706 = load ptr, ptr %20, align 8, !tbaa !5
  %3707 = load i32, ptr %38, align 4, !tbaa !9
  %3708 = sext i32 %3707 to i64
  %3709 = getelementptr inbounds %struct.doublecomplex, ptr %3706, i64 %3708
  %3710 = getelementptr inbounds %struct.doublecomplex, ptr %3709, i32 0, i32 0
  %3711 = load double, ptr %3710, align 8, !tbaa !13
  %3712 = load ptr, ptr %17, align 8, !tbaa !5
  %3713 = load i32, ptr %37, align 4, !tbaa !9
  %3714 = sext i32 %3713 to i64
  %3715 = getelementptr inbounds %struct.doublecomplex, ptr %3712, i64 %3714
  %3716 = getelementptr inbounds %struct.doublecomplex, ptr %3715, i32 0, i32 1
  %3717 = load double, ptr %3716, align 8, !tbaa !15
  %3718 = load ptr, ptr %20, align 8, !tbaa !5
  %3719 = load i32, ptr %38, 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 1
  %3723 = load double, ptr %3722, align 8, !tbaa !15
  %3724 = fmul double %3717, %3723
  %3725 = fneg double %3724
  %3726 = call double @llvm.fmuladd.f64(double %3705, double %3711, double %3725)
  %3727 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %3726, ptr %3727, align 8, !tbaa !13
  %3728 = load ptr, ptr %17, align 8, !tbaa !5
  %3729 = load i32, ptr %37, align 4, !tbaa !9
  %3730 = sext i32 %3729 to i64
  %3731 = getelementptr inbounds %struct.doublecomplex, ptr %3728, i64 %3730
  %3732 = getelementptr inbounds %struct.doublecomplex, ptr %3731, i32 0, i32 0
  %3733 = load double, ptr %3732, align 8, !tbaa !13
  %3734 = load ptr, ptr %20, align 8, !tbaa !5
  %3735 = load i32, ptr %38, align 4, !tbaa !9
  %3736 = sext i32 %3735 to i64
  %3737 = getelementptr inbounds %struct.doublecomplex, ptr %3734, i64 %3736
  %3738 = getelementptr inbounds %struct.doublecomplex, ptr %3737, i32 0, i32 1
  %3739 = load double, ptr %3738, align 8, !tbaa !15
  %3740 = load ptr, ptr %17, align 8, !tbaa !5
  %3741 = load i32, ptr %37, align 4, !tbaa !9
  %3742 = sext i32 %3741 to i64
  %3743 = getelementptr inbounds %struct.doublecomplex, ptr %3740, i64 %3742
  %3744 = getelementptr inbounds %struct.doublecomplex, ptr %3743, i32 0, i32 1
  %3745 = load double, ptr %3744, align 8, !tbaa !15
  %3746 = load ptr, ptr %20, align 8, !tbaa !5
  %3747 = load i32, ptr %38, align 4, !tbaa !9
  %3748 = sext i32 %3747 to i64
  %3749 = getelementptr inbounds %struct.doublecomplex, ptr %3746, i64 %3748
  %3750 = getelementptr inbounds %struct.doublecomplex, ptr %3749, i32 0, i32 0
  %3751 = load double, ptr %3750, align 8, !tbaa !13
  %3752 = fmul double %3745, %3751
  %3753 = call double @llvm.fmuladd.f64(double %3733, double %3739, double %3752)
  %3754 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %3753, ptr %3754, align 8, !tbaa !15
  %3755 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3756 = load double, ptr %3755, align 8, !tbaa !13
  %3757 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %3758 = load double, ptr %3757, align 8, !tbaa !13
  %3759 = fsub double %3756, %3758
  %3760 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3759, ptr %3760, align 8, !tbaa !13
  %3761 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3762 = load double, ptr %3761, align 8, !tbaa !15
  %3763 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %3764 = load double, ptr %3763, align 8, !tbaa !15
  %3765 = fsub double %3762, %3764
  %3766 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3765, ptr %3766, align 8, !tbaa !15
  %3767 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3768 = load double, ptr %3767, align 8, !tbaa !13
  %3769 = load ptr, ptr %23, align 8, !tbaa !5
  %3770 = load i32, ptr %31, align 4, !tbaa !9
  %3771 = sext i32 %3770 to i64
  %3772 = getelementptr inbounds %struct.doublecomplex, ptr %3769, i64 %3771
  %3773 = getelementptr inbounds %struct.doublecomplex, ptr %3772, i32 0, i32 0
  store double %3768, ptr %3773, align 8, !tbaa !13
  %3774 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3775 = load double, ptr %3774, align 8, !tbaa !15
  %3776 = load ptr, ptr %23, align 8, !tbaa !5
  %3777 = load i32, ptr %31, align 4, !tbaa !9
  %3778 = sext i32 %3777 to i64
  %3779 = getelementptr inbounds %struct.doublecomplex, ptr %3776, i64 %3778
  %3780 = getelementptr inbounds %struct.doublecomplex, ptr %3779, i32 0, i32 1
  store double %3775, ptr %3780, align 8, !tbaa !15
  br label %3781

3781:                                             ; preds = %3526
  %3782 = load i32, ptr %48, align 4, !tbaa !9
  %3783 = add nsw i32 %3782, 1
  store i32 %3783, ptr %48, align 4, !tbaa !9
  br label %3522, !llvm.loop !29

3784:                                             ; preds = %3522
  br label %3785

3785:                                             ; preds = %3784, %3082
  br label %3786

3786:                                             ; preds = %3785
  %3787 = load i32, ptr %49, align 4, !tbaa !9
  %3788 = add nsw i32 %3787, 1
  store i32 %3788, ptr %49, align 4, !tbaa !9
  br label %3074, !llvm.loop !30

3789:                                             ; preds = %3074
  br label %4487

3790:                                             ; preds = %3067
  %3791 = load ptr, ptr %13, align 8, !tbaa !5
  %3792 = call i32 @lsame_(ptr noundef %3791, ptr noundef @.str.2)
  %3793 = icmp ne i32 %3792, 0
  br i1 %3793, label %3794, label %4486

3794:                                             ; preds = %3790
  %3795 = load ptr, ptr %15, align 8, !tbaa !5
  %3796 = load i32, ptr %3795, align 4, !tbaa !9
  store i32 %3796, ptr %29, align 4, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !9
  br label %3797

3797:                                             ; preds = %4482, %3794
  %3798 = load i32, ptr %49, align 4, !tbaa !9
  %3799 = load i32, ptr %29, align 4, !tbaa !9
  %3800 = icmp sle i32 %3798, %3799
  br i1 %3800, label %3801, label %4485

3801:                                             ; preds = %3797
  %3802 = load ptr, ptr %14, align 8, !tbaa !5
  %3803 = load i32, ptr %3802, align 4, !tbaa !9
  %3804 = icmp eq i32 %3803, 1
  br i1 %3804, label %3805, label %3900

3805:                                             ; preds = %3801
  %3806 = load i32, ptr %49, align 4, !tbaa !9
  %3807 = load i32, ptr %25, align 4, !tbaa !9
  %3808 = mul nsw i32 %3806, %3807
  %3809 = add nsw i32 %3808, 1
  store i32 %3809, ptr %30, align 4, !tbaa !9
  %3810 = load i32, ptr %49, align 4, !tbaa !9
  %3811 = load i32, ptr %25, align 4, !tbaa !9
  %3812 = mul nsw i32 %3810, %3811
  %3813 = add nsw i32 %3812, 1
  store i32 %3813, ptr %31, align 4, !tbaa !9
  %3814 = load ptr, ptr %18, align 8, !tbaa !5
  %3815 = getelementptr inbounds %struct.doublecomplex, ptr %3814, i64 1
  %3816 = call { double, double } @Cd(ptr noundef %3815)
  %3817 = extractvalue { double, double } %3816, 0
  %3818 = extractvalue { double, double } %3816, 1
  %3819 = fneg double %3818
  %3820 = call ptr @_pCd(ptr noundef %41)
  %3821 = getelementptr inbounds { double, double }, ptr %3820, i32 0, i32 0
  %3822 = getelementptr inbounds { double, double }, ptr %3820, i32 0, i32 1
  store double %3817, ptr %3821, align 8
  store double %3819, ptr %3822, align 8
  %3823 = load i32, ptr %49, align 4, !tbaa !9
  %3824 = load i32, ptr %27, align 4, !tbaa !9
  %3825 = mul nsw i32 %3823, %3824
  %3826 = add nsw i32 %3825, 1
  store i32 %3826, ptr %32, align 4, !tbaa !9
  %3827 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3828 = load double, ptr %3827, align 8, !tbaa !13
  %3829 = load ptr, ptr %20, align 8, !tbaa !5
  %3830 = load i32, ptr %32, align 4, !tbaa !9
  %3831 = sext i32 %3830 to i64
  %3832 = getelementptr inbounds %struct.doublecomplex, ptr %3829, i64 %3831
  %3833 = getelementptr inbounds %struct.doublecomplex, ptr %3832, i32 0, i32 0
  %3834 = load double, ptr %3833, align 8, !tbaa !13
  %3835 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3836 = load double, ptr %3835, align 8, !tbaa !15
  %3837 = load ptr, ptr %20, align 8, !tbaa !5
  %3838 = load i32, ptr %32, align 4, !tbaa !9
  %3839 = sext i32 %3838 to i64
  %3840 = getelementptr inbounds %struct.doublecomplex, ptr %3837, i64 %3839
  %3841 = getelementptr inbounds %struct.doublecomplex, ptr %3840, i32 0, i32 1
  %3842 = load double, ptr %3841, align 8, !tbaa !15
  %3843 = fmul double %3836, %3842
  %3844 = fneg double %3843
  %3845 = call double @llvm.fmuladd.f64(double %3828, double %3834, double %3844)
  %3846 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3845, ptr %3846, align 8, !tbaa !13
  %3847 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3848 = load double, ptr %3847, align 8, !tbaa !13
  %3849 = load ptr, ptr %20, align 8, !tbaa !5
  %3850 = load i32, ptr %32, align 4, !tbaa !9
  %3851 = sext i32 %3850 to i64
  %3852 = getelementptr inbounds %struct.doublecomplex, ptr %3849, i64 %3851
  %3853 = getelementptr inbounds %struct.doublecomplex, ptr %3852, i32 0, i32 1
  %3854 = load double, ptr %3853, align 8, !tbaa !15
  %3855 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3856 = load double, ptr %3855, align 8, !tbaa !15
  %3857 = load ptr, ptr %20, align 8, !tbaa !5
  %3858 = load i32, ptr %32, align 4, !tbaa !9
  %3859 = sext i32 %3858 to i64
  %3860 = getelementptr inbounds %struct.doublecomplex, ptr %3857, i64 %3859
  %3861 = getelementptr inbounds %struct.doublecomplex, ptr %3860, i32 0, i32 0
  %3862 = load double, ptr %3861, align 8, !tbaa !13
  %3863 = fmul double %3856, %3862
  %3864 = call double @llvm.fmuladd.f64(double %3848, double %3854, double %3863)
  %3865 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3864, ptr %3865, align 8, !tbaa !15
  %3866 = load ptr, ptr %23, align 8, !tbaa !5
  %3867 = load i32, ptr %31, align 4, !tbaa !9
  %3868 = sext i32 %3867 to i64
  %3869 = getelementptr inbounds %struct.doublecomplex, ptr %3866, i64 %3868
  %3870 = getelementptr inbounds %struct.doublecomplex, ptr %3869, i32 0, i32 0
  %3871 = load double, ptr %3870, align 8, !tbaa !13
  %3872 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %3873 = load double, ptr %3872, align 8, !tbaa !13
  %3874 = fsub double %3871, %3873
  %3875 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %3874, ptr %3875, align 8, !tbaa !13
  %3876 = load ptr, ptr %23, align 8, !tbaa !5
  %3877 = load i32, ptr %31, align 4, !tbaa !9
  %3878 = sext i32 %3877 to i64
  %3879 = getelementptr inbounds %struct.doublecomplex, ptr %3876, i64 %3878
  %3880 = getelementptr inbounds %struct.doublecomplex, ptr %3879, i32 0, i32 1
  %3881 = load double, ptr %3880, align 8, !tbaa !15
  %3882 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %3883 = load double, ptr %3882, align 8, !tbaa !15
  %3884 = fsub double %3881, %3883
  %3885 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %3884, ptr %3885, align 8, !tbaa !15
  %3886 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %3887 = load double, ptr %3886, align 8, !tbaa !13
  %3888 = load ptr, ptr %23, align 8, !tbaa !5
  %3889 = load i32, ptr %30, align 4, !tbaa !9
  %3890 = sext i32 %3889 to i64
  %3891 = getelementptr inbounds %struct.doublecomplex, ptr %3888, i64 %3890
  %3892 = getelementptr inbounds %struct.doublecomplex, ptr %3891, i32 0, i32 0
  store double %3887, ptr %3892, align 8, !tbaa !13
  %3893 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %3894 = load double, ptr %3893, align 8, !tbaa !15
  %3895 = load ptr, ptr %23, align 8, !tbaa !5
  %3896 = load i32, ptr %30, align 4, !tbaa !9
  %3897 = sext i32 %3896 to i64
  %3898 = getelementptr inbounds %struct.doublecomplex, ptr %3895, i64 %3897
  %3899 = getelementptr inbounds %struct.doublecomplex, ptr %3898, i32 0, i32 1
  store double %3894, ptr %3899, align 8, !tbaa !15
  br label %4481

3900:                                             ; preds = %3801
  %3901 = load i32, ptr %49, align 4, !tbaa !9
  %3902 = load i32, ptr %25, align 4, !tbaa !9
  %3903 = mul nsw i32 %3901, %3902
  %3904 = add nsw i32 %3903, 1
  store i32 %3904, ptr %30, align 4, !tbaa !9
  %3905 = load i32, ptr %49, align 4, !tbaa !9
  %3906 = load i32, ptr %25, align 4, !tbaa !9
  %3907 = mul nsw i32 %3905, %3906
  %3908 = add nsw i32 %3907, 1
  store i32 %3908, ptr %31, align 4, !tbaa !9
  %3909 = load ptr, ptr %18, align 8, !tbaa !5
  %3910 = getelementptr inbounds %struct.doublecomplex, ptr %3909, i64 1
  %3911 = call { double, double } @Cd(ptr noundef %3910)
  %3912 = extractvalue { double, double } %3911, 0
  %3913 = extractvalue { double, double } %3911, 1
  %3914 = fneg double %3913
  %3915 = call ptr @_pCd(ptr noundef %42)
  %3916 = getelementptr inbounds { double, double }, ptr %3915, i32 0, i32 0
  %3917 = getelementptr inbounds { double, double }, ptr %3915, i32 0, i32 1
  store double %3912, ptr %3916, align 8
  store double %3914, ptr %3917, align 8
  %3918 = load i32, ptr %49, align 4, !tbaa !9
  %3919 = load i32, ptr %27, align 4, !tbaa !9
  %3920 = mul nsw i32 %3918, %3919
  %3921 = add nsw i32 %3920, 1
  store i32 %3921, ptr %32, align 4, !tbaa !9
  %3922 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3923 = load double, ptr %3922, align 8, !tbaa !13
  %3924 = load ptr, ptr %20, align 8, !tbaa !5
  %3925 = load i32, ptr %32, align 4, !tbaa !9
  %3926 = sext i32 %3925 to i64
  %3927 = getelementptr inbounds %struct.doublecomplex, ptr %3924, i64 %3926
  %3928 = getelementptr inbounds %struct.doublecomplex, ptr %3927, i32 0, i32 0
  %3929 = load double, ptr %3928, align 8, !tbaa !13
  %3930 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3931 = load double, ptr %3930, align 8, !tbaa !15
  %3932 = load ptr, ptr %20, align 8, !tbaa !5
  %3933 = load i32, ptr %32, align 4, !tbaa !9
  %3934 = sext i32 %3933 to i64
  %3935 = getelementptr inbounds %struct.doublecomplex, ptr %3932, i64 %3934
  %3936 = getelementptr inbounds %struct.doublecomplex, ptr %3935, i32 0, i32 1
  %3937 = load double, ptr %3936, align 8, !tbaa !15
  %3938 = fmul double %3931, %3937
  %3939 = fneg double %3938
  %3940 = call double @llvm.fmuladd.f64(double %3923, double %3929, double %3939)
  %3941 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %3940, ptr %3941, align 8, !tbaa !13
  %3942 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %3943 = load double, ptr %3942, align 8, !tbaa !13
  %3944 = load ptr, ptr %20, align 8, !tbaa !5
  %3945 = load i32, ptr %32, align 4, !tbaa !9
  %3946 = sext i32 %3945 to i64
  %3947 = getelementptr inbounds %struct.doublecomplex, ptr %3944, i64 %3946
  %3948 = getelementptr inbounds %struct.doublecomplex, ptr %3947, i32 0, i32 1
  %3949 = load double, ptr %3948, align 8, !tbaa !15
  %3950 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %3951 = load double, ptr %3950, align 8, !tbaa !15
  %3952 = load ptr, ptr %20, align 8, !tbaa !5
  %3953 = load i32, ptr %32, align 4, !tbaa !9
  %3954 = sext i32 %3953 to i64
  %3955 = getelementptr inbounds %struct.doublecomplex, ptr %3952, i64 %3954
  %3956 = getelementptr inbounds %struct.doublecomplex, ptr %3955, i32 0, i32 0
  %3957 = load double, ptr %3956, align 8, !tbaa !13
  %3958 = fmul double %3951, %3957
  %3959 = call double @llvm.fmuladd.f64(double %3943, double %3949, double %3958)
  %3960 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %3959, ptr %3960, align 8, !tbaa !15
  %3961 = load ptr, ptr %23, align 8, !tbaa !5
  %3962 = load i32, ptr %31, align 4, !tbaa !9
  %3963 = sext i32 %3962 to i64
  %3964 = getelementptr inbounds %struct.doublecomplex, ptr %3961, i64 %3963
  %3965 = getelementptr inbounds %struct.doublecomplex, ptr %3964, i32 0, i32 0
  %3966 = load double, ptr %3965, align 8, !tbaa !13
  %3967 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %3968 = load double, ptr %3967, align 8, !tbaa !13
  %3969 = fsub double %3966, %3968
  %3970 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %3969, ptr %3970, align 8, !tbaa !13
  %3971 = load ptr, ptr %23, align 8, !tbaa !5
  %3972 = load i32, ptr %31, align 4, !tbaa !9
  %3973 = sext i32 %3972 to i64
  %3974 = getelementptr inbounds %struct.doublecomplex, ptr %3971, i64 %3973
  %3975 = getelementptr inbounds %struct.doublecomplex, ptr %3974, i32 0, i32 1
  %3976 = load double, ptr %3975, align 8, !tbaa !15
  %3977 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %3978 = load double, ptr %3977, align 8, !tbaa !15
  %3979 = fsub double %3976, %3978
  %3980 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %3979, ptr %3980, align 8, !tbaa !15
  %3981 = load ptr, ptr %17, align 8, !tbaa !5
  %3982 = getelementptr inbounds %struct.doublecomplex, ptr %3981, i64 1
  %3983 = call { double, double } @Cd(ptr noundef %3982)
  %3984 = extractvalue { double, double } %3983, 0
  %3985 = extractvalue { double, double } %3983, 1
  %3986 = fneg double %3985
  %3987 = call ptr @_pCd(ptr noundef %44)
  %3988 = getelementptr inbounds { double, double }, ptr %3987, i32 0, i32 0
  %3989 = getelementptr inbounds { double, double }, ptr %3987, i32 0, i32 1
  store double %3984, ptr %3988, align 8
  store double %3986, ptr %3989, align 8
  %3990 = load i32, ptr %49, align 4, !tbaa !9
  %3991 = load i32, ptr %27, align 4, !tbaa !9
  %3992 = mul nsw i32 %3990, %3991
  %3993 = add nsw i32 %3992, 2
  store i32 %3993, ptr %33, align 4, !tbaa !9
  %3994 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %3995 = load double, ptr %3994, align 8, !tbaa !13
  %3996 = load ptr, ptr %20, align 8, !tbaa !5
  %3997 = load i32, ptr %33, align 4, !tbaa !9
  %3998 = sext i32 %3997 to i64
  %3999 = getelementptr inbounds %struct.doublecomplex, ptr %3996, i64 %3998
  %4000 = getelementptr inbounds %struct.doublecomplex, ptr %3999, i32 0, i32 0
  %4001 = load double, ptr %4000, align 8, !tbaa !13
  %4002 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %4003 = load double, ptr %4002, align 8, !tbaa !15
  %4004 = load ptr, ptr %20, align 8, !tbaa !5
  %4005 = load i32, ptr %33, align 4, !tbaa !9
  %4006 = sext i32 %4005 to i64
  %4007 = getelementptr inbounds %struct.doublecomplex, ptr %4004, i64 %4006
  %4008 = getelementptr inbounds %struct.doublecomplex, ptr %4007, i32 0, i32 1
  %4009 = load double, ptr %4008, align 8, !tbaa !15
  %4010 = fmul double %4003, %4009
  %4011 = fneg double %4010
  %4012 = call double @llvm.fmuladd.f64(double %3995, double %4001, double %4011)
  %4013 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %4012, ptr %4013, align 8, !tbaa !13
  %4014 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %4015 = load double, ptr %4014, align 8, !tbaa !13
  %4016 = load ptr, ptr %20, align 8, !tbaa !5
  %4017 = load i32, ptr %33, align 4, !tbaa !9
  %4018 = sext i32 %4017 to i64
  %4019 = getelementptr inbounds %struct.doublecomplex, ptr %4016, i64 %4018
  %4020 = getelementptr inbounds %struct.doublecomplex, ptr %4019, i32 0, i32 1
  %4021 = load double, ptr %4020, align 8, !tbaa !15
  %4022 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %4023 = load double, ptr %4022, align 8, !tbaa !15
  %4024 = load ptr, ptr %20, align 8, !tbaa !5
  %4025 = load i32, ptr %33, align 4, !tbaa !9
  %4026 = sext i32 %4025 to i64
  %4027 = getelementptr inbounds %struct.doublecomplex, ptr %4024, i64 %4026
  %4028 = getelementptr inbounds %struct.doublecomplex, ptr %4027, i32 0, i32 0
  %4029 = load double, ptr %4028, align 8, !tbaa !13
  %4030 = fmul double %4023, %4029
  %4031 = call double @llvm.fmuladd.f64(double %4015, double %4021, double %4030)
  %4032 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %4031, ptr %4032, align 8, !tbaa !15
  %4033 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %4034 = load double, ptr %4033, align 8, !tbaa !13
  %4035 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %4036 = load double, ptr %4035, align 8, !tbaa !13
  %4037 = fsub double %4034, %4036
  %4038 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %4037, ptr %4038, align 8, !tbaa !13
  %4039 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %4040 = load double, ptr %4039, align 8, !tbaa !15
  %4041 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %4042 = load double, ptr %4041, align 8, !tbaa !15
  %4043 = fsub double %4040, %4042
  %4044 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %4043, ptr %4044, align 8, !tbaa !15
  %4045 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %4046 = load double, ptr %4045, align 8, !tbaa !13
  %4047 = load ptr, ptr %23, align 8, !tbaa !5
  %4048 = load i32, ptr %30, align 4, !tbaa !9
  %4049 = sext i32 %4048 to i64
  %4050 = getelementptr inbounds %struct.doublecomplex, ptr %4047, i64 %4049
  %4051 = getelementptr inbounds %struct.doublecomplex, ptr %4050, i32 0, i32 0
  store double %4046, ptr %4051, align 8, !tbaa !13
  %4052 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %4053 = load double, ptr %4052, align 8, !tbaa !15
  %4054 = load ptr, ptr %23, align 8, !tbaa !5
  %4055 = load i32, ptr %30, align 4, !tbaa !9
  %4056 = sext i32 %4055 to i64
  %4057 = getelementptr inbounds %struct.doublecomplex, ptr %4054, i64 %4056
  %4058 = getelementptr inbounds %struct.doublecomplex, ptr %4057, i32 0, i32 1
  store double %4053, ptr %4058, align 8, !tbaa !15
  %4059 = load ptr, ptr %14, align 8, !tbaa !5
  %4060 = load i32, ptr %4059, align 4, !tbaa !9
  %4061 = load i32, ptr %49, align 4, !tbaa !9
  %4062 = load i32, ptr %25, align 4, !tbaa !9
  %4063 = mul nsw i32 %4061, %4062
  %4064 = add nsw i32 %4060, %4063
  store i32 %4064, ptr %30, align 4, !tbaa !9
  %4065 = load ptr, ptr %14, align 8, !tbaa !5
  %4066 = load i32, ptr %4065, align 4, !tbaa !9
  %4067 = load i32, ptr %49, align 4, !tbaa !9
  %4068 = load i32, ptr %25, align 4, !tbaa !9
  %4069 = mul nsw i32 %4067, %4068
  %4070 = add nsw i32 %4066, %4069
  store i32 %4070, ptr %31, align 4, !tbaa !9
  %4071 = load ptr, ptr %19, align 8, !tbaa !5
  %4072 = load ptr, ptr %14, align 8, !tbaa !5
  %4073 = load i32, ptr %4072, align 4, !tbaa !9
  %4074 = sub nsw i32 %4073, 1
  %4075 = sext i32 %4074 to i64
  %4076 = getelementptr inbounds %struct.doublecomplex, ptr %4071, i64 %4075
  %4077 = call { double, double } @Cd(ptr noundef %4076)
  %4078 = extractvalue { double, double } %4077, 0
  %4079 = extractvalue { double, double } %4077, 1
  %4080 = fneg double %4079
  %4081 = call ptr @_pCd(ptr noundef %42)
  %4082 = getelementptr inbounds { double, double }, ptr %4081, i32 0, i32 0
  %4083 = getelementptr inbounds { double, double }, ptr %4081, i32 0, i32 1
  store double %4078, ptr %4082, align 8
  store double %4080, ptr %4083, align 8
  %4084 = load ptr, ptr %14, align 8, !tbaa !5
  %4085 = load i32, ptr %4084, align 4, !tbaa !9
  %4086 = sub nsw i32 %4085, 1
  %4087 = load i32, ptr %49, align 4, !tbaa !9
  %4088 = load i32, ptr %27, align 4, !tbaa !9
  %4089 = mul nsw i32 %4087, %4088
  %4090 = add nsw i32 %4086, %4089
  store i32 %4090, ptr %32, align 4, !tbaa !9
  %4091 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %4092 = load double, ptr %4091, align 8, !tbaa !13
  %4093 = load ptr, ptr %20, align 8, !tbaa !5
  %4094 = load i32, ptr %32, align 4, !tbaa !9
  %4095 = sext i32 %4094 to i64
  %4096 = getelementptr inbounds %struct.doublecomplex, ptr %4093, i64 %4095
  %4097 = getelementptr inbounds %struct.doublecomplex, ptr %4096, i32 0, i32 0
  %4098 = load double, ptr %4097, align 8, !tbaa !13
  %4099 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %4100 = load double, ptr %4099, align 8, !tbaa !15
  %4101 = load ptr, ptr %20, align 8, !tbaa !5
  %4102 = load i32, ptr %32, align 4, !tbaa !9
  %4103 = sext i32 %4102 to i64
  %4104 = getelementptr inbounds %struct.doublecomplex, ptr %4101, i64 %4103
  %4105 = getelementptr inbounds %struct.doublecomplex, ptr %4104, i32 0, i32 1
  %4106 = load double, ptr %4105, align 8, !tbaa !15
  %4107 = fmul double %4100, %4106
  %4108 = fneg double %4107
  %4109 = call double @llvm.fmuladd.f64(double %4092, double %4098, double %4108)
  %4110 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %4109, ptr %4110, align 8, !tbaa !13
  %4111 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %4112 = load double, ptr %4111, align 8, !tbaa !13
  %4113 = load ptr, ptr %20, align 8, !tbaa !5
  %4114 = load i32, ptr %32, align 4, !tbaa !9
  %4115 = sext i32 %4114 to i64
  %4116 = getelementptr inbounds %struct.doublecomplex, ptr %4113, i64 %4115
  %4117 = getelementptr inbounds %struct.doublecomplex, ptr %4116, i32 0, i32 1
  %4118 = load double, ptr %4117, align 8, !tbaa !15
  %4119 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %4120 = load double, ptr %4119, align 8, !tbaa !15
  %4121 = load ptr, ptr %20, align 8, !tbaa !5
  %4122 = load i32, ptr %32, align 4, !tbaa !9
  %4123 = sext i32 %4122 to i64
  %4124 = getelementptr inbounds %struct.doublecomplex, ptr %4121, i64 %4123
  %4125 = getelementptr inbounds %struct.doublecomplex, ptr %4124, i32 0, i32 0
  %4126 = load double, ptr %4125, align 8, !tbaa !13
  %4127 = fmul double %4120, %4126
  %4128 = call double @llvm.fmuladd.f64(double %4112, double %4118, double %4127)
  %4129 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %4128, ptr %4129, align 8, !tbaa !15
  %4130 = load ptr, ptr %23, align 8, !tbaa !5
  %4131 = load i32, ptr %31, align 4, !tbaa !9
  %4132 = sext i32 %4131 to i64
  %4133 = getelementptr inbounds %struct.doublecomplex, ptr %4130, i64 %4132
  %4134 = getelementptr inbounds %struct.doublecomplex, ptr %4133, i32 0, i32 0
  %4135 = load double, ptr %4134, align 8, !tbaa !13
  %4136 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %4137 = load double, ptr %4136, align 8, !tbaa !13
  %4138 = fsub double %4135, %4137
  %4139 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %4138, ptr %4139, align 8, !tbaa !13
  %4140 = load ptr, ptr %23, align 8, !tbaa !5
  %4141 = load i32, ptr %31, align 4, !tbaa !9
  %4142 = sext i32 %4141 to i64
  %4143 = getelementptr inbounds %struct.doublecomplex, ptr %4140, i64 %4142
  %4144 = getelementptr inbounds %struct.doublecomplex, ptr %4143, i32 0, i32 1
  %4145 = load double, ptr %4144, align 8, !tbaa !15
  %4146 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %4147 = load double, ptr %4146, align 8, !tbaa !15
  %4148 = fsub double %4145, %4147
  %4149 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %4148, ptr %4149, align 8, !tbaa !15
  %4150 = load ptr, ptr %18, align 8, !tbaa !5
  %4151 = load ptr, ptr %14, align 8, !tbaa !5
  %4152 = load i32, ptr %4151, align 4, !tbaa !9
  %4153 = sext i32 %4152 to i64
  %4154 = getelementptr inbounds %struct.doublecomplex, ptr %4150, i64 %4153
  %4155 = call { double, double } @Cd(ptr noundef %4154)
  %4156 = extractvalue { double, double } %4155, 0
  %4157 = extractvalue { double, double } %4155, 1
  %4158 = fneg double %4157
  %4159 = call ptr @_pCd(ptr noundef %44)
  %4160 = getelementptr inbounds { double, double }, ptr %4159, i32 0, i32 0
  %4161 = getelementptr inbounds { double, double }, ptr %4159, i32 0, i32 1
  store double %4156, ptr %4160, align 8
  store double %4158, ptr %4161, align 8
  %4162 = load ptr, ptr %14, align 8, !tbaa !5
  %4163 = load i32, ptr %4162, align 4, !tbaa !9
  %4164 = load i32, ptr %49, align 4, !tbaa !9
  %4165 = load i32, ptr %27, align 4, !tbaa !9
  %4166 = mul nsw i32 %4164, %4165
  %4167 = add nsw i32 %4163, %4166
  store i32 %4167, ptr %33, align 4, !tbaa !9
  %4168 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %4169 = load double, ptr %4168, align 8, !tbaa !13
  %4170 = load ptr, ptr %20, align 8, !tbaa !5
  %4171 = load i32, ptr %33, align 4, !tbaa !9
  %4172 = sext i32 %4171 to i64
  %4173 = getelementptr inbounds %struct.doublecomplex, ptr %4170, i64 %4172
  %4174 = getelementptr inbounds %struct.doublecomplex, ptr %4173, i32 0, i32 0
  %4175 = load double, ptr %4174, align 8, !tbaa !13
  %4176 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %4177 = load double, ptr %4176, align 8, !tbaa !15
  %4178 = load ptr, ptr %20, align 8, !tbaa !5
  %4179 = load i32, ptr %33, align 4, !tbaa !9
  %4180 = sext i32 %4179 to i64
  %4181 = getelementptr inbounds %struct.doublecomplex, ptr %4178, i64 %4180
  %4182 = getelementptr inbounds %struct.doublecomplex, ptr %4181, i32 0, i32 1
  %4183 = load double, ptr %4182, align 8, !tbaa !15
  %4184 = fmul double %4177, %4183
  %4185 = fneg double %4184
  %4186 = call double @llvm.fmuladd.f64(double %4169, double %4175, double %4185)
  %4187 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  store double %4186, ptr %4187, align 8, !tbaa !13
  %4188 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %4189 = load double, ptr %4188, align 8, !tbaa !13
  %4190 = load ptr, ptr %20, align 8, !tbaa !5
  %4191 = load i32, ptr %33, align 4, !tbaa !9
  %4192 = sext i32 %4191 to i64
  %4193 = getelementptr inbounds %struct.doublecomplex, ptr %4190, i64 %4192
  %4194 = getelementptr inbounds %struct.doublecomplex, ptr %4193, i32 0, i32 1
  %4195 = load double, ptr %4194, align 8, !tbaa !15
  %4196 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %4197 = load double, ptr %4196, align 8, !tbaa !15
  %4198 = load ptr, ptr %20, align 8, !tbaa !5
  %4199 = load i32, ptr %33, align 4, !tbaa !9
  %4200 = sext i32 %4199 to i64
  %4201 = getelementptr inbounds %struct.doublecomplex, ptr %4198, i64 %4200
  %4202 = getelementptr inbounds %struct.doublecomplex, ptr %4201, i32 0, i32 0
  %4203 = load double, ptr %4202, align 8, !tbaa !13
  %4204 = fmul double %4197, %4203
  %4205 = call double @llvm.fmuladd.f64(double %4189, double %4195, double %4204)
  %4206 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  store double %4205, ptr %4206, align 8, !tbaa !15
  %4207 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %4208 = load double, ptr %4207, align 8, !tbaa !13
  %4209 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %4210 = load double, ptr %4209, align 8, !tbaa !13
  %4211 = fsub double %4208, %4210
  %4212 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %4211, ptr %4212, align 8, !tbaa !13
  %4213 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %4214 = load double, ptr %4213, align 8, !tbaa !15
  %4215 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %4216 = load double, ptr %4215, align 8, !tbaa !15
  %4217 = fsub double %4214, %4216
  %4218 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %4217, ptr %4218, align 8, !tbaa !15
  %4219 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %4220 = load double, ptr %4219, align 8, !tbaa !13
  %4221 = load ptr, ptr %23, align 8, !tbaa !5
  %4222 = load i32, ptr %30, align 4, !tbaa !9
  %4223 = sext i32 %4222 to i64
  %4224 = getelementptr inbounds %struct.doublecomplex, ptr %4221, i64 %4223
  %4225 = getelementptr inbounds %struct.doublecomplex, ptr %4224, i32 0, i32 0
  store double %4220, ptr %4225, align 8, !tbaa !13
  %4226 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %4227 = load double, ptr %4226, align 8, !tbaa !15
  %4228 = load ptr, ptr %23, align 8, !tbaa !5
  %4229 = load i32, ptr %30, align 4, !tbaa !9
  %4230 = sext i32 %4229 to i64
  %4231 = getelementptr inbounds %struct.doublecomplex, ptr %4228, i64 %4230
  %4232 = getelementptr inbounds %struct.doublecomplex, ptr %4231, i32 0, i32 1
  store double %4227, ptr %4232, align 8, !tbaa !15
  %4233 = load ptr, ptr %14, align 8, !tbaa !5
  %4234 = load i32, ptr %4233, align 4, !tbaa !9
  %4235 = sub nsw i32 %4234, 1
  store i32 %4235, ptr %30, align 4, !tbaa !9
  store i32 2, ptr %48, align 4, !tbaa !9
  br label %4236

4236:                                             ; preds = %4477, %3900
  %4237 = load i32, ptr %48, align 4, !tbaa !9
  %4238 = load i32, ptr %30, align 4, !tbaa !9
  %4239 = icmp sle i32 %4237, %4238
  br i1 %4239, label %4240, label %4480

4240:                                             ; preds = %4236
  %4241 = load i32, ptr %48, align 4, !tbaa !9
  %4242 = load i32, ptr %49, align 4, !tbaa !9
  %4243 = load i32, ptr %25, align 4, !tbaa !9
  %4244 = mul nsw i32 %4242, %4243
  %4245 = add nsw i32 %4241, %4244
  store i32 %4245, ptr %31, align 4, !tbaa !9
  %4246 = load i32, ptr %48, align 4, !tbaa !9
  %4247 = load i32, ptr %49, align 4, !tbaa !9
  %4248 = load i32, ptr %25, align 4, !tbaa !9
  %4249 = mul nsw i32 %4247, %4248
  %4250 = add nsw i32 %4246, %4249
  store i32 %4250, ptr %32, align 4, !tbaa !9
  %4251 = load ptr, ptr %19, align 8, !tbaa !5
  %4252 = load i32, ptr %48, align 4, !tbaa !9
  %4253 = sub nsw i32 %4252, 1
  %4254 = sext i32 %4253 to i64
  %4255 = getelementptr inbounds %struct.doublecomplex, ptr %4251, i64 %4254
  %4256 = call { double, double } @Cd(ptr noundef %4255)
  %4257 = extractvalue { double, double } %4256, 0
  %4258 = extractvalue { double, double } %4256, 1
  %4259 = fneg double %4258
  %4260 = call ptr @_pCd(ptr noundef %43)
  %4261 = getelementptr inbounds { double, double }, ptr %4260, i32 0, i32 0
  %4262 = getelementptr inbounds { double, double }, ptr %4260, i32 0, i32 1
  store double %4257, ptr %4261, align 8
  store double %4259, ptr %4262, align 8
  %4263 = load i32, ptr %48, align 4, !tbaa !9
  %4264 = sub nsw i32 %4263, 1
  %4265 = load i32, ptr %49, align 4, !tbaa !9
  %4266 = load i32, ptr %27, align 4, !tbaa !9
  %4267 = mul nsw i32 %4265, %4266
  %4268 = add nsw i32 %4264, %4267
  store i32 %4268, ptr %33, align 4, !tbaa !9
  %4269 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %4270 = load double, ptr %4269, align 8, !tbaa !13
  %4271 = load ptr, ptr %20, align 8, !tbaa !5
  %4272 = load i32, ptr %33, align 4, !tbaa !9
  %4273 = sext i32 %4272 to i64
  %4274 = getelementptr inbounds %struct.doublecomplex, ptr %4271, i64 %4273
  %4275 = getelementptr inbounds %struct.doublecomplex, ptr %4274, i32 0, i32 0
  %4276 = load double, ptr %4275, align 8, !tbaa !13
  %4277 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %4278 = load double, ptr %4277, align 8, !tbaa !15
  %4279 = load ptr, ptr %20, align 8, !tbaa !5
  %4280 = load i32, ptr %33, align 4, !tbaa !9
  %4281 = sext i32 %4280 to i64
  %4282 = getelementptr inbounds %struct.doublecomplex, ptr %4279, i64 %4281
  %4283 = getelementptr inbounds %struct.doublecomplex, ptr %4282, i32 0, i32 1
  %4284 = load double, ptr %4283, align 8, !tbaa !15
  %4285 = fmul double %4278, %4284
  %4286 = fneg double %4285
  %4287 = call double @llvm.fmuladd.f64(double %4270, double %4276, double %4286)
  %4288 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  store double %4287, ptr %4288, align 8, !tbaa !13
  %4289 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 0
  %4290 = load double, ptr %4289, align 8, !tbaa !13
  %4291 = load ptr, ptr %20, align 8, !tbaa !5
  %4292 = load i32, ptr %33, align 4, !tbaa !9
  %4293 = sext i32 %4292 to i64
  %4294 = getelementptr inbounds %struct.doublecomplex, ptr %4291, i64 %4293
  %4295 = getelementptr inbounds %struct.doublecomplex, ptr %4294, i32 0, i32 1
  %4296 = load double, ptr %4295, align 8, !tbaa !15
  %4297 = getelementptr inbounds %struct.doublecomplex, ptr %43, i32 0, i32 1
  %4298 = load double, ptr %4297, align 8, !tbaa !15
  %4299 = load ptr, ptr %20, align 8, !tbaa !5
  %4300 = load i32, ptr %33, align 4, !tbaa !9
  %4301 = sext i32 %4300 to i64
  %4302 = getelementptr inbounds %struct.doublecomplex, ptr %4299, i64 %4301
  %4303 = getelementptr inbounds %struct.doublecomplex, ptr %4302, i32 0, i32 0
  %4304 = load double, ptr %4303, align 8, !tbaa !13
  %4305 = fmul double %4298, %4304
  %4306 = call double @llvm.fmuladd.f64(double %4290, double %4296, double %4305)
  %4307 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  store double %4306, ptr %4307, align 8, !tbaa !15
  %4308 = load ptr, ptr %23, align 8, !tbaa !5
  %4309 = load i32, ptr %32, align 4, !tbaa !9
  %4310 = sext i32 %4309 to i64
  %4311 = getelementptr inbounds %struct.doublecomplex, ptr %4308, i64 %4310
  %4312 = getelementptr inbounds %struct.doublecomplex, ptr %4311, i32 0, i32 0
  %4313 = load double, ptr %4312, align 8, !tbaa !13
  %4314 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 0
  %4315 = load double, ptr %4314, align 8, !tbaa !13
  %4316 = fsub double %4313, %4315
  %4317 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %4316, ptr %4317, align 8, !tbaa !13
  %4318 = load ptr, ptr %23, align 8, !tbaa !5
  %4319 = load i32, ptr %32, align 4, !tbaa !9
  %4320 = sext i32 %4319 to i64
  %4321 = getelementptr inbounds %struct.doublecomplex, ptr %4318, i64 %4320
  %4322 = getelementptr inbounds %struct.doublecomplex, ptr %4321, i32 0, i32 1
  %4323 = load double, ptr %4322, align 8, !tbaa !15
  %4324 = getelementptr inbounds %struct.doublecomplex, ptr %42, i32 0, i32 1
  %4325 = load double, ptr %4324, align 8, !tbaa !15
  %4326 = fsub double %4323, %4325
  %4327 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double %4326, ptr %4327, align 8, !tbaa !15
  %4328 = load ptr, ptr %18, align 8, !tbaa !5
  %4329 = load i32, ptr %48, align 4, !tbaa !9
  %4330 = sext i32 %4329 to i64
  %4331 = getelementptr inbounds %struct.doublecomplex, ptr %4328, i64 %4330
  %4332 = call { double, double } @Cd(ptr noundef %4331)
  %4333 = extractvalue { double, double } %4332, 0
  %4334 = extractvalue { double, double } %4332, 1
  %4335 = fneg double %4334
  %4336 = call ptr @_pCd(ptr noundef %45)
  %4337 = getelementptr inbounds { double, double }, ptr %4336, i32 0, i32 0
  %4338 = getelementptr inbounds { double, double }, ptr %4336, i32 0, i32 1
  store double %4333, ptr %4337, align 8
  store double %4335, ptr %4338, align 8
  %4339 = load i32, ptr %48, align 4, !tbaa !9
  %4340 = load i32, ptr %49, align 4, !tbaa !9
  %4341 = load i32, ptr %27, align 4, !tbaa !9
  %4342 = mul nsw i32 %4340, %4341
  %4343 = add nsw i32 %4339, %4342
  store i32 %4343, ptr %34, align 4, !tbaa !9
  %4344 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %4345 = load double, ptr %4344, align 8, !tbaa !13
  %4346 = load ptr, ptr %20, align 8, !tbaa !5
  %4347 = load i32, ptr %34, align 4, !tbaa !9
  %4348 = sext i32 %4347 to i64
  %4349 = getelementptr inbounds %struct.doublecomplex, ptr %4346, i64 %4348
  %4350 = getelementptr inbounds %struct.doublecomplex, ptr %4349, i32 0, i32 0
  %4351 = load double, ptr %4350, align 8, !tbaa !13
  %4352 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %4353 = load double, ptr %4352, align 8, !tbaa !15
  %4354 = load ptr, ptr %20, align 8, !tbaa !5
  %4355 = load i32, ptr %34, align 4, !tbaa !9
  %4356 = sext i32 %4355 to i64
  %4357 = getelementptr inbounds %struct.doublecomplex, ptr %4354, i64 %4356
  %4358 = getelementptr inbounds %struct.doublecomplex, ptr %4357, i32 0, i32 1
  %4359 = load double, ptr %4358, align 8, !tbaa !15
  %4360 = fmul double %4353, %4359
  %4361 = fneg double %4360
  %4362 = call double @llvm.fmuladd.f64(double %4345, double %4351, double %4361)
  %4363 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %4362, ptr %4363, align 8, !tbaa !13
  %4364 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 0
  %4365 = load double, ptr %4364, align 8, !tbaa !13
  %4366 = load ptr, ptr %20, align 8, !tbaa !5
  %4367 = load i32, ptr %34, align 4, !tbaa !9
  %4368 = sext i32 %4367 to i64
  %4369 = getelementptr inbounds %struct.doublecomplex, ptr %4366, i64 %4368
  %4370 = getelementptr inbounds %struct.doublecomplex, ptr %4369, i32 0, i32 1
  %4371 = load double, ptr %4370, align 8, !tbaa !15
  %4372 = getelementptr inbounds %struct.doublecomplex, ptr %45, i32 0, i32 1
  %4373 = load double, ptr %4372, align 8, !tbaa !15
  %4374 = load ptr, ptr %20, align 8, !tbaa !5
  %4375 = load i32, ptr %34, align 4, !tbaa !9
  %4376 = sext i32 %4375 to i64
  %4377 = getelementptr inbounds %struct.doublecomplex, ptr %4374, i64 %4376
  %4378 = getelementptr inbounds %struct.doublecomplex, ptr %4377, i32 0, i32 0
  %4379 = load double, ptr %4378, align 8, !tbaa !13
  %4380 = fmul double %4373, %4379
  %4381 = call double @llvm.fmuladd.f64(double %4365, double %4371, double %4380)
  %4382 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %4381, ptr %4382, align 8, !tbaa !15
  %4383 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %4384 = load double, ptr %4383, align 8, !tbaa !13
  %4385 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %4386 = load double, ptr %4385, align 8, !tbaa !13
  %4387 = fsub double %4384, %4386
  %4388 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  store double %4387, ptr %4388, align 8, !tbaa !13
  %4389 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %4390 = load double, ptr %4389, align 8, !tbaa !15
  %4391 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %4392 = load double, ptr %4391, align 8, !tbaa !15
  %4393 = fsub double %4390, %4392
  %4394 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  store double %4393, ptr %4394, align 8, !tbaa !15
  %4395 = load ptr, ptr %17, align 8, !tbaa !5
  %4396 = load i32, ptr %48, align 4, !tbaa !9
  %4397 = sext i32 %4396 to i64
  %4398 = getelementptr inbounds %struct.doublecomplex, ptr %4395, i64 %4397
  %4399 = call { double, double } @Cd(ptr noundef %4398)
  %4400 = extractvalue { double, double } %4399, 0
  %4401 = extractvalue { double, double } %4399, 1
  %4402 = fneg double %4401
  %4403 = call ptr @_pCd(ptr noundef %47)
  %4404 = getelementptr inbounds { double, double }, ptr %4403, i32 0, i32 0
  %4405 = getelementptr inbounds { double, double }, ptr %4403, i32 0, i32 1
  store double %4400, ptr %4404, align 8
  store double %4402, ptr %4405, align 8
  %4406 = load i32, ptr %48, align 4, !tbaa !9
  %4407 = add nsw i32 %4406, 1
  %4408 = load i32, ptr %49, align 4, !tbaa !9
  %4409 = load i32, ptr %27, align 4, !tbaa !9
  %4410 = mul nsw i32 %4408, %4409
  %4411 = add nsw i32 %4407, %4410
  store i32 %4411, ptr %35, align 4, !tbaa !9
  %4412 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %4413 = load double, ptr %4412, align 8, !tbaa !13
  %4414 = load ptr, ptr %20, align 8, !tbaa !5
  %4415 = load i32, ptr %35, align 4, !tbaa !9
  %4416 = sext i32 %4415 to i64
  %4417 = getelementptr inbounds %struct.doublecomplex, ptr %4414, i64 %4416
  %4418 = getelementptr inbounds %struct.doublecomplex, ptr %4417, i32 0, i32 0
  %4419 = load double, ptr %4418, align 8, !tbaa !13
  %4420 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %4421 = load double, ptr %4420, align 8, !tbaa !15
  %4422 = load ptr, ptr %20, align 8, !tbaa !5
  %4423 = load i32, ptr %35, align 4, !tbaa !9
  %4424 = sext i32 %4423 to i64
  %4425 = getelementptr inbounds %struct.doublecomplex, ptr %4422, i64 %4424
  %4426 = getelementptr inbounds %struct.doublecomplex, ptr %4425, i32 0, i32 1
  %4427 = load double, ptr %4426, align 8, !tbaa !15
  %4428 = fmul double %4421, %4427
  %4429 = fneg double %4428
  %4430 = call double @llvm.fmuladd.f64(double %4413, double %4419, double %4429)
  %4431 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 0
  store double %4430, ptr %4431, align 8, !tbaa !13
  %4432 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %4433 = load double, ptr %4432, align 8, !tbaa !13
  %4434 = load ptr, ptr %20, align 8, !tbaa !5
  %4435 = load i32, ptr %35, align 4, !tbaa !9
  %4436 = sext i32 %4435 to i64
  %4437 = getelementptr inbounds %struct.doublecomplex, ptr %4434, i64 %4436
  %4438 = getelementptr inbounds %struct.doublecomplex, ptr %4437, i32 0, i32 1
  %4439 = load double, ptr %4438, align 8, !tbaa !15
  %4440 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %4441 = load double, ptr %4440, align 8, !tbaa !15
  %4442 = load ptr, ptr %20, align 8, !tbaa !5
  %4443 = load i32, ptr %35, align 4, !tbaa !9
  %4444 = sext i32 %4443 to i64
  %4445 = getelementptr inbounds %struct.doublecomplex, ptr %4442, i64 %4444
  %4446 = getelementptr inbounds %struct.doublecomplex, ptr %4445, i32 0, i32 0
  %4447 = load double, ptr %4446, align 8, !tbaa !13
  %4448 = fmul double %4441, %4447
  %4449 = call double @llvm.fmuladd.f64(double %4433, double %4439, double %4448)
  %4450 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 1
  store double %4449, ptr %4450, align 8, !tbaa !15
  %4451 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 0
  %4452 = load double, ptr %4451, align 8, !tbaa !13
  %4453 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 0
  %4454 = load double, ptr %4453, align 8, !tbaa !13
  %4455 = fsub double %4452, %4454
  %4456 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %4455, ptr %4456, align 8, !tbaa !13
  %4457 = getelementptr inbounds %struct.doublecomplex, ptr %40, i32 0, i32 1
  %4458 = load double, ptr %4457, align 8, !tbaa !15
  %4459 = getelementptr inbounds %struct.doublecomplex, ptr %46, i32 0, i32 1
  %4460 = load double, ptr %4459, align 8, !tbaa !15
  %4461 = fsub double %4458, %4460
  %4462 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %4461, ptr %4462, align 8, !tbaa !15
  %4463 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  %4464 = load double, ptr %4463, align 8, !tbaa !13
  %4465 = load ptr, ptr %23, align 8, !tbaa !5
  %4466 = load i32, ptr %31, align 4, !tbaa !9
  %4467 = sext i32 %4466 to i64
  %4468 = getelementptr inbounds %struct.doublecomplex, ptr %4465, i64 %4467
  %4469 = getelementptr inbounds %struct.doublecomplex, ptr %4468, i32 0, i32 0
  store double %4464, ptr %4469, align 8, !tbaa !13
  %4470 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  %4471 = load double, ptr %4470, align 8, !tbaa !15
  %4472 = load ptr, ptr %23, align 8, !tbaa !5
  %4473 = load i32, ptr %31, align 4, !tbaa !9
  %4474 = sext i32 %4473 to i64
  %4475 = getelementptr inbounds %struct.doublecomplex, ptr %4472, i64 %4474
  %4476 = getelementptr inbounds %struct.doublecomplex, ptr %4475, i32 0, i32 1
  store double %4471, ptr %4476, align 8, !tbaa !15
  br label %4477

4477:                                             ; preds = %4240
  %4478 = load i32, ptr %48, align 4, !tbaa !9
  %4479 = add nsw i32 %4478, 1
  store i32 %4479, ptr %48, align 4, !tbaa !9
  br label %4236, !llvm.loop !31

4480:                                             ; preds = %4236
  br label %4481

4481:                                             ; preds = %4480, %3805
  br label %4482

4482:                                             ; preds = %4481
  %4483 = load i32, ptr %49, align 4, !tbaa !9
  %4484 = add nsw i32 %4483, 1
  store i32 %4484, ptr %49, align 4, !tbaa !9
  br label %3797, !llvm.loop !32

4485:                                             ; preds = %3797
  br label %4486

4486:                                             ; preds = %4485, %3790
  br label %4487

4487:                                             ; preds = %4486, %3789
  br label %4488

4488:                                             ; preds = %4487, %3066
  br label %4489

4489:                                             ; preds = %4488, %2340
  br label %4490

4490:                                             ; preds = %4489, %2339
  store i32 1, ptr %50, align 4
  br label %4491

4491:                                             ; preds = %4490, %80
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %47) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %46) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %45) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %44) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %43) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %42) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %40) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #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 i32 @lsame_(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

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


; 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 [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1

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

30:                                               ; preds = %12
  %31 = load double, ptr %9, align 8, !tbaa !9
  %32 = fcmp oeq double %31, 0.000000e+00
  br i1 %32, label %33, label %54

33:                                               ; preds = %30
  %34 = load i32, ptr %2, align 4, !tbaa !5
  %.not12981339 = icmp slt i32 %34, 1
  %.not13171336 = icmp slt i32 %28, 1
  %or.cond = or i1 %.not12981339, %.not13171336
  br i1 %or.cond, label %.loopexit1329, label %.preheader.preheader

.preheader.preheader:                             ; preds = %33
  %35 = add i32 %25, 1
  %36 = sext i32 %35 to i64
  %37 = add nsw i64 %26, %36
  %38 = shl nsw i64 %37, 4
  %39 = sext i32 %25 to i64
  %40 = shl nsw i64 %39, 4
  %41 = zext nneg i32 %28 to i64
  %42 = shl nuw nsw i64 %41, 4
  %wide.trip.count1682 = zext nneg i32 %34 to i64
  %43 = getelementptr i8, ptr %10, i64 %38
  %44 = add nsw i64 %wide.trip.count1682, -1
  %xtraiter = and i64 %wide.trip.count1682, 7
  %45 = icmp ult i64 %44, 7
  br i1 %45, label %.loopexit1329.loopexit.unr-lcssa, label %.preheader.preheader.new

.preheader.preheader.new:                         ; preds = %.preheader.preheader
  %unroll_iter = and i64 %wide.trip.count1682, 2147483640
  br label %.preheader

.preheader:                                       ; preds = %.preheader, %.preheader.preheader.new
  %indvar = phi i64 [ 0, %.preheader.preheader.new ], [ %indvar.next.7, %.preheader ]
  %niter = phi i64 [ 0, %.preheader.preheader.new ], [ %niter.next.7, %.preheader ]
  %46 = mul i64 %40, %indvar
  %scevgep = getelementptr i8, ptr %43, i64 %46
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next = or disjoint i64 %indvar, 1
  %47 = mul i64 %40, %indvar.next
  %scevgep.1 = getelementptr i8, ptr %43, i64 %47
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.1, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.1 = or disjoint i64 %indvar, 2
  %48 = mul i64 %40, %indvar.next.1
  %scevgep.2 = getelementptr i8, ptr %43, i64 %48
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.2, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.2 = or disjoint i64 %indvar, 3
  %49 = mul i64 %40, %indvar.next.2
  %scevgep.3 = getelementptr i8, ptr %43, i64 %49
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.3, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.3 = or disjoint i64 %indvar, 4
  %50 = mul i64 %40, %indvar.next.3
  %scevgep.4 = getelementptr i8, ptr %43, i64 %50
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.4, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.4 = or disjoint i64 %indvar, 5
  %51 = mul i64 %40, %indvar.next.4
  %scevgep.5 = getelementptr i8, ptr %43, i64 %51
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.5, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.5 = or disjoint i64 %indvar, 6
  %52 = mul i64 %40, %indvar.next.5
  %scevgep.6 = getelementptr i8, ptr %43, i64 %52
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.6, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.6 = or disjoint i64 %indvar, 7
  %53 = mul i64 %40, %indvar.next.6
  %scevgep.7 = getelementptr i8, ptr %43, i64 %53
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.7, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.7 = add nuw nsw i64 %indvar, 8
  %niter.next.7 = add i64 %niter, 8
  %niter.ncmp.7 = icmp eq i64 %niter.next.7, %unroll_iter
  br i1 %niter.ncmp.7, label %.loopexit1329.loopexit.unr-lcssa, label %.preheader, !llvm.loop !11

54:                                               ; preds = %30
  %55 = fcmp oeq double %31, -1.000000e+00
  br i1 %55, label %56, label %.loopexit1329

56:                                               ; preds = %54
  %57 = load i32, ptr %2, align 4, !tbaa !5
  %.not1334 = icmp slt i32 %57, 1
  %.not12971332 = icmp slt i32 %28, 1
  %or.cond1859 = or i1 %.not1334, %.not12971332
  br i1 %or.cond1859, label %.loopexit1329, label %.preheader1330.preheader

.preheader1330.preheader:                         ; preds = %56
  %58 = add nuw i32 %28, 1
  %59 = sext i32 %25 to i64
  %60 = add nuw i32 %57, 1
  %wide.trip.count1677 = zext i32 %60 to i64
  %wide.trip.count = zext i32 %58 to i64
  %61 = zext nneg i32 %28 to i64
  %min.iters.check = icmp eq i32 %28, 1
  %n.vec = and i64 %61, 2147483646
  %ind.end = or i64 %61, 1
  %cmp.n = icmp eq i64 %n.vec, %61
  br label %.preheader1330

.preheader1330:                                   ; preds = %.preheader1330.preheader, %._crit_edge
  %indvars.iv1674 = phi i64 [ 1, %.preheader1330.preheader ], [ %indvars.iv.next1675, %._crit_edge ]
  %62 = mul nsw i64 %indvars.iv1674, %59
  %invariant.gep1785 = getelementptr %struct.doublecomplex, ptr %27, i64 %62
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.body

vector.body:                                      ; preds = %.preheader1330, %vector.body
  %index = phi i64 [ %index.next, %vector.body ], [ 0, %.preheader1330 ]
  %offset.idx = or disjoint i64 %index, 1
  %63 = getelementptr %struct.doublecomplex, ptr %invariant.gep1785, i64 %offset.idx
  %wide.vec = load <4 x double>, ptr %63, align 8, !tbaa !9
  %interleaved.vec = fneg <4 x double> %wide.vec
  store <4 x double> %interleaved.vec, ptr %63, align 8, !tbaa !9
  %index.next = add nuw i64 %index, 2
  %64 = icmp eq i64 %index.next, %n.vec
  br i1 %64, label %middle.block, label %vector.body, !llvm.loop !13

middle.block:                                     ; preds = %vector.body
  br i1 %cmp.n, label %._crit_edge, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %.preheader1330
  %indvars.iv.ph = phi i64 [ 1, %.preheader1330 ], [ %ind.end, %middle.block ]
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %scalar.ph ], [ %indvars.iv.ph, %scalar.ph.preheader ]
  %gep1786 = getelementptr %struct.doublecomplex, ptr %invariant.gep1785, i64 %indvars.iv
  %65 = load <2 x double>, ptr %gep1786, align 8, !tbaa !9
  %66 = fneg <2 x double> %65
  store <2 x double> %66, ptr %gep1786, align 8, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge, label %scalar.ph, !llvm.loop !16

._crit_edge:                                      ; preds = %scalar.ph, %middle.block
  %indvars.iv.next1675 = add nuw nsw i64 %indvars.iv1674, 1
  %exitcond1678.not = icmp eq i64 %indvars.iv.next1675, %wide.trip.count1677
  br i1 %exitcond1678.not, label %.loopexit1329, label %.preheader1330, !llvm.loop !17

.loopexit1329.loopexit.unr-lcssa:                 ; preds = %.preheader, %.preheader.preheader
  %indvar.unr = phi i64 [ 0, %.preheader.preheader ], [ %indvar.next.7, %.preheader ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.loopexit1329, label %.preheader.epil

.preheader.epil:                                  ; preds = %.loopexit1329.loopexit.unr-lcssa, %.preheader.epil
  %indvar.epil = phi i64 [ %indvar.next.epil, %.preheader.epil ], [ %indvar.unr, %.loopexit1329.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.preheader.epil ], [ 0, %.loopexit1329.loopexit.unr-lcssa ]
  %67 = mul i64 %40, %indvar.epil
  %scevgep.epil = getelementptr i8, ptr %43, i64 %67
  tail call void @llvm.memset.p0.i64(ptr align 8 %scevgep.epil, i8 0, i64 %42, i1 false), !tbaa !9
  %indvar.next.epil = add nuw nsw i64 %indvar.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %.loopexit1329, label %.preheader.epil, !llvm.loop !18

.loopexit1329:                                    ; preds = %._crit_edge, %.loopexit1329.loopexit.unr-lcssa, %.preheader.epil, %56, %33, %54
  %68 = load double, ptr %3, align 8, !tbaa !9
  %69 = fcmp oeq double %68, 1.000000e+00
  br i1 %69, label %70, label %652

70:                                               ; preds = %.loopexit1329
  %71 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #6
  %.not1308 = icmp eq i32 %71, 0
  br i1 %.not1308, label %271, label %72

72:                                               ; preds = %70
  %73 = load i32, ptr %2, align 4, !tbaa !5
  %.not13151519 = icmp slt i32 %73, 1
  br i1 %.not13151519, label %.loopexit1318, label %.lr.ph1526

.lr.ph1526:                                       ; preds = %72
  %74 = load i32, ptr %1, align 4, !tbaa !5
  %75 = icmp eq i32 %74, 1
  %76 = getelementptr inbounds i8, ptr %5, i64 8
  %77 = getelementptr inbounds i8, ptr %6, i64 8
  %78 = add nsw i32 %74, -1
  %79 = sext i32 %78 to i64
  %80 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %79
  %81 = getelementptr inbounds i8, ptr %80, i64 8
  %82 = sext i32 %74 to i64
  %83 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %82
  %84 = getelementptr inbounds i8, ptr %83, i64 8
  %.not1316.not1495 = icmp sgt i32 %74, 2
  %85 = sext i32 %25 to i64
  %86 = sext i32 %22 to i64
  %87 = add nuw i32 %73, 1
  %wide.trip.count1737 = zext i32 %87 to i64
  br i1 %75, label %.lr.ph1526.split.us.preheader, label %.lr.ph1526.split.preheader

.lr.ph1526.split.us.preheader:                    ; preds = %.lr.ph1526
  %invariant.gep2287 = getelementptr i8, ptr %24, i64 16
  %invariant.gep2289 = getelementptr i8, ptr %27, i64 16
  br label %.lr.ph1526.split.us

.lr.ph1526.split.preheader:                       ; preds = %.lr.ph1526
  %invariant.gep1831 = getelementptr %struct.doublecomplex, ptr %24, i64 %79
  %invariant.gep1833 = getelementptr %struct.doublecomplex, ptr %27, i64 %82
  %invariant.gep1835 = getelementptr %struct.doublecomplex, ptr %24, i64 %82
  %wide.trip.count1727 = zext i32 %74 to i64
  %88 = shl nsw i64 %85, 4
  %89 = shl nsw i64 %26, 4
  %90 = getelementptr i8, ptr %10, i64 %88
  %91 = getelementptr i8, ptr %90, i64 %89
  %scevgep2058 = getelementptr i8, ptr %91, i64 32
  %92 = shl nuw nsw i64 %wide.trip.count1737, 4
  %93 = add nsw i64 %92, -16
  %94 = mul i64 %93, %85
  %95 = shl nuw nsw i64 %wide.trip.count1727, 4
  %96 = getelementptr i8, ptr %10, i64 %94
  %97 = getelementptr i8, ptr %96, i64 %89
  %98 = getelementptr i8, ptr %97, i64 %95
  %scevgep2059 = getelementptr i8, ptr %98, i64 -8
  %99 = getelementptr i8, ptr %4, i64 %95
  %scevgep2060 = getelementptr i8, ptr %99, i64 -40
  %100 = shl nsw i64 %86, 4
  %101 = shl nsw i64 %23, 4
  %102 = getelementptr i8, ptr %7, i64 %100
  %103 = getelementptr i8, ptr %102, i64 %101
  %scevgep2061 = getelementptr i8, ptr %103, i64 16
  %104 = mul i64 %93, %86
  %105 = add i64 %104, %101
  %106 = add i64 %105, %95
  %107 = or disjoint i64 %106, 8
  %scevgep2062 = getelementptr i8, ptr %7, i64 %107
  %scevgep2063 = getelementptr i8, ptr %5, i64 16
  %108 = add nsw i64 %95, -24
  %scevgep2064 = getelementptr i8, ptr %5, i64 %108
  %scevgep2065 = getelementptr i8, ptr %6, i64 16
  %scevgep2066 = getelementptr i8, ptr %6, i64 %108
  %109 = getelementptr i8, ptr %10, i64 %88
  %110 = getelementptr i8, ptr %109, i64 %89
  %scevgep2067 = getelementptr i8, ptr %110, i64 40
  %111 = getelementptr i8, ptr %10, i64 %94
  %112 = getelementptr i8, ptr %111, i64 %89
  %scevgep2068 = getelementptr i8, ptr %112, i64 %95
  %scevgep2069 = getelementptr i8, ptr %4, i64 8
  %113 = getelementptr i8, ptr %4, i64 %95
  %scevgep2070 = getelementptr i8, ptr %113, i64 -32
  %114 = getelementptr i8, ptr %7, i64 %100
  %115 = getelementptr i8, ptr %114, i64 %101
  %scevgep2071 = getelementptr i8, ptr %115, i64 24
  %116 = getelementptr i8, ptr %7, i64 %104
  %117 = getelementptr i8, ptr %116, i64 %101
  %118 = getelementptr i8, ptr %117, i64 %95
  %scevgep2072 = getelementptr i8, ptr %118, i64 16
  %scevgep2073 = getelementptr i8, ptr %5, i64 24
  %119 = add nsw i64 %95, -16
  %scevgep2074 = getelementptr i8, ptr %5, i64 %119
  %scevgep2075 = getelementptr i8, ptr %6, i64 24
  %scevgep2076 = getelementptr i8, ptr %6, i64 %119
  %120 = add nsw i64 %wide.trip.count1727, -2
  %invariant.gep2285 = getelementptr i8, ptr %27, i64 16
  %min.iters.check2120 = icmp ult i64 %120, 4
  %bound02077 = icmp ult ptr %scevgep2058, %scevgep2060
  %bound12078 = icmp ugt ptr %scevgep2059, %4
  %found.conflict2079 = and i1 %bound02077, %bound12078
  %stride.check2080 = icmp slt i32 %25, 0
  %121 = or i1 %found.conflict2079, %stride.check2080
  %bound02081 = icmp ult ptr %scevgep2058, %scevgep2062
  %bound12082 = icmp ult ptr %scevgep2061, %scevgep2059
  %found.conflict2083 = and i1 %bound02081, %bound12082
  %122 = or i32 %25, %22
  %123 = icmp slt i32 %122, 0
  %124 = or i1 %found.conflict2083, %123
  %conflict.rdx2086 = or i1 %121, %124
  %bound02087 = icmp ult ptr %scevgep2058, %scevgep2064
  %bound12088 = icmp ult ptr %scevgep2063, %scevgep2059
  %found.conflict2089 = and i1 %bound02087, %bound12088
  %conflict.rdx2091 = or i1 %found.conflict2089, %conflict.rdx2086
  %bound02092 = icmp ult ptr %scevgep2058, %scevgep2066
  %bound12093 = icmp ult ptr %scevgep2065, %scevgep2059
  %found.conflict2094 = and i1 %bound02092, %bound12093
  %conflict.rdx2096 = or i1 %found.conflict2094, %conflict.rdx2091
  %bound02097 = icmp ult ptr %scevgep2067, %scevgep2070
  %bound12098 = icmp ult ptr %scevgep2069, %scevgep2068
  %found.conflict2099 = and i1 %bound02097, %bound12098
  %conflict.rdx2101 = or i1 %found.conflict2099, %conflict.rdx2096
  %bound02102 = icmp ult ptr %scevgep2067, %scevgep2072
  %bound12103 = icmp ult ptr %scevgep2071, %scevgep2068
  %found.conflict2104 = and i1 %bound02102, %bound12103
  %125 = or i32 %25, %22
  %126 = icmp slt i32 %125, 0
  %127 = or i1 %found.conflict2104, %126
  %conflict.rdx2107 = or i1 %conflict.rdx2101, %127
  %bound02108 = icmp ult ptr %scevgep2067, %scevgep2074
  %bound12109 = icmp ult ptr %scevgep2073, %scevgep2068
  %found.conflict2110 = and i1 %bound02108, %bound12109
  %conflict.rdx2112 = or i1 %found.conflict2110, %conflict.rdx2107
  %bound02113 = icmp ult ptr %scevgep2067, %scevgep2076
  %bound12114 = icmp ult ptr %scevgep2075, %scevgep2068
  %found.conflict2115 = and i1 %bound02113, %bound12114
  %conflict.rdx2117 = or i1 %found.conflict2115, %conflict.rdx2112
  %n.vec2123 = and i64 %120, -2
  %ind.end2124 = add nsw i64 %n.vec2123, 2
  %cmp.n2152 = icmp eq i64 %120, %n.vec2123
  br label %.lr.ph1526.split

.lr.ph1526.split.us:                              ; preds = %.lr.ph1526.split.us.preheader, %.lr.ph1526.split.us
  %indvars.iv1734 = phi i64 [ %indvars.iv.next1735, %.lr.ph1526.split.us ], [ 1, %.lr.ph1526.split.us.preheader ]
  %128 = mul nsw i64 %indvars.iv1734, %85
  %129 = mul nsw i64 %indvars.iv1734, %86
  %130 = load double, ptr %5, align 8, !tbaa !20
  %gep2288 = getelementptr %struct.doublecomplex, ptr %invariant.gep2287, i64 %129
  %131 = load double, ptr %76, align 8, !tbaa !22
  %132 = fneg double %131
  %gep2290 = getelementptr %struct.doublecomplex, ptr %invariant.gep2289, i64 %128
  %133 = load <2 x double>, ptr %gep2288, align 8, !tbaa !9
  %134 = insertelement <2 x double> poison, double %131, i64 0
  %135 = insertelement <2 x double> %134, double %132, i64 1
  %136 = fmul <2 x double> %133, %135
  %137 = shufflevector <2 x double> %136, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %138 = insertelement <2 x double> poison, double %130, i64 0
  %139 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> zeroinitializer
  %140 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %139, <2 x double> %133, <2 x double> %137)
  %141 = load <2 x double>, ptr %gep2290, align 8, !tbaa !9
  %142 = fadd <2 x double> %141, %140
  store <2 x double> %142, ptr %gep2290, align 8, !tbaa !9
  %indvars.iv.next1735 = add nuw nsw i64 %indvars.iv1734, 1
  %exitcond1738.not = icmp eq i64 %indvars.iv.next1735, %wide.trip.count1737
  br i1 %exitcond1738.not, label %.loopexit1318, label %.lr.ph1526.split.us, !llvm.loop !23

.lr.ph1526.split:                                 ; preds = %.lr.ph1526.split.preheader, %.loopexit1321
  %indvars.iv1729 = phi i64 [ 1, %.lr.ph1526.split.preheader ], [ %indvars.iv.next1730, %.loopexit1321 ]
  %143 = mul nsw i64 %indvars.iv1729, %85
  %144 = mul nsw i64 %indvars.iv1729, %86
  %145 = load double, ptr %5, align 8, !tbaa !20
  %146 = getelementptr %struct.doublecomplex, ptr %24, i64 %144
  %147 = getelementptr i8, ptr %146, i64 16
  %148 = load double, ptr %76, align 8, !tbaa !22
  %149 = fneg double %148
  %gep2286 = getelementptr %struct.doublecomplex, ptr %invariant.gep2285, i64 %143
  %150 = load double, ptr %6, align 8, !tbaa !20
  %151 = getelementptr i8, ptr %146, i64 32
  %152 = load double, ptr %77, align 8, !tbaa !22
  %153 = fneg double %152
  %154 = load <2 x double>, ptr %147, align 8, !tbaa !9
  %155 = insertelement <2 x double> poison, double %148, i64 0
  %156 = insertelement <2 x double> %155, double %149, i64 1
  %157 = fmul <2 x double> %154, %156
  %158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %159 = insertelement <2 x double> poison, double %145, i64 0
  %160 = shufflevector <2 x double> %159, <2 x double> poison, <2 x i32> zeroinitializer
  %161 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %160, <2 x double> %154, <2 x double> %158)
  %162 = load <2 x double>, ptr %gep2286, align 8, !tbaa !9
  %163 = fadd <2 x double> %161, %162
  %164 = load <2 x double>, ptr %151, align 8, !tbaa !9
  %165 = insertelement <2 x double> poison, double %152, i64 0
  %166 = insertelement <2 x double> %165, double %153, i64 1
  %167 = fmul <2 x double> %164, %166
  %168 = shufflevector <2 x double> %167, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %169 = insertelement <2 x double> poison, double %150, i64 0
  %170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> zeroinitializer
  %171 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %164, <2 x double> %168)
  %172 = fadd <2 x double> %163, %171
  store <2 x double> %172, ptr %gep2286, align 8, !tbaa !9
  %173 = load double, ptr %80, align 8, !tbaa !20
  %gep1832 = getelementptr %struct.doublecomplex, ptr %invariant.gep1831, i64 %144
  %174 = load double, ptr %81, align 8, !tbaa !22
  %175 = fneg double %174
  %gep1834 = getelementptr %struct.doublecomplex, ptr %invariant.gep1833, i64 %143
  %176 = load double, ptr %83, align 8, !tbaa !20
  %gep1836 = getelementptr %struct.doublecomplex, ptr %invariant.gep1835, i64 %144
  %177 = load double, ptr %84, align 8, !tbaa !22
  %178 = fneg double %177
  %179 = load <2 x double>, ptr %gep1832, align 8, !tbaa !9
  %180 = insertelement <2 x double> poison, double %174, i64 0
  %181 = insertelement <2 x double> %180, double %175, i64 1
  %182 = fmul <2 x double> %179, %181
  %183 = shufflevector <2 x double> %182, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %184 = insertelement <2 x double> poison, double %173, i64 0
  %185 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> zeroinitializer
  %186 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %185, <2 x double> %179, <2 x double> %183)
  %187 = load <2 x double>, ptr %gep1834, align 8, !tbaa !9
  %188 = fadd <2 x double> %186, %187
  %189 = load <2 x double>, ptr %gep1836, align 8, !tbaa !9
  %190 = insertelement <2 x double> poison, double %177, i64 0
  %191 = insertelement <2 x double> %190, double %178, 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 %176, i64 0
  %195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> zeroinitializer
  %196 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %195, <2 x double> %189, <2 x double> %193)
  %197 = fadd <2 x double> %188, %196
  store <2 x double> %197, ptr %gep1834, align 8, !tbaa !9
  br i1 %.not1316.not1495, label %.lr.ph1498.preheader, label %.loopexit1321

.lr.ph1498.preheader:                             ; preds = %.lr.ph1526.split
  %invariant.gep1823 = getelementptr %struct.doublecomplex, ptr %24, i64 %144
  %invariant.gep1825 = getelementptr %struct.doublecomplex, ptr %27, i64 %143
  %invariant.gep1827 = getelementptr %struct.doublecomplex, ptr %24, i64 %144
  %invariant.gep1829 = getelementptr %struct.doublecomplex, ptr %24, i64 %144
  %brmerge = select i1 %min.iters.check2120, i1 true, i1 %conflict.rdx2117
  br i1 %brmerge, label %.lr.ph1498.preheader2253, label %vector.ph2121

vector.ph2121:                                    ; preds = %.lr.ph1498.preheader
  %invariant.gep2283 = getelementptr i8, ptr %invariant.gep1829, i64 48
  br label %vector.body2126

vector.body2126:                                  ; preds = %vector.body2126, %vector.ph2121
  %index2127 = phi i64 [ 0, %vector.ph2121 ], [ %index.next2151, %vector.body2126 ]
  %offset.idx2128 = add i64 %index2127, 2
  %198 = or disjoint i64 %index2127, 1
  %199 = getelementptr %struct.doublecomplex, ptr %4, i64 %index2127
  %wide.vec2129 = load <4 x double>, ptr %199, align 8, !tbaa !9
  %strided.vec2130 = shufflevector <4 x double> %wide.vec2129, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2131 = shufflevector <4 x double> %wide.vec2129, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %200 = getelementptr %struct.doublecomplex, ptr %invariant.gep1823, i64 %198
  %wide.vec2132 = load <4 x double>, ptr %200, align 8, !tbaa !9
  %strided.vec2133 = shufflevector <4 x double> %wide.vec2132, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2134 = shufflevector <4 x double> %wide.vec2132, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %201 = fneg <2 x double> %strided.vec2131
  %202 = fmul <2 x double> %strided.vec2134, %201
  %203 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2130, <2 x double> %strided.vec2133, <2 x double> %202)
  %204 = fmul <2 x double> %strided.vec2133, %strided.vec2131
  %205 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2130, <2 x double> %strided.vec2134, <2 x double> %204)
  %206 = getelementptr %struct.doublecomplex, ptr %invariant.gep1825, i64 %offset.idx2128
  %wide.vec2135 = load <4 x double>, ptr %206, align 8, !tbaa !9
  %strided.vec2136 = shufflevector <4 x double> %wide.vec2135, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2137 = shufflevector <4 x double> %wide.vec2135, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %207 = fadd <2 x double> %203, %strided.vec2136
  %208 = fadd <2 x double> %205, %strided.vec2137
  %209 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %offset.idx2128
  %wide.vec2138 = load <4 x double>, ptr %209, align 8, !tbaa !9
  %strided.vec2139 = shufflevector <4 x double> %wide.vec2138, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2140 = shufflevector <4 x double> %wide.vec2138, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %210 = getelementptr %struct.doublecomplex, ptr %invariant.gep1827, i64 %offset.idx2128
  %wide.vec2141 = load <4 x double>, ptr %210, align 8, !tbaa !9
  %strided.vec2142 = shufflevector <4 x double> %wide.vec2141, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2143 = shufflevector <4 x double> %wide.vec2141, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %211 = fneg <2 x double> %strided.vec2140
  %212 = fmul <2 x double> %strided.vec2143, %211
  %213 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2139, <2 x double> %strided.vec2142, <2 x double> %212)
  %214 = fmul <2 x double> %strided.vec2142, %strided.vec2140
  %215 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2139, <2 x double> %strided.vec2143, <2 x double> %214)
  %216 = fadd <2 x double> %207, %213
  %217 = fadd <2 x double> %208, %215
  %218 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %offset.idx2128
  %wide.vec2144 = load <4 x double>, ptr %218, align 8, !tbaa !9
  %strided.vec2145 = shufflevector <4 x double> %wide.vec2144, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2146 = shufflevector <4 x double> %wide.vec2144, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %gep2284 = getelementptr %struct.doublecomplex, ptr %invariant.gep2283, i64 %index2127
  %wide.vec2147 = load <4 x double>, ptr %gep2284, align 8, !tbaa !9
  %strided.vec2148 = shufflevector <4 x double> %wide.vec2147, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2149 = shufflevector <4 x double> %wide.vec2147, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %219 = fneg <2 x double> %strided.vec2146
  %220 = fmul <2 x double> %strided.vec2149, %219
  %221 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2145, <2 x double> %strided.vec2148, <2 x double> %220)
  %222 = fmul <2 x double> %strided.vec2148, %strided.vec2146
  %223 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2145, <2 x double> %strided.vec2149, <2 x double> %222)
  %224 = fadd <2 x double> %216, %221
  %225 = fadd <2 x double> %217, %223
  %interleaved.vec2150 = shufflevector <2 x double> %224, <2 x double> %225, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec2150, ptr %206, align 8, !tbaa !9
  %index.next2151 = add nuw i64 %index2127, 2
  %226 = icmp eq i64 %index.next2151, %n.vec2123
  br i1 %226, label %middle.block2118, label %vector.body2126, !llvm.loop !24

middle.block2118:                                 ; preds = %vector.body2126
  br i1 %cmp.n2152, label %.loopexit1321, label %.lr.ph1498.preheader2253

.lr.ph1498.preheader2253:                         ; preds = %.lr.ph1498.preheader, %middle.block2118
  %indvars.iv1724.ph = phi i64 [ 2, %.lr.ph1498.preheader ], [ %ind.end2124, %middle.block2118 ]
  br label %.lr.ph1498

.lr.ph1498:                                       ; preds = %.lr.ph1498.preheader2253, %.lr.ph1498
  %indvars.iv1724 = phi i64 [ %indvars.iv.next1725, %.lr.ph1498 ], [ %indvars.iv1724.ph, %.lr.ph1498.preheader2253 ]
  %227 = add nsw i64 %indvars.iv1724, -1
  %228 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %227
  %229 = load double, ptr %228, align 8, !tbaa !20
  %gep1824 = getelementptr %struct.doublecomplex, ptr %invariant.gep1823, i64 %227
  %230 = getelementptr inbounds i8, ptr %228, i64 8
  %231 = load double, ptr %230, align 8, !tbaa !22
  %232 = fneg double %231
  %gep1826 = getelementptr %struct.doublecomplex, ptr %invariant.gep1825, i64 %indvars.iv1724
  %233 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1724
  %234 = load double, ptr %233, align 8, !tbaa !20
  %gep1828 = getelementptr %struct.doublecomplex, ptr %invariant.gep1827, i64 %indvars.iv1724
  %235 = getelementptr inbounds i8, ptr %233, i64 8
  %236 = load double, ptr %235, align 8, !tbaa !22
  %237 = fneg double %236
  %indvars.iv.next1725 = add nuw nsw i64 %indvars.iv1724, 1
  %238 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %indvars.iv1724
  %239 = load double, ptr %238, align 8, !tbaa !20
  %gep1830 = getelementptr %struct.doublecomplex, ptr %invariant.gep1829, i64 %indvars.iv.next1725
  %240 = getelementptr inbounds i8, ptr %238, i64 8
  %241 = load double, ptr %240, align 8, !tbaa !22
  %242 = fneg double %241
  %243 = load <2 x double>, ptr %gep1824, align 8, !tbaa !9
  %244 = insertelement <2 x double> poison, double %231, i64 0
  %245 = insertelement <2 x double> %244, double %232, i64 1
  %246 = fmul <2 x double> %243, %245
  %247 = shufflevector <2 x double> %246, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %248 = insertelement <2 x double> poison, double %229, i64 0
  %249 = shufflevector <2 x double> %248, <2 x double> poison, <2 x i32> zeroinitializer
  %250 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %249, <2 x double> %243, <2 x double> %247)
  %251 = load <2 x double>, ptr %gep1826, align 8, !tbaa !9
  %252 = fadd <2 x double> %250, %251
  %253 = load <2 x double>, ptr %gep1828, align 8, !tbaa !9
  %254 = insertelement <2 x double> poison, double %236, i64 0
  %255 = insertelement <2 x double> %254, double %237, i64 1
  %256 = fmul <2 x double> %253, %255
  %257 = shufflevector <2 x double> %256, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %258 = insertelement <2 x double> poison, double %234, i64 0
  %259 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> zeroinitializer
  %260 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %259, <2 x double> %253, <2 x double> %257)
  %261 = fadd <2 x double> %252, %260
  %262 = load <2 x double>, ptr %gep1830, align 8, !tbaa !9
  %263 = insertelement <2 x double> poison, double %241, i64 0
  %264 = insertelement <2 x double> %263, double %242, i64 1
  %265 = fmul <2 x double> %262, %264
  %266 = shufflevector <2 x double> %265, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %267 = insertelement <2 x double> poison, double %239, i64 0
  %268 = shufflevector <2 x double> %267, <2 x double> poison, <2 x i32> zeroinitializer
  %269 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %268, <2 x double> %262, <2 x double> %266)
  %270 = fadd <2 x double> %261, %269
  store <2 x double> %270, ptr %gep1826, align 8, !tbaa !9
  %exitcond1728.not = icmp eq i64 %indvars.iv.next1725, %wide.trip.count1727
  br i1 %exitcond1728.not, label %.loopexit1321, label %.lr.ph1498, !llvm.loop !25

.loopexit1321:                                    ; preds = %.lr.ph1498, %middle.block2118, %.lr.ph1526.split
  %indvars.iv.next1730 = add nuw nsw i64 %indvars.iv1729, 1
  %exitcond1733.not = icmp eq i64 %indvars.iv.next1730, %wide.trip.count1737
  br i1 %exitcond1733.not, label %.loopexit1318, label %.lr.ph1526.split, !llvm.loop !23

271:                                              ; preds = %70
  %272 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #6
  %.not1309 = icmp eq i32 %272, 0
  br i1 %.not1309, label %472, label %273

273:                                              ; preds = %271
  %274 = load i32, ptr %2, align 4, !tbaa !5
  %.not13131589 = icmp slt i32 %274, 1
  br i1 %.not13131589, label %.loopexit1318, label %.lr.ph1596

.lr.ph1596:                                       ; preds = %273
  %275 = load i32, ptr %1, align 4, !tbaa !5
  %276 = icmp eq i32 %275, 1
  %277 = getelementptr inbounds i8, ptr %5, i64 8
  %278 = getelementptr inbounds i8, ptr %4, i64 8
  %279 = add nsw i32 %275, -1
  %280 = sext i32 %279 to i64
  %281 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %280
  %282 = getelementptr inbounds i8, ptr %281, i64 8
  %283 = sext i32 %275 to i64
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %283
  %285 = getelementptr inbounds i8, ptr %284, i64 8
  %.not1314.not1565 = icmp sgt i32 %275, 2
  %286 = sext i32 %25 to i64
  %287 = sext i32 %22 to i64
  %288 = add nuw i32 %274, 1
  %wide.trip.count1752 = zext i32 %288 to i64
  br i1 %276, label %.lr.ph1596.split.us.preheader, label %.lr.ph1596.split.preheader

.lr.ph1596.split.us.preheader:                    ; preds = %.lr.ph1596
  %invariant.gep2295 = getelementptr i8, ptr %24, i64 16
  %invariant.gep2297 = getelementptr i8, ptr %27, i64 16
  br label %.lr.ph1596.split.us

.lr.ph1596.split.preheader:                       ; preds = %.lr.ph1596
  %invariant.gep1845 = getelementptr %struct.doublecomplex, ptr %24, i64 %280
  %invariant.gep1847 = getelementptr %struct.doublecomplex, ptr %27, i64 %283
  %invariant.gep1849 = getelementptr %struct.doublecomplex, ptr %24, i64 %283
  %wide.trip.count1742 = zext i32 %275 to i64
  %289 = shl nsw i64 %286, 4
  %290 = shl nsw i64 %26, 4
  %291 = getelementptr i8, ptr %10, i64 %289
  %292 = getelementptr i8, ptr %291, i64 %290
  %scevgep2154 = getelementptr i8, ptr %292, i64 32
  %293 = shl nuw nsw i64 %wide.trip.count1752, 4
  %294 = add nsw i64 %293, -16
  %295 = mul i64 %294, %286
  %296 = shl nuw nsw i64 %wide.trip.count1742, 4
  %297 = getelementptr i8, ptr %10, i64 %295
  %298 = getelementptr i8, ptr %297, i64 %290
  %299 = getelementptr i8, ptr %298, i64 %296
  %scevgep2155 = getelementptr i8, ptr %299, i64 -8
  %300 = getelementptr i8, ptr %6, i64 %296
  %scevgep2156 = getelementptr i8, ptr %300, i64 -40
  %301 = shl nsw i64 %287, 4
  %302 = shl nsw i64 %23, 4
  %303 = getelementptr i8, ptr %7, i64 %301
  %304 = getelementptr i8, ptr %303, i64 %302
  %scevgep2157 = getelementptr i8, ptr %304, i64 16
  %305 = mul i64 %294, %287
  %306 = add i64 %305, %302
  %307 = add i64 %306, %296
  %308 = or disjoint i64 %307, 8
  %scevgep2158 = getelementptr i8, ptr %7, i64 %308
  %scevgep2159 = getelementptr i8, ptr %5, i64 16
  %309 = add nsw i64 %296, -24
  %scevgep2160 = getelementptr i8, ptr %5, i64 %309
  %scevgep2161 = getelementptr i8, ptr %4, i64 16
  %scevgep2162 = getelementptr i8, ptr %4, i64 %309
  %310 = getelementptr i8, ptr %10, i64 %289
  %311 = getelementptr i8, ptr %310, i64 %290
  %scevgep2163 = getelementptr i8, ptr %311, i64 40
  %312 = getelementptr i8, ptr %10, i64 %295
  %313 = getelementptr i8, ptr %312, i64 %290
  %scevgep2164 = getelementptr i8, ptr %313, i64 %296
  %scevgep2165 = getelementptr i8, ptr %6, i64 8
  %314 = getelementptr i8, ptr %6, i64 %296
  %scevgep2166 = getelementptr i8, ptr %314, i64 -32
  %315 = getelementptr i8, ptr %7, i64 %301
  %316 = getelementptr i8, ptr %315, i64 %302
  %scevgep2167 = getelementptr i8, ptr %316, i64 24
  %317 = getelementptr i8, ptr %7, i64 %305
  %318 = getelementptr i8, ptr %317, i64 %302
  %319 = getelementptr i8, ptr %318, i64 %296
  %scevgep2168 = getelementptr i8, ptr %319, i64 16
  %scevgep2169 = getelementptr i8, ptr %5, i64 24
  %320 = add nsw i64 %296, -16
  %scevgep2170 = getelementptr i8, ptr %5, i64 %320
  %scevgep2171 = getelementptr i8, ptr %4, i64 24
  %scevgep2172 = getelementptr i8, ptr %4, i64 %320
  %321 = add nsw i64 %wide.trip.count1742, -2
  %invariant.gep2293 = getelementptr i8, ptr %27, i64 16
  %min.iters.check2216 = icmp ult i64 %321, 4
  %bound02173 = icmp ult ptr %scevgep2154, %scevgep2156
  %bound12174 = icmp ugt ptr %scevgep2155, %6
  %found.conflict2175 = and i1 %bound02173, %bound12174
  %stride.check2176 = icmp slt i32 %25, 0
  %322 = or i1 %found.conflict2175, %stride.check2176
  %bound02177 = icmp ult ptr %scevgep2154, %scevgep2158
  %bound12178 = icmp ult ptr %scevgep2157, %scevgep2155
  %found.conflict2179 = and i1 %bound02177, %bound12178
  %323 = or i32 %25, %22
  %324 = icmp slt i32 %323, 0
  %325 = or i1 %found.conflict2179, %324
  %conflict.rdx2182 = or i1 %322, %325
  %bound02183 = icmp ult ptr %scevgep2154, %scevgep2160
  %bound12184 = icmp ult ptr %scevgep2159, %scevgep2155
  %found.conflict2185 = and i1 %bound02183, %bound12184
  %conflict.rdx2187 = or i1 %found.conflict2185, %conflict.rdx2182
  %bound02188 = icmp ult ptr %scevgep2154, %scevgep2162
  %bound12189 = icmp ult ptr %scevgep2161, %scevgep2155
  %found.conflict2190 = and i1 %bound02188, %bound12189
  %conflict.rdx2192 = or i1 %found.conflict2190, %conflict.rdx2187
  %bound02193 = icmp ult ptr %scevgep2163, %scevgep2166
  %bound12194 = icmp ult ptr %scevgep2165, %scevgep2164
  %found.conflict2195 = and i1 %bound02193, %bound12194
  %conflict.rdx2197 = or i1 %found.conflict2195, %conflict.rdx2192
  %bound02198 = icmp ult ptr %scevgep2163, %scevgep2168
  %bound12199 = icmp ult ptr %scevgep2167, %scevgep2164
  %found.conflict2200 = and i1 %bound02198, %bound12199
  %326 = or i32 %25, %22
  %327 = icmp slt i32 %326, 0
  %328 = or i1 %found.conflict2200, %327
  %conflict.rdx2203 = or i1 %conflict.rdx2197, %328
  %bound02204 = icmp ult ptr %scevgep2163, %scevgep2170
  %bound12205 = icmp ult ptr %scevgep2169, %scevgep2164
  %found.conflict2206 = and i1 %bound02204, %bound12205
  %conflict.rdx2208 = or i1 %found.conflict2206, %conflict.rdx2203
  %bound02209 = icmp ult ptr %scevgep2163, %scevgep2172
  %bound12210 = icmp ult ptr %scevgep2171, %scevgep2164
  %found.conflict2211 = and i1 %bound02209, %bound12210
  %conflict.rdx2213 = or i1 %found.conflict2211, %conflict.rdx2208
  %n.vec2219 = and i64 %321, -2
  %ind.end2220 = add nsw i64 %n.vec2219, 2
  %cmp.n2248 = icmp eq i64 %321, %n.vec2219
  br label %.lr.ph1596.split

.lr.ph1596.split.us:                              ; preds = %.lr.ph1596.split.us.preheader, %.lr.ph1596.split.us
  %indvars.iv1749 = phi i64 [ %indvars.iv.next1750, %.lr.ph1596.split.us ], [ 1, %.lr.ph1596.split.us.preheader ]
  %329 = mul nsw i64 %indvars.iv1749, %286
  %330 = mul nsw i64 %indvars.iv1749, %287
  %331 = load double, ptr %5, align 8, !tbaa !20
  %gep2296 = getelementptr %struct.doublecomplex, ptr %invariant.gep2295, i64 %330
  %332 = load double, ptr %277, align 8, !tbaa !22
  %333 = fneg double %332
  %gep2298 = getelementptr %struct.doublecomplex, ptr %invariant.gep2297, i64 %329
  %334 = load <2 x double>, ptr %gep2296, align 8, !tbaa !9
  %335 = insertelement <2 x double> poison, double %332, i64 0
  %336 = insertelement <2 x double> %335, double %333, i64 1
  %337 = fmul <2 x double> %334, %336
  %338 = shufflevector <2 x double> %337, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %339 = insertelement <2 x double> poison, double %331, i64 0
  %340 = shufflevector <2 x double> %339, <2 x double> poison, <2 x i32> zeroinitializer
  %341 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %340, <2 x double> %334, <2 x double> %338)
  %342 = load <2 x double>, ptr %gep2298, align 8, !tbaa !9
  %343 = fadd <2 x double> %342, %341
  store <2 x double> %343, ptr %gep2298, align 8, !tbaa !9
  %indvars.iv.next1750 = add nuw nsw i64 %indvars.iv1749, 1
  %exitcond1753.not = icmp eq i64 %indvars.iv.next1750, %wide.trip.count1752
  br i1 %exitcond1753.not, label %.loopexit1318, label %.lr.ph1596.split.us, !llvm.loop !26

.lr.ph1596.split:                                 ; preds = %.lr.ph1596.split.preheader, %.loopexit1319
  %indvars.iv1744 = phi i64 [ 1, %.lr.ph1596.split.preheader ], [ %indvars.iv.next1745, %.loopexit1319 ]
  %344 = mul nsw i64 %indvars.iv1744, %286
  %345 = mul nsw i64 %indvars.iv1744, %287
  %346 = load double, ptr %5, align 8, !tbaa !20
  %347 = getelementptr %struct.doublecomplex, ptr %24, i64 %345
  %348 = getelementptr i8, ptr %347, i64 16
  %349 = load double, ptr %277, align 8, !tbaa !22
  %350 = fneg double %349
  %gep2294 = getelementptr %struct.doublecomplex, ptr %invariant.gep2293, i64 %344
  %351 = load double, ptr %4, align 8, !tbaa !20
  %352 = getelementptr i8, ptr %347, i64 32
  %353 = load double, ptr %278, align 8, !tbaa !22
  %354 = fneg double %353
  %355 = load <2 x double>, ptr %348, align 8, !tbaa !9
  %356 = insertelement <2 x double> poison, double %349, i64 0
  %357 = insertelement <2 x double> %356, double %350, i64 1
  %358 = fmul <2 x double> %355, %357
  %359 = shufflevector <2 x double> %358, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %360 = insertelement <2 x double> poison, double %346, i64 0
  %361 = shufflevector <2 x double> %360, <2 x double> poison, <2 x i32> zeroinitializer
  %362 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %361, <2 x double> %355, <2 x double> %359)
  %363 = load <2 x double>, ptr %gep2294, align 8, !tbaa !9
  %364 = fadd <2 x double> %362, %363
  %365 = load <2 x double>, ptr %352, align 8, !tbaa !9
  %366 = insertelement <2 x double> poison, double %353, i64 0
  %367 = insertelement <2 x double> %366, double %354, i64 1
  %368 = fmul <2 x double> %365, %367
  %369 = shufflevector <2 x double> %368, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %370 = insertelement <2 x double> poison, double %351, i64 0
  %371 = shufflevector <2 x double> %370, <2 x double> poison, <2 x i32> zeroinitializer
  %372 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %371, <2 x double> %365, <2 x double> %369)
  %373 = fadd <2 x double> %364, %372
  store <2 x double> %373, ptr %gep2294, align 8, !tbaa !9
  %374 = load double, ptr %281, align 8, !tbaa !20
  %gep1846 = getelementptr %struct.doublecomplex, ptr %invariant.gep1845, i64 %345
  %375 = load double, ptr %282, align 8, !tbaa !22
  %376 = fneg double %375
  %gep1848 = getelementptr %struct.doublecomplex, ptr %invariant.gep1847, i64 %344
  %377 = load double, ptr %284, align 8, !tbaa !20
  %gep1850 = getelementptr %struct.doublecomplex, ptr %invariant.gep1849, i64 %345
  %378 = load double, ptr %285, align 8, !tbaa !22
  %379 = fneg double %378
  %380 = load <2 x double>, ptr %gep1846, align 8, !tbaa !9
  %381 = insertelement <2 x double> poison, double %375, i64 0
  %382 = insertelement <2 x double> %381, double %376, i64 1
  %383 = fmul <2 x double> %380, %382
  %384 = shufflevector <2 x double> %383, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %385 = insertelement <2 x double> poison, double %374, i64 0
  %386 = shufflevector <2 x double> %385, <2 x double> poison, <2 x i32> zeroinitializer
  %387 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %386, <2 x double> %380, <2 x double> %384)
  %388 = load <2 x double>, ptr %gep1848, align 8, !tbaa !9
  %389 = fadd <2 x double> %387, %388
  %390 = load <2 x double>, ptr %gep1850, align 8, !tbaa !9
  %391 = insertelement <2 x double> poison, double %378, i64 0
  %392 = insertelement <2 x double> %391, double %379, i64 1
  %393 = fmul <2 x double> %390, %392
  %394 = shufflevector <2 x double> %393, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %395 = insertelement <2 x double> poison, double %377, i64 0
  %396 = shufflevector <2 x double> %395, <2 x double> poison, <2 x i32> zeroinitializer
  %397 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %396, <2 x double> %390, <2 x double> %394)
  %398 = fadd <2 x double> %389, %397
  store <2 x double> %398, ptr %gep1848, align 8, !tbaa !9
  br i1 %.not1314.not1565, label %.lr.ph1568.preheader, label %.loopexit1319

.lr.ph1568.preheader:                             ; preds = %.lr.ph1596.split
  %invariant.gep1837 = getelementptr %struct.doublecomplex, ptr %24, i64 %345
  %invariant.gep1839 = getelementptr %struct.doublecomplex, ptr %27, i64 %344
  %invariant.gep1841 = getelementptr %struct.doublecomplex, ptr %24, i64 %345
  %invariant.gep1843 = getelementptr %struct.doublecomplex, ptr %24, i64 %345
  %brmerge2303 = select i1 %min.iters.check2216, i1 true, i1 %conflict.rdx2213
  br i1 %brmerge2303, label %.lr.ph1568.preheader2250, label %vector.ph2217

vector.ph2217:                                    ; preds = %.lr.ph1568.preheader
  %invariant.gep2291 = getelementptr i8, ptr %invariant.gep1843, i64 48
  br label %vector.body2222

vector.body2222:                                  ; preds = %vector.body2222, %vector.ph2217
  %index2223 = phi i64 [ 0, %vector.ph2217 ], [ %index.next2247, %vector.body2222 ]
  %offset.idx2224 = add i64 %index2223, 2
  %399 = or disjoint i64 %index2223, 1
  %400 = getelementptr %struct.doublecomplex, ptr %6, i64 %index2223
  %wide.vec2225 = load <4 x double>, ptr %400, align 8, !tbaa !9
  %strided.vec2226 = shufflevector <4 x double> %wide.vec2225, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2227 = shufflevector <4 x double> %wide.vec2225, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %401 = getelementptr %struct.doublecomplex, ptr %invariant.gep1837, i64 %399
  %wide.vec2228 = load <4 x double>, ptr %401, align 8, !tbaa !9
  %strided.vec2229 = shufflevector <4 x double> %wide.vec2228, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2230 = shufflevector <4 x double> %wide.vec2228, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %402 = fneg <2 x double> %strided.vec2227
  %403 = fmul <2 x double> %strided.vec2230, %402
  %404 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2226, <2 x double> %strided.vec2229, <2 x double> %403)
  %405 = fmul <2 x double> %strided.vec2229, %strided.vec2227
  %406 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2226, <2 x double> %strided.vec2230, <2 x double> %405)
  %407 = getelementptr %struct.doublecomplex, ptr %invariant.gep1839, i64 %offset.idx2224
  %wide.vec2231 = load <4 x double>, ptr %407, align 8, !tbaa !9
  %strided.vec2232 = shufflevector <4 x double> %wide.vec2231, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2233 = shufflevector <4 x double> %wide.vec2231, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %408 = fadd <2 x double> %404, %strided.vec2232
  %409 = fadd <2 x double> %406, %strided.vec2233
  %410 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %offset.idx2224
  %wide.vec2234 = load <4 x double>, ptr %410, align 8, !tbaa !9
  %strided.vec2235 = shufflevector <4 x double> %wide.vec2234, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2236 = shufflevector <4 x double> %wide.vec2234, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %411 = getelementptr %struct.doublecomplex, ptr %invariant.gep1841, i64 %offset.idx2224
  %wide.vec2237 = load <4 x double>, ptr %411, align 8, !tbaa !9
  %strided.vec2238 = shufflevector <4 x double> %wide.vec2237, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2239 = shufflevector <4 x double> %wide.vec2237, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %412 = fneg <2 x double> %strided.vec2236
  %413 = fmul <2 x double> %strided.vec2239, %412
  %414 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2235, <2 x double> %strided.vec2238, <2 x double> %413)
  %415 = fmul <2 x double> %strided.vec2238, %strided.vec2236
  %416 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2235, <2 x double> %strided.vec2239, <2 x double> %415)
  %417 = fadd <2 x double> %408, %414
  %418 = fadd <2 x double> %409, %416
  %419 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %offset.idx2224
  %wide.vec2240 = load <4 x double>, ptr %419, align 8, !tbaa !9
  %strided.vec2241 = shufflevector <4 x double> %wide.vec2240, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2242 = shufflevector <4 x double> %wide.vec2240, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %gep2292 = getelementptr %struct.doublecomplex, ptr %invariant.gep2291, i64 %index2223
  %wide.vec2243 = load <4 x double>, ptr %gep2292, align 8, !tbaa !9
  %strided.vec2244 = shufflevector <4 x double> %wide.vec2243, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2245 = shufflevector <4 x double> %wide.vec2243, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %420 = fneg <2 x double> %strided.vec2242
  %421 = fmul <2 x double> %strided.vec2245, %420
  %422 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2241, <2 x double> %strided.vec2244, <2 x double> %421)
  %423 = fmul <2 x double> %strided.vec2244, %strided.vec2242
  %424 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2241, <2 x double> %strided.vec2245, <2 x double> %423)
  %425 = fadd <2 x double> %417, %422
  %426 = fadd <2 x double> %418, %424
  %interleaved.vec2246 = shufflevector <2 x double> %425, <2 x double> %426, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec2246, ptr %407, align 8, !tbaa !9
  %index.next2247 = add nuw i64 %index2223, 2
  %427 = icmp eq i64 %index.next2247, %n.vec2219
  br i1 %427, label %middle.block2214, label %vector.body2222, !llvm.loop !27

middle.block2214:                                 ; preds = %vector.body2222
  br i1 %cmp.n2248, label %.loopexit1319, label %.lr.ph1568.preheader2250

.lr.ph1568.preheader2250:                         ; preds = %.lr.ph1568.preheader, %middle.block2214
  %indvars.iv1739.ph = phi i64 [ 2, %.lr.ph1568.preheader ], [ %ind.end2220, %middle.block2214 ]
  br label %.lr.ph1568

.lr.ph1568:                                       ; preds = %.lr.ph1568.preheader2250, %.lr.ph1568
  %indvars.iv1739 = phi i64 [ %indvars.iv.next1740, %.lr.ph1568 ], [ %indvars.iv1739.ph, %.lr.ph1568.preheader2250 ]
  %428 = add nsw i64 %indvars.iv1739, -1
  %429 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %428
  %430 = load double, ptr %429, align 8, !tbaa !20
  %gep1838 = getelementptr %struct.doublecomplex, ptr %invariant.gep1837, i64 %428
  %431 = getelementptr inbounds i8, ptr %429, i64 8
  %432 = load double, ptr %431, align 8, !tbaa !22
  %433 = fneg double %432
  %gep1840 = getelementptr %struct.doublecomplex, ptr %invariant.gep1839, i64 %indvars.iv1739
  %434 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1739
  %435 = load double, ptr %434, align 8, !tbaa !20
  %gep1842 = getelementptr %struct.doublecomplex, ptr %invariant.gep1841, i64 %indvars.iv1739
  %436 = getelementptr inbounds i8, ptr %434, i64 8
  %437 = load double, ptr %436, align 8, !tbaa !22
  %438 = fneg double %437
  %indvars.iv.next1740 = add nuw nsw i64 %indvars.iv1739, 1
  %439 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1739
  %440 = load double, ptr %439, align 8, !tbaa !20
  %gep1844 = getelementptr %struct.doublecomplex, ptr %invariant.gep1843, i64 %indvars.iv.next1740
  %441 = getelementptr inbounds i8, ptr %439, i64 8
  %442 = load double, ptr %441, align 8, !tbaa !22
  %443 = fneg double %442
  %444 = load <2 x double>, ptr %gep1838, align 8, !tbaa !9
  %445 = insertelement <2 x double> poison, double %432, i64 0
  %446 = insertelement <2 x double> %445, double %433, i64 1
  %447 = fmul <2 x double> %444, %446
  %448 = shufflevector <2 x double> %447, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %449 = insertelement <2 x double> poison, double %430, i64 0
  %450 = shufflevector <2 x double> %449, <2 x double> poison, <2 x i32> zeroinitializer
  %451 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %450, <2 x double> %444, <2 x double> %448)
  %452 = load <2 x double>, ptr %gep1840, align 8, !tbaa !9
  %453 = fadd <2 x double> %451, %452
  %454 = load <2 x double>, ptr %gep1842, align 8, !tbaa !9
  %455 = insertelement <2 x double> poison, double %437, i64 0
  %456 = insertelement <2 x double> %455, double %438, i64 1
  %457 = fmul <2 x double> %454, %456
  %458 = shufflevector <2 x double> %457, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %459 = insertelement <2 x double> poison, double %435, i64 0
  %460 = shufflevector <2 x double> %459, <2 x double> poison, <2 x i32> zeroinitializer
  %461 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %460, <2 x double> %454, <2 x double> %458)
  %462 = fadd <2 x double> %453, %461
  %463 = load <2 x double>, ptr %gep1844, align 8, !tbaa !9
  %464 = insertelement <2 x double> poison, double %442, i64 0
  %465 = insertelement <2 x double> %464, double %443, i64 1
  %466 = fmul <2 x double> %463, %465
  %467 = shufflevector <2 x double> %466, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %468 = insertelement <2 x double> poison, double %440, i64 0
  %469 = shufflevector <2 x double> %468, <2 x double> poison, <2 x i32> zeroinitializer
  %470 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %469, <2 x double> %463, <2 x double> %467)
  %471 = fadd <2 x double> %462, %470
  store <2 x double> %471, ptr %gep1840, align 8, !tbaa !9
  %exitcond1743.not = icmp eq i64 %indvars.iv.next1740, %wide.trip.count1742
  br i1 %exitcond1743.not, label %.loopexit1319, label %.lr.ph1568, !llvm.loop !28

.loopexit1319:                                    ; preds = %.lr.ph1568, %middle.block2214, %.lr.ph1596.split
  %indvars.iv.next1745 = add nuw nsw i64 %indvars.iv1744, 1
  %exitcond1748.not = icmp eq i64 %indvars.iv.next1745, %wide.trip.count1752
  br i1 %exitcond1748.not, label %.loopexit1318, label %.lr.ph1596.split, !llvm.loop !26

472:                                              ; preds = %271
  %473 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.2) #6
  %.not1310 = icmp eq i32 %473, 0
  br i1 %.not1310, label %.loopexit1318, label %474

474:                                              ; preds = %472
  %475 = load i32, ptr %2, align 4, !tbaa !5
  %invariant.gep1627 = getelementptr i8, ptr %6, i64 -32
  %.not13111629 = icmp slt i32 %475, 1
  br i1 %.not13111629, label %.loopexit1318, label %.lr.ph1632

.lr.ph1632:                                       ; preds = %474
  %476 = getelementptr inbounds i8, ptr %14, i64 8
  %477 = getelementptr inbounds i8, ptr %13, i64 8
  %478 = getelementptr inbounds i8, ptr %16, i64 8
  %479 = getelementptr inbounds i8, ptr %15, i64 8
  %480 = getelementptr inbounds i8, ptr %17, i64 8
  %481 = getelementptr inbounds i8, ptr %18, i64 8
  %482 = sext i32 %25 to i64
  %483 = sext i32 %22 to i64
  %484 = add nuw i32 %475, 1
  %wide.trip.count1762 = zext i32 %484 to i64
  %invariant.gep2299 = getelementptr i8, ptr %27, i64 16
  %invariant.gep2301 = getelementptr i8, ptr %27, i64 16
  br label %485

485:                                              ; preds = %.lr.ph1632, %.loopexit
  %indvars.iv1759 = phi i64 [ 1, %.lr.ph1632 ], [ %indvars.iv.next1760, %.loopexit ]
  %486 = load i32, ptr %1, align 4, !tbaa !5
  %487 = icmp eq i32 %486, 1
  %488 = mul nsw i64 %indvars.iv1759, %482
  %489 = call { double, double } @Cd(ptr noundef %5)
  %490 = extractvalue { double, double } %489, 0
  %491 = extractvalue { double, double } %489, 1
  %492 = fneg double %491
  %493 = mul nsw i64 %indvars.iv1759, %483
  %494 = getelementptr %struct.doublecomplex, ptr %24, i64 %493
  %495 = getelementptr i8, ptr %494, i64 16
  br i1 %487, label %496, label %511

496:                                              ; preds = %485
  %497 = call ptr @_pCd(ptr noundef nonnull %13)
  %498 = getelementptr inbounds i8, ptr %497, i64 8
  store double %490, ptr %497, align 8
  store double %492, ptr %498, align 8
  %499 = load <2 x double>, ptr %13, align 16
  %500 = load double, ptr %477, align 8, !tbaa !22
  %501 = fneg double %500
  %gep2302 = getelementptr %struct.doublecomplex, ptr %invariant.gep2301, i64 %488
  %502 = load <2 x double>, ptr %495, align 8, !tbaa !9
  %503 = insertelement <2 x double> poison, double %500, i64 0
  %504 = insertelement <2 x double> %503, double %501, i64 1
  %505 = fmul <2 x double> %502, %504
  %506 = shufflevector <2 x double> %505, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %507 = shufflevector <2 x double> %499, <2 x double> poison, <2 x i32> zeroinitializer
  %508 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %507, <2 x double> %502, <2 x double> %506)
  %509 = load <2 x double>, ptr %gep2302, align 8, !tbaa !9
  %510 = fadd <2 x double> %509, %508
  store <2 x double> %510, ptr %gep2302, align 8, !tbaa !9
  br label %.loopexit

511:                                              ; preds = %485
  %512 = call ptr @_pCd(ptr noundef nonnull %14)
  %513 = getelementptr inbounds i8, ptr %512, i64 8
  store double %490, ptr %512, align 8
  store double %492, ptr %513, align 8
  %514 = load <2 x double>, ptr %14, align 16
  %515 = load double, ptr %476, align 8, !tbaa !22
  %516 = fneg double %515
  %517 = load <2 x double>, ptr %495, align 8, !tbaa !9
  %518 = insertelement <2 x double> poison, double %515, i64 0
  %519 = insertelement <2 x double> %518, double %516, i64 1
  %520 = fmul <2 x double> %517, %519
  %521 = shufflevector <2 x double> %520, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %522 = shufflevector <2 x double> %514, <2 x double> poison, <2 x i32> zeroinitializer
  %523 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %522, <2 x double> %517, <2 x double> %521)
  store <2 x double> %523, ptr %13, align 16, !tbaa !9
  %gep2300 = getelementptr %struct.doublecomplex, ptr %invariant.gep2299, i64 %488
  %524 = getelementptr i8, ptr %494, i64 32
  %525 = load <2 x double>, ptr %gep2300, align 8, !tbaa !9
  %526 = fadd <2 x double> %523, %525
  %527 = call { double, double } @Cd(ptr noundef %4)
  %528 = extractvalue { double, double } %527, 0
  %529 = extractvalue { double, double } %527, 1
  %530 = fneg double %529
  %531 = call ptr @_pCd(ptr noundef nonnull %16)
  %532 = getelementptr inbounds i8, ptr %531, i64 8
  store double %528, ptr %531, align 8
  store double %530, ptr %532, align 8
  %533 = load <2 x double>, ptr %16, align 16
  %534 = load double, ptr %478, align 8, !tbaa !22
  %535 = fneg double %534
  %536 = load <2 x double>, ptr %524, align 8, !tbaa !9
  %537 = insertelement <2 x double> poison, double %534, i64 0
  %538 = insertelement <2 x double> %537, double %535, i64 1
  %539 = fmul <2 x double> %536, %538
  %540 = shufflevector <2 x double> %539, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %541 = shufflevector <2 x double> %533, <2 x double> poison, <2 x i32> zeroinitializer
  %542 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %541, <2 x double> %536, <2 x double> %540)
  store <2 x double> %542, ptr %15, align 16, !tbaa !9
  %543 = fadd <2 x double> %526, %542
  store <2 x double> %543, ptr %gep2300, align 8, !tbaa !9
  %544 = load i32, ptr %1, align 4, !tbaa !5
  %545 = sext i32 %544 to i64
  %gep1628 = getelementptr %struct.doublecomplex, ptr %invariant.gep1627, i64 %545
  %546 = call { double, double } @Cd(ptr noundef %gep1628)
  %547 = extractvalue { double, double } %546, 0
  %548 = extractvalue { double, double } %546, 1
  %549 = fneg double %548
  %550 = call ptr @_pCd(ptr noundef nonnull %14)
  %551 = getelementptr inbounds i8, ptr %550, i64 8
  store double %547, ptr %550, align 8
  store double %549, ptr %551, align 8
  %552 = load i32, ptr %1, align 4, !tbaa !5
  %553 = trunc nsw i64 %493 to i32
  %554 = add i32 %553, -1
  %555 = add i32 %554, %552
  %556 = load <2 x double>, ptr %14, align 16
  %557 = sext i32 %555 to i64
  %558 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %557
  %559 = load double, ptr %476, align 8, !tbaa !22
  %560 = fneg double %559
  %561 = load <2 x double>, ptr %558, align 8, !tbaa !9
  %562 = insertelement <2 x double> poison, double %559, i64 0
  %563 = insertelement <2 x double> %562, double %560, i64 1
  %564 = fmul <2 x double> %561, %563
  %565 = shufflevector <2 x double> %564, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %566 = shufflevector <2 x double> %556, <2 x double> poison, <2 x i32> zeroinitializer
  %567 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %566, <2 x double> %561, <2 x double> %565)
  store <2 x double> %567, ptr %13, align 16, !tbaa !9
  %568 = getelementptr %struct.doublecomplex, ptr %27, i64 %488
  %569 = getelementptr %struct.doublecomplex, ptr %568, i64 %545
  %570 = sext i32 %552 to i64
  %571 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %570
  %572 = getelementptr %struct.doublecomplex, ptr %24, i64 %493
  %573 = load <2 x double>, ptr %569, align 8, !tbaa !9
  %574 = fadd <2 x double> %567, %573
  %575 = call { double, double } @Cd(ptr noundef nonnull %571)
  %576 = extractvalue { double, double } %575, 0
  %577 = extractvalue { double, double } %575, 1
  %578 = fneg double %577
  %579 = call ptr @_pCd(ptr noundef nonnull %16)
  %580 = getelementptr inbounds i8, ptr %579, i64 8
  store double %576, ptr %579, align 8
  store double %578, ptr %580, align 8
  %581 = load i32, ptr %1, align 4, !tbaa !5
  %582 = sext i32 %581 to i64
  %583 = load <2 x double>, ptr %16, align 16
  %584 = getelementptr %struct.doublecomplex, ptr %572, i64 %582
  %585 = load double, ptr %478, align 8, !tbaa !22
  %586 = fneg double %585
  %587 = load <2 x double>, ptr %584, align 8, !tbaa !9
  %588 = insertelement <2 x double> poison, double %585, i64 0
  %589 = insertelement <2 x double> %588, double %586, i64 1
  %590 = fmul <2 x double> %587, %589
  %591 = shufflevector <2 x double> %590, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %592 = shufflevector <2 x double> %583, <2 x double> poison, <2 x i32> zeroinitializer
  %593 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %592, <2 x double> %587, <2 x double> %591)
  store <2 x double> %593, ptr %15, align 16, !tbaa !9
  %594 = fadd <2 x double> %574, %593
  store <2 x double> %594, ptr %569, align 8, !tbaa !9
  %.not1312.not1623 = icmp sgt i32 %581, 2
  br i1 %.not1312.not1623, label %.lr.ph1626.preheader, label %.loopexit

.lr.ph1626.preheader:                             ; preds = %511
  %wide.trip.count1757 = zext nneg i32 %581 to i64
  %invariant.gep1851 = getelementptr %struct.doublecomplex, ptr %24, i64 %493
  %invariant.gep1853 = getelementptr %struct.doublecomplex, ptr %27, i64 %488
  %invariant.gep1855 = getelementptr %struct.doublecomplex, ptr %24, i64 %493
  %invariant.gep1857 = getelementptr %struct.doublecomplex, ptr %24, i64 %493
  br label %.lr.ph1626

.lr.ph1626:                                       ; preds = %.lr.ph1626.preheader, %.lr.ph1626
  %indvars.iv1754 = phi i64 [ 2, %.lr.ph1626.preheader ], [ %indvars.iv.next1755, %.lr.ph1626 ]
  %595 = add nsw i64 %indvars.iv1754, -1
  %596 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %595
  %597 = call { double, double } @Cd(ptr noundef nonnull %596)
  %598 = extractvalue { double, double } %597, 0
  %599 = extractvalue { double, double } %597, 1
  %600 = fneg double %599
  %601 = call ptr @_pCd(ptr noundef nonnull %15)
  %602 = getelementptr inbounds i8, ptr %601, i64 8
  store double %598, ptr %601, align 8
  store double %600, ptr %602, align 8
  %603 = load <2 x double>, ptr %15, align 16
  %gep1852 = getelementptr %struct.doublecomplex, ptr %invariant.gep1851, i64 %595
  %604 = load double, ptr %479, align 8, !tbaa !22
  %605 = fneg double %604
  %606 = load <2 x double>, ptr %gep1852, align 8, !tbaa !9
  %607 = insertelement <2 x double> poison, double %604, i64 0
  %608 = insertelement <2 x double> %607, double %605, i64 1
  %609 = fmul <2 x double> %606, %608
  %610 = shufflevector <2 x double> %609, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %611 = shufflevector <2 x double> %603, <2 x double> poison, <2 x i32> zeroinitializer
  %612 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %611, <2 x double> %606, <2 x double> %610)
  store <2 x double> %612, ptr %14, align 16, !tbaa !9
  %gep1854 = getelementptr %struct.doublecomplex, ptr %invariant.gep1853, i64 %indvars.iv1754
  %613 = load <2 x double>, ptr %gep1854, align 8, !tbaa !9
  %614 = fadd <2 x double> %612, %613
  store <2 x double> %614, ptr %13, align 16, !tbaa !9
  %615 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1754
  %616 = call { double, double } @Cd(ptr noundef nonnull %615)
  %617 = extractvalue { double, double } %616, 0
  %618 = extractvalue { double, double } %616, 1
  %619 = fneg double %618
  %620 = call ptr @_pCd(ptr noundef nonnull %17)
  %621 = getelementptr inbounds i8, ptr %620, i64 8
  store double %617, ptr %620, align 8
  store double %619, ptr %621, align 8
  %622 = load <2 x double>, ptr %17, align 16
  %gep1856 = getelementptr %struct.doublecomplex, ptr %invariant.gep1855, i64 %indvars.iv1754
  %623 = load double, ptr %480, align 8, !tbaa !22
  %624 = fneg double %623
  %625 = load <2 x double>, ptr %gep1856, align 8, !tbaa !9
  %626 = insertelement <2 x double> poison, double %623, i64 0
  %627 = insertelement <2 x double> %626, double %624, i64 1
  %628 = fmul <2 x double> %625, %627
  %629 = shufflevector <2 x double> %628, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %630 = shufflevector <2 x double> %622, <2 x double> poison, <2 x i32> zeroinitializer
  %631 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %630, <2 x double> %625, <2 x double> %629)
  store <2 x double> %631, ptr %16, align 16, !tbaa !9
  %632 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1754
  %indvars.iv.next1755 = add nuw nsw i64 %indvars.iv1754, 1
  %gep1858 = getelementptr %struct.doublecomplex, ptr %invariant.gep1857, i64 %indvars.iv.next1755
  %633 = load <2 x double>, ptr %13, align 16, !tbaa !9
  %634 = fadd <2 x double> %631, %633
  %635 = call { double, double } @Cd(ptr noundef nonnull %632)
  %636 = extractvalue { double, double } %635, 0
  %637 = extractvalue { double, double } %635, 1
  %638 = fneg double %637
  %639 = call ptr @_pCd(ptr noundef nonnull %18)
  %640 = getelementptr inbounds i8, ptr %639, i64 8
  store double %636, ptr %639, align 8
  store double %638, ptr %640, align 8
  %641 = load <2 x double>, ptr %18, align 16
  %642 = load double, ptr %481, align 8, !tbaa !22
  %643 = load <2 x double>, ptr %gep1858, align 8, !tbaa !9
  %644 = fneg double %642
  %645 = insertelement <2 x double> poison, double %642, i64 0
  %646 = insertelement <2 x double> %645, double %644, i64 1
  %647 = fmul <2 x double> %643, %646
  %648 = shufflevector <2 x double> %647, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %649 = shufflevector <2 x double> %641, <2 x double> poison, <2 x i32> zeroinitializer
  %650 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %649, <2 x double> %643, <2 x double> %648)
  %651 = fadd <2 x double> %634, %650
  store <2 x double> %651, ptr %gep1854, align 8, !tbaa !9
  %exitcond1758.not = icmp eq i64 %indvars.iv.next1755, %wide.trip.count1757
  br i1 %exitcond1758.not, label %.loopexit, label %.lr.ph1626, !llvm.loop !29

.loopexit:                                        ; preds = %.lr.ph1626, %511, %496
  %indvars.iv.next1760 = add nuw nsw i64 %indvars.iv1759, 1
  %exitcond1763.not = icmp eq i64 %indvars.iv.next1760, %wide.trip.count1762
  br i1 %exitcond1763.not, label %.loopexit1318, label %485, !llvm.loop !30

652:                                              ; preds = %.loopexit1329
  %653 = fcmp oeq double %68, -1.000000e+00
  br i1 %653, label %654, label %.loopexit1318

654:                                              ; preds = %652
  %655 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #6
  %.not1299 = icmp eq i32 %655, 0
  br i1 %.not1299, label %855, label %656

656:                                              ; preds = %654
  %657 = load i32, ptr %2, align 4, !tbaa !5
  %.not13061372 = icmp slt i32 %657, 1
  br i1 %.not13061372, label %.loopexit1318, label %.lr.ph1379

.lr.ph1379:                                       ; preds = %656
  %658 = load i32, ptr %1, align 4, !tbaa !5
  %659 = icmp eq i32 %658, 1
  %660 = getelementptr inbounds i8, ptr %5, i64 8
  %661 = getelementptr inbounds i8, ptr %6, i64 8
  %662 = add nsw i32 %658, -1
  %663 = sext i32 %662 to i64
  %664 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %663
  %665 = getelementptr inbounds i8, ptr %664, i64 8
  %666 = sext i32 %658 to i64
  %667 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %666
  %668 = getelementptr inbounds i8, ptr %667, i64 8
  %.not1307.not1351 = icmp sgt i32 %658, 2
  %669 = sext i32 %25 to i64
  %670 = sext i32 %22 to i64
  %671 = add nuw i32 %657, 1
  %wide.trip.count1697 = zext i32 %671 to i64
  br i1 %659, label %.lr.ph1379.split.us.preheader, label %.lr.ph1379.split.preheader

.lr.ph1379.split.us.preheader:                    ; preds = %.lr.ph1379
  %invariant.gep2267 = getelementptr i8, ptr %24, i64 16
  %invariant.gep2269 = getelementptr i8, ptr %27, i64 16
  br label %.lr.ph1379.split.us

.lr.ph1379.split.preheader:                       ; preds = %.lr.ph1379
  %invariant.gep1795 = getelementptr %struct.doublecomplex, ptr %24, i64 %663
  %invariant.gep1797 = getelementptr %struct.doublecomplex, ptr %27, i64 %666
  %invariant.gep1799 = getelementptr %struct.doublecomplex, ptr %24, i64 %666
  %wide.trip.count1687 = zext i32 %658 to i64
  %672 = shl nsw i64 %669, 4
  %673 = shl nsw i64 %26, 4
  %674 = getelementptr i8, ptr %10, i64 %672
  %675 = getelementptr i8, ptr %674, i64 %673
  %scevgep1871 = getelementptr i8, ptr %675, i64 32
  %676 = shl nuw nsw i64 %wide.trip.count1697, 4
  %677 = add nsw i64 %676, -16
  %678 = mul i64 %677, %669
  %679 = shl nuw nsw i64 %wide.trip.count1687, 4
  %680 = getelementptr i8, ptr %10, i64 %678
  %681 = getelementptr i8, ptr %680, i64 %673
  %682 = getelementptr i8, ptr %681, i64 %679
  %scevgep1872 = getelementptr i8, ptr %682, i64 -8
  %683 = getelementptr i8, ptr %4, i64 %679
  %scevgep1873 = getelementptr i8, ptr %683, i64 -40
  %684 = shl nsw i64 %670, 4
  %685 = shl nsw i64 %23, 4
  %686 = getelementptr i8, ptr %7, i64 %684
  %687 = getelementptr i8, ptr %686, i64 %685
  %scevgep1874 = getelementptr i8, ptr %687, i64 16
  %688 = mul i64 %677, %670
  %689 = add i64 %688, %685
  %690 = add i64 %689, %679
  %691 = or disjoint i64 %690, 8
  %scevgep1875 = getelementptr i8, ptr %7, i64 %691
  %scevgep1876 = getelementptr i8, ptr %5, i64 16
  %692 = add nsw i64 %679, -24
  %scevgep1877 = getelementptr i8, ptr %5, i64 %692
  %scevgep1878 = getelementptr i8, ptr %6, i64 16
  %scevgep1879 = getelementptr i8, ptr %6, i64 %692
  %693 = getelementptr i8, ptr %10, i64 %672
  %694 = getelementptr i8, ptr %693, i64 %673
  %scevgep1880 = getelementptr i8, ptr %694, i64 40
  %695 = getelementptr i8, ptr %10, i64 %678
  %696 = getelementptr i8, ptr %695, i64 %673
  %scevgep1881 = getelementptr i8, ptr %696, i64 %679
  %scevgep1882 = getelementptr i8, ptr %4, i64 8
  %697 = getelementptr i8, ptr %4, i64 %679
  %scevgep1883 = getelementptr i8, ptr %697, i64 -32
  %698 = getelementptr i8, ptr %7, i64 %684
  %699 = getelementptr i8, ptr %698, i64 %685
  %scevgep1884 = getelementptr i8, ptr %699, i64 24
  %700 = getelementptr i8, ptr %7, i64 %688
  %701 = getelementptr i8, ptr %700, i64 %685
  %702 = getelementptr i8, ptr %701, i64 %679
  %scevgep1885 = getelementptr i8, ptr %702, i64 16
  %scevgep1886 = getelementptr i8, ptr %5, i64 24
  %703 = add nsw i64 %679, -16
  %scevgep1887 = getelementptr i8, ptr %5, i64 %703
  %scevgep1888 = getelementptr i8, ptr %6, i64 24
  %scevgep1889 = getelementptr i8, ptr %6, i64 %703
  %704 = add nsw i64 %wide.trip.count1687, -2
  %invariant.gep2265 = getelementptr i8, ptr %27, i64 16
  %min.iters.check1928 = icmp ult i64 %704, 4
  %bound0 = icmp ult ptr %scevgep1871, %scevgep1873
  %bound1 = icmp ugt ptr %scevgep1872, %4
  %found.conflict = and i1 %bound0, %bound1
  %stride.check = icmp slt i32 %25, 0
  %705 = or i1 %found.conflict, %stride.check
  %bound01890 = icmp ult ptr %scevgep1871, %scevgep1875
  %bound11891 = icmp ult ptr %scevgep1874, %scevgep1872
  %found.conflict1892 = and i1 %bound01890, %bound11891
  %706 = or i32 %25, %22
  %707 = icmp slt i32 %706, 0
  %708 = or i1 %found.conflict1892, %707
  %conflict.rdx = or i1 %705, %708
  %bound01895 = icmp ult ptr %scevgep1871, %scevgep1877
  %bound11896 = icmp ult ptr %scevgep1876, %scevgep1872
  %found.conflict1897 = and i1 %bound01895, %bound11896
  %conflict.rdx1899 = or i1 %found.conflict1897, %conflict.rdx
  %bound01900 = icmp ult ptr %scevgep1871, %scevgep1879
  %bound11901 = icmp ult ptr %scevgep1878, %scevgep1872
  %found.conflict1902 = and i1 %bound01900, %bound11901
  %conflict.rdx1904 = or i1 %found.conflict1902, %conflict.rdx1899
  %bound01905 = icmp ult ptr %scevgep1880, %scevgep1883
  %bound11906 = icmp ult ptr %scevgep1882, %scevgep1881
  %found.conflict1907 = and i1 %bound01905, %bound11906
  %conflict.rdx1909 = or i1 %found.conflict1907, %conflict.rdx1904
  %bound01910 = icmp ult ptr %scevgep1880, %scevgep1885
  %bound11911 = icmp ult ptr %scevgep1884, %scevgep1881
  %found.conflict1912 = and i1 %bound01910, %bound11911
  %709 = or i32 %25, %22
  %710 = icmp slt i32 %709, 0
  %711 = or i1 %found.conflict1912, %710
  %conflict.rdx1915 = or i1 %conflict.rdx1909, %711
  %bound01916 = icmp ult ptr %scevgep1880, %scevgep1887
  %bound11917 = icmp ult ptr %scevgep1886, %scevgep1881
  %found.conflict1918 = and i1 %bound01916, %bound11917
  %conflict.rdx1920 = or i1 %found.conflict1918, %conflict.rdx1915
  %bound01921 = icmp ult ptr %scevgep1880, %scevgep1889
  %bound11922 = icmp ult ptr %scevgep1888, %scevgep1881
  %found.conflict1923 = and i1 %bound01921, %bound11922
  %conflict.rdx1925 = or i1 %found.conflict1923, %conflict.rdx1920
  %n.vec1931 = and i64 %704, -2
  %ind.end1932 = add nsw i64 %n.vec1931, 2
  %cmp.n1960 = icmp eq i64 %704, %n.vec1931
  br label %.lr.ph1379.split

.lr.ph1379.split.us:                              ; preds = %.lr.ph1379.split.us.preheader, %.lr.ph1379.split.us
  %indvars.iv1694 = phi i64 [ %indvars.iv.next1695, %.lr.ph1379.split.us ], [ 1, %.lr.ph1379.split.us.preheader ]
  %712 = mul nsw i64 %indvars.iv1694, %669
  %713 = mul nsw i64 %indvars.iv1694, %670
  %714 = load double, ptr %5, align 8, !tbaa !20
  %gep2268 = getelementptr %struct.doublecomplex, ptr %invariant.gep2267, i64 %713
  %715 = load double, ptr %660, align 8, !tbaa !22
  %716 = fneg double %715
  %gep2270 = getelementptr %struct.doublecomplex, ptr %invariant.gep2269, i64 %712
  %717 = load <2 x double>, ptr %gep2268, align 8, !tbaa !9
  %718 = insertelement <2 x double> poison, double %715, i64 0
  %719 = insertelement <2 x double> %718, double %716, i64 1
  %720 = fmul <2 x double> %717, %719
  %721 = shufflevector <2 x double> %720, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %722 = insertelement <2 x double> poison, double %714, i64 0
  %723 = shufflevector <2 x double> %722, <2 x double> poison, <2 x i32> zeroinitializer
  %724 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %723, <2 x double> %717, <2 x double> %721)
  %725 = load <2 x double>, ptr %gep2270, align 8, !tbaa !9
  %726 = fsub <2 x double> %725, %724
  store <2 x double> %726, ptr %gep2270, align 8, !tbaa !9
  %indvars.iv.next1695 = add nuw nsw i64 %indvars.iv1694, 1
  %exitcond1698.not = icmp eq i64 %indvars.iv.next1695, %wide.trip.count1697
  br i1 %exitcond1698.not, label %.loopexit1318, label %.lr.ph1379.split.us, !llvm.loop !31

.lr.ph1379.split:                                 ; preds = %.lr.ph1379.split.preheader, %.loopexit1327
  %indvars.iv1689 = phi i64 [ 1, %.lr.ph1379.split.preheader ], [ %indvars.iv.next1690, %.loopexit1327 ]
  %727 = mul nsw i64 %indvars.iv1689, %669
  %728 = mul nsw i64 %indvars.iv1689, %670
  %729 = load double, ptr %5, align 8, !tbaa !20
  %730 = getelementptr %struct.doublecomplex, ptr %24, i64 %728
  %731 = getelementptr i8, ptr %730, i64 16
  %732 = load double, ptr %660, align 8, !tbaa !22
  %733 = fneg double %732
  %gep2266 = getelementptr %struct.doublecomplex, ptr %invariant.gep2265, i64 %727
  %734 = load double, ptr %6, align 8, !tbaa !20
  %735 = getelementptr i8, ptr %730, i64 32
  %736 = load double, ptr %661, align 8, !tbaa !22
  %737 = fneg double %736
  %738 = load <2 x double>, ptr %731, align 8, !tbaa !9
  %739 = insertelement <2 x double> poison, double %732, i64 0
  %740 = insertelement <2 x double> %739, double %733, i64 1
  %741 = fmul <2 x double> %738, %740
  %742 = shufflevector <2 x double> %741, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %743 = insertelement <2 x double> poison, double %729, i64 0
  %744 = shufflevector <2 x double> %743, <2 x double> poison, <2 x i32> zeroinitializer
  %745 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %744, <2 x double> %738, <2 x double> %742)
  %746 = load <2 x double>, ptr %gep2266, align 8, !tbaa !9
  %747 = fsub <2 x double> %746, %745
  %748 = load <2 x double>, ptr %735, align 8, !tbaa !9
  %749 = insertelement <2 x double> poison, double %736, i64 0
  %750 = insertelement <2 x double> %749, double %737, i64 1
  %751 = fmul <2 x double> %748, %750
  %752 = shufflevector <2 x double> %751, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %753 = insertelement <2 x double> poison, double %734, i64 0
  %754 = shufflevector <2 x double> %753, <2 x double> poison, <2 x i32> zeroinitializer
  %755 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %754, <2 x double> %748, <2 x double> %752)
  %756 = fsub <2 x double> %747, %755
  store <2 x double> %756, ptr %gep2266, align 8, !tbaa !9
  %757 = load double, ptr %664, align 8, !tbaa !20
  %gep1796 = getelementptr %struct.doublecomplex, ptr %invariant.gep1795, i64 %728
  %758 = load double, ptr %665, align 8, !tbaa !22
  %759 = fneg double %758
  %gep1798 = getelementptr %struct.doublecomplex, ptr %invariant.gep1797, i64 %727
  %760 = load double, ptr %667, align 8, !tbaa !20
  %gep1800 = getelementptr %struct.doublecomplex, ptr %invariant.gep1799, i64 %728
  %761 = load double, ptr %668, align 8, !tbaa !22
  %762 = fneg double %761
  %763 = load <2 x double>, ptr %gep1796, align 8, !tbaa !9
  %764 = insertelement <2 x double> poison, double %758, i64 0
  %765 = insertelement <2 x double> %764, double %759, i64 1
  %766 = fmul <2 x double> %763, %765
  %767 = shufflevector <2 x double> %766, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %768 = insertelement <2 x double> poison, double %757, i64 0
  %769 = shufflevector <2 x double> %768, <2 x double> poison, <2 x i32> zeroinitializer
  %770 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %769, <2 x double> %763, <2 x double> %767)
  %771 = load <2 x double>, ptr %gep1798, align 8, !tbaa !9
  %772 = fsub <2 x double> %771, %770
  %773 = load <2 x double>, ptr %gep1800, align 8, !tbaa !9
  %774 = insertelement <2 x double> poison, double %761, i64 0
  %775 = insertelement <2 x double> %774, double %762, i64 1
  %776 = fmul <2 x double> %773, %775
  %777 = shufflevector <2 x double> %776, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %778 = insertelement <2 x double> poison, double %760, i64 0
  %779 = shufflevector <2 x double> %778, <2 x double> poison, <2 x i32> zeroinitializer
  %780 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %779, <2 x double> %773, <2 x double> %777)
  %781 = fsub <2 x double> %772, %780
  store <2 x double> %781, ptr %gep1798, align 8, !tbaa !9
  br i1 %.not1307.not1351, label %.lr.ph.preheader, label %.loopexit1327

.lr.ph.preheader:                                 ; preds = %.lr.ph1379.split
  %invariant.gep1787 = getelementptr %struct.doublecomplex, ptr %24, i64 %728
  %invariant.gep1789 = getelementptr %struct.doublecomplex, ptr %27, i64 %727
  %invariant.gep1791 = getelementptr %struct.doublecomplex, ptr %24, i64 %728
  %invariant.gep1793 = getelementptr %struct.doublecomplex, ptr %24, i64 %728
  %brmerge2304 = select i1 %min.iters.check1928, i1 true, i1 %conflict.rdx1925
  br i1 %brmerge2304, label %.lr.ph.preheader2260, label %vector.ph1929

vector.ph1929:                                    ; preds = %.lr.ph.preheader
  %invariant.gep2263 = getelementptr i8, ptr %invariant.gep1793, i64 48
  br label %vector.body1934

vector.body1934:                                  ; preds = %vector.body1934, %vector.ph1929
  %index1935 = phi i64 [ 0, %vector.ph1929 ], [ %index.next1959, %vector.body1934 ]
  %offset.idx1936 = add i64 %index1935, 2
  %782 = or disjoint i64 %index1935, 1
  %783 = getelementptr %struct.doublecomplex, ptr %4, i64 %index1935
  %wide.vec1937 = load <4 x double>, ptr %783, align 8, !tbaa !9
  %strided.vec1938 = shufflevector <4 x double> %wide.vec1937, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1939 = shufflevector <4 x double> %wide.vec1937, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %784 = getelementptr %struct.doublecomplex, ptr %invariant.gep1787, i64 %782
  %wide.vec1940 = load <4 x double>, ptr %784, align 8, !tbaa !9
  %strided.vec1941 = shufflevector <4 x double> %wide.vec1940, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1942 = shufflevector <4 x double> %wide.vec1940, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %785 = fneg <2 x double> %strided.vec1939
  %786 = fmul <2 x double> %strided.vec1942, %785
  %787 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1938, <2 x double> %strided.vec1941, <2 x double> %786)
  %788 = fmul <2 x double> %strided.vec1941, %strided.vec1939
  %789 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1938, <2 x double> %strided.vec1942, <2 x double> %788)
  %790 = getelementptr %struct.doublecomplex, ptr %invariant.gep1789, i64 %offset.idx1936
  %wide.vec1943 = load <4 x double>, ptr %790, align 8, !tbaa !9
  %strided.vec1944 = shufflevector <4 x double> %wide.vec1943, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1945 = shufflevector <4 x double> %wide.vec1943, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %791 = fsub <2 x double> %strided.vec1944, %787
  %792 = fsub <2 x double> %strided.vec1945, %789
  %793 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %offset.idx1936
  %wide.vec1946 = load <4 x double>, ptr %793, align 8, !tbaa !9
  %strided.vec1947 = shufflevector <4 x double> %wide.vec1946, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1948 = shufflevector <4 x double> %wide.vec1946, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %794 = getelementptr %struct.doublecomplex, ptr %invariant.gep1791, i64 %offset.idx1936
  %wide.vec1949 = load <4 x double>, ptr %794, align 8, !tbaa !9
  %strided.vec1950 = shufflevector <4 x double> %wide.vec1949, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1951 = shufflevector <4 x double> %wide.vec1949, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %795 = fneg <2 x double> %strided.vec1948
  %796 = fmul <2 x double> %strided.vec1951, %795
  %797 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1947, <2 x double> %strided.vec1950, <2 x double> %796)
  %798 = fmul <2 x double> %strided.vec1950, %strided.vec1948
  %799 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1947, <2 x double> %strided.vec1951, <2 x double> %798)
  %800 = fsub <2 x double> %791, %797
  %801 = fsub <2 x double> %792, %799
  %802 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %offset.idx1936
  %wide.vec1952 = load <4 x double>, ptr %802, align 8, !tbaa !9
  %strided.vec1953 = shufflevector <4 x double> %wide.vec1952, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1954 = shufflevector <4 x double> %wide.vec1952, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %gep2264 = getelementptr %struct.doublecomplex, ptr %invariant.gep2263, i64 %index1935
  %wide.vec1955 = load <4 x double>, ptr %gep2264, align 8, !tbaa !9
  %strided.vec1956 = shufflevector <4 x double> %wide.vec1955, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec1957 = shufflevector <4 x double> %wide.vec1955, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %803 = fneg <2 x double> %strided.vec1954
  %804 = fmul <2 x double> %strided.vec1957, %803
  %805 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1953, <2 x double> %strided.vec1956, <2 x double> %804)
  %806 = fmul <2 x double> %strided.vec1956, %strided.vec1954
  %807 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec1953, <2 x double> %strided.vec1957, <2 x double> %806)
  %808 = fsub <2 x double> %800, %805
  %809 = fsub <2 x double> %801, %807
  %interleaved.vec1958 = shufflevector <2 x double> %808, <2 x double> %809, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec1958, ptr %790, align 8, !tbaa !9
  %index.next1959 = add nuw i64 %index1935, 2
  %810 = icmp eq i64 %index.next1959, %n.vec1931
  br i1 %810, label %middle.block1926, label %vector.body1934, !llvm.loop !32

middle.block1926:                                 ; preds = %vector.body1934
  br i1 %cmp.n1960, label %.loopexit1327, label %.lr.ph.preheader2260

.lr.ph.preheader2260:                             ; preds = %.lr.ph.preheader, %middle.block1926
  %indvars.iv1684.ph = phi i64 [ 2, %.lr.ph.preheader ], [ %ind.end1932, %middle.block1926 ]
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader2260, %.lr.ph
  %indvars.iv1684 = phi i64 [ %indvars.iv.next1685, %.lr.ph ], [ %indvars.iv1684.ph, %.lr.ph.preheader2260 ]
  %811 = add nsw i64 %indvars.iv1684, -1
  %812 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %811
  %813 = load double, ptr %812, align 8, !tbaa !20
  %gep1788 = getelementptr %struct.doublecomplex, ptr %invariant.gep1787, i64 %811
  %814 = getelementptr inbounds i8, ptr %812, i64 8
  %815 = load double, ptr %814, align 8, !tbaa !22
  %816 = fneg double %815
  %gep1790 = getelementptr %struct.doublecomplex, ptr %invariant.gep1789, i64 %indvars.iv1684
  %817 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1684
  %818 = load double, ptr %817, align 8, !tbaa !20
  %gep1792 = getelementptr %struct.doublecomplex, ptr %invariant.gep1791, i64 %indvars.iv1684
  %819 = getelementptr inbounds i8, ptr %817, i64 8
  %820 = load double, ptr %819, align 8, !tbaa !22
  %821 = fneg double %820
  %indvars.iv.next1685 = add nuw nsw i64 %indvars.iv1684, 1
  %822 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %indvars.iv1684
  %823 = load double, ptr %822, align 8, !tbaa !20
  %gep1794 = getelementptr %struct.doublecomplex, ptr %invariant.gep1793, i64 %indvars.iv.next1685
  %824 = getelementptr inbounds i8, ptr %822, i64 8
  %825 = load double, ptr %824, align 8, !tbaa !22
  %826 = fneg double %825
  %827 = load <2 x double>, ptr %gep1788, align 8, !tbaa !9
  %828 = insertelement <2 x double> poison, double %815, i64 0
  %829 = insertelement <2 x double> %828, double %816, i64 1
  %830 = fmul <2 x double> %827, %829
  %831 = shufflevector <2 x double> %830, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %832 = insertelement <2 x double> poison, double %813, i64 0
  %833 = shufflevector <2 x double> %832, <2 x double> poison, <2 x i32> zeroinitializer
  %834 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %833, <2 x double> %827, <2 x double> %831)
  %835 = load <2 x double>, ptr %gep1790, align 8, !tbaa !9
  %836 = fsub <2 x double> %835, %834
  %837 = load <2 x double>, ptr %gep1792, align 8, !tbaa !9
  %838 = insertelement <2 x double> poison, double %820, i64 0
  %839 = insertelement <2 x double> %838, double %821, i64 1
  %840 = fmul <2 x double> %837, %839
  %841 = shufflevector <2 x double> %840, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %842 = insertelement <2 x double> poison, double %818, i64 0
  %843 = shufflevector <2 x double> %842, <2 x double> poison, <2 x i32> zeroinitializer
  %844 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %843, <2 x double> %837, <2 x double> %841)
  %845 = fsub <2 x double> %836, %844
  %846 = load <2 x double>, ptr %gep1794, align 8, !tbaa !9
  %847 = insertelement <2 x double> poison, double %825, i64 0
  %848 = insertelement <2 x double> %847, double %826, i64 1
  %849 = fmul <2 x double> %846, %848
  %850 = shufflevector <2 x double> %849, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %851 = insertelement <2 x double> poison, double %823, i64 0
  %852 = shufflevector <2 x double> %851, <2 x double> poison, <2 x i32> zeroinitializer
  %853 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %852, <2 x double> %846, <2 x double> %850)
  %854 = fsub <2 x double> %845, %853
  store <2 x double> %854, ptr %gep1790, align 8, !tbaa !9
  %exitcond1688.not = icmp eq i64 %indvars.iv.next1685, %wide.trip.count1687
  br i1 %exitcond1688.not, label %.loopexit1327, label %.lr.ph, !llvm.loop !33

.loopexit1327:                                    ; preds = %.lr.ph, %middle.block1926, %.lr.ph1379.split
  %indvars.iv.next1690 = add nuw nsw i64 %indvars.iv1689, 1
  %exitcond1693.not = icmp eq i64 %indvars.iv.next1690, %wide.trip.count1697
  br i1 %exitcond1693.not, label %.loopexit1318, label %.lr.ph1379.split, !llvm.loop !31

855:                                              ; preds = %654
  %856 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #6
  %.not1300 = icmp eq i32 %856, 0
  br i1 %.not1300, label %1056, label %857

857:                                              ; preds = %855
  %858 = load i32, ptr %2, align 4, !tbaa !5
  %.not13041441 = icmp slt i32 %858, 1
  br i1 %.not13041441, label %.loopexit1318, label %.lr.ph1448

.lr.ph1448:                                       ; preds = %857
  %859 = load i32, ptr %1, align 4, !tbaa !5
  %860 = icmp eq i32 %859, 1
  %861 = getelementptr inbounds i8, ptr %5, i64 8
  %862 = getelementptr inbounds i8, ptr %4, i64 8
  %863 = add nsw i32 %859, -1
  %864 = sext i32 %863 to i64
  %865 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %864
  %866 = getelementptr inbounds i8, ptr %865, i64 8
  %867 = sext i32 %859 to i64
  %868 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %867
  %869 = getelementptr inbounds i8, ptr %868, i64 8
  %.not1305.not1417 = icmp sgt i32 %859, 2
  %870 = sext i32 %25 to i64
  %871 = sext i32 %22 to i64
  %872 = add nuw i32 %858, 1
  %wide.trip.count1712 = zext i32 %872 to i64
  br i1 %860, label %.lr.ph1448.split.us.preheader, label %.lr.ph1448.split.preheader

.lr.ph1448.split.us.preheader:                    ; preds = %.lr.ph1448
  %invariant.gep2275 = getelementptr i8, ptr %24, i64 16
  %invariant.gep2277 = getelementptr i8, ptr %27, i64 16
  br label %.lr.ph1448.split.us

.lr.ph1448.split.preheader:                       ; preds = %.lr.ph1448
  %invariant.gep1809 = getelementptr %struct.doublecomplex, ptr %24, i64 %864
  %invariant.gep1811 = getelementptr %struct.doublecomplex, ptr %27, i64 %867
  %invariant.gep1813 = getelementptr %struct.doublecomplex, ptr %24, i64 %867
  %wide.trip.count1702 = zext i32 %859 to i64
  %873 = shl nsw i64 %870, 4
  %874 = shl nsw i64 %26, 4
  %875 = getelementptr i8, ptr %10, i64 %873
  %876 = getelementptr i8, ptr %875, i64 %874
  %scevgep1962 = getelementptr i8, ptr %876, i64 32
  %877 = shl nuw nsw i64 %wide.trip.count1712, 4
  %878 = add nsw i64 %877, -16
  %879 = mul i64 %878, %870
  %880 = shl nuw nsw i64 %wide.trip.count1702, 4
  %881 = getelementptr i8, ptr %10, i64 %879
  %882 = getelementptr i8, ptr %881, i64 %874
  %883 = getelementptr i8, ptr %882, i64 %880
  %scevgep1963 = getelementptr i8, ptr %883, i64 -8
  %884 = getelementptr i8, ptr %6, i64 %880
  %scevgep1964 = getelementptr i8, ptr %884, i64 -40
  %885 = shl nsw i64 %871, 4
  %886 = shl nsw i64 %23, 4
  %887 = getelementptr i8, ptr %7, i64 %885
  %888 = getelementptr i8, ptr %887, i64 %886
  %scevgep1965 = getelementptr i8, ptr %888, i64 16
  %889 = mul i64 %878, %871
  %890 = add i64 %889, %886
  %891 = add i64 %890, %880
  %892 = or disjoint i64 %891, 8
  %scevgep1966 = getelementptr i8, ptr %7, i64 %892
  %scevgep1967 = getelementptr i8, ptr %5, i64 16
  %893 = add nsw i64 %880, -24
  %scevgep1968 = getelementptr i8, ptr %5, i64 %893
  %scevgep1969 = getelementptr i8, ptr %4, i64 16
  %scevgep1970 = getelementptr i8, ptr %4, i64 %893
  %894 = getelementptr i8, ptr %10, i64 %873
  %895 = getelementptr i8, ptr %894, i64 %874
  %scevgep1971 = getelementptr i8, ptr %895, i64 40
  %896 = getelementptr i8, ptr %10, i64 %879
  %897 = getelementptr i8, ptr %896, i64 %874
  %scevgep1972 = getelementptr i8, ptr %897, i64 %880
  %scevgep1973 = getelementptr i8, ptr %6, i64 8
  %898 = getelementptr i8, ptr %6, i64 %880
  %scevgep1974 = getelementptr i8, ptr %898, i64 -32
  %899 = getelementptr i8, ptr %7, i64 %885
  %900 = getelementptr i8, ptr %899, i64 %886
  %scevgep1975 = getelementptr i8, ptr %900, i64 24
  %901 = getelementptr i8, ptr %7, i64 %889
  %902 = getelementptr i8, ptr %901, i64 %886
  %903 = getelementptr i8, ptr %902, i64 %880
  %scevgep1976 = getelementptr i8, ptr %903, i64 16
  %scevgep1977 = getelementptr i8, ptr %5, i64 24
  %904 = add nsw i64 %880, -16
  %scevgep1978 = getelementptr i8, ptr %5, i64 %904
  %scevgep1979 = getelementptr i8, ptr %4, i64 24
  %scevgep1980 = getelementptr i8, ptr %4, i64 %904
  %905 = add nsw i64 %wide.trip.count1702, -2
  %invariant.gep2273 = getelementptr i8, ptr %27, i64 16
  %min.iters.check2024 = icmp ult i64 %905, 4
  %bound01981 = icmp ult ptr %scevgep1962, %scevgep1964
  %bound11982 = icmp ugt ptr %scevgep1963, %6
  %found.conflict1983 = and i1 %bound01981, %bound11982
  %stride.check1984 = icmp slt i32 %25, 0
  %906 = or i1 %found.conflict1983, %stride.check1984
  %bound01985 = icmp ult ptr %scevgep1962, %scevgep1966
  %bound11986 = icmp ult ptr %scevgep1965, %scevgep1963
  %found.conflict1987 = and i1 %bound01985, %bound11986
  %907 = or i32 %25, %22
  %908 = icmp slt i32 %907, 0
  %909 = or i1 %found.conflict1987, %908
  %conflict.rdx1990 = or i1 %906, %909
  %bound01991 = icmp ult ptr %scevgep1962, %scevgep1968
  %bound11992 = icmp ult ptr %scevgep1967, %scevgep1963
  %found.conflict1993 = and i1 %bound01991, %bound11992
  %conflict.rdx1995 = or i1 %found.conflict1993, %conflict.rdx1990
  %bound01996 = icmp ult ptr %scevgep1962, %scevgep1970
  %bound11997 = icmp ult ptr %scevgep1969, %scevgep1963
  %found.conflict1998 = and i1 %bound01996, %bound11997
  %conflict.rdx2000 = or i1 %found.conflict1998, %conflict.rdx1995
  %bound02001 = icmp ult ptr %scevgep1971, %scevgep1974
  %bound12002 = icmp ult ptr %scevgep1973, %scevgep1972
  %found.conflict2003 = and i1 %bound02001, %bound12002
  %conflict.rdx2005 = or i1 %found.conflict2003, %conflict.rdx2000
  %bound02006 = icmp ult ptr %scevgep1971, %scevgep1976
  %bound12007 = icmp ult ptr %scevgep1975, %scevgep1972
  %found.conflict2008 = and i1 %bound02006, %bound12007
  %910 = or i32 %25, %22
  %911 = icmp slt i32 %910, 0
  %912 = or i1 %found.conflict2008, %911
  %conflict.rdx2011 = or i1 %conflict.rdx2005, %912
  %bound02012 = icmp ult ptr %scevgep1971, %scevgep1978
  %bound12013 = icmp ult ptr %scevgep1977, %scevgep1972
  %found.conflict2014 = and i1 %bound02012, %bound12013
  %conflict.rdx2016 = or i1 %found.conflict2014, %conflict.rdx2011
  %bound02017 = icmp ult ptr %scevgep1971, %scevgep1980
  %bound12018 = icmp ult ptr %scevgep1979, %scevgep1972
  %found.conflict2019 = and i1 %bound02017, %bound12018
  %conflict.rdx2021 = or i1 %found.conflict2019, %conflict.rdx2016
  %n.vec2027 = and i64 %905, -2
  %ind.end2028 = add nsw i64 %n.vec2027, 2
  %cmp.n2056 = icmp eq i64 %905, %n.vec2027
  br label %.lr.ph1448.split

.lr.ph1448.split.us:                              ; preds = %.lr.ph1448.split.us.preheader, %.lr.ph1448.split.us
  %indvars.iv1709 = phi i64 [ %indvars.iv.next1710, %.lr.ph1448.split.us ], [ 1, %.lr.ph1448.split.us.preheader ]
  %913 = mul nsw i64 %indvars.iv1709, %870
  %914 = mul nsw i64 %indvars.iv1709, %871
  %915 = load double, ptr %5, align 8, !tbaa !20
  %gep2276 = getelementptr %struct.doublecomplex, ptr %invariant.gep2275, i64 %914
  %916 = load double, ptr %861, align 8, !tbaa !22
  %917 = fneg double %916
  %gep2278 = getelementptr %struct.doublecomplex, ptr %invariant.gep2277, i64 %913
  %918 = load <2 x double>, ptr %gep2276, align 8, !tbaa !9
  %919 = insertelement <2 x double> poison, double %916, i64 0
  %920 = insertelement <2 x double> %919, double %917, i64 1
  %921 = fmul <2 x double> %918, %920
  %922 = shufflevector <2 x double> %921, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %923 = insertelement <2 x double> poison, double %915, i64 0
  %924 = shufflevector <2 x double> %923, <2 x double> poison, <2 x i32> zeroinitializer
  %925 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %924, <2 x double> %918, <2 x double> %922)
  %926 = load <2 x double>, ptr %gep2278, align 8, !tbaa !9
  %927 = fsub <2 x double> %926, %925
  store <2 x double> %927, ptr %gep2278, align 8, !tbaa !9
  %indvars.iv.next1710 = add nuw nsw i64 %indvars.iv1709, 1
  %exitcond1713.not = icmp eq i64 %indvars.iv.next1710, %wide.trip.count1712
  br i1 %exitcond1713.not, label %.loopexit1318, label %.lr.ph1448.split.us, !llvm.loop !34

.lr.ph1448.split:                                 ; preds = %.lr.ph1448.split.preheader, %.loopexit1325
  %indvars.iv1704 = phi i64 [ 1, %.lr.ph1448.split.preheader ], [ %indvars.iv.next1705, %.loopexit1325 ]
  %928 = mul nsw i64 %indvars.iv1704, %870
  %929 = mul nsw i64 %indvars.iv1704, %871
  %930 = load double, ptr %5, align 8, !tbaa !20
  %931 = getelementptr %struct.doublecomplex, ptr %24, i64 %929
  %932 = getelementptr i8, ptr %931, i64 16
  %933 = load double, ptr %861, align 8, !tbaa !22
  %934 = fneg double %933
  %gep2274 = getelementptr %struct.doublecomplex, ptr %invariant.gep2273, i64 %928
  %935 = load double, ptr %4, align 8, !tbaa !20
  %936 = getelementptr i8, ptr %931, i64 32
  %937 = load double, ptr %862, align 8, !tbaa !22
  %938 = fneg double %937
  %939 = load <2 x double>, ptr %932, align 8, !tbaa !9
  %940 = insertelement <2 x double> poison, double %933, i64 0
  %941 = insertelement <2 x double> %940, double %934, i64 1
  %942 = fmul <2 x double> %939, %941
  %943 = shufflevector <2 x double> %942, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %944 = insertelement <2 x double> poison, double %930, i64 0
  %945 = shufflevector <2 x double> %944, <2 x double> poison, <2 x i32> zeroinitializer
  %946 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %945, <2 x double> %939, <2 x double> %943)
  %947 = load <2 x double>, ptr %gep2274, align 8, !tbaa !9
  %948 = fsub <2 x double> %947, %946
  %949 = load <2 x double>, ptr %936, align 8, !tbaa !9
  %950 = insertelement <2 x double> poison, double %937, i64 0
  %951 = insertelement <2 x double> %950, double %938, i64 1
  %952 = fmul <2 x double> %949, %951
  %953 = shufflevector <2 x double> %952, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %954 = insertelement <2 x double> poison, double %935, i64 0
  %955 = shufflevector <2 x double> %954, <2 x double> poison, <2 x i32> zeroinitializer
  %956 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %955, <2 x double> %949, <2 x double> %953)
  %957 = fsub <2 x double> %948, %956
  store <2 x double> %957, ptr %gep2274, align 8, !tbaa !9
  %958 = load double, ptr %865, align 8, !tbaa !20
  %gep1810 = getelementptr %struct.doublecomplex, ptr %invariant.gep1809, i64 %929
  %959 = load double, ptr %866, align 8, !tbaa !22
  %960 = fneg double %959
  %gep1812 = getelementptr %struct.doublecomplex, ptr %invariant.gep1811, i64 %928
  %961 = load double, ptr %868, align 8, !tbaa !20
  %gep1814 = getelementptr %struct.doublecomplex, ptr %invariant.gep1813, i64 %929
  %962 = load double, ptr %869, align 8, !tbaa !22
  %963 = fneg double %962
  %964 = load <2 x double>, ptr %gep1810, align 8, !tbaa !9
  %965 = insertelement <2 x double> poison, double %959, i64 0
  %966 = insertelement <2 x double> %965, double %960, i64 1
  %967 = fmul <2 x double> %964, %966
  %968 = shufflevector <2 x double> %967, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %969 = insertelement <2 x double> poison, double %958, i64 0
  %970 = shufflevector <2 x double> %969, <2 x double> poison, <2 x i32> zeroinitializer
  %971 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %970, <2 x double> %964, <2 x double> %968)
  %972 = load <2 x double>, ptr %gep1812, align 8, !tbaa !9
  %973 = fsub <2 x double> %972, %971
  %974 = load <2 x double>, ptr %gep1814, align 8, !tbaa !9
  %975 = insertelement <2 x double> poison, double %962, i64 0
  %976 = insertelement <2 x double> %975, double %963, i64 1
  %977 = fmul <2 x double> %974, %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 %961, i64 0
  %980 = shufflevector <2 x double> %979, <2 x double> poison, <2 x i32> zeroinitializer
  %981 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %980, <2 x double> %974, <2 x double> %978)
  %982 = fsub <2 x double> %973, %981
  store <2 x double> %982, ptr %gep1812, align 8, !tbaa !9
  br i1 %.not1305.not1417, label %.lr.ph1420.preheader, label %.loopexit1325

.lr.ph1420.preheader:                             ; preds = %.lr.ph1448.split
  %invariant.gep1801 = getelementptr %struct.doublecomplex, ptr %24, i64 %929
  %invariant.gep1803 = getelementptr %struct.doublecomplex, ptr %27, i64 %928
  %invariant.gep1805 = getelementptr %struct.doublecomplex, ptr %24, i64 %929
  %invariant.gep1807 = getelementptr %struct.doublecomplex, ptr %24, i64 %929
  %brmerge2305 = select i1 %min.iters.check2024, i1 true, i1 %conflict.rdx2021
  br i1 %brmerge2305, label %.lr.ph1420.preheader2257, label %vector.ph2025

vector.ph2025:                                    ; preds = %.lr.ph1420.preheader
  %invariant.gep2271 = getelementptr i8, ptr %invariant.gep1807, i64 48
  br label %vector.body2030

vector.body2030:                                  ; preds = %vector.body2030, %vector.ph2025
  %index2031 = phi i64 [ 0, %vector.ph2025 ], [ %index.next2055, %vector.body2030 ]
  %offset.idx2032 = add i64 %index2031, 2
  %983 = or disjoint i64 %index2031, 1
  %984 = getelementptr %struct.doublecomplex, ptr %6, i64 %index2031
  %wide.vec2033 = load <4 x double>, ptr %984, align 8, !tbaa !9
  %strided.vec2034 = shufflevector <4 x double> %wide.vec2033, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2035 = shufflevector <4 x double> %wide.vec2033, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %985 = getelementptr %struct.doublecomplex, ptr %invariant.gep1801, i64 %983
  %wide.vec2036 = load <4 x double>, ptr %985, align 8, !tbaa !9
  %strided.vec2037 = shufflevector <4 x double> %wide.vec2036, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2038 = shufflevector <4 x double> %wide.vec2036, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %986 = fneg <2 x double> %strided.vec2035
  %987 = fmul <2 x double> %strided.vec2038, %986
  %988 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2034, <2 x double> %strided.vec2037, <2 x double> %987)
  %989 = fmul <2 x double> %strided.vec2037, %strided.vec2035
  %990 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2034, <2 x double> %strided.vec2038, <2 x double> %989)
  %991 = getelementptr %struct.doublecomplex, ptr %invariant.gep1803, i64 %offset.idx2032
  %wide.vec2039 = load <4 x double>, ptr %991, align 8, !tbaa !9
  %strided.vec2040 = shufflevector <4 x double> %wide.vec2039, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2041 = shufflevector <4 x double> %wide.vec2039, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %992 = fsub <2 x double> %strided.vec2040, %988
  %993 = fsub <2 x double> %strided.vec2041, %990
  %994 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %offset.idx2032
  %wide.vec2042 = load <4 x double>, ptr %994, align 8, !tbaa !9
  %strided.vec2043 = shufflevector <4 x double> %wide.vec2042, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2044 = shufflevector <4 x double> %wide.vec2042, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %995 = getelementptr %struct.doublecomplex, ptr %invariant.gep1805, i64 %offset.idx2032
  %wide.vec2045 = load <4 x double>, ptr %995, align 8, !tbaa !9
  %strided.vec2046 = shufflevector <4 x double> %wide.vec2045, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2047 = shufflevector <4 x double> %wide.vec2045, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %996 = fneg <2 x double> %strided.vec2044
  %997 = fmul <2 x double> %strided.vec2047, %996
  %998 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2043, <2 x double> %strided.vec2046, <2 x double> %997)
  %999 = fmul <2 x double> %strided.vec2046, %strided.vec2044
  %1000 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2043, <2 x double> %strided.vec2047, <2 x double> %999)
  %1001 = fsub <2 x double> %992, %998
  %1002 = fsub <2 x double> %993, %1000
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %offset.idx2032
  %wide.vec2048 = load <4 x double>, ptr %1003, align 8, !tbaa !9
  %strided.vec2049 = shufflevector <4 x double> %wide.vec2048, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2050 = shufflevector <4 x double> %wide.vec2048, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %gep2272 = getelementptr %struct.doublecomplex, ptr %invariant.gep2271, i64 %index2031
  %wide.vec2051 = load <4 x double>, ptr %gep2272, align 8, !tbaa !9
  %strided.vec2052 = shufflevector <4 x double> %wide.vec2051, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec2053 = shufflevector <4 x double> %wide.vec2051, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %1004 = fneg <2 x double> %strided.vec2050
  %1005 = fmul <2 x double> %strided.vec2053, %1004
  %1006 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2049, <2 x double> %strided.vec2052, <2 x double> %1005)
  %1007 = fmul <2 x double> %strided.vec2052, %strided.vec2050
  %1008 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec2049, <2 x double> %strided.vec2053, <2 x double> %1007)
  %1009 = fsub <2 x double> %1001, %1006
  %1010 = fsub <2 x double> %1002, %1008
  %interleaved.vec2054 = shufflevector <2 x double> %1009, <2 x double> %1010, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec2054, ptr %991, align 8, !tbaa !9
  %index.next2055 = add nuw i64 %index2031, 2
  %1011 = icmp eq i64 %index.next2055, %n.vec2027
  br i1 %1011, label %middle.block2022, label %vector.body2030, !llvm.loop !35

middle.block2022:                                 ; preds = %vector.body2030
  br i1 %cmp.n2056, label %.loopexit1325, label %.lr.ph1420.preheader2257

.lr.ph1420.preheader2257:                         ; preds = %.lr.ph1420.preheader, %middle.block2022
  %indvars.iv1699.ph = phi i64 [ 2, %.lr.ph1420.preheader ], [ %ind.end2028, %middle.block2022 ]
  br label %.lr.ph1420

.lr.ph1420:                                       ; preds = %.lr.ph1420.preheader2257, %.lr.ph1420
  %indvars.iv1699 = phi i64 [ %indvars.iv.next1700, %.lr.ph1420 ], [ %indvars.iv1699.ph, %.lr.ph1420.preheader2257 ]
  %1012 = add nsw i64 %indvars.iv1699, -1
  %1013 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %1012
  %1014 = load double, ptr %1013, align 8, !tbaa !20
  %gep1802 = getelementptr %struct.doublecomplex, ptr %invariant.gep1801, i64 %1012
  %1015 = getelementptr inbounds i8, ptr %1013, i64 8
  %1016 = load double, ptr %1015, align 8, !tbaa !22
  %1017 = fneg double %1016
  %gep1804 = getelementptr %struct.doublecomplex, ptr %invariant.gep1803, i64 %indvars.iv1699
  %1018 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1699
  %1019 = load double, ptr %1018, align 8, !tbaa !20
  %gep1806 = getelementptr %struct.doublecomplex, ptr %invariant.gep1805, i64 %indvars.iv1699
  %1020 = getelementptr inbounds i8, ptr %1018, i64 8
  %1021 = load double, ptr %1020, align 8, !tbaa !22
  %1022 = fneg double %1021
  %indvars.iv.next1700 = add nuw nsw i64 %indvars.iv1699, 1
  %1023 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1699
  %1024 = load double, ptr %1023, align 8, !tbaa !20
  %gep1808 = getelementptr %struct.doublecomplex, ptr %invariant.gep1807, i64 %indvars.iv.next1700
  %1025 = getelementptr inbounds i8, ptr %1023, i64 8
  %1026 = load double, ptr %1025, align 8, !tbaa !22
  %1027 = fneg double %1026
  %1028 = load <2 x double>, ptr %gep1802, align 8, !tbaa !9
  %1029 = insertelement <2 x double> poison, double %1016, i64 0
  %1030 = insertelement <2 x double> %1029, double %1017, i64 1
  %1031 = fmul <2 x double> %1028, %1030
  %1032 = shufflevector <2 x double> %1031, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1033 = insertelement <2 x double> poison, double %1014, i64 0
  %1034 = shufflevector <2 x double> %1033, <2 x double> poison, <2 x i32> zeroinitializer
  %1035 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1034, <2 x double> %1028, <2 x double> %1032)
  %1036 = load <2 x double>, ptr %gep1804, align 8, !tbaa !9
  %1037 = fsub <2 x double> %1036, %1035
  %1038 = load <2 x double>, ptr %gep1806, align 8, !tbaa !9
  %1039 = insertelement <2 x double> poison, double %1021, i64 0
  %1040 = insertelement <2 x double> %1039, double %1022, i64 1
  %1041 = fmul <2 x double> %1038, %1040
  %1042 = shufflevector <2 x double> %1041, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1043 = insertelement <2 x double> poison, double %1019, i64 0
  %1044 = shufflevector <2 x double> %1043, <2 x double> poison, <2 x i32> zeroinitializer
  %1045 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1044, <2 x double> %1038, <2 x double> %1042)
  %1046 = fsub <2 x double> %1037, %1045
  %1047 = load <2 x double>, ptr %gep1808, align 8, !tbaa !9
  %1048 = insertelement <2 x double> poison, double %1026, i64 0
  %1049 = insertelement <2 x double> %1048, double %1027, i64 1
  %1050 = fmul <2 x double> %1047, %1049
  %1051 = shufflevector <2 x double> %1050, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1052 = insertelement <2 x double> poison, double %1024, i64 0
  %1053 = shufflevector <2 x double> %1052, <2 x double> poison, <2 x i32> zeroinitializer
  %1054 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1053, <2 x double> %1047, <2 x double> %1051)
  %1055 = fsub <2 x double> %1046, %1054
  store <2 x double> %1055, ptr %gep1804, align 8, !tbaa !9
  %exitcond1703.not = icmp eq i64 %indvars.iv.next1700, %wide.trip.count1702
  br i1 %exitcond1703.not, label %.loopexit1325, label %.lr.ph1420, !llvm.loop !36

.loopexit1325:                                    ; preds = %.lr.ph1420, %middle.block2022, %.lr.ph1448.split
  %indvars.iv.next1705 = add nuw nsw i64 %indvars.iv1704, 1
  %exitcond1708.not = icmp eq i64 %indvars.iv.next1705, %wide.trip.count1712
  br i1 %exitcond1708.not, label %.loopexit1318, label %.lr.ph1448.split, !llvm.loop !34

1056:                                             ; preds = %855
  %1057 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.2) #6
  %.not1301 = icmp eq i32 %1057, 0
  br i1 %.not1301, label %.loopexit1318, label %1058

1058:                                             ; preds = %1056
  %1059 = load i32, ptr %2, align 4, !tbaa !5
  %invariant.gep = getelementptr i8, ptr %6, i64 -32
  %.not13021479 = icmp slt i32 %1059, 1
  br i1 %.not13021479, label %.loopexit1318, label %.lr.ph1482

.lr.ph1482:                                       ; preds = %1058
  %1060 = getelementptr inbounds i8, ptr %14, i64 8
  %1061 = getelementptr inbounds i8, ptr %13, i64 8
  %1062 = getelementptr inbounds i8, ptr %16, i64 8
  %1063 = getelementptr inbounds i8, ptr %15, i64 8
  %1064 = getelementptr inbounds i8, ptr %17, i64 8
  %1065 = getelementptr inbounds i8, ptr %18, i64 8
  %1066 = sext i32 %25 to i64
  %1067 = sext i32 %22 to i64
  %1068 = add nuw i32 %1059, 1
  %wide.trip.count1722 = zext i32 %1068 to i64
  %invariant.gep2279 = getelementptr i8, ptr %27, i64 16
  %invariant.gep2281 = getelementptr i8, ptr %27, i64 16
  br label %1069

1069:                                             ; preds = %.lr.ph1482, %.loopexit1323
  %indvars.iv1719 = phi i64 [ 1, %.lr.ph1482 ], [ %indvars.iv.next1720, %.loopexit1323 ]
  %1070 = load i32, ptr %1, align 4, !tbaa !5
  %1071 = icmp eq i32 %1070, 1
  %1072 = mul nsw i64 %indvars.iv1719, %1066
  %1073 = call { double, double } @Cd(ptr noundef %5)
  %1074 = extractvalue { double, double } %1073, 0
  %1075 = extractvalue { double, double } %1073, 1
  %1076 = fneg double %1075
  %1077 = mul nsw i64 %indvars.iv1719, %1067
  %1078 = getelementptr %struct.doublecomplex, ptr %24, i64 %1077
  %1079 = getelementptr i8, ptr %1078, i64 16
  br i1 %1071, label %1080, label %1095

1080:                                             ; preds = %1069
  %1081 = call ptr @_pCd(ptr noundef nonnull %13)
  %1082 = getelementptr inbounds i8, ptr %1081, i64 8
  store double %1074, ptr %1081, align 8
  store double %1076, ptr %1082, align 8
  %1083 = load <2 x double>, ptr %13, align 16
  %1084 = load double, ptr %1061, align 8, !tbaa !22
  %1085 = fneg double %1084
  %gep2282 = getelementptr %struct.doublecomplex, ptr %invariant.gep2281, i64 %1072
  %1086 = load <2 x double>, ptr %1079, align 8, !tbaa !9
  %1087 = insertelement <2 x double> poison, double %1084, i64 0
  %1088 = insertelement <2 x double> %1087, double %1085, i64 1
  %1089 = fmul <2 x double> %1086, %1088
  %1090 = shufflevector <2 x double> %1089, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1091 = shufflevector <2 x double> %1083, <2 x double> poison, <2 x i32> zeroinitializer
  %1092 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1091, <2 x double> %1086, <2 x double> %1090)
  %1093 = load <2 x double>, ptr %gep2282, align 8, !tbaa !9
  %1094 = fsub <2 x double> %1093, %1092
  store <2 x double> %1094, ptr %gep2282, align 8, !tbaa !9
  br label %.loopexit1323

1095:                                             ; preds = %1069
  %1096 = call ptr @_pCd(ptr noundef nonnull %14)
  %1097 = getelementptr inbounds i8, ptr %1096, i64 8
  store double %1074, ptr %1096, align 8
  store double %1076, ptr %1097, align 8
  %1098 = load <2 x double>, ptr %14, align 16
  %1099 = load double, ptr %1060, align 8, !tbaa !22
  %1100 = fneg double %1099
  %1101 = load <2 x double>, ptr %1079, align 8, !tbaa !9
  %1102 = insertelement <2 x double> poison, double %1099, i64 0
  %1103 = insertelement <2 x double> %1102, double %1100, i64 1
  %1104 = fmul <2 x double> %1101, %1103
  %1105 = shufflevector <2 x double> %1104, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1106 = shufflevector <2 x double> %1098, <2 x double> poison, <2 x i32> zeroinitializer
  %1107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1106, <2 x double> %1101, <2 x double> %1105)
  store <2 x double> %1107, ptr %13, align 16, !tbaa !9
  %gep2280 = getelementptr %struct.doublecomplex, ptr %invariant.gep2279, i64 %1072
  %1108 = getelementptr i8, ptr %1078, i64 32
  %1109 = load <2 x double>, ptr %gep2280, align 8, !tbaa !9
  %1110 = fsub <2 x double> %1109, %1107
  %1111 = call { double, double } @Cd(ptr noundef %4)
  %1112 = extractvalue { double, double } %1111, 0
  %1113 = extractvalue { double, double } %1111, 1
  %1114 = fneg double %1113
  %1115 = call ptr @_pCd(ptr noundef nonnull %16)
  %1116 = getelementptr inbounds i8, ptr %1115, i64 8
  store double %1112, ptr %1115, align 8
  store double %1114, ptr %1116, align 8
  %1117 = load <2 x double>, ptr %16, align 16
  %1118 = load double, ptr %1062, align 8, !tbaa !22
  %1119 = fneg double %1118
  %1120 = load <2 x double>, ptr %1108, align 8, !tbaa !9
  %1121 = insertelement <2 x double> poison, double %1118, i64 0
  %1122 = insertelement <2 x double> %1121, double %1119, i64 1
  %1123 = fmul <2 x double> %1120, %1122
  %1124 = shufflevector <2 x double> %1123, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1125 = shufflevector <2 x double> %1117, <2 x double> poison, <2 x i32> zeroinitializer
  %1126 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1125, <2 x double> %1120, <2 x double> %1124)
  store <2 x double> %1126, ptr %15, align 16, !tbaa !9
  %1127 = fsub <2 x double> %1110, %1126
  store <2 x double> %1127, ptr %gep2280, align 8, !tbaa !9
  %1128 = load i32, ptr %1, align 4, !tbaa !5
  %1129 = sext i32 %1128 to i64
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %1129
  %1130 = call { double, double } @Cd(ptr noundef %gep)
  %1131 = extractvalue { double, double } %1130, 0
  %1132 = extractvalue { double, double } %1130, 1
  %1133 = fneg double %1132
  %1134 = call ptr @_pCd(ptr noundef nonnull %14)
  %1135 = getelementptr inbounds i8, ptr %1134, i64 8
  store double %1131, ptr %1134, align 8
  store double %1133, ptr %1135, align 8
  %1136 = load i32, ptr %1, align 4, !tbaa !5
  %1137 = trunc nsw i64 %1077 to i32
  %1138 = add i32 %1137, -1
  %1139 = add i32 %1138, %1136
  %1140 = load <2 x double>, ptr %14, align 16
  %1141 = sext i32 %1139 to i64
  %1142 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %1141
  %1143 = load double, ptr %1060, align 8, !tbaa !22
  %1144 = fneg double %1143
  %1145 = load <2 x double>, ptr %1142, align 8, !tbaa !9
  %1146 = insertelement <2 x double> poison, double %1143, i64 0
  %1147 = insertelement <2 x double> %1146, double %1144, i64 1
  %1148 = fmul <2 x double> %1145, %1147
  %1149 = shufflevector <2 x double> %1148, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1150 = shufflevector <2 x double> %1140, <2 x double> poison, <2 x i32> zeroinitializer
  %1151 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1150, <2 x double> %1145, <2 x double> %1149)
  store <2 x double> %1151, ptr %13, align 16, !tbaa !9
  %1152 = getelementptr %struct.doublecomplex, ptr %27, i64 %1072
  %1153 = getelementptr %struct.doublecomplex, ptr %1152, i64 %1129
  %1154 = sext i32 %1136 to i64
  %1155 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %1154
  %1156 = getelementptr %struct.doublecomplex, ptr %24, i64 %1077
  %1157 = load <2 x double>, ptr %1153, align 8, !tbaa !9
  %1158 = fsub <2 x double> %1157, %1151
  %1159 = call { double, double } @Cd(ptr noundef nonnull %1155)
  %1160 = extractvalue { double, double } %1159, 0
  %1161 = extractvalue { double, double } %1159, 1
  %1162 = fneg double %1161
  %1163 = call ptr @_pCd(ptr noundef nonnull %16)
  %1164 = getelementptr inbounds i8, ptr %1163, i64 8
  store double %1160, ptr %1163, align 8
  store double %1162, ptr %1164, align 8
  %1165 = load i32, ptr %1, align 4, !tbaa !5
  %1166 = sext i32 %1165 to i64
  %1167 = load <2 x double>, ptr %16, align 16
  %1168 = getelementptr %struct.doublecomplex, ptr %1156, i64 %1166
  %1169 = load double, ptr %1062, align 8, !tbaa !22
  %1170 = fneg double %1169
  %1171 = load <2 x double>, ptr %1168, align 8, !tbaa !9
  %1172 = insertelement <2 x double> poison, double %1169, i64 0
  %1173 = insertelement <2 x double> %1172, double %1170, i64 1
  %1174 = fmul <2 x double> %1171, %1173
  %1175 = shufflevector <2 x double> %1174, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1176 = shufflevector <2 x double> %1167, <2 x double> poison, <2 x i32> zeroinitializer
  %1177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1176, <2 x double> %1171, <2 x double> %1175)
  store <2 x double> %1177, ptr %15, align 16, !tbaa !9
  %1178 = fsub <2 x double> %1158, %1177
  store <2 x double> %1178, ptr %1153, align 8, !tbaa !9
  %.not1303.not1475 = icmp sgt i32 %1165, 2
  br i1 %.not1303.not1475, label %.lr.ph1478.preheader, label %.loopexit1323

.lr.ph1478.preheader:                             ; preds = %1095
  %wide.trip.count1717 = zext nneg i32 %1165 to i64
  %invariant.gep1815 = getelementptr %struct.doublecomplex, ptr %24, i64 %1077
  %invariant.gep1817 = getelementptr %struct.doublecomplex, ptr %27, i64 %1072
  %invariant.gep1819 = getelementptr %struct.doublecomplex, ptr %24, i64 %1077
  %invariant.gep1821 = getelementptr %struct.doublecomplex, ptr %24, i64 %1077
  br label %.lr.ph1478

.lr.ph1478:                                       ; preds = %.lr.ph1478.preheader, %.lr.ph1478
  %indvars.iv1714 = phi i64 [ 2, %.lr.ph1478.preheader ], [ %indvars.iv.next1715, %.lr.ph1478 ]
  %1179 = add nsw i64 %indvars.iv1714, -1
  %1180 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %1179
  %1181 = call { double, double } @Cd(ptr noundef nonnull %1180)
  %1182 = extractvalue { double, double } %1181, 0
  %1183 = extractvalue { double, double } %1181, 1
  %1184 = fneg double %1183
  %1185 = call ptr @_pCd(ptr noundef nonnull %15)
  %1186 = getelementptr inbounds i8, ptr %1185, i64 8
  store double %1182, ptr %1185, align 8
  store double %1184, ptr %1186, align 8
  %1187 = load <2 x double>, ptr %15, align 16
  %gep1816 = getelementptr %struct.doublecomplex, ptr %invariant.gep1815, i64 %1179
  %1188 = load double, ptr %1063, align 8, !tbaa !22
  %1189 = fneg double %1188
  %1190 = load <2 x double>, ptr %gep1816, align 8, !tbaa !9
  %1191 = insertelement <2 x double> poison, double %1188, i64 0
  %1192 = insertelement <2 x double> %1191, double %1189, i64 1
  %1193 = fmul <2 x double> %1190, %1192
  %1194 = shufflevector <2 x double> %1193, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1195 = shufflevector <2 x double> %1187, <2 x double> poison, <2 x i32> zeroinitializer
  %1196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1195, <2 x double> %1190, <2 x double> %1194)
  store <2 x double> %1196, ptr %14, align 16, !tbaa !9
  %gep1818 = getelementptr %struct.doublecomplex, ptr %invariant.gep1817, i64 %indvars.iv1714
  %1197 = load <2 x double>, ptr %gep1818, align 8, !tbaa !9
  %1198 = fsub <2 x double> %1197, %1196
  store <2 x double> %1198, ptr %13, align 16, !tbaa !9
  %1199 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %indvars.iv1714
  %1200 = call { double, double } @Cd(ptr noundef nonnull %1199)
  %1201 = extractvalue { double, double } %1200, 0
  %1202 = extractvalue { double, double } %1200, 1
  %1203 = fneg double %1202
  %1204 = call ptr @_pCd(ptr noundef nonnull %17)
  %1205 = getelementptr inbounds i8, ptr %1204, i64 8
  store double %1201, ptr %1204, align 8
  store double %1203, ptr %1205, align 8
  %1206 = load <2 x double>, ptr %17, align 16
  %gep1820 = getelementptr %struct.doublecomplex, ptr %invariant.gep1819, i64 %indvars.iv1714
  %1207 = load double, ptr %1064, align 8, !tbaa !22
  %1208 = fneg double %1207
  %1209 = load <2 x double>, ptr %gep1820, align 8, !tbaa !9
  %1210 = insertelement <2 x double> poison, double %1207, i64 0
  %1211 = insertelement <2 x double> %1210, double %1208, i64 1
  %1212 = fmul <2 x double> %1209, %1211
  %1213 = shufflevector <2 x double> %1212, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1214 = shufflevector <2 x double> %1206, <2 x double> poison, <2 x i32> zeroinitializer
  %1215 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1214, <2 x double> %1209, <2 x double> %1213)
  store <2 x double> %1215, ptr %16, align 16, !tbaa !9
  %1216 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %indvars.iv1714
  %indvars.iv.next1715 = add nuw nsw i64 %indvars.iv1714, 1
  %gep1822 = getelementptr %struct.doublecomplex, ptr %invariant.gep1821, i64 %indvars.iv.next1715
  %1217 = load <2 x double>, ptr %13, align 16, !tbaa !9
  %1218 = fsub <2 x double> %1217, %1215
  %1219 = call { double, double } @Cd(ptr noundef nonnull %1216)
  %1220 = extractvalue { double, double } %1219, 0
  %1221 = extractvalue { double, double } %1219, 1
  %1222 = fneg double %1221
  %1223 = call ptr @_pCd(ptr noundef nonnull %18)
  %1224 = getelementptr inbounds i8, ptr %1223, i64 8
  store double %1220, ptr %1223, align 8
  store double %1222, ptr %1224, align 8
  %1225 = load <2 x double>, ptr %18, align 16
  %1226 = load double, ptr %1065, align 8, !tbaa !22
  %1227 = load <2 x double>, ptr %gep1822, align 8, !tbaa !9
  %1228 = fneg double %1226
  %1229 = insertelement <2 x double> poison, double %1226, i64 0
  %1230 = insertelement <2 x double> %1229, double %1228, i64 1
  %1231 = fmul <2 x double> %1227, %1230
  %1232 = shufflevector <2 x double> %1231, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %1233 = shufflevector <2 x double> %1225, <2 x double> poison, <2 x i32> zeroinitializer
  %1234 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1233, <2 x double> %1227, <2 x double> %1232)
  %1235 = fsub <2 x double> %1218, %1234
  store <2 x double> %1235, ptr %gep1818, align 8, !tbaa !9
  %exitcond1718.not = icmp eq i64 %indvars.iv.next1715, %wide.trip.count1717
  br i1 %exitcond1718.not, label %.loopexit1323, label %.lr.ph1478, !llvm.loop !37

.loopexit1323:                                    ; preds = %.lr.ph1478, %1095, %1080
  %indvars.iv.next1720 = add nuw nsw i64 %indvars.iv1719, 1
  %exitcond1723.not = icmp eq i64 %indvars.iv.next1720, %wide.trip.count1722
  br i1 %exitcond1723.not, label %.loopexit1318, label %1069, !llvm.loop !38

.loopexit1318:                                    ; preds = %.loopexit1327, %.lr.ph1379.split.us, %.loopexit1325, %.lr.ph1448.split.us, %.loopexit1323, %.loopexit1321, %.lr.ph1526.split.us, %.loopexit1319, %.lr.ph1596.split.us, %.loopexit, %656, %857, %72, %273, %1058, %474, %472, %1056, %652, %12
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %18) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %15) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %13) #6
  ret void
}

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

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

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

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

; 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 nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4

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

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

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


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