; LLVM IR from OpenMathLib/OpenBLAS :: lapack-netlib/TESTING/MATGEN (zlagsy)

; 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 [7 x i8], align 1
@c__3 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c_b2 = external hidden global %struct.doublecomplex, align 8
@.str.1 = external hidden unnamed_addr constant [6 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.2 = external hidden unnamed_addr constant [20 x i8], align 1

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

65:                                               ; preds = %8
  %66 = load ptr, ptr %16, align 8, !tbaa !5
  store i32 -1, ptr %66, align 4, !tbaa !9
  br label %97

67:                                               ; preds = %8
  %68 = load ptr, ptr %10, align 8, !tbaa !5
  %69 = load i32, ptr %68, align 4, !tbaa !9
  %70 = icmp slt i32 %69, 0
  br i1 %70, label %78, label %71

71:                                               ; preds = %67
  %72 = load ptr, ptr %10, align 8, !tbaa !5
  %73 = load i32, ptr %72, align 4, !tbaa !9
  %74 = load ptr, ptr %9, align 8, !tbaa !5
  %75 = load i32, ptr %74, align 4, !tbaa !9
  %76 = sub nsw i32 %75, 1
  %77 = icmp sgt i32 %73, %76
  br i1 %77, label %78, label %80

78:                                               ; preds = %71, %67
  %79 = load ptr, ptr %16, align 8, !tbaa !5
  store i32 -2, ptr %79, align 4, !tbaa !9
  br label %96

80:                                               ; preds = %71
  %81 = load ptr, ptr %13, align 8, !tbaa !5
  %82 = load i32, ptr %81, align 4, !tbaa !9
  %83 = load ptr, ptr %9, align 8, !tbaa !5
  %84 = load i32, ptr %83, align 4, !tbaa !9
  %85 = icmp sge i32 1, %84
  br i1 %85, label %86, label %87

86:                                               ; preds = %80
  br label %90

87:                                               ; preds = %80
  %88 = load ptr, ptr %9, align 8, !tbaa !5
  %89 = load i32, ptr %88, align 4, !tbaa !9
  br label %90

90:                                               ; preds = %87, %86
  %91 = phi i32 [ 1, %86 ], [ %89, %87 ]
  %92 = icmp slt i32 %82, %91
  br i1 %92, label %93, label %95

93:                                               ; preds = %90
  %94 = load ptr, ptr %16, align 8, !tbaa !5
  store i32 -5, ptr %94, align 4, !tbaa !9
  br label %95

95:                                               ; preds = %93, %90
  br label %96

96:                                               ; preds = %95, %78
  br label %97

97:                                               ; preds = %96, %65
  %98 = load ptr, ptr %16, align 8, !tbaa !5
  %99 = load i32, ptr %98, align 4, !tbaa !9
  %100 = icmp slt i32 %99, 0
  br i1 %100, label %101, label %106

101:                                              ; preds = %97
  %102 = load ptr, ptr %16, align 8, !tbaa !5
  %103 = load i32, ptr %102, align 4, !tbaa !9
  %104 = sub nsw i32 0, %103
  store i32 %104, ptr %19, align 4, !tbaa !9
  %105 = call i32 @xerbla_(ptr noundef @.str, ptr noundef %19, i32 noundef 6)
  store i32 1, ptr %42, align 4
  br label %1421

106:                                              ; preds = %97
  %107 = load ptr, ptr %9, align 8, !tbaa !5
  %108 = load i32, ptr %107, align 4, !tbaa !9
  store i32 %108, ptr %19, align 4, !tbaa !9
  store i32 1, ptr %34, align 4, !tbaa !9
  br label %109

109:                                              ; preds = %142, %106
  %110 = load i32, ptr %34, align 4, !tbaa !9
  %111 = load i32, ptr %19, align 4, !tbaa !9
  %112 = icmp sle i32 %110, %111
  br i1 %112, label %113, label %145

113:                                              ; preds = %109
  %114 = load ptr, ptr %9, align 8, !tbaa !5
  %115 = load i32, ptr %114, align 4, !tbaa !9
  store i32 %115, ptr %20, align 4, !tbaa !9
  %116 = load i32, ptr %34, align 4, !tbaa !9
  %117 = add nsw i32 %116, 1
  store i32 %117, ptr %33, align 4, !tbaa !9
  br label %118

118:                                              ; preds = %138, %113
  %119 = load i32, ptr %33, align 4, !tbaa !9
  %120 = load i32, ptr %20, align 4, !tbaa !9
  %121 = icmp sle i32 %119, %120
  br i1 %121, label %122, label %141

122:                                              ; preds = %118
  %123 = load i32, ptr %33, align 4, !tbaa !9
  %124 = load i32, ptr %34, align 4, !tbaa !9
  %125 = load i32, ptr %17, align 4, !tbaa !9
  %126 = mul nsw i32 %124, %125
  %127 = add nsw i32 %123, %126
  store i32 %127, ptr %21, align 4, !tbaa !9
  %128 = load ptr, ptr %12, align 8, !tbaa !5
  %129 = load i32, ptr %21, align 4, !tbaa !9
  %130 = sext i32 %129 to i64
  %131 = getelementptr inbounds %struct.doublecomplex, ptr %128, i64 %130
  %132 = getelementptr inbounds %struct.doublecomplex, ptr %131, i32 0, i32 0
  store double 0.000000e+00, ptr %132, align 8, !tbaa !11
  %133 = load ptr, ptr %12, align 8, !tbaa !5
  %134 = load i32, ptr %21, align 4, !tbaa !9
  %135 = sext i32 %134 to i64
  %136 = getelementptr inbounds %struct.doublecomplex, ptr %133, i64 %135
  %137 = getelementptr inbounds %struct.doublecomplex, ptr %136, i32 0, i32 1
  store double 0.000000e+00, ptr %137, align 8, !tbaa !14
  br label %138

138:                                              ; preds = %122
  %139 = load i32, ptr %33, align 4, !tbaa !9
  %140 = add nsw i32 %139, 1
  store i32 %140, ptr %33, align 4, !tbaa !9
  br label %118, !llvm.loop !15

141:                                              ; preds = %118
  br label %142

142:                                              ; preds = %141
  %143 = load i32, ptr %34, align 4, !tbaa !9
  %144 = add nsw i32 %143, 1
  store i32 %144, ptr %34, align 4, !tbaa !9
  br label %109, !llvm.loop !17

145:                                              ; preds = %109
  %146 = load ptr, ptr %9, align 8, !tbaa !5
  %147 = load i32, ptr %146, align 4, !tbaa !9
  store i32 %147, ptr %19, align 4, !tbaa !9
  store i32 1, ptr %33, align 4, !tbaa !9
  br label %148

148:                                              ; preds = %174, %145
  %149 = load i32, ptr %33, align 4, !tbaa !9
  %150 = load i32, ptr %19, align 4, !tbaa !9
  %151 = icmp sle i32 %149, %150
  br i1 %151, label %152, label %177

152:                                              ; preds = %148
  %153 = load i32, ptr %33, align 4, !tbaa !9
  %154 = load i32, ptr %33, align 4, !tbaa !9
  %155 = load i32, ptr %17, align 4, !tbaa !9
  %156 = mul nsw i32 %154, %155
  %157 = add nsw i32 %153, %156
  store i32 %157, ptr %20, align 4, !tbaa !9
  %158 = load i32, ptr %33, align 4, !tbaa !9
  store i32 %158, ptr %21, align 4, !tbaa !9
  %159 = load ptr, ptr %11, align 8, !tbaa !5
  %160 = load i32, ptr %21, align 4, !tbaa !9
  %161 = sext i32 %160 to i64
  %162 = getelementptr inbounds double, ptr %159, i64 %161
  %163 = load double, ptr %162, align 8, !tbaa !18
  %164 = load ptr, ptr %12, align 8, !tbaa !5
  %165 = load i32, ptr %20, align 4, !tbaa !9
  %166 = sext i32 %165 to i64
  %167 = getelementptr inbounds %struct.doublecomplex, ptr %164, i64 %166
  %168 = getelementptr inbounds %struct.doublecomplex, ptr %167, i32 0, i32 0
  store double %163, ptr %168, align 8, !tbaa !11
  %169 = load ptr, ptr %12, align 8, !tbaa !5
  %170 = load i32, ptr %20, align 4, !tbaa !9
  %171 = sext i32 %170 to i64
  %172 = getelementptr inbounds %struct.doublecomplex, ptr %169, i64 %171
  %173 = getelementptr inbounds %struct.doublecomplex, ptr %172, i32 0, i32 1
  store double 0.000000e+00, ptr %173, align 8, !tbaa !14
  br label %174

174:                                              ; preds = %152
  %175 = load i32, ptr %33, align 4, !tbaa !9
  %176 = add nsw i32 %175, 1
  store i32 %176, ptr %33, align 4, !tbaa !9
  br label %148, !llvm.loop !19

177:                                              ; preds = %148
  %178 = load ptr, ptr %9, align 8, !tbaa !5
  %179 = load i32, ptr %178, align 4, !tbaa !9
  %180 = sub nsw i32 %179, 1
  store i32 %180, ptr %33, align 4, !tbaa !9
  br label %181

181:                                              ; preds = %634, %177
  %182 = load i32, ptr %33, align 4, !tbaa !9
  %183 = icmp sge i32 %182, 1
  br i1 %183, label %184, label %637

184:                                              ; preds = %181
  %185 = load ptr, ptr %9, align 8, !tbaa !5
  %186 = load i32, ptr %185, align 4, !tbaa !9
  %187 = load i32, ptr %33, align 4, !tbaa !9
  %188 = sub nsw i32 %186, %187
  %189 = add nsw i32 %188, 1
  store i32 %189, ptr %19, align 4, !tbaa !9
  %190 = load ptr, ptr %14, align 8, !tbaa !5
  %191 = getelementptr inbounds i32, ptr %190, i64 1
  %192 = load ptr, ptr %15, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.doublecomplex, ptr %192, i64 1
  call void @zlarnv_(ptr noundef @c__3, ptr noundef %191, ptr noundef %19, ptr noundef %193)
  %194 = load ptr, ptr %9, align 8, !tbaa !5
  %195 = load i32, ptr %194, align 4, !tbaa !9
  %196 = load i32, ptr %33, align 4, !tbaa !9
  %197 = sub nsw i32 %195, %196
  %198 = add nsw i32 %197, 1
  store i32 %198, ptr %19, align 4, !tbaa !9
  %199 = load ptr, ptr %15, align 8, !tbaa !5
  %200 = getelementptr inbounds %struct.doublecomplex, ptr %199, i64 1
  %201 = call double @dznrm2_(ptr noundef %19, ptr noundef %200, ptr noundef @c__1)
  store double %201, ptr %40, align 8, !tbaa !18
  %202 = load double, ptr %40, align 8, !tbaa !18
  %203 = load ptr, ptr %15, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.doublecomplex, ptr %203, i64 1
  %205 = call { double, double } @Cd(ptr noundef %204)
  %206 = extractvalue { double, double } %205, 0
  %207 = extractvalue { double, double } %205, 1
  %208 = getelementptr inbounds { double, double }, ptr %43, i32 0, i32 0
  %209 = getelementptr inbounds { double, double }, ptr %43, i32 0, i32 1
  store double %206, ptr %208, align 8
  store double %207, ptr %209, align 8
  %210 = getelementptr inbounds { double, double }, ptr %43, i32 0, i32 0
  %211 = load double, ptr %210, align 8
  %212 = getelementptr inbounds { double, double }, ptr %43, i32 0, i32 1
  %213 = load double, ptr %212, align 8
  %214 = call double @cabs(double noundef %211, double noundef %213) #6
  %215 = fdiv double %202, %214
  store double %215, ptr %28, align 8, !tbaa !18
  %216 = load double, ptr %28, align 8, !tbaa !18
  %217 = load ptr, ptr %15, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct.doublecomplex, ptr %217, i64 1
  %219 = getelementptr inbounds %struct.doublecomplex, ptr %218, i32 0, i32 0
  %220 = load double, ptr %219, align 8, !tbaa !11
  %221 = fmul double %216, %220
  %222 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %221, ptr %222, align 8, !tbaa !11
  %223 = load double, ptr %28, align 8, !tbaa !18
  %224 = load ptr, ptr %15, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %224, i64 1
  %226 = getelementptr inbounds %struct.doublecomplex, ptr %225, i32 0, i32 1
  %227 = load double, ptr %226, align 8, !tbaa !14
  %228 = fmul double %223, %227
  %229 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %228, ptr %229, align 8, !tbaa !14
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %231 = load double, ptr %230, align 8, !tbaa !11
  %232 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  store double %231, ptr %232, align 8, !tbaa !11
  %233 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %234 = load double, ptr %233, align 8, !tbaa !14
  %235 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  store double %234, ptr %235, align 8, !tbaa !14
  %236 = load double, ptr %40, align 8, !tbaa !18
  %237 = fcmp oeq double %236, 0.000000e+00
  br i1 %237, label %238, label %241

238:                                              ; preds = %184
  %239 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double 0.000000e+00, ptr %239, align 8, !tbaa !11
  %240 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double 0.000000e+00, ptr %240, align 8, !tbaa !14
  br label %305

241:                                              ; preds = %184
  %242 = load ptr, ptr %15, align 8, !tbaa !5
  %243 = getelementptr inbounds %struct.doublecomplex, ptr %242, i64 1
  %244 = getelementptr inbounds %struct.doublecomplex, ptr %243, i32 0, i32 0
  %245 = load double, ptr %244, align 8, !tbaa !11
  %246 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %247 = load double, ptr %246, align 8, !tbaa !11
  %248 = fadd double %245, %247
  %249 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %248, ptr %249, align 8, !tbaa !11
  %250 = load ptr, ptr %15, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.doublecomplex, ptr %250, i64 1
  %252 = getelementptr inbounds %struct.doublecomplex, ptr %251, i32 0, i32 1
  %253 = load double, ptr %252, align 8, !tbaa !14
  %254 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %255 = load double, ptr %254, align 8, !tbaa !14
  %256 = fadd double %253, %255
  %257 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %256, ptr %257, align 8, !tbaa !14
  %258 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %259 = load double, ptr %258, align 8, !tbaa !11
  %260 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %259, ptr %260, align 8, !tbaa !11
  %261 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %262 = load double, ptr %261, align 8, !tbaa !14
  %263 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %262, ptr %263, align 8, !tbaa !14
  %264 = load ptr, ptr %9, align 8, !tbaa !5
  %265 = load i32, ptr %264, align 4, !tbaa !9
  %266 = load i32, ptr %33, align 4, !tbaa !9
  %267 = sub nsw i32 %265, %266
  store i32 %267, ptr %19, align 4, !tbaa !9
  %268 = call { double, double } @Cd(ptr noundef @c_b2)
  %269 = extractvalue { double, double } %268, 0
  %270 = extractvalue { double, double } %268, 1
  %271 = call { double, double } @Cd(ptr noundef %39)
  %272 = extractvalue { double, double } %271, 0
  %273 = extractvalue { double, double } %271, 1
  %274 = call { double, double } @__divdc3(double noundef %269, double noundef %270, double noundef %272, double noundef %273) #6
  %275 = extractvalue { double, double } %274, 0
  %276 = extractvalue { double, double } %274, 1
  %277 = call ptr @_pCd(ptr noundef %29)
  %278 = getelementptr inbounds { double, double }, ptr %277, i32 0, i32 0
  %279 = getelementptr inbounds { double, double }, ptr %277, i32 0, i32 1
  store double %275, ptr %278, align 8
  store double %276, ptr %279, align 8
  %280 = load ptr, ptr %15, align 8, !tbaa !5
  %281 = getelementptr inbounds %struct.doublecomplex, ptr %280, i64 2
  call void @zscal_(ptr noundef %19, ptr noundef %29, ptr noundef %281, ptr noundef @c__1)
  %282 = load ptr, ptr %15, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %282, i64 1
  %284 = getelementptr inbounds %struct.doublecomplex, ptr %283, i32 0, i32 0
  store double 1.000000e+00, ptr %284, align 8, !tbaa !11
  %285 = load ptr, ptr %15, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.doublecomplex, ptr %285, i64 1
  %287 = getelementptr inbounds %struct.doublecomplex, ptr %286, i32 0, i32 1
  store double 0.000000e+00, ptr %287, align 8, !tbaa !14
  %288 = call { double, double } @Cd(ptr noundef %39)
  %289 = extractvalue { double, double } %288, 0
  %290 = extractvalue { double, double } %288, 1
  %291 = call { double, double } @Cd(ptr noundef %38)
  %292 = extractvalue { double, double } %291, 0
  %293 = extractvalue { double, double } %291, 1
  %294 = call { double, double } @__divdc3(double noundef %289, double noundef %290, double noundef %292, double noundef %293) #6
  %295 = extractvalue { double, double } %294, 0
  %296 = extractvalue { double, double } %294, 1
  %297 = call ptr @_pCd(ptr noundef %29)
  %298 = getelementptr inbounds { double, double }, ptr %297, i32 0, i32 0
  %299 = getelementptr inbounds { double, double }, ptr %297, i32 0, i32 1
  store double %295, ptr %298, align 8
  store double %296, ptr %299, align 8
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %301 = load double, ptr %300, align 8, !tbaa !11
  store double %301, ptr %28, align 8, !tbaa !18
  %302 = load double, ptr %28, align 8, !tbaa !18
  %303 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %302, ptr %303, align 8, !tbaa !11
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double 0.000000e+00, ptr %304, align 8, !tbaa !14
  br label %305

305:                                              ; preds = %241, %238
  %306 = load ptr, ptr %9, align 8, !tbaa !5
  %307 = load i32, ptr %306, align 4, !tbaa !9
  %308 = load i32, ptr %33, align 4, !tbaa !9
  %309 = sub nsw i32 %307, %308
  %310 = add nsw i32 %309, 1
  store i32 %310, ptr %19, align 4, !tbaa !9
  %311 = load ptr, ptr %15, align 8, !tbaa !5
  %312 = getelementptr inbounds %struct.doublecomplex, ptr %311, i64 1
  call void @zlacgv_(ptr noundef %19, ptr noundef %312, ptr noundef @c__1)
  %313 = load ptr, ptr %9, align 8, !tbaa !5
  %314 = load i32, ptr %313, align 4, !tbaa !9
  %315 = load i32, ptr %33, align 4, !tbaa !9
  %316 = sub nsw i32 %314, %315
  %317 = add nsw i32 %316, 1
  store i32 %317, ptr %19, align 4, !tbaa !9
  %318 = load ptr, ptr %12, align 8, !tbaa !5
  %319 = load i32, ptr %33, align 4, !tbaa !9
  %320 = load i32, ptr %33, align 4, !tbaa !9
  %321 = load i32, ptr %17, align 4, !tbaa !9
  %322 = mul nsw i32 %320, %321
  %323 = add nsw i32 %319, %322
  %324 = sext i32 %323 to i64
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %318, i64 %324
  %326 = load ptr, ptr %13, align 8, !tbaa !5
  %327 = load ptr, ptr %15, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.doublecomplex, ptr %327, i64 1
  %329 = load ptr, ptr %15, align 8, !tbaa !5
  %330 = load ptr, ptr %9, align 8, !tbaa !5
  %331 = load i32, ptr %330, align 4, !tbaa !9
  %332 = add nsw i32 %331, 1
  %333 = sext i32 %332 to i64
  %334 = getelementptr inbounds %struct.doublecomplex, ptr %329, i64 %333
  call void @zsymv_(ptr noundef @.str.1, ptr noundef %19, ptr noundef %41, ptr noundef %325, ptr noundef %326, ptr noundef %328, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %334, ptr noundef @c__1)
  %335 = load ptr, ptr %9, align 8, !tbaa !5
  %336 = load i32, ptr %335, align 4, !tbaa !9
  %337 = load i32, ptr %33, align 4, !tbaa !9
  %338 = sub nsw i32 %336, %337
  %339 = add nsw i32 %338, 1
  store i32 %339, ptr %19, align 4, !tbaa !9
  %340 = load ptr, ptr %15, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.doublecomplex, ptr %340, i64 1
  call void @zlacgv_(ptr noundef %19, ptr noundef %341, ptr noundef @c__1)
  %342 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double -5.000000e-01, ptr %342, align 8, !tbaa !11
  %343 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double 0.000000e+00, ptr %343, align 8, !tbaa !14
  %344 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %345 = load double, ptr %344, align 8, !tbaa !11
  %346 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %347 = load double, ptr %346, align 8, !tbaa !11
  %348 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %349 = load double, ptr %348, align 8, !tbaa !14
  %350 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %351 = load double, ptr %350, align 8, !tbaa !14
  %352 = fmul double %349, %351
  %353 = fneg double %352
  %354 = call double @llvm.fmuladd.f64(double %345, double %347, double %353)
  %355 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %354, ptr %355, align 8, !tbaa !11
  %356 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %357 = load double, ptr %356, align 8, !tbaa !11
  %358 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %359 = load double, ptr %358, align 8, !tbaa !14
  %360 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %361 = load double, ptr %360, align 8, !tbaa !14
  %362 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %363 = load double, ptr %362, align 8, !tbaa !11
  %364 = fmul double %361, %363
  %365 = call double @llvm.fmuladd.f64(double %357, double %359, double %364)
  %366 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %365, ptr %366, align 8, !tbaa !14
  %367 = load ptr, ptr %9, align 8, !tbaa !5
  %368 = load i32, ptr %367, align 4, !tbaa !9
  %369 = load i32, ptr %33, align 4, !tbaa !9
  %370 = sub nsw i32 %368, %369
  %371 = add nsw i32 %370, 1
  store i32 %371, ptr %19, align 4, !tbaa !9
  %372 = load ptr, ptr %15, align 8, !tbaa !5
  %373 = getelementptr inbounds %struct.doublecomplex, ptr %372, i64 1
  %374 = load ptr, ptr %15, align 8, !tbaa !5
  %375 = load ptr, ptr %9, align 8, !tbaa !5
  %376 = load i32, ptr %375, align 4, !tbaa !9
  %377 = add nsw i32 %376, 1
  %378 = sext i32 %377 to i64
  %379 = getelementptr inbounds %struct.doublecomplex, ptr %374, i64 %378
  call void @zdotc_(ptr noundef %32, ptr noundef %19, ptr noundef %373, ptr noundef @c__1, ptr noundef %379, ptr noundef @c__1)
  %380 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %381 = load double, ptr %380, align 8, !tbaa !11
  %382 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %383 = load double, ptr %382, align 8, !tbaa !11
  %384 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %385 = load double, ptr %384, align 8, !tbaa !14
  %386 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %387 = load double, ptr %386, align 8, !tbaa !14
  %388 = fmul double %385, %387
  %389 = fneg double %388
  %390 = call double @llvm.fmuladd.f64(double %381, double %383, double %389)
  %391 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %390, ptr %391, align 8, !tbaa !11
  %392 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %393 = load double, ptr %392, align 8, !tbaa !11
  %394 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %395 = load double, ptr %394, align 8, !tbaa !14
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %397 = load double, ptr %396, align 8, !tbaa !14
  %398 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %399 = load double, ptr %398, align 8, !tbaa !11
  %400 = fmul double %397, %399
  %401 = call double @llvm.fmuladd.f64(double %393, double %395, double %400)
  %402 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %401, ptr %402, align 8, !tbaa !14
  %403 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %404 = load double, ptr %403, align 8, !tbaa !11
  %405 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %404, ptr %405, align 8, !tbaa !11
  %406 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %407 = load double, ptr %406, align 8, !tbaa !14
  %408 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %407, ptr %408, align 8, !tbaa !14
  %409 = load ptr, ptr %9, align 8, !tbaa !5
  %410 = load i32, ptr %409, align 4, !tbaa !9
  %411 = load i32, ptr %33, align 4, !tbaa !9
  %412 = sub nsw i32 %410, %411
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %19, align 4, !tbaa !9
  %414 = load ptr, ptr %15, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.doublecomplex, ptr %414, i64 1
  %416 = load ptr, ptr %15, align 8, !tbaa !5
  %417 = load ptr, ptr %9, align 8, !tbaa !5
  %418 = load i32, ptr %417, align 4, !tbaa !9
  %419 = add nsw i32 %418, 1
  %420 = sext i32 %419 to i64
  %421 = getelementptr inbounds %struct.doublecomplex, ptr %416, i64 %420
  call void @zaxpy_(ptr noundef %19, ptr noundef %35, ptr noundef %415, ptr noundef @c__1, ptr noundef %421, ptr noundef @c__1)
  %422 = load ptr, ptr %9, align 8, !tbaa !5
  %423 = load i32, ptr %422, align 4, !tbaa !9
  store i32 %423, ptr %19, align 4, !tbaa !9
  %424 = load i32, ptr %33, align 4, !tbaa !9
  store i32 %424, ptr %37, align 4, !tbaa !9
  br label %425

425:                                              ; preds = %630, %305
  %426 = load i32, ptr %37, align 4, !tbaa !9
  %427 = load i32, ptr %19, align 4, !tbaa !9
  %428 = icmp sle i32 %426, %427
  br i1 %428, label %429, label %633

429:                                              ; preds = %425
  %430 = load ptr, ptr %9, align 8, !tbaa !5
  %431 = load i32, ptr %430, align 4, !tbaa !9
  store i32 %431, ptr %20, align 4, !tbaa !9
  %432 = load i32, ptr %37, align 4, !tbaa !9
  store i32 %432, ptr %36, align 4, !tbaa !9
  br label %433

433:                                              ; preds = %626, %429
  %434 = load i32, ptr %36, align 4, !tbaa !9
  %435 = load i32, ptr %20, align 4, !tbaa !9
  %436 = icmp sle i32 %434, %435
  br i1 %436, label %437, label %629

437:                                              ; preds = %433
  %438 = load i32, ptr %36, align 4, !tbaa !9
  %439 = load i32, ptr %37, align 4, !tbaa !9
  %440 = load i32, ptr %17, align 4, !tbaa !9
  %441 = mul nsw i32 %439, %440
  %442 = add nsw i32 %438, %441
  store i32 %442, ptr %21, align 4, !tbaa !9
  %443 = load i32, ptr %36, align 4, !tbaa !9
  %444 = load i32, ptr %37, align 4, !tbaa !9
  %445 = load i32, ptr %17, align 4, !tbaa !9
  %446 = mul nsw i32 %444, %445
  %447 = add nsw i32 %443, %446
  store i32 %447, ptr %22, align 4, !tbaa !9
  %448 = load i32, ptr %36, align 4, !tbaa !9
  %449 = load i32, ptr %33, align 4, !tbaa !9
  %450 = sub nsw i32 %448, %449
  %451 = add nsw i32 %450, 1
  store i32 %451, ptr %23, align 4, !tbaa !9
  %452 = load ptr, ptr %9, align 8, !tbaa !5
  %453 = load i32, ptr %452, align 4, !tbaa !9
  %454 = load i32, ptr %37, align 4, !tbaa !9
  %455 = add nsw i32 %453, %454
  %456 = load i32, ptr %33, align 4, !tbaa !9
  %457 = sub nsw i32 %455, %456
  %458 = add nsw i32 %457, 1
  store i32 %458, ptr %24, align 4, !tbaa !9
  %459 = load ptr, ptr %15, align 8, !tbaa !5
  %460 = load i32, ptr %23, align 4, !tbaa !9
  %461 = sext i32 %460 to i64
  %462 = getelementptr inbounds %struct.doublecomplex, ptr %459, i64 %461
  %463 = getelementptr inbounds %struct.doublecomplex, ptr %462, i32 0, i32 0
  %464 = load double, ptr %463, align 8, !tbaa !11
  %465 = load ptr, ptr %15, align 8, !tbaa !5
  %466 = load i32, ptr %24, align 4, !tbaa !9
  %467 = sext i32 %466 to i64
  %468 = getelementptr inbounds %struct.doublecomplex, ptr %465, i64 %467
  %469 = getelementptr inbounds %struct.doublecomplex, ptr %468, i32 0, i32 0
  %470 = load double, ptr %469, align 8, !tbaa !11
  %471 = load ptr, ptr %15, align 8, !tbaa !5
  %472 = load i32, ptr %23, align 4, !tbaa !9
  %473 = sext i32 %472 to i64
  %474 = getelementptr inbounds %struct.doublecomplex, ptr %471, i64 %473
  %475 = getelementptr inbounds %struct.doublecomplex, ptr %474, i32 0, i32 1
  %476 = load double, ptr %475, align 8, !tbaa !14
  %477 = load ptr, ptr %15, align 8, !tbaa !5
  %478 = load i32, ptr %24, align 4, !tbaa !9
  %479 = sext i32 %478 to i64
  %480 = getelementptr inbounds %struct.doublecomplex, ptr %477, i64 %479
  %481 = getelementptr inbounds %struct.doublecomplex, ptr %480, i32 0, i32 1
  %482 = load double, ptr %481, align 8, !tbaa !14
  %483 = fmul double %476, %482
  %484 = fneg double %483
  %485 = call double @llvm.fmuladd.f64(double %464, double %470, double %484)
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %485, ptr %486, align 8, !tbaa !11
  %487 = load ptr, ptr %15, align 8, !tbaa !5
  %488 = load i32, ptr %23, align 4, !tbaa !9
  %489 = sext i32 %488 to i64
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %487, i64 %489
  %491 = getelementptr inbounds %struct.doublecomplex, ptr %490, i32 0, i32 0
  %492 = load double, ptr %491, align 8, !tbaa !11
  %493 = load ptr, ptr %15, align 8, !tbaa !5
  %494 = load i32, ptr %24, 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 1
  %498 = load double, ptr %497, align 8, !tbaa !14
  %499 = load ptr, ptr %15, align 8, !tbaa !5
  %500 = load i32, ptr %23, align 4, !tbaa !9
  %501 = sext i32 %500 to i64
  %502 = getelementptr inbounds %struct.doublecomplex, ptr %499, i64 %501
  %503 = getelementptr inbounds %struct.doublecomplex, ptr %502, i32 0, i32 1
  %504 = load double, ptr %503, align 8, !tbaa !14
  %505 = load ptr, ptr %15, align 8, !tbaa !5
  %506 = load i32, ptr %24, align 4, !tbaa !9
  %507 = sext i32 %506 to i64
  %508 = getelementptr inbounds %struct.doublecomplex, ptr %505, i64 %507
  %509 = getelementptr inbounds %struct.doublecomplex, ptr %508, i32 0, i32 0
  %510 = load double, ptr %509, align 8, !tbaa !11
  %511 = fmul double %504, %510
  %512 = call double @llvm.fmuladd.f64(double %492, double %498, double %511)
  %513 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %512, ptr %513, align 8, !tbaa !14
  %514 = load ptr, ptr %12, align 8, !tbaa !5
  %515 = load i32, ptr %22, align 4, !tbaa !9
  %516 = sext i32 %515 to i64
  %517 = getelementptr inbounds %struct.doublecomplex, ptr %514, i64 %516
  %518 = getelementptr inbounds %struct.doublecomplex, ptr %517, i32 0, i32 0
  %519 = load double, ptr %518, align 8, !tbaa !11
  %520 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %521 = load double, ptr %520, align 8, !tbaa !11
  %522 = fsub double %519, %521
  %523 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %522, ptr %523, align 8, !tbaa !11
  %524 = load ptr, ptr %12, align 8, !tbaa !5
  %525 = load i32, ptr %22, align 4, !tbaa !9
  %526 = sext i32 %525 to i64
  %527 = getelementptr inbounds %struct.doublecomplex, ptr %524, i64 %526
  %528 = getelementptr inbounds %struct.doublecomplex, ptr %527, i32 0, i32 1
  %529 = load double, ptr %528, align 8, !tbaa !14
  %530 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %531 = load double, ptr %530, align 8, !tbaa !14
  %532 = fsub double %529, %531
  %533 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %532, ptr %533, align 8, !tbaa !14
  %534 = load ptr, ptr %9, align 8, !tbaa !5
  %535 = load i32, ptr %534, align 4, !tbaa !9
  %536 = load i32, ptr %36, align 4, !tbaa !9
  %537 = add nsw i32 %535, %536
  %538 = load i32, ptr %33, align 4, !tbaa !9
  %539 = sub nsw i32 %537, %538
  %540 = add nsw i32 %539, 1
  store i32 %540, ptr %25, align 4, !tbaa !9
  %541 = load i32, ptr %37, align 4, !tbaa !9
  %542 = load i32, ptr %33, align 4, !tbaa !9
  %543 = sub nsw i32 %541, %542
  %544 = add nsw i32 %543, 1
  store i32 %544, ptr %26, align 4, !tbaa !9
  %545 = load ptr, ptr %15, align 8, !tbaa !5
  %546 = load i32, ptr %25, align 4, !tbaa !9
  %547 = sext i32 %546 to i64
  %548 = getelementptr inbounds %struct.doublecomplex, ptr %545, i64 %547
  %549 = getelementptr inbounds %struct.doublecomplex, ptr %548, i32 0, i32 0
  %550 = load double, ptr %549, align 8, !tbaa !11
  %551 = load ptr, ptr %15, align 8, !tbaa !5
  %552 = load i32, ptr %26, align 4, !tbaa !9
  %553 = sext i32 %552 to i64
  %554 = getelementptr inbounds %struct.doublecomplex, ptr %551, i64 %553
  %555 = getelementptr inbounds %struct.doublecomplex, ptr %554, i32 0, i32 0
  %556 = load double, ptr %555, align 8, !tbaa !11
  %557 = load ptr, ptr %15, align 8, !tbaa !5
  %558 = load i32, ptr %25, align 4, !tbaa !9
  %559 = sext i32 %558 to i64
  %560 = getelementptr inbounds %struct.doublecomplex, ptr %557, i64 %559
  %561 = getelementptr inbounds %struct.doublecomplex, ptr %560, i32 0, i32 1
  %562 = load double, ptr %561, align 8, !tbaa !14
  %563 = load ptr, ptr %15, align 8, !tbaa !5
  %564 = load i32, ptr %26, align 4, !tbaa !9
  %565 = sext i32 %564 to i64
  %566 = getelementptr inbounds %struct.doublecomplex, ptr %563, i64 %565
  %567 = getelementptr inbounds %struct.doublecomplex, ptr %566, i32 0, i32 1
  %568 = load double, ptr %567, align 8, !tbaa !14
  %569 = fmul double %562, %568
  %570 = fneg double %569
  %571 = call double @llvm.fmuladd.f64(double %550, double %556, double %570)
  %572 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %571, ptr %572, align 8, !tbaa !11
  %573 = load ptr, ptr %15, align 8, !tbaa !5
  %574 = load i32, ptr %25, align 4, !tbaa !9
  %575 = sext i32 %574 to i64
  %576 = getelementptr inbounds %struct.doublecomplex, ptr %573, i64 %575
  %577 = getelementptr inbounds %struct.doublecomplex, ptr %576, i32 0, i32 0
  %578 = load double, ptr %577, align 8, !tbaa !11
  %579 = load ptr, ptr %15, align 8, !tbaa !5
  %580 = load i32, ptr %26, 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 1
  %584 = load double, ptr %583, align 8, !tbaa !14
  %585 = load ptr, ptr %15, align 8, !tbaa !5
  %586 = load i32, ptr %25, 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 1
  %590 = load double, ptr %589, align 8, !tbaa !14
  %591 = load ptr, ptr %15, align 8, !tbaa !5
  %592 = load i32, ptr %26, align 4, !tbaa !9
  %593 = sext i32 %592 to i64
  %594 = getelementptr inbounds %struct.doublecomplex, ptr %591, i64 %593
  %595 = getelementptr inbounds %struct.doublecomplex, ptr %594, i32 0, i32 0
  %596 = load double, ptr %595, align 8, !tbaa !11
  %597 = fmul double %590, %596
  %598 = call double @llvm.fmuladd.f64(double %578, double %584, double %597)
  %599 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %598, ptr %599, align 8, !tbaa !14
  %600 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %601 = load double, ptr %600, align 8, !tbaa !11
  %602 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %603 = load double, ptr %602, align 8, !tbaa !11
  %604 = fsub double %601, %603
  %605 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %604, ptr %605, align 8, !tbaa !11
  %606 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %607 = load double, ptr %606, align 8, !tbaa !14
  %608 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %609 = load double, ptr %608, align 8, !tbaa !14
  %610 = fsub double %607, %609
  %611 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %610, ptr %611, align 8, !tbaa !14
  %612 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %613 = load double, ptr %612, align 8, !tbaa !11
  %614 = load ptr, ptr %12, align 8, !tbaa !5
  %615 = load i32, ptr %21, align 4, !tbaa !9
  %616 = sext i32 %615 to i64
  %617 = getelementptr inbounds %struct.doublecomplex, ptr %614, i64 %616
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %617, i32 0, i32 0
  store double %613, ptr %618, align 8, !tbaa !11
  %619 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %620 = load double, ptr %619, align 8, !tbaa !14
  %621 = load ptr, ptr %12, align 8, !tbaa !5
  %622 = load i32, ptr %21, align 4, !tbaa !9
  %623 = sext i32 %622 to i64
  %624 = getelementptr inbounds %struct.doublecomplex, ptr %621, i64 %623
  %625 = getelementptr inbounds %struct.doublecomplex, ptr %624, i32 0, i32 1
  store double %620, ptr %625, align 8, !tbaa !14
  br label %626

626:                                              ; preds = %437
  %627 = load i32, ptr %36, align 4, !tbaa !9
  %628 = add nsw i32 %627, 1
  store i32 %628, ptr %36, align 4, !tbaa !9
  br label %433, !llvm.loop !20

629:                                              ; preds = %433
  br label %630

630:                                              ; preds = %629
  %631 = load i32, ptr %37, align 4, !tbaa !9
  %632 = add nsw i32 %631, 1
  store i32 %632, ptr %37, align 4, !tbaa !9
  br label %425, !llvm.loop !21

633:                                              ; preds = %425
  br label %634

634:                                              ; preds = %633
  %635 = load i32, ptr %33, align 4, !tbaa !9
  %636 = add nsw i32 %635, -1
  store i32 %636, ptr %33, align 4, !tbaa !9
  br label %181, !llvm.loop !22

637:                                              ; preds = %181
  %638 = load ptr, ptr %9, align 8, !tbaa !5
  %639 = load i32, ptr %638, align 4, !tbaa !9
  %640 = sub nsw i32 %639, 1
  %641 = load ptr, ptr %10, align 8, !tbaa !5
  %642 = load i32, ptr %641, align 4, !tbaa !9
  %643 = sub nsw i32 %640, %642
  store i32 %643, ptr %19, align 4, !tbaa !9
  store i32 1, ptr %33, align 4, !tbaa !9
  br label %644

644:                                              ; preds = %1361, %637
  %645 = load i32, ptr %33, align 4, !tbaa !9
  %646 = load i32, ptr %19, align 4, !tbaa !9
  %647 = icmp sle i32 %645, %646
  br i1 %647, label %648, label %1364

648:                                              ; preds = %644
  %649 = load ptr, ptr %9, align 8, !tbaa !5
  %650 = load i32, ptr %649, align 4, !tbaa !9
  %651 = load ptr, ptr %10, align 8, !tbaa !5
  %652 = load i32, ptr %651, align 4, !tbaa !9
  %653 = sub nsw i32 %650, %652
  %654 = load i32, ptr %33, align 4, !tbaa !9
  %655 = sub nsw i32 %653, %654
  %656 = add nsw i32 %655, 1
  store i32 %656, ptr %20, align 4, !tbaa !9
  %657 = load ptr, ptr %12, align 8, !tbaa !5
  %658 = load ptr, ptr %10, align 8, !tbaa !5
  %659 = load i32, ptr %658, align 4, !tbaa !9
  %660 = load i32, ptr %33, align 4, !tbaa !9
  %661 = add nsw i32 %659, %660
  %662 = load i32, ptr %33, align 4, !tbaa !9
  %663 = load i32, ptr %17, align 4, !tbaa !9
  %664 = mul nsw i32 %662, %663
  %665 = add nsw i32 %661, %664
  %666 = sext i32 %665 to i64
  %667 = getelementptr inbounds %struct.doublecomplex, ptr %657, i64 %666
  %668 = call double @dznrm2_(ptr noundef %20, ptr noundef %667, ptr noundef @c__1)
  store double %668, ptr %40, align 8, !tbaa !18
  %669 = load double, ptr %40, align 8, !tbaa !18
  %670 = load ptr, ptr %12, align 8, !tbaa !5
  %671 = load ptr, ptr %10, align 8, !tbaa !5
  %672 = load i32, ptr %671, align 4, !tbaa !9
  %673 = load i32, ptr %33, align 4, !tbaa !9
  %674 = add nsw i32 %672, %673
  %675 = load i32, ptr %33, align 4, !tbaa !9
  %676 = load i32, ptr %17, align 4, !tbaa !9
  %677 = mul nsw i32 %675, %676
  %678 = add nsw i32 %674, %677
  %679 = sext i32 %678 to i64
  %680 = getelementptr inbounds %struct.doublecomplex, ptr %670, i64 %679
  %681 = call { double, double } @Cd(ptr noundef %680)
  %682 = extractvalue { double, double } %681, 0
  %683 = extractvalue { double, double } %681, 1
  %684 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 0
  %685 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 1
  store double %682, ptr %684, align 8
  store double %683, ptr %685, align 8
  %686 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 0
  %687 = load double, ptr %686, align 8
  %688 = getelementptr inbounds { double, double }, ptr %44, i32 0, i32 1
  %689 = load double, ptr %688, align 8
  %690 = call double @cabs(double noundef %687, double noundef %689) #6
  %691 = fdiv double %669, %690
  store double %691, ptr %28, align 8, !tbaa !18
  %692 = load ptr, ptr %10, align 8, !tbaa !5
  %693 = load i32, ptr %692, align 4, !tbaa !9
  %694 = load i32, ptr %33, align 4, !tbaa !9
  %695 = add nsw i32 %693, %694
  %696 = load i32, ptr %33, align 4, !tbaa !9
  %697 = load i32, ptr %17, align 4, !tbaa !9
  %698 = mul nsw i32 %696, %697
  %699 = add nsw i32 %695, %698
  store i32 %699, ptr %20, align 4, !tbaa !9
  %700 = load double, ptr %28, align 8, !tbaa !18
  %701 = load ptr, ptr %12, align 8, !tbaa !5
  %702 = load i32, ptr %20, align 4, !tbaa !9
  %703 = sext i32 %702 to i64
  %704 = getelementptr inbounds %struct.doublecomplex, ptr %701, i64 %703
  %705 = getelementptr inbounds %struct.doublecomplex, ptr %704, i32 0, i32 0
  %706 = load double, ptr %705, align 8, !tbaa !11
  %707 = fmul double %700, %706
  %708 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %707, ptr %708, align 8, !tbaa !11
  %709 = load double, ptr %28, align 8, !tbaa !18
  %710 = load ptr, ptr %12, align 8, !tbaa !5
  %711 = load i32, ptr %20, align 4, !tbaa !9
  %712 = sext i32 %711 to i64
  %713 = getelementptr inbounds %struct.doublecomplex, ptr %710, i64 %712
  %714 = getelementptr inbounds %struct.doublecomplex, ptr %713, i32 0, i32 1
  %715 = load double, ptr %714, align 8, !tbaa !14
  %716 = fmul double %709, %715
  %717 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %716, ptr %717, align 8, !tbaa !14
  %718 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %719 = load double, ptr %718, align 8, !tbaa !11
  %720 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  store double %719, ptr %720, align 8, !tbaa !11
  %721 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %722 = load double, ptr %721, align 8, !tbaa !14
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  store double %722, ptr %723, align 8, !tbaa !14
  %724 = load double, ptr %40, align 8, !tbaa !18
  %725 = fcmp oeq double %724, 0.000000e+00
  br i1 %725, label %726, label %729

726:                                              ; preds = %648
  %727 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double 0.000000e+00, ptr %727, align 8, !tbaa !11
  %728 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double 0.000000e+00, ptr %728, align 8, !tbaa !14
  br label %830

729:                                              ; preds = %648
  %730 = load ptr, ptr %10, align 8, !tbaa !5
  %731 = load i32, ptr %730, align 4, !tbaa !9
  %732 = load i32, ptr %33, align 4, !tbaa !9
  %733 = add nsw i32 %731, %732
  %734 = load i32, ptr %33, align 4, !tbaa !9
  %735 = load i32, ptr %17, align 4, !tbaa !9
  %736 = mul nsw i32 %734, %735
  %737 = add nsw i32 %733, %736
  store i32 %737, ptr %20, align 4, !tbaa !9
  %738 = load ptr, ptr %12, align 8, !tbaa !5
  %739 = load i32, ptr %20, align 4, !tbaa !9
  %740 = sext i32 %739 to i64
  %741 = getelementptr inbounds %struct.doublecomplex, ptr %738, i64 %740
  %742 = getelementptr inbounds %struct.doublecomplex, ptr %741, i32 0, i32 0
  %743 = load double, ptr %742, align 8, !tbaa !11
  %744 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %745 = load double, ptr %744, align 8, !tbaa !11
  %746 = fadd double %743, %745
  %747 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %746, ptr %747, align 8, !tbaa !11
  %748 = load ptr, ptr %12, align 8, !tbaa !5
  %749 = load i32, ptr %20, align 4, !tbaa !9
  %750 = sext i32 %749 to i64
  %751 = getelementptr inbounds %struct.doublecomplex, ptr %748, i64 %750
  %752 = getelementptr inbounds %struct.doublecomplex, ptr %751, i32 0, i32 1
  %753 = load double, ptr %752, align 8, !tbaa !14
  %754 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %755 = load double, ptr %754, align 8, !tbaa !14
  %756 = fadd double %753, %755
  %757 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %756, ptr %757, align 8, !tbaa !14
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %759 = load double, ptr %758, align 8, !tbaa !11
  %760 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 0
  store double %759, ptr %760, align 8, !tbaa !11
  %761 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %762 = load double, ptr %761, align 8, !tbaa !14
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %39, i32 0, i32 1
  store double %762, ptr %763, align 8, !tbaa !14
  %764 = load ptr, ptr %9, align 8, !tbaa !5
  %765 = load i32, ptr %764, align 4, !tbaa !9
  %766 = load ptr, ptr %10, align 8, !tbaa !5
  %767 = load i32, ptr %766, align 4, !tbaa !9
  %768 = sub nsw i32 %765, %767
  %769 = load i32, ptr %33, align 4, !tbaa !9
  %770 = sub nsw i32 %768, %769
  store i32 %770, ptr %20, align 4, !tbaa !9
  %771 = call { double, double } @Cd(ptr noundef @c_b2)
  %772 = extractvalue { double, double } %771, 0
  %773 = extractvalue { double, double } %771, 1
  %774 = call { double, double } @Cd(ptr noundef %39)
  %775 = extractvalue { double, double } %774, 0
  %776 = extractvalue { double, double } %774, 1
  %777 = call { double, double } @__divdc3(double noundef %772, double noundef %773, double noundef %775, double noundef %776) #6
  %778 = extractvalue { double, double } %777, 0
  %779 = extractvalue { double, double } %777, 1
  %780 = call ptr @_pCd(ptr noundef %29)
  %781 = getelementptr inbounds { double, double }, ptr %780, i32 0, i32 0
  %782 = getelementptr inbounds { double, double }, ptr %780, i32 0, i32 1
  store double %778, ptr %781, align 8
  store double %779, ptr %782, align 8
  %783 = load ptr, ptr %12, align 8, !tbaa !5
  %784 = load ptr, ptr %10, align 8, !tbaa !5
  %785 = load i32, ptr %784, align 4, !tbaa !9
  %786 = load i32, ptr %33, align 4, !tbaa !9
  %787 = add nsw i32 %785, %786
  %788 = add nsw i32 %787, 1
  %789 = load i32, ptr %33, align 4, !tbaa !9
  %790 = load i32, ptr %17, align 4, !tbaa !9
  %791 = mul nsw i32 %789, %790
  %792 = add nsw i32 %788, %791
  %793 = sext i32 %792 to i64
  %794 = getelementptr inbounds %struct.doublecomplex, ptr %783, i64 %793
  call void @zscal_(ptr noundef %20, ptr noundef %29, ptr noundef %794, ptr noundef @c__1)
  %795 = load ptr, ptr %10, align 8, !tbaa !5
  %796 = load i32, ptr %795, align 4, !tbaa !9
  %797 = load i32, ptr %33, align 4, !tbaa !9
  %798 = add nsw i32 %796, %797
  %799 = load i32, ptr %33, align 4, !tbaa !9
  %800 = load i32, ptr %17, align 4, !tbaa !9
  %801 = mul nsw i32 %799, %800
  %802 = add nsw i32 %798, %801
  store i32 %802, ptr %20, align 4, !tbaa !9
  %803 = load ptr, ptr %12, align 8, !tbaa !5
  %804 = load i32, ptr %20, align 4, !tbaa !9
  %805 = sext i32 %804 to i64
  %806 = getelementptr inbounds %struct.doublecomplex, ptr %803, i64 %805
  %807 = getelementptr inbounds %struct.doublecomplex, ptr %806, i32 0, i32 0
  store double 1.000000e+00, ptr %807, align 8, !tbaa !11
  %808 = load ptr, ptr %12, align 8, !tbaa !5
  %809 = load i32, ptr %20, align 4, !tbaa !9
  %810 = sext i32 %809 to i64
  %811 = getelementptr inbounds %struct.doublecomplex, ptr %808, i64 %810
  %812 = getelementptr inbounds %struct.doublecomplex, ptr %811, i32 0, i32 1
  store double 0.000000e+00, ptr %812, align 8, !tbaa !14
  %813 = call { double, double } @Cd(ptr noundef %39)
  %814 = extractvalue { double, double } %813, 0
  %815 = extractvalue { double, double } %813, 1
  %816 = call { double, double } @Cd(ptr noundef %38)
  %817 = extractvalue { double, double } %816, 0
  %818 = extractvalue { double, double } %816, 1
  %819 = call { double, double } @__divdc3(double noundef %814, double noundef %815, double noundef %817, double noundef %818) #6
  %820 = extractvalue { double, double } %819, 0
  %821 = extractvalue { double, double } %819, 1
  %822 = call ptr @_pCd(ptr noundef %29)
  %823 = getelementptr inbounds { double, double }, ptr %822, i32 0, i32 0
  %824 = getelementptr inbounds { double, double }, ptr %822, i32 0, i32 1
  store double %820, ptr %823, align 8
  store double %821, ptr %824, align 8
  %825 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %826 = load double, ptr %825, align 8, !tbaa !11
  store double %826, ptr %28, align 8, !tbaa !18
  %827 = load double, ptr %28, align 8, !tbaa !18
  %828 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  store double %827, ptr %828, align 8, !tbaa !11
  %829 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  store double 0.000000e+00, ptr %829, align 8, !tbaa !14
  br label %830

830:                                              ; preds = %729, %726
  %831 = load ptr, ptr %9, align 8, !tbaa !5
  %832 = load i32, ptr %831, align 4, !tbaa !9
  %833 = load ptr, ptr %10, align 8, !tbaa !5
  %834 = load i32, ptr %833, align 4, !tbaa !9
  %835 = sub nsw i32 %832, %834
  %836 = load i32, ptr %33, align 4, !tbaa !9
  %837 = sub nsw i32 %835, %836
  %838 = add nsw i32 %837, 1
  store i32 %838, ptr %20, align 4, !tbaa !9
  %839 = load ptr, ptr %10, align 8, !tbaa !5
  %840 = load i32, ptr %839, align 4, !tbaa !9
  %841 = sub nsw i32 %840, 1
  store i32 %841, ptr %21, align 4, !tbaa !9
  %842 = load ptr, ptr %12, align 8, !tbaa !5
  %843 = load ptr, ptr %10, align 8, !tbaa !5
  %844 = load i32, ptr %843, align 4, !tbaa !9
  %845 = load i32, ptr %33, align 4, !tbaa !9
  %846 = add nsw i32 %844, %845
  %847 = load i32, ptr %33, align 4, !tbaa !9
  %848 = add nsw i32 %847, 1
  %849 = load i32, ptr %17, align 4, !tbaa !9
  %850 = mul nsw i32 %848, %849
  %851 = add nsw i32 %846, %850
  %852 = sext i32 %851 to i64
  %853 = getelementptr inbounds %struct.doublecomplex, ptr %842, i64 %852
  %854 = load ptr, ptr %13, align 8, !tbaa !5
  %855 = load ptr, ptr %12, align 8, !tbaa !5
  %856 = load ptr, ptr %10, align 8, !tbaa !5
  %857 = load i32, ptr %856, align 4, !tbaa !9
  %858 = load i32, ptr %33, align 4, !tbaa !9
  %859 = add nsw i32 %857, %858
  %860 = load i32, ptr %33, align 4, !tbaa !9
  %861 = load i32, ptr %17, align 4, !tbaa !9
  %862 = mul nsw i32 %860, %861
  %863 = add nsw i32 %859, %862
  %864 = sext i32 %863 to i64
  %865 = getelementptr inbounds %struct.doublecomplex, ptr %855, i64 %864
  %866 = load ptr, ptr %15, align 8, !tbaa !5
  %867 = getelementptr inbounds %struct.doublecomplex, ptr %866, i64 1
  call void @zgemv_(ptr noundef @.str.2, ptr noundef %20, ptr noundef %21, ptr noundef @c_b2, ptr noundef %853, ptr noundef %854, ptr noundef %865, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %867, ptr noundef @c__1)
  %868 = load ptr, ptr %9, align 8, !tbaa !5
  %869 = load i32, ptr %868, align 4, !tbaa !9
  %870 = load ptr, ptr %10, align 8, !tbaa !5
  %871 = load i32, ptr %870, align 4, !tbaa !9
  %872 = sub nsw i32 %869, %871
  %873 = load i32, ptr %33, align 4, !tbaa !9
  %874 = sub nsw i32 %872, %873
  %875 = add nsw i32 %874, 1
  store i32 %875, ptr %20, align 4, !tbaa !9
  %876 = load ptr, ptr %10, align 8, !tbaa !5
  %877 = load i32, ptr %876, align 4, !tbaa !9
  %878 = sub nsw i32 %877, 1
  store i32 %878, ptr %21, align 4, !tbaa !9
  %879 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %880 = load double, ptr %879, align 8, !tbaa !11
  %881 = fneg double %880
  %882 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %881, ptr %882, align 8, !tbaa !11
  %883 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %884 = load double, ptr %883, align 8, !tbaa !14
  %885 = fneg double %884
  %886 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %885, ptr %886, align 8, !tbaa !14
  %887 = load ptr, ptr %12, align 8, !tbaa !5
  %888 = load ptr, ptr %10, align 8, !tbaa !5
  %889 = load i32, ptr %888, align 4, !tbaa !9
  %890 = load i32, ptr %33, align 4, !tbaa !9
  %891 = add nsw i32 %889, %890
  %892 = load i32, ptr %33, align 4, !tbaa !9
  %893 = load i32, ptr %17, align 4, !tbaa !9
  %894 = mul nsw i32 %892, %893
  %895 = add nsw i32 %891, %894
  %896 = sext i32 %895 to i64
  %897 = getelementptr inbounds %struct.doublecomplex, ptr %887, i64 %896
  %898 = load ptr, ptr %15, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.doublecomplex, ptr %898, i64 1
  %900 = load ptr, ptr %12, align 8, !tbaa !5
  %901 = load ptr, ptr %10, align 8, !tbaa !5
  %902 = load i32, ptr %901, align 4, !tbaa !9
  %903 = load i32, ptr %33, align 4, !tbaa !9
  %904 = add nsw i32 %902, %903
  %905 = load i32, ptr %33, align 4, !tbaa !9
  %906 = add nsw i32 %905, 1
  %907 = load i32, ptr %17, align 4, !tbaa !9
  %908 = mul nsw i32 %906, %907
  %909 = add nsw i32 %904, %908
  %910 = sext i32 %909 to i64
  %911 = getelementptr inbounds %struct.doublecomplex, ptr %900, i64 %910
  %912 = load ptr, ptr %13, align 8, !tbaa !5
  call void @zgerc_(ptr noundef %20, ptr noundef %21, ptr noundef %29, ptr noundef %897, ptr noundef @c__1, ptr noundef %899, ptr noundef @c__1, ptr noundef %911, ptr noundef %912)
  %913 = load ptr, ptr %9, align 8, !tbaa !5
  %914 = load i32, ptr %913, align 4, !tbaa !9
  %915 = load ptr, ptr %10, align 8, !tbaa !5
  %916 = load i32, ptr %915, align 4, !tbaa !9
  %917 = sub nsw i32 %914, %916
  %918 = load i32, ptr %33, align 4, !tbaa !9
  %919 = sub nsw i32 %917, %918
  %920 = add nsw i32 %919, 1
  store i32 %920, ptr %20, align 4, !tbaa !9
  %921 = load ptr, ptr %12, align 8, !tbaa !5
  %922 = load ptr, ptr %10, align 8, !tbaa !5
  %923 = load i32, ptr %922, align 4, !tbaa !9
  %924 = load i32, ptr %33, align 4, !tbaa !9
  %925 = add nsw i32 %923, %924
  %926 = load i32, ptr %33, align 4, !tbaa !9
  %927 = load i32, ptr %17, align 4, !tbaa !9
  %928 = mul nsw i32 %926, %927
  %929 = add nsw i32 %925, %928
  %930 = sext i32 %929 to i64
  %931 = getelementptr inbounds %struct.doublecomplex, ptr %921, i64 %930
  call void @zlacgv_(ptr noundef %20, ptr noundef %931, ptr noundef @c__1)
  %932 = load ptr, ptr %9, align 8, !tbaa !5
  %933 = load i32, ptr %932, align 4, !tbaa !9
  %934 = load ptr, ptr %10, align 8, !tbaa !5
  %935 = load i32, ptr %934, align 4, !tbaa !9
  %936 = sub nsw i32 %933, %935
  %937 = load i32, ptr %33, align 4, !tbaa !9
  %938 = sub nsw i32 %936, %937
  %939 = add nsw i32 %938, 1
  store i32 %939, ptr %20, align 4, !tbaa !9
  %940 = load ptr, ptr %12, align 8, !tbaa !5
  %941 = load ptr, ptr %10, align 8, !tbaa !5
  %942 = load i32, ptr %941, align 4, !tbaa !9
  %943 = load i32, ptr %33, align 4, !tbaa !9
  %944 = add nsw i32 %942, %943
  %945 = load ptr, ptr %10, align 8, !tbaa !5
  %946 = load i32, ptr %945, align 4, !tbaa !9
  %947 = load i32, ptr %33, align 4, !tbaa !9
  %948 = add nsw i32 %946, %947
  %949 = load i32, ptr %17, align 4, !tbaa !9
  %950 = mul nsw i32 %948, %949
  %951 = add nsw i32 %944, %950
  %952 = sext i32 %951 to i64
  %953 = getelementptr inbounds %struct.doublecomplex, ptr %940, i64 %952
  %954 = load ptr, ptr %13, align 8, !tbaa !5
  %955 = load ptr, ptr %12, align 8, !tbaa !5
  %956 = load ptr, ptr %10, align 8, !tbaa !5
  %957 = load i32, ptr %956, align 4, !tbaa !9
  %958 = load i32, ptr %33, align 4, !tbaa !9
  %959 = add nsw i32 %957, %958
  %960 = load i32, ptr %33, align 4, !tbaa !9
  %961 = load i32, ptr %17, align 4, !tbaa !9
  %962 = mul nsw i32 %960, %961
  %963 = add nsw i32 %959, %962
  %964 = sext i32 %963 to i64
  %965 = getelementptr inbounds %struct.doublecomplex, ptr %955, i64 %964
  %966 = load ptr, ptr %15, align 8, !tbaa !5
  %967 = getelementptr inbounds %struct.doublecomplex, ptr %966, i64 1
  call void @zsymv_(ptr noundef @.str.1, ptr noundef %20, ptr noundef %41, ptr noundef %953, ptr noundef %954, ptr noundef %965, ptr noundef @c__1, ptr noundef @c_b1, ptr noundef %967, ptr noundef @c__1)
  %968 = load ptr, ptr %9, align 8, !tbaa !5
  %969 = load i32, ptr %968, align 4, !tbaa !9
  %970 = load ptr, ptr %10, align 8, !tbaa !5
  %971 = load i32, ptr %970, align 4, !tbaa !9
  %972 = sub nsw i32 %969, %971
  %973 = load i32, ptr %33, align 4, !tbaa !9
  %974 = sub nsw i32 %972, %973
  %975 = add nsw i32 %974, 1
  store i32 %975, ptr %20, align 4, !tbaa !9
  %976 = load ptr, ptr %12, align 8, !tbaa !5
  %977 = load ptr, ptr %10, align 8, !tbaa !5
  %978 = load i32, ptr %977, align 4, !tbaa !9
  %979 = load i32, ptr %33, align 4, !tbaa !9
  %980 = add nsw i32 %978, %979
  %981 = load i32, ptr %33, align 4, !tbaa !9
  %982 = load i32, ptr %17, align 4, !tbaa !9
  %983 = mul nsw i32 %981, %982
  %984 = add nsw i32 %980, %983
  %985 = sext i32 %984 to i64
  %986 = getelementptr inbounds %struct.doublecomplex, ptr %976, i64 %985
  call void @zlacgv_(ptr noundef %20, ptr noundef %986, ptr noundef @c__1)
  %987 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double -5.000000e-01, ptr %987, align 8, !tbaa !11
  %988 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double 0.000000e+00, ptr %988, align 8, !tbaa !14
  %989 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %990 = load double, ptr %989, align 8, !tbaa !11
  %991 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %992 = load double, ptr %991, align 8, !tbaa !11
  %993 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %994 = load double, ptr %993, align 8, !tbaa !14
  %995 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %996 = load double, ptr %995, align 8, !tbaa !14
  %997 = fmul double %994, %996
  %998 = fneg double %997
  %999 = call double @llvm.fmuladd.f64(double %990, double %992, double %998)
  %1000 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %999, ptr %1000, align 8, !tbaa !11
  %1001 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1002 = load double, ptr %1001, align 8, !tbaa !11
  %1003 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 1
  %1004 = load double, ptr %1003, align 8, !tbaa !14
  %1005 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1006 = load double, ptr %1005, align 8, !tbaa !14
  %1007 = getelementptr inbounds %struct.doublecomplex, ptr %41, i32 0, i32 0
  %1008 = load double, ptr %1007, align 8, !tbaa !11
  %1009 = fmul double %1006, %1008
  %1010 = call double @llvm.fmuladd.f64(double %1002, double %1004, double %1009)
  %1011 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1010, ptr %1011, align 8, !tbaa !14
  %1012 = load ptr, ptr %9, align 8, !tbaa !5
  %1013 = load i32, ptr %1012, align 4, !tbaa !9
  %1014 = load ptr, ptr %10, align 8, !tbaa !5
  %1015 = load i32, ptr %1014, align 4, !tbaa !9
  %1016 = sub nsw i32 %1013, %1015
  %1017 = load i32, ptr %33, align 4, !tbaa !9
  %1018 = sub nsw i32 %1016, %1017
  %1019 = add nsw i32 %1018, 1
  store i32 %1019, ptr %20, align 4, !tbaa !9
  %1020 = load ptr, ptr %12, align 8, !tbaa !5
  %1021 = load ptr, ptr %10, align 8, !tbaa !5
  %1022 = load i32, ptr %1021, align 4, !tbaa !9
  %1023 = load i32, ptr %33, align 4, !tbaa !9
  %1024 = add nsw i32 %1022, %1023
  %1025 = load i32, ptr %33, align 4, !tbaa !9
  %1026 = load i32, ptr %17, align 4, !tbaa !9
  %1027 = mul nsw i32 %1025, %1026
  %1028 = add nsw i32 %1024, %1027
  %1029 = sext i32 %1028 to i64
  %1030 = getelementptr inbounds %struct.doublecomplex, ptr %1020, i64 %1029
  %1031 = load ptr, ptr %15, align 8, !tbaa !5
  %1032 = getelementptr inbounds %struct.doublecomplex, ptr %1031, i64 1
  call void @zdotc_(ptr noundef %32, ptr noundef %20, ptr noundef %1030, ptr noundef @c__1, ptr noundef %1032, ptr noundef @c__1)
  %1033 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1034 = load double, ptr %1033, align 8, !tbaa !11
  %1035 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1036 = load double, ptr %1035, align 8, !tbaa !11
  %1037 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1038 = load double, ptr %1037, align 8, !tbaa !14
  %1039 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %1040 = load double, ptr %1039, align 8, !tbaa !14
  %1041 = fmul double %1038, %1040
  %1042 = fneg double %1041
  %1043 = call double @llvm.fmuladd.f64(double %1034, double %1036, double %1042)
  %1044 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %1043, ptr %1044, align 8, !tbaa !11
  %1045 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1046 = load double, ptr %1045, align 8, !tbaa !11
  %1047 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %1048 = load double, ptr %1047, align 8, !tbaa !14
  %1049 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1050 = load double, ptr %1049, align 8, !tbaa !14
  %1051 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1052 = load double, ptr %1051, align 8, !tbaa !11
  %1053 = fmul double %1050, %1052
  %1054 = call double @llvm.fmuladd.f64(double %1046, double %1048, double %1053)
  %1055 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1054, ptr %1055, align 8, !tbaa !14
  %1056 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1057 = load double, ptr %1056, align 8, !tbaa !11
  %1058 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %1057, ptr %1058, align 8, !tbaa !11
  %1059 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1060 = load double, ptr %1059, align 8, !tbaa !14
  %1061 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %1060, ptr %1061, align 8, !tbaa !14
  %1062 = load ptr, ptr %9, align 8, !tbaa !5
  %1063 = load i32, ptr %1062, align 4, !tbaa !9
  %1064 = load ptr, ptr %10, align 8, !tbaa !5
  %1065 = load i32, ptr %1064, align 4, !tbaa !9
  %1066 = sub nsw i32 %1063, %1065
  %1067 = load i32, ptr %33, align 4, !tbaa !9
  %1068 = sub nsw i32 %1066, %1067
  %1069 = add nsw i32 %1068, 1
  store i32 %1069, ptr %20, align 4, !tbaa !9
  %1070 = load ptr, ptr %12, align 8, !tbaa !5
  %1071 = load ptr, ptr %10, align 8, !tbaa !5
  %1072 = load i32, ptr %1071, align 4, !tbaa !9
  %1073 = load i32, ptr %33, align 4, !tbaa !9
  %1074 = add nsw i32 %1072, %1073
  %1075 = load i32, ptr %33, align 4, !tbaa !9
  %1076 = load i32, ptr %17, align 4, !tbaa !9
  %1077 = mul nsw i32 %1075, %1076
  %1078 = add nsw i32 %1074, %1077
  %1079 = sext i32 %1078 to i64
  %1080 = getelementptr inbounds %struct.doublecomplex, ptr %1070, i64 %1079
  %1081 = load ptr, ptr %15, align 8, !tbaa !5
  %1082 = getelementptr inbounds %struct.doublecomplex, ptr %1081, i64 1
  call void @zaxpy_(ptr noundef %20, ptr noundef %35, ptr noundef %1080, ptr noundef @c__1, ptr noundef %1082, ptr noundef @c__1)
  %1083 = load ptr, ptr %9, align 8, !tbaa !5
  %1084 = load i32, ptr %1083, align 4, !tbaa !9
  store i32 %1084, ptr %20, align 4, !tbaa !9
  %1085 = load ptr, ptr %10, align 8, !tbaa !5
  %1086 = load i32, ptr %1085, align 4, !tbaa !9
  %1087 = load i32, ptr %33, align 4, !tbaa !9
  %1088 = add nsw i32 %1086, %1087
  store i32 %1088, ptr %37, align 4, !tbaa !9
  br label %1089

1089:                                             ; preds = %1296, %830
  %1090 = load i32, ptr %37, align 4, !tbaa !9
  %1091 = load i32, ptr %20, align 4, !tbaa !9
  %1092 = icmp sle i32 %1090, %1091
  br i1 %1092, label %1093, label %1299

1093:                                             ; preds = %1089
  %1094 = load ptr, ptr %9, align 8, !tbaa !5
  %1095 = load i32, ptr %1094, align 4, !tbaa !9
  store i32 %1095, ptr %21, align 4, !tbaa !9
  %1096 = load i32, ptr %37, align 4, !tbaa !9
  store i32 %1096, ptr %36, align 4, !tbaa !9
  br label %1097

1097:                                             ; preds = %1292, %1093
  %1098 = load i32, ptr %36, align 4, !tbaa !9
  %1099 = load i32, ptr %21, align 4, !tbaa !9
  %1100 = icmp sle i32 %1098, %1099
  br i1 %1100, label %1101, label %1295

1101:                                             ; preds = %1097
  %1102 = load i32, ptr %36, align 4, !tbaa !9
  %1103 = load i32, ptr %37, align 4, !tbaa !9
  %1104 = load i32, ptr %17, align 4, !tbaa !9
  %1105 = mul nsw i32 %1103, %1104
  %1106 = add nsw i32 %1102, %1105
  store i32 %1106, ptr %22, align 4, !tbaa !9
  %1107 = load i32, ptr %36, align 4, !tbaa !9
  %1108 = load i32, ptr %37, align 4, !tbaa !9
  %1109 = load i32, ptr %17, align 4, !tbaa !9
  %1110 = mul nsw i32 %1108, %1109
  %1111 = add nsw i32 %1107, %1110
  store i32 %1111, ptr %23, align 4, !tbaa !9
  %1112 = load i32, ptr %36, align 4, !tbaa !9
  %1113 = load i32, ptr %33, align 4, !tbaa !9
  %1114 = load i32, ptr %17, align 4, !tbaa !9
  %1115 = mul nsw i32 %1113, %1114
  %1116 = add nsw i32 %1112, %1115
  store i32 %1116, ptr %24, align 4, !tbaa !9
  %1117 = load i32, ptr %37, align 4, !tbaa !9
  %1118 = load ptr, ptr %10, align 8, !tbaa !5
  %1119 = load i32, ptr %1118, align 4, !tbaa !9
  %1120 = sub nsw i32 %1117, %1119
  %1121 = load i32, ptr %33, align 4, !tbaa !9
  %1122 = sub nsw i32 %1120, %1121
  %1123 = add nsw i32 %1122, 1
  store i32 %1123, ptr %25, align 4, !tbaa !9
  %1124 = load ptr, ptr %12, align 8, !tbaa !5
  %1125 = load i32, ptr %24, align 4, !tbaa !9
  %1126 = sext i32 %1125 to i64
  %1127 = getelementptr inbounds %struct.doublecomplex, ptr %1124, i64 %1126
  %1128 = getelementptr inbounds %struct.doublecomplex, ptr %1127, i32 0, i32 0
  %1129 = load double, ptr %1128, align 8, !tbaa !11
  %1130 = load ptr, ptr %15, align 8, !tbaa !5
  %1131 = load i32, ptr %25, align 4, !tbaa !9
  %1132 = sext i32 %1131 to i64
  %1133 = getelementptr inbounds %struct.doublecomplex, ptr %1130, i64 %1132
  %1134 = getelementptr inbounds %struct.doublecomplex, ptr %1133, i32 0, i32 0
  %1135 = load double, ptr %1134, align 8, !tbaa !11
  %1136 = load ptr, ptr %12, align 8, !tbaa !5
  %1137 = load i32, ptr %24, align 4, !tbaa !9
  %1138 = sext i32 %1137 to i64
  %1139 = getelementptr inbounds %struct.doublecomplex, ptr %1136, i64 %1138
  %1140 = getelementptr inbounds %struct.doublecomplex, ptr %1139, i32 0, i32 1
  %1141 = load double, ptr %1140, align 8, !tbaa !14
  %1142 = load ptr, ptr %15, align 8, !tbaa !5
  %1143 = load i32, ptr %25, align 4, !tbaa !9
  %1144 = sext i32 %1143 to i64
  %1145 = getelementptr inbounds %struct.doublecomplex, ptr %1142, i64 %1144
  %1146 = getelementptr inbounds %struct.doublecomplex, ptr %1145, i32 0, i32 1
  %1147 = load double, ptr %1146, align 8, !tbaa !14
  %1148 = fmul double %1141, %1147
  %1149 = fneg double %1148
  %1150 = call double @llvm.fmuladd.f64(double %1129, double %1135, double %1149)
  %1151 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %1150, ptr %1151, align 8, !tbaa !11
  %1152 = load ptr, ptr %12, align 8, !tbaa !5
  %1153 = load i32, ptr %24, align 4, !tbaa !9
  %1154 = sext i32 %1153 to i64
  %1155 = getelementptr inbounds %struct.doublecomplex, ptr %1152, i64 %1154
  %1156 = getelementptr inbounds %struct.doublecomplex, ptr %1155, i32 0, i32 0
  %1157 = load double, ptr %1156, align 8, !tbaa !11
  %1158 = load ptr, ptr %15, align 8, !tbaa !5
  %1159 = load i32, ptr %25, align 4, !tbaa !9
  %1160 = sext i32 %1159 to i64
  %1161 = getelementptr inbounds %struct.doublecomplex, ptr %1158, i64 %1160
  %1162 = getelementptr inbounds %struct.doublecomplex, ptr %1161, i32 0, i32 1
  %1163 = load double, ptr %1162, align 8, !tbaa !14
  %1164 = load ptr, ptr %12, align 8, !tbaa !5
  %1165 = load i32, ptr %24, align 4, !tbaa !9
  %1166 = sext i32 %1165 to i64
  %1167 = getelementptr inbounds %struct.doublecomplex, ptr %1164, i64 %1166
  %1168 = getelementptr inbounds %struct.doublecomplex, ptr %1167, i32 0, i32 1
  %1169 = load double, ptr %1168, align 8, !tbaa !14
  %1170 = load ptr, ptr %15, align 8, !tbaa !5
  %1171 = load i32, ptr %25, align 4, !tbaa !9
  %1172 = sext i32 %1171 to i64
  %1173 = getelementptr inbounds %struct.doublecomplex, ptr %1170, i64 %1172
  %1174 = getelementptr inbounds %struct.doublecomplex, ptr %1173, i32 0, i32 0
  %1175 = load double, ptr %1174, align 8, !tbaa !11
  %1176 = fmul double %1169, %1175
  %1177 = call double @llvm.fmuladd.f64(double %1157, double %1163, double %1176)
  %1178 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %1177, ptr %1178, align 8, !tbaa !14
  %1179 = load ptr, ptr %12, align 8, !tbaa !5
  %1180 = load i32, ptr %23, align 4, !tbaa !9
  %1181 = sext i32 %1180 to i64
  %1182 = getelementptr inbounds %struct.doublecomplex, ptr %1179, i64 %1181
  %1183 = getelementptr inbounds %struct.doublecomplex, ptr %1182, i32 0, i32 0
  %1184 = load double, ptr %1183, align 8, !tbaa !11
  %1185 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %1186 = load double, ptr %1185, align 8, !tbaa !11
  %1187 = fsub double %1184, %1186
  %1188 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  store double %1187, ptr %1188, align 8, !tbaa !11
  %1189 = load ptr, ptr %12, align 8, !tbaa !5
  %1190 = load i32, ptr %23, align 4, !tbaa !9
  %1191 = sext i32 %1190 to i64
  %1192 = getelementptr inbounds %struct.doublecomplex, ptr %1189, i64 %1191
  %1193 = getelementptr inbounds %struct.doublecomplex, ptr %1192, i32 0, i32 1
  %1194 = load double, ptr %1193, align 8, !tbaa !14
  %1195 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %1196 = load double, ptr %1195, align 8, !tbaa !14
  %1197 = fsub double %1194, %1196
  %1198 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  store double %1197, ptr %1198, align 8, !tbaa !14
  %1199 = load i32, ptr %36, align 4, !tbaa !9
  %1200 = load ptr, ptr %10, align 8, !tbaa !5
  %1201 = load i32, ptr %1200, align 4, !tbaa !9
  %1202 = sub nsw i32 %1199, %1201
  %1203 = load i32, ptr %33, align 4, !tbaa !9
  %1204 = sub nsw i32 %1202, %1203
  %1205 = add nsw i32 %1204, 1
  store i32 %1205, ptr %26, align 4, !tbaa !9
  %1206 = load i32, ptr %37, align 4, !tbaa !9
  %1207 = load i32, ptr %33, align 4, !tbaa !9
  %1208 = load i32, ptr %17, align 4, !tbaa !9
  %1209 = mul nsw i32 %1207, %1208
  %1210 = add nsw i32 %1206, %1209
  store i32 %1210, ptr %27, align 4, !tbaa !9
  %1211 = load ptr, ptr %15, align 8, !tbaa !5
  %1212 = load i32, ptr %26, align 4, !tbaa !9
  %1213 = sext i32 %1212 to i64
  %1214 = getelementptr inbounds %struct.doublecomplex, ptr %1211, i64 %1213
  %1215 = getelementptr inbounds %struct.doublecomplex, ptr %1214, i32 0, i32 0
  %1216 = load double, ptr %1215, align 8, !tbaa !11
  %1217 = load ptr, ptr %12, align 8, !tbaa !5
  %1218 = load i32, ptr %27, align 4, !tbaa !9
  %1219 = sext i32 %1218 to i64
  %1220 = getelementptr inbounds %struct.doublecomplex, ptr %1217, i64 %1219
  %1221 = getelementptr inbounds %struct.doublecomplex, ptr %1220, i32 0, i32 0
  %1222 = load double, ptr %1221, align 8, !tbaa !11
  %1223 = load ptr, ptr %15, align 8, !tbaa !5
  %1224 = load i32, ptr %26, align 4, !tbaa !9
  %1225 = sext i32 %1224 to i64
  %1226 = getelementptr inbounds %struct.doublecomplex, ptr %1223, i64 %1225
  %1227 = getelementptr inbounds %struct.doublecomplex, ptr %1226, i32 0, i32 1
  %1228 = load double, ptr %1227, align 8, !tbaa !14
  %1229 = load ptr, ptr %12, align 8, !tbaa !5
  %1230 = load i32, ptr %27, align 4, !tbaa !9
  %1231 = sext i32 %1230 to i64
  %1232 = getelementptr inbounds %struct.doublecomplex, ptr %1229, i64 %1231
  %1233 = getelementptr inbounds %struct.doublecomplex, ptr %1232, i32 0, i32 1
  %1234 = load double, ptr %1233, align 8, !tbaa !14
  %1235 = fmul double %1228, %1234
  %1236 = fneg double %1235
  %1237 = call double @llvm.fmuladd.f64(double %1216, double %1222, double %1236)
  %1238 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %1237, ptr %1238, align 8, !tbaa !11
  %1239 = load ptr, ptr %15, align 8, !tbaa !5
  %1240 = load i32, ptr %26, align 4, !tbaa !9
  %1241 = sext i32 %1240 to i64
  %1242 = getelementptr inbounds %struct.doublecomplex, ptr %1239, i64 %1241
  %1243 = getelementptr inbounds %struct.doublecomplex, ptr %1242, i32 0, i32 0
  %1244 = load double, ptr %1243, align 8, !tbaa !11
  %1245 = load ptr, ptr %12, align 8, !tbaa !5
  %1246 = load i32, ptr %27, align 4, !tbaa !9
  %1247 = sext i32 %1246 to i64
  %1248 = getelementptr inbounds %struct.doublecomplex, ptr %1245, i64 %1247
  %1249 = getelementptr inbounds %struct.doublecomplex, ptr %1248, i32 0, i32 1
  %1250 = load double, ptr %1249, align 8, !tbaa !14
  %1251 = load ptr, ptr %15, align 8, !tbaa !5
  %1252 = load i32, ptr %26, align 4, !tbaa !9
  %1253 = sext i32 %1252 to i64
  %1254 = getelementptr inbounds %struct.doublecomplex, ptr %1251, i64 %1253
  %1255 = getelementptr inbounds %struct.doublecomplex, ptr %1254, i32 0, i32 1
  %1256 = load double, ptr %1255, align 8, !tbaa !14
  %1257 = load ptr, ptr %12, align 8, !tbaa !5
  %1258 = load i32, ptr %27, align 4, !tbaa !9
  %1259 = sext i32 %1258 to i64
  %1260 = getelementptr inbounds %struct.doublecomplex, ptr %1257, i64 %1259
  %1261 = getelementptr inbounds %struct.doublecomplex, ptr %1260, i32 0, i32 0
  %1262 = load double, ptr %1261, align 8, !tbaa !11
  %1263 = fmul double %1256, %1262
  %1264 = call double @llvm.fmuladd.f64(double %1244, double %1250, double %1263)
  %1265 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %1264, ptr %1265, align 8, !tbaa !14
  %1266 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 0
  %1267 = load double, ptr %1266, align 8, !tbaa !11
  %1268 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %1269 = load double, ptr %1268, align 8, !tbaa !11
  %1270 = fsub double %1267, %1269
  %1271 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %1270, ptr %1271, align 8, !tbaa !11
  %1272 = getelementptr inbounds %struct.doublecomplex, ptr %30, i32 0, i32 1
  %1273 = load double, ptr %1272, align 8, !tbaa !14
  %1274 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %1275 = load double, ptr %1274, align 8, !tbaa !14
  %1276 = fsub double %1273, %1275
  %1277 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1276, ptr %1277, align 8, !tbaa !14
  %1278 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1279 = load double, ptr %1278, align 8, !tbaa !11
  %1280 = load ptr, ptr %12, align 8, !tbaa !5
  %1281 = load i32, ptr %22, align 4, !tbaa !9
  %1282 = sext i32 %1281 to i64
  %1283 = getelementptr inbounds %struct.doublecomplex, ptr %1280, i64 %1282
  %1284 = getelementptr inbounds %struct.doublecomplex, ptr %1283, i32 0, i32 0
  store double %1279, ptr %1284, align 8, !tbaa !11
  %1285 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1286 = load double, ptr %1285, align 8, !tbaa !14
  %1287 = load ptr, ptr %12, align 8, !tbaa !5
  %1288 = load i32, ptr %22, align 4, !tbaa !9
  %1289 = sext i32 %1288 to i64
  %1290 = getelementptr inbounds %struct.doublecomplex, ptr %1287, i64 %1289
  %1291 = getelementptr inbounds %struct.doublecomplex, ptr %1290, i32 0, i32 1
  store double %1286, ptr %1291, align 8, !tbaa !14
  br label %1292

1292:                                             ; preds = %1101
  %1293 = load i32, ptr %36, align 4, !tbaa !9
  %1294 = add nsw i32 %1293, 1
  store i32 %1294, ptr %36, align 4, !tbaa !9
  br label %1097, !llvm.loop !23

1295:                                             ; preds = %1097
  br label %1296

1296:                                             ; preds = %1295
  %1297 = load i32, ptr %37, align 4, !tbaa !9
  %1298 = add nsw i32 %1297, 1
  store i32 %1298, ptr %37, align 4, !tbaa !9
  br label %1089, !llvm.loop !24

1299:                                             ; preds = %1089
  %1300 = load ptr, ptr %10, align 8, !tbaa !5
  %1301 = load i32, ptr %1300, align 4, !tbaa !9
  %1302 = load i32, ptr %33, align 4, !tbaa !9
  %1303 = add nsw i32 %1301, %1302
  %1304 = load i32, ptr %33, align 4, !tbaa !9
  %1305 = load i32, ptr %17, align 4, !tbaa !9
  %1306 = mul nsw i32 %1304, %1305
  %1307 = add nsw i32 %1303, %1306
  store i32 %1307, ptr %20, align 4, !tbaa !9
  %1308 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 0
  %1309 = load double, ptr %1308, align 8, !tbaa !11
  %1310 = fneg double %1309
  %1311 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %1310, ptr %1311, align 8, !tbaa !11
  %1312 = getelementptr inbounds %struct.doublecomplex, ptr %38, i32 0, i32 1
  %1313 = load double, ptr %1312, align 8, !tbaa !14
  %1314 = fneg double %1313
  %1315 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %1314, ptr %1315, align 8, !tbaa !14
  %1316 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %1317 = load double, ptr %1316, align 8, !tbaa !11
  %1318 = load ptr, ptr %12, align 8, !tbaa !5
  %1319 = load i32, ptr %20, align 4, !tbaa !9
  %1320 = sext i32 %1319 to i64
  %1321 = getelementptr inbounds %struct.doublecomplex, ptr %1318, i64 %1320
  %1322 = getelementptr inbounds %struct.doublecomplex, ptr %1321, i32 0, i32 0
  store double %1317, ptr %1322, align 8, !tbaa !11
  %1323 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %1324 = load double, ptr %1323, align 8, !tbaa !14
  %1325 = load ptr, ptr %12, align 8, !tbaa !5
  %1326 = load i32, ptr %20, align 4, !tbaa !9
  %1327 = sext i32 %1326 to i64
  %1328 = getelementptr inbounds %struct.doublecomplex, ptr %1325, i64 %1327
  %1329 = getelementptr inbounds %struct.doublecomplex, ptr %1328, i32 0, i32 1
  store double %1324, ptr %1329, align 8, !tbaa !14
  %1330 = load ptr, ptr %9, align 8, !tbaa !5
  %1331 = load i32, ptr %1330, align 4, !tbaa !9
  store i32 %1331, ptr %20, align 4, !tbaa !9
  %1332 = load ptr, ptr %10, align 8, !tbaa !5
  %1333 = load i32, ptr %1332, align 4, !tbaa !9
  %1334 = load i32, ptr %33, align 4, !tbaa !9
  %1335 = add nsw i32 %1333, %1334
  %1336 = add nsw i32 %1335, 1
  store i32 %1336, ptr %34, align 4, !tbaa !9
  br label %1337

1337:                                             ; preds = %1357, %1299
  %1338 = load i32, ptr %34, align 4, !tbaa !9
  %1339 = load i32, ptr %20, align 4, !tbaa !9
  %1340 = icmp sle i32 %1338, %1339
  br i1 %1340, label %1341, label %1360

1341:                                             ; preds = %1337
  %1342 = load i32, ptr %34, align 4, !tbaa !9
  %1343 = load i32, ptr %33, align 4, !tbaa !9
  %1344 = load i32, ptr %17, align 4, !tbaa !9
  %1345 = mul nsw i32 %1343, %1344
  %1346 = add nsw i32 %1342, %1345
  store i32 %1346, ptr %21, align 4, !tbaa !9
  %1347 = load ptr, ptr %12, align 8, !tbaa !5
  %1348 = load i32, ptr %21, align 4, !tbaa !9
  %1349 = sext i32 %1348 to i64
  %1350 = getelementptr inbounds %struct.doublecomplex, ptr %1347, i64 %1349
  %1351 = getelementptr inbounds %struct.doublecomplex, ptr %1350, i32 0, i32 0
  store double 0.000000e+00, ptr %1351, align 8, !tbaa !11
  %1352 = load ptr, ptr %12, align 8, !tbaa !5
  %1353 = load i32, ptr %21, align 4, !tbaa !9
  %1354 = sext i32 %1353 to i64
  %1355 = getelementptr inbounds %struct.doublecomplex, ptr %1352, i64 %1354
  %1356 = getelementptr inbounds %struct.doublecomplex, ptr %1355, i32 0, i32 1
  store double 0.000000e+00, ptr %1356, align 8, !tbaa !14
  br label %1357

1357:                                             ; preds = %1341
  %1358 = load i32, ptr %34, align 4, !tbaa !9
  %1359 = add nsw i32 %1358, 1
  store i32 %1359, ptr %34, align 4, !tbaa !9
  br label %1337, !llvm.loop !25

1360:                                             ; preds = %1337
  br label %1361

1361:                                             ; preds = %1360
  %1362 = load i32, ptr %33, align 4, !tbaa !9
  %1363 = add nsw i32 %1362, 1
  store i32 %1363, ptr %33, align 4, !tbaa !9
  br label %644, !llvm.loop !26

1364:                                             ; preds = %644
  %1365 = load ptr, ptr %9, align 8, !tbaa !5
  %1366 = load i32, ptr %1365, align 4, !tbaa !9
  store i32 %1366, ptr %19, align 4, !tbaa !9
  store i32 1, ptr %34, align 4, !tbaa !9
  br label %1367

1367:                                             ; preds = %1417, %1364
  %1368 = load i32, ptr %34, align 4, !tbaa !9
  %1369 = load i32, ptr %19, align 4, !tbaa !9
  %1370 = icmp sle i32 %1368, %1369
  br i1 %1370, label %1371, label %1420

1371:                                             ; preds = %1367
  %1372 = load ptr, ptr %9, align 8, !tbaa !5
  %1373 = load i32, ptr %1372, align 4, !tbaa !9
  store i32 %1373, ptr %20, align 4, !tbaa !9
  %1374 = load i32, ptr %34, align 4, !tbaa !9
  %1375 = add nsw i32 %1374, 1
  store i32 %1375, ptr %33, align 4, !tbaa !9
  br label %1376

1376:                                             ; preds = %1413, %1371
  %1377 = load i32, ptr %33, align 4, !tbaa !9
  %1378 = load i32, ptr %20, align 4, !tbaa !9
  %1379 = icmp sle i32 %1377, %1378
  br i1 %1379, label %1380, label %1416

1380:                                             ; preds = %1376
  %1381 = load i32, ptr %34, align 4, !tbaa !9
  %1382 = load i32, ptr %33, align 4, !tbaa !9
  %1383 = load i32, ptr %17, align 4, !tbaa !9
  %1384 = mul nsw i32 %1382, %1383
  %1385 = add nsw i32 %1381, %1384
  store i32 %1385, ptr %21, align 4, !tbaa !9
  %1386 = load i32, ptr %33, align 4, !tbaa !9
  %1387 = load i32, ptr %34, align 4, !tbaa !9
  %1388 = load i32, ptr %17, align 4, !tbaa !9
  %1389 = mul nsw i32 %1387, %1388
  %1390 = add nsw i32 %1386, %1389
  store i32 %1390, ptr %22, align 4, !tbaa !9
  %1391 = load ptr, ptr %12, align 8, !tbaa !5
  %1392 = load i32, ptr %22, align 4, !tbaa !9
  %1393 = sext i32 %1392 to i64
  %1394 = getelementptr inbounds %struct.doublecomplex, ptr %1391, i64 %1393
  %1395 = getelementptr inbounds %struct.doublecomplex, ptr %1394, i32 0, i32 0
  %1396 = load double, ptr %1395, align 8, !tbaa !11
  %1397 = load ptr, ptr %12, align 8, !tbaa !5
  %1398 = load i32, ptr %21, align 4, !tbaa !9
  %1399 = sext i32 %1398 to i64
  %1400 = getelementptr inbounds %struct.doublecomplex, ptr %1397, i64 %1399
  %1401 = getelementptr inbounds %struct.doublecomplex, ptr %1400, i32 0, i32 0
  store double %1396, ptr %1401, align 8, !tbaa !11
  %1402 = load ptr, ptr %12, align 8, !tbaa !5
  %1403 = load i32, ptr %22, align 4, !tbaa !9
  %1404 = sext i32 %1403 to i64
  %1405 = getelementptr inbounds %struct.doublecomplex, ptr %1402, i64 %1404
  %1406 = getelementptr inbounds %struct.doublecomplex, ptr %1405, i32 0, i32 1
  %1407 = load double, ptr %1406, align 8, !tbaa !14
  %1408 = load ptr, ptr %12, align 8, !tbaa !5
  %1409 = load i32, ptr %21, align 4, !tbaa !9
  %1410 = sext i32 %1409 to i64
  %1411 = getelementptr inbounds %struct.doublecomplex, ptr %1408, i64 %1410
  %1412 = getelementptr inbounds %struct.doublecomplex, ptr %1411, i32 0, i32 1
  store double %1407, ptr %1412, align 8, !tbaa !14
  br label %1413

1413:                                             ; preds = %1380
  %1414 = load i32, ptr %33, align 4, !tbaa !9
  %1415 = add nsw i32 %1414, 1
  store i32 %1415, ptr %33, align 4, !tbaa !9
  br label %1376, !llvm.loop !27

1416:                                             ; preds = %1376
  br label %1417

1417:                                             ; preds = %1416
  %1418 = load i32, ptr %34, align 4, !tbaa !9
  %1419 = add nsw i32 %1418, 1
  store i32 %1419, ptr %34, align 4, !tbaa !9
  br label %1367, !llvm.loop !28

1420:                                             ; preds = %1367
  store i32 1, ptr %42, align 4
  br label %1421

1421:                                             ; preds = %1420, %101
  call void @llvm.lifetime.end.p0(i64 16, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 16, 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 16, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #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 @xerbla_(ptr noundef, ptr noundef, i32 noundef) #2

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

declare double @dznrm2_(ptr noundef, ptr noundef, ptr noundef) #2

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

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

declare { double, double } @__divdc3(double, double, double, double)

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

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

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

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

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

declare void @zdotc_(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 void @zgemv_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

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

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

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

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

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


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

%struct.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [7 x i8], align 1
@c__3 = external hidden global i32, align 4
@c__1 = external hidden global i32, align 4
@c_b2 = external hidden global %struct.doublecomplex, align 8
@.str.1 = external hidden unnamed_addr constant [6 x i8], align 1
@c_b1 = external hidden global %struct.doublecomplex, align 8
@.str.2 = external hidden unnamed_addr constant [20 x i8], align 1

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

25:                                               ; preds = %8
  %26 = load i32, ptr %1, align 4, !tbaa !5
  %or.cond = icmp ult i32 %26, %23
  br i1 %or.cond, label %27, label %.thread

27:                                               ; preds = %25
  %28 = load i32, ptr %4, align 4, !tbaa !5
  %29 = icmp slt i32 %28, %23
  br i1 %29, label %.thread, label %.lr.ph452.preheader

.thread:                                          ; preds = %27, %25, %8
  %.sink = phi i32 [ -1, %8 ], [ -2, %25 ], [ -5, %27 ]
  %.neg = phi i32 [ 1, %8 ], [ 2, %25 ], [ 5, %27 ]
  store i32 %.sink, ptr %7, align 4, !tbaa !5
  store i32 %.neg, ptr %9, align 4, !tbaa !5
  %30 = call i32 @xerbla_(ptr noundef nonnull @.str, ptr noundef nonnull %9, i32 noundef 6) #8
  br label %.loopexit439

.lr.ph452.preheader:                              ; preds = %27
  %31 = shl nsw i64 %20, 4
  %scevgep = getelementptr i8, ptr %3, i64 %31
  %32 = add i32 %19, 2
  %33 = add i32 %19, 1
  %34 = add nsw i32 %23, -2
  %35 = zext nneg i32 %23 to i64
  %wide.trip.count = zext nneg i32 %23 to i64
  %xtraiter = and i64 %wide.trip.count, 1
  %36 = icmp eq i32 %23, 1
  br i1 %36, label %.lr.ph461.unr-lcssa, label %.lr.ph452.preheader.new

.lr.ph452.preheader.new:                          ; preds = %.lr.ph452.preheader
  %unroll_iter = and i64 %wide.trip.count, 2147483646
  br label %.lr.ph452

.loopexit442:                                     ; preds = %.lr.ph, %.lr.ph452
  %indvars.iv.next540.1 = add nuw nsw i64 %indvars.iv539, 2
  %.not431443.not.1 = icmp ult i64 %indvars.iv.next540, %35
  br i1 %.not431443.not.1, label %.lr.ph.1, label %.loopexit442.1

.lr.ph.1:                                         ; preds = %.loopexit442
  %indvars.iv.next538 = or disjoint i64 %indvars.iv537, 1
  %37 = trunc i64 %indvars.iv.next538 to i32
  %38 = sub i32 %34, %37
  %39 = zext i32 %38 to i64
  %40 = shl nuw nsw i64 %39, 4
  %41 = add nuw nsw i64 %40, 16
  %42 = trunc nuw nsw i64 %indvars.iv.next538 to i32
  %43 = mul i32 %33, %42
  %44 = add i32 %32, %43
  %45 = sext i32 %44 to i64
  %46 = shl nsw i64 %45, 4
  %scevgep533.1 = getelementptr i8, ptr %scevgep, i64 %46
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(1) %scevgep533.1, i8 0, i64 %41, i1 false), !tbaa !9
  br label %.loopexit442.1

.loopexit442.1:                                   ; preds = %.lr.ph.1, %.loopexit442
  %indvars.iv.next538.1 = add nuw nsw i64 %indvars.iv537, 2
  %niter.next.1 = add i64 %niter, 2
  %niter.ncmp.1 = icmp eq i64 %niter.next.1, %unroll_iter
  br i1 %niter.ncmp.1, label %.lr.ph461.unr-lcssa, label %.lr.ph452, !llvm.loop !11

.lr.ph452:                                        ; preds = %.loopexit442.1, %.lr.ph452.preheader.new
  %indvars.iv539 = phi i64 [ 1, %.lr.ph452.preheader.new ], [ %indvars.iv.next540.1, %.loopexit442.1 ]
  %indvars.iv537 = phi i64 [ 0, %.lr.ph452.preheader.new ], [ %indvars.iv.next538.1, %.loopexit442.1 ]
  %niter = phi i64 [ 0, %.lr.ph452.preheader.new ], [ %niter.next.1, %.loopexit442.1 ]
  %indvars.iv.next540 = add nuw nsw i64 %indvars.iv539, 1
  %.not431443.not = icmp ult i64 %indvars.iv539, %35
  br i1 %.not431443.not, label %.lr.ph, label %.loopexit442

.lr.ph:                                           ; preds = %.lr.ph452
  %47 = trunc i64 %indvars.iv537 to i32
  %48 = sub i32 %34, %47
  %49 = zext i32 %48 to i64
  %50 = shl nuw nsw i64 %49, 4
  %51 = add nuw nsw i64 %50, 16
  %52 = trunc nuw nsw i64 %indvars.iv537 to i32
  %53 = mul i32 %33, %52
  %54 = add i32 %32, %53
  %55 = sext i32 %54 to i64
  %56 = shl nsw i64 %55, 4
  %scevgep533 = getelementptr i8, ptr %scevgep, i64 %56
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(1) %scevgep533, i8 0, i64 %51, i1 false), !tbaa !9
  br label %.loopexit442

.lr.ph461.unr-lcssa:                              ; preds = %.loopexit442.1, %.lr.ph452.preheader
  %indvars.iv539.unr = phi i64 [ 1, %.lr.ph452.preheader ], [ %indvars.iv.next540.1, %.loopexit442.1 ]
  %indvars.iv537.unr = phi i64 [ 0, %.lr.ph452.preheader ], [ %indvars.iv.next538.1, %.loopexit442.1 ]
  %lcmp.mod.not = icmp ne i64 %xtraiter, 0
  %.not431443.not.epil = icmp ult i64 %indvars.iv539.unr, %35
  %or.cond920 = select i1 %lcmp.mod.not, i1 %.not431443.not.epil, i1 false
  br i1 %or.cond920, label %.lr.ph.epil, label %.lr.ph461

.lr.ph.epil:                                      ; preds = %.lr.ph461.unr-lcssa
  %57 = trunc i64 %indvars.iv537.unr to i32
  %58 = sub i32 %34, %57
  %59 = zext i32 %58 to i64
  %60 = shl nuw nsw i64 %59, 4
  %61 = add nuw nsw i64 %60, 16
  %62 = trunc nuw nsw i64 %indvars.iv537.unr to i32
  %63 = mul i32 %33, %62
  %64 = add i32 %32, %63
  %65 = sext i32 %64 to i64
  %66 = shl nsw i64 %65, 4
  %scevgep533.epil = getelementptr i8, ptr %scevgep, i64 %66
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(1) %scevgep533.epil, i8 0, i64 %61, i1 false), !tbaa !9
  br label %.lr.ph461

.lr.ph461:                                        ; preds = %.lr.ph.epil, %.lr.ph461.unr-lcssa
  store i32 %23, ptr %10, align 4, !tbaa !5
  %67 = add i32 %19, 1
  %68 = zext nneg i32 %23 to i64
  %xtraiter879 = and i64 %68, 1
  %69 = icmp eq i32 %23, 1
  br i1 %69, label %.preheader.unr-lcssa, label %.lr.ph461.new

.lr.ph461.new:                                    ; preds = %.lr.ph461
  %unroll_iter883 = and i64 %68, 2147483646
  br label %120

.preheader.unr-lcssa:                             ; preds = %120, %.lr.ph461
  %.lcssa878.ph = phi i32 [ poison, %.lr.ph461 ], [ %129, %120 ]
  %.lcssa877.ph = phi i32 [ poison, %.lr.ph461 ], [ %130, %120 ]
  %indvars.iv545.unr = phi i64 [ 1, %.lr.ph461 ], [ %indvars.iv.next546.1, %120 ]
  %lcmp.mod880.not = icmp eq i64 %xtraiter879, 0
  br i1 %lcmp.mod880.not, label %.preheader, label %.preheader.epilog-lcssa

.preheader.epilog-lcssa:                          ; preds = %.preheader.unr-lcssa
  %70 = trunc nuw nsw i64 %indvars.iv545.unr to i32
  %71 = mul i32 %67, %70
  %72 = getelementptr inbounds double, ptr %18, i64 %indvars.iv545.unr
  %73 = load double, ptr %72, align 8, !tbaa !9
  %74 = sext i32 %71 to i64
  %75 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %74
  store double %73, ptr %75, align 8, !tbaa !13
  %76 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %74, i32 1
  store double 0.000000e+00, ptr %76, align 8, !tbaa !15
  br label %.preheader

.preheader:                                       ; preds = %.preheader.unr-lcssa, %.preheader.epilog-lcssa
  %.lcssa878 = phi i32 [ %.lcssa878.ph, %.preheader.unr-lcssa ], [ %70, %.preheader.epilog-lcssa ]
  %.lcssa877 = phi i32 [ %.lcssa877.ph, %.preheader.unr-lcssa ], [ %71, %.preheader.epilog-lcssa ]
  store i32 %.lcssa878, ptr %11, align 4, !tbaa !5
  %77 = icmp sgt i32 %23, 1
  br i1 %77, label %.lr.ph489, label %._crit_edge490

.lr.ph489:                                        ; preds = %.preheader
  %.2417.neg486 = sub nsw i32 1, %23
  %78 = getelementptr inbounds i8, ptr %6, i64 16
  %79 = getelementptr inbounds i8, ptr %17, i64 8
  %80 = add i32 %19, 1
  %81 = zext nneg i32 %23 to i64
  %82 = sext i32 %19 to i64
  %83 = add nsw i64 %wide.trip.count, -1
  %84 = mul nsw i64 %83, %82
  %85 = add i64 %84, %20
  %86 = add i64 %85, %wide.trip.count
  %87 = shl i64 %86, 4
  %88 = shl nsw i64 %82, 4
  %89 = sub nuw nsw i64 -16, %88
  %90 = add nsw i64 %88, 16
  %91 = mul nsw i64 %83, %82
  %92 = add i64 %91, %20
  %93 = add i64 %92, %wide.trip.count
  %94 = shl i64 %93, 4
  %95 = add nsw i64 %wide.trip.count, -1
  %96 = mul nsw i64 %95, %82
  %97 = add i64 %96, %20
  %98 = add i64 %97, %wide.trip.count
  %99 = shl i64 %98, 4
  %100 = shl nsw i64 %82, 4
  %101 = sub nuw nsw i64 -16, %100
  %102 = add nsw i64 %100, 16
  %scevgep640 = getelementptr i8, ptr %6, i64 8
  %scevgep643 = getelementptr i8, ptr %6, i64 8
  %scevgep645 = getelementptr i8, ptr %6, i64 8
  %103 = mul nsw i64 %95, %82
  %104 = add i64 %103, %20
  %105 = add i64 %104, %wide.trip.count
  %106 = shl i64 %105, 4
  %scevgep653 = getelementptr i8, ptr %6, i64 8
  %scevgep654 = getelementptr i8, ptr %6, i64 16
  %scevgep656 = getelementptr i8, ptr %6, i64 16
  %scevgep658 = getelementptr i8, ptr %6, i64 16
  %107 = getelementptr i8, ptr %3, i64 %99
  %108 = getelementptr i8, ptr %107, i64 -16
  %109 = getelementptr i8, ptr %3, i64 %99
  %110 = getelementptr i8, ptr %109, i64 -8
  %111 = getelementptr i8, ptr %3, i64 %106
  %112 = getelementptr i8, ptr %111, i64 -8
  %113 = getelementptr i8, ptr %3, i64 %99
  %invariant.gep910 = getelementptr i8, ptr %6, i64 16
  %114 = getelementptr i8, ptr %3, i64 %94
  %115 = getelementptr i8, ptr %114, i64 -8
  %116 = getelementptr i8, ptr %3, i64 %87
  %117 = getelementptr i8, ptr %116, i64 -8
  %118 = getelementptr i8, ptr %3, i64 %87
  %119 = getelementptr i8, ptr %118, i64 -16
  %invariant.gep906 = getelementptr i8, ptr %22, i64 16
  %invariant.gep908 = getelementptr i8, ptr %22, i64 16
  br label %139

120:                                              ; preds = %120, %.lr.ph461.new
  %indvars.iv545 = phi i64 [ 1, %.lr.ph461.new ], [ %indvars.iv.next546.1, %120 ]
  %niter884 = phi i64 [ 0, %.lr.ph461.new ], [ %niter884.next.1, %120 ]
  %121 = trunc nuw nsw i64 %indvars.iv545 to i32
  %122 = mul i32 %67, %121
  %123 = getelementptr inbounds double, ptr %18, i64 %indvars.iv545
  %124 = load double, ptr %123, align 8, !tbaa !9
  %125 = sext i32 %122 to i64
  %126 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %125
  store double %124, ptr %126, align 8, !tbaa !13
  %127 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %125, i32 1
  store double 0.000000e+00, ptr %127, align 8, !tbaa !15
  %128 = trunc i64 %indvars.iv545 to i32
  %129 = add i32 %128, 1
  %130 = mul i32 %67, %129
  %131 = getelementptr double, ptr %2, i64 %indvars.iv545
  %132 = load double, ptr %131, align 8, !tbaa !9
  %133 = sext i32 %130 to i64
  %134 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %133
  store double %132, ptr %134, align 8, !tbaa !13
  %135 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %133, i32 1
  store double 0.000000e+00, ptr %135, align 8, !tbaa !15
  %indvars.iv.next546.1 = add nuw nsw i64 %indvars.iv545, 2
  %niter884.next.1 = add i64 %niter884, 2
  %niter884.ncmp.1 = icmp eq i64 %niter884.next.1, %unroll_iter883
  br i1 %niter884.ncmp.1, label %.preheader.unr-lcssa, label %120, !llvm.loop !16

..loopexit441_crit_edge:                          ; preds = %.loopexit859
  %136 = trunc nsw i64 %.lcssa619 to i32
  store <2 x double> %349, ptr %13, align 16, !tbaa !9
  store <2 x double> %350, ptr %12, align 16, !tbaa !9
  br label %.loopexit441

.loopexit441:                                     ; preds = %..loopexit441_crit_edge, %187
  %.lcssa465474.lcssa = phi i32 [ %136, %..loopexit441_crit_edge ], [ %.promoted473, %187 ]
  %.lcssa472 = phi i32 [ %219, %..loopexit441_crit_edge ], [ %.promoted471, %187 ]
  store i32 %.lcssa472, ptr %10, align 4, !tbaa !5
  store i32 %.lcssa465474.lcssa, ptr %11, align 4, !tbaa !5
  %137 = trunc i64 %indvars.iv560 to i32
  %.2417.neg = sub i32 2, %137
  %138 = icmp sgt i64 %indvars.iv560, 2
  %indvar.next624 = add i64 %indvar623, 1
  br i1 %138, label %139, label %._crit_edge490.loopexit, !llvm.loop !17

139:                                              ; preds = %.lr.ph489, %.loopexit441
  %indvar623 = phi i64 [ 0, %.lr.ph489 ], [ %indvar.next624, %.loopexit441 ]
  %.promoted473 = phi i32 [ %.lcssa878, %.lr.ph489 ], [ %.lcssa465474.lcssa, %.loopexit441 ]
  %.promoted471 = phi i32 [ %.lcssa877, %.lr.ph489 ], [ %.lcssa472, %.loopexit441 ]
  %140 = phi i32 [ %23, %.lr.ph489 ], [ %219, %.loopexit441 ]
  %indvars.iv560 = phi i64 [ %81, %.lr.ph489 ], [ %indvars.iv.next561, %.loopexit441 ]
  %indvars.iv550.in = phi i64 [ %81, %.lr.ph489 ], [ %indvars.iv550, %.loopexit441 ]
  %.2417.neg488 = phi i32 [ %.2417.neg486, %.lr.ph489 ], [ %.2417.neg, %.loopexit441 ]
  %141 = mul i64 %101, %indvar623
  %142 = mul i64 %89, %indvar623
  %indvars.iv550 = add nsw i64 %indvars.iv550.in, -1
  %indvars.iv.next561 = add nsw i64 %indvars.iv560, -1
  %143 = add i32 %.2417.neg488, 1
  %144 = add i32 %143, %140
  store i32 %144, ptr %9, align 4, !tbaa !5
  call void @zlarnv_(ptr noundef nonnull @c__3, ptr noundef %5, ptr noundef nonnull %9, ptr noundef %6) #8
  %145 = load i32, ptr %0, align 4, !tbaa !5
  %146 = add i32 %143, %145
  store i32 %146, ptr %9, align 4, !tbaa !5
  %147 = call double @dznrm2_(ptr noundef nonnull %9, ptr noundef %6, ptr noundef nonnull @c__1) #8
  %148 = call { double, double } @Cd(ptr noundef %6)
  %149 = extractvalue { double, double } %148, 0
  %150 = extractvalue { double, double } %148, 1
  %151 = call double @cabs(double noundef %149, double noundef %150) #8
  %152 = fdiv double %147, %151
  %153 = load <2 x double>, ptr %6, align 8, !tbaa !9
  %154 = insertelement <2 x double> poison, double %152, i64 0
  %155 = shufflevector <2 x double> %154, <2 x double> poison, <2 x i32> zeroinitializer
  %156 = fmul <2 x double> %155, %153
  store <2 x double> %156, ptr %12, align 16, !tbaa !9
  store <2 x double> %156, ptr %15, align 16, !tbaa !9
  %157 = fcmp oeq double %147, 0.000000e+00
  br i1 %157, label %158, label %159

158:                                              ; preds = %139
  %.pre592 = trunc nuw nsw i64 %indvars.iv.next561 to i32
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(16) %17, i8 0, i64 16, i1 false)
  br label %187

159:                                              ; preds = %139
  %160 = fadd <2 x double> %153, %156
  store <2 x double> %160, ptr %12, align 16, !tbaa !9
  store <2 x double> %160, ptr %16, align 16, !tbaa !9
  %161 = load i32, ptr %0, align 4, !tbaa !5
  %162 = trunc nuw nsw i64 %indvars.iv.next561 to i32
  %163 = sub nsw i32 %161, %162
  store i32 %163, ptr %9, align 4, !tbaa !5
  %164 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %165 = extractvalue { double, double } %164, 0
  %166 = extractvalue { double, double } %164, 1
  %167 = call { double, double } @Cd(ptr noundef nonnull %16)
  %168 = extractvalue { double, double } %167, 0
  %169 = extractvalue { double, double } %167, 1
  %170 = call { double, double } @__divdc3(double noundef %165, double noundef %166, double noundef %168, double noundef %169) #8
  %171 = extractvalue { double, double } %170, 0
  %172 = extractvalue { double, double } %170, 1
  %173 = call ptr @_pCd(ptr noundef nonnull %12)
  %174 = getelementptr inbounds i8, ptr %173, i64 8
  store double %171, ptr %173, align 8
  store double %172, ptr %174, align 8
  call void @zscal_(ptr noundef nonnull %9, ptr noundef nonnull %12, ptr noundef nonnull %78, ptr noundef nonnull @c__1) #8
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %6, align 8, !tbaa !9
  %175 = call { double, double } @Cd(ptr noundef nonnull %16)
  %176 = extractvalue { double, double } %175, 0
  %177 = extractvalue { double, double } %175, 1
  %178 = call { double, double } @Cd(ptr noundef nonnull %15)
  %179 = extractvalue { double, double } %178, 0
  %180 = extractvalue { double, double } %178, 1
  %181 = call { double, double } @__divdc3(double noundef %176, double noundef %177, double noundef %179, double noundef %180) #8
  %182 = extractvalue { double, double } %181, 0
  %183 = extractvalue { double, double } %181, 1
  %184 = call ptr @_pCd(ptr noundef nonnull %12)
  %185 = getelementptr inbounds i8, ptr %184, i64 8
  store double %182, ptr %184, align 8
  store double %183, ptr %185, align 8
  %186 = load double, ptr %12, align 16, !tbaa !13
  store double %186, ptr %17, align 16, !tbaa !13
  store double 0.000000e+00, ptr %79, align 8, !tbaa !15
  br label %187

187:                                              ; preds = %159, %158
  %.pre-phi = phi i32 [ %162, %159 ], [ %.pre592, %158 ]
  %188 = load i32, ptr %0, align 4, !tbaa !5
  %189 = add i32 %143, %188
  store i32 %189, ptr %9, align 4, !tbaa !5
  call void @zlacgv_(ptr noundef nonnull %9, ptr noundef nonnull %6, ptr noundef nonnull @c__1) #8
  %190 = load i32, ptr %0, align 4, !tbaa !5
  %191 = add i32 %143, %190
  store i32 %191, ptr %9, align 4, !tbaa !5
  %192 = mul i32 %.pre-phi, %80
  %193 = sext i32 %192 to i64
  %194 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %193
  %195 = sext i32 %190 to i64
  %gep = getelementptr %struct.doublecomplex, ptr %6, i64 %195
  call void @zsymv_(ptr noundef nonnull @.str.1, ptr noundef nonnull %9, ptr noundef nonnull %17, ptr noundef %194, ptr noundef nonnull %4, ptr noundef nonnull %6, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %gep, ptr noundef nonnull @c__1) #8
  %196 = load i32, ptr %0, align 4, !tbaa !5
  %197 = add i32 %143, %196
  store i32 %197, ptr %9, align 4, !tbaa !5
  call void @zlacgv_(ptr noundef nonnull %9, ptr noundef nonnull %6, ptr noundef nonnull @c__1) #8
  %198 = load double, ptr %17, align 16, !tbaa !13
  %199 = load double, ptr %79, align 8, !tbaa !15
  %200 = fmul double %199, -0.000000e+00
  %201 = call double @llvm.fmuladd.f64(double %198, double -5.000000e-01, double %200)
  %202 = fmul double %198, 0.000000e+00
  %203 = call double @llvm.fmuladd.f64(double %199, double -5.000000e-01, double %202)
  %204 = load i32, ptr %0, align 4, !tbaa !5
  %205 = add i32 %143, %204
  store i32 %205, ptr %9, align 4, !tbaa !5
  %206 = sext i32 %204 to i64
  %gep482 = getelementptr %struct.doublecomplex, ptr %6, i64 %206
  call void @zdotc_(ptr noundef nonnull %13, ptr noundef nonnull %9, ptr noundef nonnull %6, ptr noundef nonnull @c__1, ptr noundef %gep482, ptr noundef nonnull @c__1) #8
  %207 = fneg double %203
  %208 = load <2 x double>, ptr %13, align 16, !tbaa !9
  %209 = insertelement <2 x double> poison, double %203, i64 0
  %210 = insertelement <2 x double> %209, double %207, i64 1
  %211 = fmul <2 x double> %208, %210
  %212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %213 = insertelement <2 x double> poison, double %201, i64 0
  %214 = shufflevector <2 x double> %213, <2 x double> poison, <2 x i32> zeroinitializer
  %215 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %214, <2 x double> %208, <2 x double> %212)
  store <2 x double> %215, ptr %12, align 16, !tbaa !9
  store <2 x double> %215, ptr %14, align 16, !tbaa !9
  %216 = load i32, ptr %0, align 4, !tbaa !5
  %217 = add i32 %143, %216
  store i32 %217, ptr %9, align 4, !tbaa !5
  %218 = sext i32 %216 to i64
  %gep484 = getelementptr %struct.doublecomplex, ptr %6, i64 %218
  call void @zaxpy_(ptr noundef nonnull %9, ptr noundef nonnull %14, ptr noundef nonnull %6, ptr noundef nonnull @c__1, ptr noundef %gep484, ptr noundef nonnull @c__1) #8
  %219 = load i32, ptr %0, align 4, !tbaa !5
  store i32 %219, ptr %9, align 4, !tbaa !5
  %220 = sext i32 %219 to i64
  %.not429475 = icmp sgt i64 %indvars.iv.next561, %220
  br i1 %.not429475, label %.loopexit441, label %.lr.ph478

.lr.ph478:                                        ; preds = %187
  %221 = add i32 %219, %.2417.neg488
  %222 = add i32 %219, 1
  %223 = zext i32 %221 to i64
  %224 = shl nuw nsw i64 %223, 4
  %scevgep641 = getelementptr i8, ptr %scevgep640, i64 %224
  %scevgep655 = getelementptr i8, ptr %scevgep654, i64 %224
  %225 = add i64 %indvar623, 2
  %226 = getelementptr i8, ptr %108, i64 %141
  %227 = getelementptr i8, ptr %110, i64 %141
  %228 = add i64 %indvar623, 1
  %229 = getelementptr i8, ptr %112, i64 %141
  %230 = getelementptr i8, ptr %113, i64 %141
  %231 = getelementptr i8, ptr %115, i64 %142
  %232 = getelementptr i8, ptr %117, i64 %142
  %233 = getelementptr i8, ptr %119, i64 %142
  %234 = add i64 %indvar623, 1
  br label %235

235:                                              ; preds = %.lr.ph478, %.loopexit859
  %indvar625 = phi i64 [ 0, %.lr.ph478 ], [ %indvar.next626, %.loopexit859 ]
  %indvars.iv552 = phi i64 [ %indvars.iv550, %.lr.ph478 ], [ %indvars.iv.next553, %.loopexit859 ]
  %smax689 = call i64 @llvm.smax.i64(i64 %indvars.iv552, i64 %220)
  %236 = add i64 %indvar625, %wide.trip.count
  %237 = sub i64 %225, %236
  %238 = add i64 %smax689, %237
  %239 = mul i64 %102, %indvar625
  %scevgep636 = getelementptr i8, ptr %226, i64 %239
  %scevgep637 = getelementptr i8, ptr %227, i64 %239
  %smax638 = call i64 @llvm.smax.i64(i64 %indvars.iv552, i64 %220)
  %240 = add i64 %indvar625, %wide.trip.count
  %241 = sub i64 %228, %240
  %242 = add i64 %smax638, %241
  %243 = shl nsw i64 %242, 4
  %scevgep639 = getelementptr i8, ptr %scevgep637, i64 %243
  %244 = trunc i64 %indvar625 to i32
  %245 = add i32 %219, %244
  %246 = sext i32 %245 to i64
  %247 = shl nsw i64 %246, 4
  %scevgep642 = getelementptr i8, ptr %6, i64 %247
  %248 = add i64 %243, %247
  %scevgep644 = getelementptr i8, ptr %scevgep643, i64 %248
  %scevgep646 = getelementptr i8, ptr %scevgep645, i64 %247
  %249 = shl nuw nsw i64 %indvar625, 4
  %scevgep647 = getelementptr i8, ptr %6, i64 %249
  %250 = or disjoint i64 %249, 8
  %scevgep648 = getelementptr i8, ptr %6, i64 %250
  %scevgep649 = getelementptr i8, ptr %scevgep648, i64 %243
  %scevgep650 = getelementptr i8, ptr %229, i64 %239
  %scevgep651 = getelementptr i8, ptr %230, i64 %239
  %scevgep652 = getelementptr i8, ptr %scevgep651, i64 %243
  %scevgep657 = getelementptr i8, ptr %scevgep656, i64 %248
  %scevgep659 = getelementptr i8, ptr %scevgep658, i64 %247
  %gep911 = getelementptr i8, ptr %invariant.gep910, i64 %249
  %scevgep661 = getelementptr i8, ptr %gep911, i64 %243
  %251 = mul nsw i64 %indvars.iv552, %82
  %252 = trunc nsw i64 %indvars.iv552 to i32
  %253 = add i32 %221, %252
  %254 = sext i32 %253 to i64
  %255 = getelementptr %struct.doublecomplex, ptr %22, i64 %254
  %256 = getelementptr i8, ptr %255, i64 16
  %257 = getelementptr i8, ptr %255, i64 24
  %258 = sub nuw nsw i64 %indvars.iv552, %indvars.iv.next561
  %259 = getelementptr %struct.doublecomplex, ptr %22, i64 %258
  %260 = getelementptr i8, ptr %259, i64 16
  %261 = getelementptr i8, ptr %259, i64 24
  %min.iters.check = icmp ult i64 %238, 8
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %235
  %262 = mul i64 %90, %indvar625
  %scevgep632 = getelementptr i8, ptr %231, i64 %262
  %scevgep628 = getelementptr i8, ptr %232, i64 %262
  %scevgep627 = getelementptr i8, ptr %233, i64 %262
  %263 = trunc i64 %indvar625 to i32
  %264 = add i32 %219, %263
  %smax = call i64 @llvm.smax.i64(i64 %indvars.iv552, i64 %220)
  %265 = add i64 %indvar625, %wide.trip.count
  %266 = sub i64 %234, %265
  %267 = add i64 %smax, %266
  %268 = trunc i64 %267 to i32
  %269 = add i32 %264, %268
  %270 = icmp slt i32 %269, %264
  %271 = icmp ugt i64 %267, 4294967295
  %272 = or i1 %270, %271
  %mul.result = shl i64 %267, 4
  %273 = getelementptr i8, ptr %scevgep627, i64 %mul.result
  %274 = icmp ult ptr %273, %scevgep627
  %mul.result630 = shl i64 %267, 4
  %275 = getelementptr i8, ptr %scevgep628, i64 %mul.result630
  %276 = icmp ult ptr %275, %scevgep628
  %mul.result634 = shl i64 %267, 4
  %277 = getelementptr i8, ptr %scevgep632, i64 %mul.result634
  %278 = icmp ult ptr %277, %scevgep632
  %279 = or i1 %274, %272
  %280 = or i1 %276, %279
  %281 = or i1 %278, %280
  br i1 %281, label %scalar.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %vector.scevcheck
  %bound0 = icmp ult ptr %scevgep636, %scevgep641
  %bound1 = icmp ugt ptr %scevgep639, %6
  %found.conflict = and i1 %bound0, %bound1
  %bound0662 = icmp ult ptr %scevgep636, %scevgep644
  %bound1663 = icmp ult ptr %scevgep642, %scevgep639
  %found.conflict664 = and i1 %bound0662, %bound1663
  %conflict.rdx = or i1 %found.conflict, %found.conflict664
  %bound0665 = icmp ult ptr %scevgep636, %scevgep646
  %bound1666 = icmp ult ptr %scevgep642, %scevgep639
  %found.conflict667 = and i1 %bound0665, %bound1666
  %conflict.rdx668 = or i1 %conflict.rdx, %found.conflict667
  %bound0669 = icmp ult ptr %scevgep636, %scevgep649
  %bound1670 = icmp ult ptr %scevgep647, %scevgep639
  %found.conflict671 = and i1 %bound0669, %bound1670
  %conflict.rdx672 = or i1 %conflict.rdx668, %found.conflict671
  %bound0673 = icmp ult ptr %scevgep650, %scevgep655
  %bound1674 = icmp ult ptr %scevgep653, %scevgep652
  %found.conflict675 = and i1 %bound0673, %bound1674
  %conflict.rdx676 = or i1 %conflict.rdx672, %found.conflict675
  %bound0677 = icmp ult ptr %scevgep650, %scevgep657
  %bound1678 = icmp ult ptr %scevgep646, %scevgep652
  %found.conflict679 = and i1 %bound0677, %bound1678
  %conflict.rdx680 = or i1 %conflict.rdx676, %found.conflict679
  %bound0681 = icmp ult ptr %scevgep650, %scevgep659
  %bound1682 = icmp ult ptr %scevgep646, %scevgep652
  %found.conflict683 = and i1 %bound0681, %bound1682
  %conflict.rdx684 = or i1 %conflict.rdx680, %found.conflict683
  %bound0685 = icmp ult ptr %scevgep650, %scevgep661
  %bound1686 = icmp ult ptr %scevgep648, %scevgep652
  %found.conflict687 = and i1 %bound0685, %bound1686
  %conflict.rdx688 = or i1 %conflict.rdx684, %found.conflict687
  br i1 %conflict.rdx688, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %vector.memcheck
  %n.vec = and i64 %238, -2
  %ind.end = add i64 %indvars.iv552, %n.vec
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %offset.idx = add i64 %indvars.iv552, %index
  %offset.idx690 = add i64 %indvars.iv552, %index
  %282 = trunc i64 %offset.idx690 to i32
  %283 = add nsw i64 %offset.idx, %251
  %284 = sub nsw i64 %offset.idx, %indvars.iv.next561
  %gep907 = getelementptr %struct.doublecomplex, ptr %invariant.gep906, i64 %284
  %wide.vec = load <4 x double>, ptr %gep907, align 8, !tbaa !9
  %strided.vec = shufflevector <4 x double> %wide.vec, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec691 = shufflevector <4 x double> %wide.vec, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %285 = load double, ptr %256, align 8, !tbaa !13, !alias.scope !18
  %broadcast.splatinsert692 = insertelement <2 x double> poison, double %285, i64 0
  %broadcast.splat693 = shufflevector <2 x double> %broadcast.splatinsert692, <2 x double> poison, <2 x i32> zeroinitializer
  %286 = load double, ptr %257, align 8, !tbaa !15, !alias.scope !21
  %broadcast.splatinsert = insertelement <2 x double> poison, double %286, i64 0
  %broadcast.splat = shufflevector <2 x double> %broadcast.splatinsert, <2 x double> poison, <2 x i32> zeroinitializer
  %287 = fneg <2 x double> %strided.vec691
  %288 = fmul <2 x double> %broadcast.splat, %287
  %289 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec, <2 x double> %broadcast.splat693, <2 x double> %288)
  %290 = fmul <2 x double> %broadcast.splat693, %strided.vec691
  %291 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec, <2 x double> %broadcast.splat, <2 x double> %290)
  %292 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %283
  %wide.vec694 = load <4 x double>, ptr %292, align 8, !tbaa !9
  %strided.vec695 = shufflevector <4 x double> %wide.vec694, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec696 = shufflevector <4 x double> %wide.vec694, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %293 = fsub <2 x double> %strided.vec695, %289
  %294 = fsub <2 x double> %strided.vec696, %291
  %295 = add i32 %221, %282
  %296 = sext i32 %295 to i64
  %gep909 = getelementptr %struct.doublecomplex, ptr %invariant.gep908, i64 %296
  %wide.vec697 = load <4 x double>, ptr %gep909, align 8, !tbaa !9
  %strided.vec698 = shufflevector <4 x double> %wide.vec697, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec699 = shufflevector <4 x double> %wide.vec697, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %297 = load double, ptr %260, align 8, !tbaa !13, !alias.scope !23
  %broadcast.splatinsert702 = insertelement <2 x double> poison, double %297, i64 0
  %broadcast.splat703 = shufflevector <2 x double> %broadcast.splatinsert702, <2 x double> poison, <2 x i32> zeroinitializer
  %298 = load double, ptr %261, align 8, !tbaa !15, !alias.scope !25
  %broadcast.splatinsert700 = insertelement <2 x double> poison, double %298, i64 0
  %broadcast.splat701 = shufflevector <2 x double> %broadcast.splatinsert700, <2 x double> poison, <2 x i32> zeroinitializer
  %299 = fneg <2 x double> %strided.vec699
  %300 = fmul <2 x double> %broadcast.splat701, %299
  %301 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec698, <2 x double> %broadcast.splat703, <2 x double> %300)
  %302 = fmul <2 x double> %broadcast.splat703, %strided.vec699
  %303 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec698, <2 x double> %broadcast.splat701, <2 x double> %302)
  %304 = fsub <2 x double> %293, %301
  %305 = fsub <2 x double> %294, %303
  %306 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %283
  %interleaved.vec = shufflevector <2 x double> %304, <2 x double> %305, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec, ptr %306, align 8, !tbaa !9
  %index.next = add nuw i64 %index, 2
  %307 = icmp eq i64 %index.next, %n.vec
  br i1 %307, label %middle.block, label %vector.body, !llvm.loop !27

middle.block:                                     ; preds = %vector.body
  %308 = add i64 %offset.idx, 1
  %309 = add nsw i64 %308, %251
  %cmp.n = icmp eq i64 %238, %n.vec
  %310 = shufflevector <2 x double> %301, <2 x double> %303, <2 x i32> <i32 1, i32 3>
  %311 = shufflevector <2 x double> %304, <2 x double> %305, <2 x i32> <i32 1, i32 3>
  br i1 %cmp.n, label %.loopexit859, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %vector.memcheck, %vector.scevcheck, %235
  %indvars.iv554.ph = phi i64 [ %indvars.iv552, %vector.memcheck ], [ %indvars.iv552, %vector.scevcheck ], [ %indvars.iv552, %235 ], [ %ind.end, %middle.block ]
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv554 = phi i64 [ %indvars.iv.next555, %scalar.ph ], [ %indvars.iv554.ph, %scalar.ph.preheader ]
  %312 = add nsw i64 %indvars.iv554, %251
  %313 = sub nsw i64 %indvars.iv554, %indvars.iv.next561
  %314 = getelementptr %struct.doublecomplex, ptr %22, i64 %313
  %315 = getelementptr i8, ptr %314, i64 16
  %316 = load double, ptr %315, align 8, !tbaa !13
  %317 = getelementptr i8, ptr %314, i64 24
  %318 = load double, ptr %317, align 8, !tbaa !15
  %319 = fneg double %318
  %320 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %312
  %321 = trunc nsw i64 %indvars.iv554 to i32
  %322 = add i32 %221, %321
  %323 = sext i32 %322 to i64
  %324 = getelementptr %struct.doublecomplex, ptr %22, i64 %323
  %325 = getelementptr i8, ptr %324, i64 16
  %326 = load double, ptr %325, align 8, !tbaa !13
  %327 = getelementptr i8, ptr %324, i64 24
  %328 = load double, ptr %327, align 8, !tbaa !15
  %329 = fneg double %328
  %330 = load <2 x double>, ptr %260, align 8, !tbaa !9
  %331 = insertelement <2 x double> poison, double %328, i64 0
  %332 = insertelement <2 x double> %331, double %329, i64 1
  %333 = fmul <2 x double> %330, %332
  %334 = shufflevector <2 x double> %333, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %335 = insertelement <2 x double> poison, double %326, i64 0
  %336 = shufflevector <2 x double> %335, <2 x double> poison, <2 x i32> zeroinitializer
  %337 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %336, <2 x double> %330, <2 x double> %334)
  %338 = load <2 x double>, ptr %256, align 8, !tbaa !9
  %339 = insertelement <2 x double> poison, double %318, i64 0
  %340 = insertelement <2 x double> %339, double %319, i64 1
  %341 = fmul <2 x double> %338, %340
  %342 = shufflevector <2 x double> %341, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %343 = insertelement <2 x double> poison, double %316, i64 0
  %344 = shufflevector <2 x double> %343, <2 x double> poison, <2 x i32> zeroinitializer
  %345 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> %338, <2 x double> %342)
  %346 = load <2 x double>, ptr %320, align 8, !tbaa !9
  %347 = fsub <2 x double> %346, %345
  %348 = fsub <2 x double> %347, %337
  store <2 x double> %348, ptr %320, align 8, !tbaa !9
  %indvars.iv.next555 = add nuw nsw i64 %indvars.iv554, 1
  %.not430.not = icmp slt i64 %indvars.iv554, %220
  br i1 %.not430.not, label %scalar.ph, label %.loopexit859, !llvm.loop !30

.loopexit859:                                     ; preds = %scalar.ph, %middle.block
  %.lcssa619 = phi i64 [ %309, %middle.block ], [ %312, %scalar.ph ]
  %349 = phi <2 x double> [ %310, %middle.block ], [ %337, %scalar.ph ]
  %350 = phi <2 x double> [ %311, %middle.block ], [ %348, %scalar.ph ]
  %indvars.iv.next553 = add nsw i64 %indvars.iv552, 1
  %lftr.wideiv558 = trunc i64 %indvars.iv.next553 to i32
  %exitcond559.not = icmp eq i32 %222, %lftr.wideiv558
  %indvar.next626 = add i64 %indvar625, 1
  br i1 %exitcond559.not, label %..loopexit441_crit_edge, label %235, !llvm.loop !31

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

._crit_edge490:                                   ; preds = %._crit_edge490.loopexit, %.preheader
  %351 = phi i32 [ %.pre, %._crit_edge490.loopexit ], [ %26, %.preheader ]
  %352 = phi i32 [ %219, %._crit_edge490.loopexit ], [ %23, %.preheader ]
  %353 = xor i32 %351, -1
  %354 = add i32 %352, %353
  store i32 %354, ptr %9, align 4, !tbaa !5
  %.not423506 = icmp slt i32 %354, 1
  br i1 %.not423506, label %._crit_edge510, label %.lr.ph509

.lr.ph509:                                        ; preds = %._crit_edge490
  %355 = getelementptr inbounds i8, ptr %17, i64 8
  %356 = add i32 %19, 1
  %357 = sext i32 %19 to i64
  %358 = shl nsw i64 %20, 4
  %scevgep569 = getelementptr i8, ptr %3, i64 %358
  %359 = add i32 %19, 2
  %360 = add i32 %19, 1
  %361 = shl nsw i64 %20, 4
  %362 = shl nsw i64 %357, 4
  %363 = add nsw i64 %362, 16
  %364 = add nsw i64 %362, %361
  %365 = shl nsw i64 %357, 4
  %366 = or disjoint i64 %361, 8
  %367 = or disjoint i64 %364, 8
  %scevgep730 = getelementptr i8, ptr %6, i64 8
  %scevgep737 = getelementptr i8, ptr %6, i64 8
  %368 = shl nsw i64 %20, 4
  %369 = shl nsw i64 %357, 4
  %370 = add nsw i64 %369, 16
  %371 = or disjoint i64 %368, 8
  %372 = add nsw i64 %369, %368
  %373 = shl nsw i64 %357, 4
  %374 = or disjoint i64 %372, 8
  %scevgep751 = getelementptr i8, ptr %6, i64 8
  %scevgep753 = getelementptr i8, ptr %6, i64 16
  %375 = add nsw i64 %372, 16
  %scevgep762 = getelementptr i8, ptr %6, i64 16
  %376 = getelementptr i8, ptr %3, i64 %368
  %377 = getelementptr i8, ptr %3, i64 %371
  %378 = getelementptr i8, ptr %3, i64 %368
  %379 = getelementptr i8, ptr %378, i64 16
  %380 = getelementptr i8, ptr %3, i64 %367
  %381 = getelementptr i8, ptr %3, i64 %366
  %382 = getelementptr i8, ptr %3, i64 %364
  %383 = getelementptr i8, ptr %3, i64 %361
  %invariant.gep912 = getelementptr i8, ptr %22, i64 16
  br label %388

..loopexit440_crit_edge:                          ; preds = %.lr.ph504, %.lr.ph504.prol.loopexit
  %indvars.iv.next572.lcssa = phi i64 [ %indvars.iv.next572.lcssa.unr, %.lr.ph504.prol.loopexit ], [ %indvars.iv.next572.7, %.lr.ph504 ]
  %384 = add nsw i64 %indvars.iv.next572.lcssa, %401
  %385 = trunc nsw i64 %384 to i32
  store i32 %385, ptr %11, align 4, !tbaa !5
  br label %.loopexit440

.loopexit440:                                     ; preds = %..loopexit440_crit_edge, %677
  %386 = load i32, ptr %9, align 4, !tbaa !5
  %387 = sext i32 %386 to i64
  %.not423.not = icmp slt i64 %indvars.iv574, %387
  %indvar.next = add nuw nsw i32 %indvar, 1
  %indvar.next713 = add i64 %indvar712, 1
  br i1 %.not423.not, label %388, label %._crit_edge510, !llvm.loop !32

388:                                              ; preds = %.lr.ph509, %.loopexit440
  %indvar712 = phi i64 [ 0, %.lr.ph509 ], [ %indvar.next713, %.loopexit440 ]
  %389 = phi i32 [ %351, %.lr.ph509 ], [ %549, %.loopexit440 ]
  %390 = phi i32 [ %352, %.lr.ph509 ], [ %548, %.loopexit440 ]
  %indvars.iv574 = phi i64 [ 1, %.lr.ph509 ], [ %indvars.iv.next575, %.loopexit440 ]
  %indvar = phi i32 [ 0, %.lr.ph509 ], [ %indvar.next, %.loopexit440 ]
  %391 = mul i64 %373, %indvar712
  %392 = add i64 %372, %391
  %scevgep743 = getelementptr i8, ptr %3, i64 %392
  %393 = add i64 %374, %391
  %scevgep745 = getelementptr i8, ptr %3, i64 %393
  %394 = add i64 %375, %391
  %scevgep758 = getelementptr i8, ptr %3, i64 %394
  %395 = mul i64 %365, %indvar712
  %indvars576 = trunc i64 %indvars.iv574 to i32
  %396 = mul i32 %356, %indvar
  %397 = add i32 %359, %396
  %398 = add i32 %389, %indvars576
  %399 = add i32 %390, 1
  %400 = sub i32 %399, %398
  store i32 %400, ptr %10, align 4, !tbaa !5
  %401 = mul nsw i64 %indvars.iv574, %357
  %402 = sext i32 %398 to i64
  %403 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %404 = getelementptr %struct.doublecomplex, ptr %403, i64 %402
  %405 = call double @dznrm2_(ptr noundef nonnull %10, ptr noundef %404, ptr noundef nonnull @c__1) #8
  %406 = load i32, ptr %1, align 4, !tbaa !5
  %407 = mul i32 %360, %indvars576
  %408 = add i32 %407, %406
  %409 = sext i32 %408 to i64
  %410 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %409
  %411 = call { double, double } @Cd(ptr noundef %410)
  %412 = extractvalue { double, double } %411, 0
  %413 = extractvalue { double, double } %411, 1
  %414 = call double @cabs(double noundef %412, double noundef %413) #8
  %415 = fdiv double %405, %414
  %416 = load i32, ptr %1, align 4, !tbaa !5
  %417 = add i32 %416, %indvars576
  %418 = trunc nsw i64 %401 to i32
  %419 = add nsw i32 %417, %418
  %420 = sext i32 %419 to i64
  %421 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %420
  %422 = load <2 x double>, ptr %421, align 8, !tbaa !9
  %423 = insertelement <2 x double> poison, double %415, i64 0
  %424 = shufflevector <2 x double> %423, <2 x double> poison, <2 x i32> zeroinitializer
  %425 = fmul <2 x double> %424, %422
  store <2 x double> %425, ptr %12, align 16, !tbaa !9
  store <2 x double> %425, ptr %15, align 16, !tbaa !9
  %426 = fcmp oeq double %405, 0.000000e+00
  br i1 %426, label %427, label %428

427:                                              ; preds = %388
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(16) %17, i8 0, i64 16, i1 false)
  br label %465

428:                                              ; preds = %388
  %429 = fadd <2 x double> %422, %425
  store <2 x double> %429, ptr %12, align 16, !tbaa !9
  store <2 x double> %429, ptr %16, align 16, !tbaa !9
  %430 = load i32, ptr %0, align 4, !tbaa !5
  %431 = sub i32 %430, %417
  store i32 %431, ptr %10, align 4, !tbaa !5
  %432 = call { double, double } @Cd(ptr noundef nonnull @c_b2)
  %433 = extractvalue { double, double } %432, 0
  %434 = extractvalue { double, double } %432, 1
  %435 = call { double, double } @Cd(ptr noundef nonnull %16)
  %436 = extractvalue { double, double } %435, 0
  %437 = extractvalue { double, double } %435, 1
  %438 = call { double, double } @__divdc3(double noundef %433, double noundef %434, double noundef %436, double noundef %437) #8
  %439 = extractvalue { double, double } %438, 0
  %440 = extractvalue { double, double } %438, 1
  %441 = call ptr @_pCd(ptr noundef nonnull %12)
  %442 = getelementptr inbounds i8, ptr %441, i64 8
  store double %439, ptr %441, align 8
  store double %440, ptr %442, align 8
  %443 = load i32, ptr %1, align 4, !tbaa !5
  %444 = add nuw i32 %indvars576, 1
  %445 = add i32 %444, %418
  %446 = add i32 %445, %443
  %447 = sext i32 %446 to i64
  %448 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %447
  call void @zscal_(ptr noundef nonnull %10, ptr noundef nonnull %12, ptr noundef %448, ptr noundef nonnull @c__1) #8
  %449 = load i32, ptr %1, align 4, !tbaa !5
  %450 = add i32 %407, %449
  store i32 %450, ptr %10, align 4, !tbaa !5
  %451 = sext i32 %450 to i64
  %452 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %451
  store <2 x double> <double 1.000000e+00, double 0.000000e+00>, ptr %452, align 8, !tbaa !9
  %453 = call { double, double } @Cd(ptr noundef nonnull %16)
  %454 = extractvalue { double, double } %453, 0
  %455 = extractvalue { double, double } %453, 1
  %456 = call { double, double } @Cd(ptr noundef nonnull %15)
  %457 = extractvalue { double, double } %456, 0
  %458 = extractvalue { double, double } %456, 1
  %459 = call { double, double } @__divdc3(double noundef %454, double noundef %455, double noundef %457, double noundef %458) #8
  %460 = extractvalue { double, double } %459, 0
  %461 = extractvalue { double, double } %459, 1
  %462 = call ptr @_pCd(ptr noundef nonnull %12)
  %463 = getelementptr inbounds i8, ptr %462, i64 8
  store double %460, ptr %462, align 8
  store double %461, ptr %463, align 8
  %464 = load double, ptr %12, align 16, !tbaa !13
  store double %464, ptr %17, align 16, !tbaa !13
  store double 0.000000e+00, ptr %355, align 8, !tbaa !15
  %.pre591 = load i32, ptr %1, align 4, !tbaa !5
  %.pre593 = add i32 %.pre591, %indvars576
  br label %465

465:                                              ; preds = %428, %427
  %.pre-phi594 = phi i32 [ %.pre593, %428 ], [ %417, %427 ]
  %466 = phi i32 [ %.pre591, %428 ], [ %416, %427 ]
  %467 = load i32, ptr %0, align 4, !tbaa !5
  %468 = add i32 %467, 1
  %469 = sub i32 %468, %.pre-phi594
  store i32 %469, ptr %10, align 4, !tbaa !5
  %470 = add nsw i32 %466, -1
  store i32 %470, ptr %11, align 4, !tbaa !5
  %indvars.iv.next575 = add nuw nsw i64 %indvars.iv574, 1
  %471 = mul nsw i64 %indvars.iv.next575, %357
  %472 = sext i32 %.pre-phi594 to i64
  %473 = getelementptr %struct.doublecomplex, ptr %21, i64 %471
  %474 = getelementptr %struct.doublecomplex, ptr %473, i64 %472
  %475 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %476 = getelementptr %struct.doublecomplex, ptr %475, i64 %472
  call void @zgemv_(ptr noundef nonnull @.str.2, ptr noundef nonnull %10, ptr noundef nonnull %11, ptr noundef nonnull @c_b2, ptr noundef %474, ptr noundef nonnull %4, ptr noundef %476, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %6, ptr noundef nonnull @c__1) #8
  %477 = load i32, ptr %0, align 4, !tbaa !5
  %478 = load i32, ptr %1, align 4, !tbaa !5
  %479 = add i32 %478, %indvars576
  %480 = add i32 %477, 1
  %481 = sub i32 %480, %479
  store i32 %481, ptr %10, align 4, !tbaa !5
  %482 = add nsw i32 %478, -1
  store i32 %482, ptr %11, align 4, !tbaa !5
  %483 = load <2 x double>, ptr %17, align 16, !tbaa !9
  %484 = fneg <2 x double> %483
  store <2 x double> %484, ptr %12, align 16, !tbaa !9
  %485 = sext i32 %479 to i64
  %486 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %487 = getelementptr %struct.doublecomplex, ptr %486, i64 %485
  %488 = getelementptr %struct.doublecomplex, ptr %21, i64 %471
  %489 = getelementptr %struct.doublecomplex, ptr %488, i64 %485
  call void @zgerc_(ptr noundef nonnull %10, ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef %487, ptr noundef nonnull @c__1, ptr noundef %6, ptr noundef nonnull @c__1, ptr noundef %489, ptr noundef nonnull %4) #8
  %490 = load i32, ptr %0, align 4, !tbaa !5
  %491 = load i32, ptr %1, align 4, !tbaa !5
  %492 = add i32 %491, %indvars576
  %493 = add i32 %490, 1
  %494 = sub i32 %493, %492
  store i32 %494, ptr %10, align 4, !tbaa !5
  %495 = sext i32 %492 to i64
  %496 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %497 = getelementptr %struct.doublecomplex, ptr %496, i64 %495
  call void @zlacgv_(ptr noundef nonnull %10, ptr noundef %497, ptr noundef nonnull @c__1) #8
  %498 = load i32, ptr %0, align 4, !tbaa !5
  %499 = load i32, ptr %1, align 4, !tbaa !5
  %500 = add i32 %499, %indvars576
  %501 = add i32 %498, 1
  %502 = sub i32 %501, %500
  store i32 %502, ptr %10, align 4, !tbaa !5
  %503 = mul i32 %500, %356
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %504
  %506 = sext i32 %500 to i64
  %507 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %508 = getelementptr %struct.doublecomplex, ptr %507, i64 %506
  call void @zsymv_(ptr noundef nonnull @.str.1, ptr noundef nonnull %10, ptr noundef nonnull %17, ptr noundef %505, ptr noundef nonnull %4, ptr noundef %508, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b1, ptr noundef %6, ptr noundef nonnull @c__1) #8
  %509 = load i32, ptr %0, align 4, !tbaa !5
  %510 = load i32, ptr %1, align 4, !tbaa !5
  %511 = add i32 %510, %indvars576
  %512 = add i32 %509, 1
  %513 = sub i32 %512, %511
  store i32 %513, ptr %10, align 4, !tbaa !5
  %514 = sext i32 %511 to i64
  %515 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %516 = getelementptr %struct.doublecomplex, ptr %515, i64 %514
  call void @zlacgv_(ptr noundef nonnull %10, ptr noundef %516, ptr noundef nonnull @c__1) #8
  %517 = load double, ptr %17, align 16, !tbaa !13
  %518 = load double, ptr %355, align 8, !tbaa !15
  %519 = fmul double %518, -0.000000e+00
  %520 = call double @llvm.fmuladd.f64(double %517, double -5.000000e-01, double %519)
  %521 = fmul double %517, 0.000000e+00
  %522 = call double @llvm.fmuladd.f64(double %518, double -5.000000e-01, double %521)
  %523 = load i32, ptr %0, align 4, !tbaa !5
  %524 = load i32, ptr %1, align 4, !tbaa !5
  %525 = add i32 %524, %indvars576
  %526 = add i32 %523, 1
  %527 = sub i32 %526, %525
  store i32 %527, ptr %10, align 4, !tbaa !5
  %528 = sext i32 %525 to i64
  %529 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %530 = getelementptr %struct.doublecomplex, ptr %529, i64 %528
  call void @zdotc_(ptr noundef nonnull %13, ptr noundef nonnull %10, ptr noundef %530, ptr noundef nonnull @c__1, ptr noundef %6, ptr noundef nonnull @c__1) #8
  %531 = fneg double %522
  %532 = load <2 x double>, ptr %13, align 16, !tbaa !9
  %533 = insertelement <2 x double> poison, double %522, i64 0
  %534 = insertelement <2 x double> %533, double %531, i64 1
  %535 = fmul <2 x double> %532, %534
  %536 = shufflevector <2 x double> %535, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %537 = insertelement <2 x double> poison, double %520, i64 0
  %538 = shufflevector <2 x double> %537, <2 x double> poison, <2 x i32> zeroinitializer
  %539 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %538, <2 x double> %532, <2 x double> %536)
  store <2 x double> %539, ptr %12, align 16, !tbaa !9
  store <2 x double> %539, ptr %14, align 16, !tbaa !9
  %540 = load i32, ptr %0, align 4, !tbaa !5
  %541 = load i32, ptr %1, align 4, !tbaa !5
  %542 = add i32 %541, %indvars576
  %543 = add i32 %540, 1
  %544 = sub i32 %543, %542
  store i32 %544, ptr %10, align 4, !tbaa !5
  %545 = sext i32 %542 to i64
  %546 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %547 = getelementptr %struct.doublecomplex, ptr %546, i64 %545
  call void @zaxpy_(ptr noundef nonnull %10, ptr noundef nonnull %14, ptr noundef %547, ptr noundef nonnull @c__1, ptr noundef %6, ptr noundef nonnull @c__1) #8
  %548 = load i32, ptr %0, align 4, !tbaa !5
  %549 = load i32, ptr %1, align 4, !tbaa !5
  %550 = add i32 %549, %indvars576
  %.not426496 = icmp sgt i32 %550, %548
  br i1 %.not426496, label %677, label %.lr.ph499.preheader

.lr.ph499.preheader:                              ; preds = %465
  %551 = sext i32 %550 to i64
  %552 = sext i32 %548 to i64
  %invariant.gep609 = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %invariant.gep = getelementptr %struct.doublecomplex, ptr %21, i64 %401
  %553 = mul i64 %363, %551
  %554 = shl nsw i64 %551, 4
  %555 = mul i64 %370, %551
  %556 = shl nsw i64 %551, 4
  %scevgep744 = getelementptr i8, ptr %scevgep743, i64 %556
  %557 = shl nsw i64 %552, 4
  %scevgep747 = getelementptr i8, ptr %scevgep745, i64 %557
  %scevgep757 = getelementptr i8, ptr %scevgep745, i64 %556
  %scevgep759 = getelementptr i8, ptr %scevgep758, i64 %557
  %558 = getelementptr i8, ptr %376, i64 %555
  %559 = getelementptr i8, ptr %377, i64 %555
  %560 = getelementptr i8, ptr %3, i64 %392
  %561 = getelementptr i8, ptr %560, i64 %556
  %562 = getelementptr i8, ptr %3, i64 %393
  %563 = getelementptr i8, ptr %562, i64 %556
  %564 = getelementptr i8, ptr %379, i64 %555
  %565 = getelementptr i8, ptr %3, i64 %394
  %566 = getelementptr i8, ptr %565, i64 %556
  %567 = getelementptr i8, ptr %380, i64 %395
  %568 = getelementptr i8, ptr %567, i64 %554
  %569 = getelementptr i8, ptr %381, i64 %553
  %570 = getelementptr i8, ptr %382, i64 %395
  %571 = getelementptr i8, ptr %570, i64 %554
  %572 = getelementptr i8, ptr %383, i64 %553
  br label %.lr.ph499

.lr.ph499:                                        ; preds = %.lr.ph499.preheader, %.loopexit858
  %indvar706 = phi i64 [ 0, %.lr.ph499.preheader ], [ %indvar.next707, %.loopexit858 ]
  %indvars.iv563 = phi i64 [ %551, %.lr.ph499.preheader ], [ %indvars.iv.next564, %.loopexit858 ]
  %smax795 = call i64 @llvm.smax.i64(i64 %indvars.iv563, i64 %552)
  %573 = add i64 %indvar706, %551
  %reass.sub = sub i64 %smax795, %573
  %574 = add i64 %reass.sub, 1
  %sext = shl i64 %indvar706, 32
  %575 = ashr exact i64 %sext, 28
  %scevgep736 = getelementptr i8, ptr %6, i64 %575
  %scevgep738 = getelementptr i8, ptr %scevgep737, i64 %575
  %576 = mul i64 %370, %indvar706
  %scevgep739 = getelementptr i8, ptr %558, i64 %576
  %scevgep740 = getelementptr i8, ptr %559, i64 %576
  %smax741 = call i64 @llvm.smax.i64(i64 %indvars.iv563, i64 %552)
  %577 = add i64 %indvar706, %551
  %578 = sub i64 %smax741, %577
  %579 = shl nsw i64 %578, 4
  %scevgep742 = getelementptr i8, ptr %scevgep740, i64 %579
  %580 = shl nuw nsw i64 %indvar706, 4
  %scevgep748 = getelementptr i8, ptr %561, i64 %580
  %scevgep749 = getelementptr i8, ptr %563, i64 %580
  %scevgep750 = getelementptr i8, ptr %scevgep749, i64 %579
  %581 = add i64 %579, %575
  %scevgep752 = getelementptr i8, ptr %scevgep751, i64 %581
  %scevgep754 = getelementptr i8, ptr %scevgep753, i64 %575
  %scevgep755 = getelementptr i8, ptr %564, i64 %576
  %scevgep756 = getelementptr i8, ptr %scevgep755, i64 %579
  %scevgep760 = getelementptr i8, ptr %566, i64 %580
  %scevgep761 = getelementptr i8, ptr %scevgep760, i64 %579
  %scevgep763 = getelementptr i8, ptr %scevgep762, i64 %581
  %582 = mul nsw i64 %indvars.iv563, %357
  %583 = trunc nsw i64 %indvars.iv563 to i32
  %584 = sub i32 %583, %550
  %585 = sext i32 %584 to i64
  %586 = getelementptr %struct.doublecomplex, ptr %22, i64 %585
  %587 = getelementptr i8, ptr %586, i64 16
  %588 = getelementptr i8, ptr %586, i64 24
  %gep610 = getelementptr %struct.doublecomplex, ptr %invariant.gep609, i64 %indvars.iv563
  %589 = getelementptr inbounds i8, ptr %gep610, i64 8
  %invariant.gep607 = getelementptr %struct.doublecomplex, ptr %21, i64 %582
  %min.iters.check798 = icmp ult i64 %574, 12
  br i1 %min.iters.check798, label %scalar.ph797.preheader, label %vector.scevcheck704

vector.scevcheck704:                              ; preds = %.lr.ph499
  %sext862 = shl i64 %indvar706, 32
  %590 = ashr exact i64 %sext862, 28
  %scevgep731 = getelementptr i8, ptr %scevgep730, i64 %590
  %591 = shl nuw nsw i64 %indvar706, 4
  %scevgep726 = getelementptr i8, ptr %568, i64 %591
  %592 = mul i64 %363, %indvar706
  %scevgep722 = getelementptr i8, ptr %569, i64 %592
  %scevgep718 = getelementptr i8, ptr %6, i64 %590
  %593 = trunc i64 %indvar706 to i32
  %scevgep714 = getelementptr i8, ptr %571, i64 %591
  %scevgep708 = getelementptr i8, ptr %572, i64 %592
  %smax705 = call i64 @llvm.smax.i64(i64 %indvars.iv563, i64 %552)
  %594 = add i64 %indvar706, %551
  %595 = sub i64 %smax705, %594
  %596 = trunc i64 %595 to i32
  %597 = add i32 %593, %596
  %598 = icmp slt i32 %597, %593
  %599 = icmp ugt i64 %595, 4294967295
  %600 = or i1 %598, %599
  %mul.result710 = shl i64 %595, 4
  %601 = getelementptr i8, ptr %scevgep708, i64 %mul.result710
  %602 = icmp ult ptr %601, %scevgep708
  %mul.result716 = shl i64 %595, 4
  %603 = getelementptr i8, ptr %scevgep714, i64 %mul.result716
  %604 = icmp ult ptr %603, %scevgep714
  %mul.result720 = shl i64 %595, 4
  %605 = getelementptr i8, ptr %scevgep718, i64 %mul.result720
  %606 = icmp ult ptr %605, %scevgep718
  %mul.result724 = shl i64 %595, 4
  %607 = getelementptr i8, ptr %scevgep722, i64 %mul.result724
  %608 = icmp ult ptr %607, %scevgep722
  %mul.result728 = shl i64 %595, 4
  %609 = getelementptr i8, ptr %scevgep726, i64 %mul.result728
  %610 = icmp ult ptr %609, %scevgep726
  %mul.result733 = shl i64 %595, 4
  %611 = getelementptr i8, ptr %scevgep731, i64 %mul.result733
  %612 = icmp ult ptr %611, %scevgep731
  %613 = or i1 %602, %600
  %614 = or i1 %604, %613
  %615 = or i1 %606, %614
  %616 = or i1 %608, %615
  %617 = or i1 %610, %616
  %618 = or i1 %612, %617
  br i1 %618, label %scalar.ph797.preheader, label %vector.memcheck735

vector.memcheck735:                               ; preds = %vector.scevcheck704
  %bound0764 = icmp ult ptr %scevgep736, %scevgep742
  %bound1765 = icmp ult ptr %scevgep739, %scevgep738
  %found.conflict766 = and i1 %bound0764, %bound1765
  %bound0767 = icmp ult ptr %scevgep744, %scevgep742
  %bound1768 = icmp ult ptr %scevgep739, %scevgep747
  %found.conflict769 = and i1 %bound0767, %bound1768
  %conflict.rdx770 = or i1 %found.conflict766, %found.conflict769
  %bound0771 = icmp ult ptr %scevgep739, %scevgep750
  %bound1772 = icmp ult ptr %scevgep748, %scevgep742
  %found.conflict773 = and i1 %bound0771, %bound1772
  %conflict.rdx774 = or i1 %conflict.rdx770, %found.conflict773
  %bound0775 = icmp ult ptr %scevgep739, %scevgep752
  %bound1776 = icmp ult ptr %scevgep736, %scevgep742
  %found.conflict777 = and i1 %bound0775, %bound1776
  %conflict.rdx778 = or i1 %conflict.rdx774, %found.conflict777
  %bound0779 = icmp ult ptr %scevgep738, %scevgep756
  %bound1780 = icmp ult ptr %scevgep740, %scevgep754
  %found.conflict781 = and i1 %bound0779, %bound1780
  %conflict.rdx782 = or i1 %conflict.rdx778, %found.conflict781
  %bound0783 = icmp ult ptr %scevgep757, %scevgep756
  %bound1784 = icmp ult ptr %scevgep740, %scevgep759
  %found.conflict785 = and i1 %bound0783, %bound1784
  %conflict.rdx786 = or i1 %conflict.rdx782, %found.conflict785
  %bound0787 = icmp ult ptr %scevgep740, %scevgep761
  %bound1788 = icmp ult ptr %scevgep749, %scevgep756
  %found.conflict789 = and i1 %bound0787, %bound1788
  %conflict.rdx790 = or i1 %conflict.rdx786, %found.conflict789
  %bound0791 = icmp ult ptr %scevgep740, %scevgep763
  %bound1792 = icmp ult ptr %scevgep738, %scevgep756
  %found.conflict793 = and i1 %bound0791, %bound1792
  %conflict.rdx794 = or i1 %conflict.rdx790, %found.conflict793
  br i1 %conflict.rdx794, label %scalar.ph797.preheader, label %vector.ph799

vector.ph799:                                     ; preds = %vector.memcheck735
  %n.vec801 = and i64 %574, -2
  %ind.end802 = add i64 %indvars.iv563, %n.vec801
  br label %vector.body804

vector.body804:                                   ; preds = %vector.body804, %vector.ph799
  %index805 = phi i64 [ 0, %vector.ph799 ], [ %index.next826, %vector.body804 ]
  %offset.idx806 = add i64 %indvars.iv563, %index805
  %offset.idx807 = add i64 %indvars.iv563, %index805
  %619 = trunc i64 %offset.idx807 to i32
  %620 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %offset.idx806
  %wide.vec808 = load <4 x double>, ptr %620, align 8, !tbaa !9
  %strided.vec809 = shufflevector <4 x double> %wide.vec808, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec810 = shufflevector <4 x double> %wide.vec808, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %621 = load double, ptr %587, align 8, !tbaa !13, !alias.scope !33, !noalias !36
  %broadcast.splatinsert813 = insertelement <2 x double> poison, double %621, i64 0
  %broadcast.splat814 = shufflevector <2 x double> %broadcast.splatinsert813, <2 x double> poison, <2 x i32> zeroinitializer
  %622 = load double, ptr %588, align 8, !tbaa !15, !alias.scope !38, !noalias !40
  %broadcast.splatinsert811 = insertelement <2 x double> poison, double %622, i64 0
  %broadcast.splat812 = shufflevector <2 x double> %broadcast.splatinsert811, <2 x double> poison, <2 x i32> zeroinitializer
  %623 = fneg <2 x double> %strided.vec810
  %624 = fmul <2 x double> %broadcast.splat812, %623
  %625 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec809, <2 x double> %broadcast.splat814, <2 x double> %624)
  %626 = fmul <2 x double> %broadcast.splat814, %strided.vec810
  %627 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec809, <2 x double> %broadcast.splat812, <2 x double> %626)
  %628 = getelementptr %struct.doublecomplex, ptr %invariant.gep607, i64 %offset.idx806
  %wide.vec815 = load <4 x double>, ptr %628, align 8, !tbaa !9
  %strided.vec816 = shufflevector <4 x double> %wide.vec815, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec817 = shufflevector <4 x double> %wide.vec815, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %629 = fsub <2 x double> %strided.vec816, %625
  %630 = fsub <2 x double> %strided.vec817, %627
  %631 = sub i32 %619, %550
  %632 = sext i32 %631 to i64
  %gep913 = getelementptr %struct.doublecomplex, ptr %invariant.gep912, i64 %632
  %wide.vec818 = load <4 x double>, ptr %gep913, align 8, !tbaa !9
  %strided.vec819 = shufflevector <4 x double> %wide.vec818, <4 x double> poison, <2 x i32> <i32 0, i32 2>
  %strided.vec820 = shufflevector <4 x double> %wide.vec818, <4 x double> poison, <2 x i32> <i32 1, i32 3>
  %633 = load double, ptr %gep610, align 8, !tbaa !13, !alias.scope !42, !noalias !36
  %broadcast.splatinsert823 = insertelement <2 x double> poison, double %633, i64 0
  %broadcast.splat824 = shufflevector <2 x double> %broadcast.splatinsert823, <2 x double> poison, <2 x i32> zeroinitializer
  %634 = load double, ptr %589, align 8, !tbaa !15, !alias.scope !44, !noalias !40
  %broadcast.splatinsert821 = insertelement <2 x double> poison, double %634, i64 0
  %broadcast.splat822 = shufflevector <2 x double> %broadcast.splatinsert821, <2 x double> poison, <2 x i32> zeroinitializer
  %635 = fneg <2 x double> %strided.vec820
  %636 = fmul <2 x double> %broadcast.splat822, %635
  %637 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec819, <2 x double> %broadcast.splat824, <2 x double> %636)
  %638 = fmul <2 x double> %broadcast.splat824, %strided.vec820
  %639 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %strided.vec819, <2 x double> %broadcast.splat822, <2 x double> %638)
  %640 = fsub <2 x double> %629, %637
  %641 = fsub <2 x double> %630, %639
  %interleaved.vec825 = shufflevector <2 x double> %640, <2 x double> %641, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
  store <4 x double> %interleaved.vec825, ptr %628, align 8, !tbaa !9
  %index.next826 = add nuw i64 %index805, 2
  %642 = icmp eq i64 %index.next826, %n.vec801
  br i1 %642, label %middle.block796, label %vector.body804, !llvm.loop !46

middle.block796:                                  ; preds = %vector.body804
  %cmp.n827 = icmp eq i64 %574, %n.vec801
  %643 = shufflevector <2 x double> %637, <2 x double> %639, <2 x i32> <i32 1, i32 3>
  br i1 %cmp.n827, label %.loopexit858, label %scalar.ph797.preheader

scalar.ph797.preheader:                           ; preds = %middle.block796, %vector.memcheck735, %vector.scevcheck704, %.lr.ph499
  %indvars.iv565.ph = phi i64 [ %indvars.iv563, %vector.memcheck735 ], [ %indvars.iv563, %vector.scevcheck704 ], [ %indvars.iv563, %.lr.ph499 ], [ %ind.end802, %middle.block796 ]
  br label %scalar.ph797

scalar.ph797:                                     ; preds = %scalar.ph797.preheader, %scalar.ph797
  %indvars.iv565 = phi i64 [ %indvars.iv.next566, %scalar.ph797 ], [ %indvars.iv565.ph, %scalar.ph797.preheader ]
  %gep606 = getelementptr %struct.doublecomplex, ptr %invariant.gep, i64 %indvars.iv565
  %644 = load double, ptr %gep606, align 8, !tbaa !13
  %645 = getelementptr inbounds i8, ptr %gep606, i64 8
  %646 = load double, ptr %645, align 8, !tbaa !15
  %647 = fneg double %646
  %gep608 = getelementptr %struct.doublecomplex, ptr %invariant.gep607, i64 %indvars.iv565
  %648 = trunc nsw i64 %indvars.iv565 to i32
  %649 = sub i32 %648, %550
  %650 = sext i32 %649 to i64
  %651 = getelementptr %struct.doublecomplex, ptr %22, i64 %650
  %652 = getelementptr i8, ptr %651, i64 16
  %653 = load double, ptr %652, align 8, !tbaa !13
  %654 = getelementptr i8, ptr %651, i64 24
  %655 = load double, ptr %654, align 8, !tbaa !15
  %656 = fneg double %655
  %657 = load <2 x double>, ptr %gep610, align 8, !tbaa !9
  %658 = insertelement <2 x double> poison, double %655, i64 0
  %659 = insertelement <2 x double> %658, double %656, i64 1
  %660 = fmul <2 x double> %657, %659
  %661 = shufflevector <2 x double> %660, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %662 = insertelement <2 x double> poison, double %653, i64 0
  %663 = shufflevector <2 x double> %662, <2 x double> poison, <2 x i32> zeroinitializer
  %664 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %663, <2 x double> %657, <2 x double> %661)
  %665 = load <2 x double>, ptr %587, align 8, !tbaa !9
  %666 = insertelement <2 x double> poison, double %646, i64 0
  %667 = insertelement <2 x double> %666, double %647, i64 1
  %668 = fmul <2 x double> %665, %667
  %669 = shufflevector <2 x double> %668, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %670 = insertelement <2 x double> poison, double %644, i64 0
  %671 = shufflevector <2 x double> %670, <2 x double> poison, <2 x i32> zeroinitializer
  %672 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %671, <2 x double> %665, <2 x double> %669)
  %673 = load <2 x double>, ptr %gep608, align 8, !tbaa !9
  %674 = fsub <2 x double> %673, %672
  %675 = fsub <2 x double> %674, %664
  store <2 x double> %675, ptr %gep608, align 8, !tbaa !9
  %indvars.iv.next566 = add nsw i64 %indvars.iv565, 1
  %.not428.not = icmp slt i64 %indvars.iv565, %552
  br i1 %.not428.not, label %scalar.ph797, label %.loopexit858, !llvm.loop !47

.loopexit858:                                     ; preds = %scalar.ph797, %middle.block796
  %676 = phi <2 x double> [ %643, %middle.block796 ], [ %664, %scalar.ph797 ]
  %indvars.iv.next564 = add nsw i64 %indvars.iv563, 1
  %.not426.not = icmp slt i64 %indvars.iv563, %552
  %indvar.next707 = add i64 %indvar706, 1
  br i1 %.not426.not, label %.lr.ph499, label %._crit_edge500, !llvm.loop !48

._crit_edge500:                                   ; preds = %.loopexit858
  store i32 %548, ptr %11, align 4, !tbaa !5
  store <2 x double> %676, ptr %13, align 16, !tbaa !9
  br label %677

677:                                              ; preds = %._crit_edge500, %465
  %678 = add nsw i32 %550, %418
  %679 = load <2 x double>, ptr %15, align 16, !tbaa !9
  %680 = fneg <2 x double> %679
  store <2 x double> %680, ptr %12, align 16, !tbaa !9
  %681 = sext i32 %678 to i64
  %682 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %681
  store <2 x double> %680, ptr %682, align 8, !tbaa !9
  store i32 %548, ptr %10, align 4, !tbaa !5
  %.not427.not501 = icmp slt i32 %550, %548
  br i1 %.not427.not501, label %.lr.ph504.preheader, label %.loopexit440

.lr.ph504.preheader:                              ; preds = %677
  %683 = add i32 %549, %397
  %684 = sext i32 %683 to i64
  %685 = shl nsw i64 %684, 4
  %scevgep570 = getelementptr i8, ptr %scevgep569, i64 %685
  %686 = add i32 %548, -2
  %687 = add i32 %indvar, %549
  %688 = sub i32 %686, %687
  %689 = zext i32 %688 to i64
  %690 = shl nuw nsw i64 %689, 4
  %691 = add nuw nsw i64 %690, 16
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(1) %scevgep570, i8 0, i64 %691, i1 false), !tbaa !9
  %692 = sext i32 %550 to i64
  %693 = sext i32 %548 to i64
  %694 = sub nsw i64 %693, %692
  %xtraiter885 = and i64 %694, 7
  %lcmp.mod886.not = icmp eq i64 %xtraiter885, 0
  br i1 %lcmp.mod886.not, label %.lr.ph504.prol.loopexit, label %.lr.ph504.prol

.lr.ph504.prol:                                   ; preds = %.lr.ph504.preheader, %.lr.ph504.prol
  %indvars.iv571.prol = phi i64 [ %indvars.iv.next572.prol, %.lr.ph504.prol ], [ %692, %.lr.ph504.preheader ]
  %prol.iter = phi i64 [ %prol.iter.next, %.lr.ph504.prol ], [ 0, %.lr.ph504.preheader ]
  %indvars.iv.next572.prol = add nsw i64 %indvars.iv571.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter885
  br i1 %prol.iter.cmp.not, label %.lr.ph504.prol.loopexit, label %.lr.ph504.prol, !llvm.loop !49

.lr.ph504.prol.loopexit:                          ; preds = %.lr.ph504.prol, %.lr.ph504.preheader
  %indvars.iv571.unr = phi i64 [ %692, %.lr.ph504.preheader ], [ %indvars.iv.next572.prol, %.lr.ph504.prol ]
  %indvars.iv.next572.lcssa.unr = phi i64 [ poison, %.lr.ph504.preheader ], [ %indvars.iv.next572.prol, %.lr.ph504.prol ]
  %695 = sub nsw i64 %692, %693
  %696 = icmp ugt i64 %695, -8
  br i1 %696, label %..loopexit440_crit_edge, label %.lr.ph504

.lr.ph504:                                        ; preds = %.lr.ph504.prol.loopexit, %.lr.ph504
  %indvars.iv571 = phi i64 [ %indvars.iv.next572.7, %.lr.ph504 ], [ %indvars.iv571.unr, %.lr.ph504.prol.loopexit ]
  %indvars.iv.next572.7 = add nsw i64 %indvars.iv571, 8
  %.not427.not.7 = icmp slt i64 %indvars.iv.next572.7, %693
  br i1 %.not427.not.7, label %.lr.ph504, label %..loopexit440_crit_edge, !llvm.loop !51

._crit_edge510:                                   ; preds = %.loopexit440, %._crit_edge490
  %697 = phi i32 [ %352, %._crit_edge490 ], [ %548, %.loopexit440 ]
  %.not424516 = icmp slt i32 %697, 1
  br i1 %.not424516, label %.loopexit439, label %.lr.ph519.preheader

.lr.ph519.preheader:                              ; preds = %._crit_edge510
  %698 = sext i32 %19 to i64
  %699 = add nuw i32 %697, 1
  %700 = zext nneg i32 %697 to i64
  %wide.trip.count587 = zext i32 %699 to i64
  %701 = add nsw i32 %697, -2
  %scevgep831 = getelementptr i8, ptr %3, i64 -32
  %scevgep836 = getelementptr i8, ptr %3, i64 -24
  %ident.check = icmp ne i32 %19, 1
  br label %.lr.ph519

.loopexit:                                        ; preds = %scalar.ph842.prol.loopexit, %scalar.ph842, %middle.block841, %.lr.ph519
  %indvars.iv.next578 = add nuw i32 %indvars.iv577, 1
  %exitcond588.not = icmp eq i64 %indvars.iv.next585, %wide.trip.count587
  %indvar.next830 = add i32 %indvar829, 1
  br i1 %exitcond588.not, label %.loopexit439, label %.lr.ph519, !llvm.loop !52

.lr.ph519:                                        ; preds = %.lr.ph519.preheader, %.loopexit
  %indvar829 = phi i32 [ 0, %.lr.ph519.preheader ], [ %indvar.next830, %.loopexit ]
  %indvars.iv584 = phi i64 [ 1, %.lr.ph519.preheader ], [ %indvars.iv.next585, %.loopexit ]
  %indvars.iv577 = phi i32 [ 2, %.lr.ph519.preheader ], [ %indvars.iv.next578, %.loopexit ]
  %702 = sub i32 %701, %indvar829
  %703 = zext i32 %702 to i64
  %704 = add nuw nsw i64 %703, 1
  %705 = sub i32 %701, %indvar829
  %706 = sext i32 %indvars.iv577 to i64
  %707 = add i64 %indvars.iv584, %706
  %708 = shl nsw i64 %707, 4
  %scevgep832 = getelementptr i8, ptr %scevgep831, i64 %708
  %scevgep837 = getelementptr i8, ptr %scevgep836, i64 %708
  %indvars.iv.next585 = add nuw nsw i64 %indvars.iv584, 1
  %.not425511.not = icmp ult i64 %indvars.iv584, %700
  br i1 %.not425511.not, label %.lr.ph514, label %.loopexit

.lr.ph514:                                        ; preds = %.lr.ph519
  %709 = sext i32 %indvars.iv577 to i64
  %710 = mul nsw i64 %indvars.iv584, %698
  %invariant.gep611 = getelementptr %struct.doublecomplex, ptr %21, i64 %710
  %min.iters.check843 = icmp ult i32 %702, 25
  br i1 %min.iters.check843, label %scalar.ph842.preheader, label %vector.scevcheck828

vector.scevcheck828:                              ; preds = %.lr.ph514
  %711 = zext i32 %705 to i64
  %mul833 = shl nuw nsw i64 %711, 4
  %712 = getelementptr i8, ptr %scevgep832, i64 %mul833
  %713 = icmp ult ptr %712, %scevgep832
  %714 = zext i32 %705 to i64
  %mul838 = shl nuw nsw i64 %714, 4
  %715 = getelementptr i8, ptr %scevgep837, i64 %mul838
  %716 = icmp ult ptr %715, %scevgep837
  %717 = or i1 %ident.check, %713
  %718 = or i1 %717, %716
  br i1 %718, label %scalar.ph842.preheader, label %vector.ph844

vector.ph844:                                     ; preds = %vector.scevcheck828
  %n.vec846 = and i64 %704, 8589934590
  %ind.end847 = add nsw i64 %n.vec846, %709
  %invariant.gep914 = getelementptr %struct.doublecomplex, ptr %21, i64 %indvars.iv584
  br label %vector.body849

vector.body849:                                   ; preds = %vector.body849, %vector.ph844
  %index850 = phi i64 [ 0, %vector.ph844 ], [ %index.next856, %vector.body849 ]
  %offset.idx851 = add i64 %index850, %709
  %719 = getelementptr %struct.doublecomplex, ptr %invariant.gep611, i64 %offset.idx851
  %wide.vec852 = load <4 x double>, ptr %719, align 8, !tbaa !9
  %gep915 = getelementptr %struct.doublecomplex, ptr %invariant.gep914, i64 %offset.idx851
  store <4 x double> %wide.vec852, ptr %gep915, align 8, !tbaa !9
  %index.next856 = add nuw i64 %index850, 2
  %720 = icmp eq i64 %index.next856, %n.vec846
  br i1 %720, label %middle.block841, label %vector.body849, !llvm.loop !53

middle.block841:                                  ; preds = %vector.body849
  %cmp.n857 = icmp eq i64 %704, %n.vec846
  br i1 %cmp.n857, label %.loopexit, label %scalar.ph842.preheader

scalar.ph842.preheader:                           ; preds = %middle.block841, %vector.scevcheck828, %.lr.ph514
  %indvars.iv579.ph = phi i64 [ %709, %vector.scevcheck828 ], [ %709, %.lr.ph514 ], [ %ind.end847, %middle.block841 ]
  %721 = trunc i64 %indvars.iv579.ph to i32
  %722 = add i32 %697, %721
  %723 = and i32 %722, 1
  %lcmp.mod888.not.not = icmp eq i32 %723, 0
  br i1 %lcmp.mod888.not.not, label %scalar.ph842.prol, label %scalar.ph842.prol.loopexit

scalar.ph842.prol:                                ; preds = %scalar.ph842.preheader
  %724 = mul nsw i64 %indvars.iv579.ph, %698
  %gep612.prol = getelementptr %struct.doublecomplex, ptr %invariant.gep611, i64 %indvars.iv579.ph
  %725 = getelementptr %struct.doublecomplex, ptr %21, i64 %724
  %726 = getelementptr %struct.doublecomplex, ptr %725, i64 %indvars.iv584
  %727 = load <2 x double>, ptr %gep612.prol, align 8, !tbaa !9
  store <2 x double> %727, ptr %726, align 8, !tbaa !9
  %indvars.iv.next580.prol = add nsw i64 %indvars.iv579.ph, 1
  br label %scalar.ph842.prol.loopexit

scalar.ph842.prol.loopexit:                       ; preds = %scalar.ph842.prol, %scalar.ph842.preheader
  %indvars.iv579.unr = phi i64 [ %indvars.iv579.ph, %scalar.ph842.preheader ], [ %indvars.iv.next580.prol, %scalar.ph842.prol ]
  %728 = icmp eq i32 %697, %721
  br i1 %728, label %.loopexit, label %scalar.ph842.preheader.new

scalar.ph842.preheader.new:                       ; preds = %scalar.ph842.prol.loopexit
  %invariant.gep916 = getelementptr %struct.doublecomplex, ptr %21, i64 %indvars.iv584
  %invariant.gep918 = getelementptr %struct.doublecomplex, ptr %21, i64 %indvars.iv584
  br label %scalar.ph842

scalar.ph842:                                     ; preds = %scalar.ph842, %scalar.ph842.preheader.new
  %indvars.iv579 = phi i64 [ %indvars.iv579.unr, %scalar.ph842.preheader.new ], [ %indvars.iv.next580.1, %scalar.ph842 ]
  %729 = mul nsw i64 %indvars.iv579, %698
  %gep612 = getelementptr %struct.doublecomplex, ptr %invariant.gep611, i64 %indvars.iv579
  %gep917 = getelementptr %struct.doublecomplex, ptr %invariant.gep916, i64 %729
  %730 = load <2 x double>, ptr %gep612, align 8, !tbaa !9
  store <2 x double> %730, ptr %gep917, align 8, !tbaa !9
  %indvars.iv.next580 = add nsw i64 %indvars.iv579, 1
  %731 = mul nsw i64 %indvars.iv.next580, %698
  %gep612.1 = getelementptr %struct.doublecomplex, ptr %invariant.gep611, i64 %indvars.iv.next580
  %gep919 = getelementptr %struct.doublecomplex, ptr %invariant.gep918, i64 %731
  %732 = load <2 x double>, ptr %gep612.1, align 8, !tbaa !9
  store <2 x double> %732, ptr %gep919, align 8, !tbaa !9
  %indvars.iv.next580.1 = add nsw i64 %indvars.iv579, 2
  %lftr.wideiv582.1 = trunc i64 %indvars.iv.next580.1 to i32
  %exitcond583.not.1 = icmp eq i32 %699, %lftr.wideiv582.1
  br i1 %exitcond583.not.1, label %.loopexit, label %scalar.ph842, !llvm.loop !54

.loopexit439:                                     ; preds = %.loopexit, %._crit_edge510, %.thread
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %16) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %15) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %13) #8
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %12) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %11) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #8
  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 @xerbla_(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #2

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

declare double @dznrm2_(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

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

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

declare { double, double } @__divdc3(double, double, double, double) local_unnamed_addr

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

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

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

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

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

declare void @zdotc_(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 void @zgemv_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

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

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

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

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

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

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

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

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


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