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

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

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

119:                                              ; preds = %16
  %120 = load ptr, ptr %17, align 8, !tbaa !5
  %121 = call i32 @lsame_(ptr noundef %120, ptr noundef @.str.1)
  %122 = icmp ne i32 %121, 0
  br i1 %122, label %125, label %123

123:                                              ; preds = %119
  %124 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -1, ptr %124, align 4, !tbaa !9
  br label %171

125:                                              ; preds = %119, %16
  %126 = load ptr, ptr %18, align 8, !tbaa !5
  %127 = load i32, ptr %126, align 4, !tbaa !9
  %128 = icmp slt i32 %127, 0
  br i1 %128, label %129, label %131

129:                                              ; preds = %125
  %130 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -2, ptr %130, align 4, !tbaa !9
  br label %170

131:                                              ; preds = %125
  %132 = load ptr, ptr %19, align 8, !tbaa !5
  %133 = load i32, ptr %132, align 4, !tbaa !9
  %134 = icmp slt i32 %133, 0
  br i1 %134, label %135, label %137

135:                                              ; preds = %131
  %136 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -3, ptr %136, align 4, !tbaa !9
  br label %169

137:                                              ; preds = %131
  %138 = load ptr, ptr %25, align 8, !tbaa !5
  %139 = load i32, ptr %138, align 4, !tbaa !9
  %140 = load ptr, ptr %18, align 8, !tbaa !5
  %141 = load i32, ptr %140, align 4, !tbaa !9
  %142 = icmp sge i32 1, %141
  br i1 %142, label %143, label %144

143:                                              ; preds = %137
  br label %147

144:                                              ; preds = %137
  %145 = load ptr, ptr %18, align 8, !tbaa !5
  %146 = load i32, ptr %145, align 4, !tbaa !9
  br label %147

147:                                              ; preds = %144, %143
  %148 = phi i32 [ 1, %143 ], [ %146, %144 ]
  %149 = icmp slt i32 %139, %148
  br i1 %149, label %150, label %152

150:                                              ; preds = %147
  %151 = load ptr, ptr %32, align 8, !tbaa !5
  store i32 -9, ptr %151, align 4, !tbaa !9
  br label %168

152:                                              ; preds = %147
  %153 = load ptr, ptr %27, align 8, !tbaa !5
  %154 = load i32, ptr %153, align 4, !tbaa !9
  %155 = load ptr, ptr %18, align 8, !tbaa !5
  %156 = load i32, ptr %155, align 4, !tbaa !9
  %157 = icmp sge i32 1, %156
  br i1 %157, label %158, label %159

158:                                              ; preds = %152
  br label %162

159:                                              ; preds = %152
  %160 = load ptr, ptr %18, align 8, !tbaa !5
  %161 = load i32, ptr %160, align 4, !tbaa !9
  br label %162

162:                                              ; preds = %159, %158
  %163 = phi i32 [ 1, %158 ], [ %161, %159 ]
  %164 = icmp slt i32 %154, %163
  br i1 %164, label %165, label %167

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

167:                                              ; preds = %165, %162
  br label %168

168:                                              ; preds = %167, %150
  br label %169

169:                                              ; preds = %168, %135
  br label %170

170:                                              ; preds = %169, %129
  br label %171

171:                                              ; preds = %170, %123
  %172 = load ptr, ptr %32, align 8, !tbaa !5
  %173 = load i32, ptr %172, align 4, !tbaa !9
  %174 = icmp ne i32 %173, 0
  br i1 %174, label %175, label %180

175:                                              ; preds = %171
  %176 = load ptr, ptr %32, align 8, !tbaa !5
  %177 = load i32, ptr %176, align 4, !tbaa !9
  %178 = sub nsw i32 0, %177
  store i32 %178, ptr %37, align 4, !tbaa !9
  %179 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %37, i32 noundef 6)
  store i32 1, ptr %74, align 4
  br label %3023

180:                                              ; preds = %171
  %181 = load ptr, ptr %18, align 8, !tbaa !5
  %182 = load i32, ptr %181, align 4, !tbaa !9
  %183 = icmp eq i32 %182, 0
  br i1 %183, label %188, label %184

184:                                              ; preds = %180
  %185 = load ptr, ptr %19, align 8, !tbaa !5
  %186 = load i32, ptr %185, align 4, !tbaa !9
  %187 = icmp eq i32 %186, 0
  br i1 %187, label %188, label %208

188:                                              ; preds = %184, %180
  %189 = load ptr, ptr %19, align 8, !tbaa !5
  %190 = load i32, ptr %189, align 4, !tbaa !9
  store i32 %190, ptr %37, align 4, !tbaa !9
  store i32 1, ptr %61, align 4, !tbaa !9
  br label %191

191:                                              ; preds = %204, %188
  %192 = load i32, ptr %61, align 4, !tbaa !9
  %193 = load i32, ptr %37, align 4, !tbaa !9
  %194 = icmp sle i32 %192, %193
  br i1 %194, label %195, label %207

195:                                              ; preds = %191
  %196 = load ptr, ptr %28, align 8, !tbaa !5
  %197 = load i32, ptr %61, align 4, !tbaa !9
  %198 = sext i32 %197 to i64
  %199 = getelementptr inbounds double, ptr %196, i64 %198
  store double 0.000000e+00, ptr %199, align 8, !tbaa !11
  %200 = load ptr, ptr %29, align 8, !tbaa !5
  %201 = load i32, ptr %61, align 4, !tbaa !9
  %202 = sext i32 %201 to i64
  %203 = getelementptr inbounds double, ptr %200, i64 %202
  store double 0.000000e+00, ptr %203, align 8, !tbaa !11
  br label %204

204:                                              ; preds = %195
  %205 = load i32, ptr %61, align 4, !tbaa !9
  %206 = add nsw i32 %205, 1
  store i32 %206, ptr %61, align 4, !tbaa !9
  br label %191, !llvm.loop !13

207:                                              ; preds = %191
  store i32 1, ptr %74, align 4
  br label %3023

208:                                              ; preds = %184
  store i32 4, ptr %70, align 4, !tbaa !9
  %209 = call double @dlamch_(ptr noundef @.str.3)
  store double %209, ptr %73, align 8, !tbaa !11
  %210 = call double @dlamch_(ptr noundef @.str.4)
  store double %210, ptr %71, align 8, !tbaa !11
  %211 = load i32, ptr %70, align 4, !tbaa !9
  %212 = sitofp i32 %211 to double
  %213 = load double, ptr %71, align 8, !tbaa !11
  %214 = fmul double %212, %213
  store double %214, ptr %58, align 8, !tbaa !11
  %215 = load double, ptr %58, align 8, !tbaa !11
  %216 = load double, ptr %73, align 8, !tbaa !11
  %217 = fdiv double %215, %216
  store double %217, ptr %59, align 8, !tbaa !11
  %218 = load ptr, ptr %19, align 8, !tbaa !5
  %219 = load i32, ptr %218, align 4, !tbaa !9
  store i32 %219, ptr %37, align 4, !tbaa !9
  store i32 1, ptr %61, align 4, !tbaa !9
  br label %220

220:                                              ; preds = %3019, %208
  %221 = load i32, ptr %61, align 4, !tbaa !9
  %222 = load i32, ptr %37, align 4, !tbaa !9
  %223 = icmp sle i32 %221, %222
  br i1 %223, label %224, label %3022

224:                                              ; preds = %220
  store i32 1, ptr %63, align 4, !tbaa !9
  store double 3.000000e+00, ptr %72, align 8, !tbaa !11
  br label %225

225:                                              ; preds = %2687, %224
  %226 = load i32, ptr %64, align 4, !tbaa !9
  %227 = icmp ne i32 %226, 0
  br i1 %227, label %228, label %1380

228:                                              ; preds = %225
  %229 = load ptr, ptr %18, align 8, !tbaa !5
  %230 = load i32, ptr %229, align 4, !tbaa !9
  %231 = icmp eq i32 %230, 1
  br i1 %231, label %232, label %356

232:                                              ; preds = %228
  %233 = load i32, ptr %61, align 4, !tbaa !9
  %234 = load i32, ptr %33, align 4, !tbaa !9
  %235 = mul nsw i32 %233, %234
  %236 = add nsw i32 %235, 1
  store i32 %236, ptr %38, align 4, !tbaa !9
  %237 = load ptr, ptr %24, align 8, !tbaa !5
  %238 = load i32, ptr %38, 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 0
  %242 = load double, ptr %241, align 8, !tbaa !15
  %243 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %242, ptr %243, align 8, !tbaa !15
  %244 = load ptr, ptr %24, align 8, !tbaa !5
  %245 = load i32, ptr %38, align 4, !tbaa !9
  %246 = sext i32 %245 to i64
  %247 = getelementptr inbounds %struct.doublecomplex, ptr %244, i64 %246
  %248 = getelementptr inbounds %struct.doublecomplex, ptr %247, i32 0, i32 1
  %249 = load double, ptr %248, align 8, !tbaa !17
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %249, ptr %250, align 8, !tbaa !17
  %251 = load i32, ptr %61, align 4, !tbaa !9
  %252 = load i32, ptr %35, align 4, !tbaa !9
  %253 = mul nsw i32 %251, %252
  %254 = add nsw i32 %253, 1
  store i32 %254, ptr %38, align 4, !tbaa !9
  %255 = load ptr, ptr %20, align 8, !tbaa !5
  %256 = getelementptr inbounds double, ptr %255, i64 1
  %257 = load double, ptr %256, align 8, !tbaa !11
  %258 = load ptr, ptr %26, align 8, !tbaa !5
  %259 = load i32, ptr %38, align 4, !tbaa !9
  %260 = sext i32 %259 to i64
  %261 = getelementptr inbounds %struct.doublecomplex, ptr %258, i64 %260
  %262 = getelementptr inbounds %struct.doublecomplex, ptr %261, i32 0, i32 0
  %263 = load double, ptr %262, align 8, !tbaa !15
  %264 = fmul double %257, %263
  %265 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %264, ptr %265, align 8, !tbaa !15
  %266 = load ptr, ptr %20, align 8, !tbaa !5
  %267 = getelementptr inbounds double, ptr %266, i64 1
  %268 = load double, ptr %267, align 8, !tbaa !11
  %269 = load ptr, ptr %26, align 8, !tbaa !5
  %270 = load i32, ptr %38, align 4, !tbaa !9
  %271 = sext i32 %270 to i64
  %272 = getelementptr inbounds %struct.doublecomplex, ptr %269, i64 %271
  %273 = getelementptr inbounds %struct.doublecomplex, ptr %272, i32 0, i32 1
  %274 = load double, ptr %273, align 8, !tbaa !17
  %275 = fmul double %268, %274
  %276 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %275, ptr %276, align 8, !tbaa !17
  %277 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %278 = load double, ptr %277, align 8, !tbaa !15
  %279 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %278, ptr %279, align 8, !tbaa !15
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %281 = load double, ptr %280, align 8, !tbaa !17
  %282 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %281, ptr %282, align 8, !tbaa !17
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %284 = load double, ptr %283, align 8, !tbaa !15
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %286 = load double, ptr %285, align 8, !tbaa !15
  %287 = fsub double %284, %286
  %288 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %287, ptr %288, align 8, !tbaa !15
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %290 = load double, ptr %289, align 8, !tbaa !17
  %291 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %292 = load double, ptr %291, align 8, !tbaa !17
  %293 = fsub double %290, %292
  %294 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %293, ptr %294, align 8, !tbaa !17
  %295 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %296 = load double, ptr %295, align 8, !tbaa !15
  %297 = load ptr, ptr %30, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.doublecomplex, ptr %297, i64 1
  %299 = getelementptr inbounds %struct.doublecomplex, ptr %298, i32 0, i32 0
  store double %296, ptr %299, align 8, !tbaa !15
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %301 = load double, ptr %300, align 8, !tbaa !17
  %302 = load ptr, ptr %30, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.doublecomplex, ptr %302, i64 1
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %303, i32 0, i32 1
  store double %301, ptr %304, align 8, !tbaa !17
  %305 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %306 = load double, ptr %305, align 8, !tbaa !15
  store double %306, ptr %43, align 8, !tbaa !11
  %307 = load double, ptr %43, align 8, !tbaa !11
  %308 = fcmp oge double %307, 0.000000e+00
  br i1 %308, label %309, label %311

309:                                              ; preds = %232
  %310 = load double, ptr %43, align 8, !tbaa !11
  br label %314

311:                                              ; preds = %232
  %312 = load double, ptr %43, align 8, !tbaa !11
  %313 = fneg double %312
  br label %314

314:                                              ; preds = %311, %309
  %315 = phi double [ %310, %309 ], [ %313, %311 ]
  %316 = call { double, double } @Cd(ptr noundef %65)
  %317 = extractvalue { double, double } %316, 0
  %318 = extractvalue { double, double } %316, 1
  store double %318, ptr %44, align 8, !tbaa !11
  %319 = load double, ptr %44, align 8, !tbaa !11
  %320 = fcmp oge double %319, 0.000000e+00
  br i1 %320, label %321, label %323

321:                                              ; preds = %314
  %322 = load double, ptr %44, align 8, !tbaa !11
  br label %326

323:                                              ; preds = %314
  %324 = load double, ptr %44, align 8, !tbaa !11
  %325 = fneg double %324
  br label %326

326:                                              ; preds = %323, %321
  %327 = phi double [ %322, %321 ], [ %325, %323 ]
  %328 = fadd double %315, %327
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %330 = load double, ptr %329, align 8, !tbaa !15
  store double %330, ptr %45, align 8, !tbaa !11
  %331 = load double, ptr %45, align 8, !tbaa !11
  %332 = fcmp oge double %331, 0.000000e+00
  br i1 %332, label %333, label %335

333:                                              ; preds = %326
  %334 = load double, ptr %45, align 8, !tbaa !11
  br label %338

335:                                              ; preds = %326
  %336 = load double, ptr %45, align 8, !tbaa !11
  %337 = fneg double %336
  br label %338

338:                                              ; preds = %335, %333
  %339 = phi double [ %334, %333 ], [ %337, %335 ]
  %340 = call { double, double } @Cd(ptr noundef %67)
  %341 = extractvalue { double, double } %340, 0
  %342 = extractvalue { double, double } %340, 1
  store double %342, ptr %46, align 8, !tbaa !11
  %343 = load double, ptr %46, align 8, !tbaa !11
  %344 = fcmp oge double %343, 0.000000e+00
  br i1 %344, label %345, label %347

345:                                              ; preds = %338
  %346 = load double, ptr %46, align 8, !tbaa !11
  br label %350

347:                                              ; preds = %338
  %348 = load double, ptr %46, align 8, !tbaa !11
  %349 = fneg double %348
  br label %350

350:                                              ; preds = %347, %345
  %351 = phi double [ %346, %345 ], [ %349, %347 ]
  %352 = fadd double %339, %351
  %353 = fadd double %328, %352
  %354 = load ptr, ptr %31, align 8, !tbaa !5
  %355 = getelementptr inbounds double, ptr %354, i64 1
  store double %353, ptr %355, align 8, !tbaa !11
  br label %1379

356:                                              ; preds = %228
  %357 = load i32, ptr %61, align 4, !tbaa !9
  %358 = load i32, ptr %33, align 4, !tbaa !9
  %359 = mul nsw i32 %357, %358
  %360 = add nsw i32 %359, 1
  store i32 %360, ptr %38, align 4, !tbaa !9
  %361 = load ptr, ptr %24, align 8, !tbaa !5
  %362 = load i32, ptr %38, align 4, !tbaa !9
  %363 = sext i32 %362 to i64
  %364 = getelementptr inbounds %struct.doublecomplex, ptr %361, i64 %363
  %365 = getelementptr inbounds %struct.doublecomplex, ptr %364, i32 0, i32 0
  %366 = load double, ptr %365, align 8, !tbaa !15
  %367 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %366, ptr %367, align 8, !tbaa !15
  %368 = load ptr, ptr %24, align 8, !tbaa !5
  %369 = load i32, ptr %38, align 4, !tbaa !9
  %370 = sext i32 %369 to i64
  %371 = getelementptr inbounds %struct.doublecomplex, ptr %368, i64 %370
  %372 = getelementptr inbounds %struct.doublecomplex, ptr %371, i32 0, i32 1
  %373 = load double, ptr %372, align 8, !tbaa !17
  %374 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %373, ptr %374, align 8, !tbaa !17
  %375 = load i32, ptr %61, align 4, !tbaa !9
  %376 = load i32, ptr %35, align 4, !tbaa !9
  %377 = mul nsw i32 %375, %376
  %378 = add nsw i32 %377, 1
  store i32 %378, ptr %38, align 4, !tbaa !9
  %379 = load ptr, ptr %20, align 8, !tbaa !5
  %380 = getelementptr inbounds double, ptr %379, i64 1
  %381 = load double, ptr %380, align 8, !tbaa !11
  %382 = load ptr, ptr %26, align 8, !tbaa !5
  %383 = load i32, ptr %38, align 4, !tbaa !9
  %384 = sext i32 %383 to i64
  %385 = getelementptr inbounds %struct.doublecomplex, ptr %382, i64 %384
  %386 = getelementptr inbounds %struct.doublecomplex, ptr %385, i32 0, i32 0
  %387 = load double, ptr %386, align 8, !tbaa !15
  %388 = fmul double %381, %387
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %388, ptr %389, align 8, !tbaa !15
  %390 = load ptr, ptr %20, align 8, !tbaa !5
  %391 = getelementptr inbounds double, ptr %390, i64 1
  %392 = load double, ptr %391, align 8, !tbaa !11
  %393 = load ptr, ptr %26, align 8, !tbaa !5
  %394 = load i32, ptr %38, align 4, !tbaa !9
  %395 = sext i32 %394 to i64
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %393, i64 %395
  %397 = getelementptr inbounds %struct.doublecomplex, ptr %396, i32 0, i32 1
  %398 = load double, ptr %397, align 8, !tbaa !17
  %399 = fmul double %392, %398
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %399, ptr %400, align 8, !tbaa !17
  %401 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %402 = load double, ptr %401, align 8, !tbaa !15
  %403 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %402, ptr %403, align 8, !tbaa !15
  %404 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %405 = load double, ptr %404, align 8, !tbaa !17
  %406 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %405, ptr %406, align 8, !tbaa !17
  %407 = load i32, ptr %61, align 4, !tbaa !9
  %408 = load i32, ptr %35, align 4, !tbaa !9
  %409 = mul nsw i32 %407, %408
  %410 = add nsw i32 %409, 2
  store i32 %410, ptr %38, align 4, !tbaa !9
  %411 = load ptr, ptr %21, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.doublecomplex, ptr %411, i64 1
  %413 = getelementptr inbounds %struct.doublecomplex, ptr %412, i32 0, i32 0
  %414 = load double, ptr %413, align 8, !tbaa !15
  %415 = load ptr, ptr %26, align 8, !tbaa !5
  %416 = load i32, ptr %38, align 4, !tbaa !9
  %417 = sext i32 %416 to i64
  %418 = getelementptr inbounds %struct.doublecomplex, ptr %415, i64 %417
  %419 = getelementptr inbounds %struct.doublecomplex, ptr %418, i32 0, i32 0
  %420 = load double, ptr %419, align 8, !tbaa !15
  %421 = load ptr, ptr %21, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.doublecomplex, ptr %421, i64 1
  %423 = getelementptr inbounds %struct.doublecomplex, ptr %422, i32 0, i32 1
  %424 = load double, ptr %423, align 8, !tbaa !17
  %425 = load ptr, ptr %26, align 8, !tbaa !5
  %426 = load i32, ptr %38, align 4, !tbaa !9
  %427 = sext i32 %426 to i64
  %428 = getelementptr inbounds %struct.doublecomplex, ptr %425, i64 %427
  %429 = getelementptr inbounds %struct.doublecomplex, ptr %428, i32 0, i32 1
  %430 = load double, ptr %429, align 8, !tbaa !17
  %431 = fmul double %424, %430
  %432 = fneg double %431
  %433 = call double @llvm.fmuladd.f64(double %414, double %420, double %432)
  %434 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %433, ptr %434, align 8, !tbaa !15
  %435 = load ptr, ptr %21, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.doublecomplex, ptr %435, i64 1
  %437 = getelementptr inbounds %struct.doublecomplex, ptr %436, i32 0, i32 0
  %438 = load double, ptr %437, align 8, !tbaa !15
  %439 = load ptr, ptr %26, align 8, !tbaa !5
  %440 = load i32, ptr %38, align 4, !tbaa !9
  %441 = sext i32 %440 to i64
  %442 = getelementptr inbounds %struct.doublecomplex, ptr %439, i64 %441
  %443 = getelementptr inbounds %struct.doublecomplex, ptr %442, i32 0, i32 1
  %444 = load double, ptr %443, align 8, !tbaa !17
  %445 = load ptr, ptr %21, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.doublecomplex, ptr %445, i64 1
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %446, i32 0, i32 1
  %448 = load double, ptr %447, align 8, !tbaa !17
  %449 = load ptr, ptr %26, align 8, !tbaa !5
  %450 = load i32, ptr %38, 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
  %454 = load double, ptr %453, align 8, !tbaa !15
  %455 = fmul double %448, %454
  %456 = call double @llvm.fmuladd.f64(double %438, double %444, double %455)
  %457 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %456, ptr %457, align 8, !tbaa !17
  %458 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %459 = load double, ptr %458, align 8, !tbaa !15
  %460 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  store double %459, ptr %460, align 8, !tbaa !15
  %461 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %462 = load double, ptr %461, align 8, !tbaa !17
  %463 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  store double %462, ptr %463, align 8, !tbaa !17
  %464 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %465 = load double, ptr %464, align 8, !tbaa !15
  %466 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %467 = load double, ptr %466, align 8, !tbaa !15
  %468 = fsub double %465, %467
  %469 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %468, ptr %469, align 8, !tbaa !15
  %470 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %471 = load double, ptr %470, align 8, !tbaa !17
  %472 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %473 = load double, ptr %472, align 8, !tbaa !17
  %474 = fsub double %471, %473
  %475 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %474, ptr %475, align 8, !tbaa !17
  %476 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %477 = load double, ptr %476, align 8, !tbaa !15
  %478 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  %479 = load double, ptr %478, align 8, !tbaa !15
  %480 = fsub double %477, %479
  %481 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %480, ptr %481, align 8, !tbaa !15
  %482 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %483 = load double, ptr %482, align 8, !tbaa !17
  %484 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  %485 = load double, ptr %484, align 8, !tbaa !17
  %486 = fsub double %483, %485
  %487 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %486, ptr %487, align 8, !tbaa !17
  %488 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %489 = load double, ptr %488, align 8, !tbaa !15
  %490 = load ptr, ptr %30, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.doublecomplex, ptr %490, i64 1
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %491, i32 0, i32 0
  store double %489, ptr %492, align 8, !tbaa !15
  %493 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %494 = load double, ptr %493, align 8, !tbaa !17
  %495 = load ptr, ptr %30, align 8, !tbaa !5
  %496 = getelementptr inbounds %struct.doublecomplex, ptr %495, i64 1
  %497 = getelementptr inbounds %struct.doublecomplex, ptr %496, i32 0, i32 1
  store double %494, ptr %497, align 8, !tbaa !17
  %498 = load i32, ptr %61, align 4, !tbaa !9
  %499 = load i32, ptr %35, align 4, !tbaa !9
  %500 = mul nsw i32 %498, %499
  %501 = add nsw i32 %500, 2
  store i32 %501, ptr %38, align 4, !tbaa !9
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %503 = load double, ptr %502, align 8, !tbaa !15
  store double %503, ptr %43, align 8, !tbaa !11
  %504 = load double, ptr %43, align 8, !tbaa !11
  %505 = fcmp oge double %504, 0.000000e+00
  br i1 %505, label %506, label %508

506:                                              ; preds = %356
  %507 = load double, ptr %43, align 8, !tbaa !11
  br label %511

508:                                              ; preds = %356
  %509 = load double, ptr %43, align 8, !tbaa !11
  %510 = fneg double %509
  br label %511

511:                                              ; preds = %508, %506
  %512 = phi double [ %507, %506 ], [ %510, %508 ]
  %513 = call { double, double } @Cd(ptr noundef %65)
  %514 = extractvalue { double, double } %513, 0
  %515 = extractvalue { double, double } %513, 1
  store double %515, ptr %44, align 8, !tbaa !11
  %516 = load double, ptr %44, align 8, !tbaa !11
  %517 = fcmp oge double %516, 0.000000e+00
  br i1 %517, label %518, label %520

518:                                              ; preds = %511
  %519 = load double, ptr %44, align 8, !tbaa !11
  br label %523

520:                                              ; preds = %511
  %521 = load double, ptr %44, align 8, !tbaa !11
  %522 = fneg double %521
  br label %523

523:                                              ; preds = %520, %518
  %524 = phi double [ %519, %518 ], [ %522, %520 ]
  %525 = fadd double %512, %524
  %526 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %527 = load double, ptr %526, align 8, !tbaa !15
  store double %527, ptr %45, align 8, !tbaa !11
  %528 = load double, ptr %45, align 8, !tbaa !11
  %529 = fcmp oge double %528, 0.000000e+00
  br i1 %529, label %530, label %532

530:                                              ; preds = %523
  %531 = load double, ptr %45, align 8, !tbaa !11
  br label %535

532:                                              ; preds = %523
  %533 = load double, ptr %45, align 8, !tbaa !11
  %534 = fneg double %533
  br label %535

535:                                              ; preds = %532, %530
  %536 = phi double [ %531, %530 ], [ %534, %532 ]
  %537 = call { double, double } @Cd(ptr noundef %67)
  %538 = extractvalue { double, double } %537, 0
  %539 = extractvalue { double, double } %537, 1
  store double %539, ptr %46, align 8, !tbaa !11
  %540 = load double, ptr %46, align 8, !tbaa !11
  %541 = fcmp oge double %540, 0.000000e+00
  br i1 %541, label %542, label %544

542:                                              ; preds = %535
  %543 = load double, ptr %46, align 8, !tbaa !11
  br label %547

544:                                              ; preds = %535
  %545 = load double, ptr %46, align 8, !tbaa !11
  %546 = fneg double %545
  br label %547

547:                                              ; preds = %544, %542
  %548 = phi double [ %543, %542 ], [ %546, %544 ]
  %549 = fadd double %536, %548
  %550 = fadd double %525, %549
  %551 = load ptr, ptr %21, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.doublecomplex, ptr %551, i64 1
  %553 = getelementptr inbounds %struct.doublecomplex, ptr %552, i32 0, i32 0
  %554 = load double, ptr %553, align 8, !tbaa !15
  store double %554, ptr %47, align 8, !tbaa !11
  %555 = load double, ptr %47, align 8, !tbaa !11
  %556 = fcmp oge double %555, 0.000000e+00
  br i1 %556, label %557, label %559

557:                                              ; preds = %547
  %558 = load double, ptr %47, align 8, !tbaa !11
  br label %562

559:                                              ; preds = %547
  %560 = load double, ptr %47, align 8, !tbaa !11
  %561 = fneg double %560
  br label %562

562:                                              ; preds = %559, %557
  %563 = phi double [ %558, %557 ], [ %561, %559 ]
  %564 = load ptr, ptr %21, align 8, !tbaa !5
  %565 = getelementptr inbounds %struct.doublecomplex, ptr %564, i64 1
  %566 = call { double, double } @Cd(ptr noundef %565)
  %567 = extractvalue { double, double } %566, 0
  %568 = extractvalue { double, double } %566, 1
  store double %568, ptr %48, align 8, !tbaa !11
  %569 = load double, ptr %48, align 8, !tbaa !11
  %570 = fcmp oge double %569, 0.000000e+00
  br i1 %570, label %571, label %573

571:                                              ; preds = %562
  %572 = load double, ptr %48, align 8, !tbaa !11
  br label %576

573:                                              ; preds = %562
  %574 = load double, ptr %48, align 8, !tbaa !11
  %575 = fneg double %574
  br label %576

576:                                              ; preds = %573, %571
  %577 = phi double [ %572, %571 ], [ %575, %573 ]
  %578 = fadd double %563, %577
  %579 = load ptr, ptr %26, align 8, !tbaa !5
  %580 = load i32, ptr %38, align 4, !tbaa !9
  %581 = sext i32 %580 to i64
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %579, i64 %581
  %583 = getelementptr inbounds %struct.doublecomplex, ptr %582, i32 0, i32 0
  %584 = load double, ptr %583, align 8, !tbaa !15
  store double %584, ptr %49, align 8, !tbaa !11
  %585 = load double, ptr %49, align 8, !tbaa !11
  %586 = fcmp oge double %585, 0.000000e+00
  br i1 %586, label %587, label %589

587:                                              ; preds = %576
  %588 = load double, ptr %49, align 8, !tbaa !11
  br label %592

589:                                              ; preds = %576
  %590 = load double, ptr %49, align 8, !tbaa !11
  %591 = fneg double %590
  br label %592

592:                                              ; preds = %589, %587
  %593 = phi double [ %588, %587 ], [ %591, %589 ]
  %594 = load ptr, ptr %26, align 8, !tbaa !5
  %595 = load i32, ptr %61, align 4, !tbaa !9
  %596 = load i32, ptr %35, align 4, !tbaa !9
  %597 = mul nsw i32 %595, %596
  %598 = add nsw i32 %597, 2
  %599 = sext i32 %598 to i64
  %600 = getelementptr inbounds %struct.doublecomplex, ptr %594, i64 %599
  %601 = call { double, double } @Cd(ptr noundef %600)
  %602 = extractvalue { double, double } %601, 0
  %603 = extractvalue { double, double } %601, 1
  store double %603, ptr %50, align 8, !tbaa !11
  %604 = load double, ptr %50, align 8, !tbaa !11
  %605 = fcmp oge double %604, 0.000000e+00
  br i1 %605, label %606, label %608

606:                                              ; preds = %592
  %607 = load double, ptr %50, align 8, !tbaa !11
  br label %611

608:                                              ; preds = %592
  %609 = load double, ptr %50, align 8, !tbaa !11
  %610 = fneg double %609
  br label %611

611:                                              ; preds = %608, %606
  %612 = phi double [ %607, %606 ], [ %610, %608 ]
  %613 = fadd double %593, %612
  %614 = call double @llvm.fmuladd.f64(double %578, double %613, double %550)
  %615 = load ptr, ptr %31, align 8, !tbaa !5
  %616 = getelementptr inbounds double, ptr %615, i64 1
  store double %614, ptr %616, align 8, !tbaa !11
  %617 = load ptr, ptr %18, align 8, !tbaa !5
  %618 = load i32, ptr %617, align 4, !tbaa !9
  %619 = sub nsw i32 %618, 1
  store i32 %619, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %620

620:                                              ; preds = %1073, %611
  %621 = load i32, ptr %60, align 4, !tbaa !9
  %622 = load i32, ptr %38, align 4, !tbaa !9
  %623 = icmp sle i32 %621, %622
  br i1 %623, label %624, label %1076

624:                                              ; preds = %620
  %625 = load i32, ptr %60, align 4, !tbaa !9
  %626 = load i32, ptr %61, align 4, !tbaa !9
  %627 = load i32, ptr %33, align 4, !tbaa !9
  %628 = mul nsw i32 %626, %627
  %629 = add nsw i32 %625, %628
  store i32 %629, ptr %39, align 4, !tbaa !9
  %630 = load ptr, ptr %24, align 8, !tbaa !5
  %631 = load i32, ptr %39, align 4, !tbaa !9
  %632 = sext i32 %631 to i64
  %633 = getelementptr inbounds %struct.doublecomplex, ptr %630, i64 %632
  %634 = getelementptr inbounds %struct.doublecomplex, ptr %633, i32 0, i32 0
  %635 = load double, ptr %634, align 8, !tbaa !15
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %635, ptr %636, align 8, !tbaa !15
  %637 = load ptr, ptr %24, align 8, !tbaa !5
  %638 = load i32, ptr %39, align 4, !tbaa !9
  %639 = sext i32 %638 to i64
  %640 = getelementptr inbounds %struct.doublecomplex, ptr %637, i64 %639
  %641 = getelementptr inbounds %struct.doublecomplex, ptr %640, i32 0, i32 1
  %642 = load double, ptr %641, align 8, !tbaa !17
  %643 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %642, ptr %643, align 8, !tbaa !17
  %644 = load ptr, ptr %21, align 8, !tbaa !5
  %645 = load i32, ptr %60, align 4, !tbaa !9
  %646 = sub nsw i32 %645, 1
  %647 = sext i32 %646 to i64
  %648 = getelementptr inbounds %struct.doublecomplex, ptr %644, i64 %647
  %649 = call { double, double } @Cd(ptr noundef %648)
  %650 = extractvalue { double, double } %649, 0
  %651 = extractvalue { double, double } %649, 1
  %652 = fneg double %651
  %653 = call ptr @_pCd(ptr noundef %56)
  %654 = getelementptr inbounds { double, double }, ptr %653, i32 0, i32 0
  %655 = getelementptr inbounds { double, double }, ptr %653, i32 0, i32 1
  store double %650, ptr %654, align 8
  store double %652, ptr %655, align 8
  %656 = load i32, ptr %60, align 4, !tbaa !9
  %657 = sub nsw i32 %656, 1
  %658 = load i32, ptr %61, align 4, !tbaa !9
  %659 = load i32, ptr %35, align 4, !tbaa !9
  %660 = mul nsw i32 %658, %659
  %661 = add nsw i32 %657, %660
  store i32 %661, ptr %39, align 4, !tbaa !9
  %662 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %663 = load double, ptr %662, align 8, !tbaa !15
  %664 = load ptr, ptr %26, align 8, !tbaa !5
  %665 = load i32, ptr %39, align 4, !tbaa !9
  %666 = sext i32 %665 to i64
  %667 = getelementptr inbounds %struct.doublecomplex, ptr %664, i64 %666
  %668 = getelementptr inbounds %struct.doublecomplex, ptr %667, i32 0, i32 0
  %669 = load double, ptr %668, align 8, !tbaa !15
  %670 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %671 = load double, ptr %670, align 8, !tbaa !17
  %672 = load ptr, ptr %26, align 8, !tbaa !5
  %673 = load i32, ptr %39, align 4, !tbaa !9
  %674 = sext i32 %673 to i64
  %675 = getelementptr inbounds %struct.doublecomplex, ptr %672, i64 %674
  %676 = getelementptr inbounds %struct.doublecomplex, ptr %675, i32 0, i32 1
  %677 = load double, ptr %676, align 8, !tbaa !17
  %678 = fmul double %671, %677
  %679 = fneg double %678
  %680 = call double @llvm.fmuladd.f64(double %663, double %669, double %679)
  %681 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %680, ptr %681, align 8, !tbaa !15
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %683 = load double, ptr %682, align 8, !tbaa !15
  %684 = load ptr, ptr %26, align 8, !tbaa !5
  %685 = load i32, ptr %39, align 4, !tbaa !9
  %686 = sext i32 %685 to i64
  %687 = getelementptr inbounds %struct.doublecomplex, ptr %684, i64 %686
  %688 = getelementptr inbounds %struct.doublecomplex, ptr %687, i32 0, i32 1
  %689 = load double, ptr %688, align 8, !tbaa !17
  %690 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %691 = load double, ptr %690, align 8, !tbaa !17
  %692 = load ptr, ptr %26, align 8, !tbaa !5
  %693 = load i32, ptr %39, align 4, !tbaa !9
  %694 = sext i32 %693 to i64
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %692, i64 %694
  %696 = getelementptr inbounds %struct.doublecomplex, ptr %695, i32 0, i32 0
  %697 = load double, ptr %696, align 8, !tbaa !15
  %698 = fmul double %691, %697
  %699 = call double @llvm.fmuladd.f64(double %683, double %689, double %698)
  %700 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %699, ptr %700, align 8, !tbaa !17
  %701 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %702 = load double, ptr %701, align 8, !tbaa !15
  %703 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  store double %702, ptr %703, align 8, !tbaa !15
  %704 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %705 = load double, ptr %704, align 8, !tbaa !17
  %706 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  store double %705, ptr %706, align 8, !tbaa !17
  %707 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %707, ptr %39, align 4, !tbaa !9
  %708 = load i32, ptr %60, align 4, !tbaa !9
  %709 = load i32, ptr %61, align 4, !tbaa !9
  %710 = load i32, ptr %35, align 4, !tbaa !9
  %711 = mul nsw i32 %709, %710
  %712 = add nsw i32 %708, %711
  store i32 %712, ptr %40, align 4, !tbaa !9
  %713 = load ptr, ptr %20, align 8, !tbaa !5
  %714 = load i32, ptr %39, align 4, !tbaa !9
  %715 = sext i32 %714 to i64
  %716 = getelementptr inbounds double, ptr %713, i64 %715
  %717 = load double, ptr %716, align 8, !tbaa !11
  %718 = load ptr, ptr %26, align 8, !tbaa !5
  %719 = load i32, ptr %40, align 4, !tbaa !9
  %720 = sext i32 %719 to i64
  %721 = getelementptr inbounds %struct.doublecomplex, ptr %718, i64 %720
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %721, i32 0, i32 0
  %723 = load double, ptr %722, align 8, !tbaa !15
  %724 = fmul double %717, %723
  %725 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %724, ptr %725, align 8, !tbaa !15
  %726 = load ptr, ptr %20, align 8, !tbaa !5
  %727 = load i32, ptr %39, align 4, !tbaa !9
  %728 = sext i32 %727 to i64
  %729 = getelementptr inbounds double, ptr %726, i64 %728
  %730 = load double, ptr %729, align 8, !tbaa !11
  %731 = load ptr, ptr %26, align 8, !tbaa !5
  %732 = load i32, ptr %40, align 4, !tbaa !9
  %733 = sext i32 %732 to i64
  %734 = getelementptr inbounds %struct.doublecomplex, ptr %731, i64 %733
  %735 = getelementptr inbounds %struct.doublecomplex, ptr %734, i32 0, i32 1
  %736 = load double, ptr %735, align 8, !tbaa !17
  %737 = fmul double %730, %736
  %738 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %737, ptr %738, align 8, !tbaa !17
  %739 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %740 = load double, ptr %739, align 8, !tbaa !15
  %741 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %740, ptr %741, align 8, !tbaa !15
  %742 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %743 = load double, ptr %742, align 8, !tbaa !17
  %744 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %743, ptr %744, align 8, !tbaa !17
  %745 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %745, ptr %39, align 4, !tbaa !9
  %746 = load i32, ptr %60, align 4, !tbaa !9
  %747 = add nsw i32 %746, 1
  %748 = load i32, ptr %61, align 4, !tbaa !9
  %749 = load i32, ptr %35, align 4, !tbaa !9
  %750 = mul nsw i32 %748, %749
  %751 = add nsw i32 %747, %750
  store i32 %751, ptr %40, align 4, !tbaa !9
  %752 = load ptr, ptr %21, align 8, !tbaa !5
  %753 = load i32, ptr %39, align 4, !tbaa !9
  %754 = sext i32 %753 to i64
  %755 = getelementptr inbounds %struct.doublecomplex, ptr %752, i64 %754
  %756 = getelementptr inbounds %struct.doublecomplex, ptr %755, i32 0, i32 0
  %757 = load double, ptr %756, align 8, !tbaa !15
  %758 = load ptr, ptr %26, align 8, !tbaa !5
  %759 = load i32, ptr %40, align 4, !tbaa !9
  %760 = sext i32 %759 to i64
  %761 = getelementptr inbounds %struct.doublecomplex, ptr %758, i64 %760
  %762 = getelementptr inbounds %struct.doublecomplex, ptr %761, i32 0, i32 0
  %763 = load double, ptr %762, align 8, !tbaa !15
  %764 = load ptr, ptr %21, align 8, !tbaa !5
  %765 = load i32, ptr %39, align 4, !tbaa !9
  %766 = sext i32 %765 to i64
  %767 = getelementptr inbounds %struct.doublecomplex, ptr %764, i64 %766
  %768 = getelementptr inbounds %struct.doublecomplex, ptr %767, i32 0, i32 1
  %769 = load double, ptr %768, align 8, !tbaa !17
  %770 = load ptr, ptr %26, align 8, !tbaa !5
  %771 = load i32, ptr %40, align 4, !tbaa !9
  %772 = sext i32 %771 to i64
  %773 = getelementptr inbounds %struct.doublecomplex, ptr %770, i64 %772
  %774 = getelementptr inbounds %struct.doublecomplex, ptr %773, i32 0, i32 1
  %775 = load double, ptr %774, align 8, !tbaa !17
  %776 = fmul double %769, %775
  %777 = fneg double %776
  %778 = call double @llvm.fmuladd.f64(double %757, double %763, double %777)
  %779 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %778, ptr %779, align 8, !tbaa !15
  %780 = load ptr, ptr %21, align 8, !tbaa !5
  %781 = load i32, ptr %39, align 4, !tbaa !9
  %782 = sext i32 %781 to i64
  %783 = getelementptr inbounds %struct.doublecomplex, ptr %780, i64 %782
  %784 = getelementptr inbounds %struct.doublecomplex, ptr %783, i32 0, i32 0
  %785 = load double, ptr %784, align 8, !tbaa !15
  %786 = load ptr, ptr %26, align 8, !tbaa !5
  %787 = load i32, ptr %40, align 4, !tbaa !9
  %788 = sext i32 %787 to i64
  %789 = getelementptr inbounds %struct.doublecomplex, ptr %786, i64 %788
  %790 = getelementptr inbounds %struct.doublecomplex, ptr %789, i32 0, i32 1
  %791 = load double, ptr %790, align 8, !tbaa !17
  %792 = load ptr, ptr %21, align 8, !tbaa !5
  %793 = load i32, ptr %39, align 4, !tbaa !9
  %794 = sext i32 %793 to i64
  %795 = getelementptr inbounds %struct.doublecomplex, ptr %792, i64 %794
  %796 = getelementptr inbounds %struct.doublecomplex, ptr %795, i32 0, i32 1
  %797 = load double, ptr %796, align 8, !tbaa !17
  %798 = load ptr, ptr %26, align 8, !tbaa !5
  %799 = load i32, ptr %40, align 4, !tbaa !9
  %800 = sext i32 %799 to i64
  %801 = getelementptr inbounds %struct.doublecomplex, ptr %798, i64 %800
  %802 = getelementptr inbounds %struct.doublecomplex, ptr %801, i32 0, i32 0
  %803 = load double, ptr %802, align 8, !tbaa !15
  %804 = fmul double %797, %803
  %805 = call double @llvm.fmuladd.f64(double %785, double %791, double %804)
  %806 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %805, ptr %806, align 8, !tbaa !17
  %807 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %808 = load double, ptr %807, align 8, !tbaa !15
  %809 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  store double %808, ptr %809, align 8, !tbaa !15
  %810 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %811 = load double, ptr %810, align 8, !tbaa !17
  %812 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  store double %811, ptr %812, align 8, !tbaa !17
  %813 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %813, ptr %39, align 4, !tbaa !9
  %814 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %815 = load double, ptr %814, align 8, !tbaa !15
  %816 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  %817 = load double, ptr %816, align 8, !tbaa !15
  %818 = fsub double %815, %817
  %819 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  store double %818, ptr %819, align 8, !tbaa !15
  %820 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %821 = load double, ptr %820, align 8, !tbaa !17
  %822 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  %823 = load double, ptr %822, align 8, !tbaa !17
  %824 = fsub double %821, %823
  %825 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  store double %824, ptr %825, align 8, !tbaa !17
  %826 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %827 = load double, ptr %826, align 8, !tbaa !15
  %828 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %829 = load double, ptr %828, align 8, !tbaa !15
  %830 = fsub double %827, %829
  %831 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %830, ptr %831, align 8, !tbaa !15
  %832 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  %833 = load double, ptr %832, align 8, !tbaa !17
  %834 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %835 = load double, ptr %834, align 8, !tbaa !17
  %836 = fsub double %833, %835
  %837 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %836, ptr %837, align 8, !tbaa !17
  %838 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %839 = load double, ptr %838, align 8, !tbaa !15
  %840 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  %841 = load double, ptr %840, align 8, !tbaa !15
  %842 = fsub double %839, %841
  %843 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %842, ptr %843, align 8, !tbaa !15
  %844 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %845 = load double, ptr %844, align 8, !tbaa !17
  %846 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  %847 = load double, ptr %846, align 8, !tbaa !17
  %848 = fsub double %845, %847
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %848, ptr %849, align 8, !tbaa !17
  %850 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %851 = load double, ptr %850, align 8, !tbaa !15
  %852 = load ptr, ptr %30, align 8, !tbaa !5
  %853 = load i32, ptr %39, align 4, !tbaa !9
  %854 = sext i32 %853 to i64
  %855 = getelementptr inbounds %struct.doublecomplex, ptr %852, i64 %854
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %855, i32 0, i32 0
  store double %851, ptr %856, align 8, !tbaa !15
  %857 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %858 = load double, ptr %857, align 8, !tbaa !17
  %859 = load ptr, ptr %30, align 8, !tbaa !5
  %860 = load i32, ptr %39, align 4, !tbaa !9
  %861 = sext i32 %860 to i64
  %862 = getelementptr inbounds %struct.doublecomplex, ptr %859, i64 %861
  %863 = getelementptr inbounds %struct.doublecomplex, ptr %862, i32 0, i32 1
  store double %858, ptr %863, align 8, !tbaa !17
  %864 = load i32, ptr %60, align 4, !tbaa !9
  %865 = sub nsw i32 %864, 1
  store i32 %865, ptr %39, align 4, !tbaa !9
  %866 = load i32, ptr %60, align 4, !tbaa !9
  %867 = sub nsw i32 %866, 1
  %868 = load i32, ptr %61, align 4, !tbaa !9
  %869 = load i32, ptr %35, align 4, !tbaa !9
  %870 = mul nsw i32 %868, %869
  %871 = add nsw i32 %867, %870
  store i32 %871, ptr %40, align 4, !tbaa !9
  %872 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %872, ptr %41, align 4, !tbaa !9
  %873 = load i32, ptr %60, align 4, !tbaa !9
  %874 = add nsw i32 %873, 1
  %875 = load i32, ptr %61, align 4, !tbaa !9
  %876 = load i32, ptr %35, align 4, !tbaa !9
  %877 = mul nsw i32 %875, %876
  %878 = add nsw i32 %874, %877
  store i32 %878, ptr %42, align 4, !tbaa !9
  %879 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %880 = load double, ptr %879, align 8, !tbaa !15
  store double %880, ptr %43, align 8, !tbaa !11
  %881 = load double, ptr %43, align 8, !tbaa !11
  %882 = fcmp oge double %881, 0.000000e+00
  br i1 %882, label %883, label %885

883:                                              ; preds = %624
  %884 = load double, ptr %43, align 8, !tbaa !11
  br label %888

885:                                              ; preds = %624
  %886 = load double, ptr %43, align 8, !tbaa !11
  %887 = fneg double %886
  br label %888

888:                                              ; preds = %885, %883
  %889 = phi double [ %884, %883 ], [ %887, %885 ]
  %890 = call { double, double } @Cd(ptr noundef %65)
  %891 = extractvalue { double, double } %890, 0
  %892 = extractvalue { double, double } %890, 1
  store double %892, ptr %44, align 8, !tbaa !11
  %893 = load double, ptr %44, align 8, !tbaa !11
  %894 = fcmp oge double %893, 0.000000e+00
  br i1 %894, label %895, label %897

895:                                              ; preds = %888
  %896 = load double, ptr %44, align 8, !tbaa !11
  br label %900

897:                                              ; preds = %888
  %898 = load double, ptr %44, align 8, !tbaa !11
  %899 = fneg double %898
  br label %900

900:                                              ; preds = %897, %895
  %901 = phi double [ %896, %895 ], [ %899, %897 ]
  %902 = fadd double %889, %901
  %903 = load ptr, ptr %21, align 8, !tbaa !5
  %904 = load i32, ptr %39, align 4, !tbaa !9
  %905 = sext i32 %904 to i64
  %906 = getelementptr inbounds %struct.doublecomplex, ptr %903, i64 %905
  %907 = getelementptr inbounds %struct.doublecomplex, ptr %906, i32 0, i32 0
  %908 = load double, ptr %907, align 8, !tbaa !15
  store double %908, ptr %45, align 8, !tbaa !11
  %909 = load double, ptr %45, align 8, !tbaa !11
  %910 = fcmp oge double %909, 0.000000e+00
  br i1 %910, label %911, label %913

911:                                              ; preds = %900
  %912 = load double, ptr %45, align 8, !tbaa !11
  br label %916

913:                                              ; preds = %900
  %914 = load double, ptr %45, align 8, !tbaa !11
  %915 = fneg double %914
  br label %916

916:                                              ; preds = %913, %911
  %917 = phi double [ %912, %911 ], [ %915, %913 ]
  %918 = load ptr, ptr %21, align 8, !tbaa !5
  %919 = load i32, ptr %60, align 4, !tbaa !9
  %920 = sub nsw i32 %919, 1
  %921 = sext i32 %920 to i64
  %922 = getelementptr inbounds %struct.doublecomplex, ptr %918, i64 %921
  %923 = call { double, double } @Cd(ptr noundef %922)
  %924 = extractvalue { double, double } %923, 0
  %925 = extractvalue { double, double } %923, 1
  store double %925, ptr %46, align 8, !tbaa !11
  %926 = load double, ptr %46, align 8, !tbaa !11
  %927 = fcmp oge double %926, 0.000000e+00
  br i1 %927, label %928, label %930

928:                                              ; preds = %916
  %929 = load double, ptr %46, align 8, !tbaa !11
  br label %933

930:                                              ; preds = %916
  %931 = load double, ptr %46, align 8, !tbaa !11
  %932 = fneg double %931
  br label %933

933:                                              ; preds = %930, %928
  %934 = phi double [ %929, %928 ], [ %932, %930 ]
  %935 = fadd double %917, %934
  %936 = load ptr, ptr %26, align 8, !tbaa !5
  %937 = load i32, ptr %40, align 4, !tbaa !9
  %938 = sext i32 %937 to i64
  %939 = getelementptr inbounds %struct.doublecomplex, ptr %936, i64 %938
  %940 = getelementptr inbounds %struct.doublecomplex, ptr %939, i32 0, i32 0
  %941 = load double, ptr %940, align 8, !tbaa !15
  store double %941, ptr %47, align 8, !tbaa !11
  %942 = load double, ptr %47, align 8, !tbaa !11
  %943 = fcmp oge double %942, 0.000000e+00
  br i1 %943, label %944, label %946

944:                                              ; preds = %933
  %945 = load double, ptr %47, align 8, !tbaa !11
  br label %949

946:                                              ; preds = %933
  %947 = load double, ptr %47, align 8, !tbaa !11
  %948 = fneg double %947
  br label %949

949:                                              ; preds = %946, %944
  %950 = phi double [ %945, %944 ], [ %948, %946 ]
  %951 = load ptr, ptr %26, align 8, !tbaa !5
  %952 = load i32, ptr %60, align 4, !tbaa !9
  %953 = sub nsw i32 %952, 1
  %954 = load i32, ptr %61, align 4, !tbaa !9
  %955 = load i32, ptr %35, align 4, !tbaa !9
  %956 = mul nsw i32 %954, %955
  %957 = add nsw i32 %953, %956
  %958 = sext i32 %957 to i64
  %959 = getelementptr inbounds %struct.doublecomplex, ptr %951, i64 %958
  %960 = call { double, double } @Cd(ptr noundef %959)
  %961 = extractvalue { double, double } %960, 0
  %962 = extractvalue { double, double } %960, 1
  store double %962, ptr %48, align 8, !tbaa !11
  %963 = load double, ptr %48, align 8, !tbaa !11
  %964 = fcmp oge double %963, 0.000000e+00
  br i1 %964, label %965, label %967

965:                                              ; preds = %949
  %966 = load double, ptr %48, align 8, !tbaa !11
  br label %970

967:                                              ; preds = %949
  %968 = load double, ptr %48, align 8, !tbaa !11
  %969 = fneg double %968
  br label %970

970:                                              ; preds = %967, %965
  %971 = phi double [ %966, %965 ], [ %969, %967 ]
  %972 = fadd double %950, %971
  %973 = call double @llvm.fmuladd.f64(double %935, double %972, double %902)
  %974 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %975 = load double, ptr %974, align 8, !tbaa !15
  store double %975, ptr %49, align 8, !tbaa !11
  %976 = load double, ptr %49, align 8, !tbaa !11
  %977 = fcmp oge double %976, 0.000000e+00
  br i1 %977, label %978, label %980

978:                                              ; preds = %970
  %979 = load double, ptr %49, align 8, !tbaa !11
  br label %983

980:                                              ; preds = %970
  %981 = load double, ptr %49, align 8, !tbaa !11
  %982 = fneg double %981
  br label %983

983:                                              ; preds = %980, %978
  %984 = phi double [ %979, %978 ], [ %982, %980 ]
  %985 = call { double, double } @Cd(ptr noundef %67)
  %986 = extractvalue { double, double } %985, 0
  %987 = extractvalue { double, double } %985, 1
  store double %987, ptr %50, align 8, !tbaa !11
  %988 = load double, ptr %50, align 8, !tbaa !11
  %989 = fcmp oge double %988, 0.000000e+00
  br i1 %989, label %990, label %992

990:                                              ; preds = %983
  %991 = load double, ptr %50, align 8, !tbaa !11
  br label %995

992:                                              ; preds = %983
  %993 = load double, ptr %50, align 8, !tbaa !11
  %994 = fneg double %993
  br label %995

995:                                              ; preds = %992, %990
  %996 = phi double [ %991, %990 ], [ %994, %992 ]
  %997 = fadd double %984, %996
  %998 = fadd double %973, %997
  %999 = load ptr, ptr %21, align 8, !tbaa !5
  %1000 = load i32, ptr %41, align 4, !tbaa !9
  %1001 = sext i32 %1000 to i64
  %1002 = getelementptr inbounds %struct.doublecomplex, ptr %999, i64 %1001
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %1002, i32 0, i32 0
  %1004 = load double, ptr %1003, align 8, !tbaa !15
  store double %1004, ptr %51, align 8, !tbaa !11
  %1005 = load double, ptr %51, align 8, !tbaa !11
  %1006 = fcmp oge double %1005, 0.000000e+00
  br i1 %1006, label %1007, label %1009

1007:                                             ; preds = %995
  %1008 = load double, ptr %51, align 8, !tbaa !11
  br label %1012

1009:                                             ; preds = %995
  %1010 = load double, ptr %51, align 8, !tbaa !11
  %1011 = fneg double %1010
  br label %1012

1012:                                             ; preds = %1009, %1007
  %1013 = phi double [ %1008, %1007 ], [ %1011, %1009 ]
  %1014 = load ptr, ptr %21, align 8, !tbaa !5
  %1015 = load i32, ptr %60, align 4, !tbaa !9
  %1016 = sext i32 %1015 to i64
  %1017 = getelementptr inbounds %struct.doublecomplex, ptr %1014, i64 %1016
  %1018 = call { double, double } @Cd(ptr noundef %1017)
  %1019 = extractvalue { double, double } %1018, 0
  %1020 = extractvalue { double, double } %1018, 1
  store double %1020, ptr %52, align 8, !tbaa !11
  %1021 = load double, ptr %52, align 8, !tbaa !11
  %1022 = fcmp oge double %1021, 0.000000e+00
  br i1 %1022, label %1023, label %1025

1023:                                             ; preds = %1012
  %1024 = load double, ptr %52, align 8, !tbaa !11
  br label %1028

1025:                                             ; preds = %1012
  %1026 = load double, ptr %52, align 8, !tbaa !11
  %1027 = fneg double %1026
  br label %1028

1028:                                             ; preds = %1025, %1023
  %1029 = phi double [ %1024, %1023 ], [ %1027, %1025 ]
  %1030 = fadd double %1013, %1029
  %1031 = load ptr, ptr %26, align 8, !tbaa !5
  %1032 = load i32, ptr %42, align 4, !tbaa !9
  %1033 = sext i32 %1032 to i64
  %1034 = getelementptr inbounds %struct.doublecomplex, ptr %1031, i64 %1033
  %1035 = getelementptr inbounds %struct.doublecomplex, ptr %1034, i32 0, i32 0
  %1036 = load double, ptr %1035, align 8, !tbaa !15
  store double %1036, ptr %53, align 8, !tbaa !11
  %1037 = load double, ptr %53, align 8, !tbaa !11
  %1038 = fcmp oge double %1037, 0.000000e+00
  br i1 %1038, label %1039, label %1041

1039:                                             ; preds = %1028
  %1040 = load double, ptr %53, align 8, !tbaa !11
  br label %1044

1041:                                             ; preds = %1028
  %1042 = load double, ptr %53, align 8, !tbaa !11
  %1043 = fneg double %1042
  br label %1044

1044:                                             ; preds = %1041, %1039
  %1045 = phi double [ %1040, %1039 ], [ %1043, %1041 ]
  %1046 = load ptr, ptr %26, align 8, !tbaa !5
  %1047 = load i32, ptr %60, align 4, !tbaa !9
  %1048 = add nsw i32 %1047, 1
  %1049 = load i32, ptr %61, align 4, !tbaa !9
  %1050 = load i32, ptr %35, align 4, !tbaa !9
  %1051 = mul nsw i32 %1049, %1050
  %1052 = add nsw i32 %1048, %1051
  %1053 = sext i32 %1052 to i64
  %1054 = getelementptr inbounds %struct.doublecomplex, ptr %1046, i64 %1053
  %1055 = call { double, double } @Cd(ptr noundef %1054)
  %1056 = extractvalue { double, double } %1055, 0
  %1057 = extractvalue { double, double } %1055, 1
  store double %1057, ptr %54, align 8, !tbaa !11
  %1058 = load double, ptr %54, align 8, !tbaa !11
  %1059 = fcmp oge double %1058, 0.000000e+00
  br i1 %1059, label %1060, label %1062

1060:                                             ; preds = %1044
  %1061 = load double, ptr %54, align 8, !tbaa !11
  br label %1065

1062:                                             ; preds = %1044
  %1063 = load double, ptr %54, align 8, !tbaa !11
  %1064 = fneg double %1063
  br label %1065

1065:                                             ; preds = %1062, %1060
  %1066 = phi double [ %1061, %1060 ], [ %1064, %1062 ]
  %1067 = fadd double %1045, %1066
  %1068 = call double @llvm.fmuladd.f64(double %1030, double %1067, double %998)
  %1069 = load ptr, ptr %31, align 8, !tbaa !5
  %1070 = load i32, ptr %60, align 4, !tbaa !9
  %1071 = sext i32 %1070 to i64
  %1072 = getelementptr inbounds double, ptr %1069, i64 %1071
  store double %1068, ptr %1072, align 8, !tbaa !11
  br label %1073

1073:                                             ; preds = %1065
  %1074 = load i32, ptr %60, align 4, !tbaa !9
  %1075 = add nsw i32 %1074, 1
  store i32 %1075, ptr %60, align 4, !tbaa !9
  br label %620, !llvm.loop !18

1076:                                             ; preds = %620
  %1077 = load ptr, ptr %18, align 8, !tbaa !5
  %1078 = load i32, ptr %1077, align 4, !tbaa !9
  %1079 = load i32, ptr %61, align 4, !tbaa !9
  %1080 = load i32, ptr %33, align 4, !tbaa !9
  %1081 = mul nsw i32 %1079, %1080
  %1082 = add nsw i32 %1078, %1081
  store i32 %1082, ptr %38, align 4, !tbaa !9
  %1083 = load ptr, ptr %24, align 8, !tbaa !5
  %1084 = load i32, ptr %38, align 4, !tbaa !9
  %1085 = sext i32 %1084 to i64
  %1086 = getelementptr inbounds %struct.doublecomplex, ptr %1083, i64 %1085
  %1087 = getelementptr inbounds %struct.doublecomplex, ptr %1086, i32 0, i32 0
  %1088 = load double, ptr %1087, align 8, !tbaa !15
  %1089 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %1088, ptr %1089, align 8, !tbaa !15
  %1090 = load ptr, ptr %24, align 8, !tbaa !5
  %1091 = load i32, ptr %38, align 4, !tbaa !9
  %1092 = sext i32 %1091 to i64
  %1093 = getelementptr inbounds %struct.doublecomplex, ptr %1090, i64 %1092
  %1094 = getelementptr inbounds %struct.doublecomplex, ptr %1093, i32 0, i32 1
  %1095 = load double, ptr %1094, align 8, !tbaa !17
  %1096 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %1095, ptr %1096, align 8, !tbaa !17
  %1097 = load ptr, ptr %21, align 8, !tbaa !5
  %1098 = load ptr, ptr %18, align 8, !tbaa !5
  %1099 = load i32, ptr %1098, align 4, !tbaa !9
  %1100 = sub nsw i32 %1099, 1
  %1101 = sext i32 %1100 to i64
  %1102 = getelementptr inbounds %struct.doublecomplex, ptr %1097, i64 %1101
  %1103 = call { double, double } @Cd(ptr noundef %1102)
  %1104 = extractvalue { double, double } %1103, 0
  %1105 = extractvalue { double, double } %1103, 1
  %1106 = fneg double %1105
  %1107 = call ptr @_pCd(ptr noundef %56)
  %1108 = getelementptr inbounds { double, double }, ptr %1107, i32 0, i32 0
  %1109 = getelementptr inbounds { double, double }, ptr %1107, i32 0, i32 1
  store double %1104, ptr %1108, align 8
  store double %1106, ptr %1109, align 8
  %1110 = load ptr, ptr %18, align 8, !tbaa !5
  %1111 = load i32, ptr %1110, align 4, !tbaa !9
  %1112 = sub nsw i32 %1111, 1
  %1113 = load i32, ptr %61, align 4, !tbaa !9
  %1114 = load i32, ptr %35, align 4, !tbaa !9
  %1115 = mul nsw i32 %1113, %1114
  %1116 = add nsw i32 %1112, %1115
  store i32 %1116, ptr %38, align 4, !tbaa !9
  %1117 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1118 = load double, ptr %1117, align 8, !tbaa !15
  %1119 = load ptr, ptr %26, align 8, !tbaa !5
  %1120 = load i32, ptr %38, align 4, !tbaa !9
  %1121 = sext i32 %1120 to i64
  %1122 = getelementptr inbounds %struct.doublecomplex, ptr %1119, i64 %1121
  %1123 = getelementptr inbounds %struct.doublecomplex, ptr %1122, i32 0, i32 0
  %1124 = load double, ptr %1123, align 8, !tbaa !15
  %1125 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1126 = load double, ptr %1125, align 8, !tbaa !17
  %1127 = load ptr, ptr %26, align 8, !tbaa !5
  %1128 = load i32, ptr %38, align 4, !tbaa !9
  %1129 = sext i32 %1128 to i64
  %1130 = getelementptr inbounds %struct.doublecomplex, ptr %1127, i64 %1129
  %1131 = getelementptr inbounds %struct.doublecomplex, ptr %1130, i32 0, i32 1
  %1132 = load double, ptr %1131, align 8, !tbaa !17
  %1133 = fmul double %1126, %1132
  %1134 = fneg double %1133
  %1135 = call double @llvm.fmuladd.f64(double %1118, double %1124, double %1134)
  %1136 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1135, ptr %1136, align 8, !tbaa !15
  %1137 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1138 = load double, ptr %1137, align 8, !tbaa !15
  %1139 = load ptr, ptr %26, align 8, !tbaa !5
  %1140 = load i32, ptr %38, 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 !17
  %1145 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1146 = load double, ptr %1145, align 8, !tbaa !17
  %1147 = load ptr, ptr %26, align 8, !tbaa !5
  %1148 = load i32, ptr %38, align 4, !tbaa !9
  %1149 = sext i32 %1148 to i64
  %1150 = getelementptr inbounds %struct.doublecomplex, ptr %1147, i64 %1149
  %1151 = getelementptr inbounds %struct.doublecomplex, ptr %1150, i32 0, i32 0
  %1152 = load double, ptr %1151, align 8, !tbaa !15
  %1153 = fmul double %1146, %1152
  %1154 = call double @llvm.fmuladd.f64(double %1138, double %1144, double %1153)
  %1155 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1154, ptr %1155, align 8, !tbaa !17
  %1156 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1157 = load double, ptr %1156, align 8, !tbaa !15
  %1158 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  store double %1157, ptr %1158, align 8, !tbaa !15
  %1159 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1160 = load double, ptr %1159, align 8, !tbaa !17
  %1161 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  store double %1160, ptr %1161, align 8, !tbaa !17
  %1162 = load ptr, ptr %18, align 8, !tbaa !5
  %1163 = load i32, ptr %1162, align 4, !tbaa !9
  store i32 %1163, ptr %38, align 4, !tbaa !9
  %1164 = load ptr, ptr %18, align 8, !tbaa !5
  %1165 = load i32, ptr %1164, align 4, !tbaa !9
  %1166 = load i32, ptr %61, align 4, !tbaa !9
  %1167 = load i32, ptr %35, align 4, !tbaa !9
  %1168 = mul nsw i32 %1166, %1167
  %1169 = add nsw i32 %1165, %1168
  store i32 %1169, ptr %39, align 4, !tbaa !9
  %1170 = load ptr, ptr %20, align 8, !tbaa !5
  %1171 = load i32, ptr %38, align 4, !tbaa !9
  %1172 = sext i32 %1171 to i64
  %1173 = getelementptr inbounds double, ptr %1170, i64 %1172
  %1174 = load double, ptr %1173, align 8, !tbaa !11
  %1175 = load ptr, ptr %26, align 8, !tbaa !5
  %1176 = load i32, ptr %39, align 4, !tbaa !9
  %1177 = sext i32 %1176 to i64
  %1178 = getelementptr inbounds %struct.doublecomplex, ptr %1175, i64 %1177
  %1179 = getelementptr inbounds %struct.doublecomplex, ptr %1178, i32 0, i32 0
  %1180 = load double, ptr %1179, align 8, !tbaa !15
  %1181 = fmul double %1174, %1180
  %1182 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1181, ptr %1182, align 8, !tbaa !15
  %1183 = load ptr, ptr %20, align 8, !tbaa !5
  %1184 = load i32, ptr %38, align 4, !tbaa !9
  %1185 = sext i32 %1184 to i64
  %1186 = getelementptr inbounds double, ptr %1183, i64 %1185
  %1187 = load double, ptr %1186, align 8, !tbaa !11
  %1188 = load ptr, ptr %26, align 8, !tbaa !5
  %1189 = load i32, ptr %39, align 4, !tbaa !9
  %1190 = sext i32 %1189 to i64
  %1191 = getelementptr inbounds %struct.doublecomplex, ptr %1188, i64 %1190
  %1192 = getelementptr inbounds %struct.doublecomplex, ptr %1191, i32 0, i32 1
  %1193 = load double, ptr %1192, align 8, !tbaa !17
  %1194 = fmul double %1187, %1193
  %1195 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1194, ptr %1195, align 8, !tbaa !17
  %1196 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1197 = load double, ptr %1196, align 8, !tbaa !15
  %1198 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %1197, ptr %1198, align 8, !tbaa !15
  %1199 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1200 = load double, ptr %1199, align 8, !tbaa !17
  %1201 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %1200, ptr %1201, align 8, !tbaa !17
  %1202 = load ptr, ptr %18, align 8, !tbaa !5
  %1203 = load i32, ptr %1202, align 4, !tbaa !9
  store i32 %1203, ptr %38, align 4, !tbaa !9
  %1204 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1205 = load double, ptr %1204, align 8, !tbaa !15
  %1206 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  %1207 = load double, ptr %1206, align 8, !tbaa !15
  %1208 = fsub double %1205, %1207
  %1209 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1208, ptr %1209, align 8, !tbaa !15
  %1210 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %1211 = load double, ptr %1210, align 8, !tbaa !17
  %1212 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  %1213 = load double, ptr %1212, align 8, !tbaa !17
  %1214 = fsub double %1211, %1213
  %1215 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1214, ptr %1215, align 8, !tbaa !17
  %1216 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1217 = load double, ptr %1216, align 8, !tbaa !15
  %1218 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1219 = load double, ptr %1218, align 8, !tbaa !15
  %1220 = fsub double %1217, %1219
  %1221 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1220, ptr %1221, align 8, !tbaa !15
  %1222 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1223 = load double, ptr %1222, align 8, !tbaa !17
  %1224 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %1225 = load double, ptr %1224, align 8, !tbaa !17
  %1226 = fsub double %1223, %1225
  %1227 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1226, ptr %1227, align 8, !tbaa !17
  %1228 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1229 = load double, ptr %1228, align 8, !tbaa !15
  %1230 = load ptr, ptr %30, align 8, !tbaa !5
  %1231 = load i32, ptr %38, align 4, !tbaa !9
  %1232 = sext i32 %1231 to i64
  %1233 = getelementptr inbounds %struct.doublecomplex, ptr %1230, i64 %1232
  %1234 = getelementptr inbounds %struct.doublecomplex, ptr %1233, i32 0, i32 0
  store double %1229, ptr %1234, align 8, !tbaa !15
  %1235 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1236 = load double, ptr %1235, align 8, !tbaa !17
  %1237 = load ptr, ptr %30, align 8, !tbaa !5
  %1238 = load i32, ptr %38, align 4, !tbaa !9
  %1239 = sext i32 %1238 to i64
  %1240 = getelementptr inbounds %struct.doublecomplex, ptr %1237, i64 %1239
  %1241 = getelementptr inbounds %struct.doublecomplex, ptr %1240, i32 0, i32 1
  store double %1236, ptr %1241, align 8, !tbaa !17
  %1242 = load ptr, ptr %18, align 8, !tbaa !5
  %1243 = load i32, ptr %1242, align 4, !tbaa !9
  %1244 = sub nsw i32 %1243, 1
  store i32 %1244, ptr %38, align 4, !tbaa !9
  %1245 = load ptr, ptr %18, align 8, !tbaa !5
  %1246 = load i32, ptr %1245, align 4, !tbaa !9
  %1247 = sub nsw i32 %1246, 1
  %1248 = load i32, ptr %61, align 4, !tbaa !9
  %1249 = load i32, ptr %35, align 4, !tbaa !9
  %1250 = mul nsw i32 %1248, %1249
  %1251 = add nsw i32 %1247, %1250
  store i32 %1251, ptr %39, align 4, !tbaa !9
  %1252 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1253 = load double, ptr %1252, align 8, !tbaa !15
  store double %1253, ptr %43, align 8, !tbaa !11
  %1254 = load double, ptr %43, align 8, !tbaa !11
  %1255 = fcmp oge double %1254, 0.000000e+00
  br i1 %1255, label %1256, label %1258

1256:                                             ; preds = %1076
  %1257 = load double, ptr %43, align 8, !tbaa !11
  br label %1261

1258:                                             ; preds = %1076
  %1259 = load double, ptr %43, align 8, !tbaa !11
  %1260 = fneg double %1259
  br label %1261

1261:                                             ; preds = %1258, %1256
  %1262 = phi double [ %1257, %1256 ], [ %1260, %1258 ]
  %1263 = call { double, double } @Cd(ptr noundef %65)
  %1264 = extractvalue { double, double } %1263, 0
  %1265 = extractvalue { double, double } %1263, 1
  store double %1265, ptr %44, align 8, !tbaa !11
  %1266 = load double, ptr %44, align 8, !tbaa !11
  %1267 = fcmp oge double %1266, 0.000000e+00
  br i1 %1267, label %1268, label %1270

1268:                                             ; preds = %1261
  %1269 = load double, ptr %44, align 8, !tbaa !11
  br label %1273

1270:                                             ; preds = %1261
  %1271 = load double, ptr %44, align 8, !tbaa !11
  %1272 = fneg double %1271
  br label %1273

1273:                                             ; preds = %1270, %1268
  %1274 = phi double [ %1269, %1268 ], [ %1272, %1270 ]
  %1275 = fadd double %1262, %1274
  %1276 = load ptr, ptr %21, align 8, !tbaa !5
  %1277 = load i32, ptr %38, align 4, !tbaa !9
  %1278 = sext i32 %1277 to i64
  %1279 = getelementptr inbounds %struct.doublecomplex, ptr %1276, i64 %1278
  %1280 = getelementptr inbounds %struct.doublecomplex, ptr %1279, i32 0, i32 0
  %1281 = load double, ptr %1280, align 8, !tbaa !15
  store double %1281, ptr %45, align 8, !tbaa !11
  %1282 = load double, ptr %45, align 8, !tbaa !11
  %1283 = fcmp oge double %1282, 0.000000e+00
  br i1 %1283, label %1284, label %1286

1284:                                             ; preds = %1273
  %1285 = load double, ptr %45, align 8, !tbaa !11
  br label %1289

1286:                                             ; preds = %1273
  %1287 = load double, ptr %45, align 8, !tbaa !11
  %1288 = fneg double %1287
  br label %1289

1289:                                             ; preds = %1286, %1284
  %1290 = phi double [ %1285, %1284 ], [ %1288, %1286 ]
  %1291 = load ptr, ptr %21, align 8, !tbaa !5
  %1292 = load ptr, ptr %18, align 8, !tbaa !5
  %1293 = load i32, ptr %1292, align 4, !tbaa !9
  %1294 = sub nsw i32 %1293, 1
  %1295 = sext i32 %1294 to i64
  %1296 = getelementptr inbounds %struct.doublecomplex, ptr %1291, i64 %1295
  %1297 = call { double, double } @Cd(ptr noundef %1296)
  %1298 = extractvalue { double, double } %1297, 0
  %1299 = extractvalue { double, double } %1297, 1
  store double %1299, ptr %46, align 8, !tbaa !11
  %1300 = load double, ptr %46, align 8, !tbaa !11
  %1301 = fcmp oge double %1300, 0.000000e+00
  br i1 %1301, label %1302, label %1304

1302:                                             ; preds = %1289
  %1303 = load double, ptr %46, align 8, !tbaa !11
  br label %1307

1304:                                             ; preds = %1289
  %1305 = load double, ptr %46, align 8, !tbaa !11
  %1306 = fneg double %1305
  br label %1307

1307:                                             ; preds = %1304, %1302
  %1308 = phi double [ %1303, %1302 ], [ %1306, %1304 ]
  %1309 = fadd double %1290, %1308
  %1310 = load ptr, ptr %26, align 8, !tbaa !5
  %1311 = load i32, ptr %39, align 4, !tbaa !9
  %1312 = sext i32 %1311 to i64
  %1313 = getelementptr inbounds %struct.doublecomplex, ptr %1310, i64 %1312
  %1314 = getelementptr inbounds %struct.doublecomplex, ptr %1313, i32 0, i32 0
  %1315 = load double, ptr %1314, align 8, !tbaa !15
  store double %1315, ptr %47, align 8, !tbaa !11
  %1316 = load double, ptr %47, align 8, !tbaa !11
  %1317 = fcmp oge double %1316, 0.000000e+00
  br i1 %1317, label %1318, label %1320

1318:                                             ; preds = %1307
  %1319 = load double, ptr %47, align 8, !tbaa !11
  br label %1323

1320:                                             ; preds = %1307
  %1321 = load double, ptr %47, align 8, !tbaa !11
  %1322 = fneg double %1321
  br label %1323

1323:                                             ; preds = %1320, %1318
  %1324 = phi double [ %1319, %1318 ], [ %1322, %1320 ]
  %1325 = load ptr, ptr %26, align 8, !tbaa !5
  %1326 = load ptr, ptr %18, align 8, !tbaa !5
  %1327 = load i32, ptr %1326, align 4, !tbaa !9
  %1328 = sub nsw i32 %1327, 1
  %1329 = load i32, ptr %61, align 4, !tbaa !9
  %1330 = load i32, ptr %35, align 4, !tbaa !9
  %1331 = mul nsw i32 %1329, %1330
  %1332 = add nsw i32 %1328, %1331
  %1333 = sext i32 %1332 to i64
  %1334 = getelementptr inbounds %struct.doublecomplex, ptr %1325, i64 %1333
  %1335 = call { double, double } @Cd(ptr noundef %1334)
  %1336 = extractvalue { double, double } %1335, 0
  %1337 = extractvalue { double, double } %1335, 1
  store double %1337, ptr %48, align 8, !tbaa !11
  %1338 = load double, ptr %48, align 8, !tbaa !11
  %1339 = fcmp oge double %1338, 0.000000e+00
  br i1 %1339, label %1340, label %1342

1340:                                             ; preds = %1323
  %1341 = load double, ptr %48, align 8, !tbaa !11
  br label %1345

1342:                                             ; preds = %1323
  %1343 = load double, ptr %48, align 8, !tbaa !11
  %1344 = fneg double %1343
  br label %1345

1345:                                             ; preds = %1342, %1340
  %1346 = phi double [ %1341, %1340 ], [ %1344, %1342 ]
  %1347 = fadd double %1324, %1346
  %1348 = call double @llvm.fmuladd.f64(double %1309, double %1347, double %1275)
  %1349 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1350 = load double, ptr %1349, align 8, !tbaa !15
  store double %1350, ptr %49, align 8, !tbaa !11
  %1351 = load double, ptr %49, align 8, !tbaa !11
  %1352 = fcmp oge double %1351, 0.000000e+00
  br i1 %1352, label %1353, label %1355

1353:                                             ; preds = %1345
  %1354 = load double, ptr %49, align 8, !tbaa !11
  br label %1358

1355:                                             ; preds = %1345
  %1356 = load double, ptr %49, align 8, !tbaa !11
  %1357 = fneg double %1356
  br label %1358

1358:                                             ; preds = %1355, %1353
  %1359 = phi double [ %1354, %1353 ], [ %1357, %1355 ]
  %1360 = call { double, double } @Cd(ptr noundef %67)
  %1361 = extractvalue { double, double } %1360, 0
  %1362 = extractvalue { double, double } %1360, 1
  store double %1362, ptr %50, align 8, !tbaa !11
  %1363 = load double, ptr %50, align 8, !tbaa !11
  %1364 = fcmp oge double %1363, 0.000000e+00
  br i1 %1364, label %1365, label %1367

1365:                                             ; preds = %1358
  %1366 = load double, ptr %50, align 8, !tbaa !11
  br label %1370

1367:                                             ; preds = %1358
  %1368 = load double, ptr %50, align 8, !tbaa !11
  %1369 = fneg double %1368
  br label %1370

1370:                                             ; preds = %1367, %1365
  %1371 = phi double [ %1366, %1365 ], [ %1369, %1367 ]
  %1372 = fadd double %1359, %1371
  %1373 = fadd double %1348, %1372
  %1374 = load ptr, ptr %31, align 8, !tbaa !5
  %1375 = load ptr, ptr %18, align 8, !tbaa !5
  %1376 = load i32, ptr %1375, align 4, !tbaa !9
  %1377 = sext i32 %1376 to i64
  %1378 = getelementptr inbounds double, ptr %1374, i64 %1377
  store double %1373, ptr %1378, align 8, !tbaa !11
  br label %1379

1379:                                             ; preds = %1370, %350
  br label %2539

1380:                                             ; preds = %225
  %1381 = load ptr, ptr %18, align 8, !tbaa !5
  %1382 = load i32, ptr %1381, align 4, !tbaa !9
  %1383 = icmp eq i32 %1382, 1
  br i1 %1383, label %1384, label %1508

1384:                                             ; preds = %1380
  %1385 = load i32, ptr %61, align 4, !tbaa !9
  %1386 = load i32, ptr %33, align 4, !tbaa !9
  %1387 = mul nsw i32 %1385, %1386
  %1388 = add nsw i32 %1387, 1
  store i32 %1388, ptr %38, align 4, !tbaa !9
  %1389 = load ptr, ptr %24, align 8, !tbaa !5
  %1390 = load i32, ptr %38, align 4, !tbaa !9
  %1391 = sext i32 %1390 to i64
  %1392 = getelementptr inbounds %struct.doublecomplex, ptr %1389, i64 %1391
  %1393 = getelementptr inbounds %struct.doublecomplex, ptr %1392, i32 0, i32 0
  %1394 = load double, ptr %1393, align 8, !tbaa !15
  %1395 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %1394, ptr %1395, align 8, !tbaa !15
  %1396 = load ptr, ptr %24, align 8, !tbaa !5
  %1397 = load i32, ptr %38, 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 1
  %1401 = load double, ptr %1400, align 8, !tbaa !17
  %1402 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %1401, ptr %1402, align 8, !tbaa !17
  %1403 = load i32, ptr %61, align 4, !tbaa !9
  %1404 = load i32, ptr %35, align 4, !tbaa !9
  %1405 = mul nsw i32 %1403, %1404
  %1406 = add nsw i32 %1405, 1
  store i32 %1406, ptr %38, align 4, !tbaa !9
  %1407 = load ptr, ptr %20, align 8, !tbaa !5
  %1408 = getelementptr inbounds double, ptr %1407, i64 1
  %1409 = load double, ptr %1408, align 8, !tbaa !11
  %1410 = load ptr, ptr %26, align 8, !tbaa !5
  %1411 = load i32, ptr %38, align 4, !tbaa !9
  %1412 = sext i32 %1411 to i64
  %1413 = getelementptr inbounds %struct.doublecomplex, ptr %1410, i64 %1412
  %1414 = getelementptr inbounds %struct.doublecomplex, ptr %1413, i32 0, i32 0
  %1415 = load double, ptr %1414, align 8, !tbaa !15
  %1416 = fmul double %1409, %1415
  %1417 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1416, ptr %1417, align 8, !tbaa !15
  %1418 = load ptr, ptr %20, align 8, !tbaa !5
  %1419 = getelementptr inbounds double, ptr %1418, i64 1
  %1420 = load double, ptr %1419, align 8, !tbaa !11
  %1421 = load ptr, ptr %26, align 8, !tbaa !5
  %1422 = load i32, ptr %38, align 4, !tbaa !9
  %1423 = sext i32 %1422 to i64
  %1424 = getelementptr inbounds %struct.doublecomplex, ptr %1421, i64 %1423
  %1425 = getelementptr inbounds %struct.doublecomplex, ptr %1424, i32 0, i32 1
  %1426 = load double, ptr %1425, align 8, !tbaa !17
  %1427 = fmul double %1420, %1426
  %1428 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1427, ptr %1428, align 8, !tbaa !17
  %1429 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1430 = load double, ptr %1429, align 8, !tbaa !15
  %1431 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %1430, ptr %1431, align 8, !tbaa !15
  %1432 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1433 = load double, ptr %1432, align 8, !tbaa !17
  %1434 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %1433, ptr %1434, align 8, !tbaa !17
  %1435 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1436 = load double, ptr %1435, align 8, !tbaa !15
  %1437 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1438 = load double, ptr %1437, align 8, !tbaa !15
  %1439 = fsub double %1436, %1438
  %1440 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1439, ptr %1440, align 8, !tbaa !15
  %1441 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %1442 = load double, ptr %1441, align 8, !tbaa !17
  %1443 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %1444 = load double, ptr %1443, align 8, !tbaa !17
  %1445 = fsub double %1442, %1444
  %1446 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1445, ptr %1446, align 8, !tbaa !17
  %1447 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1448 = load double, ptr %1447, align 8, !tbaa !15
  %1449 = load ptr, ptr %30, align 8, !tbaa !5
  %1450 = getelementptr inbounds %struct.doublecomplex, ptr %1449, i64 1
  %1451 = getelementptr inbounds %struct.doublecomplex, ptr %1450, i32 0, i32 0
  store double %1448, ptr %1451, align 8, !tbaa !15
  %1452 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1453 = load double, ptr %1452, align 8, !tbaa !17
  %1454 = load ptr, ptr %30, align 8, !tbaa !5
  %1455 = getelementptr inbounds %struct.doublecomplex, ptr %1454, i64 1
  %1456 = getelementptr inbounds %struct.doublecomplex, ptr %1455, i32 0, i32 1
  store double %1453, ptr %1456, align 8, !tbaa !17
  %1457 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1458 = load double, ptr %1457, align 8, !tbaa !15
  store double %1458, ptr %43, align 8, !tbaa !11
  %1459 = load double, ptr %43, align 8, !tbaa !11
  %1460 = fcmp oge double %1459, 0.000000e+00
  br i1 %1460, label %1461, label %1463

1461:                                             ; preds = %1384
  %1462 = load double, ptr %43, align 8, !tbaa !11
  br label %1466

1463:                                             ; preds = %1384
  %1464 = load double, ptr %43, align 8, !tbaa !11
  %1465 = fneg double %1464
  br label %1466

1466:                                             ; preds = %1463, %1461
  %1467 = phi double [ %1462, %1461 ], [ %1465, %1463 ]
  %1468 = call { double, double } @Cd(ptr noundef %65)
  %1469 = extractvalue { double, double } %1468, 0
  %1470 = extractvalue { double, double } %1468, 1
  store double %1470, ptr %44, align 8, !tbaa !11
  %1471 = load double, ptr %44, align 8, !tbaa !11
  %1472 = fcmp oge double %1471, 0.000000e+00
  br i1 %1472, label %1473, label %1475

1473:                                             ; preds = %1466
  %1474 = load double, ptr %44, align 8, !tbaa !11
  br label %1478

1475:                                             ; preds = %1466
  %1476 = load double, ptr %44, align 8, !tbaa !11
  %1477 = fneg double %1476
  br label %1478

1478:                                             ; preds = %1475, %1473
  %1479 = phi double [ %1474, %1473 ], [ %1477, %1475 ]
  %1480 = fadd double %1467, %1479
  %1481 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1482 = load double, ptr %1481, align 8, !tbaa !15
  store double %1482, ptr %45, align 8, !tbaa !11
  %1483 = load double, ptr %45, align 8, !tbaa !11
  %1484 = fcmp oge double %1483, 0.000000e+00
  br i1 %1484, label %1485, label %1487

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

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

1490:                                             ; preds = %1487, %1485
  %1491 = phi double [ %1486, %1485 ], [ %1489, %1487 ]
  %1492 = call { double, double } @Cd(ptr noundef %67)
  %1493 = extractvalue { double, double } %1492, 0
  %1494 = extractvalue { double, double } %1492, 1
  store double %1494, ptr %46, align 8, !tbaa !11
  %1495 = load double, ptr %46, align 8, !tbaa !11
  %1496 = fcmp oge double %1495, 0.000000e+00
  br i1 %1496, label %1497, label %1499

1497:                                             ; preds = %1490
  %1498 = load double, ptr %46, align 8, !tbaa !11
  br label %1502

1499:                                             ; preds = %1490
  %1500 = load double, ptr %46, align 8, !tbaa !11
  %1501 = fneg double %1500
  br label %1502

1502:                                             ; preds = %1499, %1497
  %1503 = phi double [ %1498, %1497 ], [ %1501, %1499 ]
  %1504 = fadd double %1491, %1503
  %1505 = fadd double %1480, %1504
  %1506 = load ptr, ptr %31, align 8, !tbaa !5
  %1507 = getelementptr inbounds double, ptr %1506, i64 1
  store double %1505, ptr %1507, align 8, !tbaa !11
  br label %2538

1508:                                             ; preds = %1380
  %1509 = load i32, ptr %61, align 4, !tbaa !9
  %1510 = load i32, ptr %33, align 4, !tbaa !9
  %1511 = mul nsw i32 %1509, %1510
  %1512 = add nsw i32 %1511, 1
  store i32 %1512, ptr %38, align 4, !tbaa !9
  %1513 = load ptr, ptr %24, align 8, !tbaa !5
  %1514 = load i32, ptr %38, align 4, !tbaa !9
  %1515 = sext i32 %1514 to i64
  %1516 = getelementptr inbounds %struct.doublecomplex, ptr %1513, i64 %1515
  %1517 = getelementptr inbounds %struct.doublecomplex, ptr %1516, i32 0, i32 0
  %1518 = load double, ptr %1517, align 8, !tbaa !15
  %1519 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %1518, ptr %1519, align 8, !tbaa !15
  %1520 = load ptr, ptr %24, align 8, !tbaa !5
  %1521 = load i32, ptr %38, align 4, !tbaa !9
  %1522 = sext i32 %1521 to i64
  %1523 = getelementptr inbounds %struct.doublecomplex, ptr %1520, i64 %1522
  %1524 = getelementptr inbounds %struct.doublecomplex, ptr %1523, i32 0, i32 1
  %1525 = load double, ptr %1524, align 8, !tbaa !17
  %1526 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %1525, ptr %1526, align 8, !tbaa !17
  %1527 = load i32, ptr %61, align 4, !tbaa !9
  %1528 = load i32, ptr %35, align 4, !tbaa !9
  %1529 = mul nsw i32 %1527, %1528
  %1530 = add nsw i32 %1529, 1
  store i32 %1530, ptr %38, align 4, !tbaa !9
  %1531 = load ptr, ptr %20, align 8, !tbaa !5
  %1532 = getelementptr inbounds double, ptr %1531, i64 1
  %1533 = load double, ptr %1532, align 8, !tbaa !11
  %1534 = load ptr, ptr %26, align 8, !tbaa !5
  %1535 = load i32, ptr %38, align 4, !tbaa !9
  %1536 = sext i32 %1535 to i64
  %1537 = getelementptr inbounds %struct.doublecomplex, ptr %1534, i64 %1536
  %1538 = getelementptr inbounds %struct.doublecomplex, ptr %1537, i32 0, i32 0
  %1539 = load double, ptr %1538, align 8, !tbaa !15
  %1540 = fmul double %1533, %1539
  %1541 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1540, ptr %1541, align 8, !tbaa !15
  %1542 = load ptr, ptr %20, align 8, !tbaa !5
  %1543 = getelementptr inbounds double, ptr %1542, i64 1
  %1544 = load double, ptr %1543, align 8, !tbaa !11
  %1545 = load ptr, ptr %26, align 8, !tbaa !5
  %1546 = load i32, ptr %38, align 4, !tbaa !9
  %1547 = sext i32 %1546 to i64
  %1548 = getelementptr inbounds %struct.doublecomplex, ptr %1545, i64 %1547
  %1549 = getelementptr inbounds %struct.doublecomplex, ptr %1548, i32 0, i32 1
  %1550 = load double, ptr %1549, align 8, !tbaa !17
  %1551 = fmul double %1544, %1550
  %1552 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1551, ptr %1552, align 8, !tbaa !17
  %1553 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1554 = load double, ptr %1553, align 8, !tbaa !15
  %1555 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %1554, ptr %1555, align 8, !tbaa !15
  %1556 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1557 = load double, ptr %1556, align 8, !tbaa !17
  %1558 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %1557, ptr %1558, align 8, !tbaa !17
  %1559 = load ptr, ptr %21, align 8, !tbaa !5
  %1560 = getelementptr inbounds %struct.doublecomplex, ptr %1559, i64 1
  %1561 = call { double, double } @Cd(ptr noundef %1560)
  %1562 = extractvalue { double, double } %1561, 0
  %1563 = extractvalue { double, double } %1561, 1
  %1564 = fneg double %1563
  %1565 = call ptr @_pCd(ptr noundef %56)
  %1566 = getelementptr inbounds { double, double }, ptr %1565, i32 0, i32 0
  %1567 = getelementptr inbounds { double, double }, ptr %1565, i32 0, i32 1
  store double %1562, ptr %1566, align 8
  store double %1564, ptr %1567, align 8
  %1568 = load i32, ptr %61, align 4, !tbaa !9
  %1569 = load i32, ptr %35, align 4, !tbaa !9
  %1570 = mul nsw i32 %1568, %1569
  %1571 = add nsw i32 %1570, 2
  store i32 %1571, ptr %38, align 4, !tbaa !9
  %1572 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1573 = load double, ptr %1572, align 8, !tbaa !15
  %1574 = load ptr, ptr %26, align 8, !tbaa !5
  %1575 = load i32, ptr %38, align 4, !tbaa !9
  %1576 = sext i32 %1575 to i64
  %1577 = getelementptr inbounds %struct.doublecomplex, ptr %1574, i64 %1576
  %1578 = getelementptr inbounds %struct.doublecomplex, ptr %1577, i32 0, i32 0
  %1579 = load double, ptr %1578, align 8, !tbaa !15
  %1580 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1581 = load double, ptr %1580, align 8, !tbaa !17
  %1582 = load ptr, ptr %26, align 8, !tbaa !5
  %1583 = load i32, ptr %38, align 4, !tbaa !9
  %1584 = sext i32 %1583 to i64
  %1585 = getelementptr inbounds %struct.doublecomplex, ptr %1582, i64 %1584
  %1586 = getelementptr inbounds %struct.doublecomplex, ptr %1585, i32 0, i32 1
  %1587 = load double, ptr %1586, align 8, !tbaa !17
  %1588 = fmul double %1581, %1587
  %1589 = fneg double %1588
  %1590 = call double @llvm.fmuladd.f64(double %1573, double %1579, double %1589)
  %1591 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1590, ptr %1591, align 8, !tbaa !15
  %1592 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1593 = load double, ptr %1592, align 8, !tbaa !15
  %1594 = load ptr, ptr %26, align 8, !tbaa !5
  %1595 = load i32, ptr %38, align 4, !tbaa !9
  %1596 = sext i32 %1595 to i64
  %1597 = getelementptr inbounds %struct.doublecomplex, ptr %1594, i64 %1596
  %1598 = getelementptr inbounds %struct.doublecomplex, ptr %1597, i32 0, i32 1
  %1599 = load double, ptr %1598, align 8, !tbaa !17
  %1600 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1601 = load double, ptr %1600, align 8, !tbaa !17
  %1602 = load ptr, ptr %26, align 8, !tbaa !5
  %1603 = load i32, ptr %38, align 4, !tbaa !9
  %1604 = sext i32 %1603 to i64
  %1605 = getelementptr inbounds %struct.doublecomplex, ptr %1602, i64 %1604
  %1606 = getelementptr inbounds %struct.doublecomplex, ptr %1605, i32 0, i32 0
  %1607 = load double, ptr %1606, align 8, !tbaa !15
  %1608 = fmul double %1601, %1607
  %1609 = call double @llvm.fmuladd.f64(double %1593, double %1599, double %1608)
  %1610 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1609, ptr %1610, align 8, !tbaa !17
  %1611 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1612 = load double, ptr %1611, align 8, !tbaa !15
  %1613 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  store double %1612, ptr %1613, align 8, !tbaa !15
  %1614 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1615 = load double, ptr %1614, align 8, !tbaa !17
  %1616 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  store double %1615, ptr %1616, align 8, !tbaa !17
  %1617 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1618 = load double, ptr %1617, align 8, !tbaa !15
  %1619 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1620 = load double, ptr %1619, align 8, !tbaa !15
  %1621 = fsub double %1618, %1620
  %1622 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1621, ptr %1622, align 8, !tbaa !15
  %1623 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %1624 = load double, ptr %1623, align 8, !tbaa !17
  %1625 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %1626 = load double, ptr %1625, align 8, !tbaa !17
  %1627 = fsub double %1624, %1626
  %1628 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1627, ptr %1628, align 8, !tbaa !17
  %1629 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1630 = load double, ptr %1629, align 8, !tbaa !15
  %1631 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  %1632 = load double, ptr %1631, align 8, !tbaa !15
  %1633 = fsub double %1630, %1632
  %1634 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1633, ptr %1634, align 8, !tbaa !15
  %1635 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1636 = load double, ptr %1635, align 8, !tbaa !17
  %1637 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  %1638 = load double, ptr %1637, align 8, !tbaa !17
  %1639 = fsub double %1636, %1638
  %1640 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1639, ptr %1640, align 8, !tbaa !17
  %1641 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1642 = load double, ptr %1641, align 8, !tbaa !15
  %1643 = load ptr, ptr %30, align 8, !tbaa !5
  %1644 = getelementptr inbounds %struct.doublecomplex, ptr %1643, i64 1
  %1645 = getelementptr inbounds %struct.doublecomplex, ptr %1644, i32 0, i32 0
  store double %1642, ptr %1645, align 8, !tbaa !15
  %1646 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1647 = load double, ptr %1646, align 8, !tbaa !17
  %1648 = load ptr, ptr %30, align 8, !tbaa !5
  %1649 = getelementptr inbounds %struct.doublecomplex, ptr %1648, i64 1
  %1650 = getelementptr inbounds %struct.doublecomplex, ptr %1649, i32 0, i32 1
  store double %1647, ptr %1650, align 8, !tbaa !17
  %1651 = load i32, ptr %61, align 4, !tbaa !9
  %1652 = load i32, ptr %35, align 4, !tbaa !9
  %1653 = mul nsw i32 %1651, %1652
  %1654 = add nsw i32 %1653, 2
  store i32 %1654, ptr %38, align 4, !tbaa !9
  %1655 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1656 = load double, ptr %1655, align 8, !tbaa !15
  store double %1656, ptr %43, align 8, !tbaa !11
  %1657 = load double, ptr %43, align 8, !tbaa !11
  %1658 = fcmp oge double %1657, 0.000000e+00
  br i1 %1658, label %1659, label %1661

1659:                                             ; preds = %1508
  %1660 = load double, ptr %43, align 8, !tbaa !11
  br label %1664

1661:                                             ; preds = %1508
  %1662 = load double, ptr %43, align 8, !tbaa !11
  %1663 = fneg double %1662
  br label %1664

1664:                                             ; preds = %1661, %1659
  %1665 = phi double [ %1660, %1659 ], [ %1663, %1661 ]
  %1666 = call { double, double } @Cd(ptr noundef %65)
  %1667 = extractvalue { double, double } %1666, 0
  %1668 = extractvalue { double, double } %1666, 1
  store double %1668, ptr %44, align 8, !tbaa !11
  %1669 = load double, ptr %44, align 8, !tbaa !11
  %1670 = fcmp oge double %1669, 0.000000e+00
  br i1 %1670, label %1671, label %1673

1671:                                             ; preds = %1664
  %1672 = load double, ptr %44, align 8, !tbaa !11
  br label %1676

1673:                                             ; preds = %1664
  %1674 = load double, ptr %44, align 8, !tbaa !11
  %1675 = fneg double %1674
  br label %1676

1676:                                             ; preds = %1673, %1671
  %1677 = phi double [ %1672, %1671 ], [ %1675, %1673 ]
  %1678 = fadd double %1665, %1677
  %1679 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1680 = load double, ptr %1679, align 8, !tbaa !15
  store double %1680, ptr %45, align 8, !tbaa !11
  %1681 = load double, ptr %45, align 8, !tbaa !11
  %1682 = fcmp oge double %1681, 0.000000e+00
  br i1 %1682, label %1683, label %1685

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

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

1688:                                             ; preds = %1685, %1683
  %1689 = phi double [ %1684, %1683 ], [ %1687, %1685 ]
  %1690 = call { double, double } @Cd(ptr noundef %67)
  %1691 = extractvalue { double, double } %1690, 0
  %1692 = extractvalue { double, double } %1690, 1
  store double %1692, ptr %46, align 8, !tbaa !11
  %1693 = load double, ptr %46, align 8, !tbaa !11
  %1694 = fcmp oge double %1693, 0.000000e+00
  br i1 %1694, label %1695, label %1697

1695:                                             ; preds = %1688
  %1696 = load double, ptr %46, align 8, !tbaa !11
  br label %1700

1697:                                             ; preds = %1688
  %1698 = load double, ptr %46, align 8, !tbaa !11
  %1699 = fneg double %1698
  br label %1700

1700:                                             ; preds = %1697, %1695
  %1701 = phi double [ %1696, %1695 ], [ %1699, %1697 ]
  %1702 = fadd double %1689, %1701
  %1703 = fadd double %1678, %1702
  %1704 = load ptr, ptr %21, align 8, !tbaa !5
  %1705 = getelementptr inbounds %struct.doublecomplex, ptr %1704, i64 1
  %1706 = getelementptr inbounds %struct.doublecomplex, ptr %1705, i32 0, i32 0
  %1707 = load double, ptr %1706, align 8, !tbaa !15
  store double %1707, ptr %47, align 8, !tbaa !11
  %1708 = load double, ptr %47, align 8, !tbaa !11
  %1709 = fcmp oge double %1708, 0.000000e+00
  br i1 %1709, label %1710, label %1712

1710:                                             ; preds = %1700
  %1711 = load double, ptr %47, align 8, !tbaa !11
  br label %1715

1712:                                             ; preds = %1700
  %1713 = load double, ptr %47, align 8, !tbaa !11
  %1714 = fneg double %1713
  br label %1715

1715:                                             ; preds = %1712, %1710
  %1716 = phi double [ %1711, %1710 ], [ %1714, %1712 ]
  %1717 = load ptr, ptr %21, align 8, !tbaa !5
  %1718 = getelementptr inbounds %struct.doublecomplex, ptr %1717, i64 1
  %1719 = call { double, double } @Cd(ptr noundef %1718)
  %1720 = extractvalue { double, double } %1719, 0
  %1721 = extractvalue { double, double } %1719, 1
  store double %1721, ptr %48, align 8, !tbaa !11
  %1722 = load double, ptr %48, align 8, !tbaa !11
  %1723 = fcmp oge double %1722, 0.000000e+00
  br i1 %1723, label %1724, label %1726

1724:                                             ; preds = %1715
  %1725 = load double, ptr %48, align 8, !tbaa !11
  br label %1729

1726:                                             ; preds = %1715
  %1727 = load double, ptr %48, align 8, !tbaa !11
  %1728 = fneg double %1727
  br label %1729

1729:                                             ; preds = %1726, %1724
  %1730 = phi double [ %1725, %1724 ], [ %1728, %1726 ]
  %1731 = fadd double %1716, %1730
  %1732 = load ptr, ptr %26, align 8, !tbaa !5
  %1733 = load i32, ptr %38, align 4, !tbaa !9
  %1734 = sext i32 %1733 to i64
  %1735 = getelementptr inbounds %struct.doublecomplex, ptr %1732, i64 %1734
  %1736 = getelementptr inbounds %struct.doublecomplex, ptr %1735, i32 0, i32 0
  %1737 = load double, ptr %1736, align 8, !tbaa !15
  store double %1737, ptr %49, align 8, !tbaa !11
  %1738 = load double, ptr %49, align 8, !tbaa !11
  %1739 = fcmp oge double %1738, 0.000000e+00
  br i1 %1739, label %1740, label %1742

1740:                                             ; preds = %1729
  %1741 = load double, ptr %49, align 8, !tbaa !11
  br label %1745

1742:                                             ; preds = %1729
  %1743 = load double, ptr %49, align 8, !tbaa !11
  %1744 = fneg double %1743
  br label %1745

1745:                                             ; preds = %1742, %1740
  %1746 = phi double [ %1741, %1740 ], [ %1744, %1742 ]
  %1747 = load ptr, ptr %26, align 8, !tbaa !5
  %1748 = load i32, ptr %61, align 4, !tbaa !9
  %1749 = load i32, ptr %35, align 4, !tbaa !9
  %1750 = mul nsw i32 %1748, %1749
  %1751 = add nsw i32 %1750, 2
  %1752 = sext i32 %1751 to i64
  %1753 = getelementptr inbounds %struct.doublecomplex, ptr %1747, i64 %1752
  %1754 = call { double, double } @Cd(ptr noundef %1753)
  %1755 = extractvalue { double, double } %1754, 0
  %1756 = extractvalue { double, double } %1754, 1
  store double %1756, ptr %50, align 8, !tbaa !11
  %1757 = load double, ptr %50, align 8, !tbaa !11
  %1758 = fcmp oge double %1757, 0.000000e+00
  br i1 %1758, label %1759, label %1761

1759:                                             ; preds = %1745
  %1760 = load double, ptr %50, align 8, !tbaa !11
  br label %1764

1761:                                             ; preds = %1745
  %1762 = load double, ptr %50, align 8, !tbaa !11
  %1763 = fneg double %1762
  br label %1764

1764:                                             ; preds = %1761, %1759
  %1765 = phi double [ %1760, %1759 ], [ %1763, %1761 ]
  %1766 = fadd double %1746, %1765
  %1767 = call double @llvm.fmuladd.f64(double %1731, double %1766, double %1703)
  %1768 = load ptr, ptr %31, align 8, !tbaa !5
  %1769 = getelementptr inbounds double, ptr %1768, i64 1
  store double %1767, ptr %1769, align 8, !tbaa !11
  %1770 = load ptr, ptr %18, align 8, !tbaa !5
  %1771 = load i32, ptr %1770, align 4, !tbaa !9
  %1772 = sub nsw i32 %1771, 1
  store i32 %1772, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %1773

1773:                                             ; preds = %2226, %1764
  %1774 = load i32, ptr %60, align 4, !tbaa !9
  %1775 = load i32, ptr %38, align 4, !tbaa !9
  %1776 = icmp sle i32 %1774, %1775
  br i1 %1776, label %1777, label %2229

1777:                                             ; preds = %1773
  %1778 = load i32, ptr %60, align 4, !tbaa !9
  %1779 = load i32, ptr %61, align 4, !tbaa !9
  %1780 = load i32, ptr %33, align 4, !tbaa !9
  %1781 = mul nsw i32 %1779, %1780
  %1782 = add nsw i32 %1778, %1781
  store i32 %1782, ptr %39, align 4, !tbaa !9
  %1783 = load ptr, ptr %24, align 8, !tbaa !5
  %1784 = load i32, ptr %39, 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 0
  %1788 = load double, ptr %1787, align 8, !tbaa !15
  %1789 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  store double %1788, ptr %1789, align 8, !tbaa !15
  %1790 = load ptr, ptr %24, align 8, !tbaa !5
  %1791 = load i32, ptr %39, align 4, !tbaa !9
  %1792 = sext i32 %1791 to i64
  %1793 = getelementptr inbounds %struct.doublecomplex, ptr %1790, i64 %1792
  %1794 = getelementptr inbounds %struct.doublecomplex, ptr %1793, i32 0, i32 1
  %1795 = load double, ptr %1794, align 8, !tbaa !17
  %1796 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  store double %1795, ptr %1796, align 8, !tbaa !17
  %1797 = load i32, ptr %60, align 4, !tbaa !9
  %1798 = sub nsw i32 %1797, 1
  store i32 %1798, ptr %39, align 4, !tbaa !9
  %1799 = load i32, ptr %60, align 4, !tbaa !9
  %1800 = sub nsw i32 %1799, 1
  %1801 = load i32, ptr %61, align 4, !tbaa !9
  %1802 = load i32, ptr %35, align 4, !tbaa !9
  %1803 = mul nsw i32 %1801, %1802
  %1804 = add nsw i32 %1800, %1803
  store i32 %1804, ptr %40, align 4, !tbaa !9
  %1805 = load ptr, ptr %21, align 8, !tbaa !5
  %1806 = load i32, ptr %39, align 4, !tbaa !9
  %1807 = sext i32 %1806 to i64
  %1808 = getelementptr inbounds %struct.doublecomplex, ptr %1805, i64 %1807
  %1809 = getelementptr inbounds %struct.doublecomplex, ptr %1808, i32 0, i32 0
  %1810 = load double, ptr %1809, align 8, !tbaa !15
  %1811 = load ptr, ptr %26, align 8, !tbaa !5
  %1812 = load i32, ptr %40, align 4, !tbaa !9
  %1813 = sext i32 %1812 to i64
  %1814 = getelementptr inbounds %struct.doublecomplex, ptr %1811, i64 %1813
  %1815 = getelementptr inbounds %struct.doublecomplex, ptr %1814, i32 0, i32 0
  %1816 = load double, ptr %1815, align 8, !tbaa !15
  %1817 = load ptr, ptr %21, align 8, !tbaa !5
  %1818 = load i32, ptr %39, align 4, !tbaa !9
  %1819 = sext i32 %1818 to i64
  %1820 = getelementptr inbounds %struct.doublecomplex, ptr %1817, i64 %1819
  %1821 = getelementptr inbounds %struct.doublecomplex, ptr %1820, i32 0, i32 1
  %1822 = load double, ptr %1821, align 8, !tbaa !17
  %1823 = load ptr, ptr %26, align 8, !tbaa !5
  %1824 = load i32, ptr %40, align 4, !tbaa !9
  %1825 = sext i32 %1824 to i64
  %1826 = getelementptr inbounds %struct.doublecomplex, ptr %1823, i64 %1825
  %1827 = getelementptr inbounds %struct.doublecomplex, ptr %1826, i32 0, i32 1
  %1828 = load double, ptr %1827, align 8, !tbaa !17
  %1829 = fmul double %1822, %1828
  %1830 = fneg double %1829
  %1831 = call double @llvm.fmuladd.f64(double %1810, double %1816, double %1830)
  %1832 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1831, ptr %1832, align 8, !tbaa !15
  %1833 = load ptr, ptr %21, align 8, !tbaa !5
  %1834 = load i32, ptr %39, align 4, !tbaa !9
  %1835 = sext i32 %1834 to i64
  %1836 = getelementptr inbounds %struct.doublecomplex, ptr %1833, i64 %1835
  %1837 = getelementptr inbounds %struct.doublecomplex, ptr %1836, i32 0, i32 0
  %1838 = load double, ptr %1837, align 8, !tbaa !15
  %1839 = load ptr, ptr %26, align 8, !tbaa !5
  %1840 = load i32, ptr %40, align 4, !tbaa !9
  %1841 = sext i32 %1840 to i64
  %1842 = getelementptr inbounds %struct.doublecomplex, ptr %1839, i64 %1841
  %1843 = getelementptr inbounds %struct.doublecomplex, ptr %1842, i32 0, i32 1
  %1844 = load double, ptr %1843, align 8, !tbaa !17
  %1845 = load ptr, ptr %21, align 8, !tbaa !5
  %1846 = load i32, ptr %39, align 4, !tbaa !9
  %1847 = sext i32 %1846 to i64
  %1848 = getelementptr inbounds %struct.doublecomplex, ptr %1845, i64 %1847
  %1849 = getelementptr inbounds %struct.doublecomplex, ptr %1848, i32 0, i32 1
  %1850 = load double, ptr %1849, align 8, !tbaa !17
  %1851 = load ptr, ptr %26, align 8, !tbaa !5
  %1852 = load i32, ptr %40, align 4, !tbaa !9
  %1853 = sext i32 %1852 to i64
  %1854 = getelementptr inbounds %struct.doublecomplex, ptr %1851, i64 %1853
  %1855 = getelementptr inbounds %struct.doublecomplex, ptr %1854, i32 0, i32 0
  %1856 = load double, ptr %1855, align 8, !tbaa !15
  %1857 = fmul double %1850, %1856
  %1858 = call double @llvm.fmuladd.f64(double %1838, double %1844, double %1857)
  %1859 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1858, ptr %1859, align 8, !tbaa !17
  %1860 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1861 = load double, ptr %1860, align 8, !tbaa !15
  %1862 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  store double %1861, ptr %1862, align 8, !tbaa !15
  %1863 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1864 = load double, ptr %1863, align 8, !tbaa !17
  %1865 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  store double %1864, ptr %1865, align 8, !tbaa !17
  %1866 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %1866, ptr %39, align 4, !tbaa !9
  %1867 = load i32, ptr %60, align 4, !tbaa !9
  %1868 = load i32, ptr %61, align 4, !tbaa !9
  %1869 = load i32, ptr %35, align 4, !tbaa !9
  %1870 = mul nsw i32 %1868, %1869
  %1871 = add nsw i32 %1867, %1870
  store i32 %1871, ptr %40, align 4, !tbaa !9
  %1872 = load ptr, ptr %20, align 8, !tbaa !5
  %1873 = load i32, ptr %39, align 4, !tbaa !9
  %1874 = sext i32 %1873 to i64
  %1875 = getelementptr inbounds double, ptr %1872, i64 %1874
  %1876 = load double, ptr %1875, align 8, !tbaa !11
  %1877 = load ptr, ptr %26, align 8, !tbaa !5
  %1878 = load i32, ptr %40, align 4, !tbaa !9
  %1879 = sext i32 %1878 to i64
  %1880 = getelementptr inbounds %struct.doublecomplex, ptr %1877, i64 %1879
  %1881 = getelementptr inbounds %struct.doublecomplex, ptr %1880, i32 0, i32 0
  %1882 = load double, ptr %1881, align 8, !tbaa !15
  %1883 = fmul double %1876, %1882
  %1884 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1883, ptr %1884, align 8, !tbaa !15
  %1885 = load ptr, ptr %20, align 8, !tbaa !5
  %1886 = load i32, ptr %39, align 4, !tbaa !9
  %1887 = sext i32 %1886 to i64
  %1888 = getelementptr inbounds double, ptr %1885, i64 %1887
  %1889 = load double, ptr %1888, align 8, !tbaa !11
  %1890 = load ptr, ptr %26, align 8, !tbaa !5
  %1891 = load i32, ptr %40, align 4, !tbaa !9
  %1892 = sext i32 %1891 to i64
  %1893 = getelementptr inbounds %struct.doublecomplex, ptr %1890, i64 %1892
  %1894 = getelementptr inbounds %struct.doublecomplex, ptr %1893, i32 0, i32 1
  %1895 = load double, ptr %1894, align 8, !tbaa !17
  %1896 = fmul double %1889, %1895
  %1897 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1896, ptr %1897, align 8, !tbaa !17
  %1898 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1899 = load double, ptr %1898, align 8, !tbaa !15
  %1900 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  store double %1899, ptr %1900, align 8, !tbaa !15
  %1901 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1902 = load double, ptr %1901, align 8, !tbaa !17
  %1903 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  store double %1902, ptr %1903, align 8, !tbaa !17
  %1904 = load ptr, ptr %21, align 8, !tbaa !5
  %1905 = load i32, ptr %60, align 4, !tbaa !9
  %1906 = sext i32 %1905 to i64
  %1907 = getelementptr inbounds %struct.doublecomplex, ptr %1904, i64 %1906
  %1908 = call { double, double } @Cd(ptr noundef %1907)
  %1909 = extractvalue { double, double } %1908, 0
  %1910 = extractvalue { double, double } %1908, 1
  %1911 = fneg double %1910
  %1912 = call ptr @_pCd(ptr noundef %56)
  %1913 = getelementptr inbounds { double, double }, ptr %1912, i32 0, i32 0
  %1914 = getelementptr inbounds { double, double }, ptr %1912, i32 0, i32 1
  store double %1909, ptr %1913, align 8
  store double %1911, ptr %1914, align 8
  %1915 = load i32, ptr %60, align 4, !tbaa !9
  %1916 = add nsw i32 %1915, 1
  %1917 = load i32, ptr %61, align 4, !tbaa !9
  %1918 = load i32, ptr %35, align 4, !tbaa !9
  %1919 = mul nsw i32 %1917, %1918
  %1920 = add nsw i32 %1916, %1919
  store i32 %1920, ptr %39, align 4, !tbaa !9
  %1921 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1922 = load double, ptr %1921, align 8, !tbaa !15
  %1923 = load ptr, ptr %26, align 8, !tbaa !5
  %1924 = load i32, ptr %39, align 4, !tbaa !9
  %1925 = sext i32 %1924 to i64
  %1926 = getelementptr inbounds %struct.doublecomplex, ptr %1923, i64 %1925
  %1927 = getelementptr inbounds %struct.doublecomplex, ptr %1926, i32 0, i32 0
  %1928 = load double, ptr %1927, align 8, !tbaa !15
  %1929 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1930 = load double, ptr %1929, align 8, !tbaa !17
  %1931 = load ptr, ptr %26, align 8, !tbaa !5
  %1932 = load i32, ptr %39, align 4, !tbaa !9
  %1933 = sext i32 %1932 to i64
  %1934 = getelementptr inbounds %struct.doublecomplex, ptr %1931, i64 %1933
  %1935 = getelementptr inbounds %struct.doublecomplex, ptr %1934, i32 0, i32 1
  %1936 = load double, ptr %1935, align 8, !tbaa !17
  %1937 = fmul double %1930, %1936
  %1938 = fneg double %1937
  %1939 = call double @llvm.fmuladd.f64(double %1922, double %1928, double %1938)
  %1940 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1939, ptr %1940, align 8, !tbaa !15
  %1941 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1942 = load double, ptr %1941, align 8, !tbaa !15
  %1943 = load ptr, ptr %26, align 8, !tbaa !5
  %1944 = load i32, ptr %39, align 4, !tbaa !9
  %1945 = sext i32 %1944 to i64
  %1946 = getelementptr inbounds %struct.doublecomplex, ptr %1943, i64 %1945
  %1947 = getelementptr inbounds %struct.doublecomplex, ptr %1946, i32 0, i32 1
  %1948 = load double, ptr %1947, align 8, !tbaa !17
  %1949 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1950 = load double, ptr %1949, align 8, !tbaa !17
  %1951 = load ptr, ptr %26, align 8, !tbaa !5
  %1952 = load i32, ptr %39, align 4, !tbaa !9
  %1953 = sext i32 %1952 to i64
  %1954 = getelementptr inbounds %struct.doublecomplex, ptr %1951, i64 %1953
  %1955 = getelementptr inbounds %struct.doublecomplex, ptr %1954, i32 0, i32 0
  %1956 = load double, ptr %1955, align 8, !tbaa !15
  %1957 = fmul double %1950, %1956
  %1958 = call double @llvm.fmuladd.f64(double %1942, double %1948, double %1957)
  %1959 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %1958, ptr %1959, align 8, !tbaa !17
  %1960 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %1961 = load double, ptr %1960, align 8, !tbaa !15
  %1962 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  store double %1961, ptr %1962, align 8, !tbaa !15
  %1963 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %1964 = load double, ptr %1963, align 8, !tbaa !17
  %1965 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  store double %1964, ptr %1965, align 8, !tbaa !17
  %1966 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %1966, ptr %39, align 4, !tbaa !9
  %1967 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %1968 = load double, ptr %1967, align 8, !tbaa !15
  %1969 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 0
  %1970 = load double, ptr %1969, align 8, !tbaa !15
  %1971 = fsub double %1968, %1970
  %1972 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  store double %1971, ptr %1972, align 8, !tbaa !15
  %1973 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 1
  %1974 = load double, ptr %1973, align 8, !tbaa !17
  %1975 = getelementptr inbounds %struct.doublecomplex, ptr %66, i32 0, i32 1
  %1976 = load double, ptr %1975, align 8, !tbaa !17
  %1977 = fsub double %1974, %1976
  %1978 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  store double %1977, ptr %1978, align 8, !tbaa !17
  %1979 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 0
  %1980 = load double, ptr %1979, align 8, !tbaa !15
  %1981 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %1982 = load double, ptr %1981, align 8, !tbaa !15
  %1983 = fsub double %1980, %1982
  %1984 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  store double %1983, ptr %1984, align 8, !tbaa !15
  %1985 = getelementptr inbounds %struct.doublecomplex, ptr %57, i32 0, i32 1
  %1986 = load double, ptr %1985, align 8, !tbaa !17
  %1987 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 1
  %1988 = load double, ptr %1987, align 8, !tbaa !17
  %1989 = fsub double %1986, %1988
  %1990 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  store double %1989, ptr %1990, align 8, !tbaa !17
  %1991 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 0
  %1992 = load double, ptr %1991, align 8, !tbaa !15
  %1993 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 0
  %1994 = load double, ptr %1993, align 8, !tbaa !15
  %1995 = fsub double %1992, %1994
  %1996 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  store double %1995, ptr %1996, align 8, !tbaa !15
  %1997 = getelementptr inbounds %struct.doublecomplex, ptr %56, i32 0, i32 1
  %1998 = load double, ptr %1997, align 8, !tbaa !17
  %1999 = getelementptr inbounds %struct.doublecomplex, ptr %68, i32 0, i32 1
  %2000 = load double, ptr %1999, align 8, !tbaa !17
  %2001 = fsub double %1998, %2000
  %2002 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  store double %2001, ptr %2002, align 8, !tbaa !17
  %2003 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 0
  %2004 = load double, ptr %2003, align 8, !tbaa !15
  %2005 = load ptr, ptr %30, align 8, !tbaa !5
  %2006 = load i32, ptr %39, align 4, !tbaa !9
  %2007 = sext i32 %2006 to i64
  %2008 = getelementptr inbounds %struct.doublecomplex, ptr %2005, i64 %2007
  %2009 = getelementptr inbounds %struct.doublecomplex, ptr %2008, i32 0, i32 0
  store double %2004, ptr %2009, align 8, !tbaa !15
  %2010 = getelementptr inbounds %struct.doublecomplex, ptr %55, i32 0, i32 1
  %2011 = load double, ptr %2010, align 8, !tbaa !17
  %2012 = load ptr, ptr %30, align 8, !tbaa !5
  %2013 = load i32, ptr %39, align 4, !tbaa !9
  %2014 = sext i32 %2013 to i64
  %2015 = getelementptr inbounds %struct.doublecomplex, ptr %2012, i64 %2014
  %2016 = getelementptr inbounds %struct.doublecomplex, ptr %2015, i32 0, i32 1
  store double %2011, ptr %2016, align 8, !tbaa !17
  %2017 = load i32, ptr %60, align 4, !tbaa !9
  %2018 = sub nsw i32 %2017, 1
  store i32 %2018, ptr %39, align 4, !tbaa !9
  %2019 = load i32, ptr %60, align 4, !tbaa !9
  %2020 = sub nsw i32 %2019, 1
  %2021 = load i32, ptr %61, align 4, !tbaa !9
  %2022 = load i32, ptr %35, align 4, !tbaa !9
  %2023 = mul nsw i32 %2021, %2022
  %2024 = add nsw i32 %2020, %2023
  store i32 %2024, ptr %40, align 4, !tbaa !9
  %2025 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2025, ptr %41, align 4, !tbaa !9
  %2026 = load i32, ptr %60, align 4, !tbaa !9
  %2027 = add nsw i32 %2026, 1
  %2028 = load i32, ptr %61, align 4, !tbaa !9
  %2029 = load i32, ptr %35, align 4, !tbaa !9
  %2030 = mul nsw i32 %2028, %2029
  %2031 = add nsw i32 %2027, %2030
  store i32 %2031, ptr %42, align 4, !tbaa !9
  %2032 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %2033 = load double, ptr %2032, align 8, !tbaa !15
  store double %2033, ptr %43, align 8, !tbaa !11
  %2034 = load double, ptr %43, align 8, !tbaa !11
  %2035 = fcmp oge double %2034, 0.000000e+00
  br i1 %2035, label %2036, label %2038

2036:                                             ; preds = %1777
  %2037 = load double, ptr %43, align 8, !tbaa !11
  br label %2041

2038:                                             ; preds = %1777
  %2039 = load double, ptr %43, align 8, !tbaa !11
  %2040 = fneg double %2039
  br label %2041

2041:                                             ; preds = %2038, %2036
  %2042 = phi double [ %2037, %2036 ], [ %2040, %2038 ]
  %2043 = call { double, double } @Cd(ptr noundef %65)
  %2044 = extractvalue { double, double } %2043, 0
  %2045 = extractvalue { double, double } %2043, 1
  store double %2045, ptr %44, align 8, !tbaa !11
  %2046 = load double, ptr %44, align 8, !tbaa !11
  %2047 = fcmp oge double %2046, 0.000000e+00
  br i1 %2047, label %2048, label %2050

2048:                                             ; preds = %2041
  %2049 = load double, ptr %44, align 8, !tbaa !11
  br label %2053

2050:                                             ; preds = %2041
  %2051 = load double, ptr %44, align 8, !tbaa !11
  %2052 = fneg double %2051
  br label %2053

2053:                                             ; preds = %2050, %2048
  %2054 = phi double [ %2049, %2048 ], [ %2052, %2050 ]
  %2055 = fadd double %2042, %2054
  %2056 = load ptr, ptr %21, align 8, !tbaa !5
  %2057 = load i32, ptr %39, align 4, !tbaa !9
  %2058 = sext i32 %2057 to i64
  %2059 = getelementptr inbounds %struct.doublecomplex, ptr %2056, i64 %2058
  %2060 = getelementptr inbounds %struct.doublecomplex, ptr %2059, i32 0, i32 0
  %2061 = load double, ptr %2060, align 8, !tbaa !15
  store double %2061, ptr %45, align 8, !tbaa !11
  %2062 = load double, ptr %45, align 8, !tbaa !11
  %2063 = fcmp oge double %2062, 0.000000e+00
  br i1 %2063, label %2064, label %2066

2064:                                             ; preds = %2053
  %2065 = load double, ptr %45, align 8, !tbaa !11
  br label %2069

2066:                                             ; preds = %2053
  %2067 = load double, ptr %45, align 8, !tbaa !11
  %2068 = fneg double %2067
  br label %2069

2069:                                             ; preds = %2066, %2064
  %2070 = phi double [ %2065, %2064 ], [ %2068, %2066 ]
  %2071 = load ptr, ptr %21, align 8, !tbaa !5
  %2072 = load i32, ptr %60, align 4, !tbaa !9
  %2073 = sub nsw i32 %2072, 1
  %2074 = sext i32 %2073 to i64
  %2075 = getelementptr inbounds %struct.doublecomplex, ptr %2071, i64 %2074
  %2076 = call { double, double } @Cd(ptr noundef %2075)
  %2077 = extractvalue { double, double } %2076, 0
  %2078 = extractvalue { double, double } %2076, 1
  store double %2078, ptr %46, align 8, !tbaa !11
  %2079 = load double, ptr %46, align 8, !tbaa !11
  %2080 = fcmp oge double %2079, 0.000000e+00
  br i1 %2080, label %2081, label %2083

2081:                                             ; preds = %2069
  %2082 = load double, ptr %46, align 8, !tbaa !11
  br label %2086

2083:                                             ; preds = %2069
  %2084 = load double, ptr %46, align 8, !tbaa !11
  %2085 = fneg double %2084
  br label %2086

2086:                                             ; preds = %2083, %2081
  %2087 = phi double [ %2082, %2081 ], [ %2085, %2083 ]
  %2088 = fadd double %2070, %2087
  %2089 = load ptr, ptr %26, align 8, !tbaa !5
  %2090 = load i32, ptr %40, align 4, !tbaa !9
  %2091 = sext i32 %2090 to i64
  %2092 = getelementptr inbounds %struct.doublecomplex, ptr %2089, i64 %2091
  %2093 = getelementptr inbounds %struct.doublecomplex, ptr %2092, i32 0, i32 0
  %2094 = load double, ptr %2093, align 8, !tbaa !15
  store double %2094, ptr %47, align 8, !tbaa !11
  %2095 = load double, ptr %47, align 8, !tbaa !11
  %2096 = fcmp oge double %2095, 0.000000e+00
  br i1 %2096, label %2097, label %2099

2097:                                             ; preds = %2086
  %2098 = load double, ptr %47, align 8, !tbaa !11
  br label %2102

2099:                                             ; preds = %2086
  %2100 = load double, ptr %47, align 8, !tbaa !11
  %2101 = fneg double %2100
  br label %2102

2102:                                             ; preds = %2099, %2097
  %2103 = phi double [ %2098, %2097 ], [ %2101, %2099 ]
  %2104 = load ptr, ptr %26, align 8, !tbaa !5
  %2105 = load i32, ptr %60, align 4, !tbaa !9
  %2106 = sub nsw i32 %2105, 1
  %2107 = load i32, ptr %61, align 4, !tbaa !9
  %2108 = load i32, ptr %35, align 4, !tbaa !9
  %2109 = mul nsw i32 %2107, %2108
  %2110 = add nsw i32 %2106, %2109
  %2111 = sext i32 %2110 to i64
  %2112 = getelementptr inbounds %struct.doublecomplex, ptr %2104, i64 %2111
  %2113 = call { double, double } @Cd(ptr noundef %2112)
  %2114 = extractvalue { double, double } %2113, 0
  %2115 = extractvalue { double, double } %2113, 1
  store double %2115, ptr %48, align 8, !tbaa !11
  %2116 = load double, ptr %48, align 8, !tbaa !11
  %2117 = fcmp oge double %2116, 0.000000e+00
  br i1 %2117, label %2118, label %2120

2118:                                             ; preds = %2102
  %2119 = load double, ptr %48, align 8, !tbaa !11
  br label %2123

2120:                                             ; preds = %2102
  %2121 = load double, ptr %48, align 8, !tbaa !11
  %2122 = fneg double %2121
  br label %2123

2123:                                             ; preds = %2120, %2118
  %2124 = phi double [ %2119, %2118 ], [ %2122, %2120 ]
  %2125 = fadd double %2103, %2124
  %2126 = call double @llvm.fmuladd.f64(double %2088, double %2125, double %2055)
  %2127 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2128 = load double, ptr %2127, align 8, !tbaa !15
  store double %2128, ptr %49, align 8, !tbaa !11
  %2129 = load double, ptr %49, align 8, !tbaa !11
  %2130 = fcmp oge double %2129, 0.000000e+00
  br i1 %2130, label %2131, label %2133

2131:                                             ; preds = %2123
  %2132 = load double, ptr %49, align 8, !tbaa !11
  br label %2136

2133:                                             ; preds = %2123
  %2134 = load double, ptr %49, align 8, !tbaa !11
  %2135 = fneg double %2134
  br label %2136

2136:                                             ; preds = %2133, %2131
  %2137 = phi double [ %2132, %2131 ], [ %2135, %2133 ]
  %2138 = call { double, double } @Cd(ptr noundef %67)
  %2139 = extractvalue { double, double } %2138, 0
  %2140 = extractvalue { double, double } %2138, 1
  store double %2140, ptr %50, align 8, !tbaa !11
  %2141 = load double, ptr %50, align 8, !tbaa !11
  %2142 = fcmp oge double %2141, 0.000000e+00
  br i1 %2142, label %2143, label %2145

2143:                                             ; preds = %2136
  %2144 = load double, ptr %50, align 8, !tbaa !11
  br label %2148

2145:                                             ; preds = %2136
  %2146 = load double, ptr %50, align 8, !tbaa !11
  %2147 = fneg double %2146
  br label %2148

2148:                                             ; preds = %2145, %2143
  %2149 = phi double [ %2144, %2143 ], [ %2147, %2145 ]
  %2150 = fadd double %2137, %2149
  %2151 = fadd double %2126, %2150
  %2152 = load ptr, ptr %21, align 8, !tbaa !5
  %2153 = load i32, ptr %41, align 4, !tbaa !9
  %2154 = sext i32 %2153 to i64
  %2155 = getelementptr inbounds %struct.doublecomplex, ptr %2152, i64 %2154
  %2156 = getelementptr inbounds %struct.doublecomplex, ptr %2155, i32 0, i32 0
  %2157 = load double, ptr %2156, align 8, !tbaa !15
  store double %2157, ptr %51, align 8, !tbaa !11
  %2158 = load double, ptr %51, align 8, !tbaa !11
  %2159 = fcmp oge double %2158, 0.000000e+00
  br i1 %2159, label %2160, label %2162

2160:                                             ; preds = %2148
  %2161 = load double, ptr %51, align 8, !tbaa !11
  br label %2165

2162:                                             ; preds = %2148
  %2163 = load double, ptr %51, align 8, !tbaa !11
  %2164 = fneg double %2163
  br label %2165

2165:                                             ; preds = %2162, %2160
  %2166 = phi double [ %2161, %2160 ], [ %2164, %2162 ]
  %2167 = load ptr, ptr %21, align 8, !tbaa !5
  %2168 = load i32, ptr %60, align 4, !tbaa !9
  %2169 = sext i32 %2168 to i64
  %2170 = getelementptr inbounds %struct.doublecomplex, ptr %2167, i64 %2169
  %2171 = call { double, double } @Cd(ptr noundef %2170)
  %2172 = extractvalue { double, double } %2171, 0
  %2173 = extractvalue { double, double } %2171, 1
  store double %2173, ptr %52, align 8, !tbaa !11
  %2174 = load double, ptr %52, align 8, !tbaa !11
  %2175 = fcmp oge double %2174, 0.000000e+00
  br i1 %2175, label %2176, label %2178

2176:                                             ; preds = %2165
  %2177 = load double, ptr %52, align 8, !tbaa !11
  br label %2181

2178:                                             ; preds = %2165
  %2179 = load double, ptr %52, align 8, !tbaa !11
  %2180 = fneg double %2179
  br label %2181

2181:                                             ; preds = %2178, %2176
  %2182 = phi double [ %2177, %2176 ], [ %2180, %2178 ]
  %2183 = fadd double %2166, %2182
  %2184 = load ptr, ptr %26, align 8, !tbaa !5
  %2185 = load i32, ptr %42, align 4, !tbaa !9
  %2186 = sext i32 %2185 to i64
  %2187 = getelementptr inbounds %struct.doublecomplex, ptr %2184, i64 %2186
  %2188 = getelementptr inbounds %struct.doublecomplex, ptr %2187, i32 0, i32 0
  %2189 = load double, ptr %2188, align 8, !tbaa !15
  store double %2189, ptr %53, align 8, !tbaa !11
  %2190 = load double, ptr %53, align 8, !tbaa !11
  %2191 = fcmp oge double %2190, 0.000000e+00
  br i1 %2191, label %2192, label %2194

2192:                                             ; preds = %2181
  %2193 = load double, ptr %53, align 8, !tbaa !11
  br label %2197

2194:                                             ; preds = %2181
  %2195 = load double, ptr %53, align 8, !tbaa !11
  %2196 = fneg double %2195
  br label %2197

2197:                                             ; preds = %2194, %2192
  %2198 = phi double [ %2193, %2192 ], [ %2196, %2194 ]
  %2199 = load ptr, ptr %26, align 8, !tbaa !5
  %2200 = load i32, ptr %60, align 4, !tbaa !9
  %2201 = add nsw i32 %2200, 1
  %2202 = load i32, ptr %61, align 4, !tbaa !9
  %2203 = load i32, ptr %35, align 4, !tbaa !9
  %2204 = mul nsw i32 %2202, %2203
  %2205 = add nsw i32 %2201, %2204
  %2206 = sext i32 %2205 to i64
  %2207 = getelementptr inbounds %struct.doublecomplex, ptr %2199, i64 %2206
  %2208 = call { double, double } @Cd(ptr noundef %2207)
  %2209 = extractvalue { double, double } %2208, 0
  %2210 = extractvalue { double, double } %2208, 1
  store double %2210, ptr %54, align 8, !tbaa !11
  %2211 = load double, ptr %54, align 8, !tbaa !11
  %2212 = fcmp oge double %2211, 0.000000e+00
  br i1 %2212, label %2213, label %2215

2213:                                             ; preds = %2197
  %2214 = load double, ptr %54, align 8, !tbaa !11
  br label %2218

2215:                                             ; preds = %2197
  %2216 = load double, ptr %54, align 8, !tbaa !11
  %2217 = fneg double %2216
  br label %2218

2218:                                             ; preds = %2215, %2213
  %2219 = phi double [ %2214, %2213 ], [ %2217, %2215 ]
  %2220 = fadd double %2198, %2219
  %2221 = call double @llvm.fmuladd.f64(double %2183, double %2220, double %2151)
  %2222 = load ptr, ptr %31, align 8, !tbaa !5
  %2223 = load i32, ptr %60, align 4, !tbaa !9
  %2224 = sext i32 %2223 to i64
  %2225 = getelementptr inbounds double, ptr %2222, i64 %2224
  store double %2221, ptr %2225, align 8, !tbaa !11
  br label %2226

2226:                                             ; preds = %2218
  %2227 = load i32, ptr %60, align 4, !tbaa !9
  %2228 = add nsw i32 %2227, 1
  store i32 %2228, ptr %60, align 4, !tbaa !9
  br label %1773, !llvm.loop !19

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

2415:                                             ; preds = %2229
  %2416 = load double, ptr %43, align 8, !tbaa !11
  br label %2420

2417:                                             ; preds = %2229
  %2418 = load double, ptr %43, align 8, !tbaa !11
  %2419 = fneg double %2418
  br label %2420

2420:                                             ; preds = %2417, %2415
  %2421 = phi double [ %2416, %2415 ], [ %2419, %2417 ]
  %2422 = call { double, double } @Cd(ptr noundef %65)
  %2423 = extractvalue { double, double } %2422, 0
  %2424 = extractvalue { double, double } %2422, 1
  store double %2424, ptr %44, align 8, !tbaa !11
  %2425 = load double, ptr %44, align 8, !tbaa !11
  %2426 = fcmp oge double %2425, 0.000000e+00
  br i1 %2426, label %2427, label %2429

2427:                                             ; preds = %2420
  %2428 = load double, ptr %44, align 8, !tbaa !11
  br label %2432

2429:                                             ; preds = %2420
  %2430 = load double, ptr %44, align 8, !tbaa !11
  %2431 = fneg double %2430
  br label %2432

2432:                                             ; preds = %2429, %2427
  %2433 = phi double [ %2428, %2427 ], [ %2431, %2429 ]
  %2434 = fadd double %2421, %2433
  %2435 = load ptr, ptr %21, align 8, !tbaa !5
  %2436 = load i32, ptr %38, align 4, !tbaa !9
  %2437 = sext i32 %2436 to i64
  %2438 = getelementptr inbounds %struct.doublecomplex, ptr %2435, i64 %2437
  %2439 = getelementptr inbounds %struct.doublecomplex, ptr %2438, i32 0, i32 0
  %2440 = load double, ptr %2439, align 8, !tbaa !15
  store double %2440, ptr %45, align 8, !tbaa !11
  %2441 = load double, ptr %45, align 8, !tbaa !11
  %2442 = fcmp oge double %2441, 0.000000e+00
  br i1 %2442, label %2443, label %2445

2443:                                             ; preds = %2432
  %2444 = load double, ptr %45, align 8, !tbaa !11
  br label %2448

2445:                                             ; preds = %2432
  %2446 = load double, ptr %45, align 8, !tbaa !11
  %2447 = fneg double %2446
  br label %2448

2448:                                             ; preds = %2445, %2443
  %2449 = phi double [ %2444, %2443 ], [ %2447, %2445 ]
  %2450 = load ptr, ptr %21, align 8, !tbaa !5
  %2451 = load ptr, ptr %18, align 8, !tbaa !5
  %2452 = load i32, ptr %2451, align 4, !tbaa !9
  %2453 = sub nsw i32 %2452, 1
  %2454 = sext i32 %2453 to i64
  %2455 = getelementptr inbounds %struct.doublecomplex, ptr %2450, i64 %2454
  %2456 = call { double, double } @Cd(ptr noundef %2455)
  %2457 = extractvalue { double, double } %2456, 0
  %2458 = extractvalue { double, double } %2456, 1
  store double %2458, ptr %46, align 8, !tbaa !11
  %2459 = load double, ptr %46, align 8, !tbaa !11
  %2460 = fcmp oge double %2459, 0.000000e+00
  br i1 %2460, label %2461, label %2463

2461:                                             ; preds = %2448
  %2462 = load double, ptr %46, align 8, !tbaa !11
  br label %2466

2463:                                             ; preds = %2448
  %2464 = load double, ptr %46, align 8, !tbaa !11
  %2465 = fneg double %2464
  br label %2466

2466:                                             ; preds = %2463, %2461
  %2467 = phi double [ %2462, %2461 ], [ %2465, %2463 ]
  %2468 = fadd double %2449, %2467
  %2469 = load ptr, ptr %26, align 8, !tbaa !5
  %2470 = load i32, ptr %39, align 4, !tbaa !9
  %2471 = sext i32 %2470 to i64
  %2472 = getelementptr inbounds %struct.doublecomplex, ptr %2469, i64 %2471
  %2473 = getelementptr inbounds %struct.doublecomplex, ptr %2472, i32 0, i32 0
  %2474 = load double, ptr %2473, align 8, !tbaa !15
  store double %2474, ptr %47, align 8, !tbaa !11
  %2475 = load double, ptr %47, align 8, !tbaa !11
  %2476 = fcmp oge double %2475, 0.000000e+00
  br i1 %2476, label %2477, label %2479

2477:                                             ; preds = %2466
  %2478 = load double, ptr %47, align 8, !tbaa !11
  br label %2482

2479:                                             ; preds = %2466
  %2480 = load double, ptr %47, align 8, !tbaa !11
  %2481 = fneg double %2480
  br label %2482

2482:                                             ; preds = %2479, %2477
  %2483 = phi double [ %2478, %2477 ], [ %2481, %2479 ]
  %2484 = load ptr, ptr %26, align 8, !tbaa !5
  %2485 = load ptr, ptr %18, align 8, !tbaa !5
  %2486 = load i32, ptr %2485, align 4, !tbaa !9
  %2487 = sub nsw i32 %2486, 1
  %2488 = load i32, ptr %61, align 4, !tbaa !9
  %2489 = load i32, ptr %35, align 4, !tbaa !9
  %2490 = mul nsw i32 %2488, %2489
  %2491 = add nsw i32 %2487, %2490
  %2492 = sext i32 %2491 to i64
  %2493 = getelementptr inbounds %struct.doublecomplex, ptr %2484, i64 %2492
  %2494 = call { double, double } @Cd(ptr noundef %2493)
  %2495 = extractvalue { double, double } %2494, 0
  %2496 = extractvalue { double, double } %2494, 1
  store double %2496, ptr %48, align 8, !tbaa !11
  %2497 = load double, ptr %48, align 8, !tbaa !11
  %2498 = fcmp oge double %2497, 0.000000e+00
  br i1 %2498, label %2499, label %2501

2499:                                             ; preds = %2482
  %2500 = load double, ptr %48, align 8, !tbaa !11
  br label %2504

2501:                                             ; preds = %2482
  %2502 = load double, ptr %48, align 8, !tbaa !11
  %2503 = fneg double %2502
  br label %2504

2504:                                             ; preds = %2501, %2499
  %2505 = phi double [ %2500, %2499 ], [ %2503, %2501 ]
  %2506 = fadd double %2483, %2505
  %2507 = call double @llvm.fmuladd.f64(double %2468, double %2506, double %2434)
  %2508 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %2509 = load double, ptr %2508, align 8, !tbaa !15
  store double %2509, ptr %49, align 8, !tbaa !11
  %2510 = load double, ptr %49, align 8, !tbaa !11
  %2511 = fcmp oge double %2510, 0.000000e+00
  br i1 %2511, label %2512, label %2514

2512:                                             ; preds = %2504
  %2513 = load double, ptr %49, align 8, !tbaa !11
  br label %2517

2514:                                             ; preds = %2504
  %2515 = load double, ptr %49, align 8, !tbaa !11
  %2516 = fneg double %2515
  br label %2517

2517:                                             ; preds = %2514, %2512
  %2518 = phi double [ %2513, %2512 ], [ %2516, %2514 ]
  %2519 = call { double, double } @Cd(ptr noundef %67)
  %2520 = extractvalue { double, double } %2519, 0
  %2521 = extractvalue { double, double } %2519, 1
  store double %2521, ptr %50, align 8, !tbaa !11
  %2522 = load double, ptr %50, align 8, !tbaa !11
  %2523 = fcmp oge double %2522, 0.000000e+00
  br i1 %2523, label %2524, label %2526

2524:                                             ; preds = %2517
  %2525 = load double, ptr %50, align 8, !tbaa !11
  br label %2529

2526:                                             ; preds = %2517
  %2527 = load double, ptr %50, align 8, !tbaa !11
  %2528 = fneg double %2527
  br label %2529

2529:                                             ; preds = %2526, %2524
  %2530 = phi double [ %2525, %2524 ], [ %2528, %2526 ]
  %2531 = fadd double %2518, %2530
  %2532 = fadd double %2507, %2531
  %2533 = load ptr, ptr %31, align 8, !tbaa !5
  %2534 = load ptr, ptr %18, align 8, !tbaa !5
  %2535 = load i32, ptr %2534, align 4, !tbaa !9
  %2536 = sext i32 %2535 to i64
  %2537 = getelementptr inbounds double, ptr %2533, i64 %2536
  store double %2532, ptr %2537, align 8, !tbaa !11
  br label %2538

2538:                                             ; preds = %2529, %1502
  br label %2539

2539:                                             ; preds = %2538, %1379
  store double 0.000000e+00, ptr %62, align 8, !tbaa !11
  %2540 = load ptr, ptr %18, align 8, !tbaa !5
  %2541 = load i32, ptr %2540, align 4, !tbaa !9
  store i32 %2541, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %2542

2542:                                             ; preds = %2659, %2539
  %2543 = load i32, ptr %60, align 4, !tbaa !9
  %2544 = load i32, ptr %38, align 4, !tbaa !9
  %2545 = icmp sle i32 %2543, %2544
  br i1 %2545, label %2546, label %2662

2546:                                             ; preds = %2542
  %2547 = load ptr, ptr %31, align 8, !tbaa !5
  %2548 = load i32, ptr %60, align 4, !tbaa !9
  %2549 = sext i32 %2548 to i64
  %2550 = getelementptr inbounds double, ptr %2547, i64 %2549
  %2551 = load double, ptr %2550, align 8, !tbaa !11
  %2552 = load double, ptr %59, align 8, !tbaa !11
  %2553 = fcmp ogt double %2551, %2552
  br i1 %2553, label %2554, label %2604

2554:                                             ; preds = %2546
  %2555 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2555, ptr %39, align 4, !tbaa !9
  %2556 = load double, ptr %62, align 8, !tbaa !11
  store double %2556, ptr %45, align 8, !tbaa !11
  %2557 = load ptr, ptr %30, align 8, !tbaa !5
  %2558 = load i32, ptr %39, align 4, !tbaa !9
  %2559 = sext i32 %2558 to i64
  %2560 = getelementptr inbounds %struct.doublecomplex, ptr %2557, i64 %2559
  %2561 = getelementptr inbounds %struct.doublecomplex, ptr %2560, i32 0, i32 0
  %2562 = load double, ptr %2561, align 8, !tbaa !15
  store double %2562, ptr %43, align 8, !tbaa !11
  %2563 = load double, ptr %43, align 8, !tbaa !11
  %2564 = fcmp oge double %2563, 0.000000e+00
  br i1 %2564, label %2565, label %2567

2565:                                             ; preds = %2554
  %2566 = load double, ptr %43, align 8, !tbaa !11
  br label %2570

2567:                                             ; preds = %2554
  %2568 = load double, ptr %43, align 8, !tbaa !11
  %2569 = fneg double %2568
  br label %2570

2570:                                             ; preds = %2567, %2565
  %2571 = phi double [ %2566, %2565 ], [ %2569, %2567 ]
  %2572 = load ptr, ptr %30, align 8, !tbaa !5
  %2573 = load i32, ptr %60, align 4, !tbaa !9
  %2574 = sext i32 %2573 to i64
  %2575 = getelementptr inbounds %struct.doublecomplex, ptr %2572, i64 %2574
  %2576 = call { double, double } @Cd(ptr noundef %2575)
  %2577 = extractvalue { double, double } %2576, 0
  %2578 = extractvalue { double, double } %2576, 1
  store double %2578, ptr %44, align 8, !tbaa !11
  %2579 = load double, ptr %44, align 8, !tbaa !11
  %2580 = fcmp oge double %2579, 0.000000e+00
  br i1 %2580, label %2581, label %2583

2581:                                             ; preds = %2570
  %2582 = load double, ptr %44, align 8, !tbaa !11
  br label %2586

2583:                                             ; preds = %2570
  %2584 = load double, ptr %44, align 8, !tbaa !11
  %2585 = fneg double %2584
  br label %2586

2586:                                             ; preds = %2583, %2581
  %2587 = phi double [ %2582, %2581 ], [ %2585, %2583 ]
  %2588 = fadd double %2571, %2587
  %2589 = load ptr, ptr %31, align 8, !tbaa !5
  %2590 = load i32, ptr %60, align 4, !tbaa !9
  %2591 = sext i32 %2590 to i64
  %2592 = getelementptr inbounds double, ptr %2589, i64 %2591
  %2593 = load double, ptr %2592, align 8, !tbaa !11
  %2594 = fdiv double %2588, %2593
  store double %2594, ptr %46, align 8, !tbaa !11
  %2595 = load double, ptr %45, align 8, !tbaa !11
  %2596 = load double, ptr %46, align 8, !tbaa !11
  %2597 = fcmp oge double %2595, %2596
  br i1 %2597, label %2598, label %2600

2598:                                             ; preds = %2586
  %2599 = load double, ptr %45, align 8, !tbaa !11
  br label %2602

2600:                                             ; preds = %2586
  %2601 = load double, ptr %46, align 8, !tbaa !11
  br label %2602

2602:                                             ; preds = %2600, %2598
  %2603 = phi double [ %2599, %2598 ], [ %2601, %2600 ]
  store double %2603, ptr %62, align 8, !tbaa !11
  br label %2658

2604:                                             ; preds = %2546
  %2605 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2605, ptr %39, align 4, !tbaa !9
  %2606 = load double, ptr %62, align 8, !tbaa !11
  store double %2606, ptr %45, align 8, !tbaa !11
  %2607 = load ptr, ptr %30, align 8, !tbaa !5
  %2608 = load i32, ptr %39, align 4, !tbaa !9
  %2609 = sext i32 %2608 to i64
  %2610 = getelementptr inbounds %struct.doublecomplex, ptr %2607, i64 %2609
  %2611 = getelementptr inbounds %struct.doublecomplex, ptr %2610, i32 0, i32 0
  %2612 = load double, ptr %2611, align 8, !tbaa !15
  store double %2612, ptr %43, align 8, !tbaa !11
  %2613 = load double, ptr %43, align 8, !tbaa !11
  %2614 = fcmp oge double %2613, 0.000000e+00
  br i1 %2614, label %2615, label %2617

2615:                                             ; preds = %2604
  %2616 = load double, ptr %43, align 8, !tbaa !11
  br label %2620

2617:                                             ; preds = %2604
  %2618 = load double, ptr %43, align 8, !tbaa !11
  %2619 = fneg double %2618
  br label %2620

2620:                                             ; preds = %2617, %2615
  %2621 = phi double [ %2616, %2615 ], [ %2619, %2617 ]
  %2622 = load ptr, ptr %30, align 8, !tbaa !5
  %2623 = load i32, ptr %60, align 4, !tbaa !9
  %2624 = sext i32 %2623 to i64
  %2625 = getelementptr inbounds %struct.doublecomplex, ptr %2622, i64 %2624
  %2626 = call { double, double } @Cd(ptr noundef %2625)
  %2627 = extractvalue { double, double } %2626, 0
  %2628 = extractvalue { double, double } %2626, 1
  store double %2628, ptr %44, align 8, !tbaa !11
  %2629 = load double, ptr %44, align 8, !tbaa !11
  %2630 = fcmp oge double %2629, 0.000000e+00
  br i1 %2630, label %2631, label %2633

2631:                                             ; preds = %2620
  %2632 = load double, ptr %44, align 8, !tbaa !11
  br label %2636

2633:                                             ; preds = %2620
  %2634 = load double, ptr %44, align 8, !tbaa !11
  %2635 = fneg double %2634
  br label %2636

2636:                                             ; preds = %2633, %2631
  %2637 = phi double [ %2632, %2631 ], [ %2635, %2633 ]
  %2638 = fadd double %2621, %2637
  %2639 = load double, ptr %58, align 8, !tbaa !11
  %2640 = fadd double %2638, %2639
  %2641 = load ptr, ptr %31, align 8, !tbaa !5
  %2642 = load i32, ptr %60, align 4, !tbaa !9
  %2643 = sext i32 %2642 to i64
  %2644 = getelementptr inbounds double, ptr %2641, i64 %2643
  %2645 = load double, ptr %2644, align 8, !tbaa !11
  %2646 = load double, ptr %58, align 8, !tbaa !11
  %2647 = fadd double %2645, %2646
  %2648 = fdiv double %2640, %2647
  store double %2648, ptr %46, align 8, !tbaa !11
  %2649 = load double, ptr %45, align 8, !tbaa !11
  %2650 = load double, ptr %46, align 8, !tbaa !11
  %2651 = fcmp oge double %2649, %2650
  br i1 %2651, label %2652, label %2654

2652:                                             ; preds = %2636
  %2653 = load double, ptr %45, align 8, !tbaa !11
  br label %2656

2654:                                             ; preds = %2636
  %2655 = load double, ptr %46, align 8, !tbaa !11
  br label %2656

2656:                                             ; preds = %2654, %2652
  %2657 = phi double [ %2653, %2652 ], [ %2655, %2654 ]
  store double %2657, ptr %62, align 8, !tbaa !11
  br label %2658

2658:                                             ; preds = %2656, %2602
  br label %2659

2659:                                             ; preds = %2658
  %2660 = load i32, ptr %60, align 4, !tbaa !9
  %2661 = add nsw i32 %2660, 1
  store i32 %2661, ptr %60, align 4, !tbaa !9
  br label %2542, !llvm.loop !20

2662:                                             ; preds = %2542
  %2663 = load double, ptr %62, align 8, !tbaa !11
  %2664 = load ptr, ptr %29, align 8, !tbaa !5
  %2665 = load i32, ptr %61, align 4, !tbaa !9
  %2666 = sext i32 %2665 to i64
  %2667 = getelementptr inbounds double, ptr %2664, i64 %2666
  store double %2663, ptr %2667, align 8, !tbaa !11
  %2668 = load ptr, ptr %29, align 8, !tbaa !5
  %2669 = load i32, ptr %61, align 4, !tbaa !9
  %2670 = sext i32 %2669 to i64
  %2671 = getelementptr inbounds double, ptr %2668, i64 %2670
  %2672 = load double, ptr %2671, align 8, !tbaa !11
  %2673 = load double, ptr %73, align 8, !tbaa !11
  %2674 = fcmp ogt double %2672, %2673
  br i1 %2674, label %2675, label %2715

2675:                                             ; preds = %2662
  %2676 = load ptr, ptr %29, align 8, !tbaa !5
  %2677 = load i32, ptr %61, align 4, !tbaa !9
  %2678 = sext i32 %2677 to i64
  %2679 = getelementptr inbounds double, ptr %2676, i64 %2678
  %2680 = load double, ptr %2679, align 8, !tbaa !11
  %2681 = fmul double %2680, 2.000000e+00
  %2682 = load double, ptr %72, align 8, !tbaa !11
  %2683 = fcmp ole double %2681, %2682
  br i1 %2683, label %2684, label %2715

2684:                                             ; preds = %2675
  %2685 = load i32, ptr %63, align 4, !tbaa !9
  %2686 = icmp sle i32 %2685, 5
  br i1 %2686, label %2687, label %2715

2687:                                             ; preds = %2684
  %2688 = load ptr, ptr %17, align 8, !tbaa !5
  %2689 = load ptr, ptr %18, align 8, !tbaa !5
  %2690 = load ptr, ptr %22, align 8, !tbaa !5
  %2691 = getelementptr inbounds double, ptr %2690, i64 1
  %2692 = load ptr, ptr %23, align 8, !tbaa !5
  %2693 = getelementptr inbounds %struct.doublecomplex, ptr %2692, i64 1
  %2694 = load ptr, ptr %30, align 8, !tbaa !5
  %2695 = getelementptr inbounds %struct.doublecomplex, ptr %2694, i64 1
  %2696 = load ptr, ptr %18, align 8, !tbaa !5
  %2697 = load ptr, ptr %32, align 8, !tbaa !5
  call void @zpttrs_(ptr noundef %2688, ptr noundef %2689, ptr noundef @c__1, ptr noundef %2691, ptr noundef %2693, ptr noundef %2695, ptr noundef %2696, ptr noundef %2697)
  %2698 = load ptr, ptr %18, align 8, !tbaa !5
  %2699 = load ptr, ptr %30, align 8, !tbaa !5
  %2700 = getelementptr inbounds %struct.doublecomplex, ptr %2699, i64 1
  %2701 = load ptr, ptr %26, align 8, !tbaa !5
  %2702 = load i32, ptr %61, align 4, !tbaa !9
  %2703 = load i32, ptr %35, align 4, !tbaa !9
  %2704 = mul nsw i32 %2702, %2703
  %2705 = add nsw i32 %2704, 1
  %2706 = sext i32 %2705 to i64
  %2707 = getelementptr inbounds %struct.doublecomplex, ptr %2701, i64 %2706
  call void @zaxpy_(ptr noundef %2698, ptr noundef @c_b16, ptr noundef %2700, ptr noundef @c__1, ptr noundef %2707, ptr noundef @c__1)
  %2708 = load ptr, ptr %29, align 8, !tbaa !5
  %2709 = load i32, ptr %61, align 4, !tbaa !9
  %2710 = sext i32 %2709 to i64
  %2711 = getelementptr inbounds double, ptr %2708, i64 %2710
  %2712 = load double, ptr %2711, align 8, !tbaa !11
  store double %2712, ptr %72, align 8, !tbaa !11
  %2713 = load i32, ptr %63, align 4, !tbaa !9
  %2714 = add nsw i32 %2713, 1
  store i32 %2714, ptr %63, align 4, !tbaa !9
  br label %225

2715:                                             ; preds = %2684, %2675, %2662
  %2716 = load ptr, ptr %18, align 8, !tbaa !5
  %2717 = load i32, ptr %2716, align 4, !tbaa !9
  store i32 %2717, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %2718

2718:                                             ; preds = %2829, %2715
  %2719 = load i32, ptr %60, align 4, !tbaa !9
  %2720 = load i32, ptr %38, align 4, !tbaa !9
  %2721 = icmp sle i32 %2719, %2720
  br i1 %2721, label %2722, label %2832

2722:                                             ; preds = %2718
  %2723 = load ptr, ptr %31, align 8, !tbaa !5
  %2724 = load i32, ptr %60, align 4, !tbaa !9
  %2725 = sext i32 %2724 to i64
  %2726 = getelementptr inbounds double, ptr %2723, i64 %2725
  %2727 = load double, ptr %2726, align 8, !tbaa !11
  %2728 = load double, ptr %59, align 8, !tbaa !11
  %2729 = fcmp ogt double %2727, %2728
  br i1 %2729, label %2730, label %2778

2730:                                             ; preds = %2722
  %2731 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2731, ptr %39, align 4, !tbaa !9
  %2732 = load ptr, ptr %30, align 8, !tbaa !5
  %2733 = load i32, ptr %39, align 4, !tbaa !9
  %2734 = sext i32 %2733 to i64
  %2735 = getelementptr inbounds %struct.doublecomplex, ptr %2732, i64 %2734
  %2736 = getelementptr inbounds %struct.doublecomplex, ptr %2735, i32 0, i32 0
  %2737 = load double, ptr %2736, align 8, !tbaa !15
  store double %2737, ptr %43, align 8, !tbaa !11
  %2738 = load double, ptr %43, align 8, !tbaa !11
  %2739 = fcmp oge double %2738, 0.000000e+00
  br i1 %2739, label %2740, label %2742

2740:                                             ; preds = %2730
  %2741 = load double, ptr %43, align 8, !tbaa !11
  br label %2745

2742:                                             ; preds = %2730
  %2743 = load double, ptr %43, align 8, !tbaa !11
  %2744 = fneg double %2743
  br label %2745

2745:                                             ; preds = %2742, %2740
  %2746 = phi double [ %2741, %2740 ], [ %2744, %2742 ]
  %2747 = load ptr, ptr %30, align 8, !tbaa !5
  %2748 = load i32, ptr %60, align 4, !tbaa !9
  %2749 = sext i32 %2748 to i64
  %2750 = getelementptr inbounds %struct.doublecomplex, ptr %2747, i64 %2749
  %2751 = call { double, double } @Cd(ptr noundef %2750)
  %2752 = extractvalue { double, double } %2751, 0
  %2753 = extractvalue { double, double } %2751, 1
  store double %2753, ptr %44, align 8, !tbaa !11
  %2754 = load double, ptr %44, align 8, !tbaa !11
  %2755 = fcmp oge double %2754, 0.000000e+00
  br i1 %2755, label %2756, label %2758

2756:                                             ; preds = %2745
  %2757 = load double, ptr %44, align 8, !tbaa !11
  br label %2761

2758:                                             ; preds = %2745
  %2759 = load double, ptr %44, align 8, !tbaa !11
  %2760 = fneg double %2759
  br label %2761

2761:                                             ; preds = %2758, %2756
  %2762 = phi double [ %2757, %2756 ], [ %2760, %2758 ]
  %2763 = fadd double %2746, %2762
  %2764 = load i32, ptr %70, align 4, !tbaa !9
  %2765 = sitofp i32 %2764 to double
  %2766 = load double, ptr %73, align 8, !tbaa !11
  %2767 = fmul double %2765, %2766
  %2768 = load ptr, ptr %31, align 8, !tbaa !5
  %2769 = load i32, ptr %60, align 4, !tbaa !9
  %2770 = sext i32 %2769 to i64
  %2771 = getelementptr inbounds double, ptr %2768, i64 %2770
  %2772 = load double, ptr %2771, align 8, !tbaa !11
  %2773 = call double @llvm.fmuladd.f64(double %2767, double %2772, double %2763)
  %2774 = load ptr, ptr %31, align 8, !tbaa !5
  %2775 = load i32, ptr %60, align 4, !tbaa !9
  %2776 = sext i32 %2775 to i64
  %2777 = getelementptr inbounds double, ptr %2774, i64 %2776
  store double %2773, ptr %2777, align 8, !tbaa !11
  br label %2828

2778:                                             ; preds = %2722
  %2779 = load i32, ptr %60, align 4, !tbaa !9
  store i32 %2779, ptr %39, align 4, !tbaa !9
  %2780 = load ptr, ptr %30, align 8, !tbaa !5
  %2781 = load i32, ptr %39, align 4, !tbaa !9
  %2782 = sext i32 %2781 to i64
  %2783 = getelementptr inbounds %struct.doublecomplex, ptr %2780, i64 %2782
  %2784 = getelementptr inbounds %struct.doublecomplex, ptr %2783, i32 0, i32 0
  %2785 = load double, ptr %2784, align 8, !tbaa !15
  store double %2785, ptr %43, align 8, !tbaa !11
  %2786 = load double, ptr %43, align 8, !tbaa !11
  %2787 = fcmp oge double %2786, 0.000000e+00
  br i1 %2787, label %2788, label %2790

2788:                                             ; preds = %2778
  %2789 = load double, ptr %43, align 8, !tbaa !11
  br label %2793

2790:                                             ; preds = %2778
  %2791 = load double, ptr %43, align 8, !tbaa !11
  %2792 = fneg double %2791
  br label %2793

2793:                                             ; preds = %2790, %2788
  %2794 = phi double [ %2789, %2788 ], [ %2792, %2790 ]
  %2795 = load ptr, ptr %30, align 8, !tbaa !5
  %2796 = load i32, ptr %60, align 4, !tbaa !9
  %2797 = sext i32 %2796 to i64
  %2798 = getelementptr inbounds %struct.doublecomplex, ptr %2795, i64 %2797
  %2799 = call { double, double } @Cd(ptr noundef %2798)
  %2800 = extractvalue { double, double } %2799, 0
  %2801 = extractvalue { double, double } %2799, 1
  store double %2801, ptr %44, align 8, !tbaa !11
  %2802 = load double, ptr %44, align 8, !tbaa !11
  %2803 = fcmp oge double %2802, 0.000000e+00
  br i1 %2803, label %2804, label %2806

2804:                                             ; preds = %2793
  %2805 = load double, ptr %44, align 8, !tbaa !11
  br label %2809

2806:                                             ; preds = %2793
  %2807 = load double, ptr %44, align 8, !tbaa !11
  %2808 = fneg double %2807
  br label %2809

2809:                                             ; preds = %2806, %2804
  %2810 = phi double [ %2805, %2804 ], [ %2808, %2806 ]
  %2811 = fadd double %2794, %2810
  %2812 = load i32, ptr %70, align 4, !tbaa !9
  %2813 = sitofp i32 %2812 to double
  %2814 = load double, ptr %73, align 8, !tbaa !11
  %2815 = fmul double %2813, %2814
  %2816 = load ptr, ptr %31, align 8, !tbaa !5
  %2817 = load i32, ptr %60, align 4, !tbaa !9
  %2818 = sext i32 %2817 to i64
  %2819 = getelementptr inbounds double, ptr %2816, i64 %2818
  %2820 = load double, ptr %2819, align 8, !tbaa !11
  %2821 = call double @llvm.fmuladd.f64(double %2815, double %2820, double %2811)
  %2822 = load double, ptr %58, align 8, !tbaa !11
  %2823 = fadd double %2821, %2822
  %2824 = load ptr, ptr %31, align 8, !tbaa !5
  %2825 = load i32, ptr %60, align 4, !tbaa !9
  %2826 = sext i32 %2825 to i64
  %2827 = getelementptr inbounds double, ptr %2824, i64 %2826
  store double %2823, ptr %2827, align 8, !tbaa !11
  br label %2828

2828:                                             ; preds = %2809, %2761
  br label %2829

2829:                                             ; preds = %2828
  %2830 = load i32, ptr %60, align 4, !tbaa !9
  %2831 = add nsw i32 %2830, 1
  store i32 %2831, ptr %60, align 4, !tbaa !9
  br label %2718, !llvm.loop !21

2832:                                             ; preds = %2718
  %2833 = load ptr, ptr %18, align 8, !tbaa !5
  %2834 = load ptr, ptr %31, align 8, !tbaa !5
  %2835 = getelementptr inbounds double, ptr %2834, i64 1
  %2836 = call i32 @idamax_(ptr noundef %2833, ptr noundef %2835, ptr noundef @c__1)
  store i32 %2836, ptr %69, align 4, !tbaa !9
  %2837 = load ptr, ptr %31, align 8, !tbaa !5
  %2838 = load i32, ptr %69, align 4, !tbaa !9
  %2839 = sext i32 %2838 to i64
  %2840 = getelementptr inbounds double, ptr %2837, i64 %2839
  %2841 = load double, ptr %2840, align 8, !tbaa !11
  %2842 = load ptr, ptr %28, align 8, !tbaa !5
  %2843 = load i32, ptr %61, align 4, !tbaa !9
  %2844 = sext i32 %2843 to i64
  %2845 = getelementptr inbounds double, ptr %2842, i64 %2844
  store double %2841, ptr %2845, align 8, !tbaa !11
  %2846 = load ptr, ptr %31, align 8, !tbaa !5
  %2847 = getelementptr inbounds double, ptr %2846, i64 1
  store double 1.000000e+00, ptr %2847, align 8, !tbaa !11
  %2848 = load ptr, ptr %18, align 8, !tbaa !5
  %2849 = load i32, ptr %2848, align 4, !tbaa !9
  store i32 %2849, ptr %38, align 4, !tbaa !9
  store i32 2, ptr %60, align 4, !tbaa !9
  br label %2850

2850:                                             ; preds = %2881, %2832
  %2851 = load i32, ptr %60, align 4, !tbaa !9
  %2852 = load i32, ptr %38, align 4, !tbaa !9
  %2853 = icmp sle i32 %2851, %2852
  br i1 %2853, label %2854, label %2884

2854:                                             ; preds = %2850
  %2855 = load ptr, ptr %31, align 8, !tbaa !5
  %2856 = load i32, ptr %60, align 4, !tbaa !9
  %2857 = sub nsw i32 %2856, 1
  %2858 = sext i32 %2857 to i64
  %2859 = getelementptr inbounds double, ptr %2855, i64 %2858
  %2860 = load double, ptr %2859, align 8, !tbaa !11
  %2861 = load ptr, ptr %23, align 8, !tbaa !5
  %2862 = load i32, ptr %60, align 4, !tbaa !9
  %2863 = sub nsw i32 %2862, 1
  %2864 = sext i32 %2863 to i64
  %2865 = getelementptr inbounds %struct.doublecomplex, ptr %2861, i64 %2864
  %2866 = call { double, double } @Cd(ptr noundef %2865)
  %2867 = extractvalue { double, double } %2866, 0
  %2868 = extractvalue { double, double } %2866, 1
  %2869 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 0
  %2870 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 1
  store double %2867, ptr %2869, align 8
  store double %2868, ptr %2870, align 8
  %2871 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 0
  %2872 = load double, ptr %2871, align 8
  %2873 = getelementptr inbounds { double, double }, ptr %75, i32 0, i32 1
  %2874 = load double, ptr %2873, align 8
  %2875 = call double @cabs(double noundef %2872, double noundef %2874) #6
  %2876 = call double @llvm.fmuladd.f64(double %2860, double %2875, double 1.000000e+00)
  %2877 = load ptr, ptr %31, align 8, !tbaa !5
  %2878 = load i32, ptr %60, align 4, !tbaa !9
  %2879 = sext i32 %2878 to i64
  %2880 = getelementptr inbounds double, ptr %2877, i64 %2879
  store double %2876, ptr %2880, align 8, !tbaa !11
  br label %2881

2881:                                             ; preds = %2854
  %2882 = load i32, ptr %60, align 4, !tbaa !9
  %2883 = add nsw i32 %2882, 1
  store i32 %2883, ptr %60, align 4, !tbaa !9
  br label %2850, !llvm.loop !22

2884:                                             ; preds = %2850
  %2885 = load ptr, ptr %22, align 8, !tbaa !5
  %2886 = load ptr, ptr %18, align 8, !tbaa !5
  %2887 = load i32, ptr %2886, align 4, !tbaa !9
  %2888 = sext i32 %2887 to i64
  %2889 = getelementptr inbounds double, ptr %2885, i64 %2888
  %2890 = load double, ptr %2889, align 8, !tbaa !11
  %2891 = load ptr, ptr %31, align 8, !tbaa !5
  %2892 = load ptr, ptr %18, align 8, !tbaa !5
  %2893 = load i32, ptr %2892, align 4, !tbaa !9
  %2894 = sext i32 %2893 to i64
  %2895 = getelementptr inbounds double, ptr %2891, i64 %2894
  %2896 = load double, ptr %2895, align 8, !tbaa !11
  %2897 = fdiv double %2896, %2890
  store double %2897, ptr %2895, align 8, !tbaa !11
  %2898 = load ptr, ptr %18, align 8, !tbaa !5
  %2899 = load i32, ptr %2898, align 4, !tbaa !9
  %2900 = sub nsw i32 %2899, 1
  store i32 %2900, ptr %60, align 4, !tbaa !9
  br label %2901

2901:                                             ; preds = %2941, %2884
  %2902 = load i32, ptr %60, align 4, !tbaa !9
  %2903 = icmp sge i32 %2902, 1
  br i1 %2903, label %2904, label %2944

2904:                                             ; preds = %2901
  %2905 = load ptr, ptr %31, align 8, !tbaa !5
  %2906 = load i32, ptr %60, align 4, !tbaa !9
  %2907 = sext i32 %2906 to i64
  %2908 = getelementptr inbounds double, ptr %2905, i64 %2907
  %2909 = load double, ptr %2908, align 8, !tbaa !11
  %2910 = load ptr, ptr %22, align 8, !tbaa !5
  %2911 = load i32, ptr %60, align 4, !tbaa !9
  %2912 = sext i32 %2911 to i64
  %2913 = getelementptr inbounds double, ptr %2910, i64 %2912
  %2914 = load double, ptr %2913, align 8, !tbaa !11
  %2915 = fdiv double %2909, %2914
  %2916 = load ptr, ptr %31, align 8, !tbaa !5
  %2917 = load i32, ptr %60, align 4, !tbaa !9
  %2918 = add nsw i32 %2917, 1
  %2919 = sext i32 %2918 to i64
  %2920 = getelementptr inbounds double, ptr %2916, i64 %2919
  %2921 = load double, ptr %2920, align 8, !tbaa !11
  %2922 = load ptr, ptr %23, align 8, !tbaa !5
  %2923 = load i32, ptr %60, align 4, !tbaa !9
  %2924 = sext i32 %2923 to i64
  %2925 = getelementptr inbounds %struct.doublecomplex, ptr %2922, i64 %2924
  %2926 = call { double, double } @Cd(ptr noundef %2925)
  %2927 = extractvalue { double, double } %2926, 0
  %2928 = extractvalue { double, double } %2926, 1
  %2929 = getelementptr inbounds { double, double }, ptr %76, i32 0, i32 0
  %2930 = getelementptr inbounds { double, double }, ptr %76, i32 0, i32 1
  store double %2927, ptr %2929, align 8
  store double %2928, ptr %2930, align 8
  %2931 = getelementptr inbounds { double, double }, ptr %76, i32 0, i32 0
  %2932 = load double, ptr %2931, align 8
  %2933 = getelementptr inbounds { double, double }, ptr %76, i32 0, i32 1
  %2934 = load double, ptr %2933, align 8
  %2935 = call double @cabs(double noundef %2932, double noundef %2934) #6
  %2936 = call double @llvm.fmuladd.f64(double %2921, double %2935, double %2915)
  %2937 = load ptr, ptr %31, align 8, !tbaa !5
  %2938 = load i32, ptr %60, align 4, !tbaa !9
  %2939 = sext i32 %2938 to i64
  %2940 = getelementptr inbounds double, ptr %2937, i64 %2939
  store double %2936, ptr %2940, align 8, !tbaa !11
  br label %2941

2941:                                             ; preds = %2904
  %2942 = load i32, ptr %60, align 4, !tbaa !9
  %2943 = add nsw i32 %2942, -1
  store i32 %2943, ptr %60, align 4, !tbaa !9
  br label %2901, !llvm.loop !23

2944:                                             ; preds = %2901
  %2945 = load ptr, ptr %18, align 8, !tbaa !5
  %2946 = load ptr, ptr %31, align 8, !tbaa !5
  %2947 = getelementptr inbounds double, ptr %2946, i64 1
  %2948 = call i32 @idamax_(ptr noundef %2945, ptr noundef %2947, ptr noundef @c__1)
  store i32 %2948, ptr %69, align 4, !tbaa !9
  %2949 = load ptr, ptr %31, align 8, !tbaa !5
  %2950 = load i32, ptr %69, align 4, !tbaa !9
  %2951 = sext i32 %2950 to i64
  %2952 = getelementptr inbounds double, ptr %2949, i64 %2951
  %2953 = load double, ptr %2952, align 8, !tbaa !11
  store double %2953, ptr %43, align 8, !tbaa !11
  %2954 = load double, ptr %43, align 8, !tbaa !11
  %2955 = fcmp oge double %2954, 0.000000e+00
  br i1 %2955, label %2956, label %2958

2956:                                             ; preds = %2944
  %2957 = load double, ptr %43, align 8, !tbaa !11
  br label %2961

2958:                                             ; preds = %2944
  %2959 = load double, ptr %43, align 8, !tbaa !11
  %2960 = fneg double %2959
  br label %2961

2961:                                             ; preds = %2958, %2956
  %2962 = phi double [ %2957, %2956 ], [ %2960, %2958 ]
  %2963 = load ptr, ptr %28, align 8, !tbaa !5
  %2964 = load i32, ptr %61, align 4, !tbaa !9
  %2965 = sext i32 %2964 to i64
  %2966 = getelementptr inbounds double, ptr %2963, i64 %2965
  %2967 = load double, ptr %2966, align 8, !tbaa !11
  %2968 = fmul double %2967, %2962
  store double %2968, ptr %2966, align 8, !tbaa !11
  store double 0.000000e+00, ptr %72, align 8, !tbaa !11
  %2969 = load ptr, ptr %18, align 8, !tbaa !5
  %2970 = load i32, ptr %2969, align 4, !tbaa !9
  store i32 %2970, ptr %38, align 4, !tbaa !9
  store i32 1, ptr %60, align 4, !tbaa !9
  br label %2971

2971:                                             ; preds = %3004, %2961
  %2972 = load i32, ptr %60, align 4, !tbaa !9
  %2973 = load i32, ptr %38, align 4, !tbaa !9
  %2974 = icmp sle i32 %2972, %2973
  br i1 %2974, label %2975, label %3007

2975:                                             ; preds = %2971
  %2976 = load double, ptr %72, align 8, !tbaa !11
  store double %2976, ptr %43, align 8, !tbaa !11
  %2977 = load ptr, ptr %26, align 8, !tbaa !5
  %2978 = load i32, ptr %60, align 4, !tbaa !9
  %2979 = load i32, ptr %61, align 4, !tbaa !9
  %2980 = load i32, ptr %35, align 4, !tbaa !9
  %2981 = mul nsw i32 %2979, %2980
  %2982 = add nsw i32 %2978, %2981
  %2983 = sext i32 %2982 to i64
  %2984 = getelementptr inbounds %struct.doublecomplex, ptr %2977, i64 %2983
  %2985 = call { double, double } @Cd(ptr noundef %2984)
  %2986 = extractvalue { double, double } %2985, 0
  %2987 = extractvalue { double, double } %2985, 1
  %2988 = getelementptr inbounds { double, double }, ptr %77, i32 0, i32 0
  %2989 = getelementptr inbounds { double, double }, ptr %77, i32 0, i32 1
  store double %2986, ptr %2988, align 8
  store double %2987, ptr %2989, align 8
  %2990 = getelementptr inbounds { double, double }, ptr %77, i32 0, i32 0
  %2991 = load double, ptr %2990, align 8
  %2992 = getelementptr inbounds { double, double }, ptr %77, i32 0, i32 1
  %2993 = load double, ptr %2992, align 8
  %2994 = call double @cabs(double noundef %2991, double noundef %2993) #6
  store double %2994, ptr %44, align 8, !tbaa !11
  %2995 = load double, ptr %43, align 8, !tbaa !11
  %2996 = load double, ptr %44, align 8, !tbaa !11
  %2997 = fcmp oge double %2995, %2996
  br i1 %2997, label %2998, label %3000

2998:                                             ; preds = %2975
  %2999 = load double, ptr %43, align 8, !tbaa !11
  br label %3002

3000:                                             ; preds = %2975
  %3001 = load double, ptr %44, align 8, !tbaa !11
  br label %3002

3002:                                             ; preds = %3000, %2998
  %3003 = phi double [ %2999, %2998 ], [ %3001, %3000 ]
  store double %3003, ptr %72, align 8, !tbaa !11
  br label %3004

3004:                                             ; preds = %3002
  %3005 = load i32, ptr %60, align 4, !tbaa !9
  %3006 = add nsw i32 %3005, 1
  store i32 %3006, ptr %60, align 4, !tbaa !9
  br label %2971, !llvm.loop !24

3007:                                             ; preds = %2971
  %3008 = load double, ptr %72, align 8, !tbaa !11
  %3009 = fcmp une double %3008, 0.000000e+00
  br i1 %3009, label %3010, label %3018

3010:                                             ; preds = %3007
  %3011 = load double, ptr %72, align 8, !tbaa !11
  %3012 = load ptr, ptr %28, align 8, !tbaa !5
  %3013 = load i32, ptr %61, align 4, !tbaa !9
  %3014 = sext i32 %3013 to i64
  %3015 = getelementptr inbounds double, ptr %3012, i64 %3014
  %3016 = load double, ptr %3015, align 8, !tbaa !11
  %3017 = fdiv double %3016, %3011
  store double %3017, ptr %3015, align 8, !tbaa !11
  br label %3018

3018:                                             ; preds = %3010, %3007
  br label %3019

3019:                                             ; preds = %3018
  %3020 = load i32, ptr %61, align 4, !tbaa !9
  %3021 = add nsw i32 %3020, 1
  store i32 %3021, ptr %61, align 4, !tbaa !9
  br label %220, !llvm.loop !25

3022:                                             ; preds = %220
  store i32 1, ptr %74, align 4
  br label %3023

3023:                                             ; preds = %3022, %207, %175
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %71) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %68) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %67) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %66) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %65) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %57) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %56) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  ret void
}

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

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

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

declare double @dlamch_(ptr noundef) #2

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

59:                                               ; preds = %56
  br i1 %.not913959, label %.loopexit, label %.lr.ph962.preheader

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

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

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

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

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

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

.lr.ph962.prol.loopexit:                          ; preds = %.lr.ph962.prol, %.lr.ph962.preheader1088
  %indvars.iv996.unr = phi i64 [ %indvars.iv996.ph, %.lr.ph962.preheader1088 ], [ %indvars.iv.next997.prol, %.lr.ph962.prol ]
  %73 = icmp ult i64 %70, 3
  br i1 %73, label %.loopexit, label %.lr.ph962

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

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

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

.preheader:                                       ; preds = %.preheader.lr.ph, %._crit_edge955.thread
  %indvars.iv993 = phi i64 [ 1, %.preheader.lr.ph ], [ %indvars.iv.next994, %._crit_edge955.thread ]
  %93 = getelementptr inbounds double, ptr %34, i64 %indvars.iv993
  %94 = mul nsw i64 %indvars.iv993, %91
  %gep1093 = getelementptr %struct.doublecomplex, ptr %invariant.gep1092, i64 %94
  %95 = mul nsw i64 %indvars.iv993, %92
  %96 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %97 = getelementptr i8, ptr %96, i64 16
  %98 = getelementptr i8, ptr %96, i64 32
  %99 = trunc nsw i64 %95 to i32
  %100 = add i32 %99, -1
  %gep935 = getelementptr %struct.doublecomplex, ptr %invariant.gep934, i64 %95
  %invariant.gep1011 = getelementptr %struct.doublecomplex, ptr %29, i64 %94
  %invariant.gep1013 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %invariant.gep1015 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %invariant.gep1017 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %101 = getelementptr %struct.doublecomplex, ptr %29, i64 %94
  %102 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %103 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %invariant.gep1019 = getelementptr %struct.doublecomplex, ptr %29, i64 %94
  %invariant.gep1021 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %invariant.gep1023 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %invariant.gep1025 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %104 = getelementptr %struct.doublecomplex, ptr %29, i64 %94
  %105 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  %106 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  br label %107

107:                                              ; preds = %.preheader, %661
  %.0893 = phi i32 [ %663, %661 ], [ 1, %.preheader ]
  %.0 = phi double [ %662, %661 ], [ 3.000000e+00, %.preheader ]
  %108 = load i32, ptr %1, align 4, !tbaa !5
  %109 = icmp eq i32 %108, 1
  %110 = load double, ptr %3, align 8, !tbaa !9
  %111 = load <2 x double>, ptr %gep1093, align 8, !tbaa !9
  store <2 x double> %111, ptr %21, align 16, !tbaa !9
  %112 = load <2 x double>, ptr %97, align 8, !tbaa !9
  %113 = insertelement <2 x double> poison, double %110, i64 0
  %114 = shufflevector <2 x double> %113, <2 x double> poison, <2 x i32> zeroinitializer
  %115 = fmul <2 x double> %114, %112
  store <2 x double> %115, ptr %22, align 16, !tbaa !9
  br i1 %.not, label %363, label %116

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

117:                                              ; preds = %116
  %118 = load double, ptr %4, align 8, !tbaa !18
  %119 = load double, ptr %88, align 8, !tbaa !20
  %120 = fneg double %119
  %121 = fsub <2 x double> %111, %115
  store <2 x double> %121, ptr %20, align 16, !tbaa !9
  %122 = load <2 x double>, ptr %98, align 8, !tbaa !9
  %123 = insertelement <2 x double> poison, double %119, i64 0
  %124 = insertelement <2 x double> %123, double %120, i64 1
  %125 = fmul <2 x double> %122, %124
  %126 = shufflevector <2 x double> %125, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %127 = insertelement <2 x double> poison, double %118, i64 0
  %128 = shufflevector <2 x double> %127, <2 x double> poison, <2 x i32> zeroinitializer
  %129 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %122, <2 x double> %126)
  %130 = fsub <2 x double> %121, %129
  store <2 x double> %130, ptr %13, align 8, !tbaa !9
  %131 = call { double, double } @Cd(ptr noundef nonnull %21)
  %132 = extractvalue { double, double } %131, 1
  %133 = load double, ptr %22, align 16, !tbaa !18
  %134 = call { double, double } @Cd(ptr noundef nonnull %22)
  %135 = extractvalue { double, double } %134, 1
  %136 = insertelement <2 x double> %111, double %133, i64 1
  %137 = fcmp oge <2 x double> %136, zeroinitializer
  %138 = fneg <2 x double> %136
  %139 = select <2 x i1> %137, <2 x double> %136, <2 x double> %138
  %140 = insertelement <2 x double> poison, double %132, i64 0
  %141 = insertelement <2 x double> %140, double %135, i64 1
  %142 = fcmp oge <2 x double> %141, zeroinitializer
  %143 = fneg <2 x double> %141
  %144 = select <2 x i1> %142, <2 x double> %141, <2 x double> %143
  %145 = fadd <2 x double> %139, %144
  %shift = shufflevector <2 x double> %145, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %146 = fadd <2 x double> %145, %shift
  %147 = extractelement <2 x double> %146, i64 0
  %148 = load double, ptr %4, align 8, !tbaa !18
  %149 = call { double, double } @Cd(ptr noundef nonnull %4)
  %150 = extractvalue { double, double } %149, 1
  %151 = insertelement <2 x double> poison, double %148, i64 0
  %152 = insertelement <2 x double> %151, double %150, i64 1
  %153 = fcmp oge <2 x double> %152, zeroinitializer
  %154 = fneg <2 x double> %152
  %155 = select <2 x i1> %153, <2 x double> %152, <2 x double> %154
  %shift1065 = shufflevector <2 x double> %155, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %156 = fadd <2 x double> %155, %shift1065
  %157 = extractelement <2 x double> %156, i64 0
  %158 = load double, ptr %98, align 8, !tbaa !18
  %159 = call { double, double } @Cd(ptr noundef nonnull %98)
  %160 = extractvalue { double, double } %159, 1
  %161 = insertelement <2 x double> poison, double %158, i64 0
  %162 = insertelement <2 x double> %161, double %160, i64 1
  %163 = fcmp oge <2 x double> %162, zeroinitializer
  %164 = fneg <2 x double> %162
  %165 = select <2 x i1> %163, <2 x double> %162, <2 x double> %164
  %shift1066 = shufflevector <2 x double> %165, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %166 = fadd <2 x double> %165, %shift1066
  %167 = extractelement <2 x double> %166, i64 0
  %168 = call double @llvm.fmuladd.f64(double %157, double %167, double %147)
  store double %168, ptr %14, align 8, !tbaa !9
  %169 = load i32, ptr %1, align 4, !tbaa !5
  %.not908.not917 = icmp sgt i32 %169, 2
  br i1 %.not908.not917, label %.lr.ph.preheader, label %._crit_edge

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

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv = phi i64 [ 2, %.lr.ph.preheader ], [ %indvars.iv.next, %.lr.ph ]
  %gep1012 = getelementptr %struct.doublecomplex, ptr %invariant.gep1011, i64 %indvars.iv
  %170 = load <2 x double>, ptr %gep1012, align 8, !tbaa !9
  store <2 x double> %170, ptr %21, align 16, !tbaa !9
  %171 = add nsw i64 %indvars.iv, -1
  %172 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %171
  %173 = call { double, double } @Cd(ptr noundef nonnull %172)
  %174 = extractvalue { double, double } %173, 0
  %175 = extractvalue { double, double } %173, 1
  %176 = fneg double %175
  %177 = call ptr @_pCd(ptr noundef nonnull %20)
  %178 = getelementptr inbounds i8, ptr %177, i64 8
  store double %174, ptr %177, align 8
  store double %176, ptr %178, align 8
  %179 = load <2 x double>, ptr %20, align 16
  %gep1014 = getelementptr %struct.doublecomplex, ptr %invariant.gep1013, i64 %171
  %180 = load double, ptr %89, align 8, !tbaa !20
  %181 = fneg double %180
  %182 = getelementptr inbounds double, ptr %23, i64 %indvars.iv
  %183 = load double, ptr %182, align 8, !tbaa !9
  %gep1016 = getelementptr %struct.doublecomplex, ptr %invariant.gep1015, i64 %indvars.iv
  %184 = load <2 x double>, ptr %gep1016, align 8, !tbaa !9
  %185 = insertelement <2 x double> poison, double %183, i64 0
  %186 = shufflevector <2 x double> %185, <2 x double> poison, <2 x i32> zeroinitializer
  %187 = fmul <2 x double> %186, %184
  store <2 x double> %187, ptr %22, align 16, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %188 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %indvars.iv
  %189 = load double, ptr %188, align 8, !tbaa !18
  %gep1018 = getelementptr %struct.doublecomplex, ptr %invariant.gep1017, i64 %indvars.iv.next
  %190 = getelementptr inbounds i8, ptr %188, i64 8
  %191 = load double, ptr %190, align 8, !tbaa !20
  %192 = fneg double %191
  %193 = load <2 x double>, ptr %gep1014, align 8, !tbaa !9
  %194 = insertelement <2 x double> poison, double %180, i64 0
  %195 = insertelement <2 x double> %194, double %181, i64 1
  %196 = fmul <2 x double> %193, %195
  %197 = shufflevector <2 x double> %196, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %198 = shufflevector <2 x double> %179, <2 x double> poison, <2 x i32> zeroinitializer
  %199 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %198, <2 x double> %193, <2 x double> %197)
  %200 = load <2 x double>, ptr %21, align 16, !tbaa !9
  %201 = fsub <2 x double> %200, %199
  %202 = fsub <2 x double> %201, %187
  store <2 x double> %202, ptr %20, align 16, !tbaa !9
  %203 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %indvars.iv
  %204 = load <2 x double>, ptr %gep1018, align 8, !tbaa !9
  %205 = insertelement <2 x double> poison, double %191, i64 0
  %206 = insertelement <2 x double> %205, double %192, i64 1
  %207 = fmul <2 x double> %204, %206
  %208 = shufflevector <2 x double> %207, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %209 = insertelement <2 x double> poison, double %189, i64 0
  %210 = shufflevector <2 x double> %209, <2 x double> poison, <2 x i32> zeroinitializer
  %211 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %210, <2 x double> %204, <2 x double> %208)
  %212 = fsub <2 x double> %202, %211
  store <2 x double> %212, ptr %203, align 8, !tbaa !9
  %213 = extractelement <2 x double> %200, i64 0
  %214 = fcmp oge double %213, 0.000000e+00
  %215 = fneg double %213
  %216 = select i1 %214, double %213, double %215
  %217 = call { double, double } @Cd(ptr noundef nonnull %21)
  %218 = extractvalue { double, double } %217, 1
  %219 = fcmp oge double %218, 0.000000e+00
  %220 = fneg double %218
  %221 = select i1 %219, double %218, double %220
  %222 = fadd double %216, %221
  %223 = load double, ptr %172, align 8, !tbaa !18
  %224 = call { double, double } @Cd(ptr noundef nonnull %172)
  %225 = extractvalue { double, double } %224, 1
  %226 = insertelement <2 x double> poison, double %223, i64 0
  %227 = insertelement <2 x double> %226, double %225, i64 1
  %228 = fcmp oge <2 x double> %227, zeroinitializer
  %229 = fneg <2 x double> %227
  %230 = select <2 x i1> %228, <2 x double> %227, <2 x double> %229
  %shift1067 = shufflevector <2 x double> %230, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %231 = fadd <2 x double> %230, %shift1067
  %232 = extractelement <2 x double> %231, i64 0
  %233 = load double, ptr %gep1014, align 8, !tbaa !18
  %234 = call { double, double } @Cd(ptr noundef nonnull %gep1014)
  %235 = extractvalue { double, double } %234, 1
  %236 = insertelement <2 x double> poison, double %233, i64 0
  %237 = insertelement <2 x double> %236, double %235, i64 1
  %238 = fcmp oge <2 x double> %237, zeroinitializer
  %239 = fneg <2 x double> %237
  %240 = select <2 x i1> %238, <2 x double> %237, <2 x double> %239
  %shift1068 = shufflevector <2 x double> %240, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %241 = fadd <2 x double> %240, %shift1068
  %242 = extractelement <2 x double> %241, i64 0
  %243 = call double @llvm.fmuladd.f64(double %232, double %242, double %222)
  %244 = load <2 x double>, ptr %22, align 16
  %245 = call { double, double } @Cd(ptr noundef nonnull %22)
  %246 = extractvalue { double, double } %245, 1
  %247 = insertelement <2 x double> %244, double %246, i64 1
  %248 = fcmp oge <2 x double> %247, zeroinitializer
  %249 = fneg <2 x double> %247
  %250 = select <2 x i1> %248, <2 x double> %247, <2 x double> %249
  %shift1069 = shufflevector <2 x double> %250, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %251 = fadd <2 x double> %250, %shift1069
  %252 = extractelement <2 x double> %251, i64 0
  %253 = fadd double %243, %252
  %254 = load double, ptr %188, align 8, !tbaa !18
  %255 = call { double, double } @Cd(ptr noundef nonnull %188)
  %256 = extractvalue { double, double } %255, 1
  %257 = insertelement <2 x double> poison, double %254, i64 0
  %258 = insertelement <2 x double> %257, double %256, i64 1
  %259 = fcmp oge <2 x double> %258, zeroinitializer
  %260 = fneg <2 x double> %258
  %261 = select <2 x i1> %259, <2 x double> %258, <2 x double> %260
  %shift1070 = shufflevector <2 x double> %261, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %262 = fadd <2 x double> %261, %shift1070
  %263 = extractelement <2 x double> %262, i64 0
  %264 = load double, ptr %gep1018, align 8, !tbaa !18
  %265 = call { double, double } @Cd(ptr noundef nonnull %gep1018)
  %266 = extractvalue { double, double } %265, 1
  %267 = insertelement <2 x double> poison, double %264, i64 0
  %268 = insertelement <2 x double> %267, double %266, i64 1
  %269 = fcmp oge <2 x double> %268, zeroinitializer
  %270 = fneg <2 x double> %268
  %271 = select <2 x i1> %269, <2 x double> %268, <2 x double> %270
  %shift1071 = shufflevector <2 x double> %271, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %272 = fadd <2 x double> %271, %shift1071
  %273 = extractelement <2 x double> %272, i64 0
  %274 = call double @llvm.fmuladd.f64(double %263, double %273, double %253)
  %275 = getelementptr inbounds double, ptr %36, i64 %indvars.iv
  store double %274, ptr %275, align 8, !tbaa !9
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge.loopexit, label %.lr.ph, !llvm.loop !21

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

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %117
  %276 = phi i32 [ %.pre, %._crit_edge.loopexit ], [ %169, %117 ]
  %277 = sext i32 %276 to i64
  %278 = getelementptr %struct.doublecomplex, ptr %101, i64 %277
  %279 = load <2 x double>, ptr %278, align 8, !tbaa !9
  store <2 x double> %279, ptr %21, align 16, !tbaa !9
  %gep = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %277
  %280 = call { double, double } @Cd(ptr noundef %gep)
  %281 = extractvalue { double, double } %280, 0
  %282 = extractvalue { double, double } %280, 1
  %283 = fneg double %282
  %284 = call ptr @_pCd(ptr noundef nonnull %20)
  %285 = getelementptr inbounds i8, ptr %284, i64 8
  store double %281, ptr %284, align 8
  store double %283, ptr %285, align 8
  %286 = load i32, ptr %1, align 4, !tbaa !5
  %287 = add nsw i32 %286, -1
  %288 = sext i32 %287 to i64
  %289 = load <2 x double>, ptr %20, align 16
  %290 = getelementptr %struct.doublecomplex, ptr %102, i64 %288
  %291 = load double, ptr %89, align 8, !tbaa !20
  %292 = fneg double %291
  %293 = sext i32 %286 to i64
  %294 = getelementptr inbounds double, ptr %23, i64 %293
  %295 = load double, ptr %294, align 8, !tbaa !9
  %296 = getelementptr %struct.doublecomplex, ptr %103, i64 %293
  %297 = load <2 x double>, ptr %296, align 8, !tbaa !9
  %298 = insertelement <2 x double> poison, double %295, i64 0
  %299 = shufflevector <2 x double> %298, <2 x double> poison, <2 x i32> zeroinitializer
  %300 = fmul <2 x double> %299, %297
  store <2 x double> %300, ptr %22, align 16, !tbaa !9
  %301 = load <2 x double>, ptr %290, align 8, !tbaa !9
  %302 = insertelement <2 x double> poison, double %291, i64 0
  %303 = insertelement <2 x double> %302, double %292, i64 1
  %304 = fmul <2 x double> %301, %303
  %305 = shufflevector <2 x double> %304, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %306 = shufflevector <2 x double> %289, <2 x double> poison, <2 x i32> zeroinitializer
  %307 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %306, <2 x double> %301, <2 x double> %305)
  %308 = load <2 x double>, ptr %21, align 16, !tbaa !9
  %309 = fsub <2 x double> %308, %307
  store <2 x double> %309, ptr %20, align 16, !tbaa !9
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %293
  %311 = fsub <2 x double> %309, %300
  store <2 x double> %311, ptr %310, align 8, !tbaa !9
  %312 = extractelement <2 x double> %308, i64 0
  %313 = fcmp oge double %312, 0.000000e+00
  %314 = fneg double %312
  %315 = select i1 %313, double %312, double %314
  %316 = call { double, double } @Cd(ptr noundef nonnull %21)
  %317 = extractvalue { double, double } %316, 1
  %318 = fcmp oge double %317, 0.000000e+00
  %319 = fneg double %317
  %320 = select i1 %318, double %317, double %319
  %321 = fadd double %315, %320
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %288
  %323 = load double, ptr %322, align 8, !tbaa !18
  %324 = load i32, ptr %1, align 4, !tbaa !5
  %325 = sext i32 %324 to i64
  %gep931 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %325
  %326 = call { double, double } @Cd(ptr noundef %gep931)
  %327 = extractvalue { double, double } %326, 1
  %328 = insertelement <2 x double> poison, double %323, i64 0
  %329 = insertelement <2 x double> %328, double %327, i64 1
  %330 = fcmp oge <2 x double> %329, zeroinitializer
  %331 = fneg <2 x double> %329
  %332 = select <2 x i1> %330, <2 x double> %329, <2 x double> %331
  %shift1072 = shufflevector <2 x double> %332, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %333 = fadd <2 x double> %332, %shift1072
  %334 = extractelement <2 x double> %333, i64 0
  %335 = load double, ptr %290, align 8, !tbaa !18
  %336 = load i32, ptr %1, align 4, !tbaa !5
  %337 = add i32 %100, %336
  %338 = sext i32 %337 to i64
  %339 = getelementptr inbounds %struct.doublecomplex, ptr %32, i64 %338
  %340 = call { double, double } @Cd(ptr noundef %339)
  %341 = extractvalue { double, double } %340, 1
  %342 = insertelement <2 x double> poison, double %335, i64 0
  %343 = insertelement <2 x double> %342, double %341, i64 1
  %344 = fcmp oge <2 x double> %343, zeroinitializer
  %345 = fneg <2 x double> %343
  %346 = select <2 x i1> %344, <2 x double> %343, <2 x double> %345
  %shift1073 = shufflevector <2 x double> %346, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %347 = fadd <2 x double> %346, %shift1073
  %348 = extractelement <2 x double> %347, i64 0
  %349 = call double @llvm.fmuladd.f64(double %334, double %348, double %321)
  %350 = load <2 x double>, ptr %22, align 16
  %351 = call { double, double } @Cd(ptr noundef nonnull %22)
  %352 = extractvalue { double, double } %351, 1
  %353 = insertelement <2 x double> %350, double %352, i64 1
  %354 = fcmp oge <2 x double> %353, zeroinitializer
  %355 = fneg <2 x double> %353
  %356 = select <2 x i1> %354, <2 x double> %353, <2 x double> %355
  %shift1074 = shufflevector <2 x double> %356, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %357 = fadd <2 x double> %356, %shift1074
  %358 = extractelement <2 x double> %357, i64 0
  %359 = fadd double %349, %358
  %360 = load i32, ptr %1, align 4, !tbaa !5
  %361 = sext i32 %360 to i64
  %362 = getelementptr inbounds double, ptr %36, i64 %361
  store double %359, ptr %362, align 8, !tbaa !9
  br label %628

363:                                              ; preds = %107
  br i1 %109, label %thread-pre-split, label %364

364:                                              ; preds = %363
  %365 = call { double, double } @Cd(ptr noundef %4)
  %366 = extractvalue { double, double } %365, 0
  %367 = extractvalue { double, double } %365, 1
  %368 = fneg double %367
  %369 = call ptr @_pCd(ptr noundef nonnull %20)
  %370 = getelementptr inbounds i8, ptr %369, i64 8
  store double %366, ptr %369, align 8
  store double %368, ptr %370, align 8
  %371 = load <2 x double>, ptr %20, align 16
  %372 = load double, ptr %89, align 8, !tbaa !20
  %373 = fneg double %372
  %374 = load <2 x double>, ptr %21, align 16, !tbaa !9
  %375 = load <2 x double>, ptr %22, align 16, !tbaa !9
  %376 = fsub <2 x double> %374, %375
  store <2 x double> %376, ptr %20, align 16, !tbaa !9
  %377 = load <2 x double>, ptr %98, align 8, !tbaa !9
  %378 = insertelement <2 x double> poison, double %372, i64 0
  %379 = insertelement <2 x double> %378, double %373, i64 1
  %380 = fmul <2 x double> %377, %379
  %381 = shufflevector <2 x double> %380, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %382 = shufflevector <2 x double> %371, <2 x double> poison, <2 x i32> zeroinitializer
  %383 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %382, <2 x double> %377, <2 x double> %381)
  %384 = fsub <2 x double> %376, %383
  store <2 x double> %384, ptr %13, align 8, !tbaa !9
  %385 = call { double, double } @Cd(ptr noundef nonnull %21)
  %386 = extractvalue { double, double } %385, 1
  %387 = load double, ptr %22, align 16, !tbaa !18
  %388 = call { double, double } @Cd(ptr noundef nonnull %22)
  %389 = extractvalue { double, double } %388, 1
  %390 = insertelement <2 x double> %374, double %387, i64 1
  %391 = fcmp oge <2 x double> %390, zeroinitializer
  %392 = fneg <2 x double> %390
  %393 = select <2 x i1> %391, <2 x double> %390, <2 x double> %392
  %394 = insertelement <2 x double> poison, double %386, i64 0
  %395 = insertelement <2 x double> %394, double %389, i64 1
  %396 = fcmp oge <2 x double> %395, zeroinitializer
  %397 = fneg <2 x double> %395
  %398 = select <2 x i1> %396, <2 x double> %395, <2 x double> %397
  %399 = fadd <2 x double> %393, %398
  %shift1075 = shufflevector <2 x double> %399, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %400 = fadd <2 x double> %399, %shift1075
  %401 = extractelement <2 x double> %400, i64 0
  %402 = load double, ptr %4, align 8, !tbaa !18
  %403 = call { double, double } @Cd(ptr noundef nonnull %4)
  %404 = extractvalue { double, double } %403, 1
  %405 = insertelement <2 x double> poison, double %402, i64 0
  %406 = insertelement <2 x double> %405, double %404, i64 1
  %407 = fcmp oge <2 x double> %406, zeroinitializer
  %408 = fneg <2 x double> %406
  %409 = select <2 x i1> %407, <2 x double> %406, <2 x double> %408
  %shift1076 = shufflevector <2 x double> %409, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %410 = fadd <2 x double> %409, %shift1076
  %411 = extractelement <2 x double> %410, i64 0
  %412 = load double, ptr %98, align 8, !tbaa !18
  %413 = call { double, double } @Cd(ptr noundef nonnull %98)
  %414 = extractvalue { double, double } %413, 1
  %415 = insertelement <2 x double> poison, double %412, i64 0
  %416 = insertelement <2 x double> %415, double %414, i64 1
  %417 = fcmp oge <2 x double> %416, zeroinitializer
  %418 = fneg <2 x double> %416
  %419 = select <2 x i1> %417, <2 x double> %416, <2 x double> %418
  %shift1077 = shufflevector <2 x double> %419, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %420 = fadd <2 x double> %419, %shift1077
  %421 = extractelement <2 x double> %420, i64 0
  %422 = call double @llvm.fmuladd.f64(double %411, double %421, double %401)
  store double %422, ptr %14, align 8, !tbaa !9
  %423 = load i32, ptr %1, align 4, !tbaa !5
  %.not907.not919 = icmp sgt i32 %423, 2
  br i1 %.not907.not919, label %.lr.ph922.preheader, label %._crit_edge923

.lr.ph922.preheader:                              ; preds = %364
  %wide.trip.count968 = zext nneg i32 %423 to i64
  br label %.lr.ph922

.lr.ph922:                                        ; preds = %.lr.ph922.preheader, %.lr.ph922
  %indvars.iv965 = phi i64 [ 2, %.lr.ph922.preheader ], [ %indvars.iv.next966, %.lr.ph922 ]
  %gep1020 = getelementptr %struct.doublecomplex, ptr %invariant.gep1019, i64 %indvars.iv965
  %424 = load <2 x double>, ptr %gep1020, align 8, !tbaa !9
  store <2 x double> %424, ptr %21, align 16, !tbaa !9
  %425 = add nsw i64 %indvars.iv965, -1
  %426 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %425
  %427 = load double, ptr %426, align 8, !tbaa !18
  %gep1022 = getelementptr %struct.doublecomplex, ptr %invariant.gep1021, i64 %425
  %428 = getelementptr inbounds i8, ptr %426, i64 8
  %429 = load double, ptr %428, align 8, !tbaa !20
  %430 = fneg double %429
  %431 = getelementptr inbounds double, ptr %23, i64 %indvars.iv965
  %432 = load double, ptr %431, align 8, !tbaa !9
  %gep1024 = getelementptr %struct.doublecomplex, ptr %invariant.gep1023, i64 %indvars.iv965
  %433 = load <2 x double>, ptr %gep1024, align 8, !tbaa !9
  %434 = insertelement <2 x double> poison, double %432, i64 0
  %435 = shufflevector <2 x double> %434, <2 x double> poison, <2 x i32> zeroinitializer
  %436 = fmul <2 x double> %435, %433
  store <2 x double> %436, ptr %22, align 16, !tbaa !9
  %437 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %indvars.iv965
  %indvars.iv.next966 = add nuw nsw i64 %indvars.iv965, 1
  %gep1026 = getelementptr %struct.doublecomplex, ptr %invariant.gep1025, i64 %indvars.iv.next966
  %438 = load <2 x double>, ptr %gep1022, align 8, !tbaa !9
  %439 = insertelement <2 x double> poison, double %429, i64 0
  %440 = insertelement <2 x double> %439, double %430, i64 1
  %441 = fmul <2 x double> %438, %440
  %442 = shufflevector <2 x double> %441, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %443 = insertelement <2 x double> poison, double %427, i64 0
  %444 = shufflevector <2 x double> %443, <2 x double> poison, <2 x i32> zeroinitializer
  %445 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %444, <2 x double> %438, <2 x double> %442)
  %446 = call { double, double } @Cd(ptr noundef nonnull %437)
  %447 = extractvalue { double, double } %446, 0
  %448 = extractvalue { double, double } %446, 1
  %449 = fneg double %448
  %450 = call ptr @_pCd(ptr noundef nonnull %20)
  %451 = getelementptr inbounds i8, ptr %450, i64 8
  store double %447, ptr %450, align 8
  store double %449, ptr %451, align 8
  %452 = load <2 x double>, ptr %20, align 16
  %453 = load double, ptr %89, align 8, !tbaa !20
  %454 = fneg double %453
  %455 = load <2 x double>, ptr %21, align 16, !tbaa !9
  %456 = fsub <2 x double> %455, %445
  %457 = load <2 x double>, ptr %22, align 16, !tbaa !9
  %458 = fsub <2 x double> %456, %457
  store <2 x double> %458, ptr %20, align 16, !tbaa !9
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %indvars.iv965
  %460 = load <2 x double>, ptr %gep1026, align 8, !tbaa !9
  %461 = insertelement <2 x double> poison, double %453, i64 0
  %462 = insertelement <2 x double> %461, double %454, i64 1
  %463 = fmul <2 x double> %460, %462
  %464 = shufflevector <2 x double> %463, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %465 = shufflevector <2 x double> %452, <2 x double> poison, <2 x i32> zeroinitializer
  %466 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %465, <2 x double> %460, <2 x double> %464)
  %467 = fsub <2 x double> %458, %466
  store <2 x double> %467, ptr %459, align 8, !tbaa !9
  %468 = extractelement <2 x double> %455, i64 0
  %469 = fcmp oge double %468, 0.000000e+00
  %470 = fneg double %468
  %471 = select i1 %469, double %468, double %470
  %472 = call { double, double } @Cd(ptr noundef nonnull %21)
  %473 = extractvalue { double, double } %472, 1
  %474 = fcmp oge double %473, 0.000000e+00
  %475 = fneg double %473
  %476 = select i1 %474, double %473, double %475
  %477 = fadd double %471, %476
  %478 = load double, ptr %426, align 8, !tbaa !18
  %479 = call { double, double } @Cd(ptr noundef nonnull %426)
  %480 = extractvalue { double, double } %479, 1
  %481 = insertelement <2 x double> poison, double %478, i64 0
  %482 = insertelement <2 x double> %481, double %480, i64 1
  %483 = fcmp oge <2 x double> %482, zeroinitializer
  %484 = fneg <2 x double> %482
  %485 = select <2 x i1> %483, <2 x double> %482, <2 x double> %484
  %shift1078 = shufflevector <2 x double> %485, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %486 = fadd <2 x double> %485, %shift1078
  %487 = extractelement <2 x double> %486, i64 0
  %488 = load double, ptr %gep1022, align 8, !tbaa !18
  %489 = call { double, double } @Cd(ptr noundef nonnull %gep1022)
  %490 = extractvalue { double, double } %489, 1
  %491 = insertelement <2 x double> poison, double %488, i64 0
  %492 = insertelement <2 x double> %491, double %490, i64 1
  %493 = fcmp oge <2 x double> %492, zeroinitializer
  %494 = fneg <2 x double> %492
  %495 = select <2 x i1> %493, <2 x double> %492, <2 x double> %494
  %shift1079 = shufflevector <2 x double> %495, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %496 = fadd <2 x double> %495, %shift1079
  %497 = extractelement <2 x double> %496, i64 0
  %498 = call double @llvm.fmuladd.f64(double %487, double %497, double %477)
  %499 = load <2 x double>, ptr %22, align 16
  %500 = call { double, double } @Cd(ptr noundef nonnull %22)
  %501 = extractvalue { double, double } %500, 1
  %502 = insertelement <2 x double> %499, double %501, i64 1
  %503 = fcmp oge <2 x double> %502, zeroinitializer
  %504 = fneg <2 x double> %502
  %505 = select <2 x i1> %503, <2 x double> %502, <2 x double> %504
  %shift1080 = shufflevector <2 x double> %505, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %506 = fadd <2 x double> %505, %shift1080
  %507 = extractelement <2 x double> %506, i64 0
  %508 = fadd double %498, %507
  %509 = load double, ptr %437, align 8, !tbaa !18
  %510 = call { double, double } @Cd(ptr noundef nonnull %437)
  %511 = extractvalue { double, double } %510, 1
  %512 = insertelement <2 x double> poison, double %509, i64 0
  %513 = insertelement <2 x double> %512, double %511, i64 1
  %514 = fcmp oge <2 x double> %513, zeroinitializer
  %515 = fneg <2 x double> %513
  %516 = select <2 x i1> %514, <2 x double> %513, <2 x double> %515
  %shift1081 = shufflevector <2 x double> %516, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %517 = fadd <2 x double> %516, %shift1081
  %518 = extractelement <2 x double> %517, i64 0
  %519 = load double, ptr %gep1026, align 8, !tbaa !18
  %520 = call { double, double } @Cd(ptr noundef nonnull %gep1026)
  %521 = extractvalue { double, double } %520, 1
  %522 = insertelement <2 x double> poison, double %519, i64 0
  %523 = insertelement <2 x double> %522, double %521, i64 1
  %524 = fcmp oge <2 x double> %523, zeroinitializer
  %525 = fneg <2 x double> %523
  %526 = select <2 x i1> %524, <2 x double> %523, <2 x double> %525
  %shift1082 = shufflevector <2 x double> %526, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %527 = fadd <2 x double> %526, %shift1082
  %528 = extractelement <2 x double> %527, i64 0
  %529 = call double @llvm.fmuladd.f64(double %518, double %528, double %508)
  %530 = getelementptr inbounds double, ptr %36, i64 %indvars.iv965
  store double %529, ptr %530, align 8, !tbaa !9
  %exitcond969.not = icmp eq i64 %indvars.iv.next966, %wide.trip.count968
  br i1 %exitcond969.not, label %._crit_edge923.loopexit, label %.lr.ph922, !llvm.loop !22

._crit_edge923.loopexit:                          ; preds = %.lr.ph922
  %.pre1001 = load i32, ptr %1, align 4, !tbaa !5
  br label %._crit_edge923

._crit_edge923:                                   ; preds = %._crit_edge923.loopexit, %364
  %531 = phi i32 [ %.pre1001, %._crit_edge923.loopexit ], [ %423, %364 ]
  %532 = sext i32 %531 to i64
  %533 = getelementptr %struct.doublecomplex, ptr %104, i64 %532
  %534 = load <2 x double>, ptr %533, align 8, !tbaa !9
  store <2 x double> %534, ptr %21, align 16, !tbaa !9
  %535 = add nsw i32 %531, -1
  %536 = sext i32 %535 to i64
  %537 = getelementptr inbounds %struct.doublecomplex, ptr %24, i64 %536
  %538 = load double, ptr %537, align 8, !tbaa !18
  %539 = getelementptr %struct.doublecomplex, ptr %105, i64 %536
  %540 = getelementptr inbounds i8, ptr %537, i64 8
  %541 = load double, ptr %540, align 8, !tbaa !20
  %542 = fneg double %541
  %543 = getelementptr inbounds double, ptr %23, i64 %532
  %544 = load double, ptr %543, align 8, !tbaa !9
  %545 = getelementptr %struct.doublecomplex, ptr %106, i64 %532
  %546 = load <2 x double>, ptr %545, align 8, !tbaa !9
  %547 = insertelement <2 x double> poison, double %544, i64 0
  %548 = shufflevector <2 x double> %547, <2 x double> poison, <2 x i32> zeroinitializer
  %549 = fmul <2 x double> %548, %546
  store <2 x double> %549, ptr %22, align 16, !tbaa !9
  %550 = load <2 x double>, ptr %539, align 8, !tbaa !9
  %551 = insertelement <2 x double> poison, double %541, i64 0
  %552 = insertelement <2 x double> %551, double %542, i64 1
  %553 = fmul <2 x double> %550, %552
  %554 = shufflevector <2 x double> %553, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %555 = insertelement <2 x double> poison, double %538, i64 0
  %556 = shufflevector <2 x double> %555, <2 x double> poison, <2 x i32> zeroinitializer
  %557 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %556, <2 x double> %550, <2 x double> %554)
  %558 = fsub <2 x double> %534, %557
  store <2 x double> %558, ptr %20, align 16, !tbaa !9
  %559 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %532
  %560 = fsub <2 x double> %558, %549
  store <2 x double> %560, ptr %559, align 8, !tbaa !9
  %561 = extractelement <2 x double> %534, i64 0
  %562 = fcmp oge double %561, 0.000000e+00
  %563 = fneg double %561
  %564 = select i1 %562, double %561, double %563
  %565 = call { double, double } @Cd(ptr noundef nonnull %21)
  %566 = extractvalue { double, double } %565, 1
  %567 = fcmp oge double %566, 0.000000e+00
  %568 = fneg double %566
  %569 = select i1 %567, double %566, double %568
  %570 = fadd double %564, %569
  %571 = load double, ptr %537, align 8, !tbaa !18
  %572 = load i32, ptr %1, align 4, !tbaa !5
  %573 = sext i32 %572 to i64
  %gep933 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %573
  %574 = call { double, double } @Cd(ptr noundef %gep933)
  %575 = extractvalue { double, double } %574, 1
  %576 = insertelement <2 x double> poison, double %571, i64 0
  %577 = insertelement <2 x double> %576, double %575, i64 1
  %578 = fcmp oge <2 x double> %577, zeroinitializer
  %579 = fneg <2 x double> %577
  %580 = select <2 x i1> %578, <2 x double> %577, <2 x double> %579
  %shift1083 = shufflevector <2 x double> %580, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %581 = fadd <2 x double> %580, %shift1083
  %582 = extractelement <2 x double> %581, i64 0
  %583 = load double, ptr %539, align 8, !tbaa !18
  %584 = load i32, ptr %1, align 4, !tbaa !5
  %585 = add i32 %100, %584
  %586 = sext i32 %585 to i64
  %587 = getelementptr inbounds %struct.doublecomplex, ptr %32, i64 %586
  %588 = call { double, double } @Cd(ptr noundef %587)
  %589 = extractvalue { double, double } %588, 1
  %590 = insertelement <2 x double> poison, double %583, i64 0
  %591 = insertelement <2 x double> %590, double %589, i64 1
  %592 = fcmp oge <2 x double> %591, zeroinitializer
  %593 = fneg <2 x double> %591
  %594 = select <2 x i1> %592, <2 x double> %591, <2 x double> %593
  %shift1084 = shufflevector <2 x double> %594, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %595 = fadd <2 x double> %594, %shift1084
  %596 = extractelement <2 x double> %595, i64 0
  %597 = call double @llvm.fmuladd.f64(double %582, double %596, double %570)
  %598 = load <2 x double>, ptr %22, align 16
  %599 = call { double, double } @Cd(ptr noundef nonnull %22)
  %600 = extractvalue { double, double } %599, 1
  %601 = insertelement <2 x double> %598, double %600, i64 1
  %602 = fcmp oge <2 x double> %601, zeroinitializer
  %603 = fneg <2 x double> %601
  %604 = select <2 x i1> %602, <2 x double> %601, <2 x double> %603
  %shift1085 = shufflevector <2 x double> %604, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %605 = fadd <2 x double> %604, %shift1085
  %606 = extractelement <2 x double> %605, i64 0
  %607 = fadd double %597, %606
  %608 = load i32, ptr %1, align 4, !tbaa !5
  %609 = sext i32 %608 to i64
  %610 = getelementptr inbounds double, ptr %36, i64 %609
  store double %607, ptr %610, align 8, !tbaa !9
  br label %628

thread-pre-split:                                 ; preds = %363, %116
  %611 = fsub <2 x double> %111, %115
  store <2 x double> %611, ptr %13, align 8, !tbaa !9
  %612 = call { double, double } @Cd(ptr noundef nonnull %21)
  %613 = extractvalue { double, double } %612, 1
  %.sink1046 = load double, ptr %22, align 16, !tbaa !18
  %614 = call { double, double } @Cd(ptr noundef nonnull %22)
  %615 = extractvalue { double, double } %614, 1
  %616 = insertelement <2 x double> %111, double %.sink1046, i64 1
  %617 = fcmp oge <2 x double> %616, zeroinitializer
  %618 = fneg <2 x double> %616
  %619 = select <2 x i1> %617, <2 x double> %616, <2 x double> %618
  %620 = insertelement <2 x double> poison, double %613, i64 0
  %621 = insertelement <2 x double> %620, double %615, i64 1
  %622 = fcmp oge <2 x double> %621, zeroinitializer
  %623 = fneg <2 x double> %621
  %624 = select <2 x i1> %622, <2 x double> %621, <2 x double> %623
  %625 = fadd <2 x double> %619, %624
  %shift1086 = shufflevector <2 x double> %625, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %626 = fadd <2 x double> %625, %shift1086
  %627 = extractelement <2 x double> %626, i64 0
  store double %627, ptr %14, align 8, !tbaa !9
  %.pr1008 = load i32, ptr %1, align 4, !tbaa !5
  br label %628

628:                                              ; preds = %thread-pre-split, %._crit_edge923, %._crit_edge
  %629 = phi i32 [ %.pr1008, %thread-pre-split ], [ %608, %._crit_edge923 ], [ %360, %._crit_edge ]
  %.not909924 = icmp slt i32 %629, 1
  br i1 %.not909924, label %._crit_edge929, label %.lr.ph928.preheader

.lr.ph928.preheader:                              ; preds = %628
  %630 = add nuw i32 %629, 1
  %wide.trip.count973 = zext i32 %630 to i64
  br label %.lr.ph928

.lr.ph928:                                        ; preds = %.lr.ph928.preheader, %653
  %indvars.iv970 = phi i64 [ 1, %.lr.ph928.preheader ], [ %indvars.iv.next971, %653 ]
  %.0894926 = phi double [ 0.000000e+00, %.lr.ph928.preheader ], [ %655, %653 ]
  %631 = getelementptr inbounds double, ptr %36, i64 %indvars.iv970
  %632 = load double, ptr %631, align 8, !tbaa !9
  %633 = fcmp ogt double %632, %86
  %634 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %indvars.iv970
  %635 = load double, ptr %634, align 8, !tbaa !18
  %636 = fcmp oge double %635, 0.000000e+00
  %637 = fneg double %635
  %638 = select i1 %636, double %635, double %637
  %639 = call { double, double } @Cd(ptr noundef nonnull %634)
  %640 = extractvalue { double, double } %639, 1
  %641 = fcmp oge double %640, 0.000000e+00
  %642 = fneg double %640
  %643 = select i1 %641, double %640, double %642
  %644 = fadd double %638, %643
  br i1 %633, label %645, label %648

645:                                              ; preds = %.lr.ph928
  %646 = load double, ptr %631, align 8, !tbaa !9
  %647 = fdiv double %644, %646
  br label %653

648:                                              ; preds = %.lr.ph928
  %649 = fadd double %85, %644
  %650 = load double, ptr %631, align 8, !tbaa !9
  %651 = fadd double %85, %650
  %652 = fdiv double %649, %651
  br label %653

653:                                              ; preds = %645, %648
  %.sink1049 = phi double [ %647, %645 ], [ %652, %648 ]
  %654 = fcmp oge double %.0894926, %.sink1049
  %655 = select i1 %654, double %.0894926, double %.sink1049
  %indvars.iv.next971 = add nuw nsw i64 %indvars.iv970, 1
  %exitcond974.not = icmp eq i64 %indvars.iv.next971, %wide.trip.count973
  br i1 %exitcond974.not, label %._crit_edge929, label %.lr.ph928, !llvm.loop !23

._crit_edge929:                                   ; preds = %653, %628
  %.0894.lcssa = phi double [ 0.000000e+00, %628 ], [ %655, %653 ]
  store double %.0894.lcssa, ptr %93, align 8, !tbaa !9
  %656 = fcmp ogt double %.0894.lcssa, %83
  br i1 %656, label %657, label %664

657:                                              ; preds = %._crit_edge929
  %658 = fmul double %.0894.lcssa, 2.000000e+00
  %659 = fcmp ole double %658, %.0
  %660 = icmp ult i32 %.0893, 6
  %or.cond = select i1 %659, i1 %660, i1 false
  br i1 %or.cond, label %661, label %664

661:                                              ; preds = %657
  call void @zpttrs_(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull @c__1, ptr noundef %5, ptr noundef %6, ptr noundef nonnull %13, ptr noundef nonnull %1, ptr noundef nonnull %15) #7
  call void @zaxpy_(ptr noundef nonnull %1, ptr noundef nonnull @c_b16, ptr noundef nonnull %13, ptr noundef nonnull @c__1, ptr noundef %gep935, ptr noundef nonnull @c__1) #7
  %662 = load double, ptr %93, align 8, !tbaa !9
  %663 = add nuw nsw i32 %.0893, 1
  br label %107

664:                                              ; preds = %657, %._crit_edge929
  %665 = load i32, ptr %1, align 4, !tbaa !5
  %.not910936 = icmp slt i32 %665, 1
  br i1 %.not910936, label %._crit_edge940, label %.lr.ph939.preheader

.lr.ph939.preheader:                              ; preds = %664
  %666 = add nuw i32 %665, 1
  %wide.trip.count978 = zext i32 %666 to i64
  br label %.lr.ph939

.lr.ph939:                                        ; preds = %.lr.ph939.preheader, %.lr.ph939
  %indvars.iv975 = phi i64 [ 1, %.lr.ph939.preheader ], [ %indvars.iv.next976, %.lr.ph939 ]
  %667 = getelementptr inbounds double, ptr %36, i64 %indvars.iv975
  %668 = load double, ptr %667, align 8, !tbaa !9
  %669 = fcmp ogt double %668, %86
  %670 = getelementptr inbounds %struct.doublecomplex, ptr %35, i64 %indvars.iv975
  %671 = load double, ptr %670, align 8, !tbaa !18
  %672 = call { double, double } @Cd(ptr noundef nonnull %670)
  %673 = extractvalue { double, double } %672, 1
  %674 = insertelement <2 x double> poison, double %671, i64 0
  %675 = insertelement <2 x double> %674, double %673, i64 1
  %676 = fcmp oge <2 x double> %675, zeroinitializer
  %677 = fneg <2 x double> %675
  %678 = select <2 x i1> %676, <2 x double> %675, <2 x double> %677
  %shift1087 = shufflevector <2 x double> %678, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %679 = fadd <2 x double> %678, %shift1087
  %680 = extractelement <2 x double> %679, i64 0
  %681 = load double, ptr %667, align 8, !tbaa !9
  %682 = call double @llvm.fmuladd.f64(double %90, double %681, double %680)
  %683 = fadd double %85, %682
  %storemerge = select i1 %669, double %682, double %683
  store double %storemerge, ptr %667, align 8, !tbaa !9
  %indvars.iv.next976 = add nuw nsw i64 %indvars.iv975, 1
  %exitcond979.not = icmp eq i64 %indvars.iv.next976, %wide.trip.count978
  br i1 %exitcond979.not, label %._crit_edge940, label %.lr.ph939, !llvm.loop !24

._crit_edge940:                                   ; preds = %.lr.ph939, %664
  %684 = call i32 @idamax_(ptr noundef nonnull %1, ptr noundef nonnull %14, ptr noundef nonnull @c__1) #7
  %685 = sext i32 %684 to i64
  %686 = getelementptr inbounds double, ptr %36, i64 %685
  %687 = load double, ptr %686, align 8, !tbaa !9
  %688 = getelementptr inbounds double, ptr %33, i64 %indvars.iv993
  store double %687, ptr %688, align 8, !tbaa !9
  store double 1.000000e+00, ptr %14, align 8, !tbaa !9
  %689 = load i32, ptr %1, align 4, !tbaa !5
  %.not911941 = icmp slt i32 %689, 2
  br i1 %.not911941, label %._crit_edge945.thread, label %.lr.ph944.preheader

._crit_edge945.thread:                            ; preds = %._crit_edge940
  %690 = sext i32 %689 to i64
  %691 = getelementptr inbounds double, ptr %25, i64 %690
  %692 = load double, ptr %691, align 8, !tbaa !9
  %693 = getelementptr inbounds double, ptr %36, i64 %690
  %694 = load double, ptr %693, align 8, !tbaa !9
  %695 = fdiv double %694, %692
  store double %695, ptr %693, align 8, !tbaa !9
  br label %._crit_edge949

.lr.ph944.preheader:                              ; preds = %._crit_edge940
  %696 = add nuw i32 %689, 1
  %wide.trip.count983 = zext i32 %696 to i64
  br label %.lr.ph944

.lr.ph944:                                        ; preds = %.lr.ph944.preheader, %.lr.ph944
  %697 = phi double [ 1.000000e+00, %.lr.ph944.preheader ], [ %702, %.lr.ph944 ]
  %indvars.iv980 = phi i64 [ 2, %.lr.ph944.preheader ], [ %indvars.iv.next981, %.lr.ph944 ]
  %gep1028 = getelementptr %struct.doublecomplex, ptr %invariant.gep1027, i64 %indvars.iv980
  %698 = call { double, double } @Cd(ptr noundef nonnull %gep1028)
  %699 = extractvalue { double, double } %698, 0
  %700 = extractvalue { double, double } %698, 1
  %701 = call double @cabs(double noundef %699, double noundef %700) #7
  %702 = call double @llvm.fmuladd.f64(double %697, double %701, double 1.000000e+00)
  %703 = getelementptr inbounds double, ptr %36, i64 %indvars.iv980
  store double %702, ptr %703, align 8, !tbaa !9
  %indvars.iv.next981 = add nuw nsw i64 %indvars.iv980, 1
  %exitcond984.not = icmp eq i64 %indvars.iv.next981, %wide.trip.count983
  br i1 %exitcond984.not, label %._crit_edge945, label %.lr.ph944, !llvm.loop !25

._crit_edge945:                                   ; preds = %.lr.ph944
  %.pre1003 = load i32, ptr %1, align 4, !tbaa !5
  %704 = sext i32 %.pre1003 to i64
  %705 = getelementptr inbounds double, ptr %25, i64 %704
  %706 = load double, ptr %705, align 8, !tbaa !9
  %707 = getelementptr inbounds double, ptr %36, i64 %704
  %708 = load double, ptr %707, align 8, !tbaa !9
  %709 = fdiv double %708, %706
  store double %709, ptr %707, align 8, !tbaa !9
  %710 = icmp sgt i32 %.pre1003, 1
  br i1 %710, label %.lr.ph948.preheader, label %._crit_edge949

.lr.ph948.preheader:                              ; preds = %._crit_edge945
  %711 = zext nneg i32 %.pre1003 to i64
  %.phi.trans.insert1004 = getelementptr inbounds double, ptr %36, i64 %711
  %.pre1005 = load double, ptr %.phi.trans.insert1004, align 8, !tbaa !9
  br label %.lr.ph948

.lr.ph948:                                        ; preds = %.lr.ph948.preheader, %.lr.ph948
  %712 = phi double [ %.pre1005, %.lr.ph948.preheader ], [ %723, %.lr.ph948 ]
  %indvars.iv985 = phi i64 [ %711, %.lr.ph948.preheader ], [ %indvars.iv.next986, %.lr.ph948 ]
  %indvars.iv.next986 = add nsw i64 %indvars.iv985, -1
  %713 = getelementptr inbounds double, ptr %36, i64 %indvars.iv.next986
  %714 = load double, ptr %713, align 8, !tbaa !9
  %715 = getelementptr inbounds double, ptr %25, i64 %indvars.iv.next986
  %716 = load double, ptr %715, align 8, !tbaa !9
  %717 = fdiv double %714, %716
  %718 = getelementptr inbounds %struct.doublecomplex, ptr %26, i64 %indvars.iv.next986
  %719 = call { double, double } @Cd(ptr noundef nonnull %718)
  %720 = extractvalue { double, double } %719, 0
  %721 = extractvalue { double, double } %719, 1
  %722 = call double @cabs(double noundef %720, double noundef %721) #7
  %723 = call double @llvm.fmuladd.f64(double %712, double %722, double %717)
  store double %723, ptr %713, align 8, !tbaa !9
  %724 = icmp ugt i64 %indvars.iv985, 2
  br i1 %724, label %.lr.ph948, label %._crit_edge949, !llvm.loop !26

._crit_edge949:                                   ; preds = %.lr.ph948, %._crit_edge945.thread, %._crit_edge945
  %725 = call i32 @idamax_(ptr noundef nonnull %1, ptr noundef nonnull %14, ptr noundef nonnull @c__1) #7
  %726 = sext i32 %725 to i64
  %727 = getelementptr inbounds double, ptr %36, i64 %726
  %728 = load double, ptr %727, align 8, !tbaa !9
  %729 = fcmp oge double %728, 0.000000e+00
  %730 = fneg double %728
  %731 = select i1 %729, double %728, double %730
  %732 = load double, ptr %688, align 8, !tbaa !9
  %733 = fmul double %732, %731
  store double %733, ptr %688, align 8, !tbaa !9
  %734 = load i32, ptr %1, align 4, !tbaa !5
  %.not912950 = icmp slt i32 %734, 1
  br i1 %.not912950, label %._crit_edge955.thread, label %.lr.ph954

.lr.ph954:                                        ; preds = %._crit_edge949
  %735 = add nuw i32 %734, 1
  %wide.trip.count991 = zext i32 %735 to i64
  %invariant.gep1029 = getelementptr %struct.doublecomplex, ptr %32, i64 %95
  br label %736

736:                                              ; preds = %.lr.ph954, %736
  %indvars.iv988 = phi i64 [ 1, %.lr.ph954 ], [ %indvars.iv.next989, %736 ]
  %.1952 = phi double [ 0.000000e+00, %.lr.ph954 ], [ %742, %736 ]
  %gep1030 = getelementptr %struct.doublecomplex, ptr %invariant.gep1029, i64 %indvars.iv988
  %737 = call { double, double } @Cd(ptr noundef %gep1030)
  %738 = extractvalue { double, double } %737, 0
  %739 = extractvalue { double, double } %737, 1
  %740 = call double @cabs(double noundef %738, double noundef %739) #7
  %741 = fcmp oge double %.1952, %740
  %742 = select i1 %741, double %.1952, double %740
  %indvars.iv.next989 = add nuw nsw i64 %indvars.iv988, 1
  %exitcond992.not = icmp eq i64 %indvars.iv.next989, %wide.trip.count991
  br i1 %exitcond992.not, label %._crit_edge955, label %736, !llvm.loop !27

._crit_edge955:                                   ; preds = %736
  %743 = fcmp une double %742, 0.000000e+00
  br i1 %743, label %744, label %._crit_edge955.thread

744:                                              ; preds = %._crit_edge955
  %745 = load double, ptr %688, align 8, !tbaa !9
  %746 = fdiv double %745, %742
  store double %746, ptr %688, align 8, !tbaa !9
  br label %._crit_edge955.thread

._crit_edge955.thread:                            ; preds = %._crit_edge949, %._crit_edge955, %744
  %indvars.iv.next994 = add nuw nsw i64 %indvars.iv993, 1
  %747 = load i32, ptr %19, align 4, !tbaa !5
  %748 = sext i32 %747 to i64
  %.not906.not = icmp slt i64 %indvars.iv993, %748
  br i1 %.not906.not, label %.preheader, label %.loopexit, !llvm.loop !28

.loopexit:                                        ; preds = %._crit_edge955.thread, %.lr.ph962.prol.loopexit, %.lr.ph962, %middle.block, %58, %82, %59, %.thread
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %22) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %21) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %20) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %19) #7
  ret void
}

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

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

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

declare double @dlamch_(ptr noundef) local_unnamed_addr #2

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

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

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

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

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

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

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

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

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

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

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

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

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


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