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

; 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 }

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

65:                                               ; preds = %10
  %66 = load ptr, ptr %14, align 8, !tbaa !5
  %67 = load i64, ptr %66, align 8, !tbaa !9
  %68 = icmp eq i64 %67, 0
  br i1 %68, label %69, label %70

69:                                               ; preds = %65, %10
  store i32 0, ptr %11, align 4
  store i32 1, ptr %43, align 4
  br label %3259

70:                                               ; preds = %65
  %71 = load ptr, ptr %12, align 8, !tbaa !5
  %72 = load i64, ptr %71, align 8, !tbaa !9
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %74, label %1219

74:                                               ; preds = %70
  %75 = load ptr, ptr %14, align 8, !tbaa !5
  %76 = load i64, ptr %75, align 8, !tbaa !9
  %77 = icmp sle i64 %76, 1
  br i1 %77, label %78, label %647

78:                                               ; preds = %74
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %79

79:                                               ; preds = %643, %78
  %80 = load ptr, ptr %13, align 8, !tbaa !5
  %81 = load i64, ptr %80, align 8, !tbaa !9
  %82 = sub nsw i64 %81, 1
  store i64 %82, ptr %24, align 8, !tbaa !9
  store i64 1, ptr %40, align 8, !tbaa !9
  br label %83

83:                                               ; preds = %321, %79
  %84 = load i64, ptr %40, align 8, !tbaa !9
  %85 = load i64, ptr %24, align 8, !tbaa !9
  %86 = icmp sle i64 %84, %85
  br i1 %86, label %87, label %324

87:                                               ; preds = %83
  %88 = load ptr, ptr %19, align 8, !tbaa !5
  %89 = load i64, ptr %40, align 8, !tbaa !9
  %90 = getelementptr inbounds i64, ptr %88, i64 %89
  %91 = load i64, ptr %90, align 8, !tbaa !9
  %92 = load i64, ptr %40, align 8, !tbaa !9
  %93 = icmp eq i64 %91, %92
  br i1 %93, label %94, label %190

94:                                               ; preds = %87
  %95 = load i64, ptr %40, align 8, !tbaa !9
  %96 = add nsw i64 %95, 1
  %97 = load i64, ptr %41, align 8, !tbaa !9
  %98 = load i64, ptr %22, align 8, !tbaa !9
  %99 = mul nsw i64 %97, %98
  %100 = add nsw i64 %96, %99
  store i64 %100, ptr %25, align 8, !tbaa !9
  %101 = load i64, ptr %40, align 8, !tbaa !9
  %102 = add nsw i64 %101, 1
  %103 = load i64, ptr %41, align 8, !tbaa !9
  %104 = load i64, ptr %22, align 8, !tbaa !9
  %105 = mul nsw i64 %103, %104
  %106 = add nsw i64 %102, %105
  store i64 %106, ptr %26, align 8, !tbaa !9
  %107 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %107, ptr %27, align 8, !tbaa !9
  %108 = load i64, ptr %40, align 8, !tbaa !9
  %109 = load i64, ptr %41, align 8, !tbaa !9
  %110 = load i64, ptr %22, align 8, !tbaa !9
  %111 = mul nsw i64 %109, %110
  %112 = add nsw i64 %108, %111
  store i64 %112, ptr %28, align 8, !tbaa !9
  %113 = load ptr, ptr %15, align 8, !tbaa !5
  %114 = load i64, ptr %27, align 8, !tbaa !9
  %115 = getelementptr inbounds %struct.complex, ptr %113, i64 %114
  %116 = getelementptr inbounds %struct.complex, ptr %115, i32 0, i32 0
  %117 = load float, ptr %116, align 4, !tbaa !11
  %118 = load ptr, ptr %20, align 8, !tbaa !5
  %119 = load i64, ptr %28, align 8, !tbaa !9
  %120 = getelementptr inbounds %struct.complex, ptr %118, i64 %119
  %121 = getelementptr inbounds %struct.complex, ptr %120, i32 0, i32 0
  %122 = load float, ptr %121, align 4, !tbaa !11
  %123 = load ptr, ptr %15, align 8, !tbaa !5
  %124 = load i64, ptr %27, align 8, !tbaa !9
  %125 = getelementptr inbounds %struct.complex, ptr %123, i64 %124
  %126 = getelementptr inbounds %struct.complex, ptr %125, i32 0, i32 1
  %127 = load float, ptr %126, align 4, !tbaa !14
  %128 = load ptr, ptr %20, align 8, !tbaa !5
  %129 = load i64, ptr %28, align 8, !tbaa !9
  %130 = getelementptr inbounds %struct.complex, ptr %128, i64 %129
  %131 = getelementptr inbounds %struct.complex, ptr %130, i32 0, i32 1
  %132 = load float, ptr %131, align 4, !tbaa !14
  %133 = fmul float %127, %132
  %134 = fneg float %133
  %135 = call float @llvm.fmuladd.f32(float %117, float %122, float %134)
  %136 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %135, ptr %136, align 4, !tbaa !11
  %137 = load ptr, ptr %15, align 8, !tbaa !5
  %138 = load i64, ptr %27, align 8, !tbaa !9
  %139 = getelementptr inbounds %struct.complex, ptr %137, i64 %138
  %140 = getelementptr inbounds %struct.complex, ptr %139, i32 0, i32 0
  %141 = load float, ptr %140, align 4, !tbaa !11
  %142 = load ptr, ptr %20, align 8, !tbaa !5
  %143 = load i64, ptr %28, align 8, !tbaa !9
  %144 = getelementptr inbounds %struct.complex, ptr %142, i64 %143
  %145 = getelementptr inbounds %struct.complex, ptr %144, i32 0, i32 1
  %146 = load float, ptr %145, align 4, !tbaa !14
  %147 = load ptr, ptr %15, align 8, !tbaa !5
  %148 = load i64, ptr %27, align 8, !tbaa !9
  %149 = getelementptr inbounds %struct.complex, ptr %147, i64 %148
  %150 = getelementptr inbounds %struct.complex, ptr %149, i32 0, i32 1
  %151 = load float, ptr %150, align 4, !tbaa !14
  %152 = load ptr, ptr %20, align 8, !tbaa !5
  %153 = load i64, ptr %28, align 8, !tbaa !9
  %154 = getelementptr inbounds %struct.complex, ptr %152, i64 %153
  %155 = getelementptr inbounds %struct.complex, ptr %154, i32 0, i32 0
  %156 = load float, ptr %155, align 4, !tbaa !11
  %157 = fmul float %151, %156
  %158 = call float @llvm.fmuladd.f32(float %141, float %146, float %157)
  %159 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %158, ptr %159, align 4, !tbaa !14
  %160 = load ptr, ptr %20, align 8, !tbaa !5
  %161 = load i64, ptr %26, align 8, !tbaa !9
  %162 = getelementptr inbounds %struct.complex, ptr %160, i64 %161
  %163 = getelementptr inbounds %struct.complex, ptr %162, i32 0, i32 0
  %164 = load float, ptr %163, align 4, !tbaa !11
  %165 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %166 = load float, ptr %165, align 4, !tbaa !11
  %167 = fsub float %164, %166
  %168 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %167, ptr %168, align 4, !tbaa !11
  %169 = load ptr, ptr %20, align 8, !tbaa !5
  %170 = load i64, ptr %26, align 8, !tbaa !9
  %171 = getelementptr inbounds %struct.complex, ptr %169, i64 %170
  %172 = getelementptr inbounds %struct.complex, ptr %171, i32 0, i32 1
  %173 = load float, ptr %172, align 4, !tbaa !14
  %174 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %175 = load float, ptr %174, align 4, !tbaa !14
  %176 = fsub float %173, %175
  %177 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %176, ptr %177, align 4, !tbaa !14
  %178 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %179 = load float, ptr %178, align 4, !tbaa !11
  %180 = load ptr, ptr %20, align 8, !tbaa !5
  %181 = load i64, ptr %25, align 8, !tbaa !9
  %182 = getelementptr inbounds %struct.complex, ptr %180, i64 %181
  %183 = getelementptr inbounds %struct.complex, ptr %182, i32 0, i32 0
  store float %179, ptr %183, align 4, !tbaa !11
  %184 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %185 = load float, ptr %184, align 4, !tbaa !14
  %186 = load ptr, ptr %20, align 8, !tbaa !5
  %187 = load i64, ptr %25, align 8, !tbaa !9
  %188 = getelementptr inbounds %struct.complex, ptr %186, i64 %187
  %189 = getelementptr inbounds %struct.complex, ptr %188, i32 0, i32 1
  store float %185, ptr %189, align 4, !tbaa !14
  br label %320

190:                                              ; preds = %87
  %191 = load i64, ptr %40, align 8, !tbaa !9
  %192 = load i64, ptr %41, align 8, !tbaa !9
  %193 = load i64, ptr %22, align 8, !tbaa !9
  %194 = mul nsw i64 %192, %193
  %195 = add nsw i64 %191, %194
  store i64 %195, ptr %25, align 8, !tbaa !9
  %196 = load ptr, ptr %20, align 8, !tbaa !5
  %197 = load i64, ptr %25, align 8, !tbaa !9
  %198 = getelementptr inbounds %struct.complex, ptr %196, i64 %197
  %199 = getelementptr inbounds %struct.complex, ptr %198, i32 0, i32 0
  %200 = load float, ptr %199, align 4, !tbaa !11
  %201 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %200, ptr %201, align 4, !tbaa !11
  %202 = load ptr, ptr %20, align 8, !tbaa !5
  %203 = load i64, ptr %25, align 8, !tbaa !9
  %204 = getelementptr inbounds %struct.complex, ptr %202, i64 %203
  %205 = getelementptr inbounds %struct.complex, ptr %204, i32 0, i32 1
  %206 = load float, ptr %205, align 4, !tbaa !14
  %207 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %206, ptr %207, align 4, !tbaa !14
  %208 = load i64, ptr %40, align 8, !tbaa !9
  %209 = load i64, ptr %41, align 8, !tbaa !9
  %210 = load i64, ptr %22, align 8, !tbaa !9
  %211 = mul nsw i64 %209, %210
  %212 = add nsw i64 %208, %211
  store i64 %212, ptr %25, align 8, !tbaa !9
  %213 = load i64, ptr %40, align 8, !tbaa !9
  %214 = add nsw i64 %213, 1
  %215 = load i64, ptr %41, align 8, !tbaa !9
  %216 = load i64, ptr %22, align 8, !tbaa !9
  %217 = mul nsw i64 %215, %216
  %218 = add nsw i64 %214, %217
  store i64 %218, ptr %26, align 8, !tbaa !9
  %219 = load ptr, ptr %20, align 8, !tbaa !5
  %220 = load i64, ptr %26, align 8, !tbaa !9
  %221 = getelementptr inbounds %struct.complex, ptr %219, i64 %220
  %222 = getelementptr inbounds %struct.complex, ptr %221, i32 0, i32 0
  %223 = load float, ptr %222, align 4, !tbaa !11
  %224 = load ptr, ptr %20, align 8, !tbaa !5
  %225 = load i64, ptr %25, align 8, !tbaa !9
  %226 = getelementptr inbounds %struct.complex, ptr %224, i64 %225
  %227 = getelementptr inbounds %struct.complex, ptr %226, i32 0, i32 0
  store float %223, ptr %227, align 4, !tbaa !11
  %228 = load ptr, ptr %20, align 8, !tbaa !5
  %229 = load i64, ptr %26, align 8, !tbaa !9
  %230 = getelementptr inbounds %struct.complex, ptr %228, i64 %229
  %231 = getelementptr inbounds %struct.complex, ptr %230, i32 0, i32 1
  %232 = load float, ptr %231, align 4, !tbaa !14
  %233 = load ptr, ptr %20, align 8, !tbaa !5
  %234 = load i64, ptr %25, align 8, !tbaa !9
  %235 = getelementptr inbounds %struct.complex, ptr %233, i64 %234
  %236 = getelementptr inbounds %struct.complex, ptr %235, i32 0, i32 1
  store float %232, ptr %236, align 4, !tbaa !14
  %237 = load i64, ptr %40, align 8, !tbaa !9
  %238 = add nsw i64 %237, 1
  %239 = load i64, ptr %41, align 8, !tbaa !9
  %240 = load i64, ptr %22, align 8, !tbaa !9
  %241 = mul nsw i64 %239, %240
  %242 = add nsw i64 %238, %241
  store i64 %242, ptr %25, align 8, !tbaa !9
  %243 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %243, ptr %26, align 8, !tbaa !9
  %244 = load i64, ptr %40, align 8, !tbaa !9
  %245 = load i64, ptr %41, align 8, !tbaa !9
  %246 = load i64, ptr %22, align 8, !tbaa !9
  %247 = mul nsw i64 %245, %246
  %248 = add nsw i64 %244, %247
  store i64 %248, ptr %27, align 8, !tbaa !9
  %249 = load ptr, ptr %15, align 8, !tbaa !5
  %250 = load i64, ptr %26, align 8, !tbaa !9
  %251 = getelementptr inbounds %struct.complex, ptr %249, i64 %250
  %252 = getelementptr inbounds %struct.complex, ptr %251, i32 0, i32 0
  %253 = load float, ptr %252, align 4, !tbaa !11
  %254 = load ptr, ptr %20, align 8, !tbaa !5
  %255 = load i64, ptr %27, align 8, !tbaa !9
  %256 = getelementptr inbounds %struct.complex, ptr %254, i64 %255
  %257 = getelementptr inbounds %struct.complex, ptr %256, i32 0, i32 0
  %258 = load float, ptr %257, align 4, !tbaa !11
  %259 = load ptr, ptr %15, align 8, !tbaa !5
  %260 = load i64, ptr %26, align 8, !tbaa !9
  %261 = getelementptr inbounds %struct.complex, ptr %259, i64 %260
  %262 = getelementptr inbounds %struct.complex, ptr %261, i32 0, i32 1
  %263 = load float, ptr %262, align 4, !tbaa !14
  %264 = load ptr, ptr %20, align 8, !tbaa !5
  %265 = load i64, ptr %27, align 8, !tbaa !9
  %266 = getelementptr inbounds %struct.complex, ptr %264, i64 %265
  %267 = getelementptr inbounds %struct.complex, ptr %266, i32 0, i32 1
  %268 = load float, ptr %267, align 4, !tbaa !14
  %269 = fmul float %263, %268
  %270 = fneg float %269
  %271 = call float @llvm.fmuladd.f32(float %253, float %258, float %270)
  %272 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %271, ptr %272, align 4, !tbaa !11
  %273 = load ptr, ptr %15, align 8, !tbaa !5
  %274 = load i64, ptr %26, align 8, !tbaa !9
  %275 = getelementptr inbounds %struct.complex, ptr %273, i64 %274
  %276 = getelementptr inbounds %struct.complex, ptr %275, i32 0, i32 0
  %277 = load float, ptr %276, align 4, !tbaa !11
  %278 = load ptr, ptr %20, align 8, !tbaa !5
  %279 = load i64, ptr %27, align 8, !tbaa !9
  %280 = getelementptr inbounds %struct.complex, ptr %278, i64 %279
  %281 = getelementptr inbounds %struct.complex, ptr %280, i32 0, i32 1
  %282 = load float, ptr %281, align 4, !tbaa !14
  %283 = load ptr, ptr %15, align 8, !tbaa !5
  %284 = load i64, ptr %26, align 8, !tbaa !9
  %285 = getelementptr inbounds %struct.complex, ptr %283, i64 %284
  %286 = getelementptr inbounds %struct.complex, ptr %285, i32 0, i32 1
  %287 = load float, ptr %286, align 4, !tbaa !14
  %288 = load ptr, ptr %20, align 8, !tbaa !5
  %289 = load i64, ptr %27, align 8, !tbaa !9
  %290 = getelementptr inbounds %struct.complex, ptr %288, i64 %289
  %291 = getelementptr inbounds %struct.complex, ptr %290, i32 0, i32 0
  %292 = load float, ptr %291, align 4, !tbaa !11
  %293 = fmul float %287, %292
  %294 = call float @llvm.fmuladd.f32(float %277, float %282, float %293)
  %295 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %294, ptr %295, align 4, !tbaa !14
  %296 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %297 = load float, ptr %296, align 4, !tbaa !11
  %298 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %299 = load float, ptr %298, align 4, !tbaa !11
  %300 = fsub float %297, %299
  %301 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %300, ptr %301, align 4, !tbaa !11
  %302 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %303 = load float, ptr %302, align 4, !tbaa !14
  %304 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %305 = load float, ptr %304, align 4, !tbaa !14
  %306 = fsub float %303, %305
  %307 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %306, ptr %307, align 4, !tbaa !14
  %308 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %309 = load float, ptr %308, align 4, !tbaa !11
  %310 = load ptr, ptr %20, align 8, !tbaa !5
  %311 = load i64, ptr %25, align 8, !tbaa !9
  %312 = getelementptr inbounds %struct.complex, ptr %310, i64 %311
  %313 = getelementptr inbounds %struct.complex, ptr %312, i32 0, i32 0
  store float %309, ptr %313, align 4, !tbaa !11
  %314 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %315 = load float, ptr %314, align 4, !tbaa !14
  %316 = load ptr, ptr %20, align 8, !tbaa !5
  %317 = load i64, ptr %25, align 8, !tbaa !9
  %318 = getelementptr inbounds %struct.complex, ptr %316, i64 %317
  %319 = getelementptr inbounds %struct.complex, ptr %318, i32 0, i32 1
  store float %315, ptr %319, align 4, !tbaa !14
  br label %320

320:                                              ; preds = %190, %94
  br label %321

321:                                              ; preds = %320
  %322 = load i64, ptr %40, align 8, !tbaa !9
  %323 = add nsw i64 %322, 1
  store i64 %323, ptr %40, align 8, !tbaa !9
  br label %83, !llvm.loop !15

324:                                              ; preds = %83
  %325 = load ptr, ptr %13, align 8, !tbaa !5
  %326 = load i64, ptr %325, align 8, !tbaa !9
  %327 = load i64, ptr %41, align 8, !tbaa !9
  %328 = load i64, ptr %22, align 8, !tbaa !9
  %329 = mul nsw i64 %327, %328
  %330 = add nsw i64 %326, %329
  store i64 %330, ptr %24, align 8, !tbaa !9
  %331 = load ptr, ptr %20, align 8, !tbaa !5
  %332 = load ptr, ptr %13, align 8, !tbaa !5
  %333 = load i64, ptr %332, align 8, !tbaa !9
  %334 = load i64, ptr %41, align 8, !tbaa !9
  %335 = load i64, ptr %22, align 8, !tbaa !9
  %336 = mul nsw i64 %334, %335
  %337 = add nsw i64 %333, %336
  %338 = getelementptr inbounds %struct.complex, ptr %331, i64 %337
  %339 = load ptr, ptr %16, align 8, !tbaa !5
  %340 = load ptr, ptr %13, align 8, !tbaa !5
  %341 = load i64, ptr %340, align 8, !tbaa !9
  %342 = getelementptr inbounds %struct.complex, ptr %339, i64 %341
  call void @c_div(ptr noundef %32, ptr noundef %338, ptr noundef %342)
  %343 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %344 = load float, ptr %343, align 4, !tbaa !11
  %345 = load ptr, ptr %20, align 8, !tbaa !5
  %346 = load i64, ptr %24, align 8, !tbaa !9
  %347 = getelementptr inbounds %struct.complex, ptr %345, i64 %346
  %348 = getelementptr inbounds %struct.complex, ptr %347, i32 0, i32 0
  store float %344, ptr %348, align 4, !tbaa !11
  %349 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %350 = load float, ptr %349, align 4, !tbaa !14
  %351 = load ptr, ptr %20, align 8, !tbaa !5
  %352 = load i64, ptr %24, align 8, !tbaa !9
  %353 = getelementptr inbounds %struct.complex, ptr %351, i64 %352
  %354 = getelementptr inbounds %struct.complex, ptr %353, i32 0, i32 1
  store float %350, ptr %354, align 4, !tbaa !14
  %355 = load ptr, ptr %13, align 8, !tbaa !5
  %356 = load i64, ptr %355, align 8, !tbaa !9
  %357 = icmp sgt i64 %356, 1
  br i1 %357, label %358, label %464

358:                                              ; preds = %324
  %359 = load ptr, ptr %13, align 8, !tbaa !5
  %360 = load i64, ptr %359, align 8, !tbaa !9
  %361 = sub nsw i64 %360, 1
  %362 = load i64, ptr %41, align 8, !tbaa !9
  %363 = load i64, ptr %22, align 8, !tbaa !9
  %364 = mul nsw i64 %362, %363
  %365 = add nsw i64 %361, %364
  store i64 %365, ptr %24, align 8, !tbaa !9
  %366 = load ptr, ptr %13, align 8, !tbaa !5
  %367 = load i64, ptr %366, align 8, !tbaa !9
  %368 = sub nsw i64 %367, 1
  %369 = load i64, ptr %41, align 8, !tbaa !9
  %370 = load i64, ptr %22, align 8, !tbaa !9
  %371 = mul nsw i64 %369, %370
  %372 = add nsw i64 %368, %371
  store i64 %372, ptr %25, align 8, !tbaa !9
  %373 = load ptr, ptr %13, align 8, !tbaa !5
  %374 = load i64, ptr %373, align 8, !tbaa !9
  %375 = sub nsw i64 %374, 1
  store i64 %375, ptr %26, align 8, !tbaa !9
  %376 = load ptr, ptr %13, align 8, !tbaa !5
  %377 = load i64, ptr %376, align 8, !tbaa !9
  %378 = load i64, ptr %41, align 8, !tbaa !9
  %379 = load i64, ptr %22, align 8, !tbaa !9
  %380 = mul nsw i64 %378, %379
  %381 = add nsw i64 %377, %380
  store i64 %381, ptr %27, align 8, !tbaa !9
  %382 = load ptr, ptr %17, align 8, !tbaa !5
  %383 = load i64, ptr %26, align 8, !tbaa !9
  %384 = getelementptr inbounds %struct.complex, ptr %382, i64 %383
  %385 = getelementptr inbounds %struct.complex, ptr %384, i32 0, i32 0
  %386 = load float, ptr %385, align 4, !tbaa !11
  %387 = load ptr, ptr %20, align 8, !tbaa !5
  %388 = load i64, ptr %27, align 8, !tbaa !9
  %389 = getelementptr inbounds %struct.complex, ptr %387, i64 %388
  %390 = getelementptr inbounds %struct.complex, ptr %389, i32 0, i32 0
  %391 = load float, ptr %390, align 4, !tbaa !11
  %392 = load ptr, ptr %17, align 8, !tbaa !5
  %393 = load i64, ptr %26, align 8, !tbaa !9
  %394 = getelementptr inbounds %struct.complex, ptr %392, i64 %393
  %395 = getelementptr inbounds %struct.complex, ptr %394, i32 0, i32 1
  %396 = load float, ptr %395, align 4, !tbaa !14
  %397 = load ptr, ptr %20, align 8, !tbaa !5
  %398 = load i64, ptr %27, align 8, !tbaa !9
  %399 = getelementptr inbounds %struct.complex, ptr %397, i64 %398
  %400 = getelementptr inbounds %struct.complex, ptr %399, i32 0, i32 1
  %401 = load float, ptr %400, align 4, !tbaa !14
  %402 = fmul float %396, %401
  %403 = fneg float %402
  %404 = call float @llvm.fmuladd.f32(float %386, float %391, float %403)
  %405 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %404, ptr %405, align 4, !tbaa !11
  %406 = load ptr, ptr %17, align 8, !tbaa !5
  %407 = load i64, ptr %26, align 8, !tbaa !9
  %408 = getelementptr inbounds %struct.complex, ptr %406, i64 %407
  %409 = getelementptr inbounds %struct.complex, ptr %408, i32 0, i32 0
  %410 = load float, ptr %409, align 4, !tbaa !11
  %411 = load ptr, ptr %20, align 8, !tbaa !5
  %412 = load i64, ptr %27, align 8, !tbaa !9
  %413 = getelementptr inbounds %struct.complex, ptr %411, i64 %412
  %414 = getelementptr inbounds %struct.complex, ptr %413, i32 0, i32 1
  %415 = load float, ptr %414, align 4, !tbaa !14
  %416 = load ptr, ptr %17, align 8, !tbaa !5
  %417 = load i64, ptr %26, align 8, !tbaa !9
  %418 = getelementptr inbounds %struct.complex, ptr %416, i64 %417
  %419 = getelementptr inbounds %struct.complex, ptr %418, i32 0, i32 1
  %420 = load float, ptr %419, align 4, !tbaa !14
  %421 = load ptr, ptr %20, align 8, !tbaa !5
  %422 = load i64, ptr %27, align 8, !tbaa !9
  %423 = getelementptr inbounds %struct.complex, ptr %421, i64 %422
  %424 = getelementptr inbounds %struct.complex, ptr %423, i32 0, i32 0
  %425 = load float, ptr %424, align 4, !tbaa !11
  %426 = fmul float %420, %425
  %427 = call float @llvm.fmuladd.f32(float %410, float %415, float %426)
  %428 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %427, ptr %428, align 4, !tbaa !14
  %429 = load ptr, ptr %20, align 8, !tbaa !5
  %430 = load i64, ptr %25, align 8, !tbaa !9
  %431 = getelementptr inbounds %struct.complex, ptr %429, i64 %430
  %432 = getelementptr inbounds %struct.complex, ptr %431, i32 0, i32 0
  %433 = load float, ptr %432, align 4, !tbaa !11
  %434 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %435 = load float, ptr %434, align 4, !tbaa !11
  %436 = fsub float %433, %435
  %437 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %436, ptr %437, align 4, !tbaa !11
  %438 = load ptr, ptr %20, align 8, !tbaa !5
  %439 = load i64, ptr %25, align 8, !tbaa !9
  %440 = getelementptr inbounds %struct.complex, ptr %438, i64 %439
  %441 = getelementptr inbounds %struct.complex, ptr %440, i32 0, i32 1
  %442 = load float, ptr %441, align 4, !tbaa !14
  %443 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %444 = load float, ptr %443, align 4, !tbaa !14
  %445 = fsub float %442, %444
  %446 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %445, ptr %446, align 4, !tbaa !14
  %447 = load ptr, ptr %16, align 8, !tbaa !5
  %448 = load ptr, ptr %13, align 8, !tbaa !5
  %449 = load i64, ptr %448, align 8, !tbaa !9
  %450 = sub nsw i64 %449, 1
  %451 = getelementptr inbounds %struct.complex, ptr %447, i64 %450
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %451)
  %452 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %453 = load float, ptr %452, align 4, !tbaa !11
  %454 = load ptr, ptr %20, align 8, !tbaa !5
  %455 = load i64, ptr %24, align 8, !tbaa !9
  %456 = getelementptr inbounds %struct.complex, ptr %454, i64 %455
  %457 = getelementptr inbounds %struct.complex, ptr %456, i32 0, i32 0
  store float %453, ptr %457, align 4, !tbaa !11
  %458 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %459 = load float, ptr %458, align 4, !tbaa !14
  %460 = load ptr, ptr %20, align 8, !tbaa !5
  %461 = load i64, ptr %24, align 8, !tbaa !9
  %462 = getelementptr inbounds %struct.complex, ptr %460, i64 %461
  %463 = getelementptr inbounds %struct.complex, ptr %462, i32 0, i32 1
  store float %459, ptr %463, align 4, !tbaa !14
  br label %464

464:                                              ; preds = %358, %324
  %465 = load ptr, ptr %13, align 8, !tbaa !5
  %466 = load i64, ptr %465, align 8, !tbaa !9
  %467 = sub nsw i64 %466, 2
  store i64 %467, ptr %40, align 8, !tbaa !9
  br label %468

468:                                              ; preds = %635, %464
  %469 = load i64, ptr %40, align 8, !tbaa !9
  %470 = icmp sge i64 %469, 1
  br i1 %470, label %471, label %638

471:                                              ; preds = %468
  %472 = load i64, ptr %40, align 8, !tbaa !9
  %473 = load i64, ptr %41, align 8, !tbaa !9
  %474 = load i64, ptr %22, align 8, !tbaa !9
  %475 = mul nsw i64 %473, %474
  %476 = add nsw i64 %472, %475
  store i64 %476, ptr %24, align 8, !tbaa !9
  %477 = load i64, ptr %40, align 8, !tbaa !9
  %478 = load i64, ptr %41, align 8, !tbaa !9
  %479 = load i64, ptr %22, align 8, !tbaa !9
  %480 = mul nsw i64 %478, %479
  %481 = add nsw i64 %477, %480
  store i64 %481, ptr %25, align 8, !tbaa !9
  %482 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %482, ptr %26, align 8, !tbaa !9
  %483 = load i64, ptr %40, align 8, !tbaa !9
  %484 = add nsw i64 %483, 1
  %485 = load i64, ptr %41, align 8, !tbaa !9
  %486 = load i64, ptr %22, align 8, !tbaa !9
  %487 = mul nsw i64 %485, %486
  %488 = add nsw i64 %484, %487
  store i64 %488, ptr %27, align 8, !tbaa !9
  %489 = load ptr, ptr %17, align 8, !tbaa !5
  %490 = load i64, ptr %26, align 8, !tbaa !9
  %491 = getelementptr inbounds %struct.complex, ptr %489, i64 %490
  %492 = getelementptr inbounds %struct.complex, ptr %491, i32 0, i32 0
  %493 = load float, ptr %492, align 4, !tbaa !11
  %494 = load ptr, ptr %20, align 8, !tbaa !5
  %495 = load i64, ptr %27, align 8, !tbaa !9
  %496 = getelementptr inbounds %struct.complex, ptr %494, i64 %495
  %497 = getelementptr inbounds %struct.complex, ptr %496, i32 0, i32 0
  %498 = load float, ptr %497, align 4, !tbaa !11
  %499 = load ptr, ptr %17, align 8, !tbaa !5
  %500 = load i64, ptr %26, align 8, !tbaa !9
  %501 = getelementptr inbounds %struct.complex, ptr %499, i64 %500
  %502 = getelementptr inbounds %struct.complex, ptr %501, i32 0, i32 1
  %503 = load float, ptr %502, align 4, !tbaa !14
  %504 = load ptr, ptr %20, align 8, !tbaa !5
  %505 = load i64, ptr %27, align 8, !tbaa !9
  %506 = getelementptr inbounds %struct.complex, ptr %504, i64 %505
  %507 = getelementptr inbounds %struct.complex, ptr %506, i32 0, i32 1
  %508 = load float, ptr %507, align 4, !tbaa !14
  %509 = fmul float %503, %508
  %510 = fneg float %509
  %511 = call float @llvm.fmuladd.f32(float %493, float %498, float %510)
  %512 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %511, ptr %512, align 4, !tbaa !11
  %513 = load ptr, ptr %17, align 8, !tbaa !5
  %514 = load i64, ptr %26, align 8, !tbaa !9
  %515 = getelementptr inbounds %struct.complex, ptr %513, i64 %514
  %516 = getelementptr inbounds %struct.complex, ptr %515, i32 0, i32 0
  %517 = load float, ptr %516, align 4, !tbaa !11
  %518 = load ptr, ptr %20, align 8, !tbaa !5
  %519 = load i64, ptr %27, align 8, !tbaa !9
  %520 = getelementptr inbounds %struct.complex, ptr %518, i64 %519
  %521 = getelementptr inbounds %struct.complex, ptr %520, i32 0, i32 1
  %522 = load float, ptr %521, align 4, !tbaa !14
  %523 = load ptr, ptr %17, align 8, !tbaa !5
  %524 = load i64, ptr %26, align 8, !tbaa !9
  %525 = getelementptr inbounds %struct.complex, ptr %523, i64 %524
  %526 = getelementptr inbounds %struct.complex, ptr %525, i32 0, i32 1
  %527 = load float, ptr %526, align 4, !tbaa !14
  %528 = load ptr, ptr %20, align 8, !tbaa !5
  %529 = load i64, ptr %27, align 8, !tbaa !9
  %530 = getelementptr inbounds %struct.complex, ptr %528, i64 %529
  %531 = getelementptr inbounds %struct.complex, ptr %530, i32 0, i32 0
  %532 = load float, ptr %531, align 4, !tbaa !11
  %533 = fmul float %527, %532
  %534 = call float @llvm.fmuladd.f32(float %517, float %522, float %533)
  %535 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %534, ptr %535, align 4, !tbaa !14
  %536 = load ptr, ptr %20, align 8, !tbaa !5
  %537 = load i64, ptr %25, align 8, !tbaa !9
  %538 = getelementptr inbounds %struct.complex, ptr %536, i64 %537
  %539 = getelementptr inbounds %struct.complex, ptr %538, i32 0, i32 0
  %540 = load float, ptr %539, align 4, !tbaa !11
  %541 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %542 = load float, ptr %541, align 4, !tbaa !11
  %543 = fsub float %540, %542
  %544 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %543, ptr %544, align 4, !tbaa !11
  %545 = load ptr, ptr %20, align 8, !tbaa !5
  %546 = load i64, ptr %25, align 8, !tbaa !9
  %547 = getelementptr inbounds %struct.complex, ptr %545, i64 %546
  %548 = getelementptr inbounds %struct.complex, ptr %547, i32 0, i32 1
  %549 = load float, ptr %548, align 4, !tbaa !14
  %550 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %551 = load float, ptr %550, align 4, !tbaa !14
  %552 = fsub float %549, %551
  %553 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %552, ptr %553, align 4, !tbaa !14
  %554 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %554, ptr %28, align 8, !tbaa !9
  %555 = load i64, ptr %40, align 8, !tbaa !9
  %556 = add nsw i64 %555, 2
  %557 = load i64, ptr %41, align 8, !tbaa !9
  %558 = load i64, ptr %22, align 8, !tbaa !9
  %559 = mul nsw i64 %557, %558
  %560 = add nsw i64 %556, %559
  store i64 %560, ptr %29, align 8, !tbaa !9
  %561 = load ptr, ptr %18, align 8, !tbaa !5
  %562 = load i64, ptr %28, align 8, !tbaa !9
  %563 = getelementptr inbounds %struct.complex, ptr %561, i64 %562
  %564 = getelementptr inbounds %struct.complex, ptr %563, i32 0, i32 0
  %565 = load float, ptr %564, align 4, !tbaa !11
  %566 = load ptr, ptr %20, align 8, !tbaa !5
  %567 = load i64, ptr %29, align 8, !tbaa !9
  %568 = getelementptr inbounds %struct.complex, ptr %566, i64 %567
  %569 = getelementptr inbounds %struct.complex, ptr %568, i32 0, i32 0
  %570 = load float, ptr %569, align 4, !tbaa !11
  %571 = load ptr, ptr %18, align 8, !tbaa !5
  %572 = load i64, ptr %28, align 8, !tbaa !9
  %573 = getelementptr inbounds %struct.complex, ptr %571, i64 %572
  %574 = getelementptr inbounds %struct.complex, ptr %573, i32 0, i32 1
  %575 = load float, ptr %574, align 4, !tbaa !14
  %576 = load ptr, ptr %20, align 8, !tbaa !5
  %577 = load i64, ptr %29, align 8, !tbaa !9
  %578 = getelementptr inbounds %struct.complex, ptr %576, i64 %577
  %579 = getelementptr inbounds %struct.complex, ptr %578, i32 0, i32 1
  %580 = load float, ptr %579, align 4, !tbaa !14
  %581 = fmul float %575, %580
  %582 = fneg float %581
  %583 = call float @llvm.fmuladd.f32(float %565, float %570, float %582)
  %584 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %583, ptr %584, align 4, !tbaa !11
  %585 = load ptr, ptr %18, align 8, !tbaa !5
  %586 = load i64, ptr %28, align 8, !tbaa !9
  %587 = getelementptr inbounds %struct.complex, ptr %585, i64 %586
  %588 = getelementptr inbounds %struct.complex, ptr %587, i32 0, i32 0
  %589 = load float, ptr %588, align 4, !tbaa !11
  %590 = load ptr, ptr %20, align 8, !tbaa !5
  %591 = load i64, ptr %29, align 8, !tbaa !9
  %592 = getelementptr inbounds %struct.complex, ptr %590, i64 %591
  %593 = getelementptr inbounds %struct.complex, ptr %592, i32 0, i32 1
  %594 = load float, ptr %593, align 4, !tbaa !14
  %595 = load ptr, ptr %18, align 8, !tbaa !5
  %596 = load i64, ptr %28, align 8, !tbaa !9
  %597 = getelementptr inbounds %struct.complex, ptr %595, i64 %596
  %598 = getelementptr inbounds %struct.complex, ptr %597, i32 0, i32 1
  %599 = load float, ptr %598, align 4, !tbaa !14
  %600 = load ptr, ptr %20, align 8, !tbaa !5
  %601 = load i64, ptr %29, align 8, !tbaa !9
  %602 = getelementptr inbounds %struct.complex, ptr %600, i64 %601
  %603 = getelementptr inbounds %struct.complex, ptr %602, i32 0, i32 0
  %604 = load float, ptr %603, align 4, !tbaa !11
  %605 = fmul float %599, %604
  %606 = call float @llvm.fmuladd.f32(float %589, float %594, float %605)
  %607 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %606, ptr %607, align 4, !tbaa !14
  %608 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %609 = load float, ptr %608, align 4, !tbaa !11
  %610 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %611 = load float, ptr %610, align 4, !tbaa !11
  %612 = fsub float %609, %611
  %613 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %612, ptr %613, align 4, !tbaa !11
  %614 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %615 = load float, ptr %614, align 4, !tbaa !14
  %616 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %617 = load float, ptr %616, align 4, !tbaa !14
  %618 = fsub float %615, %617
  %619 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %618, ptr %619, align 4, !tbaa !14
  %620 = load ptr, ptr %16, align 8, !tbaa !5
  %621 = load i64, ptr %40, align 8, !tbaa !9
  %622 = getelementptr inbounds %struct.complex, ptr %620, i64 %621
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %622)
  %623 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %624 = load float, ptr %623, align 4, !tbaa !11
  %625 = load ptr, ptr %20, align 8, !tbaa !5
  %626 = load i64, ptr %24, align 8, !tbaa !9
  %627 = getelementptr inbounds %struct.complex, ptr %625, i64 %626
  %628 = getelementptr inbounds %struct.complex, ptr %627, i32 0, i32 0
  store float %624, ptr %628, align 4, !tbaa !11
  %629 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %630 = load float, ptr %629, align 4, !tbaa !14
  %631 = load ptr, ptr %20, align 8, !tbaa !5
  %632 = load i64, ptr %24, align 8, !tbaa !9
  %633 = getelementptr inbounds %struct.complex, ptr %631, i64 %632
  %634 = getelementptr inbounds %struct.complex, ptr %633, i32 0, i32 1
  store float %630, ptr %634, align 4, !tbaa !14
  br label %635

635:                                              ; preds = %471
  %636 = load i64, ptr %40, align 8, !tbaa !9
  %637 = add nsw i64 %636, -1
  store i64 %637, ptr %40, align 8, !tbaa !9
  br label %468, !llvm.loop !17

638:                                              ; preds = %468
  %639 = load i64, ptr %41, align 8, !tbaa !9
  %640 = load ptr, ptr %14, align 8, !tbaa !5
  %641 = load i64, ptr %640, align 8, !tbaa !9
  %642 = icmp slt i64 %639, %641
  br i1 %642, label %643, label %646

643:                                              ; preds = %638
  %644 = load i64, ptr %41, align 8, !tbaa !9
  %645 = add nsw i64 %644, 1
  store i64 %645, ptr %41, align 8, !tbaa !9
  br label %79

646:                                              ; preds = %638
  br label %1218

647:                                              ; preds = %74
  %648 = load ptr, ptr %14, align 8, !tbaa !5
  %649 = load i64, ptr %648, align 8, !tbaa !9
  store i64 %649, ptr %24, align 8, !tbaa !9
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %650

650:                                              ; preds = %1214, %647
  %651 = load i64, ptr %41, align 8, !tbaa !9
  %652 = load i64, ptr %24, align 8, !tbaa !9
  %653 = icmp sle i64 %651, %652
  br i1 %653, label %654, label %1217

654:                                              ; preds = %650
  %655 = load ptr, ptr %13, align 8, !tbaa !5
  %656 = load i64, ptr %655, align 8, !tbaa !9
  %657 = sub nsw i64 %656, 1
  store i64 %657, ptr %25, align 8, !tbaa !9
  store i64 1, ptr %40, align 8, !tbaa !9
  br label %658

658:                                              ; preds = %896, %654
  %659 = load i64, ptr %40, align 8, !tbaa !9
  %660 = load i64, ptr %25, align 8, !tbaa !9
  %661 = icmp sle i64 %659, %660
  br i1 %661, label %662, label %899

662:                                              ; preds = %658
  %663 = load ptr, ptr %19, align 8, !tbaa !5
  %664 = load i64, ptr %40, align 8, !tbaa !9
  %665 = getelementptr inbounds i64, ptr %663, i64 %664
  %666 = load i64, ptr %665, align 8, !tbaa !9
  %667 = load i64, ptr %40, align 8, !tbaa !9
  %668 = icmp eq i64 %666, %667
  br i1 %668, label %669, label %765

669:                                              ; preds = %662
  %670 = load i64, ptr %40, align 8, !tbaa !9
  %671 = add nsw i64 %670, 1
  %672 = load i64, ptr %41, align 8, !tbaa !9
  %673 = load i64, ptr %22, align 8, !tbaa !9
  %674 = mul nsw i64 %672, %673
  %675 = add nsw i64 %671, %674
  store i64 %675, ptr %26, align 8, !tbaa !9
  %676 = load i64, ptr %40, align 8, !tbaa !9
  %677 = add nsw i64 %676, 1
  %678 = load i64, ptr %41, align 8, !tbaa !9
  %679 = load i64, ptr %22, align 8, !tbaa !9
  %680 = mul nsw i64 %678, %679
  %681 = add nsw i64 %677, %680
  store i64 %681, ptr %27, align 8, !tbaa !9
  %682 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %682, ptr %28, align 8, !tbaa !9
  %683 = load i64, ptr %40, align 8, !tbaa !9
  %684 = load i64, ptr %41, align 8, !tbaa !9
  %685 = load i64, ptr %22, align 8, !tbaa !9
  %686 = mul nsw i64 %684, %685
  %687 = add nsw i64 %683, %686
  store i64 %687, ptr %29, align 8, !tbaa !9
  %688 = load ptr, ptr %15, align 8, !tbaa !5
  %689 = load i64, ptr %28, align 8, !tbaa !9
  %690 = getelementptr inbounds %struct.complex, ptr %688, i64 %689
  %691 = getelementptr inbounds %struct.complex, ptr %690, i32 0, i32 0
  %692 = load float, ptr %691, align 4, !tbaa !11
  %693 = load ptr, ptr %20, align 8, !tbaa !5
  %694 = load i64, ptr %29, align 8, !tbaa !9
  %695 = getelementptr inbounds %struct.complex, ptr %693, i64 %694
  %696 = getelementptr inbounds %struct.complex, ptr %695, i32 0, i32 0
  %697 = load float, ptr %696, align 4, !tbaa !11
  %698 = load ptr, ptr %15, align 8, !tbaa !5
  %699 = load i64, ptr %28, align 8, !tbaa !9
  %700 = getelementptr inbounds %struct.complex, ptr %698, i64 %699
  %701 = getelementptr inbounds %struct.complex, ptr %700, i32 0, i32 1
  %702 = load float, ptr %701, align 4, !tbaa !14
  %703 = load ptr, ptr %20, align 8, !tbaa !5
  %704 = load i64, ptr %29, align 8, !tbaa !9
  %705 = getelementptr inbounds %struct.complex, ptr %703, i64 %704
  %706 = getelementptr inbounds %struct.complex, ptr %705, i32 0, i32 1
  %707 = load float, ptr %706, align 4, !tbaa !14
  %708 = fmul float %702, %707
  %709 = fneg float %708
  %710 = call float @llvm.fmuladd.f32(float %692, float %697, float %709)
  %711 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %710, ptr %711, align 4, !tbaa !11
  %712 = load ptr, ptr %15, align 8, !tbaa !5
  %713 = load i64, ptr %28, align 8, !tbaa !9
  %714 = getelementptr inbounds %struct.complex, ptr %712, i64 %713
  %715 = getelementptr inbounds %struct.complex, ptr %714, i32 0, i32 0
  %716 = load float, ptr %715, align 4, !tbaa !11
  %717 = load ptr, ptr %20, align 8, !tbaa !5
  %718 = load i64, ptr %29, align 8, !tbaa !9
  %719 = getelementptr inbounds %struct.complex, ptr %717, i64 %718
  %720 = getelementptr inbounds %struct.complex, ptr %719, i32 0, i32 1
  %721 = load float, ptr %720, align 4, !tbaa !14
  %722 = load ptr, ptr %15, align 8, !tbaa !5
  %723 = load i64, ptr %28, align 8, !tbaa !9
  %724 = getelementptr inbounds %struct.complex, ptr %722, i64 %723
  %725 = getelementptr inbounds %struct.complex, ptr %724, i32 0, i32 1
  %726 = load float, ptr %725, align 4, !tbaa !14
  %727 = load ptr, ptr %20, align 8, !tbaa !5
  %728 = load i64, ptr %29, align 8, !tbaa !9
  %729 = getelementptr inbounds %struct.complex, ptr %727, i64 %728
  %730 = getelementptr inbounds %struct.complex, ptr %729, i32 0, i32 0
  %731 = load float, ptr %730, align 4, !tbaa !11
  %732 = fmul float %726, %731
  %733 = call float @llvm.fmuladd.f32(float %716, float %721, float %732)
  %734 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %733, ptr %734, align 4, !tbaa !14
  %735 = load ptr, ptr %20, align 8, !tbaa !5
  %736 = load i64, ptr %27, align 8, !tbaa !9
  %737 = getelementptr inbounds %struct.complex, ptr %735, i64 %736
  %738 = getelementptr inbounds %struct.complex, ptr %737, i32 0, i32 0
  %739 = load float, ptr %738, align 4, !tbaa !11
  %740 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %741 = load float, ptr %740, align 4, !tbaa !11
  %742 = fsub float %739, %741
  %743 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %742, ptr %743, align 4, !tbaa !11
  %744 = load ptr, ptr %20, align 8, !tbaa !5
  %745 = load i64, ptr %27, align 8, !tbaa !9
  %746 = getelementptr inbounds %struct.complex, ptr %744, i64 %745
  %747 = getelementptr inbounds %struct.complex, ptr %746, i32 0, i32 1
  %748 = load float, ptr %747, align 4, !tbaa !14
  %749 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %750 = load float, ptr %749, align 4, !tbaa !14
  %751 = fsub float %748, %750
  %752 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %751, ptr %752, align 4, !tbaa !14
  %753 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %754 = load float, ptr %753, align 4, !tbaa !11
  %755 = load ptr, ptr %20, align 8, !tbaa !5
  %756 = load i64, ptr %26, align 8, !tbaa !9
  %757 = getelementptr inbounds %struct.complex, ptr %755, i64 %756
  %758 = getelementptr inbounds %struct.complex, ptr %757, i32 0, i32 0
  store float %754, ptr %758, align 4, !tbaa !11
  %759 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %760 = load float, ptr %759, align 4, !tbaa !14
  %761 = load ptr, ptr %20, align 8, !tbaa !5
  %762 = load i64, ptr %26, align 8, !tbaa !9
  %763 = getelementptr inbounds %struct.complex, ptr %761, i64 %762
  %764 = getelementptr inbounds %struct.complex, ptr %763, i32 0, i32 1
  store float %760, ptr %764, align 4, !tbaa !14
  br label %895

765:                                              ; preds = %662
  %766 = load i64, ptr %40, align 8, !tbaa !9
  %767 = load i64, ptr %41, align 8, !tbaa !9
  %768 = load i64, ptr %22, align 8, !tbaa !9
  %769 = mul nsw i64 %767, %768
  %770 = add nsw i64 %766, %769
  store i64 %770, ptr %26, align 8, !tbaa !9
  %771 = load ptr, ptr %20, align 8, !tbaa !5
  %772 = load i64, ptr %26, align 8, !tbaa !9
  %773 = getelementptr inbounds %struct.complex, ptr %771, i64 %772
  %774 = getelementptr inbounds %struct.complex, ptr %773, i32 0, i32 0
  %775 = load float, ptr %774, align 4, !tbaa !11
  %776 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %775, ptr %776, align 4, !tbaa !11
  %777 = load ptr, ptr %20, align 8, !tbaa !5
  %778 = load i64, ptr %26, align 8, !tbaa !9
  %779 = getelementptr inbounds %struct.complex, ptr %777, i64 %778
  %780 = getelementptr inbounds %struct.complex, ptr %779, i32 0, i32 1
  %781 = load float, ptr %780, align 4, !tbaa !14
  %782 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %781, ptr %782, align 4, !tbaa !14
  %783 = load i64, ptr %40, align 8, !tbaa !9
  %784 = load i64, ptr %41, align 8, !tbaa !9
  %785 = load i64, ptr %22, align 8, !tbaa !9
  %786 = mul nsw i64 %784, %785
  %787 = add nsw i64 %783, %786
  store i64 %787, ptr %26, align 8, !tbaa !9
  %788 = load i64, ptr %40, align 8, !tbaa !9
  %789 = add nsw i64 %788, 1
  %790 = load i64, ptr %41, align 8, !tbaa !9
  %791 = load i64, ptr %22, align 8, !tbaa !9
  %792 = mul nsw i64 %790, %791
  %793 = add nsw i64 %789, %792
  store i64 %793, ptr %27, align 8, !tbaa !9
  %794 = load ptr, ptr %20, align 8, !tbaa !5
  %795 = load i64, ptr %27, align 8, !tbaa !9
  %796 = getelementptr inbounds %struct.complex, ptr %794, i64 %795
  %797 = getelementptr inbounds %struct.complex, ptr %796, i32 0, i32 0
  %798 = load float, ptr %797, align 4, !tbaa !11
  %799 = load ptr, ptr %20, align 8, !tbaa !5
  %800 = load i64, ptr %26, align 8, !tbaa !9
  %801 = getelementptr inbounds %struct.complex, ptr %799, i64 %800
  %802 = getelementptr inbounds %struct.complex, ptr %801, i32 0, i32 0
  store float %798, ptr %802, align 4, !tbaa !11
  %803 = load ptr, ptr %20, align 8, !tbaa !5
  %804 = load i64, ptr %27, align 8, !tbaa !9
  %805 = getelementptr inbounds %struct.complex, ptr %803, i64 %804
  %806 = getelementptr inbounds %struct.complex, ptr %805, i32 0, i32 1
  %807 = load float, ptr %806, align 4, !tbaa !14
  %808 = load ptr, ptr %20, align 8, !tbaa !5
  %809 = load i64, ptr %26, align 8, !tbaa !9
  %810 = getelementptr inbounds %struct.complex, ptr %808, i64 %809
  %811 = getelementptr inbounds %struct.complex, ptr %810, i32 0, i32 1
  store float %807, ptr %811, align 4, !tbaa !14
  %812 = load i64, ptr %40, align 8, !tbaa !9
  %813 = add nsw i64 %812, 1
  %814 = load i64, ptr %41, align 8, !tbaa !9
  %815 = load i64, ptr %22, align 8, !tbaa !9
  %816 = mul nsw i64 %814, %815
  %817 = add nsw i64 %813, %816
  store i64 %817, ptr %26, align 8, !tbaa !9
  %818 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %818, ptr %27, align 8, !tbaa !9
  %819 = load i64, ptr %40, align 8, !tbaa !9
  %820 = load i64, ptr %41, align 8, !tbaa !9
  %821 = load i64, ptr %22, align 8, !tbaa !9
  %822 = mul nsw i64 %820, %821
  %823 = add nsw i64 %819, %822
  store i64 %823, ptr %28, align 8, !tbaa !9
  %824 = load ptr, ptr %15, align 8, !tbaa !5
  %825 = load i64, ptr %27, align 8, !tbaa !9
  %826 = getelementptr inbounds %struct.complex, ptr %824, i64 %825
  %827 = getelementptr inbounds %struct.complex, ptr %826, i32 0, i32 0
  %828 = load float, ptr %827, align 4, !tbaa !11
  %829 = load ptr, ptr %20, align 8, !tbaa !5
  %830 = load i64, ptr %28, align 8, !tbaa !9
  %831 = getelementptr inbounds %struct.complex, ptr %829, i64 %830
  %832 = getelementptr inbounds %struct.complex, ptr %831, i32 0, i32 0
  %833 = load float, ptr %832, align 4, !tbaa !11
  %834 = load ptr, ptr %15, align 8, !tbaa !5
  %835 = load i64, ptr %27, align 8, !tbaa !9
  %836 = getelementptr inbounds %struct.complex, ptr %834, i64 %835
  %837 = getelementptr inbounds %struct.complex, ptr %836, i32 0, i32 1
  %838 = load float, ptr %837, align 4, !tbaa !14
  %839 = load ptr, ptr %20, align 8, !tbaa !5
  %840 = load i64, ptr %28, align 8, !tbaa !9
  %841 = getelementptr inbounds %struct.complex, ptr %839, i64 %840
  %842 = getelementptr inbounds %struct.complex, ptr %841, i32 0, i32 1
  %843 = load float, ptr %842, align 4, !tbaa !14
  %844 = fmul float %838, %843
  %845 = fneg float %844
  %846 = call float @llvm.fmuladd.f32(float %828, float %833, float %845)
  %847 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %846, ptr %847, align 4, !tbaa !11
  %848 = load ptr, ptr %15, align 8, !tbaa !5
  %849 = load i64, ptr %27, align 8, !tbaa !9
  %850 = getelementptr inbounds %struct.complex, ptr %848, i64 %849
  %851 = getelementptr inbounds %struct.complex, ptr %850, i32 0, i32 0
  %852 = load float, ptr %851, align 4, !tbaa !11
  %853 = load ptr, ptr %20, align 8, !tbaa !5
  %854 = load i64, ptr %28, align 8, !tbaa !9
  %855 = getelementptr inbounds %struct.complex, ptr %853, i64 %854
  %856 = getelementptr inbounds %struct.complex, ptr %855, i32 0, i32 1
  %857 = load float, ptr %856, align 4, !tbaa !14
  %858 = load ptr, ptr %15, align 8, !tbaa !5
  %859 = load i64, ptr %27, align 8, !tbaa !9
  %860 = getelementptr inbounds %struct.complex, ptr %858, i64 %859
  %861 = getelementptr inbounds %struct.complex, ptr %860, i32 0, i32 1
  %862 = load float, ptr %861, align 4, !tbaa !14
  %863 = load ptr, ptr %20, align 8, !tbaa !5
  %864 = load i64, ptr %28, align 8, !tbaa !9
  %865 = getelementptr inbounds %struct.complex, ptr %863, i64 %864
  %866 = getelementptr inbounds %struct.complex, ptr %865, i32 0, i32 0
  %867 = load float, ptr %866, align 4, !tbaa !11
  %868 = fmul float %862, %867
  %869 = call float @llvm.fmuladd.f32(float %852, float %857, float %868)
  %870 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %869, ptr %870, align 4, !tbaa !14
  %871 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %872 = load float, ptr %871, align 4, !tbaa !11
  %873 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %874 = load float, ptr %873, align 4, !tbaa !11
  %875 = fsub float %872, %874
  %876 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %875, ptr %876, align 4, !tbaa !11
  %877 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %878 = load float, ptr %877, align 4, !tbaa !14
  %879 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %880 = load float, ptr %879, align 4, !tbaa !14
  %881 = fsub float %878, %880
  %882 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %881, ptr %882, align 4, !tbaa !14
  %883 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %884 = load float, ptr %883, align 4, !tbaa !11
  %885 = load ptr, ptr %20, align 8, !tbaa !5
  %886 = load i64, ptr %26, align 8, !tbaa !9
  %887 = getelementptr inbounds %struct.complex, ptr %885, i64 %886
  %888 = getelementptr inbounds %struct.complex, ptr %887, i32 0, i32 0
  store float %884, ptr %888, align 4, !tbaa !11
  %889 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %890 = load float, ptr %889, align 4, !tbaa !14
  %891 = load ptr, ptr %20, align 8, !tbaa !5
  %892 = load i64, ptr %26, align 8, !tbaa !9
  %893 = getelementptr inbounds %struct.complex, ptr %891, i64 %892
  %894 = getelementptr inbounds %struct.complex, ptr %893, i32 0, i32 1
  store float %890, ptr %894, align 4, !tbaa !14
  br label %895

895:                                              ; preds = %765, %669
  br label %896

896:                                              ; preds = %895
  %897 = load i64, ptr %40, align 8, !tbaa !9
  %898 = add nsw i64 %897, 1
  store i64 %898, ptr %40, align 8, !tbaa !9
  br label %658, !llvm.loop !18

899:                                              ; preds = %658
  %900 = load ptr, ptr %13, align 8, !tbaa !5
  %901 = load i64, ptr %900, align 8, !tbaa !9
  %902 = load i64, ptr %41, align 8, !tbaa !9
  %903 = load i64, ptr %22, align 8, !tbaa !9
  %904 = mul nsw i64 %902, %903
  %905 = add nsw i64 %901, %904
  store i64 %905, ptr %25, align 8, !tbaa !9
  %906 = load ptr, ptr %20, align 8, !tbaa !5
  %907 = load ptr, ptr %13, align 8, !tbaa !5
  %908 = load i64, ptr %907, align 8, !tbaa !9
  %909 = load i64, ptr %41, align 8, !tbaa !9
  %910 = load i64, ptr %22, align 8, !tbaa !9
  %911 = mul nsw i64 %909, %910
  %912 = add nsw i64 %908, %911
  %913 = getelementptr inbounds %struct.complex, ptr %906, i64 %912
  %914 = load ptr, ptr %16, align 8, !tbaa !5
  %915 = load ptr, ptr %13, align 8, !tbaa !5
  %916 = load i64, ptr %915, align 8, !tbaa !9
  %917 = getelementptr inbounds %struct.complex, ptr %914, i64 %916
  call void @c_div(ptr noundef %32, ptr noundef %913, ptr noundef %917)
  %918 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %919 = load float, ptr %918, align 4, !tbaa !11
  %920 = load ptr, ptr %20, align 8, !tbaa !5
  %921 = load i64, ptr %25, align 8, !tbaa !9
  %922 = getelementptr inbounds %struct.complex, ptr %920, i64 %921
  %923 = getelementptr inbounds %struct.complex, ptr %922, i32 0, i32 0
  store float %919, ptr %923, align 4, !tbaa !11
  %924 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %925 = load float, ptr %924, align 4, !tbaa !14
  %926 = load ptr, ptr %20, align 8, !tbaa !5
  %927 = load i64, ptr %25, align 8, !tbaa !9
  %928 = getelementptr inbounds %struct.complex, ptr %926, i64 %927
  %929 = getelementptr inbounds %struct.complex, ptr %928, i32 0, i32 1
  store float %925, ptr %929, align 4, !tbaa !14
  %930 = load ptr, ptr %13, align 8, !tbaa !5
  %931 = load i64, ptr %930, align 8, !tbaa !9
  %932 = icmp sgt i64 %931, 1
  br i1 %932, label %933, label %1039

933:                                              ; preds = %899
  %934 = load ptr, ptr %13, align 8, !tbaa !5
  %935 = load i64, ptr %934, align 8, !tbaa !9
  %936 = sub nsw i64 %935, 1
  %937 = load i64, ptr %41, align 8, !tbaa !9
  %938 = load i64, ptr %22, align 8, !tbaa !9
  %939 = mul nsw i64 %937, %938
  %940 = add nsw i64 %936, %939
  store i64 %940, ptr %25, align 8, !tbaa !9
  %941 = load ptr, ptr %13, align 8, !tbaa !5
  %942 = load i64, ptr %941, align 8, !tbaa !9
  %943 = sub nsw i64 %942, 1
  %944 = load i64, ptr %41, align 8, !tbaa !9
  %945 = load i64, ptr %22, align 8, !tbaa !9
  %946 = mul nsw i64 %944, %945
  %947 = add nsw i64 %943, %946
  store i64 %947, ptr %26, align 8, !tbaa !9
  %948 = load ptr, ptr %13, align 8, !tbaa !5
  %949 = load i64, ptr %948, align 8, !tbaa !9
  %950 = sub nsw i64 %949, 1
  store i64 %950, ptr %27, align 8, !tbaa !9
  %951 = load ptr, ptr %13, align 8, !tbaa !5
  %952 = load i64, ptr %951, align 8, !tbaa !9
  %953 = load i64, ptr %41, align 8, !tbaa !9
  %954 = load i64, ptr %22, align 8, !tbaa !9
  %955 = mul nsw i64 %953, %954
  %956 = add nsw i64 %952, %955
  store i64 %956, ptr %28, align 8, !tbaa !9
  %957 = load ptr, ptr %17, align 8, !tbaa !5
  %958 = load i64, ptr %27, align 8, !tbaa !9
  %959 = getelementptr inbounds %struct.complex, ptr %957, i64 %958
  %960 = getelementptr inbounds %struct.complex, ptr %959, i32 0, i32 0
  %961 = load float, ptr %960, align 4, !tbaa !11
  %962 = load ptr, ptr %20, align 8, !tbaa !5
  %963 = load i64, ptr %28, align 8, !tbaa !9
  %964 = getelementptr inbounds %struct.complex, ptr %962, i64 %963
  %965 = getelementptr inbounds %struct.complex, ptr %964, i32 0, i32 0
  %966 = load float, ptr %965, align 4, !tbaa !11
  %967 = load ptr, ptr %17, align 8, !tbaa !5
  %968 = load i64, ptr %27, align 8, !tbaa !9
  %969 = getelementptr inbounds %struct.complex, ptr %967, i64 %968
  %970 = getelementptr inbounds %struct.complex, ptr %969, i32 0, i32 1
  %971 = load float, ptr %970, align 4, !tbaa !14
  %972 = load ptr, ptr %20, align 8, !tbaa !5
  %973 = load i64, ptr %28, align 8, !tbaa !9
  %974 = getelementptr inbounds %struct.complex, ptr %972, i64 %973
  %975 = getelementptr inbounds %struct.complex, ptr %974, i32 0, i32 1
  %976 = load float, ptr %975, align 4, !tbaa !14
  %977 = fmul float %971, %976
  %978 = fneg float %977
  %979 = call float @llvm.fmuladd.f32(float %961, float %966, float %978)
  %980 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %979, ptr %980, align 4, !tbaa !11
  %981 = load ptr, ptr %17, align 8, !tbaa !5
  %982 = load i64, ptr %27, align 8, !tbaa !9
  %983 = getelementptr inbounds %struct.complex, ptr %981, i64 %982
  %984 = getelementptr inbounds %struct.complex, ptr %983, i32 0, i32 0
  %985 = load float, ptr %984, align 4, !tbaa !11
  %986 = load ptr, ptr %20, align 8, !tbaa !5
  %987 = load i64, ptr %28, align 8, !tbaa !9
  %988 = getelementptr inbounds %struct.complex, ptr %986, i64 %987
  %989 = getelementptr inbounds %struct.complex, ptr %988, i32 0, i32 1
  %990 = load float, ptr %989, align 4, !tbaa !14
  %991 = load ptr, ptr %17, align 8, !tbaa !5
  %992 = load i64, ptr %27, align 8, !tbaa !9
  %993 = getelementptr inbounds %struct.complex, ptr %991, i64 %992
  %994 = getelementptr inbounds %struct.complex, ptr %993, i32 0, i32 1
  %995 = load float, ptr %994, align 4, !tbaa !14
  %996 = load ptr, ptr %20, align 8, !tbaa !5
  %997 = load i64, ptr %28, align 8, !tbaa !9
  %998 = getelementptr inbounds %struct.complex, ptr %996, i64 %997
  %999 = getelementptr inbounds %struct.complex, ptr %998, i32 0, i32 0
  %1000 = load float, ptr %999, align 4, !tbaa !11
  %1001 = fmul float %995, %1000
  %1002 = call float @llvm.fmuladd.f32(float %985, float %990, float %1001)
  %1003 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1002, ptr %1003, align 4, !tbaa !14
  %1004 = load ptr, ptr %20, align 8, !tbaa !5
  %1005 = load i64, ptr %26, align 8, !tbaa !9
  %1006 = getelementptr inbounds %struct.complex, ptr %1004, i64 %1005
  %1007 = getelementptr inbounds %struct.complex, ptr %1006, i32 0, i32 0
  %1008 = load float, ptr %1007, align 4, !tbaa !11
  %1009 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1010 = load float, ptr %1009, align 4, !tbaa !11
  %1011 = fsub float %1008, %1010
  %1012 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1011, ptr %1012, align 4, !tbaa !11
  %1013 = load ptr, ptr %20, align 8, !tbaa !5
  %1014 = load i64, ptr %26, align 8, !tbaa !9
  %1015 = getelementptr inbounds %struct.complex, ptr %1013, i64 %1014
  %1016 = getelementptr inbounds %struct.complex, ptr %1015, i32 0, i32 1
  %1017 = load float, ptr %1016, align 4, !tbaa !14
  %1018 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1019 = load float, ptr %1018, align 4, !tbaa !14
  %1020 = fsub float %1017, %1019
  %1021 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1020, ptr %1021, align 4, !tbaa !14
  %1022 = load ptr, ptr %16, align 8, !tbaa !5
  %1023 = load ptr, ptr %13, align 8, !tbaa !5
  %1024 = load i64, ptr %1023, align 8, !tbaa !9
  %1025 = sub nsw i64 %1024, 1
  %1026 = getelementptr inbounds %struct.complex, ptr %1022, i64 %1025
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %1026)
  %1027 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1028 = load float, ptr %1027, align 4, !tbaa !11
  %1029 = load ptr, ptr %20, align 8, !tbaa !5
  %1030 = load i64, ptr %25, align 8, !tbaa !9
  %1031 = getelementptr inbounds %struct.complex, ptr %1029, i64 %1030
  %1032 = getelementptr inbounds %struct.complex, ptr %1031, i32 0, i32 0
  store float %1028, ptr %1032, align 4, !tbaa !11
  %1033 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1034 = load float, ptr %1033, align 4, !tbaa !14
  %1035 = load ptr, ptr %20, align 8, !tbaa !5
  %1036 = load i64, ptr %25, align 8, !tbaa !9
  %1037 = getelementptr inbounds %struct.complex, ptr %1035, i64 %1036
  %1038 = getelementptr inbounds %struct.complex, ptr %1037, i32 0, i32 1
  store float %1034, ptr %1038, align 4, !tbaa !14
  br label %1039

1039:                                             ; preds = %933, %899
  %1040 = load ptr, ptr %13, align 8, !tbaa !5
  %1041 = load i64, ptr %1040, align 8, !tbaa !9
  %1042 = sub nsw i64 %1041, 2
  store i64 %1042, ptr %40, align 8, !tbaa !9
  br label %1043

1043:                                             ; preds = %1210, %1039
  %1044 = load i64, ptr %40, align 8, !tbaa !9
  %1045 = icmp sge i64 %1044, 1
  br i1 %1045, label %1046, label %1213

1046:                                             ; preds = %1043
  %1047 = load i64, ptr %40, align 8, !tbaa !9
  %1048 = load i64, ptr %41, align 8, !tbaa !9
  %1049 = load i64, ptr %22, align 8, !tbaa !9
  %1050 = mul nsw i64 %1048, %1049
  %1051 = add nsw i64 %1047, %1050
  store i64 %1051, ptr %25, align 8, !tbaa !9
  %1052 = load i64, ptr %40, align 8, !tbaa !9
  %1053 = load i64, ptr %41, align 8, !tbaa !9
  %1054 = load i64, ptr %22, align 8, !tbaa !9
  %1055 = mul nsw i64 %1053, %1054
  %1056 = add nsw i64 %1052, %1055
  store i64 %1056, ptr %26, align 8, !tbaa !9
  %1057 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %1057, ptr %27, align 8, !tbaa !9
  %1058 = load i64, ptr %40, align 8, !tbaa !9
  %1059 = add nsw i64 %1058, 1
  %1060 = load i64, ptr %41, align 8, !tbaa !9
  %1061 = load i64, ptr %22, align 8, !tbaa !9
  %1062 = mul nsw i64 %1060, %1061
  %1063 = add nsw i64 %1059, %1062
  store i64 %1063, ptr %28, align 8, !tbaa !9
  %1064 = load ptr, ptr %17, align 8, !tbaa !5
  %1065 = load i64, ptr %27, align 8, !tbaa !9
  %1066 = getelementptr inbounds %struct.complex, ptr %1064, i64 %1065
  %1067 = getelementptr inbounds %struct.complex, ptr %1066, i32 0, i32 0
  %1068 = load float, ptr %1067, align 4, !tbaa !11
  %1069 = load ptr, ptr %20, align 8, !tbaa !5
  %1070 = load i64, ptr %28, align 8, !tbaa !9
  %1071 = getelementptr inbounds %struct.complex, ptr %1069, i64 %1070
  %1072 = getelementptr inbounds %struct.complex, ptr %1071, i32 0, i32 0
  %1073 = load float, ptr %1072, align 4, !tbaa !11
  %1074 = load ptr, ptr %17, align 8, !tbaa !5
  %1075 = load i64, ptr %27, align 8, !tbaa !9
  %1076 = getelementptr inbounds %struct.complex, ptr %1074, i64 %1075
  %1077 = getelementptr inbounds %struct.complex, ptr %1076, i32 0, i32 1
  %1078 = load float, ptr %1077, align 4, !tbaa !14
  %1079 = load ptr, ptr %20, align 8, !tbaa !5
  %1080 = load i64, ptr %28, align 8, !tbaa !9
  %1081 = getelementptr inbounds %struct.complex, ptr %1079, i64 %1080
  %1082 = getelementptr inbounds %struct.complex, ptr %1081, i32 0, i32 1
  %1083 = load float, ptr %1082, align 4, !tbaa !14
  %1084 = fmul float %1078, %1083
  %1085 = fneg float %1084
  %1086 = call float @llvm.fmuladd.f32(float %1068, float %1073, float %1085)
  %1087 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %1086, ptr %1087, align 4, !tbaa !11
  %1088 = load ptr, ptr %17, align 8, !tbaa !5
  %1089 = load i64, ptr %27, align 8, !tbaa !9
  %1090 = getelementptr inbounds %struct.complex, ptr %1088, i64 %1089
  %1091 = getelementptr inbounds %struct.complex, ptr %1090, i32 0, i32 0
  %1092 = load float, ptr %1091, align 4, !tbaa !11
  %1093 = load ptr, ptr %20, align 8, !tbaa !5
  %1094 = load i64, ptr %28, align 8, !tbaa !9
  %1095 = getelementptr inbounds %struct.complex, ptr %1093, i64 %1094
  %1096 = getelementptr inbounds %struct.complex, ptr %1095, i32 0, i32 1
  %1097 = load float, ptr %1096, align 4, !tbaa !14
  %1098 = load ptr, ptr %17, align 8, !tbaa !5
  %1099 = load i64, ptr %27, align 8, !tbaa !9
  %1100 = getelementptr inbounds %struct.complex, ptr %1098, i64 %1099
  %1101 = getelementptr inbounds %struct.complex, ptr %1100, i32 0, i32 1
  %1102 = load float, ptr %1101, align 4, !tbaa !14
  %1103 = load ptr, ptr %20, align 8, !tbaa !5
  %1104 = load i64, ptr %28, align 8, !tbaa !9
  %1105 = getelementptr inbounds %struct.complex, ptr %1103, i64 %1104
  %1106 = getelementptr inbounds %struct.complex, ptr %1105, i32 0, i32 0
  %1107 = load float, ptr %1106, align 4, !tbaa !11
  %1108 = fmul float %1102, %1107
  %1109 = call float @llvm.fmuladd.f32(float %1092, float %1097, float %1108)
  %1110 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %1109, ptr %1110, align 4, !tbaa !14
  %1111 = load ptr, ptr %20, align 8, !tbaa !5
  %1112 = load i64, ptr %26, align 8, !tbaa !9
  %1113 = getelementptr inbounds %struct.complex, ptr %1111, i64 %1112
  %1114 = getelementptr inbounds %struct.complex, ptr %1113, i32 0, i32 0
  %1115 = load float, ptr %1114, align 4, !tbaa !11
  %1116 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %1117 = load float, ptr %1116, align 4, !tbaa !11
  %1118 = fsub float %1115, %1117
  %1119 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1118, ptr %1119, align 4, !tbaa !11
  %1120 = load ptr, ptr %20, align 8, !tbaa !5
  %1121 = load i64, ptr %26, align 8, !tbaa !9
  %1122 = getelementptr inbounds %struct.complex, ptr %1120, i64 %1121
  %1123 = getelementptr inbounds %struct.complex, ptr %1122, i32 0, i32 1
  %1124 = load float, ptr %1123, align 4, !tbaa !14
  %1125 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %1126 = load float, ptr %1125, align 4, !tbaa !14
  %1127 = fsub float %1124, %1126
  %1128 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1127, ptr %1128, align 4, !tbaa !14
  %1129 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %1129, ptr %29, align 8, !tbaa !9
  %1130 = load i64, ptr %40, align 8, !tbaa !9
  %1131 = add nsw i64 %1130, 2
  %1132 = load i64, ptr %41, align 8, !tbaa !9
  %1133 = load i64, ptr %22, align 8, !tbaa !9
  %1134 = mul nsw i64 %1132, %1133
  %1135 = add nsw i64 %1131, %1134
  store i64 %1135, ptr %30, align 8, !tbaa !9
  %1136 = load ptr, ptr %18, align 8, !tbaa !5
  %1137 = load i64, ptr %29, align 8, !tbaa !9
  %1138 = getelementptr inbounds %struct.complex, ptr %1136, i64 %1137
  %1139 = getelementptr inbounds %struct.complex, ptr %1138, i32 0, i32 0
  %1140 = load float, ptr %1139, align 4, !tbaa !11
  %1141 = load ptr, ptr %20, align 8, !tbaa !5
  %1142 = load i64, ptr %30, align 8, !tbaa !9
  %1143 = getelementptr inbounds %struct.complex, ptr %1141, i64 %1142
  %1144 = getelementptr inbounds %struct.complex, ptr %1143, i32 0, i32 0
  %1145 = load float, ptr %1144, align 4, !tbaa !11
  %1146 = load ptr, ptr %18, align 8, !tbaa !5
  %1147 = load i64, ptr %29, align 8, !tbaa !9
  %1148 = getelementptr inbounds %struct.complex, ptr %1146, i64 %1147
  %1149 = getelementptr inbounds %struct.complex, ptr %1148, i32 0, i32 1
  %1150 = load float, ptr %1149, align 4, !tbaa !14
  %1151 = load ptr, ptr %20, align 8, !tbaa !5
  %1152 = load i64, ptr %30, align 8, !tbaa !9
  %1153 = getelementptr inbounds %struct.complex, ptr %1151, i64 %1152
  %1154 = getelementptr inbounds %struct.complex, ptr %1153, i32 0, i32 1
  %1155 = load float, ptr %1154, align 4, !tbaa !14
  %1156 = fmul float %1150, %1155
  %1157 = fneg float %1156
  %1158 = call float @llvm.fmuladd.f32(float %1140, float %1145, float %1157)
  %1159 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %1158, ptr %1159, align 4, !tbaa !11
  %1160 = load ptr, ptr %18, align 8, !tbaa !5
  %1161 = load i64, ptr %29, align 8, !tbaa !9
  %1162 = getelementptr inbounds %struct.complex, ptr %1160, i64 %1161
  %1163 = getelementptr inbounds %struct.complex, ptr %1162, i32 0, i32 0
  %1164 = load float, ptr %1163, align 4, !tbaa !11
  %1165 = load ptr, ptr %20, align 8, !tbaa !5
  %1166 = load i64, ptr %30, align 8, !tbaa !9
  %1167 = getelementptr inbounds %struct.complex, ptr %1165, i64 %1166
  %1168 = getelementptr inbounds %struct.complex, ptr %1167, i32 0, i32 1
  %1169 = load float, ptr %1168, align 4, !tbaa !14
  %1170 = load ptr, ptr %18, align 8, !tbaa !5
  %1171 = load i64, ptr %29, align 8, !tbaa !9
  %1172 = getelementptr inbounds %struct.complex, ptr %1170, i64 %1171
  %1173 = getelementptr inbounds %struct.complex, ptr %1172, i32 0, i32 1
  %1174 = load float, ptr %1173, align 4, !tbaa !14
  %1175 = load ptr, ptr %20, align 8, !tbaa !5
  %1176 = load i64, ptr %30, align 8, !tbaa !9
  %1177 = getelementptr inbounds %struct.complex, ptr %1175, i64 %1176
  %1178 = getelementptr inbounds %struct.complex, ptr %1177, i32 0, i32 0
  %1179 = load float, ptr %1178, align 4, !tbaa !11
  %1180 = fmul float %1174, %1179
  %1181 = call float @llvm.fmuladd.f32(float %1164, float %1169, float %1180)
  %1182 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %1181, ptr %1182, align 4, !tbaa !14
  %1183 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1184 = load float, ptr %1183, align 4, !tbaa !11
  %1185 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1186 = load float, ptr %1185, align 4, !tbaa !11
  %1187 = fsub float %1184, %1186
  %1188 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1187, ptr %1188, align 4, !tbaa !11
  %1189 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1190 = load float, ptr %1189, align 4, !tbaa !14
  %1191 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1192 = load float, ptr %1191, align 4, !tbaa !14
  %1193 = fsub float %1190, %1192
  %1194 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1193, ptr %1194, align 4, !tbaa !14
  %1195 = load ptr, ptr %16, align 8, !tbaa !5
  %1196 = load i64, ptr %40, align 8, !tbaa !9
  %1197 = getelementptr inbounds %struct.complex, ptr %1195, i64 %1196
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %1197)
  %1198 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1199 = load float, ptr %1198, align 4, !tbaa !11
  %1200 = load ptr, ptr %20, align 8, !tbaa !5
  %1201 = load i64, ptr %25, align 8, !tbaa !9
  %1202 = getelementptr inbounds %struct.complex, ptr %1200, i64 %1201
  %1203 = getelementptr inbounds %struct.complex, ptr %1202, i32 0, i32 0
  store float %1199, ptr %1203, align 4, !tbaa !11
  %1204 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1205 = load float, ptr %1204, align 4, !tbaa !14
  %1206 = load ptr, ptr %20, align 8, !tbaa !5
  %1207 = load i64, ptr %25, align 8, !tbaa !9
  %1208 = getelementptr inbounds %struct.complex, ptr %1206, i64 %1207
  %1209 = getelementptr inbounds %struct.complex, ptr %1208, i32 0, i32 1
  store float %1205, ptr %1209, align 4, !tbaa !14
  br label %1210

1210:                                             ; preds = %1046
  %1211 = load i64, ptr %40, align 8, !tbaa !9
  %1212 = add nsw i64 %1211, -1
  store i64 %1212, ptr %40, align 8, !tbaa !9
  br label %1043, !llvm.loop !19

1213:                                             ; preds = %1043
  br label %1214

1214:                                             ; preds = %1213
  %1215 = load i64, ptr %41, align 8, !tbaa !9
  %1216 = add nsw i64 %1215, 1
  store i64 %1216, ptr %41, align 8, !tbaa !9
  br label %650, !llvm.loop !20

1217:                                             ; preds = %650
  br label %1218

1218:                                             ; preds = %1217, %646
  br label %3258

1219:                                             ; preds = %70
  %1220 = load ptr, ptr %12, align 8, !tbaa !5
  %1221 = load i64, ptr %1220, align 8, !tbaa !9
  %1222 = icmp eq i64 %1221, 1
  br i1 %1222, label %1223, label %2286

1223:                                             ; preds = %1219
  %1224 = load ptr, ptr %14, align 8, !tbaa !5
  %1225 = load i64, ptr %1224, align 8, !tbaa !9
  %1226 = icmp sle i64 %1225, 1
  br i1 %1226, label %1227, label %1755

1227:                                             ; preds = %1223
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %1228

1228:                                             ; preds = %1751, %1227
  %1229 = load i64, ptr %41, align 8, !tbaa !9
  %1230 = load i64, ptr %22, align 8, !tbaa !9
  %1231 = mul nsw i64 %1229, %1230
  %1232 = add nsw i64 %1231, 1
  store i64 %1232, ptr %24, align 8, !tbaa !9
  %1233 = load ptr, ptr %20, align 8, !tbaa !5
  %1234 = load i64, ptr %41, align 8, !tbaa !9
  %1235 = load i64, ptr %22, align 8, !tbaa !9
  %1236 = mul nsw i64 %1234, %1235
  %1237 = add nsw i64 %1236, 1
  %1238 = getelementptr inbounds %struct.complex, ptr %1233, i64 %1237
  %1239 = load ptr, ptr %16, align 8, !tbaa !5
  %1240 = getelementptr inbounds %struct.complex, ptr %1239, i64 1
  call void @c_div(ptr noundef %32, ptr noundef %1238, ptr noundef %1240)
  %1241 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1242 = load float, ptr %1241, align 4, !tbaa !11
  %1243 = load ptr, ptr %20, align 8, !tbaa !5
  %1244 = load i64, ptr %24, align 8, !tbaa !9
  %1245 = getelementptr inbounds %struct.complex, ptr %1243, i64 %1244
  %1246 = getelementptr inbounds %struct.complex, ptr %1245, i32 0, i32 0
  store float %1242, ptr %1246, align 4, !tbaa !11
  %1247 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1248 = load float, ptr %1247, align 4, !tbaa !14
  %1249 = load ptr, ptr %20, align 8, !tbaa !5
  %1250 = load i64, ptr %24, align 8, !tbaa !9
  %1251 = getelementptr inbounds %struct.complex, ptr %1249, i64 %1250
  %1252 = getelementptr inbounds %struct.complex, ptr %1251, i32 0, i32 1
  store float %1248, ptr %1252, align 4, !tbaa !14
  %1253 = load ptr, ptr %13, align 8, !tbaa !5
  %1254 = load i64, ptr %1253, align 8, !tbaa !9
  %1255 = icmp sgt i64 %1254, 1
  br i1 %1255, label %1256, label %1344

1256:                                             ; preds = %1228
  %1257 = load i64, ptr %41, align 8, !tbaa !9
  %1258 = load i64, ptr %22, align 8, !tbaa !9
  %1259 = mul nsw i64 %1257, %1258
  %1260 = add nsw i64 %1259, 2
  store i64 %1260, ptr %24, align 8, !tbaa !9
  %1261 = load i64, ptr %41, align 8, !tbaa !9
  %1262 = load i64, ptr %22, align 8, !tbaa !9
  %1263 = mul nsw i64 %1261, %1262
  %1264 = add nsw i64 %1263, 2
  store i64 %1264, ptr %25, align 8, !tbaa !9
  %1265 = load i64, ptr %41, align 8, !tbaa !9
  %1266 = load i64, ptr %22, align 8, !tbaa !9
  %1267 = mul nsw i64 %1265, %1266
  %1268 = add nsw i64 %1267, 1
  store i64 %1268, ptr %26, align 8, !tbaa !9
  %1269 = load ptr, ptr %17, align 8, !tbaa !5
  %1270 = getelementptr inbounds %struct.complex, ptr %1269, i64 1
  %1271 = getelementptr inbounds %struct.complex, ptr %1270, i32 0, i32 0
  %1272 = load float, ptr %1271, align 4, !tbaa !11
  %1273 = load ptr, ptr %20, align 8, !tbaa !5
  %1274 = load i64, ptr %26, align 8, !tbaa !9
  %1275 = getelementptr inbounds %struct.complex, ptr %1273, i64 %1274
  %1276 = getelementptr inbounds %struct.complex, ptr %1275, i32 0, i32 0
  %1277 = load float, ptr %1276, align 4, !tbaa !11
  %1278 = load ptr, ptr %17, align 8, !tbaa !5
  %1279 = getelementptr inbounds %struct.complex, ptr %1278, i64 1
  %1280 = getelementptr inbounds %struct.complex, ptr %1279, i32 0, i32 1
  %1281 = load float, ptr %1280, align 4, !tbaa !14
  %1282 = load ptr, ptr %20, align 8, !tbaa !5
  %1283 = load i64, ptr %26, align 8, !tbaa !9
  %1284 = getelementptr inbounds %struct.complex, ptr %1282, i64 %1283
  %1285 = getelementptr inbounds %struct.complex, ptr %1284, i32 0, i32 1
  %1286 = load float, ptr %1285, align 4, !tbaa !14
  %1287 = fmul float %1281, %1286
  %1288 = fneg float %1287
  %1289 = call float @llvm.fmuladd.f32(float %1272, float %1277, float %1288)
  %1290 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1289, ptr %1290, align 4, !tbaa !11
  %1291 = load ptr, ptr %17, align 8, !tbaa !5
  %1292 = getelementptr inbounds %struct.complex, ptr %1291, i64 1
  %1293 = getelementptr inbounds %struct.complex, ptr %1292, i32 0, i32 0
  %1294 = load float, ptr %1293, align 4, !tbaa !11
  %1295 = load ptr, ptr %20, align 8, !tbaa !5
  %1296 = load i64, ptr %26, align 8, !tbaa !9
  %1297 = getelementptr inbounds %struct.complex, ptr %1295, i64 %1296
  %1298 = getelementptr inbounds %struct.complex, ptr %1297, i32 0, i32 1
  %1299 = load float, ptr %1298, align 4, !tbaa !14
  %1300 = load ptr, ptr %17, align 8, !tbaa !5
  %1301 = getelementptr inbounds %struct.complex, ptr %1300, i64 1
  %1302 = getelementptr inbounds %struct.complex, ptr %1301, i32 0, i32 1
  %1303 = load float, ptr %1302, align 4, !tbaa !14
  %1304 = load ptr, ptr %20, align 8, !tbaa !5
  %1305 = load i64, ptr %26, align 8, !tbaa !9
  %1306 = getelementptr inbounds %struct.complex, ptr %1304, i64 %1305
  %1307 = getelementptr inbounds %struct.complex, ptr %1306, i32 0, i32 0
  %1308 = load float, ptr %1307, align 4, !tbaa !11
  %1309 = fmul float %1303, %1308
  %1310 = call float @llvm.fmuladd.f32(float %1294, float %1299, float %1309)
  %1311 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1310, ptr %1311, align 4, !tbaa !14
  %1312 = load ptr, ptr %20, align 8, !tbaa !5
  %1313 = load i64, ptr %25, align 8, !tbaa !9
  %1314 = getelementptr inbounds %struct.complex, ptr %1312, i64 %1313
  %1315 = getelementptr inbounds %struct.complex, ptr %1314, i32 0, i32 0
  %1316 = load float, ptr %1315, align 4, !tbaa !11
  %1317 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1318 = load float, ptr %1317, align 4, !tbaa !11
  %1319 = fsub float %1316, %1318
  %1320 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1319, ptr %1320, align 4, !tbaa !11
  %1321 = load ptr, ptr %20, align 8, !tbaa !5
  %1322 = load i64, ptr %25, align 8, !tbaa !9
  %1323 = getelementptr inbounds %struct.complex, ptr %1321, i64 %1322
  %1324 = getelementptr inbounds %struct.complex, ptr %1323, i32 0, i32 1
  %1325 = load float, ptr %1324, align 4, !tbaa !14
  %1326 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1327 = load float, ptr %1326, align 4, !tbaa !14
  %1328 = fsub float %1325, %1327
  %1329 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1328, ptr %1329, align 4, !tbaa !14
  %1330 = load ptr, ptr %16, align 8, !tbaa !5
  %1331 = getelementptr inbounds %struct.complex, ptr %1330, i64 2
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %1331)
  %1332 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1333 = load float, ptr %1332, align 4, !tbaa !11
  %1334 = load ptr, ptr %20, align 8, !tbaa !5
  %1335 = load i64, ptr %24, align 8, !tbaa !9
  %1336 = getelementptr inbounds %struct.complex, ptr %1334, i64 %1335
  %1337 = getelementptr inbounds %struct.complex, ptr %1336, i32 0, i32 0
  store float %1333, ptr %1337, align 4, !tbaa !11
  %1338 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1339 = load float, ptr %1338, align 4, !tbaa !14
  %1340 = load ptr, ptr %20, align 8, !tbaa !5
  %1341 = load i64, ptr %24, align 8, !tbaa !9
  %1342 = getelementptr inbounds %struct.complex, ptr %1340, i64 %1341
  %1343 = getelementptr inbounds %struct.complex, ptr %1342, i32 0, i32 1
  store float %1339, ptr %1343, align 4, !tbaa !14
  br label %1344

1344:                                             ; preds = %1256, %1228
  %1345 = load ptr, ptr %13, align 8, !tbaa !5
  %1346 = load i64, ptr %1345, align 8, !tbaa !9
  store i64 %1346, ptr %24, align 8, !tbaa !9
  store i64 3, ptr %40, align 8, !tbaa !9
  br label %1347

1347:                                             ; preds = %1517, %1344
  %1348 = load i64, ptr %40, align 8, !tbaa !9
  %1349 = load i64, ptr %24, align 8, !tbaa !9
  %1350 = icmp sle i64 %1348, %1349
  br i1 %1350, label %1351, label %1520

1351:                                             ; preds = %1347
  %1352 = load i64, ptr %40, align 8, !tbaa !9
  %1353 = load i64, ptr %41, align 8, !tbaa !9
  %1354 = load i64, ptr %22, align 8, !tbaa !9
  %1355 = mul nsw i64 %1353, %1354
  %1356 = add nsw i64 %1352, %1355
  store i64 %1356, ptr %25, align 8, !tbaa !9
  %1357 = load i64, ptr %40, align 8, !tbaa !9
  %1358 = load i64, ptr %41, align 8, !tbaa !9
  %1359 = load i64, ptr %22, align 8, !tbaa !9
  %1360 = mul nsw i64 %1358, %1359
  %1361 = add nsw i64 %1357, %1360
  store i64 %1361, ptr %26, align 8, !tbaa !9
  %1362 = load i64, ptr %40, align 8, !tbaa !9
  %1363 = sub nsw i64 %1362, 1
  store i64 %1363, ptr %27, align 8, !tbaa !9
  %1364 = load i64, ptr %40, align 8, !tbaa !9
  %1365 = sub nsw i64 %1364, 1
  %1366 = load i64, ptr %41, align 8, !tbaa !9
  %1367 = load i64, ptr %22, align 8, !tbaa !9
  %1368 = mul nsw i64 %1366, %1367
  %1369 = add nsw i64 %1365, %1368
  store i64 %1369, ptr %28, align 8, !tbaa !9
  %1370 = load ptr, ptr %17, align 8, !tbaa !5
  %1371 = load i64, ptr %27, align 8, !tbaa !9
  %1372 = getelementptr inbounds %struct.complex, ptr %1370, i64 %1371
  %1373 = getelementptr inbounds %struct.complex, ptr %1372, i32 0, i32 0
  %1374 = load float, ptr %1373, align 4, !tbaa !11
  %1375 = load ptr, ptr %20, align 8, !tbaa !5
  %1376 = load i64, ptr %28, align 8, !tbaa !9
  %1377 = getelementptr inbounds %struct.complex, ptr %1375, i64 %1376
  %1378 = getelementptr inbounds %struct.complex, ptr %1377, i32 0, i32 0
  %1379 = load float, ptr %1378, align 4, !tbaa !11
  %1380 = load ptr, ptr %17, align 8, !tbaa !5
  %1381 = load i64, ptr %27, align 8, !tbaa !9
  %1382 = getelementptr inbounds %struct.complex, ptr %1380, i64 %1381
  %1383 = getelementptr inbounds %struct.complex, ptr %1382, i32 0, i32 1
  %1384 = load float, ptr %1383, align 4, !tbaa !14
  %1385 = load ptr, ptr %20, align 8, !tbaa !5
  %1386 = load i64, ptr %28, align 8, !tbaa !9
  %1387 = getelementptr inbounds %struct.complex, ptr %1385, i64 %1386
  %1388 = getelementptr inbounds %struct.complex, ptr %1387, i32 0, i32 1
  %1389 = load float, ptr %1388, align 4, !tbaa !14
  %1390 = fmul float %1384, %1389
  %1391 = fneg float %1390
  %1392 = call float @llvm.fmuladd.f32(float %1374, float %1379, float %1391)
  %1393 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %1392, ptr %1393, align 4, !tbaa !11
  %1394 = load ptr, ptr %17, align 8, !tbaa !5
  %1395 = load i64, ptr %27, align 8, !tbaa !9
  %1396 = getelementptr inbounds %struct.complex, ptr %1394, i64 %1395
  %1397 = getelementptr inbounds %struct.complex, ptr %1396, i32 0, i32 0
  %1398 = load float, ptr %1397, align 4, !tbaa !11
  %1399 = load ptr, ptr %20, align 8, !tbaa !5
  %1400 = load i64, ptr %28, align 8, !tbaa !9
  %1401 = getelementptr inbounds %struct.complex, ptr %1399, i64 %1400
  %1402 = getelementptr inbounds %struct.complex, ptr %1401, i32 0, i32 1
  %1403 = load float, ptr %1402, align 4, !tbaa !14
  %1404 = load ptr, ptr %17, align 8, !tbaa !5
  %1405 = load i64, ptr %27, align 8, !tbaa !9
  %1406 = getelementptr inbounds %struct.complex, ptr %1404, i64 %1405
  %1407 = getelementptr inbounds %struct.complex, ptr %1406, i32 0, i32 1
  %1408 = load float, ptr %1407, align 4, !tbaa !14
  %1409 = load ptr, ptr %20, align 8, !tbaa !5
  %1410 = load i64, ptr %28, align 8, !tbaa !9
  %1411 = getelementptr inbounds %struct.complex, ptr %1409, i64 %1410
  %1412 = getelementptr inbounds %struct.complex, ptr %1411, i32 0, i32 0
  %1413 = load float, ptr %1412, align 4, !tbaa !11
  %1414 = fmul float %1408, %1413
  %1415 = call float @llvm.fmuladd.f32(float %1398, float %1403, float %1414)
  %1416 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %1415, ptr %1416, align 4, !tbaa !14
  %1417 = load ptr, ptr %20, align 8, !tbaa !5
  %1418 = load i64, ptr %26, align 8, !tbaa !9
  %1419 = getelementptr inbounds %struct.complex, ptr %1417, i64 %1418
  %1420 = getelementptr inbounds %struct.complex, ptr %1419, i32 0, i32 0
  %1421 = load float, ptr %1420, align 4, !tbaa !11
  %1422 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %1423 = load float, ptr %1422, align 4, !tbaa !11
  %1424 = fsub float %1421, %1423
  %1425 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1424, ptr %1425, align 4, !tbaa !11
  %1426 = load ptr, ptr %20, align 8, !tbaa !5
  %1427 = load i64, ptr %26, align 8, !tbaa !9
  %1428 = getelementptr inbounds %struct.complex, ptr %1426, i64 %1427
  %1429 = getelementptr inbounds %struct.complex, ptr %1428, i32 0, i32 1
  %1430 = load float, ptr %1429, align 4, !tbaa !14
  %1431 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %1432 = load float, ptr %1431, align 4, !tbaa !14
  %1433 = fsub float %1430, %1432
  %1434 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1433, ptr %1434, align 4, !tbaa !14
  %1435 = load i64, ptr %40, align 8, !tbaa !9
  %1436 = sub nsw i64 %1435, 2
  store i64 %1436, ptr %29, align 8, !tbaa !9
  %1437 = load i64, ptr %40, align 8, !tbaa !9
  %1438 = sub nsw i64 %1437, 2
  %1439 = load i64, ptr %41, align 8, !tbaa !9
  %1440 = load i64, ptr %22, align 8, !tbaa !9
  %1441 = mul nsw i64 %1439, %1440
  %1442 = add nsw i64 %1438, %1441
  store i64 %1442, ptr %30, align 8, !tbaa !9
  %1443 = load ptr, ptr %18, align 8, !tbaa !5
  %1444 = load i64, ptr %29, align 8, !tbaa !9
  %1445 = getelementptr inbounds %struct.complex, ptr %1443, i64 %1444
  %1446 = getelementptr inbounds %struct.complex, ptr %1445, i32 0, i32 0
  %1447 = load float, ptr %1446, align 4, !tbaa !11
  %1448 = load ptr, ptr %20, align 8, !tbaa !5
  %1449 = load i64, ptr %30, align 8, !tbaa !9
  %1450 = getelementptr inbounds %struct.complex, ptr %1448, i64 %1449
  %1451 = getelementptr inbounds %struct.complex, ptr %1450, i32 0, i32 0
  %1452 = load float, ptr %1451, align 4, !tbaa !11
  %1453 = load ptr, ptr %18, align 8, !tbaa !5
  %1454 = load i64, ptr %29, align 8, !tbaa !9
  %1455 = getelementptr inbounds %struct.complex, ptr %1453, i64 %1454
  %1456 = getelementptr inbounds %struct.complex, ptr %1455, i32 0, i32 1
  %1457 = load float, ptr %1456, align 4, !tbaa !14
  %1458 = load ptr, ptr %20, align 8, !tbaa !5
  %1459 = load i64, ptr %30, align 8, !tbaa !9
  %1460 = getelementptr inbounds %struct.complex, ptr %1458, i64 %1459
  %1461 = getelementptr inbounds %struct.complex, ptr %1460, i32 0, i32 1
  %1462 = load float, ptr %1461, align 4, !tbaa !14
  %1463 = fmul float %1457, %1462
  %1464 = fneg float %1463
  %1465 = call float @llvm.fmuladd.f32(float %1447, float %1452, float %1464)
  %1466 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %1465, ptr %1466, align 4, !tbaa !11
  %1467 = load ptr, ptr %18, align 8, !tbaa !5
  %1468 = load i64, ptr %29, align 8, !tbaa !9
  %1469 = getelementptr inbounds %struct.complex, ptr %1467, i64 %1468
  %1470 = getelementptr inbounds %struct.complex, ptr %1469, i32 0, i32 0
  %1471 = load float, ptr %1470, align 4, !tbaa !11
  %1472 = load ptr, ptr %20, align 8, !tbaa !5
  %1473 = load i64, ptr %30, align 8, !tbaa !9
  %1474 = getelementptr inbounds %struct.complex, ptr %1472, i64 %1473
  %1475 = getelementptr inbounds %struct.complex, ptr %1474, i32 0, i32 1
  %1476 = load float, ptr %1475, align 4, !tbaa !14
  %1477 = load ptr, ptr %18, align 8, !tbaa !5
  %1478 = load i64, ptr %29, align 8, !tbaa !9
  %1479 = getelementptr inbounds %struct.complex, ptr %1477, i64 %1478
  %1480 = getelementptr inbounds %struct.complex, ptr %1479, i32 0, i32 1
  %1481 = load float, ptr %1480, align 4, !tbaa !14
  %1482 = load ptr, ptr %20, align 8, !tbaa !5
  %1483 = load i64, ptr %30, align 8, !tbaa !9
  %1484 = getelementptr inbounds %struct.complex, ptr %1482, i64 %1483
  %1485 = getelementptr inbounds %struct.complex, ptr %1484, i32 0, i32 0
  %1486 = load float, ptr %1485, align 4, !tbaa !11
  %1487 = fmul float %1481, %1486
  %1488 = call float @llvm.fmuladd.f32(float %1471, float %1476, float %1487)
  %1489 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %1488, ptr %1489, align 4, !tbaa !14
  %1490 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1491 = load float, ptr %1490, align 4, !tbaa !11
  %1492 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %1493 = load float, ptr %1492, align 4, !tbaa !11
  %1494 = fsub float %1491, %1493
  %1495 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1494, ptr %1495, align 4, !tbaa !11
  %1496 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1497 = load float, ptr %1496, align 4, !tbaa !14
  %1498 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %1499 = load float, ptr %1498, align 4, !tbaa !14
  %1500 = fsub float %1497, %1499
  %1501 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1500, ptr %1501, align 4, !tbaa !14
  %1502 = load ptr, ptr %16, align 8, !tbaa !5
  %1503 = load i64, ptr %40, align 8, !tbaa !9
  %1504 = getelementptr inbounds %struct.complex, ptr %1502, i64 %1503
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %1504)
  %1505 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1506 = load float, ptr %1505, align 4, !tbaa !11
  %1507 = load ptr, ptr %20, align 8, !tbaa !5
  %1508 = load i64, ptr %25, align 8, !tbaa !9
  %1509 = getelementptr inbounds %struct.complex, ptr %1507, i64 %1508
  %1510 = getelementptr inbounds %struct.complex, ptr %1509, i32 0, i32 0
  store float %1506, ptr %1510, align 4, !tbaa !11
  %1511 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1512 = load float, ptr %1511, align 4, !tbaa !14
  %1513 = load ptr, ptr %20, align 8, !tbaa !5
  %1514 = load i64, ptr %25, align 8, !tbaa !9
  %1515 = getelementptr inbounds %struct.complex, ptr %1513, i64 %1514
  %1516 = getelementptr inbounds %struct.complex, ptr %1515, i32 0, i32 1
  store float %1512, ptr %1516, align 4, !tbaa !14
  br label %1517

1517:                                             ; preds = %1351
  %1518 = load i64, ptr %40, align 8, !tbaa !9
  %1519 = add nsw i64 %1518, 1
  store i64 %1519, ptr %40, align 8, !tbaa !9
  br label %1347, !llvm.loop !21

1520:                                             ; preds = %1347
  %1521 = load ptr, ptr %13, align 8, !tbaa !5
  %1522 = load i64, ptr %1521, align 8, !tbaa !9
  %1523 = sub nsw i64 %1522, 1
  store i64 %1523, ptr %40, align 8, !tbaa !9
  br label %1524

1524:                                             ; preds = %1743, %1520
  %1525 = load i64, ptr %40, align 8, !tbaa !9
  %1526 = icmp sge i64 %1525, 1
  br i1 %1526, label %1527, label %1746

1527:                                             ; preds = %1524
  %1528 = load ptr, ptr %19, align 8, !tbaa !5
  %1529 = load i64, ptr %40, align 8, !tbaa !9
  %1530 = getelementptr inbounds i64, ptr %1528, i64 %1529
  %1531 = load i64, ptr %1530, align 8, !tbaa !9
  %1532 = load i64, ptr %40, align 8, !tbaa !9
  %1533 = icmp eq i64 %1531, %1532
  br i1 %1533, label %1534, label %1629

1534:                                             ; preds = %1527
  %1535 = load i64, ptr %40, align 8, !tbaa !9
  %1536 = load i64, ptr %41, align 8, !tbaa !9
  %1537 = load i64, ptr %22, align 8, !tbaa !9
  %1538 = mul nsw i64 %1536, %1537
  %1539 = add nsw i64 %1535, %1538
  store i64 %1539, ptr %24, align 8, !tbaa !9
  %1540 = load i64, ptr %40, align 8, !tbaa !9
  %1541 = load i64, ptr %41, align 8, !tbaa !9
  %1542 = load i64, ptr %22, align 8, !tbaa !9
  %1543 = mul nsw i64 %1541, %1542
  %1544 = add nsw i64 %1540, %1543
  store i64 %1544, ptr %25, align 8, !tbaa !9
  %1545 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %1545, ptr %26, align 8, !tbaa !9
  %1546 = load i64, ptr %40, align 8, !tbaa !9
  %1547 = add nsw i64 %1546, 1
  %1548 = load i64, ptr %41, align 8, !tbaa !9
  %1549 = load i64, ptr %22, align 8, !tbaa !9
  %1550 = mul nsw i64 %1548, %1549
  %1551 = add nsw i64 %1547, %1550
  store i64 %1551, ptr %27, align 8, !tbaa !9
  %1552 = load ptr, ptr %15, align 8, !tbaa !5
  %1553 = load i64, ptr %26, align 8, !tbaa !9
  %1554 = getelementptr inbounds %struct.complex, ptr %1552, i64 %1553
  %1555 = getelementptr inbounds %struct.complex, ptr %1554, i32 0, i32 0
  %1556 = load float, ptr %1555, align 4, !tbaa !11
  %1557 = load ptr, ptr %20, align 8, !tbaa !5
  %1558 = load i64, ptr %27, align 8, !tbaa !9
  %1559 = getelementptr inbounds %struct.complex, ptr %1557, i64 %1558
  %1560 = getelementptr inbounds %struct.complex, ptr %1559, i32 0, i32 0
  %1561 = load float, ptr %1560, align 4, !tbaa !11
  %1562 = load ptr, ptr %15, align 8, !tbaa !5
  %1563 = load i64, ptr %26, align 8, !tbaa !9
  %1564 = getelementptr inbounds %struct.complex, ptr %1562, i64 %1563
  %1565 = getelementptr inbounds %struct.complex, ptr %1564, i32 0, i32 1
  %1566 = load float, ptr %1565, align 4, !tbaa !14
  %1567 = load ptr, ptr %20, align 8, !tbaa !5
  %1568 = load i64, ptr %27, align 8, !tbaa !9
  %1569 = getelementptr inbounds %struct.complex, ptr %1567, i64 %1568
  %1570 = getelementptr inbounds %struct.complex, ptr %1569, i32 0, i32 1
  %1571 = load float, ptr %1570, align 4, !tbaa !14
  %1572 = fmul float %1566, %1571
  %1573 = fneg float %1572
  %1574 = call float @llvm.fmuladd.f32(float %1556, float %1561, float %1573)
  %1575 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1574, ptr %1575, align 4, !tbaa !11
  %1576 = load ptr, ptr %15, align 8, !tbaa !5
  %1577 = load i64, ptr %26, align 8, !tbaa !9
  %1578 = getelementptr inbounds %struct.complex, ptr %1576, i64 %1577
  %1579 = getelementptr inbounds %struct.complex, ptr %1578, i32 0, i32 0
  %1580 = load float, ptr %1579, align 4, !tbaa !11
  %1581 = load ptr, ptr %20, align 8, !tbaa !5
  %1582 = load i64, ptr %27, align 8, !tbaa !9
  %1583 = getelementptr inbounds %struct.complex, ptr %1581, i64 %1582
  %1584 = getelementptr inbounds %struct.complex, ptr %1583, i32 0, i32 1
  %1585 = load float, ptr %1584, align 4, !tbaa !14
  %1586 = load ptr, ptr %15, align 8, !tbaa !5
  %1587 = load i64, ptr %26, align 8, !tbaa !9
  %1588 = getelementptr inbounds %struct.complex, ptr %1586, i64 %1587
  %1589 = getelementptr inbounds %struct.complex, ptr %1588, i32 0, i32 1
  %1590 = load float, ptr %1589, align 4, !tbaa !14
  %1591 = load ptr, ptr %20, align 8, !tbaa !5
  %1592 = load i64, ptr %27, align 8, !tbaa !9
  %1593 = getelementptr inbounds %struct.complex, ptr %1591, i64 %1592
  %1594 = getelementptr inbounds %struct.complex, ptr %1593, i32 0, i32 0
  %1595 = load float, ptr %1594, align 4, !tbaa !11
  %1596 = fmul float %1590, %1595
  %1597 = call float @llvm.fmuladd.f32(float %1580, float %1585, float %1596)
  %1598 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1597, ptr %1598, align 4, !tbaa !14
  %1599 = load ptr, ptr %20, align 8, !tbaa !5
  %1600 = load i64, ptr %25, align 8, !tbaa !9
  %1601 = getelementptr inbounds %struct.complex, ptr %1599, i64 %1600
  %1602 = getelementptr inbounds %struct.complex, ptr %1601, i32 0, i32 0
  %1603 = load float, ptr %1602, align 4, !tbaa !11
  %1604 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1605 = load float, ptr %1604, align 4, !tbaa !11
  %1606 = fsub float %1603, %1605
  %1607 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %1606, ptr %1607, align 4, !tbaa !11
  %1608 = load ptr, ptr %20, align 8, !tbaa !5
  %1609 = load i64, ptr %25, align 8, !tbaa !9
  %1610 = getelementptr inbounds %struct.complex, ptr %1608, i64 %1609
  %1611 = getelementptr inbounds %struct.complex, ptr %1610, i32 0, i32 1
  %1612 = load float, ptr %1611, align 4, !tbaa !14
  %1613 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1614 = load float, ptr %1613, align 4, !tbaa !14
  %1615 = fsub float %1612, %1614
  %1616 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %1615, ptr %1616, align 4, !tbaa !14
  %1617 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1618 = load float, ptr %1617, align 4, !tbaa !11
  %1619 = load ptr, ptr %20, align 8, !tbaa !5
  %1620 = load i64, ptr %24, align 8, !tbaa !9
  %1621 = getelementptr inbounds %struct.complex, ptr %1619, i64 %1620
  %1622 = getelementptr inbounds %struct.complex, ptr %1621, i32 0, i32 0
  store float %1618, ptr %1622, align 4, !tbaa !11
  %1623 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1624 = load float, ptr %1623, align 4, !tbaa !14
  %1625 = load ptr, ptr %20, align 8, !tbaa !5
  %1626 = load i64, ptr %24, align 8, !tbaa !9
  %1627 = getelementptr inbounds %struct.complex, ptr %1625, i64 %1626
  %1628 = getelementptr inbounds %struct.complex, ptr %1627, i32 0, i32 1
  store float %1624, ptr %1628, align 4, !tbaa !14
  br label %1742

1629:                                             ; preds = %1527
  %1630 = load i64, ptr %40, align 8, !tbaa !9
  %1631 = add nsw i64 %1630, 1
  %1632 = load i64, ptr %41, align 8, !tbaa !9
  %1633 = load i64, ptr %22, align 8, !tbaa !9
  %1634 = mul nsw i64 %1632, %1633
  %1635 = add nsw i64 %1631, %1634
  store i64 %1635, ptr %24, align 8, !tbaa !9
  %1636 = load ptr, ptr %20, align 8, !tbaa !5
  %1637 = load i64, ptr %24, align 8, !tbaa !9
  %1638 = getelementptr inbounds %struct.complex, ptr %1636, i64 %1637
  %1639 = getelementptr inbounds %struct.complex, ptr %1638, i32 0, i32 0
  %1640 = load float, ptr %1639, align 4, !tbaa !11
  %1641 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %1640, ptr %1641, align 4, !tbaa !11
  %1642 = load ptr, ptr %20, align 8, !tbaa !5
  %1643 = load i64, ptr %24, align 8, !tbaa !9
  %1644 = getelementptr inbounds %struct.complex, ptr %1642, i64 %1643
  %1645 = getelementptr inbounds %struct.complex, ptr %1644, i32 0, i32 1
  %1646 = load float, ptr %1645, align 4, !tbaa !14
  %1647 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %1646, ptr %1647, align 4, !tbaa !14
  %1648 = load i64, ptr %40, align 8, !tbaa !9
  %1649 = add nsw i64 %1648, 1
  %1650 = load i64, ptr %41, align 8, !tbaa !9
  %1651 = load i64, ptr %22, align 8, !tbaa !9
  %1652 = mul nsw i64 %1650, %1651
  %1653 = add nsw i64 %1649, %1652
  store i64 %1653, ptr %24, align 8, !tbaa !9
  %1654 = load i64, ptr %40, align 8, !tbaa !9
  %1655 = load i64, ptr %41, align 8, !tbaa !9
  %1656 = load i64, ptr %22, align 8, !tbaa !9
  %1657 = mul nsw i64 %1655, %1656
  %1658 = add nsw i64 %1654, %1657
  store i64 %1658, ptr %25, align 8, !tbaa !9
  %1659 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %1659, ptr %26, align 8, !tbaa !9
  %1660 = load ptr, ptr %15, align 8, !tbaa !5
  %1661 = load i64, ptr %26, align 8, !tbaa !9
  %1662 = getelementptr inbounds %struct.complex, ptr %1660, i64 %1661
  %1663 = getelementptr inbounds %struct.complex, ptr %1662, i32 0, i32 0
  %1664 = load float, ptr %1663, align 4, !tbaa !11
  %1665 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %1666 = load float, ptr %1665, align 4, !tbaa !11
  %1667 = load ptr, ptr %15, align 8, !tbaa !5
  %1668 = load i64, ptr %26, align 8, !tbaa !9
  %1669 = getelementptr inbounds %struct.complex, ptr %1667, i64 %1668
  %1670 = getelementptr inbounds %struct.complex, ptr %1669, i32 0, i32 1
  %1671 = load float, ptr %1670, align 4, !tbaa !14
  %1672 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %1673 = load float, ptr %1672, align 4, !tbaa !14
  %1674 = fmul float %1671, %1673
  %1675 = fneg float %1674
  %1676 = call float @llvm.fmuladd.f32(float %1664, float %1666, float %1675)
  %1677 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1676, ptr %1677, align 4, !tbaa !11
  %1678 = load ptr, ptr %15, align 8, !tbaa !5
  %1679 = load i64, ptr %26, align 8, !tbaa !9
  %1680 = getelementptr inbounds %struct.complex, ptr %1678, i64 %1679
  %1681 = getelementptr inbounds %struct.complex, ptr %1680, i32 0, i32 0
  %1682 = load float, ptr %1681, align 4, !tbaa !11
  %1683 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %1684 = load float, ptr %1683, align 4, !tbaa !14
  %1685 = load ptr, ptr %15, align 8, !tbaa !5
  %1686 = load i64, ptr %26, align 8, !tbaa !9
  %1687 = getelementptr inbounds %struct.complex, ptr %1685, i64 %1686
  %1688 = getelementptr inbounds %struct.complex, ptr %1687, i32 0, i32 1
  %1689 = load float, ptr %1688, align 4, !tbaa !14
  %1690 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %1691 = load float, ptr %1690, align 4, !tbaa !11
  %1692 = fmul float %1689, %1691
  %1693 = call float @llvm.fmuladd.f32(float %1682, float %1684, float %1692)
  %1694 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1693, ptr %1694, align 4, !tbaa !14
  %1695 = load ptr, ptr %20, align 8, !tbaa !5
  %1696 = load i64, ptr %25, align 8, !tbaa !9
  %1697 = getelementptr inbounds %struct.complex, ptr %1695, i64 %1696
  %1698 = getelementptr inbounds %struct.complex, ptr %1697, i32 0, i32 0
  %1699 = load float, ptr %1698, align 4, !tbaa !11
  %1700 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %1701 = load float, ptr %1700, align 4, !tbaa !11
  %1702 = fsub float %1699, %1701
  %1703 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %1702, ptr %1703, align 4, !tbaa !11
  %1704 = load ptr, ptr %20, align 8, !tbaa !5
  %1705 = load i64, ptr %25, align 8, !tbaa !9
  %1706 = getelementptr inbounds %struct.complex, ptr %1704, i64 %1705
  %1707 = getelementptr inbounds %struct.complex, ptr %1706, i32 0, i32 1
  %1708 = load float, ptr %1707, align 4, !tbaa !14
  %1709 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %1710 = load float, ptr %1709, align 4, !tbaa !14
  %1711 = fsub float %1708, %1710
  %1712 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %1711, ptr %1712, align 4, !tbaa !14
  %1713 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1714 = load float, ptr %1713, align 4, !tbaa !11
  %1715 = load ptr, ptr %20, align 8, !tbaa !5
  %1716 = load i64, ptr %24, align 8, !tbaa !9
  %1717 = getelementptr inbounds %struct.complex, ptr %1715, i64 %1716
  %1718 = getelementptr inbounds %struct.complex, ptr %1717, i32 0, i32 0
  store float %1714, ptr %1718, align 4, !tbaa !11
  %1719 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1720 = load float, ptr %1719, align 4, !tbaa !14
  %1721 = load ptr, ptr %20, align 8, !tbaa !5
  %1722 = load i64, ptr %24, align 8, !tbaa !9
  %1723 = getelementptr inbounds %struct.complex, ptr %1721, i64 %1722
  %1724 = getelementptr inbounds %struct.complex, ptr %1723, i32 0, i32 1
  store float %1720, ptr %1724, align 4, !tbaa !14
  %1725 = load i64, ptr %40, align 8, !tbaa !9
  %1726 = load i64, ptr %41, align 8, !tbaa !9
  %1727 = load i64, ptr %22, align 8, !tbaa !9
  %1728 = mul nsw i64 %1726, %1727
  %1729 = add nsw i64 %1725, %1728
  store i64 %1729, ptr %24, align 8, !tbaa !9
  %1730 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %1731 = load float, ptr %1730, align 4, !tbaa !11
  %1732 = load ptr, ptr %20, align 8, !tbaa !5
  %1733 = load i64, ptr %24, align 8, !tbaa !9
  %1734 = getelementptr inbounds %struct.complex, ptr %1732, i64 %1733
  %1735 = getelementptr inbounds %struct.complex, ptr %1734, i32 0, i32 0
  store float %1731, ptr %1735, align 4, !tbaa !11
  %1736 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %1737 = load float, ptr %1736, align 4, !tbaa !14
  %1738 = load ptr, ptr %20, align 8, !tbaa !5
  %1739 = load i64, ptr %24, align 8, !tbaa !9
  %1740 = getelementptr inbounds %struct.complex, ptr %1738, i64 %1739
  %1741 = getelementptr inbounds %struct.complex, ptr %1740, i32 0, i32 1
  store float %1737, ptr %1741, align 4, !tbaa !14
  br label %1742

1742:                                             ; preds = %1629, %1534
  br label %1743

1743:                                             ; preds = %1742
  %1744 = load i64, ptr %40, align 8, !tbaa !9
  %1745 = add nsw i64 %1744, -1
  store i64 %1745, ptr %40, align 8, !tbaa !9
  br label %1524, !llvm.loop !22

1746:                                             ; preds = %1524
  %1747 = load i64, ptr %41, align 8, !tbaa !9
  %1748 = load ptr, ptr %14, align 8, !tbaa !5
  %1749 = load i64, ptr %1748, align 8, !tbaa !9
  %1750 = icmp slt i64 %1747, %1749
  br i1 %1750, label %1751, label %1754

1751:                                             ; preds = %1746
  %1752 = load i64, ptr %41, align 8, !tbaa !9
  %1753 = add nsw i64 %1752, 1
  store i64 %1753, ptr %41, align 8, !tbaa !9
  br label %1228

1754:                                             ; preds = %1746
  br label %2285

1755:                                             ; preds = %1223
  %1756 = load ptr, ptr %14, align 8, !tbaa !5
  %1757 = load i64, ptr %1756, align 8, !tbaa !9
  store i64 %1757, ptr %24, align 8, !tbaa !9
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %1758

1758:                                             ; preds = %2281, %1755
  %1759 = load i64, ptr %41, align 8, !tbaa !9
  %1760 = load i64, ptr %24, align 8, !tbaa !9
  %1761 = icmp sle i64 %1759, %1760
  br i1 %1761, label %1762, label %2284

1762:                                             ; preds = %1758
  %1763 = load i64, ptr %41, align 8, !tbaa !9
  %1764 = load i64, ptr %22, align 8, !tbaa !9
  %1765 = mul nsw i64 %1763, %1764
  %1766 = add nsw i64 %1765, 1
  store i64 %1766, ptr %25, align 8, !tbaa !9
  %1767 = load ptr, ptr %20, align 8, !tbaa !5
  %1768 = load i64, ptr %41, align 8, !tbaa !9
  %1769 = load i64, ptr %22, align 8, !tbaa !9
  %1770 = mul nsw i64 %1768, %1769
  %1771 = add nsw i64 %1770, 1
  %1772 = getelementptr inbounds %struct.complex, ptr %1767, i64 %1771
  %1773 = load ptr, ptr %16, align 8, !tbaa !5
  %1774 = getelementptr inbounds %struct.complex, ptr %1773, i64 1
  call void @c_div(ptr noundef %32, ptr noundef %1772, ptr noundef %1774)
  %1775 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1776 = load float, ptr %1775, align 4, !tbaa !11
  %1777 = load ptr, ptr %20, align 8, !tbaa !5
  %1778 = load i64, ptr %25, align 8, !tbaa !9
  %1779 = getelementptr inbounds %struct.complex, ptr %1777, i64 %1778
  %1780 = getelementptr inbounds %struct.complex, ptr %1779, i32 0, i32 0
  store float %1776, ptr %1780, align 4, !tbaa !11
  %1781 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1782 = load float, ptr %1781, align 4, !tbaa !14
  %1783 = load ptr, ptr %20, align 8, !tbaa !5
  %1784 = load i64, ptr %25, align 8, !tbaa !9
  %1785 = getelementptr inbounds %struct.complex, ptr %1783, i64 %1784
  %1786 = getelementptr inbounds %struct.complex, ptr %1785, i32 0, i32 1
  store float %1782, ptr %1786, align 4, !tbaa !14
  %1787 = load ptr, ptr %13, align 8, !tbaa !5
  %1788 = load i64, ptr %1787, align 8, !tbaa !9
  %1789 = icmp sgt i64 %1788, 1
  br i1 %1789, label %1790, label %1878

1790:                                             ; preds = %1762
  %1791 = load i64, ptr %41, align 8, !tbaa !9
  %1792 = load i64, ptr %22, align 8, !tbaa !9
  %1793 = mul nsw i64 %1791, %1792
  %1794 = add nsw i64 %1793, 2
  store i64 %1794, ptr %25, align 8, !tbaa !9
  %1795 = load i64, ptr %41, align 8, !tbaa !9
  %1796 = load i64, ptr %22, align 8, !tbaa !9
  %1797 = mul nsw i64 %1795, %1796
  %1798 = add nsw i64 %1797, 2
  store i64 %1798, ptr %26, align 8, !tbaa !9
  %1799 = load i64, ptr %41, align 8, !tbaa !9
  %1800 = load i64, ptr %22, align 8, !tbaa !9
  %1801 = mul nsw i64 %1799, %1800
  %1802 = add nsw i64 %1801, 1
  store i64 %1802, ptr %27, align 8, !tbaa !9
  %1803 = load ptr, ptr %17, align 8, !tbaa !5
  %1804 = getelementptr inbounds %struct.complex, ptr %1803, i64 1
  %1805 = getelementptr inbounds %struct.complex, ptr %1804, i32 0, i32 0
  %1806 = load float, ptr %1805, align 4, !tbaa !11
  %1807 = load ptr, ptr %20, align 8, !tbaa !5
  %1808 = load i64, ptr %27, align 8, !tbaa !9
  %1809 = getelementptr inbounds %struct.complex, ptr %1807, i64 %1808
  %1810 = getelementptr inbounds %struct.complex, ptr %1809, i32 0, i32 0
  %1811 = load float, ptr %1810, align 4, !tbaa !11
  %1812 = load ptr, ptr %17, align 8, !tbaa !5
  %1813 = getelementptr inbounds %struct.complex, ptr %1812, i64 1
  %1814 = getelementptr inbounds %struct.complex, ptr %1813, i32 0, i32 1
  %1815 = load float, ptr %1814, align 4, !tbaa !14
  %1816 = load ptr, ptr %20, align 8, !tbaa !5
  %1817 = load i64, ptr %27, align 8, !tbaa !9
  %1818 = getelementptr inbounds %struct.complex, ptr %1816, i64 %1817
  %1819 = getelementptr inbounds %struct.complex, ptr %1818, i32 0, i32 1
  %1820 = load float, ptr %1819, align 4, !tbaa !14
  %1821 = fmul float %1815, %1820
  %1822 = fneg float %1821
  %1823 = call float @llvm.fmuladd.f32(float %1806, float %1811, float %1822)
  %1824 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1823, ptr %1824, align 4, !tbaa !11
  %1825 = load ptr, ptr %17, align 8, !tbaa !5
  %1826 = getelementptr inbounds %struct.complex, ptr %1825, i64 1
  %1827 = getelementptr inbounds %struct.complex, ptr %1826, i32 0, i32 0
  %1828 = load float, ptr %1827, align 4, !tbaa !11
  %1829 = load ptr, ptr %20, align 8, !tbaa !5
  %1830 = load i64, ptr %27, align 8, !tbaa !9
  %1831 = getelementptr inbounds %struct.complex, ptr %1829, i64 %1830
  %1832 = getelementptr inbounds %struct.complex, ptr %1831, i32 0, i32 1
  %1833 = load float, ptr %1832, align 4, !tbaa !14
  %1834 = load ptr, ptr %17, align 8, !tbaa !5
  %1835 = getelementptr inbounds %struct.complex, ptr %1834, i64 1
  %1836 = getelementptr inbounds %struct.complex, ptr %1835, i32 0, i32 1
  %1837 = load float, ptr %1836, align 4, !tbaa !14
  %1838 = load ptr, ptr %20, align 8, !tbaa !5
  %1839 = load i64, ptr %27, align 8, !tbaa !9
  %1840 = getelementptr inbounds %struct.complex, ptr %1838, i64 %1839
  %1841 = getelementptr inbounds %struct.complex, ptr %1840, i32 0, i32 0
  %1842 = load float, ptr %1841, align 4, !tbaa !11
  %1843 = fmul float %1837, %1842
  %1844 = call float @llvm.fmuladd.f32(float %1828, float %1833, float %1843)
  %1845 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1844, ptr %1845, align 4, !tbaa !14
  %1846 = load ptr, ptr %20, align 8, !tbaa !5
  %1847 = load i64, ptr %26, align 8, !tbaa !9
  %1848 = getelementptr inbounds %struct.complex, ptr %1846, i64 %1847
  %1849 = getelementptr inbounds %struct.complex, ptr %1848, i32 0, i32 0
  %1850 = load float, ptr %1849, align 4, !tbaa !11
  %1851 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %1852 = load float, ptr %1851, align 4, !tbaa !11
  %1853 = fsub float %1850, %1852
  %1854 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %1853, ptr %1854, align 4, !tbaa !11
  %1855 = load ptr, ptr %20, align 8, !tbaa !5
  %1856 = load i64, ptr %26, align 8, !tbaa !9
  %1857 = getelementptr inbounds %struct.complex, ptr %1855, i64 %1856
  %1858 = getelementptr inbounds %struct.complex, ptr %1857, i32 0, i32 1
  %1859 = load float, ptr %1858, align 4, !tbaa !14
  %1860 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %1861 = load float, ptr %1860, align 4, !tbaa !14
  %1862 = fsub float %1859, %1861
  %1863 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %1862, ptr %1863, align 4, !tbaa !14
  %1864 = load ptr, ptr %16, align 8, !tbaa !5
  %1865 = getelementptr inbounds %struct.complex, ptr %1864, i64 2
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %1865)
  %1866 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %1867 = load float, ptr %1866, align 4, !tbaa !11
  %1868 = load ptr, ptr %20, align 8, !tbaa !5
  %1869 = load i64, ptr %25, align 8, !tbaa !9
  %1870 = getelementptr inbounds %struct.complex, ptr %1868, i64 %1869
  %1871 = getelementptr inbounds %struct.complex, ptr %1870, i32 0, i32 0
  store float %1867, ptr %1871, align 4, !tbaa !11
  %1872 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %1873 = load float, ptr %1872, align 4, !tbaa !14
  %1874 = load ptr, ptr %20, align 8, !tbaa !5
  %1875 = load i64, ptr %25, align 8, !tbaa !9
  %1876 = getelementptr inbounds %struct.complex, ptr %1874, i64 %1875
  %1877 = getelementptr inbounds %struct.complex, ptr %1876, i32 0, i32 1
  store float %1873, ptr %1877, align 4, !tbaa !14
  br label %1878

1878:                                             ; preds = %1790, %1762
  %1879 = load ptr, ptr %13, align 8, !tbaa !5
  %1880 = load i64, ptr %1879, align 8, !tbaa !9
  store i64 %1880, ptr %25, align 8, !tbaa !9
  store i64 3, ptr %40, align 8, !tbaa !9
  br label %1881

1881:                                             ; preds = %2051, %1878
  %1882 = load i64, ptr %40, align 8, !tbaa !9
  %1883 = load i64, ptr %25, align 8, !tbaa !9
  %1884 = icmp sle i64 %1882, %1883
  br i1 %1884, label %1885, label %2054

1885:                                             ; preds = %1881
  %1886 = load i64, ptr %40, align 8, !tbaa !9
  %1887 = load i64, ptr %41, align 8, !tbaa !9
  %1888 = load i64, ptr %22, align 8, !tbaa !9
  %1889 = mul nsw i64 %1887, %1888
  %1890 = add nsw i64 %1886, %1889
  store i64 %1890, ptr %26, align 8, !tbaa !9
  %1891 = load i64, ptr %40, align 8, !tbaa !9
  %1892 = load i64, ptr %41, align 8, !tbaa !9
  %1893 = load i64, ptr %22, align 8, !tbaa !9
  %1894 = mul nsw i64 %1892, %1893
  %1895 = add nsw i64 %1891, %1894
  store i64 %1895, ptr %27, align 8, !tbaa !9
  %1896 = load i64, ptr %40, align 8, !tbaa !9
  %1897 = sub nsw i64 %1896, 1
  store i64 %1897, ptr %28, align 8, !tbaa !9
  %1898 = load i64, ptr %40, align 8, !tbaa !9
  %1899 = sub nsw i64 %1898, 1
  %1900 = load i64, ptr %41, align 8, !tbaa !9
  %1901 = load i64, ptr %22, align 8, !tbaa !9
  %1902 = mul nsw i64 %1900, %1901
  %1903 = add nsw i64 %1899, %1902
  store i64 %1903, ptr %29, align 8, !tbaa !9
  %1904 = load ptr, ptr %17, align 8, !tbaa !5
  %1905 = load i64, ptr %28, align 8, !tbaa !9
  %1906 = getelementptr inbounds %struct.complex, ptr %1904, i64 %1905
  %1907 = getelementptr inbounds %struct.complex, ptr %1906, i32 0, i32 0
  %1908 = load float, ptr %1907, align 4, !tbaa !11
  %1909 = load ptr, ptr %20, align 8, !tbaa !5
  %1910 = load i64, ptr %29, align 8, !tbaa !9
  %1911 = getelementptr inbounds %struct.complex, ptr %1909, i64 %1910
  %1912 = getelementptr inbounds %struct.complex, ptr %1911, i32 0, i32 0
  %1913 = load float, ptr %1912, align 4, !tbaa !11
  %1914 = load ptr, ptr %17, align 8, !tbaa !5
  %1915 = load i64, ptr %28, align 8, !tbaa !9
  %1916 = getelementptr inbounds %struct.complex, ptr %1914, i64 %1915
  %1917 = getelementptr inbounds %struct.complex, ptr %1916, i32 0, i32 1
  %1918 = load float, ptr %1917, align 4, !tbaa !14
  %1919 = load ptr, ptr %20, align 8, !tbaa !5
  %1920 = load i64, ptr %29, align 8, !tbaa !9
  %1921 = getelementptr inbounds %struct.complex, ptr %1919, i64 %1920
  %1922 = getelementptr inbounds %struct.complex, ptr %1921, i32 0, i32 1
  %1923 = load float, ptr %1922, align 4, !tbaa !14
  %1924 = fmul float %1918, %1923
  %1925 = fneg float %1924
  %1926 = call float @llvm.fmuladd.f32(float %1908, float %1913, float %1925)
  %1927 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %1926, ptr %1927, align 4, !tbaa !11
  %1928 = load ptr, ptr %17, align 8, !tbaa !5
  %1929 = load i64, ptr %28, align 8, !tbaa !9
  %1930 = getelementptr inbounds %struct.complex, ptr %1928, i64 %1929
  %1931 = getelementptr inbounds %struct.complex, ptr %1930, i32 0, i32 0
  %1932 = load float, ptr %1931, align 4, !tbaa !11
  %1933 = load ptr, ptr %20, align 8, !tbaa !5
  %1934 = load i64, ptr %29, align 8, !tbaa !9
  %1935 = getelementptr inbounds %struct.complex, ptr %1933, i64 %1934
  %1936 = getelementptr inbounds %struct.complex, ptr %1935, i32 0, i32 1
  %1937 = load float, ptr %1936, align 4, !tbaa !14
  %1938 = load ptr, ptr %17, align 8, !tbaa !5
  %1939 = load i64, ptr %28, align 8, !tbaa !9
  %1940 = getelementptr inbounds %struct.complex, ptr %1938, i64 %1939
  %1941 = getelementptr inbounds %struct.complex, ptr %1940, i32 0, i32 1
  %1942 = load float, ptr %1941, align 4, !tbaa !14
  %1943 = load ptr, ptr %20, align 8, !tbaa !5
  %1944 = load i64, ptr %29, align 8, !tbaa !9
  %1945 = getelementptr inbounds %struct.complex, ptr %1943, i64 %1944
  %1946 = getelementptr inbounds %struct.complex, ptr %1945, i32 0, i32 0
  %1947 = load float, ptr %1946, align 4, !tbaa !11
  %1948 = fmul float %1942, %1947
  %1949 = call float @llvm.fmuladd.f32(float %1932, float %1937, float %1948)
  %1950 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %1949, ptr %1950, align 4, !tbaa !14
  %1951 = load ptr, ptr %20, align 8, !tbaa !5
  %1952 = load i64, ptr %27, align 8, !tbaa !9
  %1953 = getelementptr inbounds %struct.complex, ptr %1951, i64 %1952
  %1954 = getelementptr inbounds %struct.complex, ptr %1953, i32 0, i32 0
  %1955 = load float, ptr %1954, align 4, !tbaa !11
  %1956 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %1957 = load float, ptr %1956, align 4, !tbaa !11
  %1958 = fsub float %1955, %1957
  %1959 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %1958, ptr %1959, align 4, !tbaa !11
  %1960 = load ptr, ptr %20, align 8, !tbaa !5
  %1961 = load i64, ptr %27, align 8, !tbaa !9
  %1962 = getelementptr inbounds %struct.complex, ptr %1960, i64 %1961
  %1963 = getelementptr inbounds %struct.complex, ptr %1962, i32 0, i32 1
  %1964 = load float, ptr %1963, align 4, !tbaa !14
  %1965 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %1966 = load float, ptr %1965, align 4, !tbaa !14
  %1967 = fsub float %1964, %1966
  %1968 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %1967, ptr %1968, align 4, !tbaa !14
  %1969 = load i64, ptr %40, align 8, !tbaa !9
  %1970 = sub nsw i64 %1969, 2
  store i64 %1970, ptr %30, align 8, !tbaa !9
  %1971 = load i64, ptr %40, align 8, !tbaa !9
  %1972 = sub nsw i64 %1971, 2
  %1973 = load i64, ptr %41, align 8, !tbaa !9
  %1974 = load i64, ptr %22, align 8, !tbaa !9
  %1975 = mul nsw i64 %1973, %1974
  %1976 = add nsw i64 %1972, %1975
  store i64 %1976, ptr %31, align 8, !tbaa !9
  %1977 = load ptr, ptr %18, align 8, !tbaa !5
  %1978 = load i64, ptr %30, align 8, !tbaa !9
  %1979 = getelementptr inbounds %struct.complex, ptr %1977, i64 %1978
  %1980 = getelementptr inbounds %struct.complex, ptr %1979, i32 0, i32 0
  %1981 = load float, ptr %1980, align 4, !tbaa !11
  %1982 = load ptr, ptr %20, align 8, !tbaa !5
  %1983 = load i64, ptr %31, align 8, !tbaa !9
  %1984 = getelementptr inbounds %struct.complex, ptr %1982, i64 %1983
  %1985 = getelementptr inbounds %struct.complex, ptr %1984, i32 0, i32 0
  %1986 = load float, ptr %1985, align 4, !tbaa !11
  %1987 = load ptr, ptr %18, align 8, !tbaa !5
  %1988 = load i64, ptr %30, align 8, !tbaa !9
  %1989 = getelementptr inbounds %struct.complex, ptr %1987, i64 %1988
  %1990 = getelementptr inbounds %struct.complex, ptr %1989, i32 0, i32 1
  %1991 = load float, ptr %1990, align 4, !tbaa !14
  %1992 = load ptr, ptr %20, align 8, !tbaa !5
  %1993 = load i64, ptr %31, align 8, !tbaa !9
  %1994 = getelementptr inbounds %struct.complex, ptr %1992, i64 %1993
  %1995 = getelementptr inbounds %struct.complex, ptr %1994, i32 0, i32 1
  %1996 = load float, ptr %1995, align 4, !tbaa !14
  %1997 = fmul float %1991, %1996
  %1998 = fneg float %1997
  %1999 = call float @llvm.fmuladd.f32(float %1981, float %1986, float %1998)
  %2000 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  store float %1999, ptr %2000, align 4, !tbaa !11
  %2001 = load ptr, ptr %18, align 8, !tbaa !5
  %2002 = load i64, ptr %30, align 8, !tbaa !9
  %2003 = getelementptr inbounds %struct.complex, ptr %2001, i64 %2002
  %2004 = getelementptr inbounds %struct.complex, ptr %2003, i32 0, i32 0
  %2005 = load float, ptr %2004, align 4, !tbaa !11
  %2006 = load ptr, ptr %20, align 8, !tbaa !5
  %2007 = load i64, ptr %31, align 8, !tbaa !9
  %2008 = getelementptr inbounds %struct.complex, ptr %2006, i64 %2007
  %2009 = getelementptr inbounds %struct.complex, ptr %2008, i32 0, i32 1
  %2010 = load float, ptr %2009, align 4, !tbaa !14
  %2011 = load ptr, ptr %18, align 8, !tbaa !5
  %2012 = load i64, ptr %30, align 8, !tbaa !9
  %2013 = getelementptr inbounds %struct.complex, ptr %2011, i64 %2012
  %2014 = getelementptr inbounds %struct.complex, ptr %2013, i32 0, i32 1
  %2015 = load float, ptr %2014, align 4, !tbaa !14
  %2016 = load ptr, ptr %20, align 8, !tbaa !5
  %2017 = load i64, ptr %31, align 8, !tbaa !9
  %2018 = getelementptr inbounds %struct.complex, ptr %2016, i64 %2017
  %2019 = getelementptr inbounds %struct.complex, ptr %2018, i32 0, i32 0
  %2020 = load float, ptr %2019, align 4, !tbaa !11
  %2021 = fmul float %2015, %2020
  %2022 = call float @llvm.fmuladd.f32(float %2005, float %2010, float %2021)
  %2023 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  store float %2022, ptr %2023, align 4, !tbaa !14
  %2024 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2025 = load float, ptr %2024, align 4, !tbaa !11
  %2026 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %2027 = load float, ptr %2026, align 4, !tbaa !11
  %2028 = fsub float %2025, %2027
  %2029 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2028, ptr %2029, align 4, !tbaa !11
  %2030 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2031 = load float, ptr %2030, align 4, !tbaa !14
  %2032 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %2033 = load float, ptr %2032, align 4, !tbaa !14
  %2034 = fsub float %2031, %2033
  %2035 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2034, ptr %2035, align 4, !tbaa !14
  %2036 = load ptr, ptr %16, align 8, !tbaa !5
  %2037 = load i64, ptr %40, align 8, !tbaa !9
  %2038 = getelementptr inbounds %struct.complex, ptr %2036, i64 %2037
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %2038)
  %2039 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2040 = load float, ptr %2039, align 4, !tbaa !11
  %2041 = load ptr, ptr %20, align 8, !tbaa !5
  %2042 = load i64, ptr %26, align 8, !tbaa !9
  %2043 = getelementptr inbounds %struct.complex, ptr %2041, i64 %2042
  %2044 = getelementptr inbounds %struct.complex, ptr %2043, i32 0, i32 0
  store float %2040, ptr %2044, align 4, !tbaa !11
  %2045 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2046 = load float, ptr %2045, align 4, !tbaa !14
  %2047 = load ptr, ptr %20, align 8, !tbaa !5
  %2048 = load i64, ptr %26, align 8, !tbaa !9
  %2049 = getelementptr inbounds %struct.complex, ptr %2047, i64 %2048
  %2050 = getelementptr inbounds %struct.complex, ptr %2049, i32 0, i32 1
  store float %2046, ptr %2050, align 4, !tbaa !14
  br label %2051

2051:                                             ; preds = %1885
  %2052 = load i64, ptr %40, align 8, !tbaa !9
  %2053 = add nsw i64 %2052, 1
  store i64 %2053, ptr %40, align 8, !tbaa !9
  br label %1881, !llvm.loop !23

2054:                                             ; preds = %1881
  %2055 = load ptr, ptr %13, align 8, !tbaa !5
  %2056 = load i64, ptr %2055, align 8, !tbaa !9
  %2057 = sub nsw i64 %2056, 1
  store i64 %2057, ptr %40, align 8, !tbaa !9
  br label %2058

2058:                                             ; preds = %2277, %2054
  %2059 = load i64, ptr %40, align 8, !tbaa !9
  %2060 = icmp sge i64 %2059, 1
  br i1 %2060, label %2061, label %2280

2061:                                             ; preds = %2058
  %2062 = load ptr, ptr %19, align 8, !tbaa !5
  %2063 = load i64, ptr %40, align 8, !tbaa !9
  %2064 = getelementptr inbounds i64, ptr %2062, i64 %2063
  %2065 = load i64, ptr %2064, align 8, !tbaa !9
  %2066 = load i64, ptr %40, align 8, !tbaa !9
  %2067 = icmp eq i64 %2065, %2066
  br i1 %2067, label %2068, label %2163

2068:                                             ; preds = %2061
  %2069 = load i64, ptr %40, align 8, !tbaa !9
  %2070 = load i64, ptr %41, align 8, !tbaa !9
  %2071 = load i64, ptr %22, align 8, !tbaa !9
  %2072 = mul nsw i64 %2070, %2071
  %2073 = add nsw i64 %2069, %2072
  store i64 %2073, ptr %25, align 8, !tbaa !9
  %2074 = load i64, ptr %40, align 8, !tbaa !9
  %2075 = load i64, ptr %41, align 8, !tbaa !9
  %2076 = load i64, ptr %22, align 8, !tbaa !9
  %2077 = mul nsw i64 %2075, %2076
  %2078 = add nsw i64 %2074, %2077
  store i64 %2078, ptr %26, align 8, !tbaa !9
  %2079 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %2079, ptr %27, align 8, !tbaa !9
  %2080 = load i64, ptr %40, align 8, !tbaa !9
  %2081 = add nsw i64 %2080, 1
  %2082 = load i64, ptr %41, align 8, !tbaa !9
  %2083 = load i64, ptr %22, align 8, !tbaa !9
  %2084 = mul nsw i64 %2082, %2083
  %2085 = add nsw i64 %2081, %2084
  store i64 %2085, ptr %28, align 8, !tbaa !9
  %2086 = load ptr, ptr %15, align 8, !tbaa !5
  %2087 = load i64, ptr %27, align 8, !tbaa !9
  %2088 = getelementptr inbounds %struct.complex, ptr %2086, i64 %2087
  %2089 = getelementptr inbounds %struct.complex, ptr %2088, i32 0, i32 0
  %2090 = load float, ptr %2089, align 4, !tbaa !11
  %2091 = load ptr, ptr %20, align 8, !tbaa !5
  %2092 = load i64, ptr %28, align 8, !tbaa !9
  %2093 = getelementptr inbounds %struct.complex, ptr %2091, i64 %2092
  %2094 = getelementptr inbounds %struct.complex, ptr %2093, i32 0, i32 0
  %2095 = load float, ptr %2094, align 4, !tbaa !11
  %2096 = load ptr, ptr %15, align 8, !tbaa !5
  %2097 = load i64, ptr %27, align 8, !tbaa !9
  %2098 = getelementptr inbounds %struct.complex, ptr %2096, i64 %2097
  %2099 = getelementptr inbounds %struct.complex, ptr %2098, i32 0, i32 1
  %2100 = load float, ptr %2099, align 4, !tbaa !14
  %2101 = load ptr, ptr %20, align 8, !tbaa !5
  %2102 = load i64, ptr %28, align 8, !tbaa !9
  %2103 = getelementptr inbounds %struct.complex, ptr %2101, i64 %2102
  %2104 = getelementptr inbounds %struct.complex, ptr %2103, i32 0, i32 1
  %2105 = load float, ptr %2104, align 4, !tbaa !14
  %2106 = fmul float %2100, %2105
  %2107 = fneg float %2106
  %2108 = call float @llvm.fmuladd.f32(float %2090, float %2095, float %2107)
  %2109 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2108, ptr %2109, align 4, !tbaa !11
  %2110 = load ptr, ptr %15, align 8, !tbaa !5
  %2111 = load i64, ptr %27, align 8, !tbaa !9
  %2112 = getelementptr inbounds %struct.complex, ptr %2110, i64 %2111
  %2113 = getelementptr inbounds %struct.complex, ptr %2112, i32 0, i32 0
  %2114 = load float, ptr %2113, align 4, !tbaa !11
  %2115 = load ptr, ptr %20, align 8, !tbaa !5
  %2116 = load i64, ptr %28, align 8, !tbaa !9
  %2117 = getelementptr inbounds %struct.complex, ptr %2115, i64 %2116
  %2118 = getelementptr inbounds %struct.complex, ptr %2117, i32 0, i32 1
  %2119 = load float, ptr %2118, align 4, !tbaa !14
  %2120 = load ptr, ptr %15, align 8, !tbaa !5
  %2121 = load i64, ptr %27, align 8, !tbaa !9
  %2122 = getelementptr inbounds %struct.complex, ptr %2120, i64 %2121
  %2123 = getelementptr inbounds %struct.complex, ptr %2122, i32 0, i32 1
  %2124 = load float, ptr %2123, align 4, !tbaa !14
  %2125 = load ptr, ptr %20, align 8, !tbaa !5
  %2126 = load i64, ptr %28, align 8, !tbaa !9
  %2127 = getelementptr inbounds %struct.complex, ptr %2125, i64 %2126
  %2128 = getelementptr inbounds %struct.complex, ptr %2127, i32 0, i32 0
  %2129 = load float, ptr %2128, align 4, !tbaa !11
  %2130 = fmul float %2124, %2129
  %2131 = call float @llvm.fmuladd.f32(float %2114, float %2119, float %2130)
  %2132 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2131, ptr %2132, align 4, !tbaa !14
  %2133 = load ptr, ptr %20, align 8, !tbaa !5
  %2134 = load i64, ptr %26, align 8, !tbaa !9
  %2135 = getelementptr inbounds %struct.complex, ptr %2133, i64 %2134
  %2136 = getelementptr inbounds %struct.complex, ptr %2135, i32 0, i32 0
  %2137 = load float, ptr %2136, align 4, !tbaa !11
  %2138 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %2139 = load float, ptr %2138, align 4, !tbaa !11
  %2140 = fsub float %2137, %2139
  %2141 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %2140, ptr %2141, align 4, !tbaa !11
  %2142 = load ptr, ptr %20, align 8, !tbaa !5
  %2143 = load i64, ptr %26, align 8, !tbaa !9
  %2144 = getelementptr inbounds %struct.complex, ptr %2142, i64 %2143
  %2145 = getelementptr inbounds %struct.complex, ptr %2144, i32 0, i32 1
  %2146 = load float, ptr %2145, align 4, !tbaa !14
  %2147 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %2148 = load float, ptr %2147, align 4, !tbaa !14
  %2149 = fsub float %2146, %2148
  %2150 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %2149, ptr %2150, align 4, !tbaa !14
  %2151 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2152 = load float, ptr %2151, align 4, !tbaa !11
  %2153 = load ptr, ptr %20, align 8, !tbaa !5
  %2154 = load i64, ptr %25, align 8, !tbaa !9
  %2155 = getelementptr inbounds %struct.complex, ptr %2153, i64 %2154
  %2156 = getelementptr inbounds %struct.complex, ptr %2155, i32 0, i32 0
  store float %2152, ptr %2156, align 4, !tbaa !11
  %2157 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2158 = load float, ptr %2157, align 4, !tbaa !14
  %2159 = load ptr, ptr %20, align 8, !tbaa !5
  %2160 = load i64, ptr %25, align 8, !tbaa !9
  %2161 = getelementptr inbounds %struct.complex, ptr %2159, i64 %2160
  %2162 = getelementptr inbounds %struct.complex, ptr %2161, i32 0, i32 1
  store float %2158, ptr %2162, align 4, !tbaa !14
  br label %2276

2163:                                             ; preds = %2061
  %2164 = load i64, ptr %40, align 8, !tbaa !9
  %2165 = add nsw i64 %2164, 1
  %2166 = load i64, ptr %41, align 8, !tbaa !9
  %2167 = load i64, ptr %22, align 8, !tbaa !9
  %2168 = mul nsw i64 %2166, %2167
  %2169 = add nsw i64 %2165, %2168
  store i64 %2169, ptr %25, align 8, !tbaa !9
  %2170 = load ptr, ptr %20, align 8, !tbaa !5
  %2171 = load i64, ptr %25, align 8, !tbaa !9
  %2172 = getelementptr inbounds %struct.complex, ptr %2170, i64 %2171
  %2173 = getelementptr inbounds %struct.complex, ptr %2172, i32 0, i32 0
  %2174 = load float, ptr %2173, align 4, !tbaa !11
  %2175 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %2174, ptr %2175, align 4, !tbaa !11
  %2176 = load ptr, ptr %20, align 8, !tbaa !5
  %2177 = load i64, ptr %25, align 8, !tbaa !9
  %2178 = getelementptr inbounds %struct.complex, ptr %2176, i64 %2177
  %2179 = getelementptr inbounds %struct.complex, ptr %2178, i32 0, i32 1
  %2180 = load float, ptr %2179, align 4, !tbaa !14
  %2181 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %2180, ptr %2181, align 4, !tbaa !14
  %2182 = load i64, ptr %40, align 8, !tbaa !9
  %2183 = add nsw i64 %2182, 1
  %2184 = load i64, ptr %41, align 8, !tbaa !9
  %2185 = load i64, ptr %22, align 8, !tbaa !9
  %2186 = mul nsw i64 %2184, %2185
  %2187 = add nsw i64 %2183, %2186
  store i64 %2187, ptr %25, align 8, !tbaa !9
  %2188 = load i64, ptr %40, align 8, !tbaa !9
  %2189 = load i64, ptr %41, align 8, !tbaa !9
  %2190 = load i64, ptr %22, align 8, !tbaa !9
  %2191 = mul nsw i64 %2189, %2190
  %2192 = add nsw i64 %2188, %2191
  store i64 %2192, ptr %26, align 8, !tbaa !9
  %2193 = load i64, ptr %40, align 8, !tbaa !9
  store i64 %2193, ptr %27, align 8, !tbaa !9
  %2194 = load ptr, ptr %15, align 8, !tbaa !5
  %2195 = load i64, ptr %27, align 8, !tbaa !9
  %2196 = getelementptr inbounds %struct.complex, ptr %2194, i64 %2195
  %2197 = getelementptr inbounds %struct.complex, ptr %2196, i32 0, i32 0
  %2198 = load float, ptr %2197, align 4, !tbaa !11
  %2199 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2200 = load float, ptr %2199, align 4, !tbaa !11
  %2201 = load ptr, ptr %15, align 8, !tbaa !5
  %2202 = load i64, ptr %27, align 8, !tbaa !9
  %2203 = getelementptr inbounds %struct.complex, ptr %2201, i64 %2202
  %2204 = getelementptr inbounds %struct.complex, ptr %2203, i32 0, i32 1
  %2205 = load float, ptr %2204, align 4, !tbaa !14
  %2206 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2207 = load float, ptr %2206, align 4, !tbaa !14
  %2208 = fmul float %2205, %2207
  %2209 = fneg float %2208
  %2210 = call float @llvm.fmuladd.f32(float %2198, float %2200, float %2209)
  %2211 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2210, ptr %2211, align 4, !tbaa !11
  %2212 = load ptr, ptr %15, align 8, !tbaa !5
  %2213 = load i64, ptr %27, align 8, !tbaa !9
  %2214 = getelementptr inbounds %struct.complex, ptr %2212, i64 %2213
  %2215 = getelementptr inbounds %struct.complex, ptr %2214, i32 0, i32 0
  %2216 = load float, ptr %2215, align 4, !tbaa !11
  %2217 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2218 = load float, ptr %2217, align 4, !tbaa !14
  %2219 = load ptr, ptr %15, align 8, !tbaa !5
  %2220 = load i64, ptr %27, align 8, !tbaa !9
  %2221 = getelementptr inbounds %struct.complex, ptr %2219, i64 %2220
  %2222 = getelementptr inbounds %struct.complex, ptr %2221, i32 0, i32 1
  %2223 = load float, ptr %2222, align 4, !tbaa !14
  %2224 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2225 = load float, ptr %2224, align 4, !tbaa !11
  %2226 = fmul float %2223, %2225
  %2227 = call float @llvm.fmuladd.f32(float %2216, float %2218, float %2226)
  %2228 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2227, ptr %2228, align 4, !tbaa !14
  %2229 = load ptr, ptr %20, align 8, !tbaa !5
  %2230 = load i64, ptr %26, align 8, !tbaa !9
  %2231 = getelementptr inbounds %struct.complex, ptr %2229, i64 %2230
  %2232 = getelementptr inbounds %struct.complex, ptr %2231, i32 0, i32 0
  %2233 = load float, ptr %2232, align 4, !tbaa !11
  %2234 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %2235 = load float, ptr %2234, align 4, !tbaa !11
  %2236 = fsub float %2233, %2235
  %2237 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %2236, ptr %2237, align 4, !tbaa !11
  %2238 = load ptr, ptr %20, align 8, !tbaa !5
  %2239 = load i64, ptr %26, align 8, !tbaa !9
  %2240 = getelementptr inbounds %struct.complex, ptr %2238, i64 %2239
  %2241 = getelementptr inbounds %struct.complex, ptr %2240, i32 0, i32 1
  %2242 = load float, ptr %2241, align 4, !tbaa !14
  %2243 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %2244 = load float, ptr %2243, align 4, !tbaa !14
  %2245 = fsub float %2242, %2244
  %2246 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %2245, ptr %2246, align 4, !tbaa !14
  %2247 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2248 = load float, ptr %2247, align 4, !tbaa !11
  %2249 = load ptr, ptr %20, align 8, !tbaa !5
  %2250 = load i64, ptr %25, align 8, !tbaa !9
  %2251 = getelementptr inbounds %struct.complex, ptr %2249, i64 %2250
  %2252 = getelementptr inbounds %struct.complex, ptr %2251, i32 0, i32 0
  store float %2248, ptr %2252, align 4, !tbaa !11
  %2253 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2254 = load float, ptr %2253, align 4, !tbaa !14
  %2255 = load ptr, ptr %20, align 8, !tbaa !5
  %2256 = load i64, ptr %25, align 8, !tbaa !9
  %2257 = getelementptr inbounds %struct.complex, ptr %2255, i64 %2256
  %2258 = getelementptr inbounds %struct.complex, ptr %2257, i32 0, i32 1
  store float %2254, ptr %2258, align 4, !tbaa !14
  %2259 = load i64, ptr %40, align 8, !tbaa !9
  %2260 = load i64, ptr %41, align 8, !tbaa !9
  %2261 = load i64, ptr %22, align 8, !tbaa !9
  %2262 = mul nsw i64 %2260, %2261
  %2263 = add nsw i64 %2259, %2262
  store i64 %2263, ptr %25, align 8, !tbaa !9
  %2264 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2265 = load float, ptr %2264, align 4, !tbaa !11
  %2266 = load ptr, ptr %20, align 8, !tbaa !5
  %2267 = load i64, ptr %25, align 8, !tbaa !9
  %2268 = getelementptr inbounds %struct.complex, ptr %2266, i64 %2267
  %2269 = getelementptr inbounds %struct.complex, ptr %2268, i32 0, i32 0
  store float %2265, ptr %2269, align 4, !tbaa !11
  %2270 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2271 = load float, ptr %2270, align 4, !tbaa !14
  %2272 = load ptr, ptr %20, align 8, !tbaa !5
  %2273 = load i64, ptr %25, align 8, !tbaa !9
  %2274 = getelementptr inbounds %struct.complex, ptr %2272, i64 %2273
  %2275 = getelementptr inbounds %struct.complex, ptr %2274, i32 0, i32 1
  store float %2271, ptr %2275, align 4, !tbaa !14
  br label %2276

2276:                                             ; preds = %2163, %2068
  br label %2277

2277:                                             ; preds = %2276
  %2278 = load i64, ptr %40, align 8, !tbaa !9
  %2279 = add nsw i64 %2278, -1
  store i64 %2279, ptr %40, align 8, !tbaa !9
  br label %2058, !llvm.loop !24

2280:                                             ; preds = %2058
  br label %2281

2281:                                             ; preds = %2280
  %2282 = load i64, ptr %41, align 8, !tbaa !9
  %2283 = add nsw i64 %2282, 1
  store i64 %2283, ptr %41, align 8, !tbaa !9
  br label %1758, !llvm.loop !25

2284:                                             ; preds = %1758
  br label %2285

2285:                                             ; preds = %2284, %1754
  br label %3257

2286:                                             ; preds = %1219
  %2287 = load ptr, ptr %14, align 8, !tbaa !5
  %2288 = load i64, ptr %2287, align 8, !tbaa !9
  %2289 = icmp sle i64 %2288, 1
  br i1 %2289, label %2290, label %2772

2290:                                             ; preds = %2286
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %2291

2291:                                             ; preds = %2768, %2290
  %2292 = load i64, ptr %41, align 8, !tbaa !9
  %2293 = load i64, ptr %22, align 8, !tbaa !9
  %2294 = mul nsw i64 %2292, %2293
  %2295 = add nsw i64 %2294, 1
  store i64 %2295, ptr %24, align 8, !tbaa !9
  %2296 = load ptr, ptr %16, align 8, !tbaa !5
  %2297 = getelementptr inbounds %struct.complex, ptr %2296, i64 1
  call void @r_cnjg(ptr noundef %33, ptr noundef %2297)
  %2298 = load ptr, ptr %20, align 8, !tbaa !5
  %2299 = load i64, ptr %41, align 8, !tbaa !9
  %2300 = load i64, ptr %22, align 8, !tbaa !9
  %2301 = mul nsw i64 %2299, %2300
  %2302 = add nsw i64 %2301, 1
  %2303 = getelementptr inbounds %struct.complex, ptr %2298, i64 %2302
  call void @c_div(ptr noundef %32, ptr noundef %2303, ptr noundef %33)
  %2304 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2305 = load float, ptr %2304, align 4, !tbaa !11
  %2306 = load ptr, ptr %20, align 8, !tbaa !5
  %2307 = load i64, ptr %24, align 8, !tbaa !9
  %2308 = getelementptr inbounds %struct.complex, ptr %2306, i64 %2307
  %2309 = getelementptr inbounds %struct.complex, ptr %2308, i32 0, i32 0
  store float %2305, ptr %2309, align 4, !tbaa !11
  %2310 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2311 = load float, ptr %2310, align 4, !tbaa !14
  %2312 = load ptr, ptr %20, align 8, !tbaa !5
  %2313 = load i64, ptr %24, align 8, !tbaa !9
  %2314 = getelementptr inbounds %struct.complex, ptr %2312, i64 %2313
  %2315 = getelementptr inbounds %struct.complex, ptr %2314, i32 0, i32 1
  store float %2311, ptr %2315, align 4, !tbaa !14
  %2316 = load ptr, ptr %13, align 8, !tbaa !5
  %2317 = load i64, ptr %2316, align 8, !tbaa !9
  %2318 = icmp sgt i64 %2317, 1
  br i1 %2318, label %2319, label %2401

2319:                                             ; preds = %2291
  %2320 = load i64, ptr %41, align 8, !tbaa !9
  %2321 = load i64, ptr %22, align 8, !tbaa !9
  %2322 = mul nsw i64 %2320, %2321
  %2323 = add nsw i64 %2322, 2
  store i64 %2323, ptr %24, align 8, !tbaa !9
  %2324 = load i64, ptr %41, align 8, !tbaa !9
  %2325 = load i64, ptr %22, align 8, !tbaa !9
  %2326 = mul nsw i64 %2324, %2325
  %2327 = add nsw i64 %2326, 2
  store i64 %2327, ptr %25, align 8, !tbaa !9
  %2328 = load ptr, ptr %17, align 8, !tbaa !5
  %2329 = getelementptr inbounds %struct.complex, ptr %2328, i64 1
  call void @r_cnjg(ptr noundef %35, ptr noundef %2329)
  %2330 = load i64, ptr %41, align 8, !tbaa !9
  %2331 = load i64, ptr %22, align 8, !tbaa !9
  %2332 = mul nsw i64 %2330, %2331
  %2333 = add nsw i64 %2332, 1
  store i64 %2333, ptr %26, align 8, !tbaa !9
  %2334 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2335 = load float, ptr %2334, align 4, !tbaa !11
  %2336 = load ptr, ptr %20, align 8, !tbaa !5
  %2337 = load i64, ptr %26, align 8, !tbaa !9
  %2338 = getelementptr inbounds %struct.complex, ptr %2336, i64 %2337
  %2339 = getelementptr inbounds %struct.complex, ptr %2338, i32 0, i32 0
  %2340 = load float, ptr %2339, align 4, !tbaa !11
  %2341 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2342 = load float, ptr %2341, align 4, !tbaa !14
  %2343 = load ptr, ptr %20, align 8, !tbaa !5
  %2344 = load i64, ptr %26, align 8, !tbaa !9
  %2345 = getelementptr inbounds %struct.complex, ptr %2343, i64 %2344
  %2346 = getelementptr inbounds %struct.complex, ptr %2345, i32 0, i32 1
  %2347 = load float, ptr %2346, align 4, !tbaa !14
  %2348 = fmul float %2342, %2347
  %2349 = fneg float %2348
  %2350 = call float @llvm.fmuladd.f32(float %2335, float %2340, float %2349)
  %2351 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %2350, ptr %2351, align 4, !tbaa !11
  %2352 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2353 = load float, ptr %2352, align 4, !tbaa !11
  %2354 = load ptr, ptr %20, align 8, !tbaa !5
  %2355 = load i64, ptr %26, align 8, !tbaa !9
  %2356 = getelementptr inbounds %struct.complex, ptr %2354, i64 %2355
  %2357 = getelementptr inbounds %struct.complex, ptr %2356, i32 0, i32 1
  %2358 = load float, ptr %2357, align 4, !tbaa !14
  %2359 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2360 = load float, ptr %2359, align 4, !tbaa !14
  %2361 = load ptr, ptr %20, align 8, !tbaa !5
  %2362 = load i64, ptr %26, align 8, !tbaa !9
  %2363 = getelementptr inbounds %struct.complex, ptr %2361, i64 %2362
  %2364 = getelementptr inbounds %struct.complex, ptr %2363, i32 0, i32 0
  %2365 = load float, ptr %2364, align 4, !tbaa !11
  %2366 = fmul float %2360, %2365
  %2367 = call float @llvm.fmuladd.f32(float %2353, float %2358, float %2366)
  %2368 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %2367, ptr %2368, align 4, !tbaa !14
  %2369 = load ptr, ptr %20, align 8, !tbaa !5
  %2370 = load i64, ptr %25, align 8, !tbaa !9
  %2371 = getelementptr inbounds %struct.complex, ptr %2369, i64 %2370
  %2372 = getelementptr inbounds %struct.complex, ptr %2371, i32 0, i32 0
  %2373 = load float, ptr %2372, align 4, !tbaa !11
  %2374 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2375 = load float, ptr %2374, align 4, !tbaa !11
  %2376 = fsub float %2373, %2375
  %2377 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2376, ptr %2377, align 4, !tbaa !11
  %2378 = load ptr, ptr %20, align 8, !tbaa !5
  %2379 = load i64, ptr %25, align 8, !tbaa !9
  %2380 = getelementptr inbounds %struct.complex, ptr %2378, i64 %2379
  %2381 = getelementptr inbounds %struct.complex, ptr %2380, i32 0, i32 1
  %2382 = load float, ptr %2381, align 4, !tbaa !14
  %2383 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2384 = load float, ptr %2383, align 4, !tbaa !14
  %2385 = fsub float %2382, %2384
  %2386 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2385, ptr %2386, align 4, !tbaa !14
  %2387 = load ptr, ptr %16, align 8, !tbaa !5
  %2388 = getelementptr inbounds %struct.complex, ptr %2387, i64 2
  call void @r_cnjg(ptr noundef %36, ptr noundef %2388)
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %36)
  %2389 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2390 = load float, ptr %2389, align 4, !tbaa !11
  %2391 = load ptr, ptr %20, align 8, !tbaa !5
  %2392 = load i64, ptr %24, align 8, !tbaa !9
  %2393 = getelementptr inbounds %struct.complex, ptr %2391, i64 %2392
  %2394 = getelementptr inbounds %struct.complex, ptr %2393, i32 0, i32 0
  store float %2390, ptr %2394, align 4, !tbaa !11
  %2395 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2396 = load float, ptr %2395, align 4, !tbaa !14
  %2397 = load ptr, ptr %20, align 8, !tbaa !5
  %2398 = load i64, ptr %24, align 8, !tbaa !9
  %2399 = getelementptr inbounds %struct.complex, ptr %2397, i64 %2398
  %2400 = getelementptr inbounds %struct.complex, ptr %2399, i32 0, i32 1
  store float %2396, ptr %2400, align 4, !tbaa !14
  br label %2401

2401:                                             ; preds = %2319, %2291
  %2402 = load ptr, ptr %13, align 8, !tbaa !5
  %2403 = load i64, ptr %2402, align 8, !tbaa !9
  store i64 %2403, ptr %24, align 8, !tbaa !9
  store i64 3, ptr %40, align 8, !tbaa !9
  br label %2404

2404:                                             ; preds = %2554, %2401
  %2405 = load i64, ptr %40, align 8, !tbaa !9
  %2406 = load i64, ptr %24, align 8, !tbaa !9
  %2407 = icmp sle i64 %2405, %2406
  br i1 %2407, label %2408, label %2557

2408:                                             ; preds = %2404
  %2409 = load i64, ptr %40, align 8, !tbaa !9
  %2410 = load i64, ptr %41, align 8, !tbaa !9
  %2411 = load i64, ptr %22, align 8, !tbaa !9
  %2412 = mul nsw i64 %2410, %2411
  %2413 = add nsw i64 %2409, %2412
  store i64 %2413, ptr %25, align 8, !tbaa !9
  %2414 = load i64, ptr %40, align 8, !tbaa !9
  %2415 = load i64, ptr %41, align 8, !tbaa !9
  %2416 = load i64, ptr %22, align 8, !tbaa !9
  %2417 = mul nsw i64 %2415, %2416
  %2418 = add nsw i64 %2414, %2417
  store i64 %2418, ptr %26, align 8, !tbaa !9
  %2419 = load ptr, ptr %17, align 8, !tbaa !5
  %2420 = load i64, ptr %40, align 8, !tbaa !9
  %2421 = sub nsw i64 %2420, 1
  %2422 = getelementptr inbounds %struct.complex, ptr %2419, i64 %2421
  call void @r_cnjg(ptr noundef %36, ptr noundef %2422)
  %2423 = load i64, ptr %40, align 8, !tbaa !9
  %2424 = sub nsw i64 %2423, 1
  %2425 = load i64, ptr %41, align 8, !tbaa !9
  %2426 = load i64, ptr %22, align 8, !tbaa !9
  %2427 = mul nsw i64 %2425, %2426
  %2428 = add nsw i64 %2424, %2427
  store i64 %2428, ptr %27, align 8, !tbaa !9
  %2429 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %2430 = load float, ptr %2429, align 4, !tbaa !11
  %2431 = load ptr, ptr %20, align 8, !tbaa !5
  %2432 = load i64, ptr %27, align 8, !tbaa !9
  %2433 = getelementptr inbounds %struct.complex, ptr %2431, i64 %2432
  %2434 = getelementptr inbounds %struct.complex, ptr %2433, i32 0, i32 0
  %2435 = load float, ptr %2434, align 4, !tbaa !11
  %2436 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %2437 = load float, ptr %2436, align 4, !tbaa !14
  %2438 = load ptr, ptr %20, align 8, !tbaa !5
  %2439 = load i64, ptr %27, align 8, !tbaa !9
  %2440 = getelementptr inbounds %struct.complex, ptr %2438, i64 %2439
  %2441 = getelementptr inbounds %struct.complex, ptr %2440, i32 0, i32 1
  %2442 = load float, ptr %2441, align 4, !tbaa !14
  %2443 = fmul float %2437, %2442
  %2444 = fneg float %2443
  %2445 = call float @llvm.fmuladd.f32(float %2430, float %2435, float %2444)
  %2446 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %2445, ptr %2446, align 4, !tbaa !11
  %2447 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %2448 = load float, ptr %2447, align 4, !tbaa !11
  %2449 = load ptr, ptr %20, align 8, !tbaa !5
  %2450 = load i64, ptr %27, align 8, !tbaa !9
  %2451 = getelementptr inbounds %struct.complex, ptr %2449, i64 %2450
  %2452 = getelementptr inbounds %struct.complex, ptr %2451, i32 0, i32 1
  %2453 = load float, ptr %2452, align 4, !tbaa !14
  %2454 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %2455 = load float, ptr %2454, align 4, !tbaa !14
  %2456 = load ptr, ptr %20, align 8, !tbaa !5
  %2457 = load i64, ptr %27, align 8, !tbaa !9
  %2458 = getelementptr inbounds %struct.complex, ptr %2456, i64 %2457
  %2459 = getelementptr inbounds %struct.complex, ptr %2458, i32 0, i32 0
  %2460 = load float, ptr %2459, align 4, !tbaa !11
  %2461 = fmul float %2455, %2460
  %2462 = call float @llvm.fmuladd.f32(float %2448, float %2453, float %2461)
  %2463 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %2462, ptr %2463, align 4, !tbaa !14
  %2464 = load ptr, ptr %20, align 8, !tbaa !5
  %2465 = load i64, ptr %26, align 8, !tbaa !9
  %2466 = getelementptr inbounds %struct.complex, ptr %2464, i64 %2465
  %2467 = getelementptr inbounds %struct.complex, ptr %2466, i32 0, i32 0
  %2468 = load float, ptr %2467, align 4, !tbaa !11
  %2469 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2470 = load float, ptr %2469, align 4, !tbaa !11
  %2471 = fsub float %2468, %2470
  %2472 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %2471, ptr %2472, align 4, !tbaa !11
  %2473 = load ptr, ptr %20, align 8, !tbaa !5
  %2474 = load i64, ptr %26, align 8, !tbaa !9
  %2475 = getelementptr inbounds %struct.complex, ptr %2473, i64 %2474
  %2476 = getelementptr inbounds %struct.complex, ptr %2475, i32 0, i32 1
  %2477 = load float, ptr %2476, align 4, !tbaa !14
  %2478 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2479 = load float, ptr %2478, align 4, !tbaa !14
  %2480 = fsub float %2477, %2479
  %2481 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %2480, ptr %2481, align 4, !tbaa !14
  %2482 = load ptr, ptr %18, align 8, !tbaa !5
  %2483 = load i64, ptr %40, align 8, !tbaa !9
  %2484 = sub nsw i64 %2483, 2
  %2485 = getelementptr inbounds %struct.complex, ptr %2482, i64 %2484
  call void @r_cnjg(ptr noundef %38, ptr noundef %2485)
  %2486 = load i64, ptr %40, align 8, !tbaa !9
  %2487 = sub nsw i64 %2486, 2
  %2488 = load i64, ptr %41, align 8, !tbaa !9
  %2489 = load i64, ptr %22, align 8, !tbaa !9
  %2490 = mul nsw i64 %2488, %2489
  %2491 = add nsw i64 %2487, %2490
  store i64 %2491, ptr %28, align 8, !tbaa !9
  %2492 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %2493 = load float, ptr %2492, align 4, !tbaa !11
  %2494 = load ptr, ptr %20, align 8, !tbaa !5
  %2495 = load i64, ptr %28, align 8, !tbaa !9
  %2496 = getelementptr inbounds %struct.complex, ptr %2494, i64 %2495
  %2497 = getelementptr inbounds %struct.complex, ptr %2496, i32 0, i32 0
  %2498 = load float, ptr %2497, align 4, !tbaa !11
  %2499 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %2500 = load float, ptr %2499, align 4, !tbaa !14
  %2501 = load ptr, ptr %20, align 8, !tbaa !5
  %2502 = load i64, ptr %28, align 8, !tbaa !9
  %2503 = getelementptr inbounds %struct.complex, ptr %2501, i64 %2502
  %2504 = getelementptr inbounds %struct.complex, ptr %2503, i32 0, i32 1
  %2505 = load float, ptr %2504, align 4, !tbaa !14
  %2506 = fmul float %2500, %2505
  %2507 = fneg float %2506
  %2508 = call float @llvm.fmuladd.f32(float %2493, float %2498, float %2507)
  %2509 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  store float %2508, ptr %2509, align 4, !tbaa !11
  %2510 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %2511 = load float, ptr %2510, align 4, !tbaa !11
  %2512 = load ptr, ptr %20, align 8, !tbaa !5
  %2513 = load i64, ptr %28, align 8, !tbaa !9
  %2514 = getelementptr inbounds %struct.complex, ptr %2512, i64 %2513
  %2515 = getelementptr inbounds %struct.complex, ptr %2514, i32 0, i32 1
  %2516 = load float, ptr %2515, align 4, !tbaa !14
  %2517 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %2518 = load float, ptr %2517, align 4, !tbaa !14
  %2519 = load ptr, ptr %20, align 8, !tbaa !5
  %2520 = load i64, ptr %28, align 8, !tbaa !9
  %2521 = getelementptr inbounds %struct.complex, ptr %2519, i64 %2520
  %2522 = getelementptr inbounds %struct.complex, ptr %2521, i32 0, i32 0
  %2523 = load float, ptr %2522, align 4, !tbaa !11
  %2524 = fmul float %2518, %2523
  %2525 = call float @llvm.fmuladd.f32(float %2511, float %2516, float %2524)
  %2526 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  store float %2525, ptr %2526, align 4, !tbaa !14
  %2527 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2528 = load float, ptr %2527, align 4, !tbaa !11
  %2529 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %2530 = load float, ptr %2529, align 4, !tbaa !11
  %2531 = fsub float %2528, %2530
  %2532 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2531, ptr %2532, align 4, !tbaa !11
  %2533 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2534 = load float, ptr %2533, align 4, !tbaa !14
  %2535 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %2536 = load float, ptr %2535, align 4, !tbaa !14
  %2537 = fsub float %2534, %2536
  %2538 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2537, ptr %2538, align 4, !tbaa !14
  %2539 = load ptr, ptr %16, align 8, !tbaa !5
  %2540 = load i64, ptr %40, align 8, !tbaa !9
  %2541 = getelementptr inbounds %struct.complex, ptr %2539, i64 %2540
  call void @r_cnjg(ptr noundef %39, ptr noundef %2541)
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %39)
  %2542 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2543 = load float, ptr %2542, align 4, !tbaa !11
  %2544 = load ptr, ptr %20, align 8, !tbaa !5
  %2545 = load i64, ptr %25, align 8, !tbaa !9
  %2546 = getelementptr inbounds %struct.complex, ptr %2544, i64 %2545
  %2547 = getelementptr inbounds %struct.complex, ptr %2546, i32 0, i32 0
  store float %2543, ptr %2547, align 4, !tbaa !11
  %2548 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2549 = load float, ptr %2548, align 4, !tbaa !14
  %2550 = load ptr, ptr %20, align 8, !tbaa !5
  %2551 = load i64, ptr %25, align 8, !tbaa !9
  %2552 = getelementptr inbounds %struct.complex, ptr %2550, i64 %2551
  %2553 = getelementptr inbounds %struct.complex, ptr %2552, i32 0, i32 1
  store float %2549, ptr %2553, align 4, !tbaa !14
  br label %2554

2554:                                             ; preds = %2408
  %2555 = load i64, ptr %40, align 8, !tbaa !9
  %2556 = add nsw i64 %2555, 1
  store i64 %2556, ptr %40, align 8, !tbaa !9
  br label %2404, !llvm.loop !26

2557:                                             ; preds = %2404
  %2558 = load ptr, ptr %13, align 8, !tbaa !5
  %2559 = load i64, ptr %2558, align 8, !tbaa !9
  %2560 = sub nsw i64 %2559, 1
  store i64 %2560, ptr %40, align 8, !tbaa !9
  br label %2561

2561:                                             ; preds = %2760, %2557
  %2562 = load i64, ptr %40, align 8, !tbaa !9
  %2563 = icmp sge i64 %2562, 1
  br i1 %2563, label %2564, label %2763

2564:                                             ; preds = %2561
  %2565 = load ptr, ptr %19, align 8, !tbaa !5
  %2566 = load i64, ptr %40, align 8, !tbaa !9
  %2567 = getelementptr inbounds i64, ptr %2565, i64 %2566
  %2568 = load i64, ptr %2567, align 8, !tbaa !9
  %2569 = load i64, ptr %40, align 8, !tbaa !9
  %2570 = icmp eq i64 %2568, %2569
  br i1 %2570, label %2571, label %2656

2571:                                             ; preds = %2564
  %2572 = load i64, ptr %40, align 8, !tbaa !9
  %2573 = load i64, ptr %41, align 8, !tbaa !9
  %2574 = load i64, ptr %22, align 8, !tbaa !9
  %2575 = mul nsw i64 %2573, %2574
  %2576 = add nsw i64 %2572, %2575
  store i64 %2576, ptr %24, align 8, !tbaa !9
  %2577 = load i64, ptr %40, align 8, !tbaa !9
  %2578 = load i64, ptr %41, align 8, !tbaa !9
  %2579 = load i64, ptr %22, align 8, !tbaa !9
  %2580 = mul nsw i64 %2578, %2579
  %2581 = add nsw i64 %2577, %2580
  store i64 %2581, ptr %25, align 8, !tbaa !9
  %2582 = load ptr, ptr %15, align 8, !tbaa !5
  %2583 = load i64, ptr %40, align 8, !tbaa !9
  %2584 = getelementptr inbounds %struct.complex, ptr %2582, i64 %2583
  call void @r_cnjg(ptr noundef %34, ptr noundef %2584)
  %2585 = load i64, ptr %40, align 8, !tbaa !9
  %2586 = add nsw i64 %2585, 1
  %2587 = load i64, ptr %41, align 8, !tbaa !9
  %2588 = load i64, ptr %22, align 8, !tbaa !9
  %2589 = mul nsw i64 %2587, %2588
  %2590 = add nsw i64 %2586, %2589
  store i64 %2590, ptr %26, align 8, !tbaa !9
  %2591 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2592 = load float, ptr %2591, align 4, !tbaa !11
  %2593 = load ptr, ptr %20, align 8, !tbaa !5
  %2594 = load i64, ptr %26, align 8, !tbaa !9
  %2595 = getelementptr inbounds %struct.complex, ptr %2593, i64 %2594
  %2596 = getelementptr inbounds %struct.complex, ptr %2595, i32 0, i32 0
  %2597 = load float, ptr %2596, align 4, !tbaa !11
  %2598 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2599 = load float, ptr %2598, align 4, !tbaa !14
  %2600 = load ptr, ptr %20, align 8, !tbaa !5
  %2601 = load i64, ptr %26, align 8, !tbaa !9
  %2602 = getelementptr inbounds %struct.complex, ptr %2600, i64 %2601
  %2603 = getelementptr inbounds %struct.complex, ptr %2602, i32 0, i32 1
  %2604 = load float, ptr %2603, align 4, !tbaa !14
  %2605 = fmul float %2599, %2604
  %2606 = fneg float %2605
  %2607 = call float @llvm.fmuladd.f32(float %2592, float %2597, float %2606)
  %2608 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2607, ptr %2608, align 4, !tbaa !11
  %2609 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2610 = load float, ptr %2609, align 4, !tbaa !11
  %2611 = load ptr, ptr %20, align 8, !tbaa !5
  %2612 = load i64, ptr %26, align 8, !tbaa !9
  %2613 = getelementptr inbounds %struct.complex, ptr %2611, i64 %2612
  %2614 = getelementptr inbounds %struct.complex, ptr %2613, i32 0, i32 1
  %2615 = load float, ptr %2614, align 4, !tbaa !14
  %2616 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2617 = load float, ptr %2616, align 4, !tbaa !14
  %2618 = load ptr, ptr %20, align 8, !tbaa !5
  %2619 = load i64, ptr %26, align 8, !tbaa !9
  %2620 = getelementptr inbounds %struct.complex, ptr %2618, i64 %2619
  %2621 = getelementptr inbounds %struct.complex, ptr %2620, i32 0, i32 0
  %2622 = load float, ptr %2621, align 4, !tbaa !11
  %2623 = fmul float %2617, %2622
  %2624 = call float @llvm.fmuladd.f32(float %2610, float %2615, float %2623)
  %2625 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2624, ptr %2625, align 4, !tbaa !14
  %2626 = load ptr, ptr %20, align 8, !tbaa !5
  %2627 = load i64, ptr %25, align 8, !tbaa !9
  %2628 = getelementptr inbounds %struct.complex, ptr %2626, i64 %2627
  %2629 = getelementptr inbounds %struct.complex, ptr %2628, i32 0, i32 0
  %2630 = load float, ptr %2629, align 4, !tbaa !11
  %2631 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %2632 = load float, ptr %2631, align 4, !tbaa !11
  %2633 = fsub float %2630, %2632
  %2634 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %2633, ptr %2634, align 4, !tbaa !11
  %2635 = load ptr, ptr %20, align 8, !tbaa !5
  %2636 = load i64, ptr %25, align 8, !tbaa !9
  %2637 = getelementptr inbounds %struct.complex, ptr %2635, i64 %2636
  %2638 = getelementptr inbounds %struct.complex, ptr %2637, i32 0, i32 1
  %2639 = load float, ptr %2638, align 4, !tbaa !14
  %2640 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %2641 = load float, ptr %2640, align 4, !tbaa !14
  %2642 = fsub float %2639, %2641
  %2643 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %2642, ptr %2643, align 4, !tbaa !14
  %2644 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2645 = load float, ptr %2644, align 4, !tbaa !11
  %2646 = load ptr, ptr %20, align 8, !tbaa !5
  %2647 = load i64, ptr %24, align 8, !tbaa !9
  %2648 = getelementptr inbounds %struct.complex, ptr %2646, i64 %2647
  %2649 = getelementptr inbounds %struct.complex, ptr %2648, i32 0, i32 0
  store float %2645, ptr %2649, align 4, !tbaa !11
  %2650 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2651 = load float, ptr %2650, align 4, !tbaa !14
  %2652 = load ptr, ptr %20, align 8, !tbaa !5
  %2653 = load i64, ptr %24, align 8, !tbaa !9
  %2654 = getelementptr inbounds %struct.complex, ptr %2652, i64 %2653
  %2655 = getelementptr inbounds %struct.complex, ptr %2654, i32 0, i32 1
  store float %2651, ptr %2655, align 4, !tbaa !14
  br label %2759

2656:                                             ; preds = %2564
  %2657 = load i64, ptr %40, align 8, !tbaa !9
  %2658 = add nsw i64 %2657, 1
  %2659 = load i64, ptr %41, align 8, !tbaa !9
  %2660 = load i64, ptr %22, align 8, !tbaa !9
  %2661 = mul nsw i64 %2659, %2660
  %2662 = add nsw i64 %2658, %2661
  store i64 %2662, ptr %24, align 8, !tbaa !9
  %2663 = load ptr, ptr %20, align 8, !tbaa !5
  %2664 = load i64, ptr %24, align 8, !tbaa !9
  %2665 = getelementptr inbounds %struct.complex, ptr %2663, i64 %2664
  %2666 = getelementptr inbounds %struct.complex, ptr %2665, i32 0, i32 0
  %2667 = load float, ptr %2666, align 4, !tbaa !11
  %2668 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %2667, ptr %2668, align 4, !tbaa !11
  %2669 = load ptr, ptr %20, align 8, !tbaa !5
  %2670 = load i64, ptr %24, align 8, !tbaa !9
  %2671 = getelementptr inbounds %struct.complex, ptr %2669, i64 %2670
  %2672 = getelementptr inbounds %struct.complex, ptr %2671, i32 0, i32 1
  %2673 = load float, ptr %2672, align 4, !tbaa !14
  %2674 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %2673, ptr %2674, align 4, !tbaa !14
  %2675 = load i64, ptr %40, align 8, !tbaa !9
  %2676 = add nsw i64 %2675, 1
  %2677 = load i64, ptr %41, align 8, !tbaa !9
  %2678 = load i64, ptr %22, align 8, !tbaa !9
  %2679 = mul nsw i64 %2677, %2678
  %2680 = add nsw i64 %2676, %2679
  store i64 %2680, ptr %24, align 8, !tbaa !9
  %2681 = load i64, ptr %40, align 8, !tbaa !9
  %2682 = load i64, ptr %41, align 8, !tbaa !9
  %2683 = load i64, ptr %22, align 8, !tbaa !9
  %2684 = mul nsw i64 %2682, %2683
  %2685 = add nsw i64 %2681, %2684
  store i64 %2685, ptr %25, align 8, !tbaa !9
  %2686 = load ptr, ptr %15, align 8, !tbaa !5
  %2687 = load i64, ptr %40, align 8, !tbaa !9
  %2688 = getelementptr inbounds %struct.complex, ptr %2686, i64 %2687
  call void @r_cnjg(ptr noundef %34, ptr noundef %2688)
  %2689 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2690 = load float, ptr %2689, align 4, !tbaa !11
  %2691 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2692 = load float, ptr %2691, align 4, !tbaa !11
  %2693 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2694 = load float, ptr %2693, align 4, !tbaa !14
  %2695 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2696 = load float, ptr %2695, align 4, !tbaa !14
  %2697 = fmul float %2694, %2696
  %2698 = fneg float %2697
  %2699 = call float @llvm.fmuladd.f32(float %2690, float %2692, float %2698)
  %2700 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2699, ptr %2700, align 4, !tbaa !11
  %2701 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2702 = load float, ptr %2701, align 4, !tbaa !11
  %2703 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2704 = load float, ptr %2703, align 4, !tbaa !14
  %2705 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2706 = load float, ptr %2705, align 4, !tbaa !14
  %2707 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2708 = load float, ptr %2707, align 4, !tbaa !11
  %2709 = fmul float %2706, %2708
  %2710 = call float @llvm.fmuladd.f32(float %2702, float %2704, float %2709)
  %2711 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2710, ptr %2711, align 4, !tbaa !14
  %2712 = load ptr, ptr %20, align 8, !tbaa !5
  %2713 = load i64, ptr %25, align 8, !tbaa !9
  %2714 = getelementptr inbounds %struct.complex, ptr %2712, i64 %2713
  %2715 = getelementptr inbounds %struct.complex, ptr %2714, i32 0, i32 0
  %2716 = load float, ptr %2715, align 4, !tbaa !11
  %2717 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %2718 = load float, ptr %2717, align 4, !tbaa !11
  %2719 = fsub float %2716, %2718
  %2720 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %2719, ptr %2720, align 4, !tbaa !11
  %2721 = load ptr, ptr %20, align 8, !tbaa !5
  %2722 = load i64, ptr %25, align 8, !tbaa !9
  %2723 = getelementptr inbounds %struct.complex, ptr %2721, i64 %2722
  %2724 = getelementptr inbounds %struct.complex, ptr %2723, i32 0, i32 1
  %2725 = load float, ptr %2724, align 4, !tbaa !14
  %2726 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %2727 = load float, ptr %2726, align 4, !tbaa !14
  %2728 = fsub float %2725, %2727
  %2729 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %2728, ptr %2729, align 4, !tbaa !14
  %2730 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2731 = load float, ptr %2730, align 4, !tbaa !11
  %2732 = load ptr, ptr %20, align 8, !tbaa !5
  %2733 = load i64, ptr %24, align 8, !tbaa !9
  %2734 = getelementptr inbounds %struct.complex, ptr %2732, i64 %2733
  %2735 = getelementptr inbounds %struct.complex, ptr %2734, i32 0, i32 0
  store float %2731, ptr %2735, align 4, !tbaa !11
  %2736 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2737 = load float, ptr %2736, align 4, !tbaa !14
  %2738 = load ptr, ptr %20, align 8, !tbaa !5
  %2739 = load i64, ptr %24, align 8, !tbaa !9
  %2740 = getelementptr inbounds %struct.complex, ptr %2738, i64 %2739
  %2741 = getelementptr inbounds %struct.complex, ptr %2740, i32 0, i32 1
  store float %2737, ptr %2741, align 4, !tbaa !14
  %2742 = load i64, ptr %40, align 8, !tbaa !9
  %2743 = load i64, ptr %41, align 8, !tbaa !9
  %2744 = load i64, ptr %22, align 8, !tbaa !9
  %2745 = mul nsw i64 %2743, %2744
  %2746 = add nsw i64 %2742, %2745
  store i64 %2746, ptr %24, align 8, !tbaa !9
  %2747 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %2748 = load float, ptr %2747, align 4, !tbaa !11
  %2749 = load ptr, ptr %20, align 8, !tbaa !5
  %2750 = load i64, ptr %24, align 8, !tbaa !9
  %2751 = getelementptr inbounds %struct.complex, ptr %2749, i64 %2750
  %2752 = getelementptr inbounds %struct.complex, ptr %2751, i32 0, i32 0
  store float %2748, ptr %2752, align 4, !tbaa !11
  %2753 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %2754 = load float, ptr %2753, align 4, !tbaa !14
  %2755 = load ptr, ptr %20, align 8, !tbaa !5
  %2756 = load i64, ptr %24, align 8, !tbaa !9
  %2757 = getelementptr inbounds %struct.complex, ptr %2755, i64 %2756
  %2758 = getelementptr inbounds %struct.complex, ptr %2757, i32 0, i32 1
  store float %2754, ptr %2758, align 4, !tbaa !14
  br label %2759

2759:                                             ; preds = %2656, %2571
  br label %2760

2760:                                             ; preds = %2759
  %2761 = load i64, ptr %40, align 8, !tbaa !9
  %2762 = add nsw i64 %2761, -1
  store i64 %2762, ptr %40, align 8, !tbaa !9
  br label %2561, !llvm.loop !27

2763:                                             ; preds = %2561
  %2764 = load i64, ptr %41, align 8, !tbaa !9
  %2765 = load ptr, ptr %14, align 8, !tbaa !5
  %2766 = load i64, ptr %2765, align 8, !tbaa !9
  %2767 = icmp slt i64 %2764, %2766
  br i1 %2767, label %2768, label %2771

2768:                                             ; preds = %2763
  %2769 = load i64, ptr %41, align 8, !tbaa !9
  %2770 = add nsw i64 %2769, 1
  store i64 %2770, ptr %41, align 8, !tbaa !9
  br label %2291

2771:                                             ; preds = %2763
  br label %3256

2772:                                             ; preds = %2286
  %2773 = load ptr, ptr %14, align 8, !tbaa !5
  %2774 = load i64, ptr %2773, align 8, !tbaa !9
  store i64 %2774, ptr %24, align 8, !tbaa !9
  store i64 1, ptr %41, align 8, !tbaa !9
  br label %2775

2775:                                             ; preds = %3252, %2772
  %2776 = load i64, ptr %41, align 8, !tbaa !9
  %2777 = load i64, ptr %24, align 8, !tbaa !9
  %2778 = icmp sle i64 %2776, %2777
  br i1 %2778, label %2779, label %3255

2779:                                             ; preds = %2775
  %2780 = load i64, ptr %41, align 8, !tbaa !9
  %2781 = load i64, ptr %22, align 8, !tbaa !9
  %2782 = mul nsw i64 %2780, %2781
  %2783 = add nsw i64 %2782, 1
  store i64 %2783, ptr %25, align 8, !tbaa !9
  %2784 = load ptr, ptr %16, align 8, !tbaa !5
  %2785 = getelementptr inbounds %struct.complex, ptr %2784, i64 1
  call void @r_cnjg(ptr noundef %33, ptr noundef %2785)
  %2786 = load ptr, ptr %20, align 8, !tbaa !5
  %2787 = load i64, ptr %41, align 8, !tbaa !9
  %2788 = load i64, ptr %22, align 8, !tbaa !9
  %2789 = mul nsw i64 %2787, %2788
  %2790 = add nsw i64 %2789, 1
  %2791 = getelementptr inbounds %struct.complex, ptr %2786, i64 %2790
  call void @c_div(ptr noundef %32, ptr noundef %2791, ptr noundef %33)
  %2792 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2793 = load float, ptr %2792, align 4, !tbaa !11
  %2794 = load ptr, ptr %20, align 8, !tbaa !5
  %2795 = load i64, ptr %25, align 8, !tbaa !9
  %2796 = getelementptr inbounds %struct.complex, ptr %2794, i64 %2795
  %2797 = getelementptr inbounds %struct.complex, ptr %2796, i32 0, i32 0
  store float %2793, ptr %2797, align 4, !tbaa !11
  %2798 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2799 = load float, ptr %2798, align 4, !tbaa !14
  %2800 = load ptr, ptr %20, align 8, !tbaa !5
  %2801 = load i64, ptr %25, align 8, !tbaa !9
  %2802 = getelementptr inbounds %struct.complex, ptr %2800, i64 %2801
  %2803 = getelementptr inbounds %struct.complex, ptr %2802, i32 0, i32 1
  store float %2799, ptr %2803, align 4, !tbaa !14
  %2804 = load ptr, ptr %13, align 8, !tbaa !5
  %2805 = load i64, ptr %2804, align 8, !tbaa !9
  %2806 = icmp sgt i64 %2805, 1
  br i1 %2806, label %2807, label %2889

2807:                                             ; preds = %2779
  %2808 = load i64, ptr %41, align 8, !tbaa !9
  %2809 = load i64, ptr %22, align 8, !tbaa !9
  %2810 = mul nsw i64 %2808, %2809
  %2811 = add nsw i64 %2810, 2
  store i64 %2811, ptr %25, align 8, !tbaa !9
  %2812 = load i64, ptr %41, align 8, !tbaa !9
  %2813 = load i64, ptr %22, align 8, !tbaa !9
  %2814 = mul nsw i64 %2812, %2813
  %2815 = add nsw i64 %2814, 2
  store i64 %2815, ptr %26, align 8, !tbaa !9
  %2816 = load ptr, ptr %17, align 8, !tbaa !5
  %2817 = getelementptr inbounds %struct.complex, ptr %2816, i64 1
  call void @r_cnjg(ptr noundef %35, ptr noundef %2817)
  %2818 = load i64, ptr %41, align 8, !tbaa !9
  %2819 = load i64, ptr %22, align 8, !tbaa !9
  %2820 = mul nsw i64 %2818, %2819
  %2821 = add nsw i64 %2820, 1
  store i64 %2821, ptr %27, align 8, !tbaa !9
  %2822 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2823 = load float, ptr %2822, align 4, !tbaa !11
  %2824 = load ptr, ptr %20, align 8, !tbaa !5
  %2825 = load i64, ptr %27, align 8, !tbaa !9
  %2826 = getelementptr inbounds %struct.complex, ptr %2824, i64 %2825
  %2827 = getelementptr inbounds %struct.complex, ptr %2826, i32 0, i32 0
  %2828 = load float, ptr %2827, align 4, !tbaa !11
  %2829 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2830 = load float, ptr %2829, align 4, !tbaa !14
  %2831 = load ptr, ptr %20, align 8, !tbaa !5
  %2832 = load i64, ptr %27, align 8, !tbaa !9
  %2833 = getelementptr inbounds %struct.complex, ptr %2831, i64 %2832
  %2834 = getelementptr inbounds %struct.complex, ptr %2833, i32 0, i32 1
  %2835 = load float, ptr %2834, align 4, !tbaa !14
  %2836 = fmul float %2830, %2835
  %2837 = fneg float %2836
  %2838 = call float @llvm.fmuladd.f32(float %2823, float %2828, float %2837)
  %2839 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %2838, ptr %2839, align 4, !tbaa !11
  %2840 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2841 = load float, ptr %2840, align 4, !tbaa !11
  %2842 = load ptr, ptr %20, align 8, !tbaa !5
  %2843 = load i64, ptr %27, align 8, !tbaa !9
  %2844 = getelementptr inbounds %struct.complex, ptr %2842, i64 %2843
  %2845 = getelementptr inbounds %struct.complex, ptr %2844, i32 0, i32 1
  %2846 = load float, ptr %2845, align 4, !tbaa !14
  %2847 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2848 = load float, ptr %2847, align 4, !tbaa !14
  %2849 = load ptr, ptr %20, align 8, !tbaa !5
  %2850 = load i64, ptr %27, align 8, !tbaa !9
  %2851 = getelementptr inbounds %struct.complex, ptr %2849, i64 %2850
  %2852 = getelementptr inbounds %struct.complex, ptr %2851, i32 0, i32 0
  %2853 = load float, ptr %2852, align 4, !tbaa !11
  %2854 = fmul float %2848, %2853
  %2855 = call float @llvm.fmuladd.f32(float %2841, float %2846, float %2854)
  %2856 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %2855, ptr %2856, align 4, !tbaa !14
  %2857 = load ptr, ptr %20, align 8, !tbaa !5
  %2858 = load i64, ptr %26, align 8, !tbaa !9
  %2859 = getelementptr inbounds %struct.complex, ptr %2857, i64 %2858
  %2860 = getelementptr inbounds %struct.complex, ptr %2859, i32 0, i32 0
  %2861 = load float, ptr %2860, align 4, !tbaa !11
  %2862 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %2863 = load float, ptr %2862, align 4, !tbaa !11
  %2864 = fsub float %2861, %2863
  %2865 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %2864, ptr %2865, align 4, !tbaa !11
  %2866 = load ptr, ptr %20, align 8, !tbaa !5
  %2867 = load i64, ptr %26, align 8, !tbaa !9
  %2868 = getelementptr inbounds %struct.complex, ptr %2866, i64 %2867
  %2869 = getelementptr inbounds %struct.complex, ptr %2868, i32 0, i32 1
  %2870 = load float, ptr %2869, align 4, !tbaa !14
  %2871 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %2872 = load float, ptr %2871, align 4, !tbaa !14
  %2873 = fsub float %2870, %2872
  %2874 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %2873, ptr %2874, align 4, !tbaa !14
  %2875 = load ptr, ptr %16, align 8, !tbaa !5
  %2876 = getelementptr inbounds %struct.complex, ptr %2875, i64 2
  call void @r_cnjg(ptr noundef %36, ptr noundef %2876)
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %36)
  %2877 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %2878 = load float, ptr %2877, align 4, !tbaa !11
  %2879 = load ptr, ptr %20, align 8, !tbaa !5
  %2880 = load i64, ptr %25, align 8, !tbaa !9
  %2881 = getelementptr inbounds %struct.complex, ptr %2879, i64 %2880
  %2882 = getelementptr inbounds %struct.complex, ptr %2881, i32 0, i32 0
  store float %2878, ptr %2882, align 4, !tbaa !11
  %2883 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %2884 = load float, ptr %2883, align 4, !tbaa !14
  %2885 = load ptr, ptr %20, align 8, !tbaa !5
  %2886 = load i64, ptr %25, align 8, !tbaa !9
  %2887 = getelementptr inbounds %struct.complex, ptr %2885, i64 %2886
  %2888 = getelementptr inbounds %struct.complex, ptr %2887, i32 0, i32 1
  store float %2884, ptr %2888, align 4, !tbaa !14
  br label %2889

2889:                                             ; preds = %2807, %2779
  %2890 = load ptr, ptr %13, align 8, !tbaa !5
  %2891 = load i64, ptr %2890, align 8, !tbaa !9
  store i64 %2891, ptr %25, align 8, !tbaa !9
  store i64 3, ptr %40, align 8, !tbaa !9
  br label %2892

2892:                                             ; preds = %3042, %2889
  %2893 = load i64, ptr %40, align 8, !tbaa !9
  %2894 = load i64, ptr %25, align 8, !tbaa !9
  %2895 = icmp sle i64 %2893, %2894
  br i1 %2895, label %2896, label %3045

2896:                                             ; preds = %2892
  %2897 = load i64, ptr %40, align 8, !tbaa !9
  %2898 = load i64, ptr %41, align 8, !tbaa !9
  %2899 = load i64, ptr %22, align 8, !tbaa !9
  %2900 = mul nsw i64 %2898, %2899
  %2901 = add nsw i64 %2897, %2900
  store i64 %2901, ptr %26, align 8, !tbaa !9
  %2902 = load i64, ptr %40, align 8, !tbaa !9
  %2903 = load i64, ptr %41, align 8, !tbaa !9
  %2904 = load i64, ptr %22, align 8, !tbaa !9
  %2905 = mul nsw i64 %2903, %2904
  %2906 = add nsw i64 %2902, %2905
  store i64 %2906, ptr %27, align 8, !tbaa !9
  %2907 = load ptr, ptr %17, align 8, !tbaa !5
  %2908 = load i64, ptr %40, align 8, !tbaa !9
  %2909 = sub nsw i64 %2908, 1
  %2910 = getelementptr inbounds %struct.complex, ptr %2907, i64 %2909
  call void @r_cnjg(ptr noundef %36, ptr noundef %2910)
  %2911 = load i64, ptr %40, align 8, !tbaa !9
  %2912 = sub nsw i64 %2911, 1
  %2913 = load i64, ptr %41, align 8, !tbaa !9
  %2914 = load i64, ptr %22, align 8, !tbaa !9
  %2915 = mul nsw i64 %2913, %2914
  %2916 = add nsw i64 %2912, %2915
  store i64 %2916, ptr %28, align 8, !tbaa !9
  %2917 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %2918 = load float, ptr %2917, align 4, !tbaa !11
  %2919 = load ptr, ptr %20, align 8, !tbaa !5
  %2920 = load i64, ptr %28, align 8, !tbaa !9
  %2921 = getelementptr inbounds %struct.complex, ptr %2919, i64 %2920
  %2922 = getelementptr inbounds %struct.complex, ptr %2921, i32 0, i32 0
  %2923 = load float, ptr %2922, align 4, !tbaa !11
  %2924 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %2925 = load float, ptr %2924, align 4, !tbaa !14
  %2926 = load ptr, ptr %20, align 8, !tbaa !5
  %2927 = load i64, ptr %28, align 8, !tbaa !9
  %2928 = getelementptr inbounds %struct.complex, ptr %2926, i64 %2927
  %2929 = getelementptr inbounds %struct.complex, ptr %2928, i32 0, i32 1
  %2930 = load float, ptr %2929, align 4, !tbaa !14
  %2931 = fmul float %2925, %2930
  %2932 = fneg float %2931
  %2933 = call float @llvm.fmuladd.f32(float %2918, float %2923, float %2932)
  %2934 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  store float %2933, ptr %2934, align 4, !tbaa !11
  %2935 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 0
  %2936 = load float, ptr %2935, align 4, !tbaa !11
  %2937 = load ptr, ptr %20, align 8, !tbaa !5
  %2938 = load i64, ptr %28, align 8, !tbaa !9
  %2939 = getelementptr inbounds %struct.complex, ptr %2937, i64 %2938
  %2940 = getelementptr inbounds %struct.complex, ptr %2939, i32 0, i32 1
  %2941 = load float, ptr %2940, align 4, !tbaa !14
  %2942 = getelementptr inbounds %struct.complex, ptr %36, i32 0, i32 1
  %2943 = load float, ptr %2942, align 4, !tbaa !14
  %2944 = load ptr, ptr %20, align 8, !tbaa !5
  %2945 = load i64, ptr %28, align 8, !tbaa !9
  %2946 = getelementptr inbounds %struct.complex, ptr %2944, i64 %2945
  %2947 = getelementptr inbounds %struct.complex, ptr %2946, i32 0, i32 0
  %2948 = load float, ptr %2947, align 4, !tbaa !11
  %2949 = fmul float %2943, %2948
  %2950 = call float @llvm.fmuladd.f32(float %2936, float %2941, float %2949)
  %2951 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  store float %2950, ptr %2951, align 4, !tbaa !14
  %2952 = load ptr, ptr %20, align 8, !tbaa !5
  %2953 = load i64, ptr %27, align 8, !tbaa !9
  %2954 = getelementptr inbounds %struct.complex, ptr %2952, i64 %2953
  %2955 = getelementptr inbounds %struct.complex, ptr %2954, i32 0, i32 0
  %2956 = load float, ptr %2955, align 4, !tbaa !11
  %2957 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 0
  %2958 = load float, ptr %2957, align 4, !tbaa !11
  %2959 = fsub float %2956, %2958
  %2960 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  store float %2959, ptr %2960, align 4, !tbaa !11
  %2961 = load ptr, ptr %20, align 8, !tbaa !5
  %2962 = load i64, ptr %27, align 8, !tbaa !9
  %2963 = getelementptr inbounds %struct.complex, ptr %2961, i64 %2962
  %2964 = getelementptr inbounds %struct.complex, ptr %2963, i32 0, i32 1
  %2965 = load float, ptr %2964, align 4, !tbaa !14
  %2966 = getelementptr inbounds %struct.complex, ptr %35, i32 0, i32 1
  %2967 = load float, ptr %2966, align 4, !tbaa !14
  %2968 = fsub float %2965, %2967
  %2969 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  store float %2968, ptr %2969, align 4, !tbaa !14
  %2970 = load ptr, ptr %18, align 8, !tbaa !5
  %2971 = load i64, ptr %40, align 8, !tbaa !9
  %2972 = sub nsw i64 %2971, 2
  %2973 = getelementptr inbounds %struct.complex, ptr %2970, i64 %2972
  call void @r_cnjg(ptr noundef %38, ptr noundef %2973)
  %2974 = load i64, ptr %40, align 8, !tbaa !9
  %2975 = sub nsw i64 %2974, 2
  %2976 = load i64, ptr %41, align 8, !tbaa !9
  %2977 = load i64, ptr %22, align 8, !tbaa !9
  %2978 = mul nsw i64 %2976, %2977
  %2979 = add nsw i64 %2975, %2978
  store i64 %2979, ptr %29, align 8, !tbaa !9
  %2980 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %2981 = load float, ptr %2980, align 4, !tbaa !11
  %2982 = load ptr, ptr %20, align 8, !tbaa !5
  %2983 = load i64, ptr %29, align 8, !tbaa !9
  %2984 = getelementptr inbounds %struct.complex, ptr %2982, i64 %2983
  %2985 = getelementptr inbounds %struct.complex, ptr %2984, i32 0, i32 0
  %2986 = load float, ptr %2985, align 4, !tbaa !11
  %2987 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %2988 = load float, ptr %2987, align 4, !tbaa !14
  %2989 = load ptr, ptr %20, align 8, !tbaa !5
  %2990 = load i64, ptr %29, align 8, !tbaa !9
  %2991 = getelementptr inbounds %struct.complex, ptr %2989, i64 %2990
  %2992 = getelementptr inbounds %struct.complex, ptr %2991, i32 0, i32 1
  %2993 = load float, ptr %2992, align 4, !tbaa !14
  %2994 = fmul float %2988, %2993
  %2995 = fneg float %2994
  %2996 = call float @llvm.fmuladd.f32(float %2981, float %2986, float %2995)
  %2997 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  store float %2996, ptr %2997, align 4, !tbaa !11
  %2998 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %2999 = load float, ptr %2998, align 4, !tbaa !11
  %3000 = load ptr, ptr %20, align 8, !tbaa !5
  %3001 = load i64, ptr %29, align 8, !tbaa !9
  %3002 = getelementptr inbounds %struct.complex, ptr %3000, i64 %3001
  %3003 = getelementptr inbounds %struct.complex, ptr %3002, i32 0, i32 1
  %3004 = load float, ptr %3003, align 4, !tbaa !14
  %3005 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %3006 = load float, ptr %3005, align 4, !tbaa !14
  %3007 = load ptr, ptr %20, align 8, !tbaa !5
  %3008 = load i64, ptr %29, align 8, !tbaa !9
  %3009 = getelementptr inbounds %struct.complex, ptr %3007, i64 %3008
  %3010 = getelementptr inbounds %struct.complex, ptr %3009, i32 0, i32 0
  %3011 = load float, ptr %3010, align 4, !tbaa !11
  %3012 = fmul float %3006, %3011
  %3013 = call float @llvm.fmuladd.f32(float %2999, float %3004, float %3012)
  %3014 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  store float %3013, ptr %3014, align 4, !tbaa !14
  %3015 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %3016 = load float, ptr %3015, align 4, !tbaa !11
  %3017 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 0
  %3018 = load float, ptr %3017, align 4, !tbaa !11
  %3019 = fsub float %3016, %3018
  %3020 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %3019, ptr %3020, align 4, !tbaa !11
  %3021 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %3022 = load float, ptr %3021, align 4, !tbaa !14
  %3023 = getelementptr inbounds %struct.complex, ptr %37, i32 0, i32 1
  %3024 = load float, ptr %3023, align 4, !tbaa !14
  %3025 = fsub float %3022, %3024
  %3026 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %3025, ptr %3026, align 4, !tbaa !14
  %3027 = load ptr, ptr %16, align 8, !tbaa !5
  %3028 = load i64, ptr %40, align 8, !tbaa !9
  %3029 = getelementptr inbounds %struct.complex, ptr %3027, i64 %3028
  call void @r_cnjg(ptr noundef %39, ptr noundef %3029)
  call void @c_div(ptr noundef %32, ptr noundef %33, ptr noundef %39)
  %3030 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %3031 = load float, ptr %3030, align 4, !tbaa !11
  %3032 = load ptr, ptr %20, align 8, !tbaa !5
  %3033 = load i64, ptr %26, align 8, !tbaa !9
  %3034 = getelementptr inbounds %struct.complex, ptr %3032, i64 %3033
  %3035 = getelementptr inbounds %struct.complex, ptr %3034, i32 0, i32 0
  store float %3031, ptr %3035, align 4, !tbaa !11
  %3036 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %3037 = load float, ptr %3036, align 4, !tbaa !14
  %3038 = load ptr, ptr %20, align 8, !tbaa !5
  %3039 = load i64, ptr %26, align 8, !tbaa !9
  %3040 = getelementptr inbounds %struct.complex, ptr %3038, i64 %3039
  %3041 = getelementptr inbounds %struct.complex, ptr %3040, i32 0, i32 1
  store float %3037, ptr %3041, align 4, !tbaa !14
  br label %3042

3042:                                             ; preds = %2896
  %3043 = load i64, ptr %40, align 8, !tbaa !9
  %3044 = add nsw i64 %3043, 1
  store i64 %3044, ptr %40, align 8, !tbaa !9
  br label %2892, !llvm.loop !28

3045:                                             ; preds = %2892
  %3046 = load ptr, ptr %13, align 8, !tbaa !5
  %3047 = load i64, ptr %3046, align 8, !tbaa !9
  %3048 = sub nsw i64 %3047, 1
  store i64 %3048, ptr %40, align 8, !tbaa !9
  br label %3049

3049:                                             ; preds = %3248, %3045
  %3050 = load i64, ptr %40, align 8, !tbaa !9
  %3051 = icmp sge i64 %3050, 1
  br i1 %3051, label %3052, label %3251

3052:                                             ; preds = %3049
  %3053 = load ptr, ptr %19, align 8, !tbaa !5
  %3054 = load i64, ptr %40, align 8, !tbaa !9
  %3055 = getelementptr inbounds i64, ptr %3053, i64 %3054
  %3056 = load i64, ptr %3055, align 8, !tbaa !9
  %3057 = load i64, ptr %40, align 8, !tbaa !9
  %3058 = icmp eq i64 %3056, %3057
  br i1 %3058, label %3059, label %3144

3059:                                             ; preds = %3052
  %3060 = load i64, ptr %40, align 8, !tbaa !9
  %3061 = load i64, ptr %41, align 8, !tbaa !9
  %3062 = load i64, ptr %22, align 8, !tbaa !9
  %3063 = mul nsw i64 %3061, %3062
  %3064 = add nsw i64 %3060, %3063
  store i64 %3064, ptr %25, align 8, !tbaa !9
  %3065 = load i64, ptr %40, align 8, !tbaa !9
  %3066 = load i64, ptr %41, align 8, !tbaa !9
  %3067 = load i64, ptr %22, align 8, !tbaa !9
  %3068 = mul nsw i64 %3066, %3067
  %3069 = add nsw i64 %3065, %3068
  store i64 %3069, ptr %26, align 8, !tbaa !9
  %3070 = load ptr, ptr %15, align 8, !tbaa !5
  %3071 = load i64, ptr %40, align 8, !tbaa !9
  %3072 = getelementptr inbounds %struct.complex, ptr %3070, i64 %3071
  call void @r_cnjg(ptr noundef %34, ptr noundef %3072)
  %3073 = load i64, ptr %40, align 8, !tbaa !9
  %3074 = add nsw i64 %3073, 1
  %3075 = load i64, ptr %41, align 8, !tbaa !9
  %3076 = load i64, ptr %22, align 8, !tbaa !9
  %3077 = mul nsw i64 %3075, %3076
  %3078 = add nsw i64 %3074, %3077
  store i64 %3078, ptr %27, align 8, !tbaa !9
  %3079 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %3080 = load float, ptr %3079, align 4, !tbaa !11
  %3081 = load ptr, ptr %20, align 8, !tbaa !5
  %3082 = load i64, ptr %27, align 8, !tbaa !9
  %3083 = getelementptr inbounds %struct.complex, ptr %3081, i64 %3082
  %3084 = getelementptr inbounds %struct.complex, ptr %3083, i32 0, i32 0
  %3085 = load float, ptr %3084, align 4, !tbaa !11
  %3086 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %3087 = load float, ptr %3086, align 4, !tbaa !14
  %3088 = load ptr, ptr %20, align 8, !tbaa !5
  %3089 = load i64, ptr %27, align 8, !tbaa !9
  %3090 = getelementptr inbounds %struct.complex, ptr %3088, i64 %3089
  %3091 = getelementptr inbounds %struct.complex, ptr %3090, i32 0, i32 1
  %3092 = load float, ptr %3091, align 4, !tbaa !14
  %3093 = fmul float %3087, %3092
  %3094 = fneg float %3093
  %3095 = call float @llvm.fmuladd.f32(float %3080, float %3085, float %3094)
  %3096 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %3095, ptr %3096, align 4, !tbaa !11
  %3097 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %3098 = load float, ptr %3097, align 4, !tbaa !11
  %3099 = load ptr, ptr %20, align 8, !tbaa !5
  %3100 = load i64, ptr %27, align 8, !tbaa !9
  %3101 = getelementptr inbounds %struct.complex, ptr %3099, i64 %3100
  %3102 = getelementptr inbounds %struct.complex, ptr %3101, i32 0, i32 1
  %3103 = load float, ptr %3102, align 4, !tbaa !14
  %3104 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %3105 = load float, ptr %3104, align 4, !tbaa !14
  %3106 = load ptr, ptr %20, align 8, !tbaa !5
  %3107 = load i64, ptr %27, align 8, !tbaa !9
  %3108 = getelementptr inbounds %struct.complex, ptr %3106, i64 %3107
  %3109 = getelementptr inbounds %struct.complex, ptr %3108, i32 0, i32 0
  %3110 = load float, ptr %3109, align 4, !tbaa !11
  %3111 = fmul float %3105, %3110
  %3112 = call float @llvm.fmuladd.f32(float %3098, float %3103, float %3111)
  %3113 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %3112, ptr %3113, align 4, !tbaa !14
  %3114 = load ptr, ptr %20, align 8, !tbaa !5
  %3115 = load i64, ptr %26, align 8, !tbaa !9
  %3116 = getelementptr inbounds %struct.complex, ptr %3114, i64 %3115
  %3117 = getelementptr inbounds %struct.complex, ptr %3116, i32 0, i32 0
  %3118 = load float, ptr %3117, align 4, !tbaa !11
  %3119 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %3120 = load float, ptr %3119, align 4, !tbaa !11
  %3121 = fsub float %3118, %3120
  %3122 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %3121, ptr %3122, align 4, !tbaa !11
  %3123 = load ptr, ptr %20, align 8, !tbaa !5
  %3124 = load i64, ptr %26, align 8, !tbaa !9
  %3125 = getelementptr inbounds %struct.complex, ptr %3123, i64 %3124
  %3126 = getelementptr inbounds %struct.complex, ptr %3125, i32 0, i32 1
  %3127 = load float, ptr %3126, align 4, !tbaa !14
  %3128 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %3129 = load float, ptr %3128, align 4, !tbaa !14
  %3130 = fsub float %3127, %3129
  %3131 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %3130, ptr %3131, align 4, !tbaa !14
  %3132 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %3133 = load float, ptr %3132, align 4, !tbaa !11
  %3134 = load ptr, ptr %20, align 8, !tbaa !5
  %3135 = load i64, ptr %25, align 8, !tbaa !9
  %3136 = getelementptr inbounds %struct.complex, ptr %3134, i64 %3135
  %3137 = getelementptr inbounds %struct.complex, ptr %3136, i32 0, i32 0
  store float %3133, ptr %3137, align 4, !tbaa !11
  %3138 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %3139 = load float, ptr %3138, align 4, !tbaa !14
  %3140 = load ptr, ptr %20, align 8, !tbaa !5
  %3141 = load i64, ptr %25, align 8, !tbaa !9
  %3142 = getelementptr inbounds %struct.complex, ptr %3140, i64 %3141
  %3143 = getelementptr inbounds %struct.complex, ptr %3142, i32 0, i32 1
  store float %3139, ptr %3143, align 4, !tbaa !14
  br label %3247

3144:                                             ; preds = %3052
  %3145 = load i64, ptr %40, align 8, !tbaa !9
  %3146 = add nsw i64 %3145, 1
  %3147 = load i64, ptr %41, align 8, !tbaa !9
  %3148 = load i64, ptr %22, align 8, !tbaa !9
  %3149 = mul nsw i64 %3147, %3148
  %3150 = add nsw i64 %3146, %3149
  store i64 %3150, ptr %25, align 8, !tbaa !9
  %3151 = load ptr, ptr %20, align 8, !tbaa !5
  %3152 = load i64, ptr %25, align 8, !tbaa !9
  %3153 = getelementptr inbounds %struct.complex, ptr %3151, i64 %3152
  %3154 = getelementptr inbounds %struct.complex, ptr %3153, i32 0, i32 0
  %3155 = load float, ptr %3154, align 4, !tbaa !11
  %3156 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %3155, ptr %3156, align 4, !tbaa !11
  %3157 = load ptr, ptr %20, align 8, !tbaa !5
  %3158 = load i64, ptr %25, align 8, !tbaa !9
  %3159 = getelementptr inbounds %struct.complex, ptr %3157, i64 %3158
  %3160 = getelementptr inbounds %struct.complex, ptr %3159, i32 0, i32 1
  %3161 = load float, ptr %3160, align 4, !tbaa !14
  %3162 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %3161, ptr %3162, align 4, !tbaa !14
  %3163 = load i64, ptr %40, align 8, !tbaa !9
  %3164 = add nsw i64 %3163, 1
  %3165 = load i64, ptr %41, align 8, !tbaa !9
  %3166 = load i64, ptr %22, align 8, !tbaa !9
  %3167 = mul nsw i64 %3165, %3166
  %3168 = add nsw i64 %3164, %3167
  store i64 %3168, ptr %25, align 8, !tbaa !9
  %3169 = load i64, ptr %40, align 8, !tbaa !9
  %3170 = load i64, ptr %41, align 8, !tbaa !9
  %3171 = load i64, ptr %22, align 8, !tbaa !9
  %3172 = mul nsw i64 %3170, %3171
  %3173 = add nsw i64 %3169, %3172
  store i64 %3173, ptr %26, align 8, !tbaa !9
  %3174 = load ptr, ptr %15, align 8, !tbaa !5
  %3175 = load i64, ptr %40, align 8, !tbaa !9
  %3176 = getelementptr inbounds %struct.complex, ptr %3174, i64 %3175
  call void @r_cnjg(ptr noundef %34, ptr noundef %3176)
  %3177 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %3178 = load float, ptr %3177, align 4, !tbaa !11
  %3179 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %3180 = load float, ptr %3179, align 4, !tbaa !11
  %3181 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %3182 = load float, ptr %3181, align 4, !tbaa !14
  %3183 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %3184 = load float, ptr %3183, align 4, !tbaa !14
  %3185 = fmul float %3182, %3184
  %3186 = fneg float %3185
  %3187 = call float @llvm.fmuladd.f32(float %3178, float %3180, float %3186)
  %3188 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  store float %3187, ptr %3188, align 4, !tbaa !11
  %3189 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 0
  %3190 = load float, ptr %3189, align 4, !tbaa !11
  %3191 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %3192 = load float, ptr %3191, align 4, !tbaa !14
  %3193 = getelementptr inbounds %struct.complex, ptr %34, i32 0, i32 1
  %3194 = load float, ptr %3193, align 4, !tbaa !14
  %3195 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %3196 = load float, ptr %3195, align 4, !tbaa !11
  %3197 = fmul float %3194, %3196
  %3198 = call float @llvm.fmuladd.f32(float %3190, float %3192, float %3197)
  %3199 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  store float %3198, ptr %3199, align 4, !tbaa !14
  %3200 = load ptr, ptr %20, align 8, !tbaa !5
  %3201 = load i64, ptr %26, align 8, !tbaa !9
  %3202 = getelementptr inbounds %struct.complex, ptr %3200, i64 %3201
  %3203 = getelementptr inbounds %struct.complex, ptr %3202, i32 0, i32 0
  %3204 = load float, ptr %3203, align 4, !tbaa !11
  %3205 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 0
  %3206 = load float, ptr %3205, align 4, !tbaa !11
  %3207 = fsub float %3204, %3206
  %3208 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  store float %3207, ptr %3208, align 4, !tbaa !11
  %3209 = load ptr, ptr %20, align 8, !tbaa !5
  %3210 = load i64, ptr %26, align 8, !tbaa !9
  %3211 = getelementptr inbounds %struct.complex, ptr %3209, i64 %3210
  %3212 = getelementptr inbounds %struct.complex, ptr %3211, i32 0, i32 1
  %3213 = load float, ptr %3212, align 4, !tbaa !14
  %3214 = getelementptr inbounds %struct.complex, ptr %33, i32 0, i32 1
  %3215 = load float, ptr %3214, align 4, !tbaa !14
  %3216 = fsub float %3213, %3215
  %3217 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  store float %3216, ptr %3217, align 4, !tbaa !14
  %3218 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 0
  %3219 = load float, ptr %3218, align 4, !tbaa !11
  %3220 = load ptr, ptr %20, align 8, !tbaa !5
  %3221 = load i64, ptr %25, align 8, !tbaa !9
  %3222 = getelementptr inbounds %struct.complex, ptr %3220, i64 %3221
  %3223 = getelementptr inbounds %struct.complex, ptr %3222, i32 0, i32 0
  store float %3219, ptr %3223, align 4, !tbaa !11
  %3224 = getelementptr inbounds %struct.complex, ptr %32, i32 0, i32 1
  %3225 = load float, ptr %3224, align 4, !tbaa !14
  %3226 = load ptr, ptr %20, align 8, !tbaa !5
  %3227 = load i64, ptr %25, align 8, !tbaa !9
  %3228 = getelementptr inbounds %struct.complex, ptr %3226, i64 %3227
  %3229 = getelementptr inbounds %struct.complex, ptr %3228, i32 0, i32 1
  store float %3225, ptr %3229, align 4, !tbaa !14
  %3230 = load i64, ptr %40, align 8, !tbaa !9
  %3231 = load i64, ptr %41, align 8, !tbaa !9
  %3232 = load i64, ptr %22, align 8, !tbaa !9
  %3233 = mul nsw i64 %3231, %3232
  %3234 = add nsw i64 %3230, %3233
  store i64 %3234, ptr %25, align 8, !tbaa !9
  %3235 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %3236 = load float, ptr %3235, align 4, !tbaa !11
  %3237 = load ptr, ptr %20, align 8, !tbaa !5
  %3238 = load i64, ptr %25, align 8, !tbaa !9
  %3239 = getelementptr inbounds %struct.complex, ptr %3237, i64 %3238
  %3240 = getelementptr inbounds %struct.complex, ptr %3239, i32 0, i32 0
  store float %3236, ptr %3240, align 4, !tbaa !11
  %3241 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %3242 = load float, ptr %3241, align 4, !tbaa !14
  %3243 = load ptr, ptr %20, align 8, !tbaa !5
  %3244 = load i64, ptr %25, align 8, !tbaa !9
  %3245 = getelementptr inbounds %struct.complex, ptr %3243, i64 %3244
  %3246 = getelementptr inbounds %struct.complex, ptr %3245, i32 0, i32 1
  store float %3242, ptr %3246, align 4, !tbaa !14
  br label %3247

3247:                                             ; preds = %3144, %3059
  br label %3248

3248:                                             ; preds = %3247
  %3249 = load i64, ptr %40, align 8, !tbaa !9
  %3250 = add nsw i64 %3249, -1
  store i64 %3250, ptr %40, align 8, !tbaa !9
  br label %3049, !llvm.loop !29

3251:                                             ; preds = %3049
  br label %3252

3252:                                             ; preds = %3251
  %3253 = load i64, ptr %41, align 8, !tbaa !9
  %3254 = add nsw i64 %3253, 1
  store i64 %3254, ptr %41, align 8, !tbaa !9
  br label %2775, !llvm.loop !30

3255:                                             ; preds = %2775
  br label %3256

3256:                                             ; preds = %3255, %2771
  br label %3257

3257:                                             ; preds = %3256, %2285
  br label %3258

3258:                                             ; preds = %3257, %1218
  store i32 0, ptr %11, align 4
  store i32 1, ptr %43, align 4
  br label %3259

3259:                                             ; preds = %3258, %69
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  %3260 = load i32, ptr %11, align 4
  ret i32 %3260
}

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

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

declare void @c_div(ptr noundef, ptr noundef, ptr noundef) #3

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"long", !7, i64 0}
!11 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 4}
!13 = !{!"float", !7, i64 0}
!14 = !{!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}
!24 = distinct !{!24, !16}
!25 = distinct !{!25, !16}
!26 = distinct !{!26, !16}
!27 = distinct !{!27, !16}
!28 = distinct !{!28, !16}
!29 = distinct !{!29, !16}
!30 = distinct !{!30, !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 }

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

28:                                               ; preds = %10
  %29 = load i64, ptr %2, align 8, !tbaa !5
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %.loopexit, label %31

31:                                               ; preds = %28
  %32 = load i64, ptr %0, align 8, !tbaa !5
  %33 = icmp slt i64 %29, 2
  switch i64 %32, label %470 [
    i64 0, label %34
    i64 1, label %271
  ]

34:                                               ; preds = %31
  %invariant.gep1196 = getelementptr i8, ptr %4, i64 -16
  br i1 %33, label %.preheader1121, label %.preheader1123

.preheader1121:                                   ; preds = %34, %._crit_edge1195
  %.0 = phi i64 [ %153, %._crit_edge1195 ], [ 1, %34 ]
  %35 = load i64, ptr %1, align 8, !tbaa !5
  %.not1118.not1187 = icmp sgt i64 %35, 1
  %36 = mul nsw i64 %.0, %23
  br i1 %.not1118.not1187, label %.lr.ph1190, label %._crit_edge1191

.lr.ph1190:                                       ; preds = %.preheader1121, %80
  %.011001188 = phi i64 [ %81, %80 ], [ 1, %.preheader1121 ]
  %37 = getelementptr inbounds i64, ptr %22, i64 %.011001188
  %38 = load i64, ptr %37, align 8, !tbaa !5
  %39 = icmp eq i64 %38, %.011001188
  br i1 %39, label %40, label %60

40:                                               ; preds = %.lr.ph1190
  %41 = getelementptr inbounds %struct.complex, ptr %18, i64 %.011001188
  %42 = load float, ptr %41, align 4, !tbaa !9
  %43 = getelementptr %struct.complex, ptr %25, i64 %.011001188
  %44 = getelementptr %struct.complex, ptr %43, i64 %36
  %45 = getelementptr inbounds i8, ptr %41, i64 4
  %46 = load float, ptr %45, align 4, !tbaa !12
  %47 = fneg float %46
  %48 = load <2 x float>, ptr %44, align 4, !tbaa !13
  %49 = insertelement <2 x float> poison, float %46, i64 0
  %50 = insertelement <2 x float> %49, float %47, i64 1
  %51 = fmul <2 x float> %48, %50
  %52 = shufflevector <2 x float> %51, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %53 = insertelement <2 x float> poison, float %42, i64 0
  %54 = shufflevector <2 x float> %53, <2 x float> poison, <2 x i32> zeroinitializer
  %55 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %54, <2 x float> %48, <2 x float> %52)
  store <2 x float> %55, ptr %12, align 8, !tbaa !13
  %56 = getelementptr i8, ptr %43, i64 8
  %57 = getelementptr %struct.complex, ptr %56, i64 %36
  %58 = load <2 x float>, ptr %57, align 4, !tbaa !13
  %59 = fsub <2 x float> %58, %55
  store <2 x float> %59, ptr %11, align 8, !tbaa !13
  store <2 x float> %59, ptr %57, align 4, !tbaa !13
  br label %80

60:                                               ; preds = %.lr.ph1190
  %61 = getelementptr %struct.complex, ptr %25, i64 %.011001188
  %62 = getelementptr %struct.complex, ptr %61, i64 %36
  %63 = getelementptr i8, ptr %61, i64 8
  %64 = getelementptr %struct.complex, ptr %63, i64 %36
  %65 = getelementptr inbounds %struct.complex, ptr %18, i64 %.011001188
  %66 = getelementptr inbounds i8, ptr %65, i64 4
  %67 = load <2 x float>, ptr %62, align 4, !tbaa !13
  %68 = load <2 x float>, ptr %64, align 4, !tbaa !13
  store <2 x float> %68, ptr %62, align 4, !tbaa !13
  %69 = load float, ptr %65, align 4, !tbaa !9
  %70 = load float, ptr %66, align 4, !tbaa !12
  %71 = fneg float %70
  %72 = insertelement <2 x float> poison, float %70, i64 0
  %73 = insertelement <2 x float> %72, float %71, i64 1
  %74 = fmul <2 x float> %68, %73
  %75 = shufflevector <2 x float> %74, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %76 = insertelement <2 x float> poison, float %69, i64 0
  %77 = shufflevector <2 x float> %76, <2 x float> poison, <2 x i32> zeroinitializer
  %78 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %77, <2 x float> %68, <2 x float> %75)
  store <2 x float> %78, ptr %12, align 8, !tbaa !13
  %79 = fsub <2 x float> %67, %78
  store <2 x float> %79, ptr %11, align 8, !tbaa !13
  store <2 x float> %79, ptr %64, align 4, !tbaa !13
  br label %80

80:                                               ; preds = %40, %60
  %81 = add nuw nsw i64 %.011001188, 1
  %exitcond1258.not = icmp eq i64 %81, %35
  br i1 %exitcond1258.not, label %._crit_edge1191, label %.lr.ph1190, !llvm.loop !14

._crit_edge1191:                                  ; preds = %80, %.preheader1121
  %82 = getelementptr %struct.complex, ptr %25, i64 %35
  %83 = getelementptr %struct.complex, ptr %82, i64 %36
  %84 = getelementptr inbounds %struct.complex, ptr %19, i64 %35
  call void @c_div(ptr noundef nonnull %11, ptr noundef %83, ptr noundef nonnull %84) #4
  %85 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %85, ptr %83, align 4, !tbaa !13
  %86 = load i64, ptr %1, align 8, !tbaa !5
  %87 = icmp sgt i64 %86, 1
  br i1 %87, label %88, label %._crit_edge1195

88:                                               ; preds = %._crit_edge1191
  %89 = add nsw i64 %86, -1
  %90 = getelementptr inbounds %struct.complex, ptr %20, i64 %89
  %91 = load float, ptr %90, align 4, !tbaa !9
  %92 = getelementptr %struct.complex, ptr %25, i64 %86
  %93 = getelementptr %struct.complex, ptr %92, i64 %36
  %94 = getelementptr inbounds i8, ptr %90, i64 4
  %95 = load float, ptr %94, align 4, !tbaa !12
  %96 = fneg float %95
  %97 = getelementptr %struct.complex, ptr %25, i64 %89
  %98 = getelementptr %struct.complex, ptr %97, i64 %36
  %99 = load <2 x float>, ptr %93, align 4, !tbaa !13
  %100 = insertelement <2 x float> poison, float %95, i64 0
  %101 = insertelement <2 x float> %100, float %96, i64 1
  %102 = fmul <2 x float> %99, %101
  %103 = shufflevector <2 x float> %102, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %104 = insertelement <2 x float> poison, float %91, i64 0
  %105 = shufflevector <2 x float> %104, <2 x float> poison, <2 x i32> zeroinitializer
  %106 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %99, <2 x float> %103)
  %107 = load <2 x float>, ptr %98, align 4, !tbaa !13
  %108 = fsub <2 x float> %107, %106
  store <2 x float> %108, ptr %12, align 8, !tbaa !13
  %gep1197 = getelementptr %struct.complex, ptr %invariant.gep1196, i64 %86
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef %gep1197) #4
  %109 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %109, ptr %98, align 4, !tbaa !13
  %.pre1271 = load i64, ptr %1, align 8, !tbaa !5
  %110 = icmp sgt i64 %.pre1271, 2
  br i1 %110, label %.lr.ph1194.preheader, label %._crit_edge1195

.lr.ph1194.preheader:                             ; preds = %88
  %111 = add nsw i64 %.pre1271, -2
  br label %.lr.ph1194

.lr.ph1194:                                       ; preds = %.lr.ph1194.preheader, %.lr.ph1194
  %.111011192 = phi i64 [ %149, %.lr.ph1194 ], [ %111, %.lr.ph1194.preheader ]
  %112 = getelementptr inbounds %struct.complex, ptr %20, i64 %.111011192
  %113 = load float, ptr %112, align 4, !tbaa !9
  %114 = getelementptr %struct.complex, ptr %25, i64 %.111011192
  %115 = getelementptr i8, ptr %114, i64 8
  %116 = getelementptr %struct.complex, ptr %115, i64 %36
  %117 = getelementptr inbounds i8, ptr %112, i64 4
  %118 = load float, ptr %117, align 4, !tbaa !12
  %119 = fneg float %118
  %120 = getelementptr %struct.complex, ptr %114, i64 %36
  %121 = getelementptr inbounds %struct.complex, ptr %21, i64 %.111011192
  %122 = load float, ptr %121, align 4, !tbaa !9
  %123 = getelementptr i8, ptr %114, i64 16
  %124 = getelementptr %struct.complex, ptr %123, i64 %36
  %125 = getelementptr inbounds i8, ptr %121, i64 4
  %126 = load float, ptr %125, align 4, !tbaa !12
  %127 = fneg float %126
  %128 = load <2 x float>, ptr %116, align 4, !tbaa !13
  %129 = insertelement <2 x float> poison, float %118, i64 0
  %130 = insertelement <2 x float> %129, float %119, i64 1
  %131 = fmul <2 x float> %128, %130
  %132 = shufflevector <2 x float> %131, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %133 = insertelement <2 x float> poison, float %113, i64 0
  %134 = shufflevector <2 x float> %133, <2 x float> poison, <2 x i32> zeroinitializer
  %135 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %134, <2 x float> %128, <2 x float> %132)
  %136 = load <2 x float>, ptr %120, align 4, !tbaa !13
  %137 = fsub <2 x float> %136, %135
  %138 = load <2 x float>, ptr %124, align 4, !tbaa !13
  %139 = insertelement <2 x float> poison, float %126, i64 0
  %140 = insertelement <2 x float> %139, float %127, i64 1
  %141 = fmul <2 x float> %138, %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 %122, i64 0
  %144 = shufflevector <2 x float> %143, <2 x float> poison, <2 x i32> zeroinitializer
  %145 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %144, <2 x float> %138, <2 x float> %142)
  %146 = fsub <2 x float> %137, %145
  store <2 x float> %146, ptr %12, align 8, !tbaa !13
  %147 = getelementptr inbounds %struct.complex, ptr %19, i64 %.111011192
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %147) #4
  %148 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %148, ptr %120, align 4, !tbaa !13
  %149 = add nsw i64 %.111011192, -1
  %150 = icmp ugt i64 %.111011192, 1
  br i1 %150, label %.lr.ph1194, label %._crit_edge1195, !llvm.loop !16

._crit_edge1195:                                  ; preds = %.lr.ph1194, %._crit_edge1191, %88
  %151 = load i64, ptr %2, align 8, !tbaa !5
  %152 = icmp slt i64 %.0, %151
  %153 = add nuw nsw i64 %.0, 1
  br i1 %152, label %.preheader1121, label %.loopexit

.preheader1123:                                   ; preds = %34, %._crit_edge1183
  %.11186 = phi i64 [ %270, %._crit_edge1183 ], [ 1, %34 ]
  %154 = load i64, ptr %1, align 8, !tbaa !5
  %.not1117.not1175 = icmp sgt i64 %154, 1
  %155 = mul nsw i64 %.11186, %23
  br i1 %.not1117.not1175, label %.lr.ph1178, label %._crit_edge1179

.lr.ph1178:                                       ; preds = %.preheader1123, %199
  %.211021176 = phi i64 [ %200, %199 ], [ 1, %.preheader1123 ]
  %156 = getelementptr inbounds i64, ptr %22, i64 %.211021176
  %157 = load i64, ptr %156, align 8, !tbaa !5
  %158 = icmp eq i64 %157, %.211021176
  br i1 %158, label %159, label %179

159:                                              ; preds = %.lr.ph1178
  %160 = getelementptr inbounds %struct.complex, ptr %18, i64 %.211021176
  %161 = load float, ptr %160, align 4, !tbaa !9
  %162 = getelementptr %struct.complex, ptr %25, i64 %.211021176
  %163 = getelementptr %struct.complex, ptr %162, i64 %155
  %164 = getelementptr inbounds i8, ptr %160, i64 4
  %165 = load float, ptr %164, align 4, !tbaa !12
  %166 = fneg float %165
  %167 = load <2 x float>, ptr %163, align 4, !tbaa !13
  %168 = insertelement <2 x float> poison, float %165, i64 0
  %169 = insertelement <2 x float> %168, float %166, i64 1
  %170 = fmul <2 x float> %167, %169
  %171 = shufflevector <2 x float> %170, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %172 = insertelement <2 x float> poison, float %161, i64 0
  %173 = shufflevector <2 x float> %172, <2 x float> poison, <2 x i32> zeroinitializer
  %174 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %173, <2 x float> %167, <2 x float> %171)
  store <2 x float> %174, ptr %12, align 8, !tbaa !13
  %175 = getelementptr i8, ptr %162, i64 8
  %176 = getelementptr %struct.complex, ptr %175, i64 %155
  %177 = load <2 x float>, ptr %176, align 4, !tbaa !13
  %178 = fsub <2 x float> %177, %174
  store <2 x float> %178, ptr %11, align 8, !tbaa !13
  store <2 x float> %178, ptr %176, align 4, !tbaa !13
  br label %199

179:                                              ; preds = %.lr.ph1178
  %180 = getelementptr %struct.complex, ptr %25, i64 %.211021176
  %181 = getelementptr %struct.complex, ptr %180, i64 %155
  %182 = getelementptr i8, ptr %180, i64 8
  %183 = getelementptr %struct.complex, ptr %182, i64 %155
  %184 = getelementptr inbounds %struct.complex, ptr %18, i64 %.211021176
  %185 = getelementptr inbounds i8, ptr %184, i64 4
  %186 = load <2 x float>, ptr %181, align 4, !tbaa !13
  %187 = load <2 x float>, ptr %183, align 4, !tbaa !13
  store <2 x float> %187, ptr %181, align 4, !tbaa !13
  %188 = load float, ptr %184, align 4, !tbaa !9
  %189 = load float, ptr %185, align 4, !tbaa !12
  %190 = fneg float %189
  %191 = insertelement <2 x float> poison, float %189, i64 0
  %192 = insertelement <2 x float> %191, float %190, i64 1
  %193 = fmul <2 x float> %187, %192
  %194 = shufflevector <2 x float> %193, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %195 = insertelement <2 x float> poison, float %188, i64 0
  %196 = shufflevector <2 x float> %195, <2 x float> poison, <2 x i32> zeroinitializer
  %197 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %196, <2 x float> %187, <2 x float> %194)
  store <2 x float> %197, ptr %12, align 8, !tbaa !13
  %198 = fsub <2 x float> %186, %197
  store <2 x float> %198, ptr %11, align 8, !tbaa !13
  store <2 x float> %198, ptr %183, align 4, !tbaa !13
  br label %199

199:                                              ; preds = %159, %179
  %200 = add nuw nsw i64 %.211021176, 1
  %exitcond1256.not = icmp eq i64 %200, %154
  br i1 %exitcond1256.not, label %._crit_edge1179, label %.lr.ph1178, !llvm.loop !17

._crit_edge1179:                                  ; preds = %199, %.preheader1123
  %201 = getelementptr %struct.complex, ptr %25, i64 %154
  %202 = getelementptr %struct.complex, ptr %201, i64 %155
  %203 = getelementptr inbounds %struct.complex, ptr %19, i64 %154
  call void @c_div(ptr noundef nonnull %11, ptr noundef %202, ptr noundef nonnull %203) #4
  %204 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %204, ptr %202, align 4, !tbaa !13
  %205 = load i64, ptr %1, align 8, !tbaa !5
  %206 = icmp sgt i64 %205, 1
  br i1 %206, label %207, label %._crit_edge1183

207:                                              ; preds = %._crit_edge1179
  %208 = add nsw i64 %205, -1
  %209 = getelementptr inbounds %struct.complex, ptr %20, i64 %208
  %210 = load float, ptr %209, align 4, !tbaa !9
  %211 = getelementptr %struct.complex, ptr %25, i64 %205
  %212 = getelementptr %struct.complex, ptr %211, i64 %155
  %213 = getelementptr inbounds i8, ptr %209, i64 4
  %214 = load float, ptr %213, align 4, !tbaa !12
  %215 = fneg float %214
  %216 = getelementptr %struct.complex, ptr %25, i64 %208
  %217 = getelementptr %struct.complex, ptr %216, i64 %155
  %218 = load <2 x float>, ptr %212, align 4, !tbaa !13
  %219 = insertelement <2 x float> poison, float %214, i64 0
  %220 = insertelement <2 x float> %219, float %215, i64 1
  %221 = fmul <2 x float> %218, %220
  %222 = shufflevector <2 x float> %221, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %223 = insertelement <2 x float> poison, float %210, i64 0
  %224 = shufflevector <2 x float> %223, <2 x float> poison, <2 x i32> zeroinitializer
  %225 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %224, <2 x float> %218, <2 x float> %222)
  %226 = load <2 x float>, ptr %217, align 4, !tbaa !13
  %227 = fsub <2 x float> %226, %225
  store <2 x float> %227, ptr %12, align 8, !tbaa !13
  %gep1185 = getelementptr %struct.complex, ptr %invariant.gep1196, i64 %205
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef %gep1185) #4
  %228 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %228, ptr %217, align 4, !tbaa !13
  %.pre1270 = load i64, ptr %1, align 8, !tbaa !5
  %229 = icmp sgt i64 %.pre1270, 2
  br i1 %229, label %.lr.ph1182.preheader, label %._crit_edge1183

.lr.ph1182.preheader:                             ; preds = %207
  %230 = add nsw i64 %.pre1270, -2
  br label %.lr.ph1182

.lr.ph1182:                                       ; preds = %.lr.ph1182.preheader, %.lr.ph1182
  %.311031180 = phi i64 [ %268, %.lr.ph1182 ], [ %230, %.lr.ph1182.preheader ]
  %231 = getelementptr inbounds %struct.complex, ptr %20, i64 %.311031180
  %232 = load float, ptr %231, align 4, !tbaa !9
  %233 = getelementptr %struct.complex, ptr %25, i64 %.311031180
  %234 = getelementptr i8, ptr %233, i64 8
  %235 = getelementptr %struct.complex, ptr %234, i64 %155
  %236 = getelementptr inbounds i8, ptr %231, i64 4
  %237 = load float, ptr %236, align 4, !tbaa !12
  %238 = fneg float %237
  %239 = getelementptr %struct.complex, ptr %233, i64 %155
  %240 = getelementptr inbounds %struct.complex, ptr %21, i64 %.311031180
  %241 = load float, ptr %240, align 4, !tbaa !9
  %242 = getelementptr i8, ptr %233, i64 16
  %243 = getelementptr %struct.complex, ptr %242, i64 %155
  %244 = getelementptr inbounds i8, ptr %240, i64 4
  %245 = load float, ptr %244, align 4, !tbaa !12
  %246 = fneg float %245
  %247 = load <2 x float>, ptr %235, align 4, !tbaa !13
  %248 = insertelement <2 x float> poison, float %237, i64 0
  %249 = insertelement <2 x float> %248, float %238, i64 1
  %250 = fmul <2 x float> %247, %249
  %251 = shufflevector <2 x float> %250, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %252 = insertelement <2 x float> poison, float %232, i64 0
  %253 = shufflevector <2 x float> %252, <2 x float> poison, <2 x i32> zeroinitializer
  %254 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %253, <2 x float> %247, <2 x float> %251)
  %255 = load <2 x float>, ptr %239, align 4, !tbaa !13
  %256 = fsub <2 x float> %255, %254
  %257 = load <2 x float>, ptr %243, align 4, !tbaa !13
  %258 = insertelement <2 x float> poison, float %245, i64 0
  %259 = insertelement <2 x float> %258, float %246, i64 1
  %260 = fmul <2 x float> %257, %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 %241, i64 0
  %263 = shufflevector <2 x float> %262, <2 x float> poison, <2 x i32> zeroinitializer
  %264 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %263, <2 x float> %257, <2 x float> %261)
  %265 = fsub <2 x float> %256, %264
  store <2 x float> %265, ptr %12, align 8, !tbaa !13
  %266 = getelementptr inbounds %struct.complex, ptr %19, i64 %.311031180
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %266) #4
  %267 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %267, ptr %239, align 4, !tbaa !13
  %268 = add nsw i64 %.311031180, -1
  %269 = icmp ugt i64 %.311031180, 1
  br i1 %269, label %.lr.ph1182, label %._crit_edge1183, !llvm.loop !18

._crit_edge1183:                                  ; preds = %.lr.ph1182, %._crit_edge1179, %207
  %270 = add nuw i64 %.11186, 1
  %exitcond1257.not = icmp eq i64 %.11186, %29
  br i1 %exitcond1257.not, label %.loopexit, label %.preheader1123, !llvm.loop !19

271:                                              ; preds = %31
  %272 = getelementptr inbounds i8, ptr %5, i64 4
  %273 = getelementptr inbounds i8, ptr %4, i64 8
  br i1 %33, label %.preheader1125, label %.preheader1127

.preheader1125:                                   ; preds = %271, %._crit_edge1174
  %.2 = phi i64 [ %372, %._crit_edge1174 ], [ 1, %271 ]
  %274 = mul nsw i64 %.2, %23
  %275 = getelementptr %struct.complex, ptr %25, i64 %274
  %276 = getelementptr i8, ptr %275, i64 8
  call void @c_div(ptr noundef nonnull %11, ptr noundef %276, ptr noundef %4) #4
  %277 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %277, ptr %276, align 4, !tbaa !13
  %278 = load i64, ptr %1, align 8, !tbaa !5
  %279 = icmp sgt i64 %278, 1
  br i1 %279, label %280, label %._crit_edge1174

280:                                              ; preds = %.preheader1125
  %281 = load float, ptr %5, align 4, !tbaa !9
  %282 = load float, ptr %272, align 4, !tbaa !12
  %283 = fneg float %282
  %284 = getelementptr i8, ptr %275, i64 16
  %285 = insertelement <2 x float> poison, float %282, i64 0
  %286 = insertelement <2 x float> %285, float %283, i64 1
  %287 = fmul <2 x float> %277, %286
  %288 = shufflevector <2 x float> %287, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %289 = insertelement <2 x float> poison, float %281, i64 0
  %290 = shufflevector <2 x float> %289, <2 x float> poison, <2 x i32> zeroinitializer
  %291 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %290, <2 x float> %277, <2 x float> %288)
  %292 = load <2 x float>, ptr %284, align 4, !tbaa !13
  %293 = fsub <2 x float> %292, %291
  store <2 x float> %293, ptr %12, align 8, !tbaa !13
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %273) #4
  %294 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %294, ptr %284, align 4, !tbaa !13
  %.pre1265 = load i64, ptr %1, align 8, !tbaa !5
  %.not11151156 = icmp slt i64 %.pre1265, 3
  br i1 %.not11151156, label %._crit_edge1160, label %.lr.ph1159.preheader

.lr.ph1159.preheader:                             ; preds = %280
  %gep1151.phi.trans.insert = getelementptr i8, ptr %275, i64 16
  %295 = load <2 x float>, ptr %gep1151.phi.trans.insert, align 4, !tbaa !13
  br label %.lr.ph1159

.lr.ph1159:                                       ; preds = %.lr.ph1159.preheader, %.lr.ph1159
  %.411041157 = phi i64 [ %329, %.lr.ph1159 ], [ 3, %.lr.ph1159.preheader ]
  %296 = phi <2 x float> [ %328, %.lr.ph1159 ], [ %295, %.lr.ph1159.preheader ]
  %297 = getelementptr %struct.complex, ptr %20, i64 %.411041157
  %298 = getelementptr i8, ptr %297, i64 -8
  %299 = load float, ptr %298, align 4, !tbaa !9
  %300 = getelementptr i8, ptr %297, i64 -4
  %301 = load float, ptr %300, align 4, !tbaa !12
  %302 = fneg float %301
  %gep1153 = getelementptr %struct.complex, ptr %275, i64 %.411041157
  %303 = add nsw i64 %.411041157, -2
  %304 = getelementptr inbounds %struct.complex, ptr %21, i64 %303
  %305 = load float, ptr %304, align 4, !tbaa !9
  %gep1155 = getelementptr %struct.complex, ptr %275, i64 %303
  %306 = getelementptr inbounds i8, ptr %304, i64 4
  %307 = load float, ptr %306, align 4, !tbaa !12
  %308 = fneg float %307
  %309 = getelementptr inbounds %struct.complex, ptr %19, i64 %.411041157
  %310 = insertelement <2 x float> poison, float %301, i64 0
  %311 = insertelement <2 x float> %310, float %302, i64 1
  %312 = fmul <2 x float> %296, %311
  %313 = shufflevector <2 x float> %312, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %314 = insertelement <2 x float> poison, float %299, i64 0
  %315 = shufflevector <2 x float> %314, <2 x float> poison, <2 x i32> zeroinitializer
  %316 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %315, <2 x float> %296, <2 x float> %313)
  %317 = load <2 x float>, ptr %gep1153, align 4, !tbaa !13
  %318 = fsub <2 x float> %317, %316
  %319 = load <2 x float>, ptr %gep1155, align 4, !tbaa !13
  %320 = insertelement <2 x float> poison, float %307, i64 0
  %321 = insertelement <2 x float> %320, float %308, i64 1
  %322 = fmul <2 x float> %319, %321
  %323 = shufflevector <2 x float> %322, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %324 = insertelement <2 x float> poison, float %305, i64 0
  %325 = shufflevector <2 x float> %324, <2 x float> poison, <2 x i32> zeroinitializer
  %326 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %325, <2 x float> %319, <2 x float> %323)
  %327 = fsub <2 x float> %318, %326
  store <2 x float> %327, ptr %12, align 8, !tbaa !13
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %309) #4
  %328 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %328, ptr %gep1153, align 4, !tbaa !13
  %329 = add nuw i64 %.411041157, 1
  %exitcond1255.not = icmp eq i64 %.411041157, %.pre1265
  br i1 %exitcond1255.not, label %._crit_edge1160.loopexit, label %.lr.ph1159, !llvm.loop !20

._crit_edge1160.loopexit:                         ; preds = %.lr.ph1159
  %.pre1269 = load i64, ptr %1, align 8, !tbaa !5
  br label %._crit_edge1160

._crit_edge1160:                                  ; preds = %._crit_edge1160.loopexit, %280
  %330 = phi i64 [ %.pre1269, %._crit_edge1160.loopexit ], [ %.pre1265, %280 ]
  %331 = icmp sgt i64 %330, 1
  br i1 %331, label %.lr.ph1173, label %._crit_edge1174

.lr.ph1173:                                       ; preds = %._crit_edge1160, %367
  %.51105.in1170 = phi i64 [ %.511051171, %367 ], [ %330, %._crit_edge1160 ]
  %.511051171 = add nsw i64 %.51105.in1170, -1
  %332 = getelementptr inbounds i64, ptr %22, i64 %.511051171
  %333 = load i64, ptr %332, align 8, !tbaa !5
  %334 = icmp eq i64 %333, %.511051171
  %gep1168 = getelementptr %struct.complex, ptr %275, i64 %.511051171
  br i1 %334, label %335, label %351

335:                                              ; preds = %.lr.ph1173
  %336 = getelementptr inbounds %struct.complex, ptr %18, i64 %.511051171
  %337 = load float, ptr %336, align 4, !tbaa !9
  %gep1166 = getelementptr %struct.complex, ptr %275, i64 %.51105.in1170
  %338 = getelementptr inbounds i8, ptr %336, i64 4
  %339 = load float, ptr %338, align 4, !tbaa !12
  %340 = fneg float %339
  %341 = load <2 x float>, ptr %gep1166, align 4, !tbaa !13
  %342 = insertelement <2 x float> poison, float %339, i64 0
  %343 = insertelement <2 x float> %342, float %340, i64 1
  %344 = fmul <2 x float> %341, %343
  %345 = shufflevector <2 x float> %344, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %346 = insertelement <2 x float> poison, float %337, i64 0
  %347 = shufflevector <2 x float> %346, <2 x float> poison, <2 x i32> zeroinitializer
  %348 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %347, <2 x float> %341, <2 x float> %345)
  store <2 x float> %348, ptr %12, align 8, !tbaa !13
  %349 = load <2 x float>, ptr %gep1168, align 4, !tbaa !13
  %350 = fsub <2 x float> %349, %348
  store <2 x float> %350, ptr %11, align 8, !tbaa !13
  br label %367

351:                                              ; preds = %.lr.ph1173
  %gep1162 = getelementptr %struct.complex, ptr %275, i64 %.51105.in1170
  %352 = load <2 x float>, ptr %gep1162, align 4, !tbaa !13
  %353 = getelementptr inbounds %struct.complex, ptr %18, i64 %.511051171
  %354 = load float, ptr %353, align 4, !tbaa !9
  %355 = getelementptr inbounds i8, ptr %353, i64 4
  %356 = load float, ptr %355, align 4, !tbaa !12
  %357 = fneg float %356
  %358 = insertelement <2 x float> poison, float %356, i64 0
  %359 = insertelement <2 x float> %358, float %357, i64 1
  %360 = fmul <2 x float> %352, %359
  %361 = shufflevector <2 x float> %360, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %362 = insertelement <2 x float> poison, float %354, i64 0
  %363 = shufflevector <2 x float> %362, <2 x float> poison, <2 x i32> zeroinitializer
  %364 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %363, <2 x float> %352, <2 x float> %361)
  store <2 x float> %364, ptr %12, align 8, !tbaa !13
  %365 = load <2 x float>, ptr %gep1168, align 4, !tbaa !13
  %366 = fsub <2 x float> %365, %364
  store <2 x float> %366, ptr %11, align 8, !tbaa !13
  store <2 x float> %366, ptr %gep1162, align 4, !tbaa !13
  br label %367

367:                                              ; preds = %335, %351
  %368 = phi <2 x float> [ %350, %335 ], [ %352, %351 ]
  store <2 x float> %368, ptr %gep1168, align 4, !tbaa !13
  %369 = icmp ugt i64 %.51105.in1170, 2
  br i1 %369, label %.lr.ph1173, label %._crit_edge1174, !llvm.loop !21

._crit_edge1174:                                  ; preds = %367, %.preheader1125, %._crit_edge1160
  %370 = load i64, ptr %2, align 8, !tbaa !5
  %371 = icmp slt i64 %.2, %370
  %372 = add nuw nsw i64 %.2, 1
  br i1 %371, label %.preheader1125, label %.loopexit

.preheader1127:                                   ; preds = %271, %._crit_edge1148
  %.31149 = phi i64 [ %469, %._crit_edge1148 ], [ 1, %271 ]
  %373 = mul nsw i64 %.31149, %23
  %374 = getelementptr %struct.complex, ptr %25, i64 %373
  %375 = getelementptr i8, ptr %374, i64 8
  call void @c_div(ptr noundef nonnull %11, ptr noundef %375, ptr noundef %4) #4
  %376 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %376, ptr %375, align 4, !tbaa !13
  %377 = load i64, ptr %1, align 8, !tbaa !5
  %378 = icmp sgt i64 %377, 1
  br i1 %378, label %379, label %._crit_edge1148

379:                                              ; preds = %.preheader1127
  %380 = load float, ptr %5, align 4, !tbaa !9
  %381 = load float, ptr %272, align 4, !tbaa !12
  %382 = fneg float %381
  %383 = getelementptr i8, ptr %374, i64 16
  %384 = insertelement <2 x float> poison, float %381, i64 0
  %385 = insertelement <2 x float> %384, float %382, i64 1
  %386 = fmul <2 x float> %376, %385
  %387 = shufflevector <2 x float> %386, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %388 = insertelement <2 x float> poison, float %380, i64 0
  %389 = shufflevector <2 x float> %388, <2 x float> poison, <2 x i32> zeroinitializer
  %390 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %389, <2 x float> %376, <2 x float> %387)
  %391 = load <2 x float>, ptr %383, align 4, !tbaa !13
  %392 = fsub <2 x float> %391, %390
  store <2 x float> %392, ptr %12, align 8, !tbaa !13
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %273) #4
  %393 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %393, ptr %383, align 4, !tbaa !13
  %.pre = load i64, ptr %1, align 8, !tbaa !5
  %.not11141133 = icmp slt i64 %.pre, 3
  br i1 %.not11141133, label %._crit_edge, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %379
  %gep.phi.trans.insert = getelementptr i8, ptr %374, i64 16
  %394 = load <2 x float>, ptr %gep.phi.trans.insert, align 4, !tbaa !13
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader, %.lr.ph
  %.61134 = phi i64 [ %428, %.lr.ph ], [ 3, %.lr.ph.preheader ]
  %395 = phi <2 x float> [ %427, %.lr.ph ], [ %394, %.lr.ph.preheader ]
  %396 = getelementptr %struct.complex, ptr %20, i64 %.61134
  %397 = getelementptr i8, ptr %396, i64 -8
  %398 = load float, ptr %397, align 4, !tbaa !9
  %399 = getelementptr i8, ptr %396, i64 -4
  %400 = load float, ptr %399, align 4, !tbaa !12
  %401 = fneg float %400
  %gep1130 = getelementptr %struct.complex, ptr %374, i64 %.61134
  %402 = add nsw i64 %.61134, -2
  %403 = getelementptr inbounds %struct.complex, ptr %21, i64 %402
  %404 = load float, ptr %403, align 4, !tbaa !9
  %gep1132 = getelementptr %struct.complex, ptr %374, i64 %402
  %405 = getelementptr inbounds i8, ptr %403, i64 4
  %406 = load float, ptr %405, align 4, !tbaa !12
  %407 = fneg float %406
  %408 = getelementptr inbounds %struct.complex, ptr %19, i64 %.61134
  %409 = insertelement <2 x float> poison, float %400, i64 0
  %410 = insertelement <2 x float> %409, float %401, i64 1
  %411 = fmul <2 x float> %395, %410
  %412 = shufflevector <2 x float> %411, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %413 = insertelement <2 x float> poison, float %398, i64 0
  %414 = shufflevector <2 x float> %413, <2 x float> poison, <2 x i32> zeroinitializer
  %415 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %414, <2 x float> %395, <2 x float> %412)
  %416 = load <2 x float>, ptr %gep1130, align 4, !tbaa !13
  %417 = fsub <2 x float> %416, %415
  %418 = load <2 x float>, ptr %gep1132, align 4, !tbaa !13
  %419 = insertelement <2 x float> poison, float %406, i64 0
  %420 = insertelement <2 x float> %419, float %407, i64 1
  %421 = fmul <2 x float> %418, %420
  %422 = shufflevector <2 x float> %421, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %423 = insertelement <2 x float> poison, float %404, i64 0
  %424 = shufflevector <2 x float> %423, <2 x float> poison, <2 x i32> zeroinitializer
  %425 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %424, <2 x float> %418, <2 x float> %422)
  %426 = fsub <2 x float> %417, %425
  store <2 x float> %426, ptr %12, align 8, !tbaa !13
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %408) #4
  %427 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %427, ptr %gep1130, align 4, !tbaa !13
  %428 = add nuw i64 %.61134, 1
  %exitcond.not = icmp eq i64 %.61134, %.pre
  br i1 %exitcond.not, label %._crit_edge.loopexit, label %.lr.ph, !llvm.loop !22

._crit_edge.loopexit:                             ; preds = %.lr.ph
  %.pre1264 = load i64, ptr %1, align 8, !tbaa !5
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %379
  %429 = phi i64 [ %.pre1264, %._crit_edge.loopexit ], [ %.pre, %379 ]
  %430 = icmp sgt i64 %429, 1
  br i1 %430, label %.lr.ph1147, label %._crit_edge1148

.lr.ph1147:                                       ; preds = %._crit_edge, %466
  %.7.in1144 = phi i64 [ %.71145, %466 ], [ %429, %._crit_edge ]
  %.71145 = add nsw i64 %.7.in1144, -1
  %431 = getelementptr inbounds i64, ptr %22, i64 %.71145
  %432 = load i64, ptr %431, align 8, !tbaa !5
  %433 = icmp eq i64 %432, %.71145
  %gep1142 = getelementptr %struct.complex, ptr %374, i64 %.71145
  br i1 %433, label %434, label %450

434:                                              ; preds = %.lr.ph1147
  %435 = getelementptr inbounds %struct.complex, ptr %18, i64 %.71145
  %436 = load float, ptr %435, align 4, !tbaa !9
  %gep1140 = getelementptr %struct.complex, ptr %374, i64 %.7.in1144
  %437 = getelementptr inbounds i8, ptr %435, i64 4
  %438 = load float, ptr %437, align 4, !tbaa !12
  %439 = fneg float %438
  %440 = load <2 x float>, ptr %gep1140, align 4, !tbaa !13
  %441 = insertelement <2 x float> poison, float %438, i64 0
  %442 = insertelement <2 x float> %441, float %439, i64 1
  %443 = fmul <2 x float> %440, %442
  %444 = shufflevector <2 x float> %443, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %445 = insertelement <2 x float> poison, float %436, i64 0
  %446 = shufflevector <2 x float> %445, <2 x float> poison, <2 x i32> zeroinitializer
  %447 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %446, <2 x float> %440, <2 x float> %444)
  store <2 x float> %447, ptr %12, align 8, !tbaa !13
  %448 = load <2 x float>, ptr %gep1142, align 4, !tbaa !13
  %449 = fsub <2 x float> %448, %447
  store <2 x float> %449, ptr %11, align 8, !tbaa !13
  br label %466

450:                                              ; preds = %.lr.ph1147
  %gep1136 = getelementptr %struct.complex, ptr %374, i64 %.7.in1144
  %451 = load <2 x float>, ptr %gep1136, align 4, !tbaa !13
  %452 = getelementptr inbounds %struct.complex, ptr %18, i64 %.71145
  %453 = load float, ptr %452, align 4, !tbaa !9
  %454 = getelementptr inbounds i8, ptr %452, i64 4
  %455 = load float, ptr %454, align 4, !tbaa !12
  %456 = fneg float %455
  %457 = insertelement <2 x float> poison, float %455, i64 0
  %458 = insertelement <2 x float> %457, float %456, i64 1
  %459 = fmul <2 x float> %451, %458
  %460 = shufflevector <2 x float> %459, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %461 = insertelement <2 x float> poison, float %453, i64 0
  %462 = shufflevector <2 x float> %461, <2 x float> poison, <2 x i32> zeroinitializer
  %463 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %462, <2 x float> %451, <2 x float> %460)
  store <2 x float> %463, ptr %12, align 8, !tbaa !13
  %464 = load <2 x float>, ptr %gep1142, align 4, !tbaa !13
  %465 = fsub <2 x float> %464, %463
  store <2 x float> %465, ptr %11, align 8, !tbaa !13
  store <2 x float> %465, ptr %gep1136, align 4, !tbaa !13
  br label %466

466:                                              ; preds = %434, %450
  %467 = phi <2 x float> [ %449, %434 ], [ %451, %450 ]
  store <2 x float> %467, ptr %gep1142, align 4, !tbaa !13
  %468 = icmp ugt i64 %.7.in1144, 2
  br i1 %468, label %.lr.ph1147, label %._crit_edge1148, !llvm.loop !23

._crit_edge1148:                                  ; preds = %466, %.preheader1127, %._crit_edge
  %469 = add nuw i64 %.31149, 1
  %exitcond1254.not = icmp eq i64 %.31149, %29
  br i1 %exitcond1254.not, label %.loopexit, label %.preheader1127, !llvm.loop !24

470:                                              ; preds = %31
  %471 = getelementptr inbounds i8, ptr %14, i64 4
  %472 = getelementptr inbounds i8, ptr %13, i64 4
  %473 = getelementptr inbounds i8, ptr %4, i64 8
  %474 = getelementptr inbounds i8, ptr %15, i64 4
  %475 = getelementptr inbounds i8, ptr %16, i64 4
  br i1 %33, label %.preheader, label %.preheader1119

.preheader:                                       ; preds = %470, %._crit_edge1248
  %.4 = phi i64 [ %571, %._crit_edge1248 ], [ 1, %470 ]
  %476 = mul nsw i64 %.4, %23
  call void @r_cnjg(ptr noundef nonnull %12, ptr noundef %4) #4
  %477 = getelementptr %struct.complex, ptr %25, i64 %476
  %478 = getelementptr i8, ptr %477, i64 8
  call void @c_div(ptr noundef nonnull %11, ptr noundef %478, ptr noundef nonnull %12) #4
  %479 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %479, ptr %478, align 4, !tbaa !13
  %480 = load i64, ptr %1, align 8, !tbaa !5
  %481 = icmp sgt i64 %480, 1
  br i1 %481, label %482, label %._crit_edge1248

482:                                              ; preds = %.preheader
  call void @r_cnjg(ptr noundef nonnull %14, ptr noundef %5) #4
  %483 = load float, ptr %14, align 8, !tbaa !9
  %484 = load float, ptr %471, align 4, !tbaa !12
  %485 = fneg float %484
  %486 = load <2 x float>, ptr %478, align 4, !tbaa !13
  %487 = insertelement <2 x float> poison, float %484, i64 0
  %488 = insertelement <2 x float> %487, float %485, i64 1
  %489 = fmul <2 x float> %486, %488
  %490 = shufflevector <2 x float> %489, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %491 = insertelement <2 x float> poison, float %483, i64 0
  %492 = shufflevector <2 x float> %491, <2 x float> poison, <2 x i32> zeroinitializer
  %493 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %492, <2 x float> %486, <2 x float> %490)
  store <2 x float> %493, ptr %13, align 8, !tbaa !13
  %494 = getelementptr i8, ptr %477, i64 16
  %495 = load <2 x float>, ptr %494, align 4, !tbaa !13
  %496 = fsub <2 x float> %495, %493
  store <2 x float> %496, ptr %12, align 8, !tbaa !13
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %473) #4
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %15) #4
  %497 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %497, ptr %494, align 4, !tbaa !13
  %.pre1274 = load i64, ptr %1, align 8, !tbaa !5
  %.not11121230 = icmp slt i64 %.pre1274, 3
  br i1 %.not11121230, label %._crit_edge1234, label %.lr.ph1233

.lr.ph1233:                                       ; preds = %482, %.lr.ph1233
  %.81231 = phi i64 [ %530, %.lr.ph1233 ], [ 3, %482 ]
  %498 = add nsw i64 %.81231, -1
  %499 = getelementptr inbounds %struct.complex, ptr %20, i64 %498
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %499) #4
  %500 = load float, ptr %15, align 4, !tbaa !9
  %gep1225 = getelementptr %struct.complex, ptr %477, i64 %498
  %501 = load float, ptr %474, align 4, !tbaa !12
  %502 = fneg float %501
  %503 = load <2 x float>, ptr %gep1225, align 4, !tbaa !13
  %504 = insertelement <2 x float> poison, float %501, i64 0
  %505 = insertelement <2 x float> %504, float %502, i64 1
  %506 = fmul <2 x float> %503, %505
  %507 = shufflevector <2 x float> %506, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %508 = insertelement <2 x float> poison, float %500, i64 0
  %509 = shufflevector <2 x float> %508, <2 x float> poison, <2 x i32> zeroinitializer
  %510 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %509, <2 x float> %503, <2 x float> %507)
  store <2 x float> %510, ptr %14, align 8, !tbaa !13
  %gep1227 = getelementptr %struct.complex, ptr %477, i64 %.81231
  %511 = load <2 x float>, ptr %gep1227, align 4, !tbaa !13
  %512 = fsub <2 x float> %511, %510
  store <2 x float> %512, ptr %13, align 8, !tbaa !13
  %513 = add nsw i64 %.81231, -2
  %514 = getelementptr inbounds %struct.complex, ptr %21, i64 %513
  call void @r_cnjg(ptr noundef nonnull %16, ptr noundef nonnull %514) #4
  %515 = load float, ptr %16, align 4, !tbaa !9
  %gep1229 = getelementptr %struct.complex, ptr %477, i64 %513
  %516 = load float, ptr %475, align 4, !tbaa !12
  %517 = fneg float %516
  %518 = load <2 x float>, ptr %gep1229, align 4, !tbaa !13
  %519 = insertelement <2 x float> poison, float %516, i64 0
  %520 = insertelement <2 x float> %519, float %517, i64 1
  %521 = fmul <2 x float> %518, %520
  %522 = shufflevector <2 x float> %521, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %523 = insertelement <2 x float> poison, float %515, i64 0
  %524 = shufflevector <2 x float> %523, <2 x float> poison, <2 x i32> zeroinitializer
  %525 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %524, <2 x float> %518, <2 x float> %522)
  %526 = load <2 x float>, ptr %13, align 8, !tbaa !13
  %527 = fsub <2 x float> %526, %525
  store <2 x float> %527, ptr %12, align 8, !tbaa !13
  %528 = getelementptr inbounds %struct.complex, ptr %19, i64 %.81231
  call void @r_cnjg(ptr noundef nonnull %17, ptr noundef nonnull %528) #4
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %17) #4
  %529 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %529, ptr %gep1227, align 4, !tbaa !13
  %530 = add nuw i64 %.81231, 1
  %exitcond1261.not = icmp eq i64 %.81231, %.pre1274
  br i1 %exitcond1261.not, label %._crit_edge1234.loopexit, label %.lr.ph1233, !llvm.loop !25

._crit_edge1234.loopexit:                         ; preds = %.lr.ph1233
  %.pre1275 = load i64, ptr %1, align 8, !tbaa !5
  br label %._crit_edge1234

._crit_edge1234:                                  ; preds = %._crit_edge1234.loopexit, %482
  %531 = phi i64 [ %.pre1275, %._crit_edge1234.loopexit ], [ %.pre1274, %482 ]
  %532 = icmp sgt i64 %531, 1
  br i1 %532, label %.lr.ph1247, label %._crit_edge1248

.lr.ph1247:                                       ; preds = %._crit_edge1234, %566
  %.9.in1244 = phi i64 [ %.91245, %566 ], [ %531, %._crit_edge1234 ]
  %.91245 = add nsw i64 %.9.in1244, -1
  %533 = getelementptr inbounds i64, ptr %22, i64 %.91245
  %534 = load i64, ptr %533, align 8, !tbaa !5
  %535 = icmp eq i64 %534, %.91245
  %gep1242 = getelementptr %struct.complex, ptr %477, i64 %.91245
  br i1 %535, label %536, label %551

536:                                              ; preds = %.lr.ph1247
  %537 = getelementptr inbounds %struct.complex, ptr %18, i64 %.91245
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef nonnull %537) #4
  %538 = load float, ptr %13, align 8, !tbaa !9
  %gep1240 = getelementptr %struct.complex, ptr %477, i64 %.9.in1244
  %539 = load float, ptr %472, align 4, !tbaa !12
  %540 = fneg float %539
  %541 = load <2 x float>, ptr %gep1240, align 4, !tbaa !13
  %542 = insertelement <2 x float> poison, float %539, i64 0
  %543 = insertelement <2 x float> %542, float %540, i64 1
  %544 = fmul <2 x float> %541, %543
  %545 = shufflevector <2 x float> %544, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %546 = insertelement <2 x float> poison, float %538, i64 0
  %547 = shufflevector <2 x float> %546, <2 x float> poison, <2 x i32> zeroinitializer
  %548 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %547, <2 x float> %541, <2 x float> %545)
  store <2 x float> %548, ptr %12, align 8, !tbaa !13
  %549 = load <2 x float>, ptr %gep1242, align 4, !tbaa !13
  %550 = fsub <2 x float> %549, %548
  store <2 x float> %550, ptr %11, align 8, !tbaa !13
  br label %566

551:                                              ; preds = %.lr.ph1247
  %gep1236 = getelementptr %struct.complex, ptr %477, i64 %.9.in1244
  %552 = load <2 x float>, ptr %gep1236, align 4, !tbaa !13
  %553 = getelementptr inbounds %struct.complex, ptr %18, i64 %.91245
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef nonnull %553) #4
  %554 = load float, ptr %13, align 8, !tbaa !9
  %555 = load float, ptr %472, align 4, !tbaa !12
  %556 = fneg float %555
  %557 = insertelement <2 x float> poison, float %555, i64 0
  %558 = insertelement <2 x float> %557, float %556, i64 1
  %559 = fmul <2 x float> %552, %558
  %560 = shufflevector <2 x float> %559, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %561 = insertelement <2 x float> poison, float %554, i64 0
  %562 = shufflevector <2 x float> %561, <2 x float> poison, <2 x i32> zeroinitializer
  %563 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %562, <2 x float> %552, <2 x float> %560)
  store <2 x float> %563, ptr %12, align 8, !tbaa !13
  %564 = load <2 x float>, ptr %gep1242, align 4, !tbaa !13
  %565 = fsub <2 x float> %564, %563
  store <2 x float> %565, ptr %11, align 8, !tbaa !13
  store <2 x float> %565, ptr %gep1236, align 4, !tbaa !13
  br label %566

566:                                              ; preds = %536, %551
  %567 = phi <2 x float> [ %550, %536 ], [ %552, %551 ]
  store <2 x float> %567, ptr %gep1242, align 4, !tbaa !13
  %568 = icmp ugt i64 %.9.in1244, 2
  br i1 %568, label %.lr.ph1247, label %._crit_edge1248, !llvm.loop !26

._crit_edge1248:                                  ; preds = %566, %.preheader, %._crit_edge1234
  %569 = load i64, ptr %2, align 8, !tbaa !5
  %570 = icmp slt i64 %.4, %569
  %571 = add nuw nsw i64 %.4, 1
  br i1 %570, label %.preheader, label %.loopexit

.preheader1119:                                   ; preds = %470, %._crit_edge1222
  %.51223 = phi i64 [ %665, %._crit_edge1222 ], [ 1, %470 ]
  %572 = mul nsw i64 %.51223, %23
  call void @r_cnjg(ptr noundef nonnull %12, ptr noundef %4) #4
  %573 = getelementptr %struct.complex, ptr %25, i64 %572
  %574 = getelementptr i8, ptr %573, i64 8
  call void @c_div(ptr noundef nonnull %11, ptr noundef %574, ptr noundef nonnull %12) #4
  %575 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %575, ptr %574, align 4, !tbaa !13
  %576 = load i64, ptr %1, align 8, !tbaa !5
  %577 = icmp sgt i64 %576, 1
  br i1 %577, label %578, label %._crit_edge1222

578:                                              ; preds = %.preheader1119
  call void @r_cnjg(ptr noundef nonnull %14, ptr noundef %5) #4
  %579 = load float, ptr %14, align 8, !tbaa !9
  %580 = load float, ptr %471, align 4, !tbaa !12
  %581 = fneg float %580
  %582 = load <2 x float>, ptr %574, align 4, !tbaa !13
  %583 = insertelement <2 x float> poison, float %580, i64 0
  %584 = insertelement <2 x float> %583, float %581, i64 1
  %585 = fmul <2 x float> %582, %584
  %586 = shufflevector <2 x float> %585, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %587 = insertelement <2 x float> poison, float %579, i64 0
  %588 = shufflevector <2 x float> %587, <2 x float> poison, <2 x i32> zeroinitializer
  %589 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %588, <2 x float> %582, <2 x float> %586)
  store <2 x float> %589, ptr %13, align 8, !tbaa !13
  %590 = getelementptr i8, ptr %573, i64 16
  %591 = load <2 x float>, ptr %590, align 4, !tbaa !13
  %592 = fsub <2 x float> %591, %589
  store <2 x float> %592, ptr %12, align 8, !tbaa !13
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %473) #4
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %15) #4
  %593 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %593, ptr %590, align 4, !tbaa !13
  %.pre1272 = load i64, ptr %1, align 8, !tbaa !5
  %.not11111204 = icmp slt i64 %.pre1272, 3
  br i1 %.not11111204, label %._crit_edge1208, label %.lr.ph1207

.lr.ph1207:                                       ; preds = %578, %.lr.ph1207
  %.101205 = phi i64 [ %626, %.lr.ph1207 ], [ 3, %578 ]
  %594 = add nsw i64 %.101205, -1
  %595 = getelementptr inbounds %struct.complex, ptr %20, i64 %594
  call void @r_cnjg(ptr noundef nonnull %15, ptr noundef nonnull %595) #4
  %596 = load float, ptr %15, align 4, !tbaa !9
  %gep1199 = getelementptr %struct.complex, ptr %573, i64 %594
  %597 = load float, ptr %474, align 4, !tbaa !12
  %598 = fneg float %597
  %599 = load <2 x float>, ptr %gep1199, align 4, !tbaa !13
  %600 = insertelement <2 x float> poison, float %597, i64 0
  %601 = insertelement <2 x float> %600, float %598, i64 1
  %602 = fmul <2 x float> %599, %601
  %603 = shufflevector <2 x float> %602, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %604 = insertelement <2 x float> poison, float %596, i64 0
  %605 = shufflevector <2 x float> %604, <2 x float> poison, <2 x i32> zeroinitializer
  %606 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %605, <2 x float> %599, <2 x float> %603)
  store <2 x float> %606, ptr %14, align 8, !tbaa !13
  %gep1201 = getelementptr %struct.complex, ptr %573, i64 %.101205
  %607 = load <2 x float>, ptr %gep1201, align 4, !tbaa !13
  %608 = fsub <2 x float> %607, %606
  store <2 x float> %608, ptr %13, align 8, !tbaa !13
  %609 = add nsw i64 %.101205, -2
  %610 = getelementptr inbounds %struct.complex, ptr %21, i64 %609
  call void @r_cnjg(ptr noundef nonnull %16, ptr noundef nonnull %610) #4
  %611 = load float, ptr %16, align 4, !tbaa !9
  %gep1203 = getelementptr %struct.complex, ptr %573, i64 %609
  %612 = load float, ptr %475, align 4, !tbaa !12
  %613 = fneg float %612
  %614 = load <2 x float>, ptr %gep1203, align 4, !tbaa !13
  %615 = insertelement <2 x float> poison, float %612, i64 0
  %616 = insertelement <2 x float> %615, float %613, i64 1
  %617 = fmul <2 x float> %614, %616
  %618 = shufflevector <2 x float> %617, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %619 = insertelement <2 x float> poison, float %611, i64 0
  %620 = shufflevector <2 x float> %619, <2 x float> poison, <2 x i32> zeroinitializer
  %621 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %620, <2 x float> %614, <2 x float> %618)
  %622 = load <2 x float>, ptr %13, align 8, !tbaa !13
  %623 = fsub <2 x float> %622, %621
  store <2 x float> %623, ptr %12, align 8, !tbaa !13
  %624 = getelementptr inbounds %struct.complex, ptr %19, i64 %.101205
  call void @r_cnjg(ptr noundef nonnull %17, ptr noundef nonnull %624) #4
  call void @c_div(ptr noundef nonnull %11, ptr noundef nonnull %12, ptr noundef nonnull %17) #4
  %625 = load <2 x float>, ptr %11, align 8, !tbaa !13
  store <2 x float> %625, ptr %gep1201, align 4, !tbaa !13
  %626 = add nuw i64 %.101205, 1
  %exitcond1259.not = icmp eq i64 %.101205, %.pre1272
  br i1 %exitcond1259.not, label %._crit_edge1208.loopexit, label %.lr.ph1207, !llvm.loop !27

._crit_edge1208.loopexit:                         ; preds = %.lr.ph1207
  %.pre1273 = load i64, ptr %1, align 8, !tbaa !5
  br label %._crit_edge1208

._crit_edge1208:                                  ; preds = %._crit_edge1208.loopexit, %578
  %627 = phi i64 [ %.pre1273, %._crit_edge1208.loopexit ], [ %.pre1272, %578 ]
  %628 = icmp sgt i64 %627, 1
  br i1 %628, label %.lr.ph1221, label %._crit_edge1222

.lr.ph1221:                                       ; preds = %._crit_edge1208, %662
  %.11.in1218 = phi i64 [ %.111219, %662 ], [ %627, %._crit_edge1208 ]
  %.111219 = add nsw i64 %.11.in1218, -1
  %629 = getelementptr inbounds i64, ptr %22, i64 %.111219
  %630 = load i64, ptr %629, align 8, !tbaa !5
  %631 = icmp eq i64 %630, %.111219
  %gep1216 = getelementptr %struct.complex, ptr %573, i64 %.111219
  br i1 %631, label %632, label %647

632:                                              ; preds = %.lr.ph1221
  %633 = getelementptr inbounds %struct.complex, ptr %18, i64 %.111219
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef nonnull %633) #4
  %634 = load float, ptr %13, align 8, !tbaa !9
  %gep1214 = getelementptr %struct.complex, ptr %573, i64 %.11.in1218
  %635 = load float, ptr %472, align 4, !tbaa !12
  %636 = fneg float %635
  %637 = load <2 x float>, ptr %gep1214, align 4, !tbaa !13
  %638 = insertelement <2 x float> poison, float %635, i64 0
  %639 = insertelement <2 x float> %638, float %636, i64 1
  %640 = fmul <2 x float> %637, %639
  %641 = shufflevector <2 x float> %640, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %642 = insertelement <2 x float> poison, float %634, i64 0
  %643 = shufflevector <2 x float> %642, <2 x float> poison, <2 x i32> zeroinitializer
  %644 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %643, <2 x float> %637, <2 x float> %641)
  store <2 x float> %644, ptr %12, align 8, !tbaa !13
  %645 = load <2 x float>, ptr %gep1216, align 4, !tbaa !13
  %646 = fsub <2 x float> %645, %644
  store <2 x float> %646, ptr %11, align 8, !tbaa !13
  br label %662

647:                                              ; preds = %.lr.ph1221
  %gep1210 = getelementptr %struct.complex, ptr %573, i64 %.11.in1218
  %648 = load <2 x float>, ptr %gep1210, align 4, !tbaa !13
  %649 = getelementptr inbounds %struct.complex, ptr %18, i64 %.111219
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef nonnull %649) #4
  %650 = load float, ptr %13, align 8, !tbaa !9
  %651 = load float, ptr %472, align 4, !tbaa !12
  %652 = fneg float %651
  %653 = insertelement <2 x float> poison, float %651, i64 0
  %654 = insertelement <2 x float> %653, float %652, i64 1
  %655 = fmul <2 x float> %648, %654
  %656 = shufflevector <2 x float> %655, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %657 = insertelement <2 x float> poison, float %650, i64 0
  %658 = shufflevector <2 x float> %657, <2 x float> poison, <2 x i32> zeroinitializer
  %659 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %658, <2 x float> %648, <2 x float> %656)
  store <2 x float> %659, ptr %12, align 8, !tbaa !13
  %660 = load <2 x float>, ptr %gep1216, align 4, !tbaa !13
  %661 = fsub <2 x float> %660, %659
  store <2 x float> %661, ptr %11, align 8, !tbaa !13
  store <2 x float> %661, ptr %gep1210, align 4, !tbaa !13
  br label %662

662:                                              ; preds = %632, %647
  %663 = phi <2 x float> [ %646, %632 ], [ %648, %647 ]
  store <2 x float> %663, ptr %gep1216, align 4, !tbaa !13
  %664 = icmp ugt i64 %.11.in1218, 2
  br i1 %664, label %.lr.ph1221, label %._crit_edge1222, !llvm.loop !28

._crit_edge1222:                                  ; preds = %662, %.preheader1119, %._crit_edge1208
  %665 = add nuw i64 %.51223, 1
  %exitcond1260.not = icmp eq i64 %.51223, %29
  br i1 %exitcond1260.not, label %.loopexit, label %.preheader1119, !llvm.loop !29

.loopexit:                                        ; preds = %._crit_edge1148, %._crit_edge1174, %._crit_edge1183, %._crit_edge1195, %._crit_edge1222, %._crit_edge1248, %10, %28
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %17) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %16) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %12) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #4
  ret i32 0
}

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

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

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x float> @llvm.fmuladd.v2f32(<2 x float>, <2 x float>, <2 x float>) #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 = !{!"long", !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}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = distinct !{!17, !15}
!18 = distinct !{!18, !15}
!19 = distinct !{!19, !15}
!20 = distinct !{!20, !15}
!21 = distinct !{!21, !15}
!22 = distinct !{!22, !15}
!23 = distinct !{!23, !15}
!24 = distinct !{!24, !15}
!25 = distinct !{!25, !15}
!26 = distinct !{!26, !15}
!27 = distinct !{!27, !15}
!28 = distinct !{!28, !15}
!29 = distinct !{!29, !15}


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