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

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

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

103:                                              ; preds = %13
  store i32 0, ptr %14, align 4
  store i32 1, ptr %66, align 4
  br label %834

104:                                              ; preds = %13
  store i64 2, ptr %46, align 8, !tbaa !9
  store i64 0, ptr %59, align 8, !tbaa !9
  store i64 0, ptr %65, align 8, !tbaa !9
  %105 = load ptr, ptr %18, align 8, !tbaa !5
  %106 = load ptr, ptr %26, align 8, !tbaa !5
  %107 = load i64, ptr %106, align 8, !tbaa !9
  %108 = load ptr, ptr %26, align 8, !tbaa !5
  %109 = load i64, ptr %108, align 8, !tbaa !9
  %110 = load i64, ptr %28, align 8, !tbaa !9
  %111 = mul nsw i64 %109, %110
  %112 = add nsw i64 %107, %111
  %113 = getelementptr inbounds %struct.complex, ptr %105, i64 %112
  %114 = load ptr, ptr %19, align 8, !tbaa !5
  %115 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %116 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %113, ptr noundef %114, ptr noundef %115, ptr noundef @c__2)
  %117 = load ptr, ptr %20, align 8, !tbaa !5
  %118 = load ptr, ptr %26, align 8, !tbaa !5
  %119 = load i64, ptr %118, align 8, !tbaa !9
  %120 = load ptr, ptr %26, align 8, !tbaa !5
  %121 = load i64, ptr %120, align 8, !tbaa !9
  %122 = load i64, ptr %30, align 8, !tbaa !9
  %123 = mul nsw i64 %121, %122
  %124 = add nsw i64 %119, %123
  %125 = getelementptr inbounds %struct.complex, ptr %117, i64 %124
  %126 = load ptr, ptr %21, align 8, !tbaa !5
  %127 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %128 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %125, ptr noundef %126, ptr noundef %127, ptr noundef @c__2)
  %129 = call double @slamch_(ptr noundef @.str.1)
  %130 = fptrunc double %129 to float
  store float %130, ptr %57, align 4, !tbaa !11
  %131 = call double @slamch_(ptr noundef @.str.2)
  %132 = load float, ptr %57, align 4, !tbaa !11
  %133 = fpext float %132 to double
  %134 = fdiv double %131, %133
  %135 = fptrunc double %134 to float
  store float %135, ptr %64, align 4, !tbaa !11
  store float 0.000000e+00, ptr %62, align 4, !tbaa !11
  store float 1.000000e+00, ptr %58, align 4, !tbaa !11
  %136 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %137 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %138 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %136, ptr noundef @c__2, ptr noundef %137, ptr noundef %46)
  %139 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %140 = load i64, ptr %46, align 8, !tbaa !9
  %141 = load i64, ptr %46, align 8, !tbaa !9
  %142 = mul nsw i64 %140, %141
  %143 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %142
  %144 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %139, ptr noundef @c__2, ptr noundef %143, ptr noundef %46)
  %145 = load i64, ptr %46, align 8, !tbaa !9
  %146 = shl i64 %145, 1
  %147 = load i64, ptr %46, align 8, !tbaa !9
  %148 = mul nsw i64 %146, %147
  store i64 %148, ptr %36, align 8, !tbaa !9
  %149 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %150 = call i32 @classq_(ptr noundef %36, ptr noundef %149, ptr noundef @c__1, ptr noundef %62, ptr noundef %58)
  %151 = load float, ptr %62, align 4, !tbaa !11
  %152 = fpext float %151 to double
  %153 = load float, ptr %58, align 4, !tbaa !11
  %154 = fpext float %153 to double
  %155 = call double @sqrt(double noundef %154) #5
  %156 = fmul double %152, %155
  %157 = fptrunc double %156 to float
  store float %157, ptr %50, align 4, !tbaa !11
  %158 = load float, ptr %57, align 4, !tbaa !11
  %159 = fmul float %158, 1.000000e+01
  %160 = load float, ptr %50, align 4, !tbaa !11
  %161 = fmul float %159, %160
  store float %161, ptr %39, align 4, !tbaa !11
  %162 = load float, ptr %39, align 4, !tbaa !11
  %163 = load float, ptr %64, align 4, !tbaa !11
  %164 = fcmp oge float %162, %163
  br i1 %164, label %165, label %167

165:                                              ; preds = %104
  %166 = load float, ptr %39, align 4, !tbaa !11
  br label %169

167:                                              ; preds = %104
  %168 = load float, ptr %64, align 4, !tbaa !11
  br label %169

169:                                              ; preds = %167, %165
  %170 = phi float [ %166, %165 ], [ %168, %167 ]
  %171 = fpext float %170 to double
  %172 = fptrunc double %171 to float
  store float %172, ptr %63, align 4, !tbaa !11
  %173 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %174 = getelementptr inbounds %struct.complex, ptr %173, i32 0, i32 0
  %175 = load float, ptr %174, align 8, !tbaa !13
  %176 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %177 = getelementptr inbounds %struct.complex, ptr %176, i32 0, i32 0
  %178 = load float, ptr %177, align 16, !tbaa !13
  %179 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %180 = getelementptr inbounds %struct.complex, ptr %179, i32 0, i32 1
  %181 = load float, ptr %180, align 4, !tbaa !15
  %182 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %183 = getelementptr inbounds %struct.complex, ptr %182, i32 0, i32 1
  %184 = load float, ptr %183, align 4, !tbaa !15
  %185 = fmul float %181, %184
  %186 = fneg float %185
  %187 = call float @llvm.fmuladd.f32(float %175, float %178, float %186)
  %188 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %187, ptr %188, align 4, !tbaa !13
  %189 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %190 = getelementptr inbounds %struct.complex, ptr %189, i32 0, i32 0
  %191 = load float, ptr %190, align 8, !tbaa !13
  %192 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %193 = getelementptr inbounds %struct.complex, ptr %192, i32 0, i32 1
  %194 = load float, ptr %193, align 4, !tbaa !15
  %195 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %196 = getelementptr inbounds %struct.complex, ptr %195, i32 0, i32 1
  %197 = load float, ptr %196, align 4, !tbaa !15
  %198 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %199 = getelementptr inbounds %struct.complex, ptr %198, i32 0, i32 0
  %200 = load float, ptr %199, align 16, !tbaa !13
  %201 = fmul float %197, %200
  %202 = call float @llvm.fmuladd.f32(float %191, float %194, float %201)
  %203 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %202, ptr %203, align 4, !tbaa !15
  %204 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %205 = getelementptr inbounds %struct.complex, ptr %204, i32 0, i32 0
  %206 = load float, ptr %205, align 8, !tbaa !13
  %207 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %208 = getelementptr inbounds %struct.complex, ptr %207, i32 0, i32 0
  %209 = load float, ptr %208, align 16, !tbaa !13
  %210 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %211 = getelementptr inbounds %struct.complex, ptr %210, i32 0, i32 1
  %212 = load float, ptr %211, align 4, !tbaa !15
  %213 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %214 = getelementptr inbounds %struct.complex, ptr %213, i32 0, i32 1
  %215 = load float, ptr %214, align 4, !tbaa !15
  %216 = fmul float %212, %215
  %217 = fneg float %216
  %218 = call float @llvm.fmuladd.f32(float %206, float %209, float %217)
  %219 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %218, ptr %219, align 4, !tbaa !13
  %220 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %221 = getelementptr inbounds %struct.complex, ptr %220, i32 0, i32 0
  %222 = load float, ptr %221, align 8, !tbaa !13
  %223 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %224 = getelementptr inbounds %struct.complex, ptr %223, i32 0, i32 1
  %225 = load float, ptr %224, align 4, !tbaa !15
  %226 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %227 = getelementptr inbounds %struct.complex, ptr %226, i32 0, i32 1
  %228 = load float, ptr %227, align 4, !tbaa !15
  %229 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %230 = getelementptr inbounds %struct.complex, ptr %229, i32 0, i32 0
  %231 = load float, ptr %230, align 16, !tbaa !13
  %232 = fmul float %228, %231
  %233 = call float @llvm.fmuladd.f32(float %222, float %225, float %232)
  %234 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %233, ptr %234, align 4, !tbaa !15
  %235 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %236 = load float, ptr %235, align 4, !tbaa !13
  %237 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %238 = load float, ptr %237, align 4, !tbaa !13
  %239 = fsub float %236, %238
  %240 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %239, ptr %240, align 4, !tbaa !13
  %241 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %242 = load float, ptr %241, align 4, !tbaa !15
  %243 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %244 = load float, ptr %243, align 4, !tbaa !15
  %245 = fsub float %242, %244
  %246 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %245, ptr %246, align 4, !tbaa !15
  %247 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %248 = load float, ptr %247, align 4, !tbaa !13
  %249 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 0
  store float %248, ptr %249, align 4, !tbaa !13
  %250 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %251 = load float, ptr %250, align 4, !tbaa !15
  %252 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 1
  store float %251, ptr %252, align 4, !tbaa !15
  %253 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %254 = getelementptr inbounds %struct.complex, ptr %253, i32 0, i32 0
  %255 = load float, ptr %254, align 8, !tbaa !13
  %256 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 2
  %257 = getelementptr inbounds %struct.complex, ptr %256, i32 0, i32 0
  %258 = load float, ptr %257, align 16, !tbaa !13
  %259 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %260 = getelementptr inbounds %struct.complex, ptr %259, i32 0, i32 1
  %261 = load float, ptr %260, align 4, !tbaa !15
  %262 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 2
  %263 = getelementptr inbounds %struct.complex, ptr %262, i32 0, i32 1
  %264 = load float, ptr %263, align 4, !tbaa !15
  %265 = fmul float %261, %264
  %266 = fneg float %265
  %267 = call float @llvm.fmuladd.f32(float %255, float %258, float %266)
  %268 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %267, ptr %268, align 4, !tbaa !13
  %269 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %270 = getelementptr inbounds %struct.complex, ptr %269, i32 0, i32 0
  %271 = load float, ptr %270, align 8, !tbaa !13
  %272 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 2
  %273 = getelementptr inbounds %struct.complex, ptr %272, i32 0, i32 1
  %274 = load float, ptr %273, align 4, !tbaa !15
  %275 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %276 = getelementptr inbounds %struct.complex, ptr %275, i32 0, i32 1
  %277 = load float, ptr %276, align 4, !tbaa !15
  %278 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 2
  %279 = getelementptr inbounds %struct.complex, ptr %278, i32 0, i32 0
  %280 = load float, ptr %279, align 16, !tbaa !13
  %281 = fmul float %277, %280
  %282 = call float @llvm.fmuladd.f32(float %271, float %274, float %281)
  %283 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %282, ptr %283, align 4, !tbaa !15
  %284 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %285 = getelementptr inbounds %struct.complex, ptr %284, i32 0, i32 0
  %286 = load float, ptr %285, align 8, !tbaa !13
  %287 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 2
  %288 = getelementptr inbounds %struct.complex, ptr %287, i32 0, i32 0
  %289 = load float, ptr %288, align 16, !tbaa !13
  %290 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %291 = getelementptr inbounds %struct.complex, ptr %290, i32 0, i32 1
  %292 = load float, ptr %291, align 4, !tbaa !15
  %293 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 2
  %294 = getelementptr inbounds %struct.complex, ptr %293, i32 0, i32 1
  %295 = load float, ptr %294, align 4, !tbaa !15
  %296 = fmul float %292, %295
  %297 = fneg float %296
  %298 = call float @llvm.fmuladd.f32(float %286, float %289, float %297)
  %299 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %298, ptr %299, align 4, !tbaa !13
  %300 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %301 = getelementptr inbounds %struct.complex, ptr %300, i32 0, i32 0
  %302 = load float, ptr %301, align 8, !tbaa !13
  %303 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 2
  %304 = getelementptr inbounds %struct.complex, ptr %303, i32 0, i32 1
  %305 = load float, ptr %304, align 4, !tbaa !15
  %306 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %307 = getelementptr inbounds %struct.complex, ptr %306, i32 0, i32 1
  %308 = load float, ptr %307, align 4, !tbaa !15
  %309 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 2
  %310 = getelementptr inbounds %struct.complex, ptr %309, i32 0, i32 0
  %311 = load float, ptr %310, align 16, !tbaa !13
  %312 = fmul float %308, %311
  %313 = call float @llvm.fmuladd.f32(float %302, float %305, float %312)
  %314 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %313, ptr %314, align 4, !tbaa !15
  %315 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %316 = load float, ptr %315, align 4, !tbaa !13
  %317 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %318 = load float, ptr %317, align 4, !tbaa !13
  %319 = fsub float %316, %318
  %320 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %319, ptr %320, align 4, !tbaa !13
  %321 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %322 = load float, ptr %321, align 4, !tbaa !15
  %323 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %324 = load float, ptr %323, align 4, !tbaa !15
  %325 = fsub float %322, %324
  %326 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %325, ptr %326, align 4, !tbaa !15
  %327 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %328 = load float, ptr %327, align 4, !tbaa !13
  %329 = getelementptr inbounds %struct.complex, ptr %44, i32 0, i32 0
  store float %328, ptr %329, align 4, !tbaa !13
  %330 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %331 = load float, ptr %330, align 4, !tbaa !15
  %332 = getelementptr inbounds %struct.complex, ptr %44, i32 0, i32 1
  store float %331, ptr %332, align 4, !tbaa !15
  %333 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 3
  %334 = call double @c_abs(ptr noundef %333)
  %335 = fptrunc double %334 to float
  store float %335, ptr %50, align 4, !tbaa !11
  %336 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 3
  %337 = call double @c_abs(ptr noundef %336)
  %338 = fptrunc double %337 to float
  store float %338, ptr %51, align 4, !tbaa !11
  %339 = call i32 @clartg_(ptr noundef %44, ptr noundef %43, ptr noundef %52, ptr noundef %56, ptr noundef %60)
  %340 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  %341 = load float, ptr %340, align 4, !tbaa !13
  %342 = fneg float %341
  %343 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %342, ptr %343, align 4, !tbaa !13
  %344 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  %345 = load float, ptr %344, align 4, !tbaa !15
  %346 = fneg float %345
  %347 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %346, ptr %347, align 4, !tbaa !15
  %348 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %349 = load float, ptr %348, align 4, !tbaa !13
  %350 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 0
  store float %349, ptr %350, align 4, !tbaa !13
  %351 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %352 = load float, ptr %351, align 4, !tbaa !15
  %353 = getelementptr inbounds %struct.complex, ptr %56, i32 0, i32 1
  store float %352, ptr %353, align 4, !tbaa !15
  call void @r_cnjg(ptr noundef %40, ptr noundef %56)
  %354 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %355 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 2
  %356 = call i32 @crot_(ptr noundef @c__2, ptr noundef %354, ptr noundef @c__1, ptr noundef %355, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  call void @r_cnjg(ptr noundef %40, ptr noundef %56)
  %357 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %358 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 2
  %359 = call i32 @crot_(ptr noundef @c__2, ptr noundef %357, ptr noundef @c__1, ptr noundef %358, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  %360 = load float, ptr %50, align 4, !tbaa !11
  %361 = load float, ptr %51, align 4, !tbaa !11
  %362 = fcmp oge float %360, %361
  br i1 %362, label %363, label %367

363:                                              ; preds = %169
  %364 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %365 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 1
  %366 = call i32 @clartg_(ptr noundef %364, ptr noundef %365, ptr noundef %49, ptr noundef %53, ptr noundef %60)
  br label %371

367:                                              ; preds = %169
  %368 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %369 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 1
  %370 = call i32 @clartg_(ptr noundef %368, ptr noundef %369, ptr noundef %49, ptr noundef %53, ptr noundef %60)
  br label %371

371:                                              ; preds = %367, %363
  %372 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %373 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 1
  %374 = call i32 @crot_(ptr noundef @c__2, ptr noundef %372, ptr noundef @c__2, ptr noundef %373, ptr noundef @c__2, ptr noundef %49, ptr noundef %53)
  %375 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %376 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 1
  %377 = call i32 @crot_(ptr noundef @c__2, ptr noundef %375, ptr noundef @c__2, ptr noundef %376, ptr noundef @c__2, ptr noundef %49, ptr noundef %53)
  %378 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 1
  %379 = call double @c_abs(ptr noundef %378)
  %380 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 1
  %381 = call double @c_abs(ptr noundef %380)
  %382 = fadd double %379, %381
  %383 = fptrunc double %382 to float
  store float %383, ptr %55, align 4, !tbaa !11
  %384 = load float, ptr %55, align 4, !tbaa !11
  %385 = load float, ptr %63, align 4, !tbaa !11
  %386 = fcmp ole float %384, %385
  %387 = zext i1 %386 to i32
  %388 = sext i32 %387 to i64
  store i64 %388, ptr %59, align 8, !tbaa !9
  %389 = load i64, ptr %59, align 8, !tbaa !9
  %390 = icmp ne i64 %389, 0
  br i1 %390, label %392, label %391

391:                                              ; preds = %371
  br label %832

392:                                              ; preds = %371
  %393 = getelementptr inbounds [4 x %struct.complex], ptr %47, i64 0, i64 0
  %394 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %395 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %393, ptr noundef @c__2, ptr noundef %394, ptr noundef %46)
  %396 = getelementptr inbounds [4 x %struct.complex], ptr %48, i64 0, i64 0
  %397 = load i64, ptr %46, align 8, !tbaa !9
  %398 = load i64, ptr %46, align 8, !tbaa !9
  %399 = mul nsw i64 %397, %398
  %400 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %399
  %401 = call i32 @clacpy_(ptr noundef @.str, ptr noundef %46, ptr noundef %46, ptr noundef %396, ptr noundef @c__2, ptr noundef %400, ptr noundef %46)
  call void @r_cnjg(ptr noundef %41, ptr noundef %56)
  %402 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %403 = load float, ptr %402, align 4, !tbaa !13
  %404 = fneg float %403
  %405 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %404, ptr %405, align 4, !tbaa !13
  %406 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %407 = load float, ptr %406, align 4, !tbaa !15
  %408 = fneg float %407
  %409 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %408, ptr %409, align 4, !tbaa !15
  %410 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %411 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 2
  %412 = call i32 @crot_(ptr noundef @c__2, ptr noundef %410, ptr noundef @c__1, ptr noundef %411, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  call void @r_cnjg(ptr noundef %41, ptr noundef %56)
  %413 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %414 = load float, ptr %413, align 4, !tbaa !13
  %415 = fneg float %414
  %416 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %415, ptr %416, align 4, !tbaa !13
  %417 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %418 = load float, ptr %417, align 4, !tbaa !15
  %419 = fneg float %418
  %420 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %419, ptr %420, align 4, !tbaa !15
  %421 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 4
  %422 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 6
  %423 = call i32 @crot_(ptr noundef @c__2, ptr noundef %421, ptr noundef @c__1, ptr noundef %422, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  %424 = getelementptr inbounds %struct.complex, ptr %53, i32 0, i32 0
  %425 = load float, ptr %424, align 4, !tbaa !13
  %426 = fneg float %425
  %427 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %426, ptr %427, align 4, !tbaa !13
  %428 = getelementptr inbounds %struct.complex, ptr %53, i32 0, i32 1
  %429 = load float, ptr %428, align 4, !tbaa !15
  %430 = fneg float %429
  %431 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %430, ptr %431, align 4, !tbaa !15
  %432 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %433 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 1
  %434 = call i32 @crot_(ptr noundef @c__2, ptr noundef %432, ptr noundef @c__2, ptr noundef %433, ptr noundef @c__2, ptr noundef %49, ptr noundef %40)
  %435 = getelementptr inbounds %struct.complex, ptr %53, i32 0, i32 0
  %436 = load float, ptr %435, align 4, !tbaa !13
  %437 = fneg float %436
  %438 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %437, ptr %438, align 4, !tbaa !13
  %439 = getelementptr inbounds %struct.complex, ptr %53, i32 0, i32 1
  %440 = load float, ptr %439, align 4, !tbaa !15
  %441 = fneg float %440
  %442 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %441, ptr %442, align 4, !tbaa !15
  %443 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 4
  %444 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 5
  %445 = call i32 @crot_(ptr noundef @c__2, ptr noundef %443, ptr noundef @c__2, ptr noundef %444, ptr noundef @c__2, ptr noundef %49, ptr noundef %40)
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %446

446:                                              ; preds = %636, %392
  %447 = load i64, ptr %45, align 8, !tbaa !9
  %448 = icmp sle i64 %447, 2
  br i1 %448, label %449, label %639

449:                                              ; preds = %446
  %450 = load i64, ptr %45, align 8, !tbaa !9
  %451 = sub nsw i64 %450, 1
  store i64 %451, ptr %36, align 8, !tbaa !9
  %452 = load i64, ptr %45, align 8, !tbaa !9
  %453 = sub nsw i64 %452, 1
  store i64 %453, ptr %37, align 8, !tbaa !9
  %454 = load ptr, ptr %26, align 8, !tbaa !5
  %455 = load i64, ptr %454, align 8, !tbaa !9
  %456 = load i64, ptr %45, align 8, !tbaa !9
  %457 = add nsw i64 %455, %456
  %458 = sub nsw i64 %457, 1
  %459 = load ptr, ptr %26, align 8, !tbaa !5
  %460 = load i64, ptr %459, align 8, !tbaa !9
  %461 = load i64, ptr %28, align 8, !tbaa !9
  %462 = mul nsw i64 %460, %461
  %463 = add nsw i64 %458, %462
  store i64 %463, ptr %38, align 8, !tbaa !9
  %464 = load i64, ptr %37, align 8, !tbaa !9
  %465 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %464
  %466 = getelementptr inbounds %struct.complex, ptr %465, i32 0, i32 0
  %467 = load float, ptr %466, align 8, !tbaa !13
  %468 = load ptr, ptr %18, align 8, !tbaa !5
  %469 = load i64, ptr %38, align 8, !tbaa !9
  %470 = getelementptr inbounds %struct.complex, ptr %468, i64 %469
  %471 = getelementptr inbounds %struct.complex, ptr %470, i32 0, i32 0
  %472 = load float, ptr %471, align 4, !tbaa !13
  %473 = fsub float %467, %472
  %474 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %473, ptr %474, align 4, !tbaa !13
  %475 = load i64, ptr %37, align 8, !tbaa !9
  %476 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %475
  %477 = getelementptr inbounds %struct.complex, ptr %476, i32 0, i32 1
  %478 = load float, ptr %477, align 4, !tbaa !15
  %479 = load ptr, ptr %18, align 8, !tbaa !5
  %480 = load i64, ptr %38, align 8, !tbaa !9
  %481 = getelementptr inbounds %struct.complex, ptr %479, i64 %480
  %482 = getelementptr inbounds %struct.complex, ptr %481, i32 0, i32 1
  %483 = load float, ptr %482, align 4, !tbaa !15
  %484 = fsub float %478, %483
  %485 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %484, ptr %485, align 4, !tbaa !15
  %486 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %487 = load float, ptr %486, align 4, !tbaa !13
  %488 = load i64, ptr %36, align 8, !tbaa !9
  %489 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %488
  %490 = getelementptr inbounds %struct.complex, ptr %489, i32 0, i32 0
  store float %487, ptr %490, align 8, !tbaa !13
  %491 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %492 = load float, ptr %491, align 4, !tbaa !15
  %493 = load i64, ptr %36, align 8, !tbaa !9
  %494 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %493
  %495 = getelementptr inbounds %struct.complex, ptr %494, i32 0, i32 1
  store float %492, ptr %495, align 4, !tbaa !15
  %496 = load i64, ptr %45, align 8, !tbaa !9
  %497 = add nsw i64 %496, 1
  store i64 %497, ptr %36, align 8, !tbaa !9
  %498 = load i64, ptr %45, align 8, !tbaa !9
  %499 = add nsw i64 %498, 1
  store i64 %499, ptr %37, align 8, !tbaa !9
  %500 = load ptr, ptr %26, align 8, !tbaa !5
  %501 = load i64, ptr %500, align 8, !tbaa !9
  %502 = load i64, ptr %45, align 8, !tbaa !9
  %503 = add nsw i64 %501, %502
  %504 = sub nsw i64 %503, 1
  %505 = load ptr, ptr %26, align 8, !tbaa !5
  %506 = load i64, ptr %505, align 8, !tbaa !9
  %507 = add nsw i64 %506, 1
  %508 = load i64, ptr %28, align 8, !tbaa !9
  %509 = mul nsw i64 %507, %508
  %510 = add nsw i64 %504, %509
  store i64 %510, ptr %38, align 8, !tbaa !9
  %511 = load i64, ptr %37, align 8, !tbaa !9
  %512 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %511
  %513 = getelementptr inbounds %struct.complex, ptr %512, i32 0, i32 0
  %514 = load float, ptr %513, align 8, !tbaa !13
  %515 = load ptr, ptr %18, align 8, !tbaa !5
  %516 = load i64, ptr %38, align 8, !tbaa !9
  %517 = getelementptr inbounds %struct.complex, ptr %515, i64 %516
  %518 = getelementptr inbounds %struct.complex, ptr %517, i32 0, i32 0
  %519 = load float, ptr %518, align 4, !tbaa !13
  %520 = fsub float %514, %519
  %521 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %520, ptr %521, align 4, !tbaa !13
  %522 = load i64, ptr %37, align 8, !tbaa !9
  %523 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %522
  %524 = getelementptr inbounds %struct.complex, ptr %523, i32 0, i32 1
  %525 = load float, ptr %524, align 4, !tbaa !15
  %526 = load ptr, ptr %18, align 8, !tbaa !5
  %527 = load i64, ptr %38, align 8, !tbaa !9
  %528 = getelementptr inbounds %struct.complex, ptr %526, i64 %527
  %529 = getelementptr inbounds %struct.complex, ptr %528, i32 0, i32 1
  %530 = load float, ptr %529, align 4, !tbaa !15
  %531 = fsub float %525, %530
  %532 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %531, ptr %532, align 4, !tbaa !15
  %533 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %534 = load float, ptr %533, align 4, !tbaa !13
  %535 = load i64, ptr %36, align 8, !tbaa !9
  %536 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %535
  %537 = getelementptr inbounds %struct.complex, ptr %536, i32 0, i32 0
  store float %534, ptr %537, align 8, !tbaa !13
  %538 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %539 = load float, ptr %538, align 4, !tbaa !15
  %540 = load i64, ptr %36, align 8, !tbaa !9
  %541 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %540
  %542 = getelementptr inbounds %struct.complex, ptr %541, i32 0, i32 1
  store float %539, ptr %542, align 4, !tbaa !15
  %543 = load i64, ptr %45, align 8, !tbaa !9
  %544 = add nsw i64 %543, 3
  store i64 %544, ptr %36, align 8, !tbaa !9
  %545 = load i64, ptr %45, align 8, !tbaa !9
  %546 = add nsw i64 %545, 3
  store i64 %546, ptr %37, align 8, !tbaa !9
  %547 = load ptr, ptr %26, align 8, !tbaa !5
  %548 = load i64, ptr %547, align 8, !tbaa !9
  %549 = load i64, ptr %45, align 8, !tbaa !9
  %550 = add nsw i64 %548, %549
  %551 = sub nsw i64 %550, 1
  %552 = load ptr, ptr %26, align 8, !tbaa !5
  %553 = load i64, ptr %552, align 8, !tbaa !9
  %554 = load i64, ptr %30, align 8, !tbaa !9
  %555 = mul nsw i64 %553, %554
  %556 = add nsw i64 %551, %555
  store i64 %556, ptr %38, align 8, !tbaa !9
  %557 = load i64, ptr %37, align 8, !tbaa !9
  %558 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %557
  %559 = getelementptr inbounds %struct.complex, ptr %558, i32 0, i32 0
  %560 = load float, ptr %559, align 8, !tbaa !13
  %561 = load ptr, ptr %20, align 8, !tbaa !5
  %562 = load i64, ptr %38, align 8, !tbaa !9
  %563 = getelementptr inbounds %struct.complex, ptr %561, i64 %562
  %564 = getelementptr inbounds %struct.complex, ptr %563, i32 0, i32 0
  %565 = load float, ptr %564, align 4, !tbaa !13
  %566 = fsub float %560, %565
  %567 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %566, ptr %567, align 4, !tbaa !13
  %568 = load i64, ptr %37, align 8, !tbaa !9
  %569 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %568
  %570 = getelementptr inbounds %struct.complex, ptr %569, i32 0, i32 1
  %571 = load float, ptr %570, align 4, !tbaa !15
  %572 = load ptr, ptr %20, align 8, !tbaa !5
  %573 = load i64, ptr %38, align 8, !tbaa !9
  %574 = getelementptr inbounds %struct.complex, ptr %572, i64 %573
  %575 = getelementptr inbounds %struct.complex, ptr %574, i32 0, i32 1
  %576 = load float, ptr %575, align 4, !tbaa !15
  %577 = fsub float %571, %576
  %578 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %577, ptr %578, align 4, !tbaa !15
  %579 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %580 = load float, ptr %579, align 4, !tbaa !13
  %581 = load i64, ptr %36, align 8, !tbaa !9
  %582 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %581
  %583 = getelementptr inbounds %struct.complex, ptr %582, i32 0, i32 0
  store float %580, ptr %583, align 8, !tbaa !13
  %584 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %585 = load float, ptr %584, align 4, !tbaa !15
  %586 = load i64, ptr %36, align 8, !tbaa !9
  %587 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %586
  %588 = getelementptr inbounds %struct.complex, ptr %587, i32 0, i32 1
  store float %585, ptr %588, align 4, !tbaa !15
  %589 = load i64, ptr %45, align 8, !tbaa !9
  %590 = add nsw i64 %589, 5
  store i64 %590, ptr %36, align 8, !tbaa !9
  %591 = load i64, ptr %45, align 8, !tbaa !9
  %592 = add nsw i64 %591, 5
  store i64 %592, ptr %37, align 8, !tbaa !9
  %593 = load ptr, ptr %26, align 8, !tbaa !5
  %594 = load i64, ptr %593, align 8, !tbaa !9
  %595 = load i64, ptr %45, align 8, !tbaa !9
  %596 = add nsw i64 %594, %595
  %597 = sub nsw i64 %596, 1
  %598 = load ptr, ptr %26, align 8, !tbaa !5
  %599 = load i64, ptr %598, align 8, !tbaa !9
  %600 = add nsw i64 %599, 1
  %601 = load i64, ptr %30, align 8, !tbaa !9
  %602 = mul nsw i64 %600, %601
  %603 = add nsw i64 %597, %602
  store i64 %603, ptr %38, align 8, !tbaa !9
  %604 = load i64, ptr %37, align 8, !tbaa !9
  %605 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %604
  %606 = getelementptr inbounds %struct.complex, ptr %605, i32 0, i32 0
  %607 = load float, ptr %606, align 8, !tbaa !13
  %608 = load ptr, ptr %20, align 8, !tbaa !5
  %609 = load i64, ptr %38, align 8, !tbaa !9
  %610 = getelementptr inbounds %struct.complex, ptr %608, i64 %609
  %611 = getelementptr inbounds %struct.complex, ptr %610, i32 0, i32 0
  %612 = load float, ptr %611, align 4, !tbaa !13
  %613 = fsub float %607, %612
  %614 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %613, ptr %614, align 4, !tbaa !13
  %615 = load i64, ptr %37, align 8, !tbaa !9
  %616 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %615
  %617 = getelementptr inbounds %struct.complex, ptr %616, i32 0, i32 1
  %618 = load float, ptr %617, align 4, !tbaa !15
  %619 = load ptr, ptr %20, align 8, !tbaa !5
  %620 = load i64, ptr %38, align 8, !tbaa !9
  %621 = getelementptr inbounds %struct.complex, ptr %619, i64 %620
  %622 = getelementptr inbounds %struct.complex, ptr %621, i32 0, i32 1
  %623 = load float, ptr %622, align 4, !tbaa !15
  %624 = fsub float %618, %623
  %625 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %624, ptr %625, align 4, !tbaa !15
  %626 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %627 = load float, ptr %626, align 4, !tbaa !13
  %628 = load i64, ptr %36, align 8, !tbaa !9
  %629 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %628
  %630 = getelementptr inbounds %struct.complex, ptr %629, i32 0, i32 0
  store float %627, ptr %630, align 8, !tbaa !13
  %631 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %632 = load float, ptr %631, align 4, !tbaa !15
  %633 = load i64, ptr %36, align 8, !tbaa !9
  %634 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 %633
  %635 = getelementptr inbounds %struct.complex, ptr %634, i32 0, i32 1
  store float %632, ptr %635, align 4, !tbaa !15
  br label %636

636:                                              ; preds = %449
  %637 = load i64, ptr %45, align 8, !tbaa !9
  %638 = add nsw i64 %637, 1
  store i64 %638, ptr %45, align 8, !tbaa !9
  br label %446, !llvm.loop !16

639:                                              ; preds = %446
  store float 0.000000e+00, ptr %62, align 4, !tbaa !11
  store float 1.000000e+00, ptr %58, align 4, !tbaa !11
  %640 = load i64, ptr %46, align 8, !tbaa !9
  %641 = shl i64 %640, 1
  %642 = load i64, ptr %46, align 8, !tbaa !9
  %643 = mul nsw i64 %641, %642
  store i64 %643, ptr %36, align 8, !tbaa !9
  %644 = getelementptr inbounds [8 x %struct.complex], ptr %61, i64 0, i64 0
  %645 = call i32 @classq_(ptr noundef %36, ptr noundef %644, ptr noundef @c__1, ptr noundef %62, ptr noundef %58)
  %646 = load float, ptr %62, align 4, !tbaa !11
  %647 = fpext float %646 to double
  %648 = load float, ptr %58, align 4, !tbaa !11
  %649 = fpext float %648 to double
  %650 = call double @sqrt(double noundef %649) #5
  %651 = fmul double %647, %650
  %652 = fptrunc double %651 to float
  store float %652, ptr %54, align 4, !tbaa !11
  %653 = load float, ptr %54, align 4, !tbaa !11
  %654 = load float, ptr %63, align 4, !tbaa !11
  %655 = fcmp ole float %653, %654
  %656 = zext i1 %655 to i32
  %657 = sext i32 %656 to i64
  store i64 %657, ptr %65, align 8, !tbaa !9
  %658 = load i64, ptr %65, align 8, !tbaa !9
  %659 = icmp ne i64 %658, 0
  br i1 %659, label %661, label %660

660:                                              ; preds = %639
  br label %832

661:                                              ; preds = %639
  %662 = load ptr, ptr %26, align 8, !tbaa !5
  %663 = load i64, ptr %662, align 8, !tbaa !9
  %664 = add nsw i64 %663, 1
  store i64 %664, ptr %36, align 8, !tbaa !9
  call void @r_cnjg(ptr noundef %40, ptr noundef %56)
  %665 = load ptr, ptr %18, align 8, !tbaa !5
  %666 = load ptr, ptr %26, align 8, !tbaa !5
  %667 = load i64, ptr %666, align 8, !tbaa !9
  %668 = load i64, ptr %28, align 8, !tbaa !9
  %669 = mul nsw i64 %667, %668
  %670 = add nsw i64 %669, 1
  %671 = getelementptr inbounds %struct.complex, ptr %665, i64 %670
  %672 = load ptr, ptr %18, align 8, !tbaa !5
  %673 = load ptr, ptr %26, align 8, !tbaa !5
  %674 = load i64, ptr %673, align 8, !tbaa !9
  %675 = add nsw i64 %674, 1
  %676 = load i64, ptr %28, align 8, !tbaa !9
  %677 = mul nsw i64 %675, %676
  %678 = add nsw i64 %677, 1
  %679 = getelementptr inbounds %struct.complex, ptr %672, i64 %678
  %680 = call i32 @crot_(ptr noundef %36, ptr noundef %671, ptr noundef @c__1, ptr noundef %679, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  %681 = load ptr, ptr %26, align 8, !tbaa !5
  %682 = load i64, ptr %681, align 8, !tbaa !9
  %683 = add nsw i64 %682, 1
  store i64 %683, ptr %36, align 8, !tbaa !9
  call void @r_cnjg(ptr noundef %40, ptr noundef %56)
  %684 = load ptr, ptr %20, align 8, !tbaa !5
  %685 = load ptr, ptr %26, align 8, !tbaa !5
  %686 = load i64, ptr %685, align 8, !tbaa !9
  %687 = load i64, ptr %30, align 8, !tbaa !9
  %688 = mul nsw i64 %686, %687
  %689 = add nsw i64 %688, 1
  %690 = getelementptr inbounds %struct.complex, ptr %684, i64 %689
  %691 = load ptr, ptr %20, align 8, !tbaa !5
  %692 = load ptr, ptr %26, align 8, !tbaa !5
  %693 = load i64, ptr %692, align 8, !tbaa !9
  %694 = add nsw i64 %693, 1
  %695 = load i64, ptr %30, align 8, !tbaa !9
  %696 = mul nsw i64 %694, %695
  %697 = add nsw i64 %696, 1
  %698 = getelementptr inbounds %struct.complex, ptr %691, i64 %697
  %699 = call i32 @crot_(ptr noundef %36, ptr noundef %690, ptr noundef @c__1, ptr noundef %698, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  %700 = load ptr, ptr %17, align 8, !tbaa !5
  %701 = load i64, ptr %700, align 8, !tbaa !9
  %702 = load ptr, ptr %26, align 8, !tbaa !5
  %703 = load i64, ptr %702, align 8, !tbaa !9
  %704 = sub nsw i64 %701, %703
  %705 = add nsw i64 %704, 1
  store i64 %705, ptr %36, align 8, !tbaa !9
  %706 = load ptr, ptr %18, align 8, !tbaa !5
  %707 = load ptr, ptr %26, align 8, !tbaa !5
  %708 = load i64, ptr %707, align 8, !tbaa !9
  %709 = load ptr, ptr %26, align 8, !tbaa !5
  %710 = load i64, ptr %709, align 8, !tbaa !9
  %711 = load i64, ptr %28, align 8, !tbaa !9
  %712 = mul nsw i64 %710, %711
  %713 = add nsw i64 %708, %712
  %714 = getelementptr inbounds %struct.complex, ptr %706, i64 %713
  %715 = load ptr, ptr %19, align 8, !tbaa !5
  %716 = load ptr, ptr %18, align 8, !tbaa !5
  %717 = load ptr, ptr %26, align 8, !tbaa !5
  %718 = load i64, ptr %717, align 8, !tbaa !9
  %719 = add nsw i64 %718, 1
  %720 = load ptr, ptr %26, align 8, !tbaa !5
  %721 = load i64, ptr %720, align 8, !tbaa !9
  %722 = load i64, ptr %28, align 8, !tbaa !9
  %723 = mul nsw i64 %721, %722
  %724 = add nsw i64 %719, %723
  %725 = getelementptr inbounds %struct.complex, ptr %716, i64 %724
  %726 = load ptr, ptr %19, align 8, !tbaa !5
  %727 = call i32 @crot_(ptr noundef %36, ptr noundef %714, ptr noundef %715, ptr noundef %725, ptr noundef %726, ptr noundef %49, ptr noundef %53)
  %728 = load ptr, ptr %17, align 8, !tbaa !5
  %729 = load i64, ptr %728, align 8, !tbaa !9
  %730 = load ptr, ptr %26, align 8, !tbaa !5
  %731 = load i64, ptr %730, align 8, !tbaa !9
  %732 = sub nsw i64 %729, %731
  %733 = add nsw i64 %732, 1
  store i64 %733, ptr %36, align 8, !tbaa !9
  %734 = load ptr, ptr %20, align 8, !tbaa !5
  %735 = load ptr, ptr %26, align 8, !tbaa !5
  %736 = load i64, ptr %735, align 8, !tbaa !9
  %737 = load ptr, ptr %26, align 8, !tbaa !5
  %738 = load i64, ptr %737, align 8, !tbaa !9
  %739 = load i64, ptr %30, align 8, !tbaa !9
  %740 = mul nsw i64 %738, %739
  %741 = add nsw i64 %736, %740
  %742 = getelementptr inbounds %struct.complex, ptr %734, i64 %741
  %743 = load ptr, ptr %21, align 8, !tbaa !5
  %744 = load ptr, ptr %20, align 8, !tbaa !5
  %745 = load ptr, ptr %26, align 8, !tbaa !5
  %746 = load i64, ptr %745, align 8, !tbaa !9
  %747 = add nsw i64 %746, 1
  %748 = load ptr, ptr %26, align 8, !tbaa !5
  %749 = load i64, ptr %748, align 8, !tbaa !9
  %750 = load i64, ptr %30, align 8, !tbaa !9
  %751 = mul nsw i64 %749, %750
  %752 = add nsw i64 %747, %751
  %753 = getelementptr inbounds %struct.complex, ptr %744, i64 %752
  %754 = load ptr, ptr %21, align 8, !tbaa !5
  %755 = call i32 @crot_(ptr noundef %36, ptr noundef %742, ptr noundef %743, ptr noundef %753, ptr noundef %754, ptr noundef %49, ptr noundef %53)
  %756 = load ptr, ptr %26, align 8, !tbaa !5
  %757 = load i64, ptr %756, align 8, !tbaa !9
  %758 = add nsw i64 %757, 1
  %759 = load ptr, ptr %26, align 8, !tbaa !5
  %760 = load i64, ptr %759, align 8, !tbaa !9
  %761 = load i64, ptr %28, align 8, !tbaa !9
  %762 = mul nsw i64 %760, %761
  %763 = add nsw i64 %758, %762
  store i64 %763, ptr %36, align 8, !tbaa !9
  %764 = load ptr, ptr %18, align 8, !tbaa !5
  %765 = load i64, ptr %36, align 8, !tbaa !9
  %766 = getelementptr inbounds %struct.complex, ptr %764, i64 %765
  %767 = getelementptr inbounds %struct.complex, ptr %766, i32 0, i32 0
  store float 0.000000e+00, ptr %767, align 4, !tbaa !13
  %768 = load ptr, ptr %18, align 8, !tbaa !5
  %769 = load i64, ptr %36, align 8, !tbaa !9
  %770 = getelementptr inbounds %struct.complex, ptr %768, i64 %769
  %771 = getelementptr inbounds %struct.complex, ptr %770, i32 0, i32 1
  store float 0.000000e+00, ptr %771, align 4, !tbaa !15
  %772 = load ptr, ptr %26, align 8, !tbaa !5
  %773 = load i64, ptr %772, align 8, !tbaa !9
  %774 = add nsw i64 %773, 1
  %775 = load ptr, ptr %26, align 8, !tbaa !5
  %776 = load i64, ptr %775, align 8, !tbaa !9
  %777 = load i64, ptr %30, align 8, !tbaa !9
  %778 = mul nsw i64 %776, %777
  %779 = add nsw i64 %774, %778
  store i64 %779, ptr %36, align 8, !tbaa !9
  %780 = load ptr, ptr %20, align 8, !tbaa !5
  %781 = load i64, ptr %36, align 8, !tbaa !9
  %782 = getelementptr inbounds %struct.complex, ptr %780, i64 %781
  %783 = getelementptr inbounds %struct.complex, ptr %782, i32 0, i32 0
  store float 0.000000e+00, ptr %783, align 4, !tbaa !13
  %784 = load ptr, ptr %20, align 8, !tbaa !5
  %785 = load i64, ptr %36, align 8, !tbaa !9
  %786 = getelementptr inbounds %struct.complex, ptr %784, i64 %785
  %787 = getelementptr inbounds %struct.complex, ptr %786, i32 0, i32 1
  store float 0.000000e+00, ptr %787, align 4, !tbaa !15
  %788 = load ptr, ptr %16, align 8, !tbaa !5
  %789 = load i64, ptr %788, align 8, !tbaa !9
  %790 = icmp ne i64 %789, 0
  br i1 %790, label %791, label %809

791:                                              ; preds = %661
  call void @r_cnjg(ptr noundef %40, ptr noundef %56)
  %792 = load ptr, ptr %17, align 8, !tbaa !5
  %793 = load ptr, ptr %24, align 8, !tbaa !5
  %794 = load ptr, ptr %26, align 8, !tbaa !5
  %795 = load i64, ptr %794, align 8, !tbaa !9
  %796 = load i64, ptr %34, align 8, !tbaa !9
  %797 = mul nsw i64 %795, %796
  %798 = add nsw i64 %797, 1
  %799 = getelementptr inbounds %struct.complex, ptr %793, i64 %798
  %800 = load ptr, ptr %24, align 8, !tbaa !5
  %801 = load ptr, ptr %26, align 8, !tbaa !5
  %802 = load i64, ptr %801, align 8, !tbaa !9
  %803 = add nsw i64 %802, 1
  %804 = load i64, ptr %34, align 8, !tbaa !9
  %805 = mul nsw i64 %803, %804
  %806 = add nsw i64 %805, 1
  %807 = getelementptr inbounds %struct.complex, ptr %800, i64 %806
  %808 = call i32 @crot_(ptr noundef %792, ptr noundef %799, ptr noundef @c__1, ptr noundef %807, ptr noundef @c__1, ptr noundef %52, ptr noundef %40)
  br label %809

809:                                              ; preds = %791, %661
  %810 = load ptr, ptr %15, align 8, !tbaa !5
  %811 = load i64, ptr %810, align 8, !tbaa !9
  %812 = icmp ne i64 %811, 0
  br i1 %812, label %813, label %831

813:                                              ; preds = %809
  call void @r_cnjg(ptr noundef %40, ptr noundef %53)
  %814 = load ptr, ptr %17, align 8, !tbaa !5
  %815 = load ptr, ptr %22, align 8, !tbaa !5
  %816 = load ptr, ptr %26, align 8, !tbaa !5
  %817 = load i64, ptr %816, align 8, !tbaa !9
  %818 = load i64, ptr %32, align 8, !tbaa !9
  %819 = mul nsw i64 %817, %818
  %820 = add nsw i64 %819, 1
  %821 = getelementptr inbounds %struct.complex, ptr %815, i64 %820
  %822 = load ptr, ptr %22, align 8, !tbaa !5
  %823 = load ptr, ptr %26, align 8, !tbaa !5
  %824 = load i64, ptr %823, align 8, !tbaa !9
  %825 = add nsw i64 %824, 1
  %826 = load i64, ptr %32, align 8, !tbaa !9
  %827 = mul nsw i64 %825, %826
  %828 = add nsw i64 %827, 1
  %829 = getelementptr inbounds %struct.complex, ptr %822, i64 %828
  %830 = call i32 @crot_(ptr noundef %814, ptr noundef %821, ptr noundef @c__1, ptr noundef %829, ptr noundef @c__1, ptr noundef %49, ptr noundef %40)
  br label %831

831:                                              ; preds = %813, %809
  store i32 0, ptr %14, align 4
  store i32 1, ptr %66, align 4
  br label %834

832:                                              ; preds = %660, %391
  %833 = load ptr, ptr %27, align 8, !tbaa !5
  store i64 1, ptr %833, align 8, !tbaa !9
  store i32 0, ptr %14, align 4
  store i32 1, ptr %66, align 4
  br label %834

834:                                              ; preds = %832, %831, %103
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr %61) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %51) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr %48) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr %47) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #5
  %835 = load i32, ptr %14, align 4
  ret i32 %835
}

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

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

declare double @slamch_(ptr noundef) #2

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

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

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

declare double @c_abs(ptr noundef) #2

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

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

declare i32 @crot_(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 = { 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 = !{!"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, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!14, !12, i64 0}
!14 = !{!"", !12, i64 0, !12, i64 4}
!15 = !{!14, !12, i64 4}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}


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

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @ctgex2_(ptr nocapture noundef readonly %0, ptr nocapture noundef readonly %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr nocapture noundef readonly %8, ptr noundef %9, ptr nocapture noundef readonly %10, ptr nocapture noundef readonly %11, ptr nocapture noundef writeonly %12) local_unnamed_addr #0 {
  %14 = alloca i64, align 8
  %15 = alloca %struct.complex, align 8
  %16 = alloca %struct.complex, align 8
  %17 = alloca %struct.complex, align 8
  %18 = alloca %struct.complex, align 8
  %19 = alloca i64, align 8
  %20 = alloca [4 x %struct.complex], align 16
  %21 = alloca [4 x %struct.complex], align 16
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca %struct.complex, align 8
  %25 = alloca %struct.complex, align 8
  %26 = alloca float, align 4
  %27 = alloca %struct.complex, align 4
  %28 = alloca [8 x %struct.complex], align 16
  %29 = alloca float, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %14) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %16) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %17) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %18) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %19) #5
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %20) #5
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %21) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %22) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %23) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %24) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %25) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %26) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %27) #5
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %28) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %29) #5
  %30 = load i64, ptr %4, align 8, !tbaa !5
  %31 = xor i64 %30, -1
  %32 = getelementptr inbounds %struct.complex, ptr %3, i64 %31
  %33 = load i64, ptr %6, align 8, !tbaa !5
  %34 = xor i64 %33, -1
  %35 = getelementptr inbounds %struct.complex, ptr %5, i64 %34
  %36 = load i64, ptr %8, align 8, !tbaa !5
  %37 = xor i64 %36, -1
  %38 = getelementptr inbounds %struct.complex, ptr %7, i64 %37
  %39 = load i64, ptr %10, align 8, !tbaa !5
  %40 = xor i64 %39, -1
  %41 = getelementptr inbounds %struct.complex, ptr %9, i64 %40
  store i64 0, ptr %12, align 8, !tbaa !5
  %42 = load i64, ptr %2, align 8, !tbaa !5
  %43 = icmp slt i64 %42, 2
  br i1 %43, label %278, label %44

44:                                               ; preds = %13
  store i64 2, ptr %19, align 8, !tbaa !5
  %45 = load i64, ptr %11, align 8, !tbaa !5
  %46 = add i64 %30, 1
  %47 = mul i64 %45, %46
  %48 = getelementptr inbounds %struct.complex, ptr %32, i64 %47
  %49 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef %48, ptr noundef nonnull %4, ptr noundef nonnull %20, ptr noundef nonnull @c__2) #5
  %50 = load i64, ptr %11, align 8, !tbaa !5
  %51 = add i64 %33, 1
  %52 = mul i64 %50, %51
  %53 = getelementptr inbounds %struct.complex, ptr %35, i64 %52
  %54 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef %53, ptr noundef nonnull %6, ptr noundef nonnull %21, ptr noundef nonnull @c__2) #5
  %55 = call double @slamch_(ptr noundef nonnull @.str.1) #5
  %56 = fptrunc double %55 to float
  %57 = call double @slamch_(ptr noundef nonnull @.str.2) #5
  %58 = fpext float %56 to double
  %59 = fdiv double %57, %58
  %60 = fptrunc double %59 to float
  store float 0.000000e+00, ptr %29, align 4, !tbaa !9
  store float 1.000000e+00, ptr %26, align 4, !tbaa !9
  %61 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef nonnull %20, ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull %19) #5
  %62 = load i64, ptr %19, align 8, !tbaa !5
  %63 = mul nsw i64 %62, %62
  %64 = getelementptr inbounds [8 x %struct.complex], ptr %28, i64 0, i64 %63
  %65 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef nonnull %21, ptr noundef nonnull @c__2, ptr noundef nonnull %64, ptr noundef nonnull %19) #5
  %66 = load i64, ptr %19, align 8, !tbaa !5
  %67 = shl i64 %66, 1
  %68 = mul nsw i64 %67, %66
  store i64 %68, ptr %14, align 8, !tbaa !5
  %69 = call i32 @classq_(ptr noundef nonnull %14, ptr noundef nonnull %28, ptr noundef nonnull @c__1, ptr noundef nonnull %29, ptr noundef nonnull %26) #5
  %70 = load float, ptr %29, align 4, !tbaa !9
  %71 = fpext float %70 to double
  %72 = load float, ptr %26, align 4, !tbaa !9
  %73 = fpext float %72 to double
  %74 = call double @sqrt(double noundef %73) #5
  %75 = fmul double %74, %71
  %76 = fptrunc double %75 to float
  %77 = fmul float %56, 1.000000e+01
  %78 = fmul float %77, %76
  %79 = fcmp oge float %78, %60
  %80 = select i1 %79, float %78, float %60
  %81 = getelementptr inbounds i8, ptr %20, i64 24
  %82 = load float, ptr %81, align 8, !tbaa !11
  %83 = getelementptr inbounds i8, ptr %20, i64 28
  %84 = load float, ptr %83, align 4, !tbaa !13
  %85 = fneg float %84
  %86 = getelementptr inbounds i8, ptr %21, i64 24
  %87 = load float, ptr %86, align 8, !tbaa !11
  %88 = getelementptr inbounds i8, ptr %21, i64 28
  %89 = load float, ptr %88, align 4, !tbaa !13
  %90 = fneg float %89
  %91 = load <2 x float>, ptr %21, align 16, !tbaa !9
  %92 = insertelement <2 x float> poison, float %84, i64 0
  %93 = insertelement <2 x float> %92, float %85, i64 1
  %94 = fmul <2 x float> %91, %93
  %95 = shufflevector <2 x float> %94, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %96 = insertelement <2 x float> poison, float %82, i64 0
  %97 = shufflevector <2 x float> %96, <2 x float> poison, <2 x i32> zeroinitializer
  %98 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %97, <2 x float> %91, <2 x float> %95)
  %99 = load <2 x float>, ptr %20, align 16, !tbaa !9
  %100 = insertelement <2 x float> poison, float %89, i64 0
  %101 = insertelement <2 x float> %100, float %90, i64 1
  %102 = fmul <2 x float> %99, %101
  %103 = shufflevector <2 x float> %102, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %104 = insertelement <2 x float> poison, float %87, i64 0
  %105 = shufflevector <2 x float> %104, <2 x float> poison, <2 x i32> zeroinitializer
  %106 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %99, <2 x float> %103)
  %107 = fsub <2 x float> %98, %106
  store <2 x float> %107, ptr %17, align 8, !tbaa !9
  %108 = getelementptr inbounds i8, ptr %21, i64 16
  %109 = load <2 x float>, ptr %108, align 16, !tbaa !9
  %110 = fmul <2 x float> %109, %93
  %111 = shufflevector <2 x float> %110, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %112 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %97, <2 x float> %109, <2 x float> %111)
  store <2 x float> %112, ptr %16, align 8, !tbaa !9
  %113 = getelementptr inbounds i8, ptr %20, i64 16
  %114 = load <2 x float>, ptr %113, align 16, !tbaa !9
  %115 = fmul <2 x float> %114, %101
  %116 = shufflevector <2 x float> %115, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %117 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %114, <2 x float> %116)
  %118 = fsub <2 x float> %112, %117
  store <2 x float> %118, ptr %18, align 8, !tbaa !9
  %119 = call double @c_abs(ptr noundef nonnull %81) #5
  %120 = fptrunc double %119 to float
  %121 = call double @c_abs(ptr noundef nonnull %86) #5
  %122 = fptrunc double %121 to float
  %123 = call i32 @clartg_(ptr noundef nonnull %18, ptr noundef nonnull %17, ptr noundef nonnull %23, ptr noundef nonnull %25, ptr noundef nonnull %27) #5
  %124 = load <2 x float>, ptr %25, align 8, !tbaa !9
  %125 = fneg <2 x float> %124
  store <2 x float> %125, ptr %15, align 8, !tbaa !9
  store <2 x float> %125, ptr %25, align 8, !tbaa !9
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %25) #5
  %126 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %20, ptr noundef nonnull @c__1, ptr noundef nonnull %113, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %25) #5
  %127 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %21, ptr noundef nonnull @c__1, ptr noundef nonnull %108, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  %128 = fcmp ult float %120, %122
  %. = select i1 %128, ptr %21, ptr %20
  %..sroa.sel.v = select i1 %128, ptr %21, ptr %20
  %..sroa.sel = getelementptr inbounds i8, ptr %..sroa.sel.v, i64 8
  %129 = call i32 @clartg_(ptr noundef nonnull %., ptr noundef nonnull %..sroa.sel, ptr noundef nonnull %22, ptr noundef nonnull %24, ptr noundef nonnull %27) #5
  %130 = getelementptr inbounds i8, ptr %20, i64 8
  %131 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %20, ptr noundef nonnull @c__2, ptr noundef nonnull %130, ptr noundef nonnull @c__2, ptr noundef nonnull %22, ptr noundef nonnull %24) #5
  %132 = getelementptr inbounds i8, ptr %21, i64 8
  %133 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %21, ptr noundef nonnull @c__2, ptr noundef nonnull %132, ptr noundef nonnull @c__2, ptr noundef nonnull %22, ptr noundef nonnull %24) #5
  %134 = call double @c_abs(ptr noundef nonnull %130) #5
  %135 = call double @c_abs(ptr noundef nonnull %132) #5
  %136 = fadd double %134, %135
  %137 = fptrunc double %136 to float
  %138 = fcmp ult float %80, %137
  br i1 %138, label %277, label %139

139:                                              ; preds = %44
  %140 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef nonnull %20, ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull %19) #5
  %141 = load i64, ptr %19, align 8, !tbaa !5
  %142 = mul nsw i64 %141, %141
  %143 = getelementptr inbounds [8 x %struct.complex], ptr %28, i64 0, i64 %142
  %144 = call i32 @clacpy_(ptr noundef nonnull @.str, ptr noundef nonnull %19, ptr noundef nonnull %19, ptr noundef nonnull %21, ptr noundef nonnull @c__2, ptr noundef nonnull %143, ptr noundef nonnull %19) #5
  call void @r_cnjg(ptr noundef nonnull %16, ptr noundef nonnull %25) #5
  %145 = load <2 x float>, ptr %16, align 8, !tbaa !9
  %146 = fneg <2 x float> %145
  store <2 x float> %146, ptr %15, align 8, !tbaa !9
  %147 = getelementptr inbounds i8, ptr %28, i64 16
  %148 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull @c__1, ptr noundef nonnull %147, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  call void @r_cnjg(ptr noundef nonnull %16, ptr noundef nonnull %25) #5
  %149 = load <2 x float>, ptr %16, align 8, !tbaa !9
  %150 = fneg <2 x float> %149
  store <2 x float> %150, ptr %15, align 8, !tbaa !9
  %151 = getelementptr inbounds i8, ptr %28, i64 32
  %152 = getelementptr inbounds i8, ptr %28, i64 48
  %153 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %151, ptr noundef nonnull @c__1, ptr noundef nonnull %152, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  %154 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %155 = fneg <2 x float> %154
  store <2 x float> %155, ptr %15, align 8, !tbaa !9
  %156 = getelementptr inbounds i8, ptr %28, i64 8
  %157 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %28, ptr noundef nonnull @c__2, ptr noundef nonnull %156, ptr noundef nonnull @c__2, ptr noundef nonnull %22, ptr noundef nonnull %15) #5
  %158 = load <2 x float>, ptr %24, align 8, !tbaa !9
  %159 = fneg <2 x float> %158
  store <2 x float> %159, ptr %15, align 8, !tbaa !9
  %160 = getelementptr inbounds i8, ptr %28, i64 40
  %161 = call i32 @crot_(ptr noundef nonnull @c__2, ptr noundef nonnull %151, ptr noundef nonnull @c__2, ptr noundef nonnull %160, ptr noundef nonnull @c__2, ptr noundef nonnull %22, ptr noundef nonnull %15) #5
  %162 = load i64, ptr %11, align 8, !tbaa !5
  %163 = mul nsw i64 %162, %30
  %164 = getelementptr %struct.complex, ptr %32, i64 %162
  %165 = add nsw i64 %162, 1
  %166 = mul nsw i64 %165, %30
  %167 = mul nsw i64 %162, %33
  %168 = getelementptr %struct.complex, ptr %35, i64 %162
  %169 = mul nsw i64 %165, %33
  %170 = getelementptr %struct.complex, ptr %164, i64 %163
  %171 = getelementptr %struct.complex, ptr %164, i64 %166
  %172 = getelementptr %struct.complex, ptr %168, i64 %167
  %173 = getelementptr %struct.complex, ptr %168, i64 %169
  %174 = load <2 x float>, ptr %152, align 16, !tbaa !9
  %175 = load <2 x float>, ptr %173, align 4, !tbaa !9
  %176 = fsub <2 x float> %174, %175
  store <2 x float> %176, ptr %152, align 16, !tbaa !9
  %177 = load <4 x float>, ptr %28, align 16, !tbaa !9
  %178 = load <4 x float>, ptr %170, align 4, !tbaa !9
  %179 = fsub <4 x float> %177, %178
  store <4 x float> %179, ptr %28, align 16, !tbaa !9
  %180 = load <4 x float>, ptr %147, align 16, !tbaa !9
  %181 = load <4 x float>, ptr %171, align 4, !tbaa !9
  %182 = fsub <4 x float> %180, %181
  store <4 x float> %182, ptr %147, align 16, !tbaa !9
  %gep164.1 = getelementptr i8, ptr %168, i64 8
  %183 = load <4 x float>, ptr %151, align 16, !tbaa !9
  %184 = load <4 x float>, ptr %172, align 4, !tbaa !9
  %185 = fsub <4 x float> %183, %184
  store <4 x float> %185, ptr %151, align 16, !tbaa !9
  %186 = getelementptr inbounds i8, ptr %28, i64 56
  %187 = getelementptr %struct.complex, ptr %gep164.1, i64 %169
  %188 = load <2 x float>, ptr %186, align 8, !tbaa !9
  %189 = load <2 x float>, ptr %187, align 4, !tbaa !9
  %190 = fsub <2 x float> %188, %189
  store <2 x float> %190, ptr %186, align 8, !tbaa !9
  store <2 x float> %190, ptr %15, align 8, !tbaa !9
  store float 0.000000e+00, ptr %29, align 4, !tbaa !9
  store float 1.000000e+00, ptr %26, align 4, !tbaa !9
  %191 = load i64, ptr %19, align 8, !tbaa !5
  %192 = shl i64 %191, 1
  %193 = mul nsw i64 %192, %191
  store i64 %193, ptr %14, align 8, !tbaa !5
  %194 = call i32 @classq_(ptr noundef nonnull %14, ptr noundef nonnull %28, ptr noundef nonnull @c__1, ptr noundef nonnull %29, ptr noundef nonnull %26) #5
  %195 = load float, ptr %29, align 4, !tbaa !9
  %196 = fpext float %195 to double
  %197 = load float, ptr %26, align 4, !tbaa !9
  %198 = fpext float %197 to double
  %199 = call double @sqrt(double noundef %198) #5
  %200 = fmul double %199, %196
  %201 = fptrunc double %200 to float
  %202 = fcmp ult float %80, %201
  br i1 %202, label %277, label %203

203:                                              ; preds = %139
  %204 = load i64, ptr %11, align 8, !tbaa !5
  %205 = add nsw i64 %204, 1
  store i64 %205, ptr %14, align 8, !tbaa !5
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %25) #5
  %206 = load i64, ptr %11, align 8, !tbaa !5
  %207 = mul nsw i64 %206, %30
  %208 = getelementptr %struct.complex, ptr %32, i64 %207
  %209 = getelementptr i8, ptr %208, i64 8
  %210 = add nsw i64 %206, 1
  %211 = mul nsw i64 %210, %30
  %212 = getelementptr %struct.complex, ptr %32, i64 %211
  %213 = getelementptr i8, ptr %212, i64 8
  %214 = call i32 @crot_(ptr noundef nonnull %14, ptr noundef %209, ptr noundef nonnull @c__1, ptr noundef %213, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  %215 = load i64, ptr %11, align 8, !tbaa !5
  %216 = add nsw i64 %215, 1
  store i64 %216, ptr %14, align 8, !tbaa !5
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %25) #5
  %217 = load i64, ptr %11, align 8, !tbaa !5
  %218 = mul nsw i64 %217, %33
  %219 = getelementptr %struct.complex, ptr %35, i64 %218
  %220 = getelementptr i8, ptr %219, i64 8
  %221 = add nsw i64 %217, 1
  %222 = mul nsw i64 %221, %33
  %223 = getelementptr %struct.complex, ptr %35, i64 %222
  %224 = getelementptr i8, ptr %223, i64 8
  %225 = call i32 @crot_(ptr noundef nonnull %14, ptr noundef %220, ptr noundef nonnull @c__1, ptr noundef %224, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  %226 = load i64, ptr %2, align 8, !tbaa !5
  %227 = load i64, ptr %11, align 8, !tbaa !5
  %228 = add i64 %226, 1
  %229 = sub i64 %228, %227
  store i64 %229, ptr %14, align 8, !tbaa !5
  %230 = mul nsw i64 %227, %30
  %231 = getelementptr %struct.complex, ptr %32, i64 %227
  %232 = getelementptr %struct.complex, ptr %231, i64 %230
  %233 = getelementptr i8, ptr %231, i64 8
  %234 = getelementptr %struct.complex, ptr %233, i64 %230
  %235 = call i32 @crot_(ptr noundef nonnull %14, ptr noundef %232, ptr noundef nonnull %4, ptr noundef %234, ptr noundef nonnull %4, ptr noundef nonnull %22, ptr noundef nonnull %24) #5
  %236 = load i64, ptr %2, align 8, !tbaa !5
  %237 = load i64, ptr %11, align 8, !tbaa !5
  %238 = add i64 %236, 1
  %239 = sub i64 %238, %237
  store i64 %239, ptr %14, align 8, !tbaa !5
  %240 = mul nsw i64 %237, %33
  %241 = getelementptr %struct.complex, ptr %35, i64 %237
  %242 = getelementptr %struct.complex, ptr %241, i64 %240
  %243 = getelementptr i8, ptr %241, i64 8
  %244 = getelementptr %struct.complex, ptr %243, i64 %240
  %245 = call i32 @crot_(ptr noundef nonnull %14, ptr noundef %242, ptr noundef nonnull %6, ptr noundef %244, ptr noundef nonnull %6, ptr noundef nonnull %22, ptr noundef nonnull %24) #5
  %246 = load i64, ptr %11, align 8, !tbaa !5
  %247 = add nsw i64 %246, 1
  %248 = mul nsw i64 %246, %30
  %249 = getelementptr %struct.complex, ptr %32, i64 %247
  %250 = getelementptr %struct.complex, ptr %249, i64 %248
  store <2 x float> zeroinitializer, ptr %250, align 4, !tbaa !9
  %251 = mul nsw i64 %246, %33
  %252 = add nsw i64 %247, %251
  store i64 %252, ptr %14, align 8, !tbaa !5
  %253 = getelementptr inbounds %struct.complex, ptr %35, i64 %252
  store <2 x float> zeroinitializer, ptr %253, align 4, !tbaa !9
  %254 = load i64, ptr %1, align 8, !tbaa !5
  %.not = icmp eq i64 %254, 0
  br i1 %.not, label %265, label %255

255:                                              ; preds = %203
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %25) #5
  %256 = load i64, ptr %11, align 8, !tbaa !5
  %257 = mul nsw i64 %256, %39
  %258 = getelementptr %struct.complex, ptr %41, i64 %257
  %259 = getelementptr i8, ptr %258, i64 8
  %260 = add nsw i64 %256, 1
  %261 = mul nsw i64 %260, %39
  %262 = getelementptr %struct.complex, ptr %41, i64 %261
  %263 = getelementptr i8, ptr %262, i64 8
  %264 = call i32 @crot_(ptr noundef nonnull %2, ptr noundef %259, ptr noundef nonnull @c__1, ptr noundef %263, ptr noundef nonnull @c__1, ptr noundef nonnull %23, ptr noundef nonnull %15) #5
  br label %265

265:                                              ; preds = %255, %203
  %266 = load i64, ptr %0, align 8, !tbaa !5
  %.not161 = icmp eq i64 %266, 0
  br i1 %.not161, label %278, label %267

267:                                              ; preds = %265
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %24) #5
  %268 = load i64, ptr %11, align 8, !tbaa !5
  %269 = mul nsw i64 %268, %36
  %270 = getelementptr %struct.complex, ptr %38, i64 %269
  %271 = getelementptr i8, ptr %270, i64 8
  %272 = add nsw i64 %268, 1
  %273 = mul nsw i64 %272, %36
  %274 = getelementptr %struct.complex, ptr %38, i64 %273
  %275 = getelementptr i8, ptr %274, i64 8
  %276 = call i32 @crot_(ptr noundef nonnull %2, ptr noundef %271, ptr noundef nonnull @c__1, ptr noundef %275, ptr noundef nonnull @c__1, ptr noundef nonnull %22, ptr noundef nonnull %15) #5
  br label %278

277:                                              ; preds = %139, %44
  store i64 1, ptr %12, align 8, !tbaa !5
  br label %278

278:                                              ; preds = %265, %267, %13, %277
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %29) #5
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %28) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %26) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %25) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %24) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %23) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %22) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %21) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %20) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %19) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %17) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #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 i32 @clacpy_(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare double @slamch_(ptr noundef) local_unnamed_addr #2

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

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @sqrt(double noundef) local_unnamed_addr #3

declare double @c_abs(ptr noundef) local_unnamed_addr #2

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

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

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

!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, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !10, i64 0}
!12 = !{!"", !10, i64 0, !10, i64 4}
!13 = !{!12, !10, i64 4}


; Effective O3 passes: DSEPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopRotatePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass