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

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

%struct.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @cspr_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5) #0 {
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca %struct.complex, align 4
  %19 = alloca %struct.complex, align 4
  %20 = alloca i32, align 4
  %21 = alloca %struct.complex, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  store ptr %0, ptr %7, align 8, !tbaa !5
  store ptr %1, ptr %8, align 8, !tbaa !5
  store ptr %2, ptr %9, align 8, !tbaa !5
  store ptr %3, ptr %10, align 8, !tbaa !5
  store ptr %4, ptr %11, align 8, !tbaa !5
  store ptr %5, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  %30 = load ptr, ptr %12, align 8, !tbaa !5
  %31 = getelementptr inbounds %struct.complex, ptr %30, i32 -1
  store ptr %31, ptr %12, align 8, !tbaa !5
  %32 = load ptr, ptr %10, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.complex, ptr %32, i32 -1
  store ptr %33, ptr %10, align 8, !tbaa !5
  store i32 0, ptr %20, align 4, !tbaa !9
  %34 = load ptr, ptr %7, align 8, !tbaa !5
  %35 = call i32 @lsame_(ptr noundef %34, ptr noundef @.str)
  %36 = icmp ne i32 %35, 0
  br i1 %36, label %42, label %37

37:                                               ; preds = %6
  %38 = load ptr, ptr %7, align 8, !tbaa !5
  %39 = call i32 @lsame_(ptr noundef %38, ptr noundef @.str.1)
  %40 = icmp ne i32 %39, 0
  br i1 %40, label %42, label %41

41:                                               ; preds = %37
  store i32 1, ptr %20, align 4, !tbaa !9
  br label %54

42:                                               ; preds = %37, %6
  %43 = load ptr, ptr %8, align 8, !tbaa !5
  %44 = load i32, ptr %43, align 4, !tbaa !9
  %45 = icmp slt i32 %44, 0
  br i1 %45, label %46, label %47

46:                                               ; preds = %42
  store i32 2, ptr %20, align 4, !tbaa !9
  br label %53

47:                                               ; preds = %42
  %48 = load ptr, ptr %11, align 8, !tbaa !5
  %49 = load i32, ptr %48, align 4, !tbaa !9
  %50 = icmp eq i32 %49, 0
  br i1 %50, label %51, label %52

51:                                               ; preds = %47
  store i32 5, ptr %20, align 4, !tbaa !9
  br label %52

52:                                               ; preds = %51, %47
  br label %53

53:                                               ; preds = %52, %46
  br label %54

54:                                               ; preds = %53, %41
  %55 = load i32, ptr %20, align 4, !tbaa !9
  %56 = icmp ne i32 %55, 0
  br i1 %56, label %57, label %59

57:                                               ; preds = %54
  %58 = call i32 @xerbla_(ptr noundef @.str.2, ptr noundef %20, i32 noundef 6)
  store i32 1, ptr %29, align 4
  br label %1261

59:                                               ; preds = %54
  %60 = load ptr, ptr %8, align 8, !tbaa !5
  %61 = load i32, ptr %60, align 4, !tbaa !9
  %62 = icmp eq i32 %61, 0
  br i1 %62, label %73, label %63

63:                                               ; preds = %59
  %64 = load ptr, ptr %9, align 8, !tbaa !5
  %65 = getelementptr inbounds %struct.complex, ptr %64, i32 0, i32 0
  %66 = load float, ptr %65, align 4, !tbaa !11
  %67 = fcmp oeq float %66, 0.000000e+00
  br i1 %67, label %68, label %74

68:                                               ; preds = %63
  %69 = load ptr, ptr %9, align 8, !tbaa !5
  %70 = getelementptr inbounds %struct.complex, ptr %69, i32 0, i32 1
  %71 = load float, ptr %70, align 4, !tbaa !14
  %72 = fcmp oeq float %71, 0.000000e+00
  br i1 %72, label %73, label %74

73:                                               ; preds = %68, %59
  store i32 1, ptr %29, align 4
  br label %1261

74:                                               ; preds = %68, %63
  %75 = load ptr, ptr %11, align 8, !tbaa !5
  %76 = load i32, ptr %75, align 4, !tbaa !9
  %77 = icmp sle i32 %76, 0
  br i1 %77, label %78, label %86

78:                                               ; preds = %74
  %79 = load ptr, ptr %8, align 8, !tbaa !5
  %80 = load i32, ptr %79, align 4, !tbaa !9
  %81 = sub nsw i32 %80, 1
  %82 = load ptr, ptr %11, align 8, !tbaa !5
  %83 = load i32, ptr %82, align 4, !tbaa !9
  %84 = mul nsw i32 %81, %83
  %85 = sub nsw i32 1, %84
  store i32 %85, ptr %28, align 4, !tbaa !9
  br label %92

86:                                               ; preds = %74
  %87 = load ptr, ptr %11, align 8, !tbaa !5
  %88 = load i32, ptr %87, align 4, !tbaa !9
  %89 = icmp ne i32 %88, 1
  br i1 %89, label %90, label %91

90:                                               ; preds = %86
  store i32 1, ptr %28, align 4, !tbaa !9
  br label %91

91:                                               ; preds = %90, %86
  br label %92

92:                                               ; preds = %91, %78
  store i32 1, ptr %25, align 4, !tbaa !9
  %93 = load ptr, ptr %7, align 8, !tbaa !5
  %94 = call i32 @lsame_(ptr noundef %93, ptr noundef @.str)
  %95 = icmp ne i32 %94, 0
  br i1 %95, label %96, label %683

96:                                               ; preds = %92
  %97 = load ptr, ptr %11, align 8, !tbaa !5
  %98 = load i32, ptr %97, align 4, !tbaa !9
  %99 = icmp eq i32 %98, 1
  br i1 %99, label %100, label %386

100:                                              ; preds = %96
  %101 = load ptr, ptr %8, align 8, !tbaa !5
  %102 = load i32, ptr %101, align 4, !tbaa !9
  store i32 %102, ptr %13, align 4, !tbaa !9
  store i32 1, ptr %23, align 4, !tbaa !9
  br label %103

103:                                              ; preds = %382, %100
  %104 = load i32, ptr %23, align 4, !tbaa !9
  %105 = load i32, ptr %13, align 4, !tbaa !9
  %106 = icmp sle i32 %104, %105
  br i1 %106, label %107, label %385

107:                                              ; preds = %103
  %108 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %108, ptr %14, align 4, !tbaa !9
  %109 = load ptr, ptr %10, align 8, !tbaa !5
  %110 = load i32, ptr %14, align 4, !tbaa !9
  %111 = sext i32 %110 to i64
  %112 = getelementptr inbounds %struct.complex, ptr %109, i64 %111
  %113 = getelementptr inbounds %struct.complex, ptr %112, i32 0, i32 0
  %114 = load float, ptr %113, align 4, !tbaa !11
  %115 = fcmp une float %114, 0.000000e+00
  br i1 %115, label %124, label %116

116:                                              ; preds = %107
  %117 = load ptr, ptr %10, align 8, !tbaa !5
  %118 = load i32, ptr %14, align 4, !tbaa !9
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds %struct.complex, ptr %117, i64 %119
  %121 = getelementptr inbounds %struct.complex, ptr %120, i32 0, i32 1
  %122 = load float, ptr %121, align 4, !tbaa !14
  %123 = fcmp une float %122, 0.000000e+00
  br i1 %123, label %124, label %347

124:                                              ; preds = %116, %107
  %125 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %125, ptr %14, align 4, !tbaa !9
  %126 = load ptr, ptr %9, align 8, !tbaa !5
  %127 = getelementptr inbounds %struct.complex, ptr %126, i32 0, i32 0
  %128 = load float, ptr %127, align 4, !tbaa !11
  %129 = load ptr, ptr %10, align 8, !tbaa !5
  %130 = load i32, ptr %14, align 4, !tbaa !9
  %131 = sext i32 %130 to i64
  %132 = getelementptr inbounds %struct.complex, ptr %129, i64 %131
  %133 = getelementptr inbounds %struct.complex, ptr %132, i32 0, i32 0
  %134 = load float, ptr %133, align 4, !tbaa !11
  %135 = load ptr, ptr %9, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.complex, ptr %135, i32 0, i32 1
  %137 = load float, ptr %136, align 4, !tbaa !14
  %138 = load ptr, ptr %10, align 8, !tbaa !5
  %139 = load i32, ptr %14, align 4, !tbaa !9
  %140 = sext i32 %139 to i64
  %141 = getelementptr inbounds %struct.complex, ptr %138, i64 %140
  %142 = getelementptr inbounds %struct.complex, ptr %141, i32 0, i32 1
  %143 = load float, ptr %142, align 4, !tbaa !14
  %144 = fmul float %137, %143
  %145 = fneg float %144
  %146 = call float @llvm.fmuladd.f32(float %128, float %134, float %145)
  %147 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %146, ptr %147, align 4, !tbaa !11
  %148 = load ptr, ptr %9, align 8, !tbaa !5
  %149 = getelementptr inbounds %struct.complex, ptr %148, i32 0, i32 0
  %150 = load float, ptr %149, align 4, !tbaa !11
  %151 = load ptr, ptr %10, align 8, !tbaa !5
  %152 = load i32, ptr %14, align 4, !tbaa !9
  %153 = sext i32 %152 to i64
  %154 = getelementptr inbounds %struct.complex, ptr %151, i64 %153
  %155 = getelementptr inbounds %struct.complex, ptr %154, i32 0, i32 1
  %156 = load float, ptr %155, align 4, !tbaa !14
  %157 = load ptr, ptr %9, align 8, !tbaa !5
  %158 = getelementptr inbounds %struct.complex, ptr %157, i32 0, i32 1
  %159 = load float, ptr %158, align 4, !tbaa !14
  %160 = load ptr, ptr %10, align 8, !tbaa !5
  %161 = load i32, ptr %14, align 4, !tbaa !9
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds %struct.complex, ptr %160, i64 %162
  %164 = getelementptr inbounds %struct.complex, ptr %163, i32 0, i32 0
  %165 = load float, ptr %164, align 4, !tbaa !11
  %166 = fmul float %159, %165
  %167 = call float @llvm.fmuladd.f32(float %150, float %156, float %166)
  %168 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %167, ptr %168, align 4, !tbaa !14
  %169 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %170 = load float, ptr %169, align 4, !tbaa !11
  %171 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  store float %170, ptr %171, align 4, !tbaa !11
  %172 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %173 = load float, ptr %172, align 4, !tbaa !14
  %174 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  store float %173, ptr %174, align 4, !tbaa !14
  %175 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %175, ptr %24, align 4, !tbaa !9
  %176 = load i32, ptr %23, align 4, !tbaa !9
  %177 = sub nsw i32 %176, 1
  store i32 %177, ptr %14, align 4, !tbaa !9
  store i32 1, ptr %22, align 4, !tbaa !9
  br label %178

178:                                              ; preds = %261, %124
  %179 = load i32, ptr %22, align 4, !tbaa !9
  %180 = load i32, ptr %14, align 4, !tbaa !9
  %181 = icmp sle i32 %179, %180
  br i1 %181, label %182, label %264

182:                                              ; preds = %178
  %183 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %183, ptr %15, align 4, !tbaa !9
  %184 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %184, ptr %16, align 4, !tbaa !9
  %185 = load i32, ptr %22, align 4, !tbaa !9
  store i32 %185, ptr %17, align 4, !tbaa !9
  %186 = load ptr, ptr %10, align 8, !tbaa !5
  %187 = load i32, ptr %17, align 4, !tbaa !9
  %188 = sext i32 %187 to i64
  %189 = getelementptr inbounds %struct.complex, ptr %186, i64 %188
  %190 = getelementptr inbounds %struct.complex, ptr %189, i32 0, i32 0
  %191 = load float, ptr %190, align 4, !tbaa !11
  %192 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %193 = load float, ptr %192, align 4, !tbaa !11
  %194 = load ptr, ptr %10, align 8, !tbaa !5
  %195 = load i32, ptr %17, align 4, !tbaa !9
  %196 = sext i32 %195 to i64
  %197 = getelementptr inbounds %struct.complex, ptr %194, i64 %196
  %198 = getelementptr inbounds %struct.complex, ptr %197, i32 0, i32 1
  %199 = load float, ptr %198, align 4, !tbaa !14
  %200 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %201 = load float, ptr %200, align 4, !tbaa !14
  %202 = fmul float %199, %201
  %203 = fneg float %202
  %204 = call float @llvm.fmuladd.f32(float %191, float %193, float %203)
  %205 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %204, ptr %205, align 4, !tbaa !11
  %206 = load ptr, ptr %10, align 8, !tbaa !5
  %207 = load i32, ptr %17, align 4, !tbaa !9
  %208 = sext i32 %207 to i64
  %209 = getelementptr inbounds %struct.complex, ptr %206, i64 %208
  %210 = getelementptr inbounds %struct.complex, ptr %209, i32 0, i32 0
  %211 = load float, ptr %210, align 4, !tbaa !11
  %212 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %213 = load float, ptr %212, align 4, !tbaa !14
  %214 = load ptr, ptr %10, align 8, !tbaa !5
  %215 = load i32, ptr %17, align 4, !tbaa !9
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds %struct.complex, ptr %214, i64 %216
  %218 = getelementptr inbounds %struct.complex, ptr %217, i32 0, i32 1
  %219 = load float, ptr %218, align 4, !tbaa !14
  %220 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %221 = load float, ptr %220, align 4, !tbaa !11
  %222 = fmul float %219, %221
  %223 = call float @llvm.fmuladd.f32(float %211, float %213, float %222)
  %224 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %223, ptr %224, align 4, !tbaa !14
  %225 = load ptr, ptr %12, align 8, !tbaa !5
  %226 = load i32, ptr %16, align 4, !tbaa !9
  %227 = sext i32 %226 to i64
  %228 = getelementptr inbounds %struct.complex, ptr %225, i64 %227
  %229 = getelementptr inbounds %struct.complex, ptr %228, i32 0, i32 0
  %230 = load float, ptr %229, align 4, !tbaa !11
  %231 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %232 = load float, ptr %231, align 4, !tbaa !11
  %233 = fadd float %230, %232
  %234 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %233, ptr %234, align 4, !tbaa !11
  %235 = load ptr, ptr %12, align 8, !tbaa !5
  %236 = load i32, ptr %16, align 4, !tbaa !9
  %237 = sext i32 %236 to i64
  %238 = getelementptr inbounds %struct.complex, ptr %235, i64 %237
  %239 = getelementptr inbounds %struct.complex, ptr %238, i32 0, i32 1
  %240 = load float, ptr %239, align 4, !tbaa !14
  %241 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %242 = load float, ptr %241, align 4, !tbaa !14
  %243 = fadd float %240, %242
  %244 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %243, ptr %244, align 4, !tbaa !14
  %245 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %246 = load float, ptr %245, align 4, !tbaa !11
  %247 = load ptr, ptr %12, align 8, !tbaa !5
  %248 = load i32, ptr %15, align 4, !tbaa !9
  %249 = sext i32 %248 to i64
  %250 = getelementptr inbounds %struct.complex, ptr %247, i64 %249
  %251 = getelementptr inbounds %struct.complex, ptr %250, i32 0, i32 0
  store float %246, ptr %251, align 4, !tbaa !11
  %252 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %253 = load float, ptr %252, align 4, !tbaa !14
  %254 = load ptr, ptr %12, align 8, !tbaa !5
  %255 = load i32, ptr %15, align 4, !tbaa !9
  %256 = sext i32 %255 to i64
  %257 = getelementptr inbounds %struct.complex, ptr %254, i64 %256
  %258 = getelementptr inbounds %struct.complex, ptr %257, i32 0, i32 1
  store float %253, ptr %258, align 4, !tbaa !14
  %259 = load i32, ptr %24, align 4, !tbaa !9
  %260 = add nsw i32 %259, 1
  store i32 %260, ptr %24, align 4, !tbaa !9
  br label %261

261:                                              ; preds = %182
  %262 = load i32, ptr %22, align 4, !tbaa !9
  %263 = add nsw i32 %262, 1
  store i32 %263, ptr %22, align 4, !tbaa !9
  br label %178, !llvm.loop !15

264:                                              ; preds = %178
  %265 = load i32, ptr %25, align 4, !tbaa !9
  %266 = load i32, ptr %23, align 4, !tbaa !9
  %267 = add nsw i32 %265, %266
  %268 = sub nsw i32 %267, 1
  store i32 %268, ptr %14, align 4, !tbaa !9
  %269 = load i32, ptr %25, align 4, !tbaa !9
  %270 = load i32, ptr %23, align 4, !tbaa !9
  %271 = add nsw i32 %269, %270
  %272 = sub nsw i32 %271, 1
  store i32 %272, ptr %15, align 4, !tbaa !9
  %273 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %273, ptr %16, align 4, !tbaa !9
  %274 = load ptr, ptr %10, align 8, !tbaa !5
  %275 = load i32, ptr %16, align 4, !tbaa !9
  %276 = sext i32 %275 to i64
  %277 = getelementptr inbounds %struct.complex, ptr %274, i64 %276
  %278 = getelementptr inbounds %struct.complex, ptr %277, i32 0, i32 0
  %279 = load float, ptr %278, align 4, !tbaa !11
  %280 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %281 = load float, ptr %280, align 4, !tbaa !11
  %282 = load ptr, ptr %10, align 8, !tbaa !5
  %283 = load i32, ptr %16, align 4, !tbaa !9
  %284 = sext i32 %283 to i64
  %285 = getelementptr inbounds %struct.complex, ptr %282, i64 %284
  %286 = getelementptr inbounds %struct.complex, ptr %285, i32 0, i32 1
  %287 = load float, ptr %286, align 4, !tbaa !14
  %288 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %289 = load float, ptr %288, align 4, !tbaa !14
  %290 = fmul float %287, %289
  %291 = fneg float %290
  %292 = call float @llvm.fmuladd.f32(float %279, float %281, float %291)
  %293 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %292, ptr %293, align 4, !tbaa !11
  %294 = load ptr, ptr %10, align 8, !tbaa !5
  %295 = load i32, ptr %16, align 4, !tbaa !9
  %296 = sext i32 %295 to i64
  %297 = getelementptr inbounds %struct.complex, ptr %294, i64 %296
  %298 = getelementptr inbounds %struct.complex, ptr %297, i32 0, i32 0
  %299 = load float, ptr %298, align 4, !tbaa !11
  %300 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %301 = load float, ptr %300, align 4, !tbaa !14
  %302 = load ptr, ptr %10, align 8, !tbaa !5
  %303 = load i32, ptr %16, align 4, !tbaa !9
  %304 = sext i32 %303 to i64
  %305 = getelementptr inbounds %struct.complex, ptr %302, i64 %304
  %306 = getelementptr inbounds %struct.complex, ptr %305, i32 0, i32 1
  %307 = load float, ptr %306, align 4, !tbaa !14
  %308 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %309 = load float, ptr %308, align 4, !tbaa !11
  %310 = fmul float %307, %309
  %311 = call float @llvm.fmuladd.f32(float %299, float %301, float %310)
  %312 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %311, ptr %312, align 4, !tbaa !14
  %313 = load ptr, ptr %12, align 8, !tbaa !5
  %314 = load i32, ptr %15, align 4, !tbaa !9
  %315 = sext i32 %314 to i64
  %316 = getelementptr inbounds %struct.complex, ptr %313, i64 %315
  %317 = getelementptr inbounds %struct.complex, ptr %316, i32 0, i32 0
  %318 = load float, ptr %317, align 4, !tbaa !11
  %319 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %320 = load float, ptr %319, align 4, !tbaa !11
  %321 = fadd float %318, %320
  %322 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %321, ptr %322, align 4, !tbaa !11
  %323 = load ptr, ptr %12, align 8, !tbaa !5
  %324 = load i32, ptr %15, align 4, !tbaa !9
  %325 = sext i32 %324 to i64
  %326 = getelementptr inbounds %struct.complex, ptr %323, i64 %325
  %327 = getelementptr inbounds %struct.complex, ptr %326, i32 0, i32 1
  %328 = load float, ptr %327, align 4, !tbaa !14
  %329 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %330 = load float, ptr %329, align 4, !tbaa !14
  %331 = fadd float %328, %330
  %332 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %331, ptr %332, align 4, !tbaa !14
  %333 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %334 = load float, ptr %333, align 4, !tbaa !11
  %335 = load ptr, ptr %12, align 8, !tbaa !5
  %336 = load i32, ptr %14, align 4, !tbaa !9
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds %struct.complex, ptr %335, i64 %337
  %339 = getelementptr inbounds %struct.complex, ptr %338, i32 0, i32 0
  store float %334, ptr %339, align 4, !tbaa !11
  %340 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %341 = load float, ptr %340, align 4, !tbaa !14
  %342 = load ptr, ptr %12, align 8, !tbaa !5
  %343 = load i32, ptr %14, align 4, !tbaa !9
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds %struct.complex, ptr %342, i64 %344
  %346 = getelementptr inbounds %struct.complex, ptr %345, i32 0, i32 1
  store float %341, ptr %346, align 4, !tbaa !14
  br label %378

347:                                              ; preds = %116
  %348 = load i32, ptr %25, align 4, !tbaa !9
  %349 = load i32, ptr %23, align 4, !tbaa !9
  %350 = add nsw i32 %348, %349
  %351 = sub nsw i32 %350, 1
  store i32 %351, ptr %14, align 4, !tbaa !9
  %352 = load i32, ptr %25, align 4, !tbaa !9
  %353 = load i32, ptr %23, align 4, !tbaa !9
  %354 = add nsw i32 %352, %353
  %355 = sub nsw i32 %354, 1
  store i32 %355, ptr %15, align 4, !tbaa !9
  %356 = load ptr, ptr %12, align 8, !tbaa !5
  %357 = load i32, ptr %15, align 4, !tbaa !9
  %358 = sext i32 %357 to i64
  %359 = getelementptr inbounds %struct.complex, ptr %356, i64 %358
  %360 = getelementptr inbounds %struct.complex, ptr %359, i32 0, i32 0
  %361 = load float, ptr %360, align 4, !tbaa !11
  %362 = load ptr, ptr %12, align 8, !tbaa !5
  %363 = load i32, ptr %14, align 4, !tbaa !9
  %364 = sext i32 %363 to i64
  %365 = getelementptr inbounds %struct.complex, ptr %362, i64 %364
  %366 = getelementptr inbounds %struct.complex, ptr %365, i32 0, i32 0
  store float %361, ptr %366, align 4, !tbaa !11
  %367 = load ptr, ptr %12, align 8, !tbaa !5
  %368 = load i32, ptr %15, align 4, !tbaa !9
  %369 = sext i32 %368 to i64
  %370 = getelementptr inbounds %struct.complex, ptr %367, i64 %369
  %371 = getelementptr inbounds %struct.complex, ptr %370, i32 0, i32 1
  %372 = load float, ptr %371, align 4, !tbaa !14
  %373 = load ptr, ptr %12, align 8, !tbaa !5
  %374 = load i32, ptr %14, align 4, !tbaa !9
  %375 = sext i32 %374 to i64
  %376 = getelementptr inbounds %struct.complex, ptr %373, i64 %375
  %377 = getelementptr inbounds %struct.complex, ptr %376, i32 0, i32 1
  store float %372, ptr %377, align 4, !tbaa !14
  br label %378

378:                                              ; preds = %347, %264
  %379 = load i32, ptr %23, align 4, !tbaa !9
  %380 = load i32, ptr %25, align 4, !tbaa !9
  %381 = add nsw i32 %380, %379
  store i32 %381, ptr %25, align 4, !tbaa !9
  br label %382

382:                                              ; preds = %378
  %383 = load i32, ptr %23, align 4, !tbaa !9
  %384 = add nsw i32 %383, 1
  store i32 %384, ptr %23, align 4, !tbaa !9
  br label %103, !llvm.loop !17

385:                                              ; preds = %103
  br label %682

386:                                              ; preds = %96
  %387 = load i32, ptr %28, align 4, !tbaa !9
  store i32 %387, ptr %27, align 4, !tbaa !9
  %388 = load ptr, ptr %8, align 8, !tbaa !5
  %389 = load i32, ptr %388, align 4, !tbaa !9
  store i32 %389, ptr %13, align 4, !tbaa !9
  store i32 1, ptr %23, align 4, !tbaa !9
  br label %390

390:                                              ; preds = %678, %386
  %391 = load i32, ptr %23, align 4, !tbaa !9
  %392 = load i32, ptr %13, align 4, !tbaa !9
  %393 = icmp sle i32 %391, %392
  br i1 %393, label %394, label %681

394:                                              ; preds = %390
  %395 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %395, ptr %14, align 4, !tbaa !9
  %396 = load ptr, ptr %10, align 8, !tbaa !5
  %397 = load i32, ptr %14, align 4, !tbaa !9
  %398 = sext i32 %397 to i64
  %399 = getelementptr inbounds %struct.complex, ptr %396, i64 %398
  %400 = getelementptr inbounds %struct.complex, ptr %399, i32 0, i32 0
  %401 = load float, ptr %400, align 4, !tbaa !11
  %402 = fcmp une float %401, 0.000000e+00
  br i1 %402, label %411, label %403

403:                                              ; preds = %394
  %404 = load ptr, ptr %10, align 8, !tbaa !5
  %405 = load i32, ptr %14, align 4, !tbaa !9
  %406 = sext i32 %405 to i64
  %407 = getelementptr inbounds %struct.complex, ptr %404, i64 %406
  %408 = getelementptr inbounds %struct.complex, ptr %407, i32 0, i32 1
  %409 = load float, ptr %408, align 4, !tbaa !14
  %410 = fcmp une float %409, 0.000000e+00
  br i1 %410, label %411, label %639

411:                                              ; preds = %403, %394
  %412 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %412, ptr %14, align 4, !tbaa !9
  %413 = load ptr, ptr %9, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.complex, ptr %413, i32 0, i32 0
  %415 = load float, ptr %414, align 4, !tbaa !11
  %416 = load ptr, ptr %10, align 8, !tbaa !5
  %417 = load i32, ptr %14, align 4, !tbaa !9
  %418 = sext i32 %417 to i64
  %419 = getelementptr inbounds %struct.complex, ptr %416, i64 %418
  %420 = getelementptr inbounds %struct.complex, ptr %419, i32 0, i32 0
  %421 = load float, ptr %420, align 4, !tbaa !11
  %422 = load ptr, ptr %9, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.complex, ptr %422, i32 0, i32 1
  %424 = load float, ptr %423, align 4, !tbaa !14
  %425 = load ptr, ptr %10, align 8, !tbaa !5
  %426 = load i32, ptr %14, align 4, !tbaa !9
  %427 = sext i32 %426 to i64
  %428 = getelementptr inbounds %struct.complex, ptr %425, i64 %427
  %429 = getelementptr inbounds %struct.complex, ptr %428, i32 0, i32 1
  %430 = load float, ptr %429, align 4, !tbaa !14
  %431 = fmul float %424, %430
  %432 = fneg float %431
  %433 = call float @llvm.fmuladd.f32(float %415, float %421, float %432)
  %434 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %433, ptr %434, align 4, !tbaa !11
  %435 = load ptr, ptr %9, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.complex, ptr %435, i32 0, i32 0
  %437 = load float, ptr %436, align 4, !tbaa !11
  %438 = load ptr, ptr %10, align 8, !tbaa !5
  %439 = load i32, ptr %14, align 4, !tbaa !9
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds %struct.complex, ptr %438, i64 %440
  %442 = getelementptr inbounds %struct.complex, ptr %441, i32 0, i32 1
  %443 = load float, ptr %442, align 4, !tbaa !14
  %444 = load ptr, ptr %9, align 8, !tbaa !5
  %445 = getelementptr inbounds %struct.complex, ptr %444, i32 0, i32 1
  %446 = load float, ptr %445, align 4, !tbaa !14
  %447 = load ptr, ptr %10, align 8, !tbaa !5
  %448 = load i32, ptr %14, align 4, !tbaa !9
  %449 = sext i32 %448 to i64
  %450 = getelementptr inbounds %struct.complex, ptr %447, i64 %449
  %451 = getelementptr inbounds %struct.complex, ptr %450, i32 0, i32 0
  %452 = load float, ptr %451, align 4, !tbaa !11
  %453 = fmul float %446, %452
  %454 = call float @llvm.fmuladd.f32(float %437, float %443, float %453)
  %455 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %454, ptr %455, align 4, !tbaa !14
  %456 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %457 = load float, ptr %456, align 4, !tbaa !11
  %458 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  store float %457, ptr %458, align 4, !tbaa !11
  %459 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %460 = load float, ptr %459, align 4, !tbaa !14
  %461 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  store float %460, ptr %461, align 4, !tbaa !14
  %462 = load i32, ptr %28, align 4, !tbaa !9
  store i32 %462, ptr %26, align 4, !tbaa !9
  %463 = load i32, ptr %25, align 4, !tbaa !9
  %464 = load i32, ptr %23, align 4, !tbaa !9
  %465 = add nsw i32 %463, %464
  %466 = sub nsw i32 %465, 2
  store i32 %466, ptr %14, align 4, !tbaa !9
  %467 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %467, ptr %24, align 4, !tbaa !9
  br label %468

468:                                              ; preds = %553, %411
  %469 = load i32, ptr %24, align 4, !tbaa !9
  %470 = load i32, ptr %14, align 4, !tbaa !9
  %471 = icmp sle i32 %469, %470
  br i1 %471, label %472, label %556

472:                                              ; preds = %468
  %473 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %473, ptr %15, align 4, !tbaa !9
  %474 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %474, ptr %16, align 4, !tbaa !9
  %475 = load i32, ptr %26, align 4, !tbaa !9
  store i32 %475, ptr %17, align 4, !tbaa !9
  %476 = load ptr, ptr %10, align 8, !tbaa !5
  %477 = load i32, ptr %17, align 4, !tbaa !9
  %478 = sext i32 %477 to i64
  %479 = getelementptr inbounds %struct.complex, ptr %476, i64 %478
  %480 = getelementptr inbounds %struct.complex, ptr %479, i32 0, i32 0
  %481 = load float, ptr %480, align 4, !tbaa !11
  %482 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %483 = load float, ptr %482, align 4, !tbaa !11
  %484 = load ptr, ptr %10, align 8, !tbaa !5
  %485 = load i32, ptr %17, align 4, !tbaa !9
  %486 = sext i32 %485 to i64
  %487 = getelementptr inbounds %struct.complex, ptr %484, i64 %486
  %488 = getelementptr inbounds %struct.complex, ptr %487, i32 0, i32 1
  %489 = load float, ptr %488, align 4, !tbaa !14
  %490 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %491 = load float, ptr %490, align 4, !tbaa !14
  %492 = fmul float %489, %491
  %493 = fneg float %492
  %494 = call float @llvm.fmuladd.f32(float %481, float %483, float %493)
  %495 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %494, ptr %495, align 4, !tbaa !11
  %496 = load ptr, ptr %10, align 8, !tbaa !5
  %497 = load i32, ptr %17, align 4, !tbaa !9
  %498 = sext i32 %497 to i64
  %499 = getelementptr inbounds %struct.complex, ptr %496, i64 %498
  %500 = getelementptr inbounds %struct.complex, ptr %499, i32 0, i32 0
  %501 = load float, ptr %500, align 4, !tbaa !11
  %502 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %503 = load float, ptr %502, align 4, !tbaa !14
  %504 = load ptr, ptr %10, align 8, !tbaa !5
  %505 = load i32, ptr %17, align 4, !tbaa !9
  %506 = sext i32 %505 to i64
  %507 = getelementptr inbounds %struct.complex, ptr %504, i64 %506
  %508 = getelementptr inbounds %struct.complex, ptr %507, i32 0, i32 1
  %509 = load float, ptr %508, align 4, !tbaa !14
  %510 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %511 = load float, ptr %510, align 4, !tbaa !11
  %512 = fmul float %509, %511
  %513 = call float @llvm.fmuladd.f32(float %501, float %503, float %512)
  %514 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %513, ptr %514, align 4, !tbaa !14
  %515 = load ptr, ptr %12, align 8, !tbaa !5
  %516 = load i32, ptr %16, align 4, !tbaa !9
  %517 = sext i32 %516 to i64
  %518 = getelementptr inbounds %struct.complex, ptr %515, i64 %517
  %519 = getelementptr inbounds %struct.complex, ptr %518, i32 0, i32 0
  %520 = load float, ptr %519, align 4, !tbaa !11
  %521 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %522 = load float, ptr %521, align 4, !tbaa !11
  %523 = fadd float %520, %522
  %524 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %523, ptr %524, align 4, !tbaa !11
  %525 = load ptr, ptr %12, align 8, !tbaa !5
  %526 = load i32, ptr %16, align 4, !tbaa !9
  %527 = sext i32 %526 to i64
  %528 = getelementptr inbounds %struct.complex, ptr %525, i64 %527
  %529 = getelementptr inbounds %struct.complex, ptr %528, i32 0, i32 1
  %530 = load float, ptr %529, align 4, !tbaa !14
  %531 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %532 = load float, ptr %531, align 4, !tbaa !14
  %533 = fadd float %530, %532
  %534 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %533, ptr %534, align 4, !tbaa !14
  %535 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %536 = load float, ptr %535, align 4, !tbaa !11
  %537 = load ptr, ptr %12, align 8, !tbaa !5
  %538 = load i32, ptr %15, align 4, !tbaa !9
  %539 = sext i32 %538 to i64
  %540 = getelementptr inbounds %struct.complex, ptr %537, i64 %539
  %541 = getelementptr inbounds %struct.complex, ptr %540, i32 0, i32 0
  store float %536, ptr %541, align 4, !tbaa !11
  %542 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %543 = load float, ptr %542, align 4, !tbaa !14
  %544 = load ptr, ptr %12, align 8, !tbaa !5
  %545 = load i32, ptr %15, align 4, !tbaa !9
  %546 = sext i32 %545 to i64
  %547 = getelementptr inbounds %struct.complex, ptr %544, i64 %546
  %548 = getelementptr inbounds %struct.complex, ptr %547, i32 0, i32 1
  store float %543, ptr %548, align 4, !tbaa !14
  %549 = load ptr, ptr %11, align 8, !tbaa !5
  %550 = load i32, ptr %549, align 4, !tbaa !9
  %551 = load i32, ptr %26, align 4, !tbaa !9
  %552 = add nsw i32 %551, %550
  store i32 %552, ptr %26, align 4, !tbaa !9
  br label %553

553:                                              ; preds = %472
  %554 = load i32, ptr %24, align 4, !tbaa !9
  %555 = add nsw i32 %554, 1
  store i32 %555, ptr %24, align 4, !tbaa !9
  br label %468, !llvm.loop !18

556:                                              ; preds = %468
  %557 = load i32, ptr %25, align 4, !tbaa !9
  %558 = load i32, ptr %23, align 4, !tbaa !9
  %559 = add nsw i32 %557, %558
  %560 = sub nsw i32 %559, 1
  store i32 %560, ptr %14, align 4, !tbaa !9
  %561 = load i32, ptr %25, align 4, !tbaa !9
  %562 = load i32, ptr %23, align 4, !tbaa !9
  %563 = add nsw i32 %561, %562
  %564 = sub nsw i32 %563, 1
  store i32 %564, ptr %15, align 4, !tbaa !9
  %565 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %565, ptr %16, align 4, !tbaa !9
  %566 = load ptr, ptr %10, align 8, !tbaa !5
  %567 = load i32, ptr %16, align 4, !tbaa !9
  %568 = sext i32 %567 to i64
  %569 = getelementptr inbounds %struct.complex, ptr %566, i64 %568
  %570 = getelementptr inbounds %struct.complex, ptr %569, i32 0, i32 0
  %571 = load float, ptr %570, align 4, !tbaa !11
  %572 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %573 = load float, ptr %572, align 4, !tbaa !11
  %574 = load ptr, ptr %10, align 8, !tbaa !5
  %575 = load i32, ptr %16, align 4, !tbaa !9
  %576 = sext i32 %575 to i64
  %577 = getelementptr inbounds %struct.complex, ptr %574, i64 %576
  %578 = getelementptr inbounds %struct.complex, ptr %577, i32 0, i32 1
  %579 = load float, ptr %578, align 4, !tbaa !14
  %580 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %581 = load float, ptr %580, align 4, !tbaa !14
  %582 = fmul float %579, %581
  %583 = fneg float %582
  %584 = call float @llvm.fmuladd.f32(float %571, float %573, float %583)
  %585 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %584, ptr %585, align 4, !tbaa !11
  %586 = load ptr, ptr %10, align 8, !tbaa !5
  %587 = load i32, ptr %16, align 4, !tbaa !9
  %588 = sext i32 %587 to i64
  %589 = getelementptr inbounds %struct.complex, ptr %586, i64 %588
  %590 = getelementptr inbounds %struct.complex, ptr %589, i32 0, i32 0
  %591 = load float, ptr %590, align 4, !tbaa !11
  %592 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %593 = load float, ptr %592, align 4, !tbaa !14
  %594 = load ptr, ptr %10, align 8, !tbaa !5
  %595 = load i32, ptr %16, align 4, !tbaa !9
  %596 = sext i32 %595 to i64
  %597 = getelementptr inbounds %struct.complex, ptr %594, i64 %596
  %598 = getelementptr inbounds %struct.complex, ptr %597, i32 0, i32 1
  %599 = load float, ptr %598, align 4, !tbaa !14
  %600 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %601 = load float, ptr %600, align 4, !tbaa !11
  %602 = fmul float %599, %601
  %603 = call float @llvm.fmuladd.f32(float %591, float %593, float %602)
  %604 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %603, ptr %604, align 4, !tbaa !14
  %605 = load ptr, ptr %12, align 8, !tbaa !5
  %606 = load i32, ptr %15, align 4, !tbaa !9
  %607 = sext i32 %606 to i64
  %608 = getelementptr inbounds %struct.complex, ptr %605, i64 %607
  %609 = getelementptr inbounds %struct.complex, ptr %608, i32 0, i32 0
  %610 = load float, ptr %609, align 4, !tbaa !11
  %611 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %612 = load float, ptr %611, align 4, !tbaa !11
  %613 = fadd float %610, %612
  %614 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %613, ptr %614, align 4, !tbaa !11
  %615 = load ptr, ptr %12, align 8, !tbaa !5
  %616 = load i32, ptr %15, align 4, !tbaa !9
  %617 = sext i32 %616 to i64
  %618 = getelementptr inbounds %struct.complex, ptr %615, i64 %617
  %619 = getelementptr inbounds %struct.complex, ptr %618, i32 0, i32 1
  %620 = load float, ptr %619, align 4, !tbaa !14
  %621 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %622 = load float, ptr %621, align 4, !tbaa !14
  %623 = fadd float %620, %622
  %624 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %623, ptr %624, align 4, !tbaa !14
  %625 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %626 = load float, ptr %625, align 4, !tbaa !11
  %627 = load ptr, ptr %12, align 8, !tbaa !5
  %628 = load i32, ptr %14, align 4, !tbaa !9
  %629 = sext i32 %628 to i64
  %630 = getelementptr inbounds %struct.complex, ptr %627, i64 %629
  %631 = getelementptr inbounds %struct.complex, ptr %630, i32 0, i32 0
  store float %626, ptr %631, align 4, !tbaa !11
  %632 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %633 = load float, ptr %632, align 4, !tbaa !14
  %634 = load ptr, ptr %12, align 8, !tbaa !5
  %635 = load i32, ptr %14, align 4, !tbaa !9
  %636 = sext i32 %635 to i64
  %637 = getelementptr inbounds %struct.complex, ptr %634, i64 %636
  %638 = getelementptr inbounds %struct.complex, ptr %637, i32 0, i32 1
  store float %633, ptr %638, align 4, !tbaa !14
  br label %670

639:                                              ; preds = %403
  %640 = load i32, ptr %25, align 4, !tbaa !9
  %641 = load i32, ptr %23, align 4, !tbaa !9
  %642 = add nsw i32 %640, %641
  %643 = sub nsw i32 %642, 1
  store i32 %643, ptr %14, align 4, !tbaa !9
  %644 = load i32, ptr %25, align 4, !tbaa !9
  %645 = load i32, ptr %23, align 4, !tbaa !9
  %646 = add nsw i32 %644, %645
  %647 = sub nsw i32 %646, 1
  store i32 %647, ptr %15, align 4, !tbaa !9
  %648 = load ptr, ptr %12, align 8, !tbaa !5
  %649 = load i32, ptr %15, align 4, !tbaa !9
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds %struct.complex, ptr %648, i64 %650
  %652 = getelementptr inbounds %struct.complex, ptr %651, i32 0, i32 0
  %653 = load float, ptr %652, align 4, !tbaa !11
  %654 = load ptr, ptr %12, align 8, !tbaa !5
  %655 = load i32, ptr %14, align 4, !tbaa !9
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds %struct.complex, ptr %654, i64 %656
  %658 = getelementptr inbounds %struct.complex, ptr %657, i32 0, i32 0
  store float %653, ptr %658, align 4, !tbaa !11
  %659 = load ptr, ptr %12, align 8, !tbaa !5
  %660 = load i32, ptr %15, align 4, !tbaa !9
  %661 = sext i32 %660 to i64
  %662 = getelementptr inbounds %struct.complex, ptr %659, i64 %661
  %663 = getelementptr inbounds %struct.complex, ptr %662, i32 0, i32 1
  %664 = load float, ptr %663, align 4, !tbaa !14
  %665 = load ptr, ptr %12, align 8, !tbaa !5
  %666 = load i32, ptr %14, align 4, !tbaa !9
  %667 = sext i32 %666 to i64
  %668 = getelementptr inbounds %struct.complex, ptr %665, i64 %667
  %669 = getelementptr inbounds %struct.complex, ptr %668, i32 0, i32 1
  store float %664, ptr %669, align 4, !tbaa !14
  br label %670

670:                                              ; preds = %639, %556
  %671 = load ptr, ptr %11, align 8, !tbaa !5
  %672 = load i32, ptr %671, align 4, !tbaa !9
  %673 = load i32, ptr %27, align 4, !tbaa !9
  %674 = add nsw i32 %673, %672
  store i32 %674, ptr %27, align 4, !tbaa !9
  %675 = load i32, ptr %23, align 4, !tbaa !9
  %676 = load i32, ptr %25, align 4, !tbaa !9
  %677 = add nsw i32 %676, %675
  store i32 %677, ptr %25, align 4, !tbaa !9
  br label %678

678:                                              ; preds = %670
  %679 = load i32, ptr %23, align 4, !tbaa !9
  %680 = add nsw i32 %679, 1
  store i32 %680, ptr %23, align 4, !tbaa !9
  br label %390, !llvm.loop !19

681:                                              ; preds = %390
  br label %682

682:                                              ; preds = %681, %385
  br label %1260

683:                                              ; preds = %92
  %684 = load ptr, ptr %11, align 8, !tbaa !5
  %685 = load i32, ptr %684, align 4, !tbaa !9
  %686 = icmp eq i32 %685, 1
  br i1 %686, label %687, label %968

687:                                              ; preds = %683
  %688 = load ptr, ptr %8, align 8, !tbaa !5
  %689 = load i32, ptr %688, align 4, !tbaa !9
  store i32 %689, ptr %13, align 4, !tbaa !9
  store i32 1, ptr %23, align 4, !tbaa !9
  br label %690

690:                                              ; preds = %964, %687
  %691 = load i32, ptr %23, align 4, !tbaa !9
  %692 = load i32, ptr %13, align 4, !tbaa !9
  %693 = icmp sle i32 %691, %692
  br i1 %693, label %694, label %967

694:                                              ; preds = %690
  %695 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %695, ptr %14, align 4, !tbaa !9
  %696 = load ptr, ptr %10, align 8, !tbaa !5
  %697 = load i32, ptr %14, align 4, !tbaa !9
  %698 = sext i32 %697 to i64
  %699 = getelementptr inbounds %struct.complex, ptr %696, i64 %698
  %700 = getelementptr inbounds %struct.complex, ptr %699, i32 0, i32 0
  %701 = load float, ptr %700, align 4, !tbaa !11
  %702 = fcmp une float %701, 0.000000e+00
  br i1 %702, label %711, label %703

703:                                              ; preds = %694
  %704 = load ptr, ptr %10, align 8, !tbaa !5
  %705 = load i32, ptr %14, align 4, !tbaa !9
  %706 = sext i32 %705 to i64
  %707 = getelementptr inbounds %struct.complex, ptr %704, i64 %706
  %708 = getelementptr inbounds %struct.complex, ptr %707, i32 0, i32 1
  %709 = load float, ptr %708, align 4, !tbaa !14
  %710 = fcmp une float %709, 0.000000e+00
  br i1 %710, label %711, label %931

711:                                              ; preds = %703, %694
  %712 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %712, ptr %14, align 4, !tbaa !9
  %713 = load ptr, ptr %9, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.complex, ptr %713, i32 0, i32 0
  %715 = load float, ptr %714, align 4, !tbaa !11
  %716 = load ptr, ptr %10, align 8, !tbaa !5
  %717 = load i32, ptr %14, align 4, !tbaa !9
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds %struct.complex, ptr %716, i64 %718
  %720 = getelementptr inbounds %struct.complex, ptr %719, i32 0, i32 0
  %721 = load float, ptr %720, align 4, !tbaa !11
  %722 = load ptr, ptr %9, align 8, !tbaa !5
  %723 = getelementptr inbounds %struct.complex, ptr %722, i32 0, i32 1
  %724 = load float, ptr %723, align 4, !tbaa !14
  %725 = load ptr, ptr %10, align 8, !tbaa !5
  %726 = load i32, ptr %14, align 4, !tbaa !9
  %727 = sext i32 %726 to i64
  %728 = getelementptr inbounds %struct.complex, ptr %725, i64 %727
  %729 = getelementptr inbounds %struct.complex, ptr %728, i32 0, i32 1
  %730 = load float, ptr %729, align 4, !tbaa !14
  %731 = fmul float %724, %730
  %732 = fneg float %731
  %733 = call float @llvm.fmuladd.f32(float %715, float %721, float %732)
  %734 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %733, ptr %734, align 4, !tbaa !11
  %735 = load ptr, ptr %9, align 8, !tbaa !5
  %736 = getelementptr inbounds %struct.complex, ptr %735, i32 0, i32 0
  %737 = load float, ptr %736, align 4, !tbaa !11
  %738 = load ptr, ptr %10, align 8, !tbaa !5
  %739 = load i32, ptr %14, align 4, !tbaa !9
  %740 = sext i32 %739 to i64
  %741 = getelementptr inbounds %struct.complex, ptr %738, i64 %740
  %742 = getelementptr inbounds %struct.complex, ptr %741, i32 0, i32 1
  %743 = load float, ptr %742, align 4, !tbaa !14
  %744 = load ptr, ptr %9, align 8, !tbaa !5
  %745 = getelementptr inbounds %struct.complex, ptr %744, i32 0, i32 1
  %746 = load float, ptr %745, align 4, !tbaa !14
  %747 = load ptr, ptr %10, align 8, !tbaa !5
  %748 = load i32, ptr %14, align 4, !tbaa !9
  %749 = sext i32 %748 to i64
  %750 = getelementptr inbounds %struct.complex, ptr %747, i64 %749
  %751 = getelementptr inbounds %struct.complex, ptr %750, i32 0, i32 0
  %752 = load float, ptr %751, align 4, !tbaa !11
  %753 = fmul float %746, %752
  %754 = call float @llvm.fmuladd.f32(float %737, float %743, float %753)
  %755 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %754, ptr %755, align 4, !tbaa !14
  %756 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %757 = load float, ptr %756, align 4, !tbaa !11
  %758 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  store float %757, ptr %758, align 4, !tbaa !11
  %759 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %760 = load float, ptr %759, align 4, !tbaa !14
  %761 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  store float %760, ptr %761, align 4, !tbaa !14
  %762 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %762, ptr %14, align 4, !tbaa !9
  %763 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %763, ptr %15, align 4, !tbaa !9
  %764 = load i32, ptr %23, align 4, !tbaa !9
  store i32 %764, ptr %16, align 4, !tbaa !9
  %765 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %766 = load float, ptr %765, align 4, !tbaa !11
  %767 = load ptr, ptr %10, align 8, !tbaa !5
  %768 = load i32, ptr %16, align 4, !tbaa !9
  %769 = sext i32 %768 to i64
  %770 = getelementptr inbounds %struct.complex, ptr %767, i64 %769
  %771 = getelementptr inbounds %struct.complex, ptr %770, i32 0, i32 0
  %772 = load float, ptr %771, align 4, !tbaa !11
  %773 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %774 = load float, ptr %773, align 4, !tbaa !14
  %775 = load ptr, ptr %10, align 8, !tbaa !5
  %776 = load i32, ptr %16, align 4, !tbaa !9
  %777 = sext i32 %776 to i64
  %778 = getelementptr inbounds %struct.complex, ptr %775, i64 %777
  %779 = getelementptr inbounds %struct.complex, ptr %778, i32 0, i32 1
  %780 = load float, ptr %779, align 4, !tbaa !14
  %781 = fmul float %774, %780
  %782 = fneg float %781
  %783 = call float @llvm.fmuladd.f32(float %766, float %772, float %782)
  %784 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %783, ptr %784, align 4, !tbaa !11
  %785 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %786 = load float, ptr %785, align 4, !tbaa !11
  %787 = load ptr, ptr %10, align 8, !tbaa !5
  %788 = load i32, ptr %16, align 4, !tbaa !9
  %789 = sext i32 %788 to i64
  %790 = getelementptr inbounds %struct.complex, ptr %787, i64 %789
  %791 = getelementptr inbounds %struct.complex, ptr %790, i32 0, i32 1
  %792 = load float, ptr %791, align 4, !tbaa !14
  %793 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %794 = load float, ptr %793, align 4, !tbaa !14
  %795 = load ptr, ptr %10, align 8, !tbaa !5
  %796 = load i32, ptr %16, align 4, !tbaa !9
  %797 = sext i32 %796 to i64
  %798 = getelementptr inbounds %struct.complex, ptr %795, i64 %797
  %799 = getelementptr inbounds %struct.complex, ptr %798, i32 0, i32 0
  %800 = load float, ptr %799, align 4, !tbaa !11
  %801 = fmul float %794, %800
  %802 = call float @llvm.fmuladd.f32(float %786, float %792, float %801)
  %803 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %802, ptr %803, align 4, !tbaa !14
  %804 = load ptr, ptr %12, align 8, !tbaa !5
  %805 = load i32, ptr %15, align 4, !tbaa !9
  %806 = sext i32 %805 to i64
  %807 = getelementptr inbounds %struct.complex, ptr %804, i64 %806
  %808 = getelementptr inbounds %struct.complex, ptr %807, i32 0, i32 0
  %809 = load float, ptr %808, align 4, !tbaa !11
  %810 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %811 = load float, ptr %810, align 4, !tbaa !11
  %812 = fadd float %809, %811
  %813 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %812, ptr %813, align 4, !tbaa !11
  %814 = load ptr, ptr %12, align 8, !tbaa !5
  %815 = load i32, ptr %15, align 4, !tbaa !9
  %816 = sext i32 %815 to i64
  %817 = getelementptr inbounds %struct.complex, ptr %814, i64 %816
  %818 = getelementptr inbounds %struct.complex, ptr %817, i32 0, i32 1
  %819 = load float, ptr %818, align 4, !tbaa !14
  %820 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %821 = load float, ptr %820, align 4, !tbaa !14
  %822 = fadd float %819, %821
  %823 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %822, ptr %823, align 4, !tbaa !14
  %824 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %825 = load float, ptr %824, align 4, !tbaa !11
  %826 = load ptr, ptr %12, align 8, !tbaa !5
  %827 = load i32, ptr %14, align 4, !tbaa !9
  %828 = sext i32 %827 to i64
  %829 = getelementptr inbounds %struct.complex, ptr %826, i64 %828
  %830 = getelementptr inbounds %struct.complex, ptr %829, i32 0, i32 0
  store float %825, ptr %830, align 4, !tbaa !11
  %831 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %832 = load float, ptr %831, align 4, !tbaa !14
  %833 = load ptr, ptr %12, align 8, !tbaa !5
  %834 = load i32, ptr %14, align 4, !tbaa !9
  %835 = sext i32 %834 to i64
  %836 = getelementptr inbounds %struct.complex, ptr %833, i64 %835
  %837 = getelementptr inbounds %struct.complex, ptr %836, i32 0, i32 1
  store float %832, ptr %837, align 4, !tbaa !14
  %838 = load i32, ptr %25, align 4, !tbaa !9
  %839 = add nsw i32 %838, 1
  store i32 %839, ptr %24, align 4, !tbaa !9
  %840 = load ptr, ptr %8, align 8, !tbaa !5
  %841 = load i32, ptr %840, align 4, !tbaa !9
  store i32 %841, ptr %14, align 4, !tbaa !9
  %842 = load i32, ptr %23, align 4, !tbaa !9
  %843 = add nsw i32 %842, 1
  store i32 %843, ptr %22, align 4, !tbaa !9
  br label %844

844:                                              ; preds = %927, %711
  %845 = load i32, ptr %22, align 4, !tbaa !9
  %846 = load i32, ptr %14, align 4, !tbaa !9
  %847 = icmp sle i32 %845, %846
  br i1 %847, label %848, label %930

848:                                              ; preds = %844
  %849 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %849, ptr %15, align 4, !tbaa !9
  %850 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %850, ptr %16, align 4, !tbaa !9
  %851 = load i32, ptr %22, align 4, !tbaa !9
  store i32 %851, ptr %17, align 4, !tbaa !9
  %852 = load ptr, ptr %10, align 8, !tbaa !5
  %853 = load i32, ptr %17, align 4, !tbaa !9
  %854 = sext i32 %853 to i64
  %855 = getelementptr inbounds %struct.complex, ptr %852, i64 %854
  %856 = getelementptr inbounds %struct.complex, ptr %855, i32 0, i32 0
  %857 = load float, ptr %856, align 4, !tbaa !11
  %858 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %859 = load float, ptr %858, align 4, !tbaa !11
  %860 = load ptr, ptr %10, align 8, !tbaa !5
  %861 = load i32, ptr %17, align 4, !tbaa !9
  %862 = sext i32 %861 to i64
  %863 = getelementptr inbounds %struct.complex, ptr %860, i64 %862
  %864 = getelementptr inbounds %struct.complex, ptr %863, i32 0, i32 1
  %865 = load float, ptr %864, align 4, !tbaa !14
  %866 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %867 = load float, ptr %866, align 4, !tbaa !14
  %868 = fmul float %865, %867
  %869 = fneg float %868
  %870 = call float @llvm.fmuladd.f32(float %857, float %859, float %869)
  %871 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %870, ptr %871, align 4, !tbaa !11
  %872 = load ptr, ptr %10, align 8, !tbaa !5
  %873 = load i32, ptr %17, align 4, !tbaa !9
  %874 = sext i32 %873 to i64
  %875 = getelementptr inbounds %struct.complex, ptr %872, i64 %874
  %876 = getelementptr inbounds %struct.complex, ptr %875, i32 0, i32 0
  %877 = load float, ptr %876, align 4, !tbaa !11
  %878 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %879 = load float, ptr %878, align 4, !tbaa !14
  %880 = load ptr, ptr %10, align 8, !tbaa !5
  %881 = load i32, ptr %17, align 4, !tbaa !9
  %882 = sext i32 %881 to i64
  %883 = getelementptr inbounds %struct.complex, ptr %880, i64 %882
  %884 = getelementptr inbounds %struct.complex, ptr %883, i32 0, i32 1
  %885 = load float, ptr %884, align 4, !tbaa !14
  %886 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %887 = load float, ptr %886, align 4, !tbaa !11
  %888 = fmul float %885, %887
  %889 = call float @llvm.fmuladd.f32(float %877, float %879, float %888)
  %890 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %889, ptr %890, align 4, !tbaa !14
  %891 = load ptr, ptr %12, align 8, !tbaa !5
  %892 = load i32, ptr %16, align 4, !tbaa !9
  %893 = sext i32 %892 to i64
  %894 = getelementptr inbounds %struct.complex, ptr %891, i64 %893
  %895 = getelementptr inbounds %struct.complex, ptr %894, i32 0, i32 0
  %896 = load float, ptr %895, align 4, !tbaa !11
  %897 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %898 = load float, ptr %897, align 4, !tbaa !11
  %899 = fadd float %896, %898
  %900 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %899, ptr %900, align 4, !tbaa !11
  %901 = load ptr, ptr %12, align 8, !tbaa !5
  %902 = load i32, ptr %16, align 4, !tbaa !9
  %903 = sext i32 %902 to i64
  %904 = getelementptr inbounds %struct.complex, ptr %901, i64 %903
  %905 = getelementptr inbounds %struct.complex, ptr %904, i32 0, i32 1
  %906 = load float, ptr %905, align 4, !tbaa !14
  %907 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %908 = load float, ptr %907, align 4, !tbaa !14
  %909 = fadd float %906, %908
  %910 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %909, ptr %910, align 4, !tbaa !14
  %911 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %912 = load float, ptr %911, align 4, !tbaa !11
  %913 = load ptr, ptr %12, align 8, !tbaa !5
  %914 = load i32, ptr %15, align 4, !tbaa !9
  %915 = sext i32 %914 to i64
  %916 = getelementptr inbounds %struct.complex, ptr %913, i64 %915
  %917 = getelementptr inbounds %struct.complex, ptr %916, i32 0, i32 0
  store float %912, ptr %917, align 4, !tbaa !11
  %918 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %919 = load float, ptr %918, align 4, !tbaa !14
  %920 = load ptr, ptr %12, align 8, !tbaa !5
  %921 = load i32, ptr %15, align 4, !tbaa !9
  %922 = sext i32 %921 to i64
  %923 = getelementptr inbounds %struct.complex, ptr %920, i64 %922
  %924 = getelementptr inbounds %struct.complex, ptr %923, i32 0, i32 1
  store float %919, ptr %924, align 4, !tbaa !14
  %925 = load i32, ptr %24, align 4, !tbaa !9
  %926 = add nsw i32 %925, 1
  store i32 %926, ptr %24, align 4, !tbaa !9
  br label %927

927:                                              ; preds = %848
  %928 = load i32, ptr %22, align 4, !tbaa !9
  %929 = add nsw i32 %928, 1
  store i32 %929, ptr %22, align 4, !tbaa !9
  br label %844, !llvm.loop !20

930:                                              ; preds = %844
  br label %956

931:                                              ; preds = %703
  %932 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %932, ptr %14, align 4, !tbaa !9
  %933 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %933, ptr %15, align 4, !tbaa !9
  %934 = load ptr, ptr %12, align 8, !tbaa !5
  %935 = load i32, ptr %15, align 4, !tbaa !9
  %936 = sext i32 %935 to i64
  %937 = getelementptr inbounds %struct.complex, ptr %934, i64 %936
  %938 = getelementptr inbounds %struct.complex, ptr %937, i32 0, i32 0
  %939 = load float, ptr %938, align 4, !tbaa !11
  %940 = load ptr, ptr %12, align 8, !tbaa !5
  %941 = load i32, ptr %14, align 4, !tbaa !9
  %942 = sext i32 %941 to i64
  %943 = getelementptr inbounds %struct.complex, ptr %940, i64 %942
  %944 = getelementptr inbounds %struct.complex, ptr %943, i32 0, i32 0
  store float %939, ptr %944, align 4, !tbaa !11
  %945 = load ptr, ptr %12, align 8, !tbaa !5
  %946 = load i32, ptr %15, align 4, !tbaa !9
  %947 = sext i32 %946 to i64
  %948 = getelementptr inbounds %struct.complex, ptr %945, i64 %947
  %949 = getelementptr inbounds %struct.complex, ptr %948, i32 0, i32 1
  %950 = load float, ptr %949, align 4, !tbaa !14
  %951 = load ptr, ptr %12, align 8, !tbaa !5
  %952 = load i32, ptr %14, align 4, !tbaa !9
  %953 = sext i32 %952 to i64
  %954 = getelementptr inbounds %struct.complex, ptr %951, i64 %953
  %955 = getelementptr inbounds %struct.complex, ptr %954, i32 0, i32 1
  store float %950, ptr %955, align 4, !tbaa !14
  br label %956

956:                                              ; preds = %931, %930
  %957 = load i32, ptr %25, align 4, !tbaa !9
  %958 = load ptr, ptr %8, align 8, !tbaa !5
  %959 = load i32, ptr %958, align 4, !tbaa !9
  %960 = add nsw i32 %957, %959
  %961 = load i32, ptr %23, align 4, !tbaa !9
  %962 = sub nsw i32 %960, %961
  %963 = add nsw i32 %962, 1
  store i32 %963, ptr %25, align 4, !tbaa !9
  br label %964

964:                                              ; preds = %956
  %965 = load i32, ptr %23, align 4, !tbaa !9
  %966 = add nsw i32 %965, 1
  store i32 %966, ptr %23, align 4, !tbaa !9
  br label %690, !llvm.loop !21

967:                                              ; preds = %690
  br label %1259

968:                                              ; preds = %683
  %969 = load i32, ptr %28, align 4, !tbaa !9
  store i32 %969, ptr %27, align 4, !tbaa !9
  %970 = load ptr, ptr %8, align 8, !tbaa !5
  %971 = load i32, ptr %970, align 4, !tbaa !9
  store i32 %971, ptr %13, align 4, !tbaa !9
  store i32 1, ptr %23, align 4, !tbaa !9
  br label %972

972:                                              ; preds = %1255, %968
  %973 = load i32, ptr %23, align 4, !tbaa !9
  %974 = load i32, ptr %13, align 4, !tbaa !9
  %975 = icmp sle i32 %973, %974
  br i1 %975, label %976, label %1258

976:                                              ; preds = %972
  %977 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %977, ptr %14, align 4, !tbaa !9
  %978 = load ptr, ptr %10, align 8, !tbaa !5
  %979 = load i32, ptr %14, align 4, !tbaa !9
  %980 = sext i32 %979 to i64
  %981 = getelementptr inbounds %struct.complex, ptr %978, i64 %980
  %982 = getelementptr inbounds %struct.complex, ptr %981, i32 0, i32 0
  %983 = load float, ptr %982, align 4, !tbaa !11
  %984 = fcmp une float %983, 0.000000e+00
  br i1 %984, label %993, label %985

985:                                              ; preds = %976
  %986 = load ptr, ptr %10, align 8, !tbaa !5
  %987 = load i32, ptr %14, align 4, !tbaa !9
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds %struct.complex, ptr %986, i64 %988
  %990 = getelementptr inbounds %struct.complex, ptr %989, i32 0, i32 1
  %991 = load float, ptr %990, align 4, !tbaa !14
  %992 = fcmp une float %991, 0.000000e+00
  br i1 %992, label %993, label %1218

993:                                              ; preds = %985, %976
  %994 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %994, ptr %14, align 4, !tbaa !9
  %995 = load ptr, ptr %9, align 8, !tbaa !5
  %996 = getelementptr inbounds %struct.complex, ptr %995, i32 0, i32 0
  %997 = load float, ptr %996, align 4, !tbaa !11
  %998 = load ptr, ptr %10, align 8, !tbaa !5
  %999 = load i32, ptr %14, align 4, !tbaa !9
  %1000 = sext i32 %999 to i64
  %1001 = getelementptr inbounds %struct.complex, ptr %998, i64 %1000
  %1002 = getelementptr inbounds %struct.complex, ptr %1001, i32 0, i32 0
  %1003 = load float, ptr %1002, align 4, !tbaa !11
  %1004 = load ptr, ptr %9, align 8, !tbaa !5
  %1005 = getelementptr inbounds %struct.complex, ptr %1004, i32 0, i32 1
  %1006 = load float, ptr %1005, align 4, !tbaa !14
  %1007 = load ptr, ptr %10, align 8, !tbaa !5
  %1008 = load i32, ptr %14, align 4, !tbaa !9
  %1009 = sext i32 %1008 to i64
  %1010 = getelementptr inbounds %struct.complex, ptr %1007, i64 %1009
  %1011 = getelementptr inbounds %struct.complex, ptr %1010, i32 0, i32 1
  %1012 = load float, ptr %1011, align 4, !tbaa !14
  %1013 = fmul float %1006, %1012
  %1014 = fneg float %1013
  %1015 = call float @llvm.fmuladd.f32(float %997, float %1003, float %1014)
  %1016 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %1015, ptr %1016, align 4, !tbaa !11
  %1017 = load ptr, ptr %9, align 8, !tbaa !5
  %1018 = getelementptr inbounds %struct.complex, ptr %1017, i32 0, i32 0
  %1019 = load float, ptr %1018, align 4, !tbaa !11
  %1020 = load ptr, ptr %10, align 8, !tbaa !5
  %1021 = load i32, ptr %14, align 4, !tbaa !9
  %1022 = sext i32 %1021 to i64
  %1023 = getelementptr inbounds %struct.complex, ptr %1020, i64 %1022
  %1024 = getelementptr inbounds %struct.complex, ptr %1023, i32 0, i32 1
  %1025 = load float, ptr %1024, align 4, !tbaa !14
  %1026 = load ptr, ptr %9, align 8, !tbaa !5
  %1027 = getelementptr inbounds %struct.complex, ptr %1026, i32 0, i32 1
  %1028 = load float, ptr %1027, align 4, !tbaa !14
  %1029 = load ptr, ptr %10, align 8, !tbaa !5
  %1030 = load i32, ptr %14, align 4, !tbaa !9
  %1031 = sext i32 %1030 to i64
  %1032 = getelementptr inbounds %struct.complex, ptr %1029, i64 %1031
  %1033 = getelementptr inbounds %struct.complex, ptr %1032, i32 0, i32 0
  %1034 = load float, ptr %1033, align 4, !tbaa !11
  %1035 = fmul float %1028, %1034
  %1036 = call float @llvm.fmuladd.f32(float %1019, float %1025, float %1035)
  %1037 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %1036, ptr %1037, align 4, !tbaa !14
  %1038 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %1039 = load float, ptr %1038, align 4, !tbaa !11
  %1040 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  store float %1039, ptr %1040, align 4, !tbaa !11
  %1041 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %1042 = load float, ptr %1041, align 4, !tbaa !14
  %1043 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  store float %1042, ptr %1043, align 4, !tbaa !14
  %1044 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %1044, ptr %14, align 4, !tbaa !9
  %1045 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %1045, ptr %15, align 4, !tbaa !9
  %1046 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %1046, ptr %16, align 4, !tbaa !9
  %1047 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %1048 = load float, ptr %1047, align 4, !tbaa !11
  %1049 = load ptr, ptr %10, align 8, !tbaa !5
  %1050 = load i32, ptr %16, align 4, !tbaa !9
  %1051 = sext i32 %1050 to i64
  %1052 = getelementptr inbounds %struct.complex, ptr %1049, i64 %1051
  %1053 = getelementptr inbounds %struct.complex, ptr %1052, i32 0, i32 0
  %1054 = load float, ptr %1053, align 4, !tbaa !11
  %1055 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %1056 = load float, ptr %1055, align 4, !tbaa !14
  %1057 = load ptr, ptr %10, align 8, !tbaa !5
  %1058 = load i32, ptr %16, align 4, !tbaa !9
  %1059 = sext i32 %1058 to i64
  %1060 = getelementptr inbounds %struct.complex, ptr %1057, i64 %1059
  %1061 = getelementptr inbounds %struct.complex, ptr %1060, i32 0, i32 1
  %1062 = load float, ptr %1061, align 4, !tbaa !14
  %1063 = fmul float %1056, %1062
  %1064 = fneg float %1063
  %1065 = call float @llvm.fmuladd.f32(float %1048, float %1054, float %1064)
  %1066 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %1065, ptr %1066, align 4, !tbaa !11
  %1067 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %1068 = load float, ptr %1067, align 4, !tbaa !11
  %1069 = load ptr, ptr %10, align 8, !tbaa !5
  %1070 = load i32, ptr %16, align 4, !tbaa !9
  %1071 = sext i32 %1070 to i64
  %1072 = getelementptr inbounds %struct.complex, ptr %1069, i64 %1071
  %1073 = getelementptr inbounds %struct.complex, ptr %1072, i32 0, i32 1
  %1074 = load float, ptr %1073, align 4, !tbaa !14
  %1075 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %1076 = load float, ptr %1075, align 4, !tbaa !14
  %1077 = load ptr, ptr %10, align 8, !tbaa !5
  %1078 = load i32, ptr %16, align 4, !tbaa !9
  %1079 = sext i32 %1078 to i64
  %1080 = getelementptr inbounds %struct.complex, ptr %1077, i64 %1079
  %1081 = getelementptr inbounds %struct.complex, ptr %1080, i32 0, i32 0
  %1082 = load float, ptr %1081, align 4, !tbaa !11
  %1083 = fmul float %1076, %1082
  %1084 = call float @llvm.fmuladd.f32(float %1068, float %1074, float %1083)
  %1085 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %1084, ptr %1085, align 4, !tbaa !14
  %1086 = load ptr, ptr %12, align 8, !tbaa !5
  %1087 = load i32, ptr %15, align 4, !tbaa !9
  %1088 = sext i32 %1087 to i64
  %1089 = getelementptr inbounds %struct.complex, ptr %1086, i64 %1088
  %1090 = getelementptr inbounds %struct.complex, ptr %1089, i32 0, i32 0
  %1091 = load float, ptr %1090, align 4, !tbaa !11
  %1092 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %1093 = load float, ptr %1092, align 4, !tbaa !11
  %1094 = fadd float %1091, %1093
  %1095 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %1094, ptr %1095, align 4, !tbaa !11
  %1096 = load ptr, ptr %12, align 8, !tbaa !5
  %1097 = load i32, ptr %15, align 4, !tbaa !9
  %1098 = sext i32 %1097 to i64
  %1099 = getelementptr inbounds %struct.complex, ptr %1096, i64 %1098
  %1100 = getelementptr inbounds %struct.complex, ptr %1099, i32 0, i32 1
  %1101 = load float, ptr %1100, align 4, !tbaa !14
  %1102 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %1103 = load float, ptr %1102, align 4, !tbaa !14
  %1104 = fadd float %1101, %1103
  %1105 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %1104, ptr %1105, align 4, !tbaa !14
  %1106 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %1107 = load float, ptr %1106, align 4, !tbaa !11
  %1108 = load ptr, ptr %12, align 8, !tbaa !5
  %1109 = load i32, ptr %14, align 4, !tbaa !9
  %1110 = sext i32 %1109 to i64
  %1111 = getelementptr inbounds %struct.complex, ptr %1108, i64 %1110
  %1112 = getelementptr inbounds %struct.complex, ptr %1111, i32 0, i32 0
  store float %1107, ptr %1112, align 4, !tbaa !11
  %1113 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %1114 = load float, ptr %1113, align 4, !tbaa !14
  %1115 = load ptr, ptr %12, align 8, !tbaa !5
  %1116 = load i32, ptr %14, align 4, !tbaa !9
  %1117 = sext i32 %1116 to i64
  %1118 = getelementptr inbounds %struct.complex, ptr %1115, i64 %1117
  %1119 = getelementptr inbounds %struct.complex, ptr %1118, i32 0, i32 1
  store float %1114, ptr %1119, align 4, !tbaa !14
  %1120 = load i32, ptr %27, align 4, !tbaa !9
  store i32 %1120, ptr %26, align 4, !tbaa !9
  %1121 = load i32, ptr %25, align 4, !tbaa !9
  %1122 = load ptr, ptr %8, align 8, !tbaa !5
  %1123 = load i32, ptr %1122, align 4, !tbaa !9
  %1124 = add nsw i32 %1121, %1123
  %1125 = load i32, ptr %23, align 4, !tbaa !9
  %1126 = sub nsw i32 %1124, %1125
  store i32 %1126, ptr %14, align 4, !tbaa !9
  %1127 = load i32, ptr %25, align 4, !tbaa !9
  %1128 = add nsw i32 %1127, 1
  store i32 %1128, ptr %24, align 4, !tbaa !9
  br label %1129

1129:                                             ; preds = %1214, %993
  %1130 = load i32, ptr %24, align 4, !tbaa !9
  %1131 = load i32, ptr %14, align 4, !tbaa !9
  %1132 = icmp sle i32 %1130, %1131
  br i1 %1132, label %1133, label %1217

1133:                                             ; preds = %1129
  %1134 = load ptr, ptr %11, align 8, !tbaa !5
  %1135 = load i32, ptr %1134, align 4, !tbaa !9
  %1136 = load i32, ptr %26, align 4, !tbaa !9
  %1137 = add nsw i32 %1136, %1135
  store i32 %1137, ptr %26, align 4, !tbaa !9
  %1138 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %1138, ptr %15, align 4, !tbaa !9
  %1139 = load i32, ptr %24, align 4, !tbaa !9
  store i32 %1139, ptr %16, align 4, !tbaa !9
  %1140 = load i32, ptr %26, align 4, !tbaa !9
  store i32 %1140, ptr %17, align 4, !tbaa !9
  %1141 = load ptr, ptr %10, align 8, !tbaa !5
  %1142 = load i32, ptr %17, align 4, !tbaa !9
  %1143 = sext i32 %1142 to i64
  %1144 = getelementptr inbounds %struct.complex, ptr %1141, i64 %1143
  %1145 = getelementptr inbounds %struct.complex, ptr %1144, i32 0, i32 0
  %1146 = load float, ptr %1145, align 4, !tbaa !11
  %1147 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %1148 = load float, ptr %1147, align 4, !tbaa !11
  %1149 = load ptr, ptr %10, align 8, !tbaa !5
  %1150 = load i32, ptr %17, align 4, !tbaa !9
  %1151 = sext i32 %1150 to i64
  %1152 = getelementptr inbounds %struct.complex, ptr %1149, i64 %1151
  %1153 = getelementptr inbounds %struct.complex, ptr %1152, i32 0, i32 1
  %1154 = load float, ptr %1153, align 4, !tbaa !14
  %1155 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %1156 = load float, ptr %1155, align 4, !tbaa !14
  %1157 = fmul float %1154, %1156
  %1158 = fneg float %1157
  %1159 = call float @llvm.fmuladd.f32(float %1146, float %1148, float %1158)
  %1160 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  store float %1159, ptr %1160, align 4, !tbaa !11
  %1161 = load ptr, ptr %10, align 8, !tbaa !5
  %1162 = load i32, ptr %17, align 4, !tbaa !9
  %1163 = sext i32 %1162 to i64
  %1164 = getelementptr inbounds %struct.complex, ptr %1161, i64 %1163
  %1165 = getelementptr inbounds %struct.complex, ptr %1164, i32 0, i32 0
  %1166 = load float, ptr %1165, align 4, !tbaa !11
  %1167 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 1
  %1168 = load float, ptr %1167, align 4, !tbaa !14
  %1169 = load ptr, ptr %10, align 8, !tbaa !5
  %1170 = load i32, ptr %17, align 4, !tbaa !9
  %1171 = sext i32 %1170 to i64
  %1172 = getelementptr inbounds %struct.complex, ptr %1169, i64 %1171
  %1173 = getelementptr inbounds %struct.complex, ptr %1172, i32 0, i32 1
  %1174 = load float, ptr %1173, align 4, !tbaa !14
  %1175 = getelementptr inbounds %struct.complex, ptr %21, i32 0, i32 0
  %1176 = load float, ptr %1175, align 4, !tbaa !11
  %1177 = fmul float %1174, %1176
  %1178 = call float @llvm.fmuladd.f32(float %1166, float %1168, float %1177)
  %1179 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  store float %1178, ptr %1179, align 4, !tbaa !14
  %1180 = load ptr, ptr %12, align 8, !tbaa !5
  %1181 = load i32, ptr %16, align 4, !tbaa !9
  %1182 = sext i32 %1181 to i64
  %1183 = getelementptr inbounds %struct.complex, ptr %1180, i64 %1182
  %1184 = getelementptr inbounds %struct.complex, ptr %1183, i32 0, i32 0
  %1185 = load float, ptr %1184, align 4, !tbaa !11
  %1186 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 0
  %1187 = load float, ptr %1186, align 4, !tbaa !11
  %1188 = fadd float %1185, %1187
  %1189 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  store float %1188, ptr %1189, align 4, !tbaa !11
  %1190 = load ptr, ptr %12, align 8, !tbaa !5
  %1191 = load i32, ptr %16, align 4, !tbaa !9
  %1192 = sext i32 %1191 to i64
  %1193 = getelementptr inbounds %struct.complex, ptr %1190, i64 %1192
  %1194 = getelementptr inbounds %struct.complex, ptr %1193, i32 0, i32 1
  %1195 = load float, ptr %1194, align 4, !tbaa !14
  %1196 = getelementptr inbounds %struct.complex, ptr %19, i32 0, i32 1
  %1197 = load float, ptr %1196, align 4, !tbaa !14
  %1198 = fadd float %1195, %1197
  %1199 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  store float %1198, ptr %1199, align 4, !tbaa !14
  %1200 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 0
  %1201 = load float, ptr %1200, align 4, !tbaa !11
  %1202 = load ptr, ptr %12, align 8, !tbaa !5
  %1203 = load i32, ptr %15, align 4, !tbaa !9
  %1204 = sext i32 %1203 to i64
  %1205 = getelementptr inbounds %struct.complex, ptr %1202, i64 %1204
  %1206 = getelementptr inbounds %struct.complex, ptr %1205, i32 0, i32 0
  store float %1201, ptr %1206, align 4, !tbaa !11
  %1207 = getelementptr inbounds %struct.complex, ptr %18, i32 0, i32 1
  %1208 = load float, ptr %1207, align 4, !tbaa !14
  %1209 = load ptr, ptr %12, align 8, !tbaa !5
  %1210 = load i32, ptr %15, align 4, !tbaa !9
  %1211 = sext i32 %1210 to i64
  %1212 = getelementptr inbounds %struct.complex, ptr %1209, i64 %1211
  %1213 = getelementptr inbounds %struct.complex, ptr %1212, i32 0, i32 1
  store float %1208, ptr %1213, align 4, !tbaa !14
  br label %1214

1214:                                             ; preds = %1133
  %1215 = load i32, ptr %24, align 4, !tbaa !9
  %1216 = add nsw i32 %1215, 1
  store i32 %1216, ptr %24, align 4, !tbaa !9
  br label %1129, !llvm.loop !22

1217:                                             ; preds = %1129
  br label %1243

1218:                                             ; preds = %985
  %1219 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %1219, ptr %14, align 4, !tbaa !9
  %1220 = load i32, ptr %25, align 4, !tbaa !9
  store i32 %1220, ptr %15, align 4, !tbaa !9
  %1221 = load ptr, ptr %12, align 8, !tbaa !5
  %1222 = load i32, ptr %15, align 4, !tbaa !9
  %1223 = sext i32 %1222 to i64
  %1224 = getelementptr inbounds %struct.complex, ptr %1221, i64 %1223
  %1225 = getelementptr inbounds %struct.complex, ptr %1224, i32 0, i32 0
  %1226 = load float, ptr %1225, align 4, !tbaa !11
  %1227 = load ptr, ptr %12, align 8, !tbaa !5
  %1228 = load i32, ptr %14, align 4, !tbaa !9
  %1229 = sext i32 %1228 to i64
  %1230 = getelementptr inbounds %struct.complex, ptr %1227, i64 %1229
  %1231 = getelementptr inbounds %struct.complex, ptr %1230, i32 0, i32 0
  store float %1226, ptr %1231, align 4, !tbaa !11
  %1232 = load ptr, ptr %12, align 8, !tbaa !5
  %1233 = load i32, ptr %15, align 4, !tbaa !9
  %1234 = sext i32 %1233 to i64
  %1235 = getelementptr inbounds %struct.complex, ptr %1232, i64 %1234
  %1236 = getelementptr inbounds %struct.complex, ptr %1235, i32 0, i32 1
  %1237 = load float, ptr %1236, align 4, !tbaa !14
  %1238 = load ptr, ptr %12, align 8, !tbaa !5
  %1239 = load i32, ptr %14, align 4, !tbaa !9
  %1240 = sext i32 %1239 to i64
  %1241 = getelementptr inbounds %struct.complex, ptr %1238, i64 %1240
  %1242 = getelementptr inbounds %struct.complex, ptr %1241, i32 0, i32 1
  store float %1237, ptr %1242, align 4, !tbaa !14
  br label %1243

1243:                                             ; preds = %1218, %1217
  %1244 = load ptr, ptr %11, align 8, !tbaa !5
  %1245 = load i32, ptr %1244, align 4, !tbaa !9
  %1246 = load i32, ptr %27, align 4, !tbaa !9
  %1247 = add nsw i32 %1246, %1245
  store i32 %1247, ptr %27, align 4, !tbaa !9
  %1248 = load i32, ptr %25, align 4, !tbaa !9
  %1249 = load ptr, ptr %8, align 8, !tbaa !5
  %1250 = load i32, ptr %1249, align 4, !tbaa !9
  %1251 = add nsw i32 %1248, %1250
  %1252 = load i32, ptr %23, align 4, !tbaa !9
  %1253 = sub nsw i32 %1251, %1252
  %1254 = add nsw i32 %1253, 1
  store i32 %1254, ptr %25, align 4, !tbaa !9
  br label %1255

1255:                                             ; preds = %1243
  %1256 = load i32, ptr %23, align 4, !tbaa !9
  %1257 = add nsw i32 %1256, 1
  store i32 %1257, ptr %23, align 4, !tbaa !9
  br label %972, !llvm.loop !23

1258:                                             ; preds = %972
  br label %1259

1259:                                             ; preds = %1258, %967
  br label %1260

1260:                                             ; preds = %1259, %682
  store i32 1, ptr %29, align 4
  br label %1261

1261:                                             ; preds = %1260, %73, %57
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  ret void
}

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

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

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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "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 4}
!13 = !{!"float", !7, i64 0}
!14 = !{!12, !13, i64 4}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = distinct !{!17, !16}
!18 = distinct !{!18, !16}
!19 = distinct !{!19, !16}
!20 = distinct !{!20, !16}
!21 = distinct !{!21, !16}
!22 = distinct !{!22, !16}
!23 = distinct !{!23, !16}


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

%struct.complex = type { float, float }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @cspr_(ptr noundef %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr nocapture noundef readonly %4, ptr nocapture noundef %5) local_unnamed_addr #0 {
  %7 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %7) #4
  %8 = getelementptr inbounds i8, ptr %5, i64 -8
  %9 = getelementptr inbounds i8, ptr %3, i64 -8
  %10 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #4
  %.not = icmp eq i32 %10, 0
  br i1 %.not, label %11, label %14

11:                                               ; preds = %6
  %12 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.1) #4
  %.not436 = icmp eq i32 %12, 0
  br i1 %.not436, label %13, label %14

13:                                               ; preds = %11
  store i32 1, ptr %7, align 4, !tbaa !5
  br label %.thread

14:                                               ; preds = %11, %6
  %15 = load i32, ptr %1, align 4, !tbaa !5
  %16 = icmp slt i32 %15, 0
  br i1 %16, label %17, label %18

17:                                               ; preds = %14
  store i32 2, ptr %7, align 4, !tbaa !5
  br label %.thread

18:                                               ; preds = %14
  %19 = load i32, ptr %4, align 4, !tbaa !5
  %20 = icmp eq i32 %19, 0
  br i1 %20, label %21, label %23

21:                                               ; preds = %18
  store i32 5, ptr %7, align 4, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %13, %21, %17
  %22 = call i32 @xerbla_(ptr noundef nonnull @.str.2, ptr noundef nonnull %7, i32 noundef 6) #4
  br label %.loopexit449

23:                                               ; preds = %18
  %24 = icmp eq i32 %15, 0
  br i1 %24, label %.loopexit449, label %25

25:                                               ; preds = %23
  %26 = load float, ptr %2, align 4, !tbaa !9
  %27 = fcmp oeq float %26, 0.000000e+00
  br i1 %27, label %28, label %32

28:                                               ; preds = %25
  %29 = getelementptr inbounds i8, ptr %2, i64 4
  %30 = load float, ptr %29, align 4, !tbaa !12
  %31 = fcmp oeq float %30, 0.000000e+00
  br i1 %31, label %.loopexit449, label %32

32:                                               ; preds = %28, %25
  %33 = icmp slt i32 %19, 1
  %34 = add nsw i32 %15, -1
  %35 = mul nsw i32 %19, %34
  %36 = sub nsw i32 1, %35
  %.0 = select i1 %33, i32 %36, i32 1
  %37 = tail call i32 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #4
  %.not439 = icmp eq i32 %37, 0
  %38 = load i32, ptr %4, align 4, !tbaa !5
  %39 = icmp eq i32 %38, 1
  %40 = load i32, ptr %1, align 4, !tbaa !5
  %.not442495 = icmp slt i32 %40, 1
  br i1 %.not439, label %162, label %41

41:                                               ; preds = %32
  br i1 %39, label %42, label %107

42:                                               ; preds = %41
  br i1 %.not442495, label %.loopexit449, label %.lr.ph475

.lr.ph475:                                        ; preds = %42
  %43 = getelementptr inbounds i8, ptr %2, i64 4
  %44 = add nuw i32 %40, 1
  %wide.trip.count529 = zext i32 %44 to i64
  %scevgep630 = getelementptr i8, ptr %5, i64 -8
  %scevgep637 = getelementptr i8, ptr %5, i64 -4
  %scevgep641 = getelementptr i8, ptr %3, i64 4
  %invariant.gep792 = getelementptr i8, ptr %5, i64 -12
  %invariant.gep794 = getelementptr i8, ptr %3, i64 -4
  %invariant.gep796 = getelementptr i8, ptr %5, i64 -8
  br label %45

45:                                               ; preds = %.lr.ph475, %104
  %indvar632 = phi i64 [ 0, %.lr.ph475 ], [ %indvar.next633, %104 ]
  %indvars.iv526 = phi i64 [ 1, %.lr.ph475 ], [ %indvars.iv.next527, %104 ]
  %.0422472 = phi i32 [ 1, %.lr.ph475 ], [ %106, %104 ]
  %46 = zext i32 %.0422472 to i64
  %47 = shl nuw nsw i64 %46, 3
  %scevgep631 = getelementptr i8, ptr %scevgep630, i64 %47
  %48 = shl nuw nsw i64 %indvar632, 3
  %gep793 = getelementptr i8, ptr %invariant.gep792, i64 %48
  %scevgep635 = getelementptr i8, ptr %gep793, i64 %47
  %gep795 = getelementptr i8, ptr %invariant.gep794, i64 %48
  %scevgep638 = getelementptr i8, ptr %scevgep637, i64 %47
  %gep797 = getelementptr i8, ptr %invariant.gep796, i64 %48
  %scevgep640 = getelementptr i8, ptr %gep797, i64 %47
  %scevgep642 = getelementptr i8, ptr %3, i64 %48
  %49 = zext i32 %.0422472 to i64
  %50 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv526
  %51 = load <2 x float>, ptr %50, align 4, !tbaa !13
  %52 = extractelement <2 x float> %51, i64 0
  %53 = fcmp une float %52, 0.000000e+00
  %54 = extractelement <2 x float> %51, i64 1
  %55 = fcmp une float %54, 0.000000e+00
  %or.cond = select i1 %53, i1 true, i1 %55
  br i1 %or.cond, label %._crit_edge582, label %104

._crit_edge582:                                   ; preds = %45
  %56 = load float, ptr %2, align 4, !tbaa !9
  %57 = load float, ptr %43, align 4, !tbaa !12
  %58 = fneg float %57
  %59 = insertelement <2 x float> poison, float %57, i64 0
  %60 = insertelement <2 x float> %59, float %58, i64 1
  %61 = fmul <2 x float> %51, %60
  %62 = shufflevector <2 x float> %61, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %63 = insertelement <2 x float> poison, float %56, i64 0
  %64 = shufflevector <2 x float> %63, <2 x float> poison, <2 x i32> zeroinitializer
  %65 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %64, <2 x float> %51, <2 x float> %62)
  %.not447.not464 = icmp ugt i64 %indvars.iv526, 1
  br i1 %.not447.not464, label %.lr.ph468.preheader, label %._crit_edge469

.lr.ph468.preheader:                              ; preds = %._crit_edge582
  %min.iters.check652 = icmp ult i64 %indvar632, 4
  br i1 %min.iters.check652, label %.lr.ph468.preheader787, label %vector.memcheck629

vector.memcheck629:                               ; preds = %.lr.ph468.preheader
  %bound0643 = icmp ult ptr %scevgep631, %gep795
  %bound1644 = icmp ugt ptr %scevgep635, %3
  %found.conflict645 = and i1 %bound0643, %bound1644
  %bound0646 = icmp ult ptr %scevgep638, %scevgep642
  %bound1647 = icmp ult ptr %scevgep641, %scevgep640
  %found.conflict648 = and i1 %bound0646, %bound1647
  %conflict.rdx649 = or i1 %found.conflict645, %found.conflict648
  br i1 %conflict.rdx649, label %.lr.ph468.preheader787, label %vector.ph653

vector.ph653:                                     ; preds = %vector.memcheck629
  %n.vec655 = and i64 %indvar632, -4
  %ind.end656 = or disjoint i64 %n.vec655, 1
  %ind.end658 = add i64 %n.vec655, %49
  %broadcast.splat668 = shufflevector <2 x float> %65, <2 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
  %broadcast.splat670 = shufflevector <2 x float> %65, <2 x float> poison, <4 x i32> zeroinitializer
  %invariant.gep790 = getelementptr %struct.complex, ptr %8, i64 %49
  br label %vector.body660

vector.body660:                                   ; preds = %vector.body660, %vector.ph653
  %index661 = phi i64 [ 0, %vector.ph653 ], [ %index.next675, %vector.body660 ]
  %66 = getelementptr %struct.complex, ptr %3, i64 %index661
  %wide.vec664 = load <8 x float>, ptr %66, align 4, !tbaa !13
  %strided.vec665 = shufflevector <8 x float> %wide.vec664, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec666 = shufflevector <8 x float> %wide.vec664, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %67 = fneg <4 x float> %strided.vec666
  %68 = fmul <4 x float> %broadcast.splat668, %67
  %69 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %strided.vec665, <4 x float> %broadcast.splat670, <4 x float> %68)
  %70 = fmul <4 x float> %broadcast.splat670, %strided.vec666
  %71 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %strided.vec665, <4 x float> %broadcast.splat668, <4 x float> %70)
  %gep791 = getelementptr %struct.complex, ptr %invariant.gep790, i64 %index661
  %wide.vec671 = load <8 x float>, ptr %gep791, align 4, !tbaa !13
  %strided.vec672 = shufflevector <8 x float> %wide.vec671, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec673 = shufflevector <8 x float> %wide.vec671, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %72 = fadd <4 x float> %strided.vec672, %69
  %73 = fadd <4 x float> %strided.vec673, %71
  %interleaved.vec674 = shufflevector <4 x float> %72, <4 x float> %73, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec674, ptr %gep791, align 4, !tbaa !13
  %index.next675 = add nuw i64 %index661, 4
  %74 = icmp eq i64 %index.next675, %n.vec655
  br i1 %74, label %middle.block650, label %vector.body660, !llvm.loop !14

middle.block650:                                  ; preds = %vector.body660
  %cmp.n676 = icmp eq i64 %indvar632, %n.vec655
  br i1 %cmp.n676, label %._crit_edge469.loopexit, label %.lr.ph468.preheader787

.lr.ph468.preheader787:                           ; preds = %middle.block650, %vector.memcheck629, %.lr.ph468.preheader
  %indvars.iv519.ph = phi i64 [ 1, %vector.memcheck629 ], [ 1, %.lr.ph468.preheader ], [ %ind.end656, %middle.block650 ]
  %indvars.iv517.ph = phi i64 [ %49, %vector.memcheck629 ], [ %49, %.lr.ph468.preheader ], [ %ind.end658, %middle.block650 ]
  br label %.lr.ph468

.lr.ph468:                                        ; preds = %.lr.ph468.preheader787, %.lr.ph468
  %indvars.iv519 = phi i64 [ %indvars.iv.next520, %.lr.ph468 ], [ %indvars.iv519.ph, %.lr.ph468.preheader787 ]
  %indvars.iv517 = phi i64 [ %indvars.iv.next518, %.lr.ph468 ], [ %indvars.iv517.ph, %.lr.ph468.preheader787 ]
  %75 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv519
  %76 = load float, ptr %75, align 4, !tbaa !9
  %77 = getelementptr inbounds i8, ptr %75, i64 4
  %78 = load float, ptr %77, align 4, !tbaa !12
  %79 = fneg float %78
  %80 = getelementptr inbounds %struct.complex, ptr %8, i64 %indvars.iv517
  %81 = insertelement <2 x float> poison, float %78, i64 0
  %82 = insertelement <2 x float> %81, float %79, i64 1
  %83 = fmul <2 x float> %65, %82
  %84 = shufflevector <2 x float> %83, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %85 = insertelement <2 x float> poison, float %76, i64 0
  %86 = shufflevector <2 x float> %85, <2 x float> poison, <2 x i32> zeroinitializer
  %87 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %86, <2 x float> %65, <2 x float> %84)
  %88 = load <2 x float>, ptr %80, align 4, !tbaa !13
  %89 = fadd <2 x float> %88, %87
  store <2 x float> %89, ptr %80, align 4, !tbaa !13
  %indvars.iv.next518 = add nuw nsw i64 %indvars.iv517, 1
  %indvars.iv.next520 = add nuw nsw i64 %indvars.iv519, 1
  %exitcond525.not = icmp eq i64 %indvars.iv.next520, %indvars.iv526
  br i1 %exitcond525.not, label %._crit_edge469.loopexit, label %.lr.ph468, !llvm.loop !18

._crit_edge469.loopexit:                          ; preds = %.lr.ph468, %middle.block650
  %90 = load <2 x float>, ptr %50, align 4, !tbaa !13
  br label %._crit_edge469

._crit_edge469:                                   ; preds = %._crit_edge469.loopexit, %._crit_edge582
  %91 = phi <2 x float> [ %90, %._crit_edge469.loopexit ], [ %51, %._crit_edge582 ]
  %92 = getelementptr %struct.complex, ptr %8, i64 %indvars.iv526
  %93 = getelementptr %struct.complex, ptr %92, i64 %49
  %94 = getelementptr i8, ptr %93, i64 -8
  %95 = shufflevector <2 x float> %91, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %96 = fneg <2 x float> %91
  %97 = shufflevector <2 x float> %95, <2 x float> %96, <2 x i32> <i32 0, i32 3>
  %98 = fmul <2 x float> %65, %97
  %99 = shufflevector <2 x float> %98, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %100 = shufflevector <2 x float> %91, <2 x float> poison, <2 x i32> zeroinitializer
  %101 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %100, <2 x float> %65, <2 x float> %99)
  %102 = load <2 x float>, ptr %94, align 4, !tbaa !13
  %103 = fadd <2 x float> %102, %101
  store <2 x float> %103, ptr %94, align 4, !tbaa !13
  br label %104

104:                                              ; preds = %45, %._crit_edge469
  %105 = trunc i64 %indvars.iv526 to i32
  %106 = add i32 %.0422472, %105
  %indvars.iv.next527 = add nuw nsw i64 %indvars.iv526, 1
  %exitcond530.not = icmp eq i64 %indvars.iv.next527, %wide.trip.count529
  %indvar.next633 = add i64 %indvar632, 1
  br i1 %exitcond530.not, label %.loopexit449, label %45, !llvm.loop !19

107:                                              ; preds = %41
  br i1 %.not442495, label %.loopexit449, label %.lr.ph463

.lr.ph463:                                        ; preds = %107
  %108 = getelementptr inbounds i8, ptr %2, i64 4
  %109 = sext i32 %.0 to i64
  %110 = sext i32 %38 to i64
  %111 = add nuw i32 %40, 1
  %wide.trip.count = zext i32 %111 to i64
  %invariant.gep = getelementptr i8, ptr %8, i64 -8
  br label %112

112:                                              ; preds = %.lr.ph463, %161
  %indvars.iv512 = phi i64 [ 1, %.lr.ph463 ], [ %indvars.iv.next513, %161 ]
  %indvars.iv510 = phi i64 [ %109, %.lr.ph463 ], [ %indvars.iv.next511, %161 ]
  %.1423459 = phi i32 [ 1, %.lr.ph463 ], [ %.pre-phi596, %161 ]
  %113 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv510
  %114 = load <2 x float>, ptr %113, align 4, !tbaa !13
  %115 = extractelement <2 x float> %114, i64 0
  %116 = fcmp une float %115, 0.000000e+00
  %117 = extractelement <2 x float> %114, i64 1
  %118 = fcmp une float %117, 0.000000e+00
  %or.cond600 = select i1 %116, i1 true, i1 %118
  br i1 %or.cond600, label %._crit_edge579, label %._crit_edge593

._crit_edge593:                                   ; preds = %112
  %.pre594 = trunc nuw nsw i64 %indvars.iv512 to i32
  %.pre595 = add nuw nsw i32 %.1423459, %.pre594
  br label %161

._crit_edge579:                                   ; preds = %112
  %119 = load float, ptr %2, align 4, !tbaa !9
  %120 = load float, ptr %108, align 4, !tbaa !12
  %121 = fneg float %120
  %122 = insertelement <2 x float> poison, float %120, i64 0
  %123 = insertelement <2 x float> %122, float %121, i64 1
  %124 = fmul <2 x float> %114, %123
  %125 = shufflevector <2 x float> %124, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %126 = insertelement <2 x float> poison, float %119, i64 0
  %127 = shufflevector <2 x float> %126, <2 x float> poison, <2 x i32> zeroinitializer
  %128 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %127, <2 x float> %114, <2 x float> %125)
  %129 = trunc nuw nsw i64 %indvars.iv512 to i32
  %130 = add nuw nsw i32 %.1423459, %129
  %131 = add nsw i32 %130, -2
  %.not445454 = icmp sgt i32 %.1423459, %131
  br i1 %.not445454, label %._crit_edge, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %._crit_edge579
  %132 = zext i32 %.1423459 to i64
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %indvars.iv505 = phi i64 [ %indvars.iv.next506, %.lr.ph ], [ %132, %.lr.ph.preheader ]
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %109, %.lr.ph.preheader ]
  %133 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv
  %134 = load float, ptr %133, align 4, !tbaa !9
  %135 = getelementptr inbounds i8, ptr %133, i64 4
  %136 = load float, ptr %135, align 4, !tbaa !12
  %137 = fneg float %136
  %138 = getelementptr inbounds %struct.complex, ptr %8, i64 %indvars.iv505
  %139 = insertelement <2 x float> poison, float %136, i64 0
  %140 = insertelement <2 x float> %139, float %137, i64 1
  %141 = fmul <2 x float> %128, %140
  %142 = shufflevector <2 x float> %141, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %143 = insertelement <2 x float> poison, float %134, i64 0
  %144 = shufflevector <2 x float> %143, <2 x float> poison, <2 x i32> zeroinitializer
  %145 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %144, <2 x float> %128, <2 x float> %142)
  %146 = load <2 x float>, ptr %138, align 4, !tbaa !13
  %147 = fadd <2 x float> %146, %145
  store <2 x float> %147, ptr %138, align 4, !tbaa !13
  %indvars.iv.next = add nsw i64 %indvars.iv, %110
  %indvars.iv.next506 = add nuw nsw i64 %indvars.iv505, 1
  %148 = trunc nuw i64 %indvars.iv505 to i32
  %.not445.not = icmp sgt i32 %131, %148
  br i1 %.not445.not, label %.lr.ph, label %._crit_edge.loopexit, !llvm.loop !20

._crit_edge.loopexit:                             ; preds = %.lr.ph
  %149 = load <2 x float>, ptr %113, align 4, !tbaa !13
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %._crit_edge579
  %150 = phi <2 x float> [ %149, %._crit_edge.loopexit ], [ %114, %._crit_edge579 ]
  %151 = zext nneg i32 %130 to i64
  %gep = getelementptr %struct.complex, ptr %invariant.gep, i64 %151
  %152 = shufflevector <2 x float> %150, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %153 = fneg <2 x float> %150
  %154 = shufflevector <2 x float> %152, <2 x float> %153, <2 x i32> <i32 0, i32 3>
  %155 = fmul <2 x float> %128, %154
  %156 = shufflevector <2 x float> %155, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %157 = shufflevector <2 x float> %150, <2 x float> poison, <2 x i32> zeroinitializer
  %158 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %157, <2 x float> %128, <2 x float> %156)
  %159 = load <2 x float>, ptr %gep, align 4, !tbaa !13
  %160 = fadd <2 x float> %159, %158
  store <2 x float> %160, ptr %gep, align 4, !tbaa !13
  br label %161

161:                                              ; preds = %._crit_edge593, %._crit_edge
  %.pre-phi596 = phi i32 [ %.pre595, %._crit_edge593 ], [ %130, %._crit_edge ]
  %indvars.iv.next511 = add nsw i64 %indvars.iv510, %110
  %indvars.iv.next513 = add nuw nsw i64 %indvars.iv512, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next513, %wide.trip.count
  br i1 %exitcond.not, label %.loopexit449, label %112, !llvm.loop !21

162:                                              ; preds = %32
  br i1 %39, label %163, label %242

163:                                              ; preds = %162
  br i1 %.not442495, label %.loopexit449, label %.lr.ph501

.lr.ph501:                                        ; preds = %163
  %164 = getelementptr inbounds i8, ptr %2, i64 4
  %165 = add nuw i32 %40, 1
  %166 = zext nneg i32 %40 to i64
  %wide.trip.count577 = zext i32 %165 to i64
  %wide.trip.count574 = zext nneg i32 %40 to i64
  %167 = add nsw i64 %wide.trip.count574, -2
  %scevgep734 = getelementptr i8, ptr %5, i64 4
  %168 = shl nuw nsw i64 %wide.trip.count574, 3
  %169 = getelementptr i8, ptr %3, i64 %168
  %scevgep744 = getelementptr i8, ptr %169, i64 -4
  %scevgep745 = getelementptr i8, ptr %5, i64 4
  %scevgep750 = getelementptr i8, ptr %3, i64 %168
  %170 = getelementptr i8, ptr %5, i64 %168
  %171 = getelementptr i8, ptr %170, i64 -12
  %invariant.gep800 = getelementptr i8, ptr %3, i64 8
  %172 = getelementptr i8, ptr %5, i64 %168
  %173 = getelementptr i8, ptr %172, i64 -8
  %invariant.gep802 = getelementptr i8, ptr %3, i64 12
  br label %174

174:                                              ; preds = %.lr.ph501, %.loopexit
  %indvar731 = phi i64 [ 0, %.lr.ph501 ], [ %indvar.next732, %.loopexit ]
  %indvars.iv567 = phi i64 [ 1, %.lr.ph501 ], [ %indvars.iv.next568, %.loopexit ]
  %indvars.iv563 = phi i32 [ 1, %.lr.ph501 ], [ %indvars.iv.next564, %.loopexit ]
  %indvars.iv561 = phi i32 [ %40, %.lr.ph501 ], [ %indvars.iv.next562, %.loopexit ]
  %175 = xor i64 %indvar731, -1
  %176 = add i64 %175, %wide.trip.count574
  %177 = sext i32 %indvars.iv563 to i64
  %178 = shl nsw i64 %177, 3
  %scevgep740 = getelementptr i8, ptr %5, i64 %178
  %179 = mul nsw i64 %indvar731, -8
  %scevgep741 = getelementptr i8, ptr %171, i64 %179
  %scevgep742 = getelementptr i8, ptr %scevgep741, i64 %178
  %180 = shl nuw nsw i64 %indvar731, 3
  %gep801 = getelementptr i8, ptr %invariant.gep800, i64 %180
  %scevgep746 = getelementptr i8, ptr %scevgep745, i64 %178
  %scevgep747 = getelementptr i8, ptr %173, i64 %179
  %scevgep748 = getelementptr i8, ptr %scevgep747, i64 %178
  %gep803 = getelementptr i8, ptr %invariant.gep802, i64 %180
  %181 = sub i64 %167, %indvar731
  %182 = sext i32 %indvars.iv563 to i64
  %183 = shl nsw i64 %182, 3
  %scevgep733 = getelementptr i8, ptr %5, i64 %183
  %scevgep735 = getelementptr i8, ptr %scevgep734, i64 %183
  %184 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv567
  %185 = load <2 x float>, ptr %184, align 4, !tbaa !13
  %186 = extractelement <2 x float> %185, i64 0
  %187 = fcmp une float %186, 0.000000e+00
  %188 = extractelement <2 x float> %185, i64 1
  %189 = fcmp une float %188, 0.000000e+00
  %or.cond601 = select i1 %187, i1 true, i1 %189
  br i1 %or.cond601, label %._crit_edge590, label %.loopexit

._crit_edge590:                                   ; preds = %174
  %190 = sext i32 %indvars.iv563 to i64
  %191 = load float, ptr %2, align 4, !tbaa !9
  %192 = load float, ptr %164, align 4, !tbaa !12
  %193 = fneg float %192
  %194 = insertelement <2 x float> poison, float %192, i64 0
  %195 = insertelement <2 x float> %194, float %193, i64 1
  %196 = fmul <2 x float> %185, %195
  %197 = shufflevector <2 x float> %196, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %198 = insertelement <2 x float> poison, float %191, i64 0
  %199 = shufflevector <2 x float> %198, <2 x float> poison, <2 x i32> zeroinitializer
  %200 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %199, <2 x float> %185, <2 x float> %197)
  %201 = getelementptr inbounds %struct.complex, ptr %8, i64 %190
  %202 = shufflevector <2 x float> %200, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %203 = fneg <2 x float> %200
  %204 = shufflevector <2 x float> %202, <2 x float> %203, <2 x i32> <i32 0, i32 3>
  %205 = fmul <2 x float> %185, %204
  %206 = shufflevector <2 x float> %205, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %207 = shufflevector <2 x float> %200, <2 x float> poison, <2 x i32> zeroinitializer
  %208 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %207, <2 x float> %185, <2 x float> %206)
  %209 = load <2 x float>, ptr %201, align 4, !tbaa !13
  %210 = fadd <2 x float> %209, %208
  store <2 x float> %210, ptr %201, align 4, !tbaa !13
  %.not443.not490 = icmp ult i64 %indvars.iv567, %166
  br i1 %.not443.not490, label %.lr.ph494.preheader, label %.loopexit

.lr.ph494.preheader:                              ; preds = %._crit_edge590
  %min.iters.check760 = icmp ult i64 %176, 8
  br i1 %min.iters.check760, label %.lr.ph494.preheader785, label %vector.scevcheck730

vector.scevcheck730:                              ; preds = %.lr.ph494.preheader
  %mul.result = shl i64 %181, 3
  %211 = getelementptr i8, ptr %scevgep733, i64 %mul.result
  %212 = icmp ult ptr %211, %scevgep733
  %mul.result737 = shl i64 %181, 3
  %mul.overflow738 = icmp ugt i64 %181, 2305843009213693951
  %213 = getelementptr i8, ptr %scevgep735, i64 %mul.result737
  %214 = icmp ult ptr %213, %scevgep735
  %215 = or i1 %214, %mul.overflow738
  %216 = or i1 %212, %215
  br i1 %216, label %.lr.ph494.preheader785, label %vector.memcheck739

vector.memcheck739:                               ; preds = %vector.scevcheck730
  %bound0751 = icmp ult ptr %scevgep740, %scevgep744
  %bound1752 = icmp ult ptr %gep801, %scevgep742
  %found.conflict753 = and i1 %bound0751, %bound1752
  %bound0754 = icmp ult ptr %scevgep746, %scevgep750
  %bound1755 = icmp ult ptr %gep803, %scevgep748
  %found.conflict756 = and i1 %bound0754, %bound1755
  %conflict.rdx757 = or i1 %found.conflict753, %found.conflict756
  br i1 %conflict.rdx757, label %.lr.ph494.preheader785, label %vector.ph761

vector.ph761:                                     ; preds = %vector.memcheck739
  %n.vec763 = and i64 %176, -4
  %ind.end764 = add i64 %indvars.iv567, %n.vec763
  %ind.end766 = add i64 %n.vec763, %190
  %broadcast.splat776 = shufflevector <2 x float> %200, <2 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
  %broadcast.splat778 = shufflevector <2 x float> %200, <2 x float> poison, <4 x i32> zeroinitializer
  %217 = getelementptr %struct.complex, ptr %3, i64 %indvars.iv567
  %invariant.gep798 = getelementptr %struct.complex, ptr %5, i64 %190
  br label %vector.body768

vector.body768:                                   ; preds = %vector.body768, %vector.ph761
  %index769 = phi i64 [ 0, %vector.ph761 ], [ %index.next783, %vector.body768 ]
  %218 = getelementptr %struct.complex, ptr %217, i64 %index769
  %wide.vec772 = load <8 x float>, ptr %218, align 4, !tbaa !13
  %strided.vec773 = shufflevector <8 x float> %wide.vec772, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec774 = shufflevector <8 x float> %wide.vec772, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %219 = fneg <4 x float> %strided.vec774
  %220 = fmul <4 x float> %broadcast.splat776, %219
  %221 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %strided.vec773, <4 x float> %broadcast.splat778, <4 x float> %220)
  %222 = fmul <4 x float> %broadcast.splat778, %strided.vec774
  %223 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %strided.vec773, <4 x float> %broadcast.splat776, <4 x float> %222)
  %gep799 = getelementptr %struct.complex, ptr %invariant.gep798, i64 %index769
  %wide.vec779 = load <8 x float>, ptr %gep799, align 4, !tbaa !13
  %strided.vec780 = shufflevector <8 x float> %wide.vec779, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec781 = shufflevector <8 x float> %wide.vec779, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %224 = fadd <4 x float> %strided.vec780, %221
  %225 = fadd <4 x float> %strided.vec781, %223
  %interleaved.vec782 = shufflevector <4 x float> %224, <4 x float> %225, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec782, ptr %gep799, align 4, !tbaa !13
  %index.next783 = add nuw i64 %index769, 4
  %226 = icmp eq i64 %index.next783, %n.vec763
  br i1 %226, label %middle.block758, label %vector.body768, !llvm.loop !22

middle.block758:                                  ; preds = %vector.body768
  %cmp.n784 = icmp eq i64 %176, %n.vec763
  br i1 %cmp.n784, label %.loopexit, label %.lr.ph494.preheader785

.lr.ph494.preheader785:                           ; preds = %middle.block758, %vector.memcheck739, %vector.scevcheck730, %.lr.ph494.preheader
  %indvars.iv569.ph = phi i64 [ %indvars.iv567, %vector.memcheck739 ], [ %indvars.iv567, %vector.scevcheck730 ], [ %indvars.iv567, %.lr.ph494.preheader ], [ %ind.end764, %middle.block758 ]
  %indvars.iv565.ph = phi i64 [ %190, %vector.memcheck739 ], [ %190, %vector.scevcheck730 ], [ %190, %.lr.ph494.preheader ], [ %ind.end766, %middle.block758 ]
  br label %.lr.ph494

.lr.ph494:                                        ; preds = %.lr.ph494.preheader785, %.lr.ph494
  %indvars.iv569 = phi i64 [ %indvars.iv.next570, %.lr.ph494 ], [ %indvars.iv569.ph, %.lr.ph494.preheader785 ]
  %indvars.iv565 = phi i64 [ %indvars.iv.next566, %.lr.ph494 ], [ %indvars.iv565.ph, %.lr.ph494.preheader785 ]
  %indvars.iv.next570 = add nuw nsw i64 %indvars.iv569, 1
  %indvars.iv.next566 = add nsw i64 %indvars.iv565, 1
  %227 = getelementptr %struct.complex, ptr %3, i64 %indvars.iv569
  %228 = load float, ptr %227, align 4, !tbaa !9
  %229 = getelementptr inbounds i8, ptr %227, i64 4
  %230 = load float, ptr %229, align 4, !tbaa !12
  %231 = fneg float %230
  %232 = getelementptr %struct.complex, ptr %5, i64 %indvars.iv565
  %233 = insertelement <2 x float> poison, float %230, i64 0
  %234 = insertelement <2 x float> %233, float %231, i64 1
  %235 = fmul <2 x float> %200, %234
  %236 = shufflevector <2 x float> %235, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %237 = insertelement <2 x float> poison, float %228, i64 0
  %238 = shufflevector <2 x float> %237, <2 x float> poison, <2 x i32> zeroinitializer
  %239 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %238, <2 x float> %200, <2 x float> %236)
  %240 = load <2 x float>, ptr %232, align 4, !tbaa !13
  %241 = fadd <2 x float> %240, %239
  store <2 x float> %241, ptr %232, align 4, !tbaa !13
  %exitcond575.not = icmp eq i64 %indvars.iv.next570, %wide.trip.count574
  br i1 %exitcond575.not, label %.loopexit, label %.lr.ph494, !llvm.loop !23

.loopexit:                                        ; preds = %.lr.ph494, %middle.block758, %174, %._crit_edge590
  %indvars.iv.next564 = add i32 %indvars.iv563, %indvars.iv561
  %indvars.iv.next568 = add nuw nsw i64 %indvars.iv567, 1
  %indvars.iv.next562 = add i32 %indvars.iv561, -1
  %exitcond578.not = icmp eq i64 %indvars.iv.next568, %wide.trip.count577
  %indvar.next732 = add i64 %indvar731, 1
  br i1 %exitcond578.not, label %.loopexit449, label %174, !llvm.loop !24

242:                                              ; preds = %162
  br i1 %.not442495, label %.loopexit449, label %.lr.ph489

.lr.ph489:                                        ; preds = %242
  %243 = getelementptr inbounds i8, ptr %2, i64 4
  %244 = add nuw i32 %40, 1
  %245 = sext i32 %.0 to i64
  %246 = sext i32 %38 to i64
  %wide.trip.count559 = zext i32 %244 to i64
  br label %247

247:                                              ; preds = %.lr.ph489, %.loopexit450
  %indvars.iv551 = phi i64 [ 1, %.lr.ph489 ], [ %indvars.iv.next552, %.loopexit450 ]
  %indvars.iv549 = phi i64 [ -1, %.lr.ph489 ], [ %indvars.iv.next550, %.loopexit450 ]
  %indvars.iv546 = phi i32 [ %40, %.lr.ph489 ], [ %indvars.iv.next547, %.loopexit450 ]
  %indvars.iv544.in = phi i32 [ %40, %.lr.ph489 ], [ %indvars.iv544, %.loopexit450 ]
  %indvars.iv537 = phi i32 [ 1, %.lr.ph489 ], [ %indvars.iv.next538, %.loopexit450 ]
  %indvars.iv535 = phi i32 [ %40, %.lr.ph489 ], [ %indvars.iv.next536, %.loopexit450 ]
  %indvars.iv531 = phi i64 [ %245, %.lr.ph489 ], [ %indvars.iv.next532, %.loopexit450 ]
  %indvars.iv544 = add i32 %indvars.iv544.in, -1
  %248 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv531
  %249 = load <2 x float>, ptr %248, align 4, !tbaa !13
  %250 = extractelement <2 x float> %249, i64 0
  %251 = fcmp une float %250, 0.000000e+00
  %252 = extractelement <2 x float> %249, i64 1
  %253 = fcmp une float %252, 0.000000e+00
  %or.cond602 = select i1 %251, i1 true, i1 %253
  br i1 %or.cond602, label %._crit_edge587, label %.loopexit450

._crit_edge587:                                   ; preds = %247
  %254 = sext i32 %indvars.iv537 to i64
  %255 = load float, ptr %2, align 4, !tbaa !9
  %256 = load float, ptr %243, align 4, !tbaa !12
  %257 = fneg float %256
  %258 = insertelement <2 x float> poison, float %256, i64 0
  %259 = insertelement <2 x float> %258, float %257, i64 1
  %260 = fmul <2 x float> %249, %259
  %261 = shufflevector <2 x float> %260, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %262 = insertelement <2 x float> poison, float %255, i64 0
  %263 = shufflevector <2 x float> %262, <2 x float> poison, <2 x i32> zeroinitializer
  %264 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %263, <2 x float> %249, <2 x float> %261)
  %265 = getelementptr inbounds %struct.complex, ptr %8, i64 %254
  %266 = shufflevector <2 x float> %264, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %267 = fneg <2 x float> %264
  %268 = shufflevector <2 x float> %266, <2 x float> %267, <2 x i32> <i32 0, i32 3>
  %269 = fmul <2 x float> %249, %268
  %270 = shufflevector <2 x float> %269, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %271 = shufflevector <2 x float> %264, <2 x float> poison, <2 x i32> zeroinitializer
  %272 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %271, <2 x float> %249, <2 x float> %270)
  %273 = load <2 x float>, ptr %265, align 4, !tbaa !13
  %274 = fadd <2 x float> %273, %272
  store <2 x float> %274, ptr %265, align 4, !tbaa !13
  %275 = trunc nsw i64 %indvars.iv549 to i32
  %276 = add i32 %40, %275
  %277 = add i32 %276, %indvars.iv537
  %.not441.not476 = icmp slt i32 %indvars.iv537, %277
  br i1 %.not441.not476, label %.lr.ph480, label %.loopexit450

.lr.ph480:                                        ; preds = %._crit_edge587, %.lr.ph480
  %indvars.iv539 = phi i64 [ %indvars.iv.next540, %.lr.ph480 ], [ %254, %._crit_edge587 ]
  %indvars.iv533 = phi i64 [ %indvars.iv.next534, %.lr.ph480 ], [ %indvars.iv531, %._crit_edge587 ]
  %indvars.iv.next540 = add nsw i64 %indvars.iv539, 1
  %indvars.iv.next534 = add nsw i64 %indvars.iv533, %246
  %278 = getelementptr inbounds %struct.complex, ptr %9, i64 %indvars.iv.next534
  %279 = load float, ptr %278, align 4, !tbaa !9
  %280 = getelementptr inbounds i8, ptr %278, i64 4
  %281 = load float, ptr %280, align 4, !tbaa !12
  %282 = fneg float %281
  %283 = getelementptr %struct.complex, ptr %5, i64 %indvars.iv539
  %284 = insertelement <2 x float> poison, float %281, i64 0
  %285 = insertelement <2 x float> %284, float %282, i64 1
  %286 = fmul <2 x float> %264, %285
  %287 = shufflevector <2 x float> %286, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %288 = insertelement <2 x float> poison, float %279, i64 0
  %289 = shufflevector <2 x float> %288, <2 x float> poison, <2 x i32> zeroinitializer
  %290 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %289, <2 x float> %264, <2 x float> %287)
  %291 = load <2 x float>, ptr %283, align 4, !tbaa !13
  %292 = fadd <2 x float> %291, %290
  store <2 x float> %292, ptr %283, align 4, !tbaa !13
  %lftr.wideiv = trunc i64 %indvars.iv.next540 to i32
  %exitcond548.not = icmp eq i32 %indvars.iv546, %lftr.wideiv
  br i1 %exitcond548.not, label %.loopexit450, label %.lr.ph480, !llvm.loop !25

.loopexit450:                                     ; preds = %.lr.ph480, %247, %._crit_edge587
  %indvars.iv.next532 = add nsw i64 %indvars.iv531, %246
  %indvars.iv.next538 = add i32 %indvars.iv537, %indvars.iv535
  %indvars.iv.next552 = add nuw nsw i64 %indvars.iv551, 1
  %indvars.iv.next536 = add i32 %indvars.iv535, -1
  %indvars.iv.next547 = add i32 %indvars.iv546, %indvars.iv544
  %indvars.iv.next550 = add nsw i64 %indvars.iv549, -1
  %exitcond560.not = icmp eq i64 %indvars.iv.next552, %wide.trip.count559
  br i1 %exitcond560.not, label %.loopexit449, label %247, !llvm.loop !26

.loopexit449:                                     ; preds = %161, %104, %.loopexit450, %.loopexit, %107, %42, %242, %163, %23, %28, %.thread
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %7) #4
  ret void
}

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

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

declare i32 @xerbla_(ptr noundef, ptr noundef, i32 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 <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #3

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

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 = { 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 = !{!"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 4}
!11 = !{!"float", !7, i64 0}
!12 = !{!10, !11, i64 4}
!13 = !{!11, !11, i64 0}
!14 = distinct !{!14, !15, !16, !17}
!15 = !{!"llvm.loop.mustprogress"}
!16 = !{!"llvm.loop.isvectorized", i32 1}
!17 = !{!"llvm.loop.unroll.runtime.disable"}
!18 = distinct !{!18, !15, !16}
!19 = distinct !{!19, !15}
!20 = distinct !{!20, !15, !16}
!21 = distinct !{!21, !15}
!22 = distinct !{!22, !15, !16, !17}
!23 = distinct !{!23, !15, !16}
!24 = distinct !{!24, !15}
!25 = distinct !{!25, !15, !16}
!26 = distinct !{!26, !15}


; Effective O3 passes: BDCEPass,DSEPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass