; LLVM IR from niuyishuai/PDCABB :: LAPACK_BLAS/LAPACK (chetd2)

; 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.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1
@c__1 = external hidden global i64, align 8
@c_b2 = external hidden global %struct.complex, align 4

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

52:                                               ; preds = %8
  %53 = load ptr, ptr %10, align 8, !tbaa !5
  %54 = call i64 @lsame_(ptr noundef %53, ptr noundef @.str.1)
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %58, label %56

56:                                               ; preds = %52
  %57 = load ptr, ptr %17, align 8, !tbaa !5
  store i64 -1, ptr %57, align 8, !tbaa !9
  br label %81

58:                                               ; preds = %52, %8
  %59 = load ptr, ptr %11, align 8, !tbaa !5
  %60 = load i64, ptr %59, align 8, !tbaa !9
  %61 = icmp slt i64 %60, 0
  br i1 %61, label %62, label %64

62:                                               ; preds = %58
  %63 = load ptr, ptr %17, align 8, !tbaa !5
  store i64 -2, ptr %63, align 8, !tbaa !9
  br label %80

64:                                               ; preds = %58
  %65 = load ptr, ptr %13, align 8, !tbaa !5
  %66 = load i64, ptr %65, align 8, !tbaa !9
  %67 = load ptr, ptr %11, align 8, !tbaa !5
  %68 = load i64, ptr %67, align 8, !tbaa !9
  %69 = icmp sge i64 1, %68
  br i1 %69, label %70, label %71

70:                                               ; preds = %64
  br label %74

71:                                               ; preds = %64
  %72 = load ptr, ptr %11, align 8, !tbaa !5
  %73 = load i64, ptr %72, align 8, !tbaa !9
  br label %74

74:                                               ; preds = %71, %70
  %75 = phi i64 [ 1, %70 ], [ %73, %71 ]
  %76 = icmp slt i64 %66, %75
  br i1 %76, label %77, label %79

77:                                               ; preds = %74
  %78 = load ptr, ptr %17, align 8, !tbaa !5
  store i64 -4, ptr %78, align 8, !tbaa !9
  br label %79

79:                                               ; preds = %77, %74
  br label %80

80:                                               ; preds = %79, %62
  br label %81

81:                                               ; preds = %80, %56
  %82 = load ptr, ptr %17, align 8, !tbaa !5
  %83 = load i64, ptr %82, align 8, !tbaa !9
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %85, label %90

85:                                               ; preds = %81
  %86 = load ptr, ptr %17, align 8, !tbaa !5
  %87 = load i64, ptr %86, align 8, !tbaa !9
  %88 = sub nsw i64 0, %87
  store i64 %88, ptr %20, align 8, !tbaa !9
  %89 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %20)
  store i32 0, ptr %9, align 4
  store i32 1, ptr %32, align 4
  br label %717

90:                                               ; preds = %81
  %91 = load ptr, ptr %11, align 8, !tbaa !5
  %92 = load i64, ptr %91, align 8, !tbaa !9
  %93 = icmp sle i64 %92, 0
  br i1 %93, label %94, label %95

94:                                               ; preds = %90
  store i32 0, ptr %9, align 4
  store i32 1, ptr %32, align 4
  br label %717

95:                                               ; preds = %90
  %96 = load i64, ptr %31, align 8, !tbaa !9
  %97 = icmp ne i64 %96, 0
  br i1 %97, label %98, label %381

98:                                               ; preds = %95
  %99 = load ptr, ptr %11, align 8, !tbaa !5
  %100 = load i64, ptr %99, align 8, !tbaa !9
  %101 = load ptr, ptr %11, align 8, !tbaa !5
  %102 = load i64, ptr %101, align 8, !tbaa !9
  %103 = load i64, ptr %18, align 8, !tbaa !9
  %104 = mul nsw i64 %102, %103
  %105 = add nsw i64 %100, %104
  store i64 %105, ptr %20, align 8, !tbaa !9
  %106 = load ptr, ptr %11, align 8, !tbaa !5
  %107 = load i64, ptr %106, align 8, !tbaa !9
  %108 = load ptr, ptr %11, align 8, !tbaa !5
  %109 = load i64, ptr %108, align 8, !tbaa !9
  %110 = load i64, ptr %18, align 8, !tbaa !9
  %111 = mul nsw i64 %109, %110
  %112 = add nsw i64 %107, %111
  store i64 %112, ptr %21, align 8, !tbaa !9
  %113 = load ptr, ptr %12, align 8, !tbaa !5
  %114 = load i64, ptr %21, align 8, !tbaa !9
  %115 = getelementptr inbounds %struct.complex, ptr %113, i64 %114
  %116 = getelementptr inbounds %struct.complex, ptr %115, i32 0, i32 0
  %117 = load float, ptr %116, align 4, !tbaa !11
  store float %117, ptr %23, align 4, !tbaa !14
  %118 = load float, ptr %23, align 4, !tbaa !14
  %119 = load ptr, ptr %12, align 8, !tbaa !5
  %120 = load i64, ptr %20, align 8, !tbaa !9
  %121 = getelementptr inbounds %struct.complex, ptr %119, i64 %120
  %122 = getelementptr inbounds %struct.complex, ptr %121, i32 0, i32 0
  store float %118, ptr %122, align 4, !tbaa !11
  %123 = load ptr, ptr %12, align 8, !tbaa !5
  %124 = load i64, ptr %20, align 8, !tbaa !9
  %125 = getelementptr inbounds %struct.complex, ptr %123, i64 %124
  %126 = getelementptr inbounds %struct.complex, ptr %125, i32 0, i32 1
  store float 0.000000e+00, ptr %126, align 4, !tbaa !15
  %127 = load ptr, ptr %11, align 8, !tbaa !5
  %128 = load i64, ptr %127, align 8, !tbaa !9
  %129 = sub nsw i64 %128, 1
  store i64 %129, ptr %28, align 8, !tbaa !9
  br label %130

130:                                              ; preds = %368, %98
  %131 = load i64, ptr %28, align 8, !tbaa !9
  %132 = icmp sge i64 %131, 1
  br i1 %132, label %133, label %371

133:                                              ; preds = %130
  %134 = load i64, ptr %28, align 8, !tbaa !9
  %135 = load i64, ptr %28, align 8, !tbaa !9
  %136 = add nsw i64 %135, 1
  %137 = load i64, ptr %18, align 8, !tbaa !9
  %138 = mul nsw i64 %136, %137
  %139 = add nsw i64 %134, %138
  store i64 %139, ptr %20, align 8, !tbaa !9
  %140 = load ptr, ptr %12, align 8, !tbaa !5
  %141 = load i64, ptr %20, align 8, !tbaa !9
  %142 = getelementptr inbounds %struct.complex, ptr %140, i64 %141
  %143 = getelementptr inbounds %struct.complex, ptr %142, i32 0, i32 0
  %144 = load float, ptr %143, align 4, !tbaa !11
  %145 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  store float %144, ptr %145, align 4, !tbaa !11
  %146 = load ptr, ptr %12, align 8, !tbaa !5
  %147 = load i64, ptr %20, align 8, !tbaa !9
  %148 = getelementptr inbounds %struct.complex, ptr %146, i64 %147
  %149 = getelementptr inbounds %struct.complex, ptr %148, i32 0, i32 1
  %150 = load float, ptr %149, align 4, !tbaa !15
  %151 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 1
  store float %150, ptr %151, align 4, !tbaa !15
  %152 = load ptr, ptr %12, align 8, !tbaa !5
  %153 = load i64, ptr %28, align 8, !tbaa !9
  %154 = add nsw i64 %153, 1
  %155 = load i64, ptr %18, align 8, !tbaa !9
  %156 = mul nsw i64 %154, %155
  %157 = add nsw i64 %156, 1
  %158 = getelementptr inbounds %struct.complex, ptr %152, i64 %157
  %159 = call i32 @clarfg_(ptr noundef %28, ptr noundef %30, ptr noundef %158, ptr noundef @c__1, ptr noundef %29)
  %160 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %160, ptr %20, align 8, !tbaa !9
  %161 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  %162 = load float, ptr %161, align 4, !tbaa !11
  %163 = load ptr, ptr %15, align 8, !tbaa !5
  %164 = load i64, ptr %20, align 8, !tbaa !9
  %165 = getelementptr inbounds float, ptr %163, i64 %164
  store float %162, ptr %165, align 4, !tbaa !14
  %166 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %167 = load float, ptr %166, align 4, !tbaa !11
  %168 = fcmp une float %167, 0.000000e+00
  br i1 %168, label %173, label %169

169:                                              ; preds = %133
  %170 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %171 = load float, ptr %170, align 4, !tbaa !15
  %172 = fcmp une float %171, 0.000000e+00
  br i1 %172, label %173, label %293

173:                                              ; preds = %169, %133
  %174 = load i64, ptr %28, align 8, !tbaa !9
  %175 = load i64, ptr %28, align 8, !tbaa !9
  %176 = add nsw i64 %175, 1
  %177 = load i64, ptr %18, align 8, !tbaa !9
  %178 = mul nsw i64 %176, %177
  %179 = add nsw i64 %174, %178
  store i64 %179, ptr %20, align 8, !tbaa !9
  %180 = load ptr, ptr %12, align 8, !tbaa !5
  %181 = load i64, ptr %20, align 8, !tbaa !9
  %182 = getelementptr inbounds %struct.complex, ptr %180, i64 %181
  %183 = getelementptr inbounds %struct.complex, ptr %182, i32 0, i32 0
  store float 1.000000e+00, ptr %183, align 4, !tbaa !11
  %184 = load ptr, ptr %12, align 8, !tbaa !5
  %185 = load i64, ptr %20, align 8, !tbaa !9
  %186 = getelementptr inbounds %struct.complex, ptr %184, i64 %185
  %187 = getelementptr inbounds %struct.complex, ptr %186, i32 0, i32 1
  store float 0.000000e+00, ptr %187, align 4, !tbaa !15
  %188 = load ptr, ptr %10, align 8, !tbaa !5
  %189 = load ptr, ptr %12, align 8, !tbaa !5
  %190 = load i64, ptr %19, align 8, !tbaa !9
  %191 = getelementptr inbounds %struct.complex, ptr %189, i64 %190
  %192 = load ptr, ptr %13, align 8, !tbaa !5
  %193 = load ptr, ptr %12, align 8, !tbaa !5
  %194 = load i64, ptr %28, align 8, !tbaa !9
  %195 = add nsw i64 %194, 1
  %196 = load i64, ptr %18, align 8, !tbaa !9
  %197 = mul nsw i64 %195, %196
  %198 = add nsw i64 %197, 1
  %199 = getelementptr inbounds %struct.complex, ptr %193, i64 %198
  %200 = load ptr, ptr %16, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.complex, ptr %200, i64 1
  %202 = call i32 @f2c_chemv(ptr noundef %188, ptr noundef %28, ptr noundef %29, ptr noundef %191, ptr noundef %192, ptr noundef %199, ptr noundef @c__1, ptr noundef @c_b2, ptr noundef %201, ptr noundef @c__1)
  %203 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float -5.000000e-01, ptr %203, align 4, !tbaa !11
  %204 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float -0.000000e+00, ptr %204, align 4, !tbaa !15
  %205 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %206 = load float, ptr %205, align 4, !tbaa !11
  %207 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %208 = load float, ptr %207, align 4, !tbaa !11
  %209 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %210 = load float, ptr %209, align 4, !tbaa !15
  %211 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %212 = load float, ptr %211, align 4, !tbaa !15
  %213 = fmul float %210, %212
  %214 = fneg float %213
  %215 = call float @llvm.fmuladd.f32(float %206, float %208, float %214)
  %216 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float %215, ptr %216, align 4, !tbaa !11
  %217 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %218 = load float, ptr %217, align 4, !tbaa !11
  %219 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %220 = load float, ptr %219, align 4, !tbaa !15
  %221 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %222 = load float, ptr %221, align 4, !tbaa !15
  %223 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %224 = load float, ptr %223, align 4, !tbaa !11
  %225 = fmul float %222, %224
  %226 = call float @llvm.fmuladd.f32(float %218, float %220, float %225)
  %227 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float %226, ptr %227, align 4, !tbaa !15
  %228 = load ptr, ptr %16, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.complex, ptr %228, i64 1
  %230 = load ptr, ptr %12, align 8, !tbaa !5
  %231 = load i64, ptr %28, align 8, !tbaa !9
  %232 = add nsw i64 %231, 1
  %233 = load i64, ptr %18, align 8, !tbaa !9
  %234 = mul nsw i64 %232, %233
  %235 = add nsw i64 %234, 1
  %236 = getelementptr inbounds %struct.complex, ptr %230, i64 %235
  call void @f2c_cdotc(ptr noundef %27, ptr noundef %28, ptr noundef %229, ptr noundef @c__1, ptr noundef %236, ptr noundef @c__1)
  %237 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %238 = load float, ptr %237, align 4, !tbaa !11
  %239 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %240 = load float, ptr %239, align 4, !tbaa !11
  %241 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %242 = load float, ptr %241, align 4, !tbaa !15
  %243 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %244 = load float, ptr %243, align 4, !tbaa !15
  %245 = fmul float %242, %244
  %246 = fneg float %245
  %247 = call float @llvm.fmuladd.f32(float %238, float %240, float %246)
  %248 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  store float %247, ptr %248, align 4, !tbaa !11
  %249 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %250 = load float, ptr %249, align 4, !tbaa !11
  %251 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %252 = load float, ptr %251, align 4, !tbaa !15
  %253 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %254 = load float, ptr %253, align 4, !tbaa !15
  %255 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %256 = load float, ptr %255, align 4, !tbaa !11
  %257 = fmul float %254, %256
  %258 = call float @llvm.fmuladd.f32(float %250, float %252, float %257)
  %259 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  store float %258, ptr %259, align 4, !tbaa !15
  %260 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  %261 = load float, ptr %260, align 4, !tbaa !11
  %262 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  store float %261, ptr %262, align 4, !tbaa !11
  %263 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  %264 = load float, ptr %263, align 4, !tbaa !15
  %265 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 1
  store float %264, ptr %265, align 4, !tbaa !15
  %266 = load ptr, ptr %12, align 8, !tbaa !5
  %267 = load i64, ptr %28, align 8, !tbaa !9
  %268 = add nsw i64 %267, 1
  %269 = load i64, ptr %18, align 8, !tbaa !9
  %270 = mul nsw i64 %268, %269
  %271 = add nsw i64 %270, 1
  %272 = getelementptr inbounds %struct.complex, ptr %266, i64 %271
  %273 = load ptr, ptr %16, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.complex, ptr %273, i64 1
  %275 = call i32 @f2c_caxpy(ptr noundef %28, ptr noundef %30, ptr noundef %272, ptr noundef @c__1, ptr noundef %274, ptr noundef @c__1)
  %276 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  store float -1.000000e+00, ptr %276, align 4, !tbaa !11
  %277 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  store float -0.000000e+00, ptr %277, align 4, !tbaa !15
  %278 = load ptr, ptr %10, align 8, !tbaa !5
  %279 = load ptr, ptr %12, align 8, !tbaa !5
  %280 = load i64, ptr %28, align 8, !tbaa !9
  %281 = add nsw i64 %280, 1
  %282 = load i64, ptr %18, align 8, !tbaa !9
  %283 = mul nsw i64 %281, %282
  %284 = add nsw i64 %283, 1
  %285 = getelementptr inbounds %struct.complex, ptr %279, i64 %284
  %286 = load ptr, ptr %16, align 8, !tbaa !5
  %287 = getelementptr inbounds %struct.complex, ptr %286, i64 1
  %288 = load ptr, ptr %12, align 8, !tbaa !5
  %289 = load i64, ptr %19, align 8, !tbaa !9
  %290 = getelementptr inbounds %struct.complex, ptr %288, i64 %289
  %291 = load ptr, ptr %13, align 8, !tbaa !5
  %292 = call i32 @f2c_cher2(ptr noundef %278, ptr noundef %28, ptr noundef %24, ptr noundef %285, ptr noundef @c__1, ptr noundef %287, ptr noundef @c__1, ptr noundef %290, ptr noundef %291)
  br label %318

293:                                              ; preds = %169
  %294 = load i64, ptr %28, align 8, !tbaa !9
  %295 = load i64, ptr %28, align 8, !tbaa !9
  %296 = load i64, ptr %18, align 8, !tbaa !9
  %297 = mul nsw i64 %295, %296
  %298 = add nsw i64 %294, %297
  store i64 %298, ptr %20, align 8, !tbaa !9
  %299 = load i64, ptr %28, align 8, !tbaa !9
  %300 = load i64, ptr %28, align 8, !tbaa !9
  %301 = load i64, ptr %18, align 8, !tbaa !9
  %302 = mul nsw i64 %300, %301
  %303 = add nsw i64 %299, %302
  store i64 %303, ptr %21, align 8, !tbaa !9
  %304 = load ptr, ptr %12, align 8, !tbaa !5
  %305 = load i64, ptr %21, align 8, !tbaa !9
  %306 = getelementptr inbounds %struct.complex, ptr %304, i64 %305
  %307 = getelementptr inbounds %struct.complex, ptr %306, i32 0, i32 0
  %308 = load float, ptr %307, align 4, !tbaa !11
  store float %308, ptr %23, align 4, !tbaa !14
  %309 = load float, ptr %23, align 4, !tbaa !14
  %310 = load ptr, ptr %12, align 8, !tbaa !5
  %311 = load i64, ptr %20, align 8, !tbaa !9
  %312 = getelementptr inbounds %struct.complex, ptr %310, i64 %311
  %313 = getelementptr inbounds %struct.complex, ptr %312, i32 0, i32 0
  store float %309, ptr %313, align 4, !tbaa !11
  %314 = load ptr, ptr %12, align 8, !tbaa !5
  %315 = load i64, ptr %20, align 8, !tbaa !9
  %316 = getelementptr inbounds %struct.complex, ptr %314, i64 %315
  %317 = getelementptr inbounds %struct.complex, ptr %316, i32 0, i32 1
  store float 0.000000e+00, ptr %317, align 4, !tbaa !15
  br label %318

318:                                              ; preds = %293, %173
  %319 = load i64, ptr %28, align 8, !tbaa !9
  %320 = load i64, ptr %28, align 8, !tbaa !9
  %321 = add nsw i64 %320, 1
  %322 = load i64, ptr %18, align 8, !tbaa !9
  %323 = mul nsw i64 %321, %322
  %324 = add nsw i64 %319, %323
  store i64 %324, ptr %20, align 8, !tbaa !9
  %325 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %325, ptr %21, align 8, !tbaa !9
  %326 = load ptr, ptr %15, align 8, !tbaa !5
  %327 = load i64, ptr %21, align 8, !tbaa !9
  %328 = getelementptr inbounds float, ptr %326, i64 %327
  %329 = load float, ptr %328, align 4, !tbaa !14
  %330 = load ptr, ptr %12, align 8, !tbaa !5
  %331 = load i64, ptr %20, align 8, !tbaa !9
  %332 = getelementptr inbounds %struct.complex, ptr %330, i64 %331
  %333 = getelementptr inbounds %struct.complex, ptr %332, i32 0, i32 0
  store float %329, ptr %333, align 4, !tbaa !11
  %334 = load ptr, ptr %12, align 8, !tbaa !5
  %335 = load i64, ptr %20, align 8, !tbaa !9
  %336 = getelementptr inbounds %struct.complex, ptr %334, i64 %335
  %337 = getelementptr inbounds %struct.complex, ptr %336, i32 0, i32 1
  store float 0.000000e+00, ptr %337, align 4, !tbaa !15
  %338 = load i64, ptr %28, align 8, !tbaa !9
  %339 = add nsw i64 %338, 1
  store i64 %339, ptr %20, align 8, !tbaa !9
  %340 = load i64, ptr %28, align 8, !tbaa !9
  %341 = add nsw i64 %340, 1
  %342 = load i64, ptr %28, align 8, !tbaa !9
  %343 = add nsw i64 %342, 1
  %344 = load i64, ptr %18, align 8, !tbaa !9
  %345 = mul nsw i64 %343, %344
  %346 = add nsw i64 %341, %345
  store i64 %346, ptr %21, align 8, !tbaa !9
  %347 = load ptr, ptr %12, align 8, !tbaa !5
  %348 = load i64, ptr %21, align 8, !tbaa !9
  %349 = getelementptr inbounds %struct.complex, ptr %347, i64 %348
  %350 = getelementptr inbounds %struct.complex, ptr %349, i32 0, i32 0
  %351 = load float, ptr %350, align 4, !tbaa !11
  %352 = load ptr, ptr %14, align 8, !tbaa !5
  %353 = load i64, ptr %20, align 8, !tbaa !9
  %354 = getelementptr inbounds float, ptr %352, i64 %353
  store float %351, ptr %354, align 4, !tbaa !14
  %355 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %355, ptr %20, align 8, !tbaa !9
  %356 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %357 = load float, ptr %356, align 4, !tbaa !11
  %358 = load ptr, ptr %16, align 8, !tbaa !5
  %359 = load i64, ptr %20, align 8, !tbaa !9
  %360 = getelementptr inbounds %struct.complex, ptr %358, i64 %359
  %361 = getelementptr inbounds %struct.complex, ptr %360, i32 0, i32 0
  store float %357, ptr %361, align 4, !tbaa !11
  %362 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %363 = load float, ptr %362, align 4, !tbaa !15
  %364 = load ptr, ptr %16, align 8, !tbaa !5
  %365 = load i64, ptr %20, align 8, !tbaa !9
  %366 = getelementptr inbounds %struct.complex, ptr %364, i64 %365
  %367 = getelementptr inbounds %struct.complex, ptr %366, i32 0, i32 1
  store float %363, ptr %367, align 4, !tbaa !15
  br label %368

368:                                              ; preds = %318
  %369 = load i64, ptr %28, align 8, !tbaa !9
  %370 = add nsw i64 %369, -1
  store i64 %370, ptr %28, align 8, !tbaa !9
  br label %130, !llvm.loop !16

371:                                              ; preds = %130
  %372 = load i64, ptr %18, align 8, !tbaa !9
  %373 = add nsw i64 %372, 1
  store i64 %373, ptr %20, align 8, !tbaa !9
  %374 = load ptr, ptr %12, align 8, !tbaa !5
  %375 = load i64, ptr %20, align 8, !tbaa !9
  %376 = getelementptr inbounds %struct.complex, ptr %374, i64 %375
  %377 = getelementptr inbounds %struct.complex, ptr %376, i32 0, i32 0
  %378 = load float, ptr %377, align 4, !tbaa !11
  %379 = load ptr, ptr %14, align 8, !tbaa !5
  %380 = getelementptr inbounds float, ptr %379, i64 1
  store float %378, ptr %380, align 4, !tbaa !14
  br label %716

381:                                              ; preds = %95
  %382 = load i64, ptr %18, align 8, !tbaa !9
  %383 = add nsw i64 %382, 1
  store i64 %383, ptr %20, align 8, !tbaa !9
  %384 = load i64, ptr %18, align 8, !tbaa !9
  %385 = add nsw i64 %384, 1
  store i64 %385, ptr %21, align 8, !tbaa !9
  %386 = load ptr, ptr %12, align 8, !tbaa !5
  %387 = load i64, ptr %21, align 8, !tbaa !9
  %388 = getelementptr inbounds %struct.complex, ptr %386, i64 %387
  %389 = getelementptr inbounds %struct.complex, ptr %388, i32 0, i32 0
  %390 = load float, ptr %389, align 4, !tbaa !11
  store float %390, ptr %23, align 4, !tbaa !14
  %391 = load float, ptr %23, align 4, !tbaa !14
  %392 = load ptr, ptr %12, align 8, !tbaa !5
  %393 = load i64, ptr %20, align 8, !tbaa !9
  %394 = getelementptr inbounds %struct.complex, ptr %392, i64 %393
  %395 = getelementptr inbounds %struct.complex, ptr %394, i32 0, i32 0
  store float %391, ptr %395, align 4, !tbaa !11
  %396 = load ptr, ptr %12, align 8, !tbaa !5
  %397 = load i64, ptr %20, align 8, !tbaa !9
  %398 = getelementptr inbounds %struct.complex, ptr %396, i64 %397
  %399 = getelementptr inbounds %struct.complex, ptr %398, i32 0, i32 1
  store float 0.000000e+00, ptr %399, align 4, !tbaa !15
  %400 = load ptr, ptr %11, align 8, !tbaa !5
  %401 = load i64, ptr %400, align 8, !tbaa !9
  %402 = sub nsw i64 %401, 1
  store i64 %402, ptr %20, align 8, !tbaa !9
  store i64 1, ptr %28, align 8, !tbaa !9
  br label %403

403:                                              ; preds = %695, %381
  %404 = load i64, ptr %28, align 8, !tbaa !9
  %405 = load i64, ptr %20, align 8, !tbaa !9
  %406 = icmp sle i64 %404, %405
  br i1 %406, label %407, label %698

407:                                              ; preds = %403
  %408 = load i64, ptr %28, align 8, !tbaa !9
  %409 = add nsw i64 %408, 1
  %410 = load i64, ptr %28, align 8, !tbaa !9
  %411 = load i64, ptr %18, align 8, !tbaa !9
  %412 = mul nsw i64 %410, %411
  %413 = add nsw i64 %409, %412
  store i64 %413, ptr %21, align 8, !tbaa !9
  %414 = load ptr, ptr %12, align 8, !tbaa !5
  %415 = load i64, ptr %21, align 8, !tbaa !9
  %416 = getelementptr inbounds %struct.complex, ptr %414, i64 %415
  %417 = getelementptr inbounds %struct.complex, ptr %416, i32 0, i32 0
  %418 = load float, ptr %417, align 4, !tbaa !11
  %419 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  store float %418, ptr %419, align 4, !tbaa !11
  %420 = load ptr, ptr %12, align 8, !tbaa !5
  %421 = load i64, ptr %21, align 8, !tbaa !9
  %422 = getelementptr inbounds %struct.complex, ptr %420, i64 %421
  %423 = getelementptr inbounds %struct.complex, ptr %422, i32 0, i32 1
  %424 = load float, ptr %423, align 4, !tbaa !15
  %425 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 1
  store float %424, ptr %425, align 4, !tbaa !15
  %426 = load ptr, ptr %11, align 8, !tbaa !5
  %427 = load i64, ptr %426, align 8, !tbaa !9
  %428 = load i64, ptr %28, align 8, !tbaa !9
  %429 = sub nsw i64 %427, %428
  store i64 %429, ptr %21, align 8, !tbaa !9
  %430 = load i64, ptr %28, align 8, !tbaa !9
  %431 = add nsw i64 %430, 2
  store i64 %431, ptr %22, align 8, !tbaa !9
  %432 = load ptr, ptr %12, align 8, !tbaa !5
  %433 = load i64, ptr %22, align 8, !tbaa !9
  %434 = load ptr, ptr %11, align 8, !tbaa !5
  %435 = load i64, ptr %434, align 8, !tbaa !9
  %436 = icmp sle i64 %433, %435
  br i1 %436, label %437, label %439

437:                                              ; preds = %407
  %438 = load i64, ptr %22, align 8, !tbaa !9
  br label %442

439:                                              ; preds = %407
  %440 = load ptr, ptr %11, align 8, !tbaa !5
  %441 = load i64, ptr %440, align 8, !tbaa !9
  br label %442

442:                                              ; preds = %439, %437
  %443 = phi i64 [ %438, %437 ], [ %441, %439 ]
  %444 = load i64, ptr %28, align 8, !tbaa !9
  %445 = load i64, ptr %18, align 8, !tbaa !9
  %446 = mul nsw i64 %444, %445
  %447 = add nsw i64 %443, %446
  %448 = getelementptr inbounds %struct.complex, ptr %432, i64 %447
  %449 = call i32 @clarfg_(ptr noundef %21, ptr noundef %30, ptr noundef %448, ptr noundef @c__1, ptr noundef %29)
  %450 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %450, ptr %21, align 8, !tbaa !9
  %451 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  %452 = load float, ptr %451, align 4, !tbaa !11
  %453 = load ptr, ptr %15, align 8, !tbaa !5
  %454 = load i64, ptr %21, align 8, !tbaa !9
  %455 = getelementptr inbounds float, ptr %453, i64 %454
  store float %452, ptr %455, align 4, !tbaa !14
  %456 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %457 = load float, ptr %456, align 4, !tbaa !11
  %458 = fcmp une float %457, 0.000000e+00
  br i1 %458, label %463, label %459

459:                                              ; preds = %442
  %460 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %461 = load float, ptr %460, align 4, !tbaa !15
  %462 = fcmp une float %461, 0.000000e+00
  br i1 %462, label %463, label %619

463:                                              ; preds = %459, %442
  %464 = load i64, ptr %28, align 8, !tbaa !9
  %465 = add nsw i64 %464, 1
  %466 = load i64, ptr %28, align 8, !tbaa !9
  %467 = load i64, ptr %18, align 8, !tbaa !9
  %468 = mul nsw i64 %466, %467
  %469 = add nsw i64 %465, %468
  store i64 %469, ptr %21, align 8, !tbaa !9
  %470 = load ptr, ptr %12, align 8, !tbaa !5
  %471 = load i64, ptr %21, align 8, !tbaa !9
  %472 = getelementptr inbounds %struct.complex, ptr %470, i64 %471
  %473 = getelementptr inbounds %struct.complex, ptr %472, i32 0, i32 0
  store float 1.000000e+00, ptr %473, align 4, !tbaa !11
  %474 = load ptr, ptr %12, align 8, !tbaa !5
  %475 = load i64, ptr %21, align 8, !tbaa !9
  %476 = getelementptr inbounds %struct.complex, ptr %474, i64 %475
  %477 = getelementptr inbounds %struct.complex, ptr %476, i32 0, i32 1
  store float 0.000000e+00, ptr %477, align 4, !tbaa !15
  %478 = load ptr, ptr %11, align 8, !tbaa !5
  %479 = load i64, ptr %478, align 8, !tbaa !9
  %480 = load i64, ptr %28, align 8, !tbaa !9
  %481 = sub nsw i64 %479, %480
  store i64 %481, ptr %21, align 8, !tbaa !9
  %482 = load ptr, ptr %10, align 8, !tbaa !5
  %483 = load ptr, ptr %12, align 8, !tbaa !5
  %484 = load i64, ptr %28, align 8, !tbaa !9
  %485 = add nsw i64 %484, 1
  %486 = load i64, ptr %28, align 8, !tbaa !9
  %487 = add nsw i64 %486, 1
  %488 = load i64, ptr %18, align 8, !tbaa !9
  %489 = mul nsw i64 %487, %488
  %490 = add nsw i64 %485, %489
  %491 = getelementptr inbounds %struct.complex, ptr %483, i64 %490
  %492 = load ptr, ptr %13, align 8, !tbaa !5
  %493 = load ptr, ptr %12, align 8, !tbaa !5
  %494 = load i64, ptr %28, align 8, !tbaa !9
  %495 = add nsw i64 %494, 1
  %496 = load i64, ptr %28, align 8, !tbaa !9
  %497 = load i64, ptr %18, align 8, !tbaa !9
  %498 = mul nsw i64 %496, %497
  %499 = add nsw i64 %495, %498
  %500 = getelementptr inbounds %struct.complex, ptr %493, i64 %499
  %501 = load ptr, ptr %16, align 8, !tbaa !5
  %502 = load i64, ptr %28, align 8, !tbaa !9
  %503 = getelementptr inbounds %struct.complex, ptr %501, i64 %502
  %504 = call i32 @f2c_chemv(ptr noundef %482, ptr noundef %21, ptr noundef %29, ptr noundef %491, ptr noundef %492, ptr noundef %500, ptr noundef @c__1, ptr noundef @c_b2, ptr noundef %503, ptr noundef @c__1)
  %505 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  store float -5.000000e-01, ptr %505, align 4, !tbaa !11
  %506 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  store float -0.000000e+00, ptr %506, align 4, !tbaa !15
  %507 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %508 = load float, ptr %507, align 4, !tbaa !11
  %509 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %510 = load float, ptr %509, align 4, !tbaa !11
  %511 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %512 = load float, ptr %511, align 4, !tbaa !15
  %513 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %514 = load float, ptr %513, align 4, !tbaa !15
  %515 = fmul float %512, %514
  %516 = fneg float %515
  %517 = call float @llvm.fmuladd.f32(float %508, float %510, float %516)
  %518 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  store float %517, ptr %518, align 4, !tbaa !11
  %519 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 0
  %520 = load float, ptr %519, align 4, !tbaa !11
  %521 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %522 = load float, ptr %521, align 4, !tbaa !15
  %523 = getelementptr inbounds %struct.complex, ptr %26, i32 0, i32 1
  %524 = load float, ptr %523, align 4, !tbaa !15
  %525 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %526 = load float, ptr %525, align 4, !tbaa !11
  %527 = fmul float %524, %526
  %528 = call float @llvm.fmuladd.f32(float %520, float %522, float %527)
  %529 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  store float %528, ptr %529, align 4, !tbaa !15
  %530 = load ptr, ptr %11, align 8, !tbaa !5
  %531 = load i64, ptr %530, align 8, !tbaa !9
  %532 = load i64, ptr %28, align 8, !tbaa !9
  %533 = sub nsw i64 %531, %532
  store i64 %533, ptr %21, align 8, !tbaa !9
  %534 = load ptr, ptr %16, align 8, !tbaa !5
  %535 = load i64, ptr %28, align 8, !tbaa !9
  %536 = getelementptr inbounds %struct.complex, ptr %534, i64 %535
  %537 = load ptr, ptr %12, align 8, !tbaa !5
  %538 = load i64, ptr %28, align 8, !tbaa !9
  %539 = add nsw i64 %538, 1
  %540 = load i64, ptr %28, align 8, !tbaa !9
  %541 = load i64, ptr %18, align 8, !tbaa !9
  %542 = mul nsw i64 %540, %541
  %543 = add nsw i64 %539, %542
  %544 = getelementptr inbounds %struct.complex, ptr %537, i64 %543
  call void @f2c_cdotc(ptr noundef %27, ptr noundef %21, ptr noundef %536, ptr noundef @c__1, ptr noundef %544, ptr noundef @c__1)
  %545 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %546 = load float, ptr %545, align 4, !tbaa !11
  %547 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %548 = load float, ptr %547, align 4, !tbaa !11
  %549 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %550 = load float, ptr %549, align 4, !tbaa !15
  %551 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %552 = load float, ptr %551, align 4, !tbaa !15
  %553 = fmul float %550, %552
  %554 = fneg float %553
  %555 = call float @llvm.fmuladd.f32(float %546, float %548, float %554)
  %556 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  store float %555, ptr %556, align 4, !tbaa !11
  %557 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 0
  %558 = load float, ptr %557, align 4, !tbaa !11
  %559 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 1
  %560 = load float, ptr %559, align 4, !tbaa !15
  %561 = getelementptr inbounds %struct.complex, ptr %25, i32 0, i32 1
  %562 = load float, ptr %561, align 4, !tbaa !15
  %563 = getelementptr inbounds %struct.complex, ptr %27, i32 0, i32 0
  %564 = load float, ptr %563, align 4, !tbaa !11
  %565 = fmul float %562, %564
  %566 = call float @llvm.fmuladd.f32(float %558, float %560, float %565)
  %567 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  store float %566, ptr %567, align 4, !tbaa !15
  %568 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  %569 = load float, ptr %568, align 4, !tbaa !11
  %570 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 0
  store float %569, ptr %570, align 4, !tbaa !11
  %571 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  %572 = load float, ptr %571, align 4, !tbaa !15
  %573 = getelementptr inbounds %struct.complex, ptr %30, i32 0, i32 1
  store float %572, ptr %573, align 4, !tbaa !15
  %574 = load ptr, ptr %11, align 8, !tbaa !5
  %575 = load i64, ptr %574, align 8, !tbaa !9
  %576 = load i64, ptr %28, align 8, !tbaa !9
  %577 = sub nsw i64 %575, %576
  store i64 %577, ptr %21, align 8, !tbaa !9
  %578 = load ptr, ptr %12, align 8, !tbaa !5
  %579 = load i64, ptr %28, align 8, !tbaa !9
  %580 = add nsw i64 %579, 1
  %581 = load i64, ptr %28, align 8, !tbaa !9
  %582 = load i64, ptr %18, align 8, !tbaa !9
  %583 = mul nsw i64 %581, %582
  %584 = add nsw i64 %580, %583
  %585 = getelementptr inbounds %struct.complex, ptr %578, i64 %584
  %586 = load ptr, ptr %16, align 8, !tbaa !5
  %587 = load i64, ptr %28, align 8, !tbaa !9
  %588 = getelementptr inbounds %struct.complex, ptr %586, i64 %587
  %589 = call i32 @f2c_caxpy(ptr noundef %21, ptr noundef %30, ptr noundef %585, ptr noundef @c__1, ptr noundef %588, ptr noundef @c__1)
  %590 = load ptr, ptr %11, align 8, !tbaa !5
  %591 = load i64, ptr %590, align 8, !tbaa !9
  %592 = load i64, ptr %28, align 8, !tbaa !9
  %593 = sub nsw i64 %591, %592
  store i64 %593, ptr %21, align 8, !tbaa !9
  %594 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 0
  store float -1.000000e+00, ptr %594, align 4, !tbaa !11
  %595 = getelementptr inbounds %struct.complex, ptr %24, i32 0, i32 1
  store float -0.000000e+00, ptr %595, align 4, !tbaa !15
  %596 = load ptr, ptr %10, align 8, !tbaa !5
  %597 = load ptr, ptr %12, align 8, !tbaa !5
  %598 = load i64, ptr %28, align 8, !tbaa !9
  %599 = add nsw i64 %598, 1
  %600 = load i64, ptr %28, align 8, !tbaa !9
  %601 = load i64, ptr %18, align 8, !tbaa !9
  %602 = mul nsw i64 %600, %601
  %603 = add nsw i64 %599, %602
  %604 = getelementptr inbounds %struct.complex, ptr %597, i64 %603
  %605 = load ptr, ptr %16, align 8, !tbaa !5
  %606 = load i64, ptr %28, align 8, !tbaa !9
  %607 = getelementptr inbounds %struct.complex, ptr %605, i64 %606
  %608 = load ptr, ptr %12, align 8, !tbaa !5
  %609 = load i64, ptr %28, align 8, !tbaa !9
  %610 = add nsw i64 %609, 1
  %611 = load i64, ptr %28, align 8, !tbaa !9
  %612 = add nsw i64 %611, 1
  %613 = load i64, ptr %18, align 8, !tbaa !9
  %614 = mul nsw i64 %612, %613
  %615 = add nsw i64 %610, %614
  %616 = getelementptr inbounds %struct.complex, ptr %608, i64 %615
  %617 = load ptr, ptr %13, align 8, !tbaa !5
  %618 = call i32 @f2c_cher2(ptr noundef %596, ptr noundef %21, ptr noundef %24, ptr noundef %604, ptr noundef @c__1, ptr noundef %607, ptr noundef @c__1, ptr noundef %616, ptr noundef %617)
  br label %648

619:                                              ; preds = %459
  %620 = load i64, ptr %28, align 8, !tbaa !9
  %621 = add nsw i64 %620, 1
  %622 = load i64, ptr %28, align 8, !tbaa !9
  %623 = add nsw i64 %622, 1
  %624 = load i64, ptr %18, align 8, !tbaa !9
  %625 = mul nsw i64 %623, %624
  %626 = add nsw i64 %621, %625
  store i64 %626, ptr %21, align 8, !tbaa !9
  %627 = load i64, ptr %28, align 8, !tbaa !9
  %628 = add nsw i64 %627, 1
  %629 = load i64, ptr %28, align 8, !tbaa !9
  %630 = add nsw i64 %629, 1
  %631 = load i64, ptr %18, align 8, !tbaa !9
  %632 = mul nsw i64 %630, %631
  %633 = add nsw i64 %628, %632
  store i64 %633, ptr %22, align 8, !tbaa !9
  %634 = load ptr, ptr %12, align 8, !tbaa !5
  %635 = load i64, ptr %22, align 8, !tbaa !9
  %636 = getelementptr inbounds %struct.complex, ptr %634, i64 %635
  %637 = getelementptr inbounds %struct.complex, ptr %636, i32 0, i32 0
  %638 = load float, ptr %637, align 4, !tbaa !11
  store float %638, ptr %23, align 4, !tbaa !14
  %639 = load float, ptr %23, align 4, !tbaa !14
  %640 = load ptr, ptr %12, align 8, !tbaa !5
  %641 = load i64, ptr %21, align 8, !tbaa !9
  %642 = getelementptr inbounds %struct.complex, ptr %640, i64 %641
  %643 = getelementptr inbounds %struct.complex, ptr %642, i32 0, i32 0
  store float %639, ptr %643, align 4, !tbaa !11
  %644 = load ptr, ptr %12, align 8, !tbaa !5
  %645 = load i64, ptr %21, align 8, !tbaa !9
  %646 = getelementptr inbounds %struct.complex, ptr %644, i64 %645
  %647 = getelementptr inbounds %struct.complex, ptr %646, i32 0, i32 1
  store float 0.000000e+00, ptr %647, align 4, !tbaa !15
  br label %648

648:                                              ; preds = %619, %463
  %649 = load i64, ptr %28, align 8, !tbaa !9
  %650 = add nsw i64 %649, 1
  %651 = load i64, ptr %28, align 8, !tbaa !9
  %652 = load i64, ptr %18, align 8, !tbaa !9
  %653 = mul nsw i64 %651, %652
  %654 = add nsw i64 %650, %653
  store i64 %654, ptr %21, align 8, !tbaa !9
  %655 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %655, ptr %22, align 8, !tbaa !9
  %656 = load ptr, ptr %15, align 8, !tbaa !5
  %657 = load i64, ptr %22, align 8, !tbaa !9
  %658 = getelementptr inbounds float, ptr %656, i64 %657
  %659 = load float, ptr %658, align 4, !tbaa !14
  %660 = load ptr, ptr %12, align 8, !tbaa !5
  %661 = load i64, ptr %21, align 8, !tbaa !9
  %662 = getelementptr inbounds %struct.complex, ptr %660, i64 %661
  %663 = getelementptr inbounds %struct.complex, ptr %662, i32 0, i32 0
  store float %659, ptr %663, align 4, !tbaa !11
  %664 = load ptr, ptr %12, align 8, !tbaa !5
  %665 = load i64, ptr %21, align 8, !tbaa !9
  %666 = getelementptr inbounds %struct.complex, ptr %664, i64 %665
  %667 = getelementptr inbounds %struct.complex, ptr %666, i32 0, i32 1
  store float 0.000000e+00, ptr %667, align 4, !tbaa !15
  %668 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %668, ptr %21, align 8, !tbaa !9
  %669 = load i64, ptr %28, align 8, !tbaa !9
  %670 = load i64, ptr %28, align 8, !tbaa !9
  %671 = load i64, ptr %18, align 8, !tbaa !9
  %672 = mul nsw i64 %670, %671
  %673 = add nsw i64 %669, %672
  store i64 %673, ptr %22, align 8, !tbaa !9
  %674 = load ptr, ptr %12, align 8, !tbaa !5
  %675 = load i64, ptr %22, align 8, !tbaa !9
  %676 = getelementptr inbounds %struct.complex, ptr %674, i64 %675
  %677 = getelementptr inbounds %struct.complex, ptr %676, i32 0, i32 0
  %678 = load float, ptr %677, align 4, !tbaa !11
  %679 = load ptr, ptr %14, align 8, !tbaa !5
  %680 = load i64, ptr %21, align 8, !tbaa !9
  %681 = getelementptr inbounds float, ptr %679, i64 %680
  store float %678, ptr %681, align 4, !tbaa !14
  %682 = load i64, ptr %28, align 8, !tbaa !9
  store i64 %682, ptr %21, align 8, !tbaa !9
  %683 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 0
  %684 = load float, ptr %683, align 4, !tbaa !11
  %685 = load ptr, ptr %16, align 8, !tbaa !5
  %686 = load i64, ptr %21, align 8, !tbaa !9
  %687 = getelementptr inbounds %struct.complex, ptr %685, i64 %686
  %688 = getelementptr inbounds %struct.complex, ptr %687, i32 0, i32 0
  store float %684, ptr %688, align 4, !tbaa !11
  %689 = getelementptr inbounds %struct.complex, ptr %29, i32 0, i32 1
  %690 = load float, ptr %689, align 4, !tbaa !15
  %691 = load ptr, ptr %16, align 8, !tbaa !5
  %692 = load i64, ptr %21, align 8, !tbaa !9
  %693 = getelementptr inbounds %struct.complex, ptr %691, i64 %692
  %694 = getelementptr inbounds %struct.complex, ptr %693, i32 0, i32 1
  store float %690, ptr %694, align 4, !tbaa !15
  br label %695

695:                                              ; preds = %648
  %696 = load i64, ptr %28, align 8, !tbaa !9
  %697 = add nsw i64 %696, 1
  store i64 %697, ptr %28, align 8, !tbaa !9
  br label %403, !llvm.loop !18

698:                                              ; preds = %403
  %699 = load ptr, ptr %11, align 8, !tbaa !5
  %700 = load i64, ptr %699, align 8, !tbaa !9
  store i64 %700, ptr %20, align 8, !tbaa !9
  %701 = load ptr, ptr %11, align 8, !tbaa !5
  %702 = load i64, ptr %701, align 8, !tbaa !9
  %703 = load ptr, ptr %11, align 8, !tbaa !5
  %704 = load i64, ptr %703, align 8, !tbaa !9
  %705 = load i64, ptr %18, align 8, !tbaa !9
  %706 = mul nsw i64 %704, %705
  %707 = add nsw i64 %702, %706
  store i64 %707, ptr %21, align 8, !tbaa !9
  %708 = load ptr, ptr %12, align 8, !tbaa !5
  %709 = load i64, ptr %21, align 8, !tbaa !9
  %710 = getelementptr inbounds %struct.complex, ptr %708, i64 %709
  %711 = getelementptr inbounds %struct.complex, ptr %710, i32 0, i32 0
  %712 = load float, ptr %711, align 4, !tbaa !11
  %713 = load ptr, ptr %14, align 8, !tbaa !5
  %714 = load i64, ptr %20, align 8, !tbaa !9
  %715 = getelementptr inbounds float, ptr %713, i64 %714
  store float %712, ptr %715, align 4, !tbaa !14
  br label %716

716:                                              ; preds = %698, %371
  store i32 0, ptr %9, align 4
  store i32 1, ptr %32, align 4
  br label %717

717:                                              ; preds = %716, %94, %85
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #4
  %718 = load i32, ptr %9, align 4
  ret i32 %718
}

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

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

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

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

declare i32 @f2c_chemv(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 float @llvm.fmuladd.f32(float, float, float) #3

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

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

declare i32 @f2c_cher2(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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nounwind }

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

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


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

%struct.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1
@c__1 = external hidden global i64, align 8
@c_b2 = external hidden global %struct.complex, align 4

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

24:                                               ; preds = %8
  %25 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #5
  %.not174 = icmp eq i64 %25, 0
  br i1 %.not174, label %.thread.sink.split, label %26

26:                                               ; preds = %24, %8
  %27 = load i64, ptr %1, align 8, !tbaa !5
  %28 = icmp slt i64 %27, 0
  br i1 %28, label %.thread.sink.split, label %29

29:                                               ; preds = %26
  %30 = load i64, ptr %3, align 8, !tbaa !5
  %spec.select = tail call i64 @llvm.umax.i64(i64 %27, i64 1)
  %31 = icmp slt i64 %30, %spec.select
  br i1 %31, label %.thread.sink.split, label %32

32:                                               ; preds = %29
  %.pr = load i64, ptr %7, align 8, !tbaa !5
  %.not175 = icmp eq i64 %.pr, 0
  br i1 %.not175, label %36, label %.thread

.thread.sink.split:                               ; preds = %29, %26, %24
  %.sink = phi i64 [ -1, %24 ], [ -2, %26 ], [ -4, %29 ]
  store i64 %.sink, ptr %7, align 8, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %.thread.sink.split, %32
  %33 = phi i64 [ %.pr, %32 ], [ %.sink, %.thread.sink.split ]
  %34 = sub nsw i64 0, %33
  store i64 %34, ptr %9, align 8, !tbaa !5
  %35 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %9) #5
  br label %184

36:                                               ; preds = %32
  %37 = icmp eq i64 %27, 0
  br i1 %37, label %184, label %38

38:                                               ; preds = %36
  %invariant.gep192 = getelementptr i8, ptr %19, i64 8
  br i1 %.not, label %109, label %39

39:                                               ; preds = %38
  %40 = mul i64 %27, %17
  %41 = getelementptr inbounds %struct.complex, ptr %19, i64 %40, i32 1
  store float 0.000000e+00, ptr %41, align 4, !tbaa !9
  %storemerge178189 = add nsw i64 %27, -1
  store i64 %storemerge178189, ptr %13, align 8, !tbaa !5
  %.not206 = icmp eq i64 %27, 1
  br i1 %.not206, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %39
  %42 = getelementptr inbounds i8, ptr %14, i64 4
  br label %43

43:                                               ; preds = %.lr.ph, %93
  %storemerge178191 = phi i64 [ %storemerge178189, %.lr.ph ], [ %storemerge178, %93 ]
  %storemerge178.in190 = phi i64 [ %27, %.lr.ph ], [ %storemerge178.in, %93 ]
  %44 = mul nsw i64 %storemerge178.in190, %16
  %45 = getelementptr %struct.complex, ptr %19, i64 %storemerge178191
  %46 = getelementptr %struct.complex, ptr %45, i64 %44
  %47 = load <2 x float>, ptr %46, align 4, !tbaa !12
  store <2 x float> %47, ptr %15, align 8, !tbaa !12
  %gep = getelementptr %struct.complex, ptr %invariant.gep192, i64 %44
  %48 = call i32 @clarfg_(ptr noundef nonnull %13, ptr noundef nonnull %15, ptr noundef %gep, ptr noundef nonnull @c__1, ptr noundef nonnull %14) #5
  %49 = load i64, ptr %13, align 8, !tbaa !5
  %50 = load float, ptr %15, align 8, !tbaa !13
  %51 = getelementptr inbounds float, ptr %21, i64 %49
  store float %50, ptr %51, align 4, !tbaa !12
  %52 = load <2 x float>, ptr %14, align 8
  %53 = extractelement <2 x float> %52, i64 0
  %54 = fcmp une float %53, 0.000000e+00
  %55 = extractelement <2 x float> %52, i64 1
  %56 = fcmp une float %55, 0.000000e+00
  %or.cond = select i1 %54, i1 true, i1 %56
  br i1 %or.cond, label %57, label %90

57:                                               ; preds = %43
  %58 = add nsw i64 %49, 1
  %59 = mul nsw i64 %58, %16
  %60 = getelementptr %struct.complex, ptr %19, i64 %59
  %61 = getelementptr %struct.complex, ptr %60, i64 %49
  store <2 x float> <float 1.000000e+00, float 0.000000e+00>, ptr %61, align 4, !tbaa !12
  %gep181 = getelementptr %struct.complex, ptr %invariant.gep192, i64 %59
  %62 = call i32 @f2c_chemv(ptr noundef %0, ptr noundef nonnull %13, ptr noundef nonnull %14, ptr noundef nonnull %2, ptr noundef nonnull %3, ptr noundef %gep181, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b2, ptr noundef %6, ptr noundef nonnull @c__1) #5
  %63 = load float, ptr %14, align 8, !tbaa !13
  %64 = load float, ptr %42, align 4, !tbaa !9
  %65 = fmul float %64, 0.000000e+00
  %66 = call float @llvm.fmuladd.f32(float %63, float -5.000000e-01, float %65)
  %67 = fmul float %63, -0.000000e+00
  %68 = call float @llvm.fmuladd.f32(float %64, float -5.000000e-01, float %67)
  %69 = load i64, ptr %13, align 8, !tbaa !5
  %70 = add nsw i64 %69, 1
  %71 = mul nsw i64 %70, %16
  %gep183 = getelementptr %struct.complex, ptr %invariant.gep192, i64 %71
  call void @f2c_cdotc(ptr noundef nonnull %12, ptr noundef nonnull %13, ptr noundef %6, ptr noundef nonnull @c__1, ptr noundef %gep183, ptr noundef nonnull @c__1) #5
  %72 = fneg float %68
  %73 = load <2 x float>, ptr %12, align 8, !tbaa !12
  %74 = insertelement <2 x float> poison, float %68, i64 0
  %75 = insertelement <2 x float> %74, float %72, i64 1
  %76 = fmul <2 x float> %73, %75
  %77 = shufflevector <2 x float> %76, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %78 = insertelement <2 x float> poison, float %66, i64 0
  %79 = shufflevector <2 x float> %78, <2 x float> poison, <2 x i32> zeroinitializer
  %80 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %79, <2 x float> %73, <2 x float> %77)
  store <2 x float> %80, ptr %11, align 8, !tbaa !12
  store <2 x float> %80, ptr %15, align 8, !tbaa !12
  %81 = load i64, ptr %13, align 8, !tbaa !5
  %82 = add nsw i64 %81, 1
  %83 = mul nsw i64 %82, %16
  %gep185 = getelementptr %struct.complex, ptr %invariant.gep192, i64 %83
  %84 = call i32 @f2c_caxpy(ptr noundef nonnull %13, ptr noundef nonnull %15, ptr noundef %gep185, ptr noundef nonnull @c__1, ptr noundef %6, ptr noundef nonnull @c__1) #5
  store <2 x float> <float -1.000000e+00, float -0.000000e+00>, ptr %11, align 8, !tbaa !12
  %85 = load i64, ptr %13, align 8, !tbaa !5
  %86 = add nsw i64 %85, 1
  %87 = mul nsw i64 %86, %16
  %gep187 = getelementptr %struct.complex, ptr %invariant.gep192, i64 %87
  %88 = call i32 @f2c_cher2(ptr noundef %0, ptr noundef nonnull %13, ptr noundef nonnull %11, ptr noundef %gep187, ptr noundef nonnull @c__1, ptr noundef %6, ptr noundef nonnull @c__1, ptr noundef nonnull %2, ptr noundef nonnull %3) #5
  %.pre = load i64, ptr %13, align 8, !tbaa !5
  %89 = load <2 x float>, ptr %14, align 8, !tbaa !12
  br label %93

90:                                               ; preds = %43
  %91 = mul i64 %49, %17
  %92 = getelementptr inbounds %struct.complex, ptr %19, i64 %91, i32 1
  store float 0.000000e+00, ptr %92, align 4, !tbaa !9
  br label %93

93:                                               ; preds = %90, %57
  %storemerge178.in = phi i64 [ %49, %90 ], [ %.pre, %57 ]
  %94 = phi <2 x float> [ %52, %90 ], [ %89, %57 ]
  %95 = add nsw i64 %storemerge178.in, 1
  %96 = mul nsw i64 %95, %16
  %97 = add nsw i64 %96, %storemerge178.in
  %98 = getelementptr inbounds float, ptr %21, i64 %storemerge178.in
  %99 = load float, ptr %98, align 4, !tbaa !12
  %100 = getelementptr inbounds %struct.complex, ptr %19, i64 %97
  store float %99, ptr %100, align 4, !tbaa !13
  %101 = getelementptr inbounds %struct.complex, ptr %19, i64 %97, i32 1
  store float 0.000000e+00, ptr %101, align 4, !tbaa !9
  %102 = mul i64 %95, %17
  %103 = getelementptr inbounds %struct.complex, ptr %19, i64 %102
  %104 = load float, ptr %103, align 4, !tbaa !13
  %105 = getelementptr float, ptr %4, i64 %storemerge178.in
  store float %104, ptr %105, align 4, !tbaa !12
  %106 = getelementptr inbounds %struct.complex, ptr %22, i64 %storemerge178.in
  store <2 x float> %94, ptr %106, align 4, !tbaa !12
  %storemerge178 = add nsw i64 %storemerge178.in, -1
  store i64 %storemerge178, ptr %13, align 8, !tbaa !5
  %107 = icmp sgt i64 %storemerge178.in, 1
  br i1 %107, label %43, label %._crit_edge, !llvm.loop !14

._crit_edge:                                      ; preds = %93, %39
  %108 = load float, ptr %2, align 4, !tbaa !13
  store float %108, ptr %4, align 4, !tbaa !12
  br label %184

109:                                              ; preds = %38
  %110 = getelementptr inbounds i8, ptr %2, i64 4
  store float 0.000000e+00, ptr %110, align 4, !tbaa !9
  %111 = add nsw i64 %27, -1
  %.not176196 = icmp eq i64 %27, 1
  br i1 %.not176196, label %._crit_edge200, label %.lr.ph199

.lr.ph199:                                        ; preds = %109
  %112 = getelementptr inbounds i8, ptr %14, i64 4
  br label %113

113:                                              ; preds = %.lr.ph199, %171
  %114 = phi i64 [ 1, %.lr.ph199 ], [ %115, %171 ]
  %115 = add nuw nsw i64 %114, 1
  %116 = mul nsw i64 %114, %16
  %117 = add nsw i64 %115, %116
  %118 = getelementptr inbounds %struct.complex, ptr %19, i64 %117
  %119 = getelementptr inbounds %struct.complex, ptr %19, i64 %117, i32 1
  %120 = load <2 x float>, ptr %118, align 4, !tbaa !12
  store <2 x float> %120, ptr %15, align 8, !tbaa !12
  %121 = load i64, ptr %1, align 8, !tbaa !5
  %122 = sub nsw i64 %121, %114
  store i64 %122, ptr %10, align 8, !tbaa !5
  %123 = add nuw nsw i64 %114, 2
  %. = call i64 @llvm.smin.i64(i64 %123, i64 %121)
  %124 = getelementptr %struct.complex, ptr %19, i64 %.
  %125 = getelementptr %struct.complex, ptr %124, i64 %116
  %126 = call i32 @clarfg_(ptr noundef nonnull %10, ptr noundef nonnull %15, ptr noundef %125, ptr noundef nonnull @c__1, ptr noundef nonnull %14) #5
  %127 = load float, ptr %15, align 8, !tbaa !13
  %128 = getelementptr inbounds float, ptr %21, i64 %114
  store float %127, ptr %128, align 4, !tbaa !12
  %129 = load <2 x float>, ptr %14, align 8
  %130 = extractelement <2 x float> %129, i64 0
  %131 = fcmp une float %130, 0.000000e+00
  %132 = extractelement <2 x float> %129, i64 1
  %133 = fcmp une float %132, 0.000000e+00
  %or.cond5 = select i1 %131, i1 true, i1 %133
  br i1 %or.cond5, label %134, label %168

134:                                              ; preds = %113
  store <2 x float> <float 1.000000e+00, float 0.000000e+00>, ptr %118, align 4, !tbaa !12
  %135 = load i64, ptr %1, align 8, !tbaa !5
  %136 = sub nsw i64 %135, %114
  store i64 %136, ptr %10, align 8, !tbaa !5
  %137 = mul i64 %115, %17
  %138 = getelementptr inbounds %struct.complex, ptr %19, i64 %137
  %139 = getelementptr %struct.complex, ptr %19, i64 %115
  %140 = getelementptr %struct.complex, ptr %139, i64 %116
  %141 = getelementptr inbounds %struct.complex, ptr %22, i64 %114
  %142 = call i32 @f2c_chemv(ptr noundef %0, ptr noundef nonnull %10, ptr noundef nonnull %14, ptr noundef %138, ptr noundef nonnull %3, ptr noundef %140, ptr noundef nonnull @c__1, ptr noundef nonnull @c_b2, ptr noundef nonnull %141, ptr noundef nonnull @c__1) #5
  %143 = load float, ptr %14, align 8, !tbaa !13
  %144 = load float, ptr %112, align 4, !tbaa !9
  %145 = fmul float %144, 0.000000e+00
  %146 = call float @llvm.fmuladd.f32(float %143, float -5.000000e-01, float %145)
  %147 = fmul float %143, -0.000000e+00
  %148 = call float @llvm.fmuladd.f32(float %144, float -5.000000e-01, float %147)
  %149 = load i64, ptr %1, align 8, !tbaa !5
  %150 = sub nsw i64 %149, %114
  store i64 %150, ptr %10, align 8, !tbaa !5
  %gep193 = getelementptr %struct.complex, ptr %invariant.gep192, i64 %114
  %151 = getelementptr %struct.complex, ptr %gep193, i64 %116
  call void @f2c_cdotc(ptr noundef nonnull %12, ptr noundef nonnull %10, ptr noundef nonnull %141, ptr noundef nonnull @c__1, ptr noundef %151, ptr noundef nonnull @c__1) #5
  %152 = fneg float %148
  %153 = load <2 x float>, ptr %12, align 8, !tbaa !12
  %154 = insertelement <2 x float> poison, float %148, i64 0
  %155 = insertelement <2 x float> %154, float %152, i64 1
  %156 = fmul <2 x float> %153, %155
  %157 = shufflevector <2 x float> %156, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %158 = insertelement <2 x float> poison, float %146, i64 0
  %159 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> zeroinitializer
  %160 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %159, <2 x float> %153, <2 x float> %157)
  store <2 x float> %160, ptr %11, align 8, !tbaa !12
  store <2 x float> %160, ptr %15, align 8, !tbaa !12
  %161 = load i64, ptr %1, align 8, !tbaa !5
  %162 = sub nsw i64 %161, %114
  store i64 %162, ptr %10, align 8, !tbaa !5
  %163 = call i32 @f2c_caxpy(ptr noundef nonnull %10, ptr noundef nonnull %15, ptr noundef %151, ptr noundef nonnull @c__1, ptr noundef nonnull %141, ptr noundef nonnull @c__1) #5
  %164 = load i64, ptr %1, align 8, !tbaa !5
  %165 = sub nsw i64 %164, %114
  store i64 %165, ptr %10, align 8, !tbaa !5
  store <2 x float> <float -1.000000e+00, float -0.000000e+00>, ptr %11, align 8, !tbaa !12
  %166 = call i32 @f2c_cher2(ptr noundef %0, ptr noundef nonnull %10, ptr noundef nonnull %11, ptr noundef %140, ptr noundef nonnull @c__1, ptr noundef nonnull %141, ptr noundef nonnull @c__1, ptr noundef %138, ptr noundef nonnull %3) #5
  %167 = load <2 x float>, ptr %14, align 8, !tbaa !12
  br label %171

168:                                              ; preds = %113
  %169 = mul i64 %115, %17
  %170 = getelementptr inbounds %struct.complex, ptr %19, i64 %169, i32 1
  store float 0.000000e+00, ptr %170, align 4, !tbaa !9
  br label %171

171:                                              ; preds = %168, %134
  %172 = phi <2 x float> [ %129, %168 ], [ %167, %134 ]
  %173 = load float, ptr %128, align 4, !tbaa !12
  store float %173, ptr %118, align 4, !tbaa !13
  store float 0.000000e+00, ptr %119, align 4, !tbaa !9
  %174 = mul i64 %114, %17
  %175 = getelementptr inbounds %struct.complex, ptr %19, i64 %174
  %176 = load float, ptr %175, align 4, !tbaa !13
  %177 = getelementptr inbounds float, ptr %20, i64 %114
  store float %176, ptr %177, align 4, !tbaa !12
  store i64 %114, ptr %10, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.complex, ptr %22, i64 %114
  store <2 x float> %172, ptr %178, align 4, !tbaa !12
  %.not176.not = icmp slt i64 %114, %111
  br i1 %.not176.not, label %113, label %._crit_edge200.loopexit, !llvm.loop !16

._crit_edge200.loopexit:                          ; preds = %171
  %.pre205 = load i64, ptr %1, align 8, !tbaa !5
  br label %._crit_edge200

._crit_edge200:                                   ; preds = %._crit_edge200.loopexit, %109
  %179 = phi i64 [ %.pre205, %._crit_edge200.loopexit ], [ 1, %109 ]
  %180 = mul i64 %179, %17
  %181 = getelementptr inbounds %struct.complex, ptr %19, i64 %180
  %182 = load float, ptr %181, align 4, !tbaa !13
  %183 = getelementptr inbounds float, ptr %20, i64 %179
  store float %182, ptr %183, align 4, !tbaa !12
  br label %184

184:                                              ; preds = %._crit_edge, %._crit_edge200, %36, %.thread
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %12) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %9) #5
  ret i32 0
}

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

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

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

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

declare i32 @f2c_chemv(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 float @llvm.fmuladd.f32(float, float, float) #3

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

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

declare i32 @f2c_cher2(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 nosync nounwind speculatable willreturn memory(none)
declare i64 @llvm.umax.i64(i64, i64) #4

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

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

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

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

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


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