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

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

%struct.doublecomplex = type { double, double }

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

52:                                               ; preds = %6
  %53 = load ptr, ptr %7, align 8, !tbaa !5
  %54 = load i32, ptr %53, align 4, !tbaa !9
  %55 = icmp ne i32 %54, 3
  br i1 %55, label %56, label %57

56:                                               ; preds = %52
  store i32 1, ptr %36, align 4
  br label %1132

57:                                               ; preds = %52, %6
  %58 = load ptr, ptr %7, align 8, !tbaa !5
  %59 = load i32, ptr %58, align 4, !tbaa !9
  %60 = icmp eq i32 %59, 2
  br i1 %60, label %61, label %434

61:                                               ; preds = %57
  %62 = load i32, ptr %13, align 4, !tbaa !9
  %63 = add nsw i32 %62, 1
  store i32 %63, ptr %15, align 4, !tbaa !9
  %64 = load ptr, ptr %8, align 8, !tbaa !5
  %65 = load i32, ptr %15, align 4, !tbaa !9
  %66 = sext i32 %65 to i64
  %67 = getelementptr inbounds %struct.doublecomplex, ptr %64, i64 %66
  %68 = getelementptr inbounds %struct.doublecomplex, ptr %67, i32 0, i32 0
  %69 = load double, ptr %68, align 8, !tbaa !11
  %70 = load ptr, ptr %11, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.doublecomplex, ptr %70, i32 0, i32 0
  %72 = load double, ptr %71, align 8, !tbaa !11
  %73 = fsub double %69, %72
  %74 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %73, ptr %74, align 8, !tbaa !11
  %75 = load ptr, ptr %8, align 8, !tbaa !5
  %76 = load i32, ptr %15, align 4, !tbaa !9
  %77 = sext i32 %76 to i64
  %78 = getelementptr inbounds %struct.doublecomplex, ptr %75, i64 %77
  %79 = getelementptr inbounds %struct.doublecomplex, ptr %78, i32 0, i32 1
  %80 = load double, ptr %79, align 8, !tbaa !14
  %81 = load ptr, ptr %11, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.doublecomplex, ptr %81, i32 0, i32 1
  %83 = load double, ptr %82, align 8, !tbaa !14
  %84 = fsub double %80, %83
  %85 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %84, ptr %85, align 8, !tbaa !14
  %86 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %87 = load double, ptr %86, align 8, !tbaa !11
  %88 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %87, ptr %88, align 8, !tbaa !11
  %89 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %90 = load double, ptr %89, align 8, !tbaa !14
  %91 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %90, ptr %91, align 8, !tbaa !14
  %92 = load i32, ptr %13, align 4, !tbaa !9
  %93 = add nsw i32 %92, 2
  store i32 %93, ptr %16, align 4, !tbaa !9
  %94 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %95 = load double, ptr %94, align 8, !tbaa !11
  store double %95, ptr %19, align 8, !tbaa !15
  %96 = load double, ptr %19, align 8, !tbaa !15
  %97 = fcmp oge double %96, 0.000000e+00
  br i1 %97, label %98, label %100

98:                                               ; preds = %61
  %99 = load double, ptr %19, align 8, !tbaa !15
  br label %103

100:                                              ; preds = %61
  %101 = load double, ptr %19, align 8, !tbaa !15
  %102 = fneg double %101
  br label %103

103:                                              ; preds = %100, %98
  %104 = phi double [ %99, %98 ], [ %102, %100 ]
  %105 = call { double, double } @Cd(ptr noundef %25)
  %106 = extractvalue { double, double } %105, 0
  %107 = extractvalue { double, double } %105, 1
  store double %107, ptr %20, align 8, !tbaa !15
  %108 = load double, ptr %20, align 8, !tbaa !15
  %109 = fcmp oge double %108, 0.000000e+00
  br i1 %109, label %110, label %112

110:                                              ; preds = %103
  %111 = load double, ptr %20, align 8, !tbaa !15
  br label %115

112:                                              ; preds = %103
  %113 = load double, ptr %20, align 8, !tbaa !15
  %114 = fneg double %113
  br label %115

115:                                              ; preds = %112, %110
  %116 = phi double [ %111, %110 ], [ %114, %112 ]
  %117 = fadd double %104, %116
  %118 = load ptr, ptr %8, align 8, !tbaa !5
  %119 = load i32, ptr %16, align 4, !tbaa !9
  %120 = sext i32 %119 to i64
  %121 = getelementptr inbounds %struct.doublecomplex, ptr %118, i64 %120
  %122 = getelementptr inbounds %struct.doublecomplex, ptr %121, i32 0, i32 0
  %123 = load double, ptr %122, align 8, !tbaa !11
  store double %123, ptr %21, align 8, !tbaa !15
  %124 = load double, ptr %21, align 8, !tbaa !15
  %125 = fcmp oge double %124, 0.000000e+00
  br i1 %125, label %126, label %128

126:                                              ; preds = %115
  %127 = load double, ptr %21, align 8, !tbaa !15
  br label %131

128:                                              ; preds = %115
  %129 = load double, ptr %21, align 8, !tbaa !15
  %130 = fneg double %129
  br label %131

131:                                              ; preds = %128, %126
  %132 = phi double [ %127, %126 ], [ %130, %128 ]
  %133 = load ptr, ptr %8, align 8, !tbaa !5
  %134 = load i32, ptr %13, align 4, !tbaa !9
  %135 = add nsw i32 %134, 2
  %136 = sext i32 %135 to i64
  %137 = getelementptr inbounds %struct.doublecomplex, ptr %133, i64 %136
  %138 = call { double, double } @Cd(ptr noundef %137)
  %139 = extractvalue { double, double } %138, 0
  %140 = extractvalue { double, double } %138, 1
  store double %140, ptr %22, align 8, !tbaa !15
  %141 = load double, ptr %22, align 8, !tbaa !15
  %142 = fcmp oge double %141, 0.000000e+00
  br i1 %142, label %143, label %145

143:                                              ; preds = %131
  %144 = load double, ptr %22, align 8, !tbaa !15
  br label %148

145:                                              ; preds = %131
  %146 = load double, ptr %22, align 8, !tbaa !15
  %147 = fneg double %146
  br label %148

148:                                              ; preds = %145, %143
  %149 = phi double [ %144, %143 ], [ %147, %145 ]
  %150 = fadd double %132, %149
  %151 = fadd double %117, %150
  store double %151, ptr %33, align 8, !tbaa !15
  %152 = load double, ptr %33, align 8, !tbaa !15
  %153 = fcmp oeq double %152, 0.000000e+00
  br i1 %153, label %154, label %167

154:                                              ; preds = %148
  %155 = load ptr, ptr %12, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.doublecomplex, ptr %155, i64 1
  %157 = getelementptr inbounds %struct.doublecomplex, ptr %156, i32 0, i32 0
  store double 0.000000e+00, ptr %157, align 8, !tbaa !11
  %158 = load ptr, ptr %12, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.doublecomplex, ptr %158, i64 1
  %160 = getelementptr inbounds %struct.doublecomplex, ptr %159, i32 0, i32 1
  store double 0.000000e+00, ptr %160, align 8, !tbaa !14
  %161 = load ptr, ptr %12, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.doublecomplex, ptr %161, i64 2
  %163 = getelementptr inbounds %struct.doublecomplex, ptr %162, i32 0, i32 0
  store double 0.000000e+00, ptr %163, align 8, !tbaa !11
  %164 = load ptr, ptr %12, align 8, !tbaa !5
  %165 = getelementptr inbounds %struct.doublecomplex, ptr %164, i64 2
  %166 = getelementptr inbounds %struct.doublecomplex, ptr %165, i32 0, i32 1
  store double 0.000000e+00, ptr %166, align 8, !tbaa !14
  br label %433

167:                                              ; preds = %148
  %168 = load i32, ptr %13, align 4, !tbaa !9
  %169 = add nsw i32 %168, 2
  store i32 %169, ptr %15, align 4, !tbaa !9
  %170 = load ptr, ptr %8, align 8, !tbaa !5
  %171 = load i32, ptr %15, align 4, !tbaa !9
  %172 = sext i32 %171 to i64
  %173 = getelementptr inbounds %struct.doublecomplex, ptr %170, i64 %172
  %174 = getelementptr inbounds %struct.doublecomplex, ptr %173, i32 0, i32 0
  %175 = load double, ptr %174, align 8, !tbaa !11
  %176 = load double, ptr %33, align 8, !tbaa !15
  %177 = fdiv double %175, %176
  %178 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %177, ptr %178, align 8, !tbaa !11
  %179 = load ptr, ptr %8, align 8, !tbaa !5
  %180 = load i32, ptr %15, align 4, !tbaa !9
  %181 = sext i32 %180 to i64
  %182 = getelementptr inbounds %struct.doublecomplex, ptr %179, i64 %181
  %183 = getelementptr inbounds %struct.doublecomplex, ptr %182, i32 0, i32 1
  %184 = load double, ptr %183, align 8, !tbaa !14
  %185 = load double, ptr %33, align 8, !tbaa !15
  %186 = fdiv double %184, %185
  %187 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %186, ptr %187, align 8, !tbaa !14
  %188 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %189 = load double, ptr %188, align 8, !tbaa !11
  %190 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %189, ptr %190, align 8, !tbaa !11
  %191 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %192 = load double, ptr %191, align 8, !tbaa !14
  %193 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %192, ptr %193, align 8, !tbaa !14
  %194 = load i32, ptr %13, align 4, !tbaa !9
  %195 = shl i32 %194, 1
  %196 = add nsw i32 %195, 1
  store i32 %196, ptr %15, align 4, !tbaa !9
  %197 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %198 = load double, ptr %197, align 8, !tbaa !11
  %199 = load ptr, ptr %8, align 8, !tbaa !5
  %200 = load i32, ptr %15, align 4, !tbaa !9
  %201 = sext i32 %200 to i64
  %202 = getelementptr inbounds %struct.doublecomplex, ptr %199, i64 %201
  %203 = getelementptr inbounds %struct.doublecomplex, ptr %202, i32 0, i32 0
  %204 = load double, ptr %203, align 8, !tbaa !11
  %205 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %206 = load double, ptr %205, align 8, !tbaa !14
  %207 = load ptr, ptr %8, align 8, !tbaa !5
  %208 = load i32, ptr %15, align 4, !tbaa !9
  %209 = sext i32 %208 to i64
  %210 = getelementptr inbounds %struct.doublecomplex, ptr %207, i64 %209
  %211 = getelementptr inbounds %struct.doublecomplex, ptr %210, i32 0, i32 1
  %212 = load double, ptr %211, align 8, !tbaa !14
  %213 = fmul double %206, %212
  %214 = fneg double %213
  %215 = call double @llvm.fmuladd.f64(double %198, double %204, double %214)
  %216 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %215, ptr %216, align 8, !tbaa !11
  %217 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %218 = load double, ptr %217, align 8, !tbaa !11
  %219 = load ptr, ptr %8, align 8, !tbaa !5
  %220 = load i32, ptr %15, align 4, !tbaa !9
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds %struct.doublecomplex, ptr %219, i64 %221
  %223 = getelementptr inbounds %struct.doublecomplex, ptr %222, i32 0, i32 1
  %224 = load double, ptr %223, align 8, !tbaa !14
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %226 = load double, ptr %225, align 8, !tbaa !14
  %227 = load ptr, ptr %8, align 8, !tbaa !5
  %228 = load i32, ptr %15, align 4, !tbaa !9
  %229 = sext i32 %228 to i64
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %227, i64 %229
  %231 = getelementptr inbounds %struct.doublecomplex, ptr %230, i32 0, i32 0
  %232 = load double, ptr %231, align 8, !tbaa !11
  %233 = fmul double %226, %232
  %234 = call double @llvm.fmuladd.f64(double %218, double %224, double %233)
  %235 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %234, ptr %235, align 8, !tbaa !14
  %236 = load i32, ptr %13, align 4, !tbaa !9
  %237 = add nsw i32 %236, 1
  store i32 %237, ptr %16, align 4, !tbaa !9
  %238 = load ptr, ptr %8, align 8, !tbaa !5
  %239 = load i32, ptr %16, align 4, !tbaa !9
  %240 = sext i32 %239 to i64
  %241 = getelementptr inbounds %struct.doublecomplex, ptr %238, i64 %240
  %242 = getelementptr inbounds %struct.doublecomplex, ptr %241, i32 0, i32 0
  %243 = load double, ptr %242, align 8, !tbaa !11
  %244 = load ptr, ptr %10, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.doublecomplex, ptr %244, i32 0, i32 0
  %246 = load double, ptr %245, align 8, !tbaa !11
  %247 = fsub double %243, %246
  %248 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %247, ptr %248, align 8, !tbaa !11
  %249 = load ptr, ptr %8, align 8, !tbaa !5
  %250 = load i32, ptr %16, align 4, !tbaa !9
  %251 = sext i32 %250 to i64
  %252 = getelementptr inbounds %struct.doublecomplex, ptr %249, i64 %251
  %253 = getelementptr inbounds %struct.doublecomplex, ptr %252, i32 0, i32 1
  %254 = load double, ptr %253, align 8, !tbaa !14
  %255 = load ptr, ptr %10, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.doublecomplex, ptr %255, i32 0, i32 1
  %257 = load double, ptr %256, align 8, !tbaa !14
  %258 = fsub double %254, %257
  %259 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %258, ptr %259, align 8, !tbaa !14
  %260 = load i32, ptr %13, align 4, !tbaa !9
  %261 = add nsw i32 %260, 1
  store i32 %261, ptr %17, align 4, !tbaa !9
  %262 = load ptr, ptr %8, align 8, !tbaa !5
  %263 = load i32, ptr %17, align 4, !tbaa !9
  %264 = sext i32 %263 to i64
  %265 = getelementptr inbounds %struct.doublecomplex, ptr %262, i64 %264
  %266 = getelementptr inbounds %struct.doublecomplex, ptr %265, i32 0, i32 0
  %267 = load double, ptr %266, align 8, !tbaa !11
  %268 = load ptr, ptr %11, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %268, i32 0, i32 0
  %270 = load double, ptr %269, align 8, !tbaa !11
  %271 = fsub double %267, %270
  %272 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %271, ptr %272, align 8, !tbaa !11
  %273 = load ptr, ptr %8, align 8, !tbaa !5
  %274 = load i32, ptr %17, align 4, !tbaa !9
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds %struct.doublecomplex, ptr %273, i64 %275
  %277 = getelementptr inbounds %struct.doublecomplex, ptr %276, i32 0, i32 1
  %278 = load double, ptr %277, align 8, !tbaa !14
  %279 = load ptr, ptr %11, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %279, i32 0, i32 1
  %281 = load double, ptr %280, align 8, !tbaa !14
  %282 = fsub double %278, %281
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %282, ptr %283, align 8, !tbaa !14
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %285 = load double, ptr %284, align 8, !tbaa !11
  %286 = load double, ptr %33, align 8, !tbaa !15
  %287 = fdiv double %285, %286
  %288 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %287, ptr %288, align 8, !tbaa !11
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %290 = load double, ptr %289, align 8, !tbaa !14
  %291 = load double, ptr %33, align 8, !tbaa !15
  %292 = fdiv double %290, %291
  %293 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %292, ptr %293, align 8, !tbaa !14
  %294 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %295 = load double, ptr %294, align 8, !tbaa !11
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %297 = load double, ptr %296, align 8, !tbaa !11
  %298 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %299 = load double, ptr %298, align 8, !tbaa !14
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %301 = load double, ptr %300, align 8, !tbaa !14
  %302 = fmul double %299, %301
  %303 = fneg double %302
  %304 = call double @llvm.fmuladd.f64(double %295, double %297, double %303)
  %305 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %304, ptr %305, align 8, !tbaa !11
  %306 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %307 = load double, ptr %306, align 8, !tbaa !11
  %308 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %309 = load double, ptr %308, align 8, !tbaa !14
  %310 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %311 = load double, ptr %310, align 8, !tbaa !14
  %312 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %313 = load double, ptr %312, align 8, !tbaa !11
  %314 = fmul double %311, %313
  %315 = call double @llvm.fmuladd.f64(double %307, double %309, double %314)
  %316 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %315, ptr %316, align 8, !tbaa !14
  %317 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %318 = load double, ptr %317, align 8, !tbaa !11
  %319 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %320 = load double, ptr %319, align 8, !tbaa !11
  %321 = fadd double %318, %320
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %321, ptr %322, align 8, !tbaa !11
  %323 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %324 = load double, ptr %323, align 8, !tbaa !14
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %326 = load double, ptr %325, align 8, !tbaa !14
  %327 = fadd double %324, %326
  %328 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %327, ptr %328, align 8, !tbaa !14
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %330 = load double, ptr %329, align 8, !tbaa !11
  %331 = load ptr, ptr %12, align 8, !tbaa !5
  %332 = getelementptr inbounds %struct.doublecomplex, ptr %331, i64 1
  %333 = getelementptr inbounds %struct.doublecomplex, ptr %332, i32 0, i32 0
  store double %330, ptr %333, align 8, !tbaa !11
  %334 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %335 = load double, ptr %334, align 8, !tbaa !14
  %336 = load ptr, ptr %12, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.doublecomplex, ptr %336, i64 1
  %338 = getelementptr inbounds %struct.doublecomplex, ptr %337, i32 0, i32 1
  store double %335, ptr %338, align 8, !tbaa !14
  %339 = load i32, ptr %13, align 4, !tbaa !9
  %340 = add nsw i32 %339, 1
  store i32 %340, ptr %15, align 4, !tbaa !9
  %341 = load i32, ptr %13, align 4, !tbaa !9
  %342 = shl i32 %341, 1
  %343 = add nsw i32 %342, 2
  store i32 %343, ptr %16, align 4, !tbaa !9
  %344 = load ptr, ptr %8, align 8, !tbaa !5
  %345 = load i32, ptr %15, align 4, !tbaa !9
  %346 = sext i32 %345 to i64
  %347 = getelementptr inbounds %struct.doublecomplex, ptr %344, i64 %346
  %348 = getelementptr inbounds %struct.doublecomplex, ptr %347, i32 0, i32 0
  %349 = load double, ptr %348, align 8, !tbaa !11
  %350 = load ptr, ptr %8, align 8, !tbaa !5
  %351 = load i32, ptr %16, align 4, !tbaa !9
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds %struct.doublecomplex, ptr %350, i64 %352
  %354 = getelementptr inbounds %struct.doublecomplex, ptr %353, i32 0, i32 0
  %355 = load double, ptr %354, align 8, !tbaa !11
  %356 = fadd double %349, %355
  %357 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %356, ptr %357, align 8, !tbaa !11
  %358 = load ptr, ptr %8, align 8, !tbaa !5
  %359 = load i32, ptr %15, align 4, !tbaa !9
  %360 = sext i32 %359 to i64
  %361 = getelementptr inbounds %struct.doublecomplex, ptr %358, i64 %360
  %362 = getelementptr inbounds %struct.doublecomplex, ptr %361, i32 0, i32 1
  %363 = load double, ptr %362, align 8, !tbaa !14
  %364 = load ptr, ptr %8, align 8, !tbaa !5
  %365 = load i32, ptr %16, align 4, !tbaa !9
  %366 = sext i32 %365 to i64
  %367 = getelementptr inbounds %struct.doublecomplex, ptr %364, i64 %366
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %367, i32 0, i32 1
  %369 = load double, ptr %368, align 8, !tbaa !14
  %370 = fadd double %363, %369
  %371 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %370, ptr %371, align 8, !tbaa !14
  %372 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %373 = load double, ptr %372, align 8, !tbaa !11
  %374 = load ptr, ptr %10, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.doublecomplex, ptr %374, i32 0, i32 0
  %376 = load double, ptr %375, align 8, !tbaa !11
  %377 = fsub double %373, %376
  %378 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %377, ptr %378, align 8, !tbaa !11
  %379 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %380 = load double, ptr %379, align 8, !tbaa !14
  %381 = load ptr, ptr %10, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.doublecomplex, ptr %381, i32 0, i32 1
  %383 = load double, ptr %382, align 8, !tbaa !14
  %384 = fsub double %380, %383
  %385 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %384, ptr %385, align 8, !tbaa !14
  %386 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %387 = load double, ptr %386, align 8, !tbaa !11
  %388 = load ptr, ptr %11, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %388, i32 0, i32 0
  %390 = load double, ptr %389, align 8, !tbaa !11
  %391 = fsub double %387, %390
  %392 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %391, ptr %392, align 8, !tbaa !11
  %393 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %394 = load double, ptr %393, align 8, !tbaa !14
  %395 = load ptr, ptr %11, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %395, i32 0, i32 1
  %397 = load double, ptr %396, align 8, !tbaa !14
  %398 = fsub double %394, %397
  %399 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %398, ptr %399, align 8, !tbaa !14
  %400 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %401 = load double, ptr %400, align 8, !tbaa !11
  %402 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %403 = load double, ptr %402, align 8, !tbaa !11
  %404 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %405 = load double, ptr %404, align 8, !tbaa !14
  %406 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %407 = load double, ptr %406, align 8, !tbaa !14
  %408 = fmul double %405, %407
  %409 = fneg double %408
  %410 = call double @llvm.fmuladd.f64(double %401, double %403, double %409)
  %411 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %410, ptr %411, align 8, !tbaa !11
  %412 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %413 = load double, ptr %412, align 8, !tbaa !11
  %414 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %415 = load double, ptr %414, align 8, !tbaa !14
  %416 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %417 = load double, ptr %416, align 8, !tbaa !14
  %418 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %419 = load double, ptr %418, align 8, !tbaa !11
  %420 = fmul double %417, %419
  %421 = call double @llvm.fmuladd.f64(double %413, double %415, double %420)
  %422 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %421, ptr %422, align 8, !tbaa !14
  %423 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %424 = load double, ptr %423, align 8, !tbaa !11
  %425 = load ptr, ptr %12, align 8, !tbaa !5
  %426 = getelementptr inbounds %struct.doublecomplex, ptr %425, i64 2
  %427 = getelementptr inbounds %struct.doublecomplex, ptr %426, i32 0, i32 0
  store double %424, ptr %427, align 8, !tbaa !11
  %428 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %429 = load double, ptr %428, align 8, !tbaa !14
  %430 = load ptr, ptr %12, align 8, !tbaa !5
  %431 = getelementptr inbounds %struct.doublecomplex, ptr %430, i64 2
  %432 = getelementptr inbounds %struct.doublecomplex, ptr %431, i32 0, i32 1
  store double %429, ptr %432, align 8, !tbaa !14
  br label %433

433:                                              ; preds = %167, %154
  br label %1131

434:                                              ; preds = %57
  %435 = load i32, ptr %13, align 4, !tbaa !9
  %436 = add nsw i32 %435, 1
  store i32 %436, ptr %15, align 4, !tbaa !9
  %437 = load ptr, ptr %8, align 8, !tbaa !5
  %438 = load i32, ptr %15, align 4, !tbaa !9
  %439 = sext i32 %438 to i64
  %440 = getelementptr inbounds %struct.doublecomplex, ptr %437, i64 %439
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %440, i32 0, i32 0
  %442 = load double, ptr %441, align 8, !tbaa !11
  %443 = load ptr, ptr %11, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.doublecomplex, ptr %443, i32 0, i32 0
  %445 = load double, ptr %444, align 8, !tbaa !11
  %446 = fsub double %442, %445
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %446, ptr %447, align 8, !tbaa !11
  %448 = load ptr, ptr %8, align 8, !tbaa !5
  %449 = load i32, ptr %15, align 4, !tbaa !9
  %450 = sext i32 %449 to i64
  %451 = getelementptr inbounds %struct.doublecomplex, ptr %448, i64 %450
  %452 = getelementptr inbounds %struct.doublecomplex, ptr %451, i32 0, i32 1
  %453 = load double, ptr %452, align 8, !tbaa !14
  %454 = load ptr, ptr %11, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.doublecomplex, ptr %454, i32 0, i32 1
  %456 = load double, ptr %455, align 8, !tbaa !14
  %457 = fsub double %453, %456
  %458 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %457, ptr %458, align 8, !tbaa !14
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %460 = load double, ptr %459, align 8, !tbaa !11
  %461 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %460, ptr %461, align 8, !tbaa !11
  %462 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %463 = load double, ptr %462, align 8, !tbaa !14
  %464 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %463, ptr %464, align 8, !tbaa !14
  %465 = load i32, ptr %13, align 4, !tbaa !9
  %466 = add nsw i32 %465, 2
  store i32 %466, ptr %16, align 4, !tbaa !9
  %467 = load i32, ptr %13, align 4, !tbaa !9
  %468 = add nsw i32 %467, 3
  store i32 %468, ptr %17, align 4, !tbaa !9
  %469 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %470 = load double, ptr %469, align 8, !tbaa !11
  store double %470, ptr %19, align 8, !tbaa !15
  %471 = load double, ptr %19, align 8, !tbaa !15
  %472 = fcmp oge double %471, 0.000000e+00
  br i1 %472, label %473, label %475

473:                                              ; preds = %434
  %474 = load double, ptr %19, align 8, !tbaa !15
  br label %478

475:                                              ; preds = %434
  %476 = load double, ptr %19, align 8, !tbaa !15
  %477 = fneg double %476
  br label %478

478:                                              ; preds = %475, %473
  %479 = phi double [ %474, %473 ], [ %477, %475 ]
  %480 = call { double, double } @Cd(ptr noundef %25)
  %481 = extractvalue { double, double } %480, 0
  %482 = extractvalue { double, double } %480, 1
  store double %482, ptr %20, align 8, !tbaa !15
  %483 = load double, ptr %20, align 8, !tbaa !15
  %484 = fcmp oge double %483, 0.000000e+00
  br i1 %484, label %485, label %487

485:                                              ; preds = %478
  %486 = load double, ptr %20, align 8, !tbaa !15
  br label %490

487:                                              ; preds = %478
  %488 = load double, ptr %20, align 8, !tbaa !15
  %489 = fneg double %488
  br label %490

490:                                              ; preds = %487, %485
  %491 = phi double [ %486, %485 ], [ %489, %487 ]
  %492 = fadd double %479, %491
  %493 = load ptr, ptr %8, align 8, !tbaa !5
  %494 = load i32, ptr %16, align 4, !tbaa !9
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds %struct.doublecomplex, ptr %493, i64 %495
  %497 = getelementptr inbounds %struct.doublecomplex, ptr %496, i32 0, i32 0
  %498 = load double, ptr %497, align 8, !tbaa !11
  store double %498, ptr %21, align 8, !tbaa !15
  %499 = load double, ptr %21, align 8, !tbaa !15
  %500 = fcmp oge double %499, 0.000000e+00
  br i1 %500, label %501, label %503

501:                                              ; preds = %490
  %502 = load double, ptr %21, align 8, !tbaa !15
  br label %506

503:                                              ; preds = %490
  %504 = load double, ptr %21, align 8, !tbaa !15
  %505 = fneg double %504
  br label %506

506:                                              ; preds = %503, %501
  %507 = phi double [ %502, %501 ], [ %505, %503 ]
  %508 = load ptr, ptr %8, align 8, !tbaa !5
  %509 = load i32, ptr %13, align 4, !tbaa !9
  %510 = add nsw i32 %509, 2
  %511 = sext i32 %510 to i64
  %512 = getelementptr inbounds %struct.doublecomplex, ptr %508, i64 %511
  %513 = call { double, double } @Cd(ptr noundef %512)
  %514 = extractvalue { double, double } %513, 0
  %515 = extractvalue { double, double } %513, 1
  store double %515, ptr %22, align 8, !tbaa !15
  %516 = load double, ptr %22, align 8, !tbaa !15
  %517 = fcmp oge double %516, 0.000000e+00
  br i1 %517, label %518, label %520

518:                                              ; preds = %506
  %519 = load double, ptr %22, align 8, !tbaa !15
  br label %523

520:                                              ; preds = %506
  %521 = load double, ptr %22, align 8, !tbaa !15
  %522 = fneg double %521
  br label %523

523:                                              ; preds = %520, %518
  %524 = phi double [ %519, %518 ], [ %522, %520 ]
  %525 = fadd double %507, %524
  %526 = fadd double %492, %525
  %527 = load ptr, ptr %8, align 8, !tbaa !5
  %528 = load i32, ptr %17, align 4, !tbaa !9
  %529 = sext i32 %528 to i64
  %530 = getelementptr inbounds %struct.doublecomplex, ptr %527, i64 %529
  %531 = getelementptr inbounds %struct.doublecomplex, ptr %530, i32 0, i32 0
  %532 = load double, ptr %531, align 8, !tbaa !11
  store double %532, ptr %23, align 8, !tbaa !15
  %533 = load double, ptr %23, align 8, !tbaa !15
  %534 = fcmp oge double %533, 0.000000e+00
  br i1 %534, label %535, label %537

535:                                              ; preds = %523
  %536 = load double, ptr %23, align 8, !tbaa !15
  br label %540

537:                                              ; preds = %523
  %538 = load double, ptr %23, align 8, !tbaa !15
  %539 = fneg double %538
  br label %540

540:                                              ; preds = %537, %535
  %541 = phi double [ %536, %535 ], [ %539, %537 ]
  %542 = load ptr, ptr %8, align 8, !tbaa !5
  %543 = load i32, ptr %13, align 4, !tbaa !9
  %544 = add nsw i32 %543, 3
  %545 = sext i32 %544 to i64
  %546 = getelementptr inbounds %struct.doublecomplex, ptr %542, i64 %545
  %547 = call { double, double } @Cd(ptr noundef %546)
  %548 = extractvalue { double, double } %547, 0
  %549 = extractvalue { double, double } %547, 1
  store double %549, ptr %24, align 8, !tbaa !15
  %550 = load double, ptr %24, align 8, !tbaa !15
  %551 = fcmp oge double %550, 0.000000e+00
  br i1 %551, label %552, label %554

552:                                              ; preds = %540
  %553 = load double, ptr %24, align 8, !tbaa !15
  br label %557

554:                                              ; preds = %540
  %555 = load double, ptr %24, align 8, !tbaa !15
  %556 = fneg double %555
  br label %557

557:                                              ; preds = %554, %552
  %558 = phi double [ %553, %552 ], [ %556, %554 ]
  %559 = fadd double %541, %558
  %560 = fadd double %526, %559
  store double %560, ptr %33, align 8, !tbaa !15
  %561 = load double, ptr %33, align 8, !tbaa !15
  %562 = fcmp oeq double %561, 0.000000e+00
  br i1 %562, label %563, label %582

563:                                              ; preds = %557
  %564 = load ptr, ptr %12, align 8, !tbaa !5
  %565 = getelementptr inbounds %struct.doublecomplex, ptr %564, i64 1
  %566 = getelementptr inbounds %struct.doublecomplex, ptr %565, i32 0, i32 0
  store double 0.000000e+00, ptr %566, align 8, !tbaa !11
  %567 = load ptr, ptr %12, align 8, !tbaa !5
  %568 = getelementptr inbounds %struct.doublecomplex, ptr %567, i64 1
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %568, i32 0, i32 1
  store double 0.000000e+00, ptr %569, align 8, !tbaa !14
  %570 = load ptr, ptr %12, align 8, !tbaa !5
  %571 = getelementptr inbounds %struct.doublecomplex, ptr %570, i64 2
  %572 = getelementptr inbounds %struct.doublecomplex, ptr %571, i32 0, i32 0
  store double 0.000000e+00, ptr %572, align 8, !tbaa !11
  %573 = load ptr, ptr %12, align 8, !tbaa !5
  %574 = getelementptr inbounds %struct.doublecomplex, ptr %573, i64 2
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %574, i32 0, i32 1
  store double 0.000000e+00, ptr %575, align 8, !tbaa !14
  %576 = load ptr, ptr %12, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.doublecomplex, ptr %576, i64 3
  %578 = getelementptr inbounds %struct.doublecomplex, ptr %577, i32 0, i32 0
  store double 0.000000e+00, ptr %578, align 8, !tbaa !11
  %579 = load ptr, ptr %12, align 8, !tbaa !5
  %580 = getelementptr inbounds %struct.doublecomplex, ptr %579, i64 3
  %581 = getelementptr inbounds %struct.doublecomplex, ptr %580, i32 0, i32 1
  store double 0.000000e+00, ptr %581, align 8, !tbaa !14
  br label %1130

582:                                              ; preds = %557
  %583 = load i32, ptr %13, align 4, !tbaa !9
  %584 = add nsw i32 %583, 2
  store i32 %584, ptr %15, align 4, !tbaa !9
  %585 = load ptr, ptr %8, align 8, !tbaa !5
  %586 = load i32, ptr %15, align 4, !tbaa !9
  %587 = sext i32 %586 to i64
  %588 = getelementptr inbounds %struct.doublecomplex, ptr %585, i64 %587
  %589 = getelementptr inbounds %struct.doublecomplex, ptr %588, i32 0, i32 0
  %590 = load double, ptr %589, align 8, !tbaa !11
  %591 = load double, ptr %33, align 8, !tbaa !15
  %592 = fdiv double %590, %591
  %593 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %592, ptr %593, align 8, !tbaa !11
  %594 = load ptr, ptr %8, align 8, !tbaa !5
  %595 = load i32, ptr %15, align 4, !tbaa !9
  %596 = sext i32 %595 to i64
  %597 = getelementptr inbounds %struct.doublecomplex, ptr %594, i64 %596
  %598 = getelementptr inbounds %struct.doublecomplex, ptr %597, i32 0, i32 1
  %599 = load double, ptr %598, align 8, !tbaa !14
  %600 = load double, ptr %33, align 8, !tbaa !15
  %601 = fdiv double %599, %600
  %602 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %601, ptr %602, align 8, !tbaa !14
  %603 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %604 = load double, ptr %603, align 8, !tbaa !11
  %605 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  store double %604, ptr %605, align 8, !tbaa !11
  %606 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %607 = load double, ptr %606, align 8, !tbaa !14
  %608 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  store double %607, ptr %608, align 8, !tbaa !14
  %609 = load i32, ptr %13, align 4, !tbaa !9
  %610 = add nsw i32 %609, 3
  store i32 %610, ptr %15, align 4, !tbaa !9
  %611 = load ptr, ptr %8, align 8, !tbaa !5
  %612 = load i32, ptr %15, align 4, !tbaa !9
  %613 = sext i32 %612 to i64
  %614 = getelementptr inbounds %struct.doublecomplex, ptr %611, i64 %613
  %615 = getelementptr inbounds %struct.doublecomplex, ptr %614, i32 0, i32 0
  %616 = load double, ptr %615, align 8, !tbaa !11
  %617 = load double, ptr %33, align 8, !tbaa !15
  %618 = fdiv double %616, %617
  %619 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %618, ptr %619, align 8, !tbaa !11
  %620 = load ptr, ptr %8, align 8, !tbaa !5
  %621 = load i32, ptr %15, align 4, !tbaa !9
  %622 = sext i32 %621 to i64
  %623 = getelementptr inbounds %struct.doublecomplex, ptr %620, i64 %622
  %624 = getelementptr inbounds %struct.doublecomplex, ptr %623, i32 0, i32 1
  %625 = load double, ptr %624, align 8, !tbaa !14
  %626 = load double, ptr %33, align 8, !tbaa !15
  %627 = fdiv double %625, %626
  %628 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %627, ptr %628, align 8, !tbaa !14
  %629 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %630 = load double, ptr %629, align 8, !tbaa !11
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %630, ptr %631, align 8, !tbaa !11
  %632 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %633 = load double, ptr %632, align 8, !tbaa !14
  %634 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %633, ptr %634, align 8, !tbaa !14
  %635 = load i32, ptr %13, align 4, !tbaa !9
  %636 = add nsw i32 %635, 1
  store i32 %636, ptr %15, align 4, !tbaa !9
  %637 = load ptr, ptr %8, align 8, !tbaa !5
  %638 = load i32, ptr %15, 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 0
  %642 = load double, ptr %641, align 8, !tbaa !11
  %643 = load ptr, ptr %10, align 8, !tbaa !5
  %644 = getelementptr inbounds %struct.doublecomplex, ptr %643, i32 0, i32 0
  %645 = load double, ptr %644, align 8, !tbaa !11
  %646 = fsub double %642, %645
  %647 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %646, ptr %647, align 8, !tbaa !11
  %648 = load ptr, ptr %8, align 8, !tbaa !5
  %649 = load i32, ptr %15, align 4, !tbaa !9
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds %struct.doublecomplex, ptr %648, i64 %650
  %652 = getelementptr inbounds %struct.doublecomplex, ptr %651, i32 0, i32 1
  %653 = load double, ptr %652, align 8, !tbaa !14
  %654 = load ptr, ptr %10, align 8, !tbaa !5
  %655 = getelementptr inbounds %struct.doublecomplex, ptr %654, i32 0, i32 1
  %656 = load double, ptr %655, align 8, !tbaa !14
  %657 = fsub double %653, %656
  %658 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %657, ptr %658, align 8, !tbaa !14
  %659 = load i32, ptr %13, align 4, !tbaa !9
  %660 = add nsw i32 %659, 1
  store i32 %660, ptr %16, align 4, !tbaa !9
  %661 = load ptr, ptr %8, align 8, !tbaa !5
  %662 = load i32, ptr %16, align 4, !tbaa !9
  %663 = sext i32 %662 to i64
  %664 = getelementptr inbounds %struct.doublecomplex, ptr %661, i64 %663
  %665 = getelementptr inbounds %struct.doublecomplex, ptr %664, i32 0, i32 0
  %666 = load double, ptr %665, align 8, !tbaa !11
  %667 = load ptr, ptr %11, align 8, !tbaa !5
  %668 = getelementptr inbounds %struct.doublecomplex, ptr %667, i32 0, i32 0
  %669 = load double, ptr %668, align 8, !tbaa !11
  %670 = fsub double %666, %669
  %671 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %670, ptr %671, align 8, !tbaa !11
  %672 = load ptr, ptr %8, align 8, !tbaa !5
  %673 = load i32, ptr %16, 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 !14
  %678 = load ptr, ptr %11, align 8, !tbaa !5
  %679 = getelementptr inbounds %struct.doublecomplex, ptr %678, i32 0, i32 1
  %680 = load double, ptr %679, align 8, !tbaa !14
  %681 = fsub double %677, %680
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %681, ptr %682, align 8, !tbaa !14
  %683 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %684 = load double, ptr %683, align 8, !tbaa !11
  %685 = load double, ptr %33, align 8, !tbaa !15
  %686 = fdiv double %684, %685
  %687 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %686, ptr %687, align 8, !tbaa !11
  %688 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %689 = load double, ptr %688, align 8, !tbaa !14
  %690 = load double, ptr %33, align 8, !tbaa !15
  %691 = fdiv double %689, %690
  %692 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %691, ptr %692, align 8, !tbaa !14
  %693 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %694 = load double, ptr %693, align 8, !tbaa !11
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %696 = load double, ptr %695, align 8, !tbaa !11
  %697 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %698 = load double, ptr %697, align 8, !tbaa !14
  %699 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %700 = load double, ptr %699, align 8, !tbaa !14
  %701 = fmul double %698, %700
  %702 = fneg double %701
  %703 = call double @llvm.fmuladd.f64(double %694, double %696, double %702)
  %704 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %703, ptr %704, align 8, !tbaa !11
  %705 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %706 = load double, ptr %705, align 8, !tbaa !11
  %707 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %708 = load double, ptr %707, align 8, !tbaa !14
  %709 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %710 = load double, ptr %709, align 8, !tbaa !14
  %711 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %712 = load double, ptr %711, align 8, !tbaa !11
  %713 = fmul double %710, %712
  %714 = call double @llvm.fmuladd.f64(double %706, double %708, double %713)
  %715 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %714, ptr %715, align 8, !tbaa !14
  %716 = load i32, ptr %13, align 4, !tbaa !9
  %717 = shl i32 %716, 1
  %718 = add nsw i32 %717, 1
  store i32 %718, ptr %17, align 4, !tbaa !9
  %719 = load ptr, ptr %8, align 8, !tbaa !5
  %720 = load i32, ptr %17, align 4, !tbaa !9
  %721 = sext i32 %720 to i64
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %719, i64 %721
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %722, i32 0, i32 0
  %724 = load double, ptr %723, align 8, !tbaa !11
  %725 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %726 = load double, ptr %725, align 8, !tbaa !11
  %727 = load ptr, ptr %8, align 8, !tbaa !5
  %728 = load i32, ptr %17, align 4, !tbaa !9
  %729 = sext i32 %728 to i64
  %730 = getelementptr inbounds %struct.doublecomplex, ptr %727, i64 %729
  %731 = getelementptr inbounds %struct.doublecomplex, ptr %730, i32 0, i32 1
  %732 = load double, ptr %731, align 8, !tbaa !14
  %733 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %734 = load double, ptr %733, align 8, !tbaa !14
  %735 = fmul double %732, %734
  %736 = fneg double %735
  %737 = call double @llvm.fmuladd.f64(double %724, double %726, double %736)
  %738 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %737, ptr %738, align 8, !tbaa !11
  %739 = load ptr, ptr %8, align 8, !tbaa !5
  %740 = load i32, ptr %17, align 4, !tbaa !9
  %741 = sext i32 %740 to i64
  %742 = getelementptr inbounds %struct.doublecomplex, ptr %739, i64 %741
  %743 = getelementptr inbounds %struct.doublecomplex, ptr %742, i32 0, i32 0
  %744 = load double, ptr %743, align 8, !tbaa !11
  %745 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %746 = load double, ptr %745, align 8, !tbaa !14
  %747 = load ptr, ptr %8, align 8, !tbaa !5
  %748 = load i32, ptr %17, align 4, !tbaa !9
  %749 = sext i32 %748 to i64
  %750 = getelementptr inbounds %struct.doublecomplex, ptr %747, i64 %749
  %751 = getelementptr inbounds %struct.doublecomplex, ptr %750, i32 0, i32 1
  %752 = load double, ptr %751, align 8, !tbaa !14
  %753 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %754 = load double, ptr %753, align 8, !tbaa !11
  %755 = fmul double %752, %754
  %756 = call double @llvm.fmuladd.f64(double %744, double %746, double %755)
  %757 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %756, ptr %757, align 8, !tbaa !14
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %759 = load double, ptr %758, align 8, !tbaa !11
  %760 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %761 = load double, ptr %760, align 8, !tbaa !11
  %762 = fadd double %759, %761
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %762, ptr %763, align 8, !tbaa !11
  %764 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %765 = load double, ptr %764, align 8, !tbaa !14
  %766 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %767 = load double, ptr %766, align 8, !tbaa !14
  %768 = fadd double %765, %767
  %769 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %768, ptr %769, align 8, !tbaa !14
  %770 = load i32, ptr %13, align 4, !tbaa !9
  %771 = mul nsw i32 %770, 3
  %772 = add nsw i32 %771, 1
  store i32 %772, ptr %18, align 4, !tbaa !9
  %773 = load ptr, ptr %8, align 8, !tbaa !5
  %774 = load i32, ptr %18, align 4, !tbaa !9
  %775 = sext i32 %774 to i64
  %776 = getelementptr inbounds %struct.doublecomplex, ptr %773, i64 %775
  %777 = getelementptr inbounds %struct.doublecomplex, ptr %776, i32 0, i32 0
  %778 = load double, ptr %777, align 8, !tbaa !11
  %779 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %780 = load double, ptr %779, align 8, !tbaa !11
  %781 = load ptr, ptr %8, align 8, !tbaa !5
  %782 = load i32, ptr %18, align 4, !tbaa !9
  %783 = sext i32 %782 to i64
  %784 = getelementptr inbounds %struct.doublecomplex, ptr %781, i64 %783
  %785 = getelementptr inbounds %struct.doublecomplex, ptr %784, i32 0, i32 1
  %786 = load double, ptr %785, align 8, !tbaa !14
  %787 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %788 = load double, ptr %787, align 8, !tbaa !14
  %789 = fmul double %786, %788
  %790 = fneg double %789
  %791 = call double @llvm.fmuladd.f64(double %778, double %780, double %790)
  %792 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %791, ptr %792, align 8, !tbaa !11
  %793 = load ptr, ptr %8, align 8, !tbaa !5
  %794 = load i32, ptr %18, align 4, !tbaa !9
  %795 = sext i32 %794 to i64
  %796 = getelementptr inbounds %struct.doublecomplex, ptr %793, i64 %795
  %797 = getelementptr inbounds %struct.doublecomplex, ptr %796, i32 0, i32 0
  %798 = load double, ptr %797, align 8, !tbaa !11
  %799 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %800 = load double, ptr %799, align 8, !tbaa !14
  %801 = load ptr, ptr %8, align 8, !tbaa !5
  %802 = load i32, ptr %18, align 4, !tbaa !9
  %803 = sext i32 %802 to i64
  %804 = getelementptr inbounds %struct.doublecomplex, ptr %801, i64 %803
  %805 = getelementptr inbounds %struct.doublecomplex, ptr %804, i32 0, i32 1
  %806 = load double, ptr %805, align 8, !tbaa !14
  %807 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %808 = load double, ptr %807, align 8, !tbaa !11
  %809 = fmul double %806, %808
  %810 = call double @llvm.fmuladd.f64(double %798, double %800, double %809)
  %811 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %810, ptr %811, align 8, !tbaa !14
  %812 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %813 = load double, ptr %812, align 8, !tbaa !11
  %814 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %815 = load double, ptr %814, align 8, !tbaa !11
  %816 = fadd double %813, %815
  %817 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %816, ptr %817, align 8, !tbaa !11
  %818 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %819 = load double, ptr %818, align 8, !tbaa !14
  %820 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %821 = load double, ptr %820, align 8, !tbaa !14
  %822 = fadd double %819, %821
  %823 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %822, ptr %823, align 8, !tbaa !14
  %824 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %825 = load double, ptr %824, align 8, !tbaa !11
  %826 = load ptr, ptr %12, align 8, !tbaa !5
  %827 = getelementptr inbounds %struct.doublecomplex, ptr %826, i64 1
  %828 = getelementptr inbounds %struct.doublecomplex, ptr %827, i32 0, i32 0
  store double %825, ptr %828, align 8, !tbaa !11
  %829 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %830 = load double, ptr %829, align 8, !tbaa !14
  %831 = load ptr, ptr %12, align 8, !tbaa !5
  %832 = getelementptr inbounds %struct.doublecomplex, ptr %831, i64 1
  %833 = getelementptr inbounds %struct.doublecomplex, ptr %832, i32 0, i32 1
  store double %830, ptr %833, align 8, !tbaa !14
  %834 = load i32, ptr %13, align 4, !tbaa !9
  %835 = add nsw i32 %834, 1
  store i32 %835, ptr %15, align 4, !tbaa !9
  %836 = load i32, ptr %13, align 4, !tbaa !9
  %837 = shl i32 %836, 1
  %838 = add nsw i32 %837, 2
  store i32 %838, ptr %16, align 4, !tbaa !9
  %839 = load ptr, ptr %8, align 8, !tbaa !5
  %840 = load i32, ptr %15, align 4, !tbaa !9
  %841 = sext i32 %840 to i64
  %842 = getelementptr inbounds %struct.doublecomplex, ptr %839, i64 %841
  %843 = getelementptr inbounds %struct.doublecomplex, ptr %842, i32 0, i32 0
  %844 = load double, ptr %843, align 8, !tbaa !11
  %845 = load ptr, ptr %8, align 8, !tbaa !5
  %846 = load i32, ptr %16, align 4, !tbaa !9
  %847 = sext i32 %846 to i64
  %848 = getelementptr inbounds %struct.doublecomplex, ptr %845, i64 %847
  %849 = getelementptr inbounds %struct.doublecomplex, ptr %848, i32 0, i32 0
  %850 = load double, ptr %849, align 8, !tbaa !11
  %851 = fadd double %844, %850
  %852 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %851, ptr %852, align 8, !tbaa !11
  %853 = load ptr, ptr %8, align 8, !tbaa !5
  %854 = load i32, ptr %15, align 4, !tbaa !9
  %855 = sext i32 %854 to i64
  %856 = getelementptr inbounds %struct.doublecomplex, ptr %853, i64 %855
  %857 = getelementptr inbounds %struct.doublecomplex, ptr %856, i32 0, i32 1
  %858 = load double, ptr %857, align 8, !tbaa !14
  %859 = load ptr, ptr %8, align 8, !tbaa !5
  %860 = load i32, ptr %16, 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
  %864 = load double, ptr %863, align 8, !tbaa !14
  %865 = fadd double %858, %864
  %866 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %865, ptr %866, align 8, !tbaa !14
  %867 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %868 = load double, ptr %867, align 8, !tbaa !11
  %869 = load ptr, ptr %10, align 8, !tbaa !5
  %870 = getelementptr inbounds %struct.doublecomplex, ptr %869, i32 0, i32 0
  %871 = load double, ptr %870, align 8, !tbaa !11
  %872 = fsub double %868, %871
  %873 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %872, ptr %873, align 8, !tbaa !11
  %874 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %875 = load double, ptr %874, align 8, !tbaa !14
  %876 = load ptr, ptr %10, align 8, !tbaa !5
  %877 = getelementptr inbounds %struct.doublecomplex, ptr %876, i32 0, i32 1
  %878 = load double, ptr %877, align 8, !tbaa !14
  %879 = fsub double %875, %878
  %880 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %879, ptr %880, align 8, !tbaa !14
  %881 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %882 = load double, ptr %881, align 8, !tbaa !11
  %883 = load ptr, ptr %11, align 8, !tbaa !5
  %884 = getelementptr inbounds %struct.doublecomplex, ptr %883, i32 0, i32 0
  %885 = load double, ptr %884, align 8, !tbaa !11
  %886 = fsub double %882, %885
  %887 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %886, ptr %887, align 8, !tbaa !11
  %888 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %889 = load double, ptr %888, align 8, !tbaa !14
  %890 = load ptr, ptr %11, align 8, !tbaa !5
  %891 = getelementptr inbounds %struct.doublecomplex, ptr %890, i32 0, i32 1
  %892 = load double, ptr %891, align 8, !tbaa !14
  %893 = fsub double %889, %892
  %894 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %893, ptr %894, align 8, !tbaa !14
  %895 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %896 = load double, ptr %895, align 8, !tbaa !11
  %897 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %898 = load double, ptr %897, align 8, !tbaa !11
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %900 = load double, ptr %899, align 8, !tbaa !14
  %901 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %902 = load double, ptr %901, align 8, !tbaa !14
  %903 = fmul double %900, %902
  %904 = fneg double %903
  %905 = call double @llvm.fmuladd.f64(double %896, double %898, double %904)
  %906 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %905, ptr %906, align 8, !tbaa !11
  %907 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %908 = load double, ptr %907, align 8, !tbaa !11
  %909 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %910 = load double, ptr %909, align 8, !tbaa !14
  %911 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %912 = load double, ptr %911, align 8, !tbaa !14
  %913 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %914 = load double, ptr %913, align 8, !tbaa !11
  %915 = fmul double %912, %914
  %916 = call double @llvm.fmuladd.f64(double %908, double %910, double %915)
  %917 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %916, ptr %917, align 8, !tbaa !14
  %918 = load i32, ptr %13, align 4, !tbaa !9
  %919 = mul nsw i32 %918, 3
  %920 = add nsw i32 %919, 2
  store i32 %920, ptr %17, align 4, !tbaa !9
  %921 = load ptr, ptr %8, align 8, !tbaa !5
  %922 = load i32, ptr %17, align 4, !tbaa !9
  %923 = sext i32 %922 to i64
  %924 = getelementptr inbounds %struct.doublecomplex, ptr %921, i64 %923
  %925 = getelementptr inbounds %struct.doublecomplex, ptr %924, i32 0, i32 0
  %926 = load double, ptr %925, align 8, !tbaa !11
  %927 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %928 = load double, ptr %927, align 8, !tbaa !11
  %929 = load ptr, ptr %8, align 8, !tbaa !5
  %930 = load i32, ptr %17, align 4, !tbaa !9
  %931 = sext i32 %930 to i64
  %932 = getelementptr inbounds %struct.doublecomplex, ptr %929, i64 %931
  %933 = getelementptr inbounds %struct.doublecomplex, ptr %932, i32 0, i32 1
  %934 = load double, ptr %933, align 8, !tbaa !14
  %935 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %936 = load double, ptr %935, align 8, !tbaa !14
  %937 = fmul double %934, %936
  %938 = fneg double %937
  %939 = call double @llvm.fmuladd.f64(double %926, double %928, double %938)
  %940 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %939, ptr %940, align 8, !tbaa !11
  %941 = load ptr, ptr %8, align 8, !tbaa !5
  %942 = load i32, ptr %17, align 4, !tbaa !9
  %943 = sext i32 %942 to i64
  %944 = getelementptr inbounds %struct.doublecomplex, ptr %941, i64 %943
  %945 = getelementptr inbounds %struct.doublecomplex, ptr %944, i32 0, i32 0
  %946 = load double, ptr %945, align 8, !tbaa !11
  %947 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %948 = load double, ptr %947, align 8, !tbaa !14
  %949 = load ptr, ptr %8, align 8, !tbaa !5
  %950 = load i32, ptr %17, align 4, !tbaa !9
  %951 = sext i32 %950 to i64
  %952 = getelementptr inbounds %struct.doublecomplex, ptr %949, i64 %951
  %953 = getelementptr inbounds %struct.doublecomplex, ptr %952, i32 0, i32 1
  %954 = load double, ptr %953, align 8, !tbaa !14
  %955 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %956 = load double, ptr %955, align 8, !tbaa !11
  %957 = fmul double %954, %956
  %958 = call double @llvm.fmuladd.f64(double %946, double %948, double %957)
  %959 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %958, ptr %959, align 8, !tbaa !14
  %960 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %961 = load double, ptr %960, align 8, !tbaa !11
  %962 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %963 = load double, ptr %962, align 8, !tbaa !11
  %964 = fadd double %961, %963
  %965 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %964, ptr %965, align 8, !tbaa !11
  %966 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %967 = load double, ptr %966, align 8, !tbaa !14
  %968 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %969 = load double, ptr %968, align 8, !tbaa !14
  %970 = fadd double %967, %969
  %971 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %970, ptr %971, align 8, !tbaa !14
  %972 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %973 = load double, ptr %972, align 8, !tbaa !11
  %974 = load ptr, ptr %12, align 8, !tbaa !5
  %975 = getelementptr inbounds %struct.doublecomplex, ptr %974, i64 2
  %976 = getelementptr inbounds %struct.doublecomplex, ptr %975, i32 0, i32 0
  store double %973, ptr %976, align 8, !tbaa !11
  %977 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %978 = load double, ptr %977, align 8, !tbaa !14
  %979 = load ptr, ptr %12, align 8, !tbaa !5
  %980 = getelementptr inbounds %struct.doublecomplex, ptr %979, i64 2
  %981 = getelementptr inbounds %struct.doublecomplex, ptr %980, i32 0, i32 1
  store double %978, ptr %981, align 8, !tbaa !14
  %982 = load i32, ptr %13, align 4, !tbaa !9
  %983 = add nsw i32 %982, 1
  store i32 %983, ptr %15, align 4, !tbaa !9
  %984 = load i32, ptr %13, align 4, !tbaa !9
  %985 = mul nsw i32 %984, 3
  %986 = add nsw i32 %985, 3
  store i32 %986, ptr %16, align 4, !tbaa !9
  %987 = load ptr, ptr %8, align 8, !tbaa !5
  %988 = load i32, ptr %15, align 4, !tbaa !9
  %989 = sext i32 %988 to i64
  %990 = getelementptr inbounds %struct.doublecomplex, ptr %987, i64 %989
  %991 = getelementptr inbounds %struct.doublecomplex, ptr %990, i32 0, i32 0
  %992 = load double, ptr %991, align 8, !tbaa !11
  %993 = load ptr, ptr %8, align 8, !tbaa !5
  %994 = load i32, ptr %16, align 4, !tbaa !9
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds %struct.doublecomplex, ptr %993, i64 %995
  %997 = getelementptr inbounds %struct.doublecomplex, ptr %996, i32 0, i32 0
  %998 = load double, ptr %997, align 8, !tbaa !11
  %999 = fadd double %992, %998
  %1000 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %999, ptr %1000, align 8, !tbaa !11
  %1001 = load ptr, ptr %8, align 8, !tbaa !5
  %1002 = load i32, ptr %15, align 4, !tbaa !9
  %1003 = sext i32 %1002 to i64
  %1004 = getelementptr inbounds %struct.doublecomplex, ptr %1001, i64 %1003
  %1005 = getelementptr inbounds %struct.doublecomplex, ptr %1004, i32 0, i32 1
  %1006 = load double, ptr %1005, align 8, !tbaa !14
  %1007 = load ptr, ptr %8, align 8, !tbaa !5
  %1008 = load i32, ptr %16, align 4, !tbaa !9
  %1009 = sext i32 %1008 to i64
  %1010 = getelementptr inbounds %struct.doublecomplex, ptr %1007, i64 %1009
  %1011 = getelementptr inbounds %struct.doublecomplex, ptr %1010, i32 0, i32 1
  %1012 = load double, ptr %1011, align 8, !tbaa !14
  %1013 = fadd double %1006, %1012
  %1014 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1013, ptr %1014, align 8, !tbaa !14
  %1015 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1016 = load double, ptr %1015, align 8, !tbaa !11
  %1017 = load ptr, ptr %10, align 8, !tbaa !5
  %1018 = getelementptr inbounds %struct.doublecomplex, ptr %1017, i32 0, i32 0
  %1019 = load double, ptr %1018, align 8, !tbaa !11
  %1020 = fsub double %1016, %1019
  %1021 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %1020, ptr %1021, align 8, !tbaa !11
  %1022 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1023 = load double, ptr %1022, align 8, !tbaa !14
  %1024 = load ptr, ptr %10, align 8, !tbaa !5
  %1025 = getelementptr inbounds %struct.doublecomplex, ptr %1024, i32 0, i32 1
  %1026 = load double, ptr %1025, align 8, !tbaa !14
  %1027 = fsub double %1023, %1026
  %1028 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %1027, ptr %1028, align 8, !tbaa !14
  %1029 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %1030 = load double, ptr %1029, align 8, !tbaa !11
  %1031 = load ptr, ptr %11, align 8, !tbaa !5
  %1032 = getelementptr inbounds %struct.doublecomplex, ptr %1031, i32 0, i32 0
  %1033 = load double, ptr %1032, align 8, !tbaa !11
  %1034 = fsub double %1030, %1033
  %1035 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %1034, ptr %1035, align 8, !tbaa !11
  %1036 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %1037 = load double, ptr %1036, align 8, !tbaa !14
  %1038 = load ptr, ptr %11, align 8, !tbaa !5
  %1039 = getelementptr inbounds %struct.doublecomplex, ptr %1038, i32 0, i32 1
  %1040 = load double, ptr %1039, align 8, !tbaa !14
  %1041 = fsub double %1037, %1040
  %1042 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %1041, ptr %1042, align 8, !tbaa !14
  %1043 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %1044 = load double, ptr %1043, align 8, !tbaa !11
  %1045 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1046 = load double, ptr %1045, align 8, !tbaa !11
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %1048 = load double, ptr %1047, align 8, !tbaa !14
  %1049 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1050 = load double, ptr %1049, align 8, !tbaa !14
  %1051 = fmul double %1048, %1050
  %1052 = fneg double %1051
  %1053 = call double @llvm.fmuladd.f64(double %1044, double %1046, double %1052)
  %1054 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %1053, ptr %1054, align 8, !tbaa !11
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %1056 = load double, ptr %1055, align 8, !tbaa !11
  %1057 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %1058 = load double, ptr %1057, align 8, !tbaa !14
  %1059 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %1060 = load double, ptr %1059, align 8, !tbaa !14
  %1061 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %1062 = load double, ptr %1061, align 8, !tbaa !11
  %1063 = fmul double %1060, %1062
  %1064 = call double @llvm.fmuladd.f64(double %1056, double %1058, double %1063)
  %1065 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %1064, ptr %1065, align 8, !tbaa !14
  %1066 = load i32, ptr %13, align 4, !tbaa !9
  %1067 = shl i32 %1066, 1
  %1068 = add nsw i32 %1067, 3
  store i32 %1068, ptr %17, align 4, !tbaa !9
  %1069 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1070 = load double, ptr %1069, align 8, !tbaa !11
  %1071 = load ptr, ptr %8, align 8, !tbaa !5
  %1072 = load i32, ptr %17, align 4, !tbaa !9
  %1073 = sext i32 %1072 to i64
  %1074 = getelementptr inbounds %struct.doublecomplex, ptr %1071, i64 %1073
  %1075 = getelementptr inbounds %struct.doublecomplex, ptr %1074, i32 0, i32 0
  %1076 = load double, ptr %1075, align 8, !tbaa !11
  %1077 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1078 = load double, ptr %1077, align 8, !tbaa !14
  %1079 = load ptr, ptr %8, align 8, !tbaa !5
  %1080 = load i32, ptr %17, align 4, !tbaa !9
  %1081 = sext i32 %1080 to i64
  %1082 = getelementptr inbounds %struct.doublecomplex, ptr %1079, i64 %1081
  %1083 = getelementptr inbounds %struct.doublecomplex, ptr %1082, i32 0, i32 1
  %1084 = load double, ptr %1083, align 8, !tbaa !14
  %1085 = fmul double %1078, %1084
  %1086 = fneg double %1085
  %1087 = call double @llvm.fmuladd.f64(double %1070, double %1076, double %1086)
  %1088 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %1087, ptr %1088, align 8, !tbaa !11
  %1089 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 0
  %1090 = load double, ptr %1089, align 8, !tbaa !11
  %1091 = load ptr, ptr %8, align 8, !tbaa !5
  %1092 = load i32, ptr %17, align 4, !tbaa !9
  %1093 = sext i32 %1092 to i64
  %1094 = getelementptr inbounds %struct.doublecomplex, ptr %1091, i64 %1093
  %1095 = getelementptr inbounds %struct.doublecomplex, ptr %1094, i32 0, i32 1
  %1096 = load double, ptr %1095, align 8, !tbaa !14
  %1097 = getelementptr inbounds %struct.doublecomplex, ptr %34, i32 0, i32 1
  %1098 = load double, ptr %1097, align 8, !tbaa !14
  %1099 = load ptr, ptr %8, align 8, !tbaa !5
  %1100 = load i32, ptr %17, align 4, !tbaa !9
  %1101 = sext i32 %1100 to i64
  %1102 = getelementptr inbounds %struct.doublecomplex, ptr %1099, i64 %1101
  %1103 = getelementptr inbounds %struct.doublecomplex, ptr %1102, i32 0, i32 0
  %1104 = load double, ptr %1103, align 8, !tbaa !11
  %1105 = fmul double %1098, %1104
  %1106 = call double @llvm.fmuladd.f64(double %1090, double %1096, double %1105)
  %1107 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1106, ptr %1107, align 8, !tbaa !14
  %1108 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %1109 = load double, ptr %1108, align 8, !tbaa !11
  %1110 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1111 = load double, ptr %1110, align 8, !tbaa !11
  %1112 = fadd double %1109, %1111
  %1113 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  store double %1112, ptr %1113, align 8, !tbaa !11
  %1114 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %1115 = load double, ptr %1114, align 8, !tbaa !14
  %1116 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1117 = load double, ptr %1116, align 8, !tbaa !14
  %1118 = fadd double %1115, %1117
  %1119 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  store double %1118, ptr %1119, align 8, !tbaa !14
  %1120 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 0
  %1121 = load double, ptr %1120, align 8, !tbaa !11
  %1122 = load ptr, ptr %12, align 8, !tbaa !5
  %1123 = getelementptr inbounds %struct.doublecomplex, ptr %1122, i64 3
  %1124 = getelementptr inbounds %struct.doublecomplex, ptr %1123, i32 0, i32 0
  store double %1121, ptr %1124, align 8, !tbaa !11
  %1125 = getelementptr inbounds %struct.doublecomplex, ptr %25, i32 0, i32 1
  %1126 = load double, ptr %1125, align 8, !tbaa !14
  %1127 = load ptr, ptr %12, align 8, !tbaa !5
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %1127, i64 3
  %1129 = getelementptr inbounds %struct.doublecomplex, ptr %1128, i32 0, i32 1
  store double %1126, ptr %1129, align 8, !tbaa !14
  br label %1130

1130:                                             ; preds = %582, %563
  br label %1131

1131:                                             ; preds = %1130, %433
  store i32 1, ptr %36, align 4
  br label %1132

1132:                                             ; preds = %1131, %56
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  ret void
}

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

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

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

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

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

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

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


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

%struct.doublecomplex = type { double, double }

; Function Attrs: nounwind uwtable
define dso_local void @zlaqr1_(ptr nocapture noundef readonly %0, ptr noundef %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr nocapture noundef readonly %4, ptr nocapture noundef writeonly %5) local_unnamed_addr #0 {
  %7 = alloca %struct.doublecomplex, align 16
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %7) #5
  %8 = load i32, ptr %2, align 4, !tbaa !5
  %narrow = xor i32 %8, -1
  %9 = sext i32 %narrow to i64
  %10 = getelementptr inbounds %struct.doublecomplex, ptr %1, i64 %9
  %11 = load i32, ptr %0, align 4, !tbaa !5
  %12 = and i32 %11, -2
  %switch = icmp eq i32 %12, 2
  br i1 %switch, label %13, label %226

13:                                               ; preds = %6
  %14 = icmp eq i32 %11, 2
  %15 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %16 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %17 = fsub <2 x double> %15, %16
  store <2 x double> %17, ptr %7, align 16, !tbaa !9
  %18 = extractelement <2 x double> %17, i64 0
  %19 = fcmp oge double %18, 0.000000e+00
  %20 = fneg double %18
  %21 = select i1 %19, double %18, double %20
  %22 = call { double, double } @Cd(ptr noundef nonnull %7)
  %23 = extractvalue { double, double } %22, 1
  %24 = fcmp oge double %23, 0.000000e+00
  %25 = fneg double %23
  %26 = select i1 %24, double %23, double %25
  %27 = fadd double %21, %26
  %28 = sext i32 %8 to i64
  %29 = getelementptr %struct.doublecomplex, ptr %10, i64 %28
  %30 = getelementptr i8, ptr %29, i64 32
  %31 = load double, ptr %30, align 8, !tbaa !11
  %32 = fcmp oge double %31, 0.000000e+00
  %33 = fneg double %31
  %34 = select i1 %32, double %31, double %33
  %35 = call { double, double } @Cd(ptr noundef nonnull %30)
  %36 = extractvalue { double, double } %35, 1
  %37 = fcmp oge double %36, 0.000000e+00
  %38 = fneg double %36
  %39 = select i1 %37, double %36, double %38
  %40 = fadd double %34, %39
  %41 = fadd double %27, %40
  br i1 %14, label %42, label %100

42:                                               ; preds = %13
  %43 = fcmp oeq double %41, 0.000000e+00
  br i1 %43, label %44, label %45

44:                                               ; preds = %42
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(32) %5, i8 0, i64 32, i1 false)
  br label %226

45:                                               ; preds = %42
  %46 = load double, ptr %30, align 8, !tbaa !11
  %47 = fdiv double %46, %41
  %48 = getelementptr i8, ptr %29, i64 40
  %49 = load double, ptr %48, align 8, !tbaa !13
  %50 = fdiv double %49, %41
  %51 = shl i32 %8, 1
  %52 = or disjoint i32 %51, 1
  %53 = sext i32 %52 to i64
  %54 = getelementptr inbounds %struct.doublecomplex, ptr %10, i64 %53
  %55 = fneg double %50
  %56 = load double, ptr %3, align 8, !tbaa !11
  %57 = getelementptr inbounds i8, ptr %3, i64 8
  %58 = load double, ptr %57, align 8, !tbaa !13
  %59 = load <2 x double>, ptr %54, align 8, !tbaa !9
  %60 = insertelement <2 x double> poison, double %50, i64 0
  %61 = insertelement <2 x double> %60, double %55, i64 1
  %62 = fmul <2 x double> %59, %61
  %63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %64 = insertelement <2 x double> poison, double %47, i64 0
  %65 = shufflevector <2 x double> %64, <2 x double> poison, <2 x i32> zeroinitializer
  %66 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %65, <2 x double> %59, <2 x double> %63)
  %67 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %68 = extractelement <2 x double> %67, i64 0
  %69 = fsub double %68, %56
  %70 = extractelement <2 x double> %67, i64 1
  %71 = fsub double %70, %58
  %72 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %73 = fsub <2 x double> %67, %72
  %74 = insertelement <2 x double> poison, double %41, i64 0
  %75 = shufflevector <2 x double> %74, <2 x double> poison, <2 x i32> zeroinitializer
  %76 = fdiv <2 x double> %73, %75
  %77 = fneg double %71
  %78 = insertelement <2 x double> poison, double %71, i64 0
  %79 = insertelement <2 x double> %78, double %77, i64 1
  %80 = fmul <2 x double> %76, %79
  %81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %82 = insertelement <2 x double> poison, double %69, i64 0
  %83 = shufflevector <2 x double> %82, <2 x double> poison, <2 x i32> zeroinitializer
  %84 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> %76, <2 x double> %81)
  %85 = fadd <2 x double> %66, %84
  store <2 x double> %85, ptr %5, align 8, !tbaa !9
  %86 = sext i32 %51 to i64
  %87 = getelementptr %struct.doublecomplex, ptr %10, i64 %86
  %88 = getelementptr i8, ptr %87, i64 32
  %89 = getelementptr inbounds i8, ptr %5, i64 16
  %90 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %91 = load <2 x double>, ptr %88, align 8, !tbaa !9
  %92 = fadd <2 x double> %90, %91
  %93 = load <2 x double>, ptr %3, align 8, !tbaa !9
  %94 = fsub <2 x double> %92, %93
  %95 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %96 = fsub <2 x double> %94, %95
  %97 = fmul <2 x double> %96, %61
  %98 = shufflevector <2 x double> %97, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %65, <2 x double> %96, <2 x double> %98)
  store <2 x double> %99, ptr %89, align 8, !tbaa !9
  br label %226

100:                                              ; preds = %13
  %101 = getelementptr i8, ptr %29, i64 48
  %102 = load double, ptr %101, align 8, !tbaa !11
  %103 = call { double, double } @Cd(ptr noundef nonnull %101)
  %104 = extractvalue { double, double } %103, 1
  %105 = insertelement <2 x double> poison, double %102, i64 0
  %106 = insertelement <2 x double> %105, double %104, i64 1
  %107 = fcmp oge <2 x double> %106, zeroinitializer
  %108 = fneg <2 x double> %106
  %109 = select <2 x i1> %107, <2 x double> %106, <2 x double> %108
  %shift = shufflevector <2 x double> %109, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %110 = fadd <2 x double> %109, %shift
  %111 = extractelement <2 x double> %110, i64 0
  %112 = fadd double %41, %111
  %113 = fcmp oeq double %112, 0.000000e+00
  br i1 %113, label %114, label %115

114:                                              ; preds = %100
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %5, i8 0, i64 48, i1 false)
  br label %226

115:                                              ; preds = %100
  %116 = load double, ptr %3, align 8, !tbaa !11
  %117 = getelementptr inbounds i8, ptr %3, i64 8
  %118 = load double, ptr %117, align 8, !tbaa !13
  %119 = shl i32 %8, 1
  %120 = or disjoint i32 %119, 1
  %121 = sext i32 %120 to i64
  %122 = getelementptr inbounds %struct.doublecomplex, ptr %10, i64 %121
  %123 = load double, ptr %122, align 8, !tbaa !11
  %124 = getelementptr inbounds i8, ptr %122, i64 8
  %125 = load double, ptr %124, align 8, !tbaa !13
  %126 = fneg double %125
  %127 = mul nsw i32 %8, 3
  %128 = sext i32 %127 to i64
  %129 = getelementptr %struct.doublecomplex, ptr %10, i64 %128
  %130 = getelementptr i8, ptr %129, i64 16
  %131 = load double, ptr %130, align 8, !tbaa !11
  %132 = getelementptr i8, ptr %129, i64 24
  %133 = load double, ptr %132, align 8, !tbaa !13
  %134 = fneg double %133
  %135 = load <2 x double>, ptr %30, align 8, !tbaa !9
  %136 = insertelement <2 x double> poison, double %112, i64 0
  %137 = shufflevector <2 x double> %136, <2 x double> poison, <2 x i32> zeroinitializer
  %138 = fdiv <2 x double> %135, %137
  %139 = load <2 x double>, ptr %101, align 8, !tbaa !9
  %140 = fdiv <2 x double> %139, %137
  %141 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %142 = extractelement <2 x double> %141, i64 0
  %143 = fsub double %142, %116
  %144 = extractelement <2 x double> %141, i64 1
  %145 = fsub double %144, %118
  %146 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %147 = fsub <2 x double> %141, %146
  %148 = fdiv <2 x double> %147, %137
  %149 = fneg double %145
  %150 = insertelement <2 x double> poison, double %145, i64 0
  %151 = insertelement <2 x double> %150, double %149, i64 1
  %152 = fmul <2 x double> %148, %151
  %153 = shufflevector <2 x double> %152, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %154 = insertelement <2 x double> poison, double %143, i64 0
  %155 = shufflevector <2 x double> %154, <2 x double> poison, <2 x i32> zeroinitializer
  %156 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %155, <2 x double> %148, <2 x double> %153)
  %157 = insertelement <2 x double> poison, double %125, i64 0
  %158 = insertelement <2 x double> %157, double %126, i64 1
  %159 = fmul <2 x double> %138, %158
  %160 = shufflevector <2 x double> %159, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %161 = insertelement <2 x double> poison, double %123, i64 0
  %162 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> zeroinitializer
  %163 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %162, <2 x double> %138, <2 x double> %160)
  %164 = fadd <2 x double> %156, %163
  %165 = insertelement <2 x double> poison, double %133, i64 0
  %166 = insertelement <2 x double> %165, double %134, i64 1
  %167 = fmul <2 x double> %140, %166
  %168 = shufflevector <2 x double> %167, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %169 = insertelement <2 x double> poison, double %131, i64 0
  %170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> zeroinitializer
  %171 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %140, <2 x double> %168)
  %172 = fadd <2 x double> %164, %171
  store <2 x double> %172, ptr %5, align 8, !tbaa !9
  %173 = sext i32 %119 to i64
  %174 = getelementptr %struct.doublecomplex, ptr %10, i64 %173
  %175 = getelementptr i8, ptr %174, i64 32
  %176 = getelementptr i8, ptr %129, i64 32
  %177 = load double, ptr %176, align 8, !tbaa !11
  %178 = getelementptr i8, ptr %129, i64 40
  %179 = load double, ptr %178, align 8, !tbaa !13
  %180 = fneg double %179
  %181 = getelementptr inbounds i8, ptr %5, i64 16
  %182 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %183 = load <2 x double>, ptr %175, align 8, !tbaa !9
  %184 = fadd <2 x double> %182, %183
  %185 = load <2 x double>, ptr %3, align 8, !tbaa !9
  %186 = fsub <2 x double> %184, %185
  %187 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %188 = fsub <2 x double> %186, %187
  %189 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %190 = fneg <2 x double> %138
  %191 = shufflevector <2 x double> %189, <2 x double> %190, <2 x i32> <i32 0, i32 3>
  %192 = fmul <2 x double> %188, %191
  %193 = shufflevector <2 x double> %192, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %194 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> zeroinitializer
  %195 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %194, <2 x double> %188, <2 x double> %193)
  %196 = insertelement <2 x double> poison, double %179, i64 0
  %197 = insertelement <2 x double> %196, double %180, i64 1
  %198 = fmul <2 x double> %140, %197
  %199 = shufflevector <2 x double> %198, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %200 = insertelement <2 x double> poison, double %177, i64 0
  %201 = shufflevector <2 x double> %200, <2 x double> poison, <2 x i32> zeroinitializer
  %202 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %201, <2 x double> %140, <2 x double> %199)
  %203 = fadd <2 x double> %195, %202
  store <2 x double> %203, ptr %181, align 8, !tbaa !9
  %204 = getelementptr i8, ptr %129, i64 48
  %205 = getelementptr i8, ptr %174, i64 48
  %206 = getelementptr inbounds i8, ptr %5, i64 32
  %207 = load <2 x double>, ptr %1, align 8, !tbaa !9
  %208 = load <2 x double>, ptr %204, align 8, !tbaa !9
  %209 = fadd <2 x double> %207, %208
  %210 = load <2 x double>, ptr %3, align 8, !tbaa !9
  %211 = fsub <2 x double> %209, %210
  %212 = load <2 x double>, ptr %4, align 8, !tbaa !9
  %213 = fsub <2 x double> %211, %212
  %214 = shufflevector <2 x double> %140, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %215 = fneg <2 x double> %140
  %216 = shufflevector <2 x double> %214, <2 x double> %215, <2 x i32> <i32 0, i32 3>
  %217 = fmul <2 x double> %213, %216
  %218 = shufflevector <2 x double> %217, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %219 = shufflevector <2 x double> %140, <2 x double> poison, <2 x i32> zeroinitializer
  %220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %213, <2 x double> %218)
  %221 = load <2 x double>, ptr %205, align 8, !tbaa !9
  %222 = fmul <2 x double> %221, %191
  %223 = shufflevector <2 x double> %222, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %224 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %194, <2 x double> %221, <2 x double> %223)
  %225 = fadd <2 x double> %220, %224
  store <2 x double> %225, ptr %206, align 8, !tbaa !9
  br label %226

226:                                              ; preds = %6, %45, %44, %115, %114
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %7) #5
  ret void
}

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

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

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

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!12, !10, i64 0}
!12 = !{!"", !10, i64 0, !10, i64 8}
!13 = !{!12, !10, i64 8}


; Effective O3 passes: DSEPass,EarlyCSEPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass