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

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

%struct.doublecomplex = type { double, double }

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

56:                                               ; preds = %357, %8
  %57 = load i32, ptr %25, align 4, !tbaa !9
  %58 = load i32, ptr %17, align 4, !tbaa !9
  %59 = icmp sle i32 %57, %58
  br i1 %59, label %60, label %360

60:                                               ; preds = %56
  %61 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %61, ptr %18, align 4, !tbaa !9
  %62 = load ptr, ptr %10, align 8, !tbaa !5
  %63 = load i32, ptr %18, align 4, !tbaa !9
  %64 = sext i32 %63 to i64
  %65 = getelementptr inbounds %struct.doublecomplex, ptr %62, i64 %64
  %66 = getelementptr inbounds %struct.doublecomplex, ptr %65, i32 0, i32 0
  %67 = load double, ptr %66, align 8, !tbaa !11
  store double %67, ptr %35, align 8, !tbaa !14
  %68 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %68, ptr %18, align 4, !tbaa !9
  %69 = load ptr, ptr %11, align 8, !tbaa !5
  %70 = load i32, ptr %18, align 4, !tbaa !9
  %71 = sext i32 %70 to i64
  %72 = getelementptr inbounds %struct.doublecomplex, ptr %69, i64 %71
  %73 = getelementptr inbounds %struct.doublecomplex, ptr %72, i32 0, i32 0
  %74 = load double, ptr %73, align 8, !tbaa !11
  store double %74, ptr %36, align 8, !tbaa !14
  %75 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %75, ptr %18, align 4, !tbaa !9
  %76 = load ptr, ptr %12, align 8, !tbaa !5
  %77 = load i32, ptr %18, align 4, !tbaa !9
  %78 = sext i32 %77 to i64
  %79 = getelementptr inbounds %struct.doublecomplex, ptr %76, i64 %78
  %80 = getelementptr inbounds %struct.doublecomplex, ptr %79, i32 0, i32 0
  %81 = load double, ptr %80, align 8, !tbaa !11
  %82 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  store double %81, ptr %82, align 8, !tbaa !11
  %83 = load ptr, ptr %12, align 8, !tbaa !5
  %84 = load i32, ptr %18, align 4, !tbaa !9
  %85 = sext i32 %84 to i64
  %86 = getelementptr inbounds %struct.doublecomplex, ptr %83, i64 %85
  %87 = getelementptr inbounds %struct.doublecomplex, ptr %86, i32 0, i32 1
  %88 = load double, ptr %87, align 8, !tbaa !15
  %89 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  store double %88, ptr %89, align 8, !tbaa !15
  %90 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %91 = load double, ptr %90, align 8, !tbaa !11
  store double %91, ptr %43, align 8, !tbaa !14
  %92 = call { double, double } @Cd(ptr noundef %37)
  %93 = extractvalue { double, double } %92, 0
  %94 = extractvalue { double, double } %92, 1
  store double %94, ptr %41, align 8, !tbaa !14
  %95 = load ptr, ptr %14, align 8, !tbaa !5
  %96 = load i32, ptr %31, align 4, !tbaa !9
  %97 = sext i32 %96 to i64
  %98 = getelementptr inbounds double, ptr %95, i64 %97
  %99 = load double, ptr %98, align 8, !tbaa !14
  store double %99, ptr %32, align 8, !tbaa !14
  %100 = load i32, ptr %31, align 4, !tbaa !9
  store i32 %100, ptr %18, align 4, !tbaa !9
  %101 = load ptr, ptr %15, align 8, !tbaa !5
  %102 = load i32, ptr %18, align 4, !tbaa !9
  %103 = sext i32 %102 to i64
  %104 = getelementptr inbounds %struct.doublecomplex, ptr %101, i64 %103
  %105 = getelementptr inbounds %struct.doublecomplex, ptr %104, i32 0, i32 0
  %106 = load double, ptr %105, align 8, !tbaa !11
  %107 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  store double %106, ptr %107, align 8, !tbaa !11
  %108 = load ptr, ptr %15, align 8, !tbaa !5
  %109 = load i32, ptr %18, align 4, !tbaa !9
  %110 = sext i32 %109 to i64
  %111 = getelementptr inbounds %struct.doublecomplex, ptr %108, i64 %110
  %112 = getelementptr inbounds %struct.doublecomplex, ptr %111, i32 0, i32 1
  %113 = load double, ptr %112, align 8, !tbaa !15
  %114 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  store double %113, ptr %114, align 8, !tbaa !15
  %115 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %116 = load double, ptr %115, align 8, !tbaa !11
  store double %116, ptr %42, align 8, !tbaa !14
  %117 = call { double, double } @Cd(ptr noundef %33)
  %118 = extractvalue { double, double } %117, 0
  %119 = extractvalue { double, double } %117, 1
  store double %119, ptr %40, align 8, !tbaa !14
  %120 = load double, ptr %42, align 8, !tbaa !14
  %121 = load double, ptr %43, align 8, !tbaa !14
  %122 = load double, ptr %40, align 8, !tbaa !14
  %123 = load double, ptr %41, align 8, !tbaa !14
  %124 = fmul double %122, %123
  %125 = fneg double %124
  %126 = call double @llvm.fmuladd.f64(double %120, double %121, double %125)
  store double %126, ptr %39, align 8, !tbaa !14
  %127 = load double, ptr %42, align 8, !tbaa !14
  %128 = load double, ptr %41, align 8, !tbaa !14
  %129 = load double, ptr %40, align 8, !tbaa !14
  %130 = load double, ptr %43, align 8, !tbaa !14
  %131 = fmul double %129, %130
  %132 = call double @llvm.fmuladd.f64(double %127, double %128, double %131)
  store double %132, ptr %38, align 8, !tbaa !14
  %133 = load double, ptr %32, align 8, !tbaa !14
  %134 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 0
  %135 = load double, ptr %134, align 8, !tbaa !11
  %136 = fmul double %133, %135
  %137 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  store double %136, ptr %137, align 8, !tbaa !11
  %138 = load double, ptr %32, align 8, !tbaa !14
  %139 = getelementptr inbounds %struct.doublecomplex, ptr %37, i32 0, i32 1
  %140 = load double, ptr %139, align 8, !tbaa !15
  %141 = fmul double %138, %140
  %142 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  store double %141, ptr %142, align 8, !tbaa !15
  %143 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  %144 = load double, ptr %143, align 8, !tbaa !11
  %145 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  store double %144, ptr %145, align 8, !tbaa !11
  %146 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  %147 = load double, ptr %146, align 8, !tbaa !15
  %148 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  store double %147, ptr %148, align 8, !tbaa !15
  %149 = call { double, double } @Cd(ptr noundef %33)
  %150 = extractvalue { double, double } %149, 0
  %151 = extractvalue { double, double } %149, 1
  %152 = fneg double %151
  %153 = call ptr @_pCd(ptr noundef %22)
  %154 = getelementptr inbounds { double, double }, ptr %153, i32 0, i32 0
  %155 = getelementptr inbounds { double, double }, ptr %153, i32 0, i32 1
  store double %150, ptr %154, align 8
  store double %152, ptr %155, align 8
  %156 = load double, ptr %35, align 8, !tbaa !14
  %157 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 0
  %158 = load double, ptr %157, align 8, !tbaa !11
  %159 = fmul double %156, %158
  %160 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 0
  store double %159, ptr %160, align 8, !tbaa !11
  %161 = load double, ptr %35, align 8, !tbaa !14
  %162 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 1
  %163 = load double, ptr %162, align 8, !tbaa !15
  %164 = fmul double %161, %163
  %165 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 1
  store double %164, ptr %165, align 8, !tbaa !15
  %166 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 0
  %167 = load double, ptr %166, align 8, !tbaa !11
  %168 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 0
  %169 = load double, ptr %168, align 8, !tbaa !11
  %170 = fsub double %167, %169
  %171 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  store double %170, ptr %171, align 8, !tbaa !11
  %172 = getelementptr inbounds %struct.doublecomplex, ptr %26, i32 0, i32 1
  %173 = load double, ptr %172, align 8, !tbaa !15
  %174 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 1
  %175 = load double, ptr %174, align 8, !tbaa !15
  %176 = fsub double %173, %175
  %177 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  store double %176, ptr %177, align 8, !tbaa !15
  %178 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  %179 = load double, ptr %178, align 8, !tbaa !11
  %180 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %179, ptr %180, align 8, !tbaa !11
  %181 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  %182 = load double, ptr %181, align 8, !tbaa !15
  %183 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %182, ptr %183, align 8, !tbaa !15
  %184 = call { double, double } @Cd(ptr noundef %26)
  %185 = extractvalue { double, double } %184, 0
  %186 = extractvalue { double, double } %184, 1
  %187 = fneg double %186
  %188 = call ptr @_pCd(ptr noundef %21)
  %189 = getelementptr inbounds { double, double }, ptr %188, i32 0, i32 0
  %190 = getelementptr inbounds { double, double }, ptr %188, i32 0, i32 1
  store double %185, ptr %189, align 8
  store double %187, ptr %190, align 8
  %191 = load double, ptr %36, align 8, !tbaa !14
  %192 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 0
  %193 = load double, ptr %192, align 8, !tbaa !11
  %194 = fmul double %191, %193
  %195 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 0
  store double %194, ptr %195, align 8, !tbaa !11
  %196 = load double, ptr %36, align 8, !tbaa !14
  %197 = getelementptr inbounds %struct.doublecomplex, ptr %33, i32 0, i32 1
  %198 = load double, ptr %197, align 8, !tbaa !15
  %199 = fmul double %196, %198
  %200 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 1
  store double %199, ptr %200, align 8, !tbaa !15
  %201 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 0
  %202 = load double, ptr %201, align 8, !tbaa !11
  %203 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 0
  %204 = load double, ptr %203, align 8, !tbaa !11
  %205 = fadd double %202, %204
  %206 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  store double %205, ptr %206, align 8, !tbaa !11
  %207 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 1
  %208 = load double, ptr %207, align 8, !tbaa !15
  %209 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 1
  %210 = load double, ptr %209, align 8, !tbaa !15
  %211 = fadd double %208, %210
  %212 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  store double %211, ptr %212, align 8, !tbaa !15
  %213 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  %214 = load double, ptr %213, align 8, !tbaa !11
  %215 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %214, ptr %215, align 8, !tbaa !11
  %216 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  %217 = load double, ptr %216, align 8, !tbaa !15
  %218 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %217, ptr %218, align 8, !tbaa !15
  %219 = load double, ptr %32, align 8, !tbaa !14
  %220 = load double, ptr %35, align 8, !tbaa !14
  %221 = load double, ptr %39, align 8, !tbaa !14
  %222 = call double @llvm.fmuladd.f64(double %219, double %220, double %221)
  store double %222, ptr %29, align 8, !tbaa !14
  %223 = load double, ptr %32, align 8, !tbaa !14
  %224 = load double, ptr %36, align 8, !tbaa !14
  %225 = load double, ptr %39, align 8, !tbaa !14
  %226 = fneg double %225
  %227 = call double @llvm.fmuladd.f64(double %223, double %224, double %226)
  store double %227, ptr %30, align 8, !tbaa !14
  %228 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %228, ptr %18, align 4, !tbaa !9
  %229 = load double, ptr %32, align 8, !tbaa !14
  %230 = load double, ptr %29, align 8, !tbaa !14
  %231 = load double, ptr %42, align 8, !tbaa !14
  %232 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %233 = load double, ptr %232, align 8, !tbaa !11
  %234 = load double, ptr %40, align 8, !tbaa !14
  %235 = call { double, double } @Cd(ptr noundef %28)
  %236 = extractvalue { double, double } %235, 0
  %237 = extractvalue { double, double } %235, 1
  %238 = fmul double %234, %237
  %239 = call double @llvm.fmuladd.f64(double %231, double %233, double %238)
  %240 = call double @llvm.fmuladd.f64(double %229, double %230, double %239)
  store double %240, ptr %19, align 8, !tbaa !14
  %241 = load double, ptr %19, align 8, !tbaa !14
  %242 = load ptr, ptr %10, align 8, !tbaa !5
  %243 = load i32, ptr %18, align 4, !tbaa !9
  %244 = sext i32 %243 to i64
  %245 = getelementptr inbounds %struct.doublecomplex, ptr %242, i64 %244
  %246 = getelementptr inbounds %struct.doublecomplex, ptr %245, i32 0, i32 0
  store double %241, ptr %246, align 8, !tbaa !11
  %247 = load ptr, ptr %10, align 8, !tbaa !5
  %248 = load i32, ptr %18, align 4, !tbaa !9
  %249 = sext i32 %248 to i64
  %250 = getelementptr inbounds %struct.doublecomplex, ptr %247, i64 %249
  %251 = getelementptr inbounds %struct.doublecomplex, ptr %250, i32 0, i32 1
  store double 0.000000e+00, ptr %251, align 8, !tbaa !15
  %252 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %252, ptr %18, align 4, !tbaa !9
  %253 = load double, ptr %32, align 8, !tbaa !14
  %254 = load double, ptr %30, align 8, !tbaa !14
  %255 = load double, ptr %42, align 8, !tbaa !14
  %256 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %257 = load double, ptr %256, align 8, !tbaa !11
  %258 = load double, ptr %40, align 8, !tbaa !14
  %259 = call { double, double } @Cd(ptr noundef %27)
  %260 = extractvalue { double, double } %259, 0
  %261 = extractvalue { double, double } %259, 1
  %262 = fmul double %258, %261
  %263 = fneg double %262
  %264 = call double @llvm.fmuladd.f64(double %255, double %257, double %263)
  %265 = fneg double %264
  %266 = call double @llvm.fmuladd.f64(double %253, double %254, double %265)
  store double %266, ptr %19, align 8, !tbaa !14
  %267 = load double, ptr %19, align 8, !tbaa !14
  %268 = load ptr, ptr %11, align 8, !tbaa !5
  %269 = load i32, ptr %18, align 4, !tbaa !9
  %270 = sext i32 %269 to i64
  %271 = getelementptr inbounds %struct.doublecomplex, ptr %268, i64 %270
  %272 = getelementptr inbounds %struct.doublecomplex, ptr %271, i32 0, i32 0
  store double %267, ptr %272, align 8, !tbaa !11
  %273 = load ptr, ptr %11, align 8, !tbaa !5
  %274 = load i32, ptr %18, align 4, !tbaa !9
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds %struct.doublecomplex, ptr %273, i64 %275
  %277 = getelementptr inbounds %struct.doublecomplex, ptr %276, i32 0, i32 1
  store double 0.000000e+00, ptr %277, align 8, !tbaa !15
  %278 = load i32, ptr %34, align 4, !tbaa !9
  store i32 %278, ptr %18, align 4, !tbaa !9
  %279 = load double, ptr %32, align 8, !tbaa !14
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %281 = load double, ptr %280, align 8, !tbaa !11
  %282 = fmul double %279, %281
  %283 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 0
  store double %282, ptr %283, align 8, !tbaa !11
  %284 = load double, ptr %32, align 8, !tbaa !14
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %286 = load double, ptr %285, align 8, !tbaa !15
  %287 = fmul double %284, %286
  %288 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 1
  store double %287, ptr %288, align 8, !tbaa !15
  %289 = call { double, double } @Cd(ptr noundef %33)
  %290 = extractvalue { double, double } %289, 0
  %291 = extractvalue { double, double } %289, 1
  %292 = fneg double %291
  %293 = call ptr @_pCd(ptr noundef %23)
  %294 = getelementptr inbounds { double, double }, ptr %293, i32 0, i32 0
  %295 = getelementptr inbounds { double, double }, ptr %293, i32 0, i32 1
  store double %290, ptr %294, align 8
  store double %292, ptr %295, align 8
  %296 = load double, ptr %30, align 8, !tbaa !14
  %297 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  store double %296, ptr %297, align 8, !tbaa !11
  %298 = load double, ptr %38, align 8, !tbaa !14
  %299 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  store double %298, ptr %299, align 8, !tbaa !15
  %300 = getelementptr inbounds %struct.doublecomplex, ptr %23, i32 0, i32 0
  %301 = load double, ptr %300, align 8, !tbaa !11
  %302 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %303 = load double, ptr %302, align 8, !tbaa !11
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %23, i32 0, i32 1
  %305 = load double, ptr %304, align 8, !tbaa !15
  %306 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %307 = load double, ptr %306, align 8, !tbaa !15
  %308 = fmul double %305, %307
  %309 = fneg double %308
  %310 = call double @llvm.fmuladd.f64(double %301, double %303, double %309)
  %311 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 0
  store double %310, ptr %311, align 8, !tbaa !11
  %312 = getelementptr inbounds %struct.doublecomplex, ptr %23, i32 0, i32 0
  %313 = load double, ptr %312, align 8, !tbaa !11
  %314 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 1
  %315 = load double, ptr %314, align 8, !tbaa !15
  %316 = getelementptr inbounds %struct.doublecomplex, ptr %23, i32 0, i32 1
  %317 = load double, ptr %316, align 8, !tbaa !15
  %318 = getelementptr inbounds %struct.doublecomplex, ptr %24, i32 0, i32 0
  %319 = load double, ptr %318, align 8, !tbaa !11
  %320 = fmul double %317, %319
  %321 = call double @llvm.fmuladd.f64(double %313, double %315, double %320)
  %322 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 1
  store double %321, ptr %322, align 8, !tbaa !15
  %323 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 0
  %324 = load double, ptr %323, align 8, !tbaa !11
  %325 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 0
  %326 = load double, ptr %325, align 8, !tbaa !11
  %327 = fadd double %324, %326
  %328 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  store double %327, ptr %328, align 8, !tbaa !11
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %21, i32 0, i32 1
  %330 = load double, ptr %329, align 8, !tbaa !15
  %331 = getelementptr inbounds %struct.doublecomplex, ptr %22, i32 0, i32 1
  %332 = load double, ptr %331, align 8, !tbaa !15
  %333 = fadd double %330, %332
  %334 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  store double %333, ptr %334, align 8, !tbaa !15
  %335 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 0
  %336 = load double, ptr %335, align 8, !tbaa !11
  %337 = load ptr, ptr %12, align 8, !tbaa !5
  %338 = load i32, ptr %18, align 4, !tbaa !9
  %339 = sext i32 %338 to i64
  %340 = getelementptr inbounds %struct.doublecomplex, ptr %337, i64 %339
  %341 = getelementptr inbounds %struct.doublecomplex, ptr %340, i32 0, i32 0
  store double %336, ptr %341, align 8, !tbaa !11
  %342 = getelementptr inbounds %struct.doublecomplex, ptr %20, i32 0, i32 1
  %343 = load double, ptr %342, align 8, !tbaa !15
  %344 = load ptr, ptr %12, align 8, !tbaa !5
  %345 = load i32, ptr %18, align 4, !tbaa !9
  %346 = sext i32 %345 to i64
  %347 = getelementptr inbounds %struct.doublecomplex, ptr %344, i64 %346
  %348 = getelementptr inbounds %struct.doublecomplex, ptr %347, i32 0, i32 1
  store double %343, ptr %348, align 8, !tbaa !15
  %349 = load ptr, ptr %13, align 8, !tbaa !5
  %350 = load i32, ptr %349, align 4, !tbaa !9
  %351 = load i32, ptr %34, align 4, !tbaa !9
  %352 = add nsw i32 %351, %350
  store i32 %352, ptr %34, align 4, !tbaa !9
  %353 = load ptr, ptr %16, align 8, !tbaa !5
  %354 = load i32, ptr %353, align 4, !tbaa !9
  %355 = load i32, ptr %31, align 4, !tbaa !9
  %356 = add nsw i32 %355, %354
  store i32 %356, ptr %31, align 4, !tbaa !9
  br label %357

357:                                              ; preds = %60
  %358 = load i32, ptr %25, align 4, !tbaa !9
  %359 = add nsw i32 %358, 1
  store i32 %359, ptr %25, align 4, !tbaa !9
  br label %56, !llvm.loop !16

360:                                              ; preds = %56
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %37) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 4, 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 16, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  ret void
}

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(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 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nounwind }

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

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

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

.lr.ph:                                           ; preds = %8
  %23 = getelementptr inbounds i8, ptr %11, i64 8
  br label %24

24:                                               ; preds = %.lr.ph, %24
  %.093 = phi i32 [ 1, %.lr.ph ], [ %122, %24 ]
  %.08892 = phi i32 [ 1, %.lr.ph ], [ %121, %24 ]
  %.08991 = phi i32 [ 1, %.lr.ph ], [ %119, %24 ]
  %25 = sext i32 %.08991 to i64
  %26 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %25
  %27 = load double, ptr %26, align 8, !tbaa !9
  %28 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %25
  %29 = load double, ptr %28, align 8, !tbaa !9
  %30 = getelementptr inbounds %struct.doublecomplex, ptr %19, i64 %25
  %31 = load <2 x double>, ptr %30, align 8, !tbaa !12
  store <2 x double> %31, ptr %16, align 16, !tbaa !12
  %32 = call { double, double } @Cd(ptr noundef nonnull %16)
  %33 = extractvalue { double, double } %32, 1
  %34 = sext i32 %.08892 to i64
  %35 = getelementptr inbounds double, ptr %18, i64 %34
  %36 = load double, ptr %35, align 8, !tbaa !12
  %37 = getelementptr inbounds %struct.doublecomplex, ptr %17, i64 %34
  %38 = load <2 x double>, ptr %37, align 8, !tbaa !12
  store <2 x double> %38, ptr %15, align 16, !tbaa !12
  %39 = call { double, double } @Cd(ptr noundef nonnull %15)
  %40 = extractvalue { double, double } %39, 1
  %41 = fneg double %40
  %42 = fmul double %33, %41
  %43 = extractelement <2 x double> %31, i64 0
  %44 = extractelement <2 x double> %38, i64 0
  %45 = call double @llvm.fmuladd.f64(double %44, double %43, double %42)
  %46 = fmul double %43, %40
  %47 = load <2 x double>, ptr %16, align 16, !tbaa !12
  %48 = insertelement <2 x double> poison, double %36, i64 0
  %49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
  %50 = fmul <2 x double> %49, %47
  store <2 x double> %50, ptr %12, align 16, !tbaa !12
  %51 = call { double, double } @Cd(ptr noundef nonnull %15)
  %52 = extractvalue { double, double } %51, 0
  %53 = extractvalue { double, double } %51, 1
  %54 = fneg double %53
  %55 = call ptr @_pCd(ptr noundef nonnull %10)
  %56 = getelementptr inbounds i8, ptr %55, i64 8
  store double %52, ptr %55, align 8
  store double %54, ptr %56, align 8
  %57 = load <2 x double>, ptr %10, align 16, !tbaa !12
  %58 = insertelement <2 x double> poison, double %27, i64 0
  %59 = shufflevector <2 x double> %58, <2 x double> poison, <2 x i32> zeroinitializer
  %60 = fmul <2 x double> %59, %57
  store <2 x double> %60, ptr %9, align 16, !tbaa !12
  %61 = load <2 x double>, ptr %12, align 16, !tbaa !12
  %62 = fsub <2 x double> %61, %60
  store <2 x double> %62, ptr %13, align 16, !tbaa !12
  %63 = call { double, double } @Cd(ptr noundef nonnull %12)
  %64 = extractvalue { double, double } %63, 0
  %65 = extractvalue { double, double } %63, 1
  %66 = fneg double %65
  %67 = call ptr @_pCd(ptr noundef nonnull %9)
  %68 = getelementptr inbounds i8, ptr %67, i64 8
  store double %64, ptr %67, align 8
  store double %66, ptr %68, align 8
  %69 = load <2 x double>, ptr %15, align 16, !tbaa !12
  %70 = insertelement <2 x double> poison, double %29, i64 0
  %71 = shufflevector <2 x double> %70, <2 x double> poison, <2 x i32> zeroinitializer
  %72 = fmul <2 x double> %71, %69
  store <2 x double> %72, ptr %10, align 16, !tbaa !12
  %73 = load <2 x double>, ptr %9, align 16, !tbaa !12
  %74 = fadd <2 x double> %72, %73
  store <2 x double> %74, ptr %14, align 16, !tbaa !12
  %75 = call double @llvm.fmuladd.f64(double %36, double %27, double %45)
  %76 = fneg double %45
  %77 = call { double, double } @Cd(ptr noundef nonnull %14)
  %78 = extractvalue { double, double } %77, 1
  %79 = fmul double %40, %78
  %80 = extractelement <2 x double> %74, i64 0
  %81 = call double @llvm.fmuladd.f64(double %44, double %80, double %79)
  %82 = call double @llvm.fmuladd.f64(double %36, double %75, double %81)
  store double %82, ptr %26, align 8, !tbaa !9
  %83 = getelementptr inbounds i8, ptr %26, i64 8
  store double 0.000000e+00, ptr %83, align 8, !tbaa !13
  %84 = load double, ptr %13, align 16, !tbaa !9
  %85 = call { double, double } @Cd(ptr noundef nonnull %13)
  %86 = extractvalue { double, double } %85, 1
  %87 = fmul double %86, %41
  %88 = call double @llvm.fmuladd.f64(double %44, double %84, double %87)
  %89 = fneg double %88
  %90 = getelementptr inbounds i8, ptr %28, i64 8
  store double 0.000000e+00, ptr %90, align 8, !tbaa !13
  %91 = load <2 x double>, ptr %13, align 16, !tbaa !12
  %92 = fmul <2 x double> %49, %91
  store <2 x double> %92, ptr %9, align 16, !tbaa !12
  %93 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> <i32 poison, i32 0>
  %94 = insertelement <2 x double> %93, double %36, i64 0
  %95 = insertelement <2 x double> %70, double %33, i64 1
  %96 = insertelement <2 x double> poison, double %76, i64 0
  %97 = insertelement <2 x double> %96, double %46, i64 1
  %98 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %94, <2 x double> %95, <2 x double> %97)
  %99 = extractelement <2 x double> %98, i64 0
  %100 = call double @llvm.fmuladd.f64(double %36, double %99, double %89)
  store double %100, ptr %28, align 8, !tbaa !9
  %101 = call { double, double } @Cd(ptr noundef nonnull %15)
  %102 = extractvalue { double, double } %101, 0
  %103 = extractvalue { double, double } %101, 1
  %104 = fneg double %103
  %105 = call ptr @_pCd(ptr noundef nonnull %11)
  %106 = getelementptr inbounds i8, ptr %105, i64 8
  store double %102, ptr %105, align 8
  store double %104, ptr %106, align 8
  %107 = load <2 x double>, ptr %11, align 16
  %108 = load double, ptr %23, align 8, !tbaa !13
  %109 = fneg double %108
  %110 = insertelement <2 x double> poison, double %108, i64 0
  %111 = insertelement <2 x double> %110, double %109, i64 1
  %112 = fmul <2 x double> %98, %111
  %113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %114 = shufflevector <2 x double> %107, <2 x double> poison, <2 x i32> zeroinitializer
  %115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %98, <2 x double> %113)
  store <2 x double> %115, ptr %10, align 16, !tbaa !12
  %116 = load <2 x double>, ptr %9, align 16, !tbaa !12
  %117 = fadd <2 x double> %115, %116
  store <2 x double> %117, ptr %30, align 8, !tbaa !12
  %118 = load i32, ptr %4, align 4, !tbaa !5
  %119 = add nsw i32 %118, %.08991
  %120 = load i32, ptr %7, align 4, !tbaa !5
  %121 = add nsw i32 %120, %.08892
  %122 = add nuw i32 %.093, 1
  %exitcond.not = icmp eq i32 %.093, %22
  br i1 %exitcond.not, label %._crit_edge, label %24, !llvm.loop !14

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(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 double> @llvm.fmuladd.v2f64(<2 x double>, <2 x double>, <2 x double>) #4

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !11, i64 0}
!10 = !{!"", !11, i64 0, !11, i64 8}
!11 = !{!"double", !7, i64 0}
!12 = !{!11, !11, i64 0}
!13 = !{!10, !11, i64 8}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}


; Effective O3 passes: EarlyCSEPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,VectorCombinePass