; LLVM IR from niuyishuai/PDCABB :: LAPACK_BLAS/BLAS/SRC (csymm)

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

%struct.complex = type { float, float }

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

; Function Attrs: nounwind uwtable
define dso_local i32 @f2c_csymm(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9, ptr noundef %10, ptr noundef %11) #0 {
  %13 = alloca i32, align 4
  %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 ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, 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 i64, align 8
  %33 = alloca i64, align 8
  %34 = alloca i64, align 8
  %35 = alloca i64, align 8
  %36 = alloca i64, align 8
  %37 = alloca i64, align 8
  %38 = alloca %struct.complex, align 4
  %39 = alloca %struct.complex, align 4
  %40 = alloca %struct.complex, align 4
  %41 = alloca %struct.complex, align 4
  %42 = alloca %struct.complex, align 4
  %43 = alloca i64, align 8
  %44 = alloca i64, align 8
  %45 = alloca i64, align 8
  %46 = alloca i64, align 8
  %47 = alloca %struct.complex, align 4
  %48 = alloca %struct.complex, align 4
  %49 = alloca i64, align 8
  %50 = alloca i64, align 8
  %51 = alloca i32, align 4
  store ptr %0, ptr %14, align 8, !tbaa !5
  store ptr %1, ptr %15, align 8, !tbaa !5
  store ptr %2, ptr %16, align 8, !tbaa !5
  store ptr %3, ptr %17, align 8, !tbaa !5
  store ptr %4, ptr %18, align 8, !tbaa !5
  store ptr %5, ptr %19, align 8, !tbaa !5
  store ptr %6, ptr %20, align 8, !tbaa !5
  store ptr %7, ptr %21, align 8, !tbaa !5
  store ptr %8, ptr %22, align 8, !tbaa !5
  store ptr %9, ptr %23, align 8, !tbaa !5
  store ptr %10, ptr %24, align 8, !tbaa !5
  store ptr %11, ptr %25, align 8, !tbaa !5
  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
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #4
  %52 = load ptr, ptr %20, align 8, !tbaa !5
  %53 = load i64, ptr %52, align 8, !tbaa !9
  store i64 %53, ptr %26, align 8, !tbaa !9
  %54 = load i64, ptr %26, align 8, !tbaa !9
  %55 = add nsw i64 1, %54
  store i64 %55, ptr %27, align 8, !tbaa !9
  %56 = load i64, ptr %27, align 8, !tbaa !9
  %57 = load ptr, ptr %19, align 8, !tbaa !5
  %58 = sub i64 0, %56
  %59 = getelementptr inbounds %struct.complex, ptr %57, i64 %58
  store ptr %59, ptr %19, align 8, !tbaa !5
  %60 = load ptr, ptr %22, align 8, !tbaa !5
  %61 = load i64, ptr %60, align 8, !tbaa !9
  store i64 %61, ptr %28, align 8, !tbaa !9
  %62 = load i64, ptr %28, align 8, !tbaa !9
  %63 = add nsw i64 1, %62
  store i64 %63, ptr %29, align 8, !tbaa !9
  %64 = load i64, ptr %29, align 8, !tbaa !9
  %65 = load ptr, ptr %21, align 8, !tbaa !5
  %66 = sub i64 0, %64
  %67 = getelementptr inbounds %struct.complex, ptr %65, i64 %66
  store ptr %67, ptr %21, align 8, !tbaa !5
  %68 = load ptr, ptr %25, align 8, !tbaa !5
  %69 = load i64, ptr %68, align 8, !tbaa !9
  store i64 %69, ptr %30, align 8, !tbaa !9
  %70 = load i64, ptr %30, align 8, !tbaa !9
  %71 = add nsw i64 1, %70
  store i64 %71, ptr %31, align 8, !tbaa !9
  %72 = load i64, ptr %31, align 8, !tbaa !9
  %73 = load ptr, ptr %24, align 8, !tbaa !5
  %74 = sub i64 0, %72
  %75 = getelementptr inbounds %struct.complex, ptr %73, i64 %74
  store ptr %75, ptr %24, align 8, !tbaa !5
  %76 = load ptr, ptr %14, align 8, !tbaa !5
  %77 = call i64 @lsame_(ptr noundef %76, ptr noundef @.str)
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %79, label %82

79:                                               ; preds = %12
  %80 = load ptr, ptr %16, align 8, !tbaa !5
  %81 = load i64, ptr %80, align 8, !tbaa !9
  store i64 %81, ptr %49, align 8, !tbaa !9
  br label %85

82:                                               ; preds = %12
  %83 = load ptr, ptr %17, align 8, !tbaa !5
  %84 = load i64, ptr %83, align 8, !tbaa !9
  store i64 %84, ptr %49, align 8, !tbaa !9
  br label %85

85:                                               ; preds = %82, %79
  %86 = load ptr, ptr %15, align 8, !tbaa !5
  %87 = call i64 @lsame_(ptr noundef %86, ptr noundef @.str.1)
  store i64 %87, ptr %50, align 8, !tbaa !9
  store i64 0, ptr %46, align 8, !tbaa !9
  %88 = load ptr, ptr %14, align 8, !tbaa !5
  %89 = call i64 @lsame_(ptr noundef %88, ptr noundef @.str)
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %96, label %91

91:                                               ; preds = %85
  %92 = load ptr, ptr %14, align 8, !tbaa !5
  %93 = call i64 @lsame_(ptr noundef %92, ptr noundef @.str.2)
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %96, label %95

95:                                               ; preds = %91
  store i64 1, ptr %46, align 8, !tbaa !9
  br label %160

96:                                               ; preds = %91, %85
  %97 = load i64, ptr %50, align 8, !tbaa !9
  %98 = icmp ne i64 %97, 0
  br i1 %98, label %104, label %99

99:                                               ; preds = %96
  %100 = load ptr, ptr %15, align 8, !tbaa !5
  %101 = call i64 @lsame_(ptr noundef %100, ptr noundef @.str)
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %104, label %103

103:                                              ; preds = %99
  store i64 2, ptr %46, align 8, !tbaa !9
  br label %159

104:                                              ; preds = %99, %96
  %105 = load ptr, ptr %16, align 8, !tbaa !5
  %106 = load i64, ptr %105, align 8, !tbaa !9
  %107 = icmp slt i64 %106, 0
  br i1 %107, label %108, label %109

108:                                              ; preds = %104
  store i64 3, ptr %46, align 8, !tbaa !9
  br label %158

109:                                              ; preds = %104
  %110 = load ptr, ptr %17, align 8, !tbaa !5
  %111 = load i64, ptr %110, align 8, !tbaa !9
  %112 = icmp slt i64 %111, 0
  br i1 %112, label %113, label %114

113:                                              ; preds = %109
  store i64 4, ptr %46, align 8, !tbaa !9
  br label %157

114:                                              ; preds = %109
  %115 = load ptr, ptr %20, align 8, !tbaa !5
  %116 = load i64, ptr %115, align 8, !tbaa !9
  %117 = load i64, ptr %49, align 8, !tbaa !9
  %118 = icmp sge i64 1, %117
  br i1 %118, label %119, label %120

119:                                              ; preds = %114
  br label %122

120:                                              ; preds = %114
  %121 = load i64, ptr %49, align 8, !tbaa !9
  br label %122

122:                                              ; preds = %120, %119
  %123 = phi i64 [ 1, %119 ], [ %121, %120 ]
  %124 = icmp slt i64 %116, %123
  br i1 %124, label %125, label %126

125:                                              ; preds = %122
  store i64 7, ptr %46, align 8, !tbaa !9
  br label %156

126:                                              ; preds = %122
  %127 = load ptr, ptr %22, align 8, !tbaa !5
  %128 = load i64, ptr %127, align 8, !tbaa !9
  %129 = load ptr, ptr %16, align 8, !tbaa !5
  %130 = load i64, ptr %129, align 8, !tbaa !9
  %131 = icmp sge i64 1, %130
  br i1 %131, label %132, label %133

132:                                              ; preds = %126
  br label %136

133:                                              ; preds = %126
  %134 = load ptr, ptr %16, align 8, !tbaa !5
  %135 = load i64, ptr %134, align 8, !tbaa !9
  br label %136

136:                                              ; preds = %133, %132
  %137 = phi i64 [ 1, %132 ], [ %135, %133 ]
  %138 = icmp slt i64 %128, %137
  br i1 %138, label %139, label %140

139:                                              ; preds = %136
  store i64 9, ptr %46, align 8, !tbaa !9
  br label %155

140:                                              ; preds = %136
  %141 = load ptr, ptr %25, align 8, !tbaa !5
  %142 = load i64, ptr %141, align 8, !tbaa !9
  %143 = load ptr, ptr %16, align 8, !tbaa !5
  %144 = load i64, ptr %143, align 8, !tbaa !9
  %145 = icmp sge i64 1, %144
  br i1 %145, label %146, label %147

146:                                              ; preds = %140
  br label %150

147:                                              ; preds = %140
  %148 = load ptr, ptr %16, align 8, !tbaa !5
  %149 = load i64, ptr %148, align 8, !tbaa !9
  br label %150

150:                                              ; preds = %147, %146
  %151 = phi i64 [ 1, %146 ], [ %149, %147 ]
  %152 = icmp slt i64 %142, %151
  br i1 %152, label %153, label %154

153:                                              ; preds = %150
  store i64 12, ptr %46, align 8, !tbaa !9
  br label %154

154:                                              ; preds = %153, %150
  br label %155

155:                                              ; preds = %154, %139
  br label %156

156:                                              ; preds = %155, %125
  br label %157

157:                                              ; preds = %156, %113
  br label %158

158:                                              ; preds = %157, %108
  br label %159

159:                                              ; preds = %158, %103
  br label %160

160:                                              ; preds = %159, %95
  %161 = load i64, ptr %46, align 8, !tbaa !9
  %162 = icmp ne i64 %161, 0
  br i1 %162, label %163, label %165

163:                                              ; preds = %160
  %164 = call i32 @xerbla_(ptr noundef @.str.3, ptr noundef %46)
  store i32 0, ptr %13, align 4
  store i32 1, ptr %51, align 4
  br label %2029

165:                                              ; preds = %160
  %166 = load ptr, ptr %16, align 8, !tbaa !5
  %167 = load i64, ptr %166, align 8, !tbaa !9
  %168 = icmp eq i64 %167, 0
  br i1 %168, label %193, label %169

169:                                              ; preds = %165
  %170 = load ptr, ptr %17, align 8, !tbaa !5
  %171 = load i64, ptr %170, align 8, !tbaa !9
  %172 = icmp eq i64 %171, 0
  br i1 %172, label %193, label %173

173:                                              ; preds = %169
  %174 = load ptr, ptr %18, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct.complex, ptr %174, i32 0, i32 0
  %176 = load float, ptr %175, align 4, !tbaa !11
  %177 = fcmp oeq float %176, 0.000000e+00
  br i1 %177, label %178, label %194

178:                                              ; preds = %173
  %179 = load ptr, ptr %18, align 8, !tbaa !5
  %180 = getelementptr inbounds %struct.complex, ptr %179, i32 0, i32 1
  %181 = load float, ptr %180, align 4, !tbaa !14
  %182 = fcmp oeq float %181, 0.000000e+00
  br i1 %182, label %183, label %194

183:                                              ; preds = %178
  %184 = load ptr, ptr %23, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct.complex, ptr %184, i32 0, i32 0
  %186 = load float, ptr %185, align 4, !tbaa !11
  %187 = fcmp oeq float %186, 1.000000e+00
  br i1 %187, label %188, label %194

188:                                              ; preds = %183
  %189 = load ptr, ptr %23, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.complex, ptr %189, i32 0, i32 1
  %191 = load float, ptr %190, align 4, !tbaa !14
  %192 = fcmp oeq float %191, 0.000000e+00
  br i1 %192, label %193, label %194

193:                                              ; preds = %188, %169, %165
  store i32 0, ptr %13, align 4
  store i32 1, ptr %51, align 4
  br label %2029

194:                                              ; preds = %188, %183, %178, %173
  %195 = load ptr, ptr %18, align 8, !tbaa !5
  %196 = getelementptr inbounds %struct.complex, ptr %195, i32 0, i32 0
  %197 = load float, ptr %196, align 4, !tbaa !11
  %198 = fcmp oeq float %197, 0.000000e+00
  br i1 %198, label %199, label %335

199:                                              ; preds = %194
  %200 = load ptr, ptr %18, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.complex, ptr %200, i32 0, i32 1
  %202 = load float, ptr %201, align 4, !tbaa !14
  %203 = fcmp oeq float %202, 0.000000e+00
  br i1 %203, label %204, label %335

204:                                              ; preds = %199
  %205 = load ptr, ptr %23, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.complex, ptr %205, i32 0, i32 0
  %207 = load float, ptr %206, align 4, !tbaa !11
  %208 = fcmp oeq float %207, 0.000000e+00
  br i1 %208, label %209, label %250

209:                                              ; preds = %204
  %210 = load ptr, ptr %23, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.complex, ptr %210, i32 0, i32 1
  %212 = load float, ptr %211, align 4, !tbaa !14
  %213 = fcmp oeq float %212, 0.000000e+00
  br i1 %213, label %214, label %250

214:                                              ; preds = %209
  %215 = load ptr, ptr %17, align 8, !tbaa !5
  %216 = load i64, ptr %215, align 8, !tbaa !9
  store i64 %216, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %217

217:                                              ; preds = %246, %214
  %218 = load i64, ptr %44, align 8, !tbaa !9
  %219 = load i64, ptr %32, align 8, !tbaa !9
  %220 = icmp sle i64 %218, %219
  br i1 %220, label %221, label %249

221:                                              ; preds = %217
  %222 = load ptr, ptr %16, align 8, !tbaa !5
  %223 = load i64, ptr %222, align 8, !tbaa !9
  store i64 %223, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %224

224:                                              ; preds = %242, %221
  %225 = load i64, ptr %43, align 8, !tbaa !9
  %226 = load i64, ptr %33, align 8, !tbaa !9
  %227 = icmp sle i64 %225, %226
  br i1 %227, label %228, label %245

228:                                              ; preds = %224
  %229 = load i64, ptr %43, align 8, !tbaa !9
  %230 = load i64, ptr %44, align 8, !tbaa !9
  %231 = load i64, ptr %30, align 8, !tbaa !9
  %232 = mul nsw i64 %230, %231
  %233 = add nsw i64 %229, %232
  store i64 %233, ptr %34, align 8, !tbaa !9
  %234 = load ptr, ptr %24, align 8, !tbaa !5
  %235 = load i64, ptr %34, align 8, !tbaa !9
  %236 = getelementptr inbounds %struct.complex, ptr %234, i64 %235
  %237 = getelementptr inbounds %struct.complex, ptr %236, i32 0, i32 0
  store float 0.000000e+00, ptr %237, align 4, !tbaa !11
  %238 = load ptr, ptr %24, align 8, !tbaa !5
  %239 = load i64, ptr %34, align 8, !tbaa !9
  %240 = getelementptr inbounds %struct.complex, ptr %238, i64 %239
  %241 = getelementptr inbounds %struct.complex, ptr %240, i32 0, i32 1
  store float 0.000000e+00, ptr %241, align 4, !tbaa !14
  br label %242

242:                                              ; preds = %228
  %243 = load i64, ptr %43, align 8, !tbaa !9
  %244 = add nsw i64 %243, 1
  store i64 %244, ptr %43, align 8, !tbaa !9
  br label %224, !llvm.loop !15

245:                                              ; preds = %224
  br label %246

246:                                              ; preds = %245
  %247 = load i64, ptr %44, align 8, !tbaa !9
  %248 = add nsw i64 %247, 1
  store i64 %248, ptr %44, align 8, !tbaa !9
  br label %217, !llvm.loop !17

249:                                              ; preds = %217
  br label %334

250:                                              ; preds = %209, %204
  %251 = load ptr, ptr %17, align 8, !tbaa !5
  %252 = load i64, ptr %251, align 8, !tbaa !9
  store i64 %252, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %253

253:                                              ; preds = %330, %250
  %254 = load i64, ptr %44, align 8, !tbaa !9
  %255 = load i64, ptr %32, align 8, !tbaa !9
  %256 = icmp sle i64 %254, %255
  br i1 %256, label %257, label %333

257:                                              ; preds = %253
  %258 = load ptr, ptr %16, align 8, !tbaa !5
  %259 = load i64, ptr %258, align 8, !tbaa !9
  store i64 %259, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %260

260:                                              ; preds = %326, %257
  %261 = load i64, ptr %43, align 8, !tbaa !9
  %262 = load i64, ptr %33, align 8, !tbaa !9
  %263 = icmp sle i64 %261, %262
  br i1 %263, label %264, label %329

264:                                              ; preds = %260
  %265 = load i64, ptr %43, align 8, !tbaa !9
  %266 = load i64, ptr %44, align 8, !tbaa !9
  %267 = load i64, ptr %30, align 8, !tbaa !9
  %268 = mul nsw i64 %266, %267
  %269 = add nsw i64 %265, %268
  store i64 %269, ptr %34, align 8, !tbaa !9
  %270 = load i64, ptr %43, align 8, !tbaa !9
  %271 = load i64, ptr %44, align 8, !tbaa !9
  %272 = load i64, ptr %30, align 8, !tbaa !9
  %273 = mul nsw i64 %271, %272
  %274 = add nsw i64 %270, %273
  store i64 %274, ptr %35, align 8, !tbaa !9
  %275 = load ptr, ptr %23, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.complex, ptr %275, i32 0, i32 0
  %277 = load float, ptr %276, align 4, !tbaa !11
  %278 = load ptr, ptr %24, align 8, !tbaa !5
  %279 = load i64, ptr %35, align 8, !tbaa !9
  %280 = getelementptr inbounds %struct.complex, ptr %278, i64 %279
  %281 = getelementptr inbounds %struct.complex, ptr %280, i32 0, i32 0
  %282 = load float, ptr %281, align 4, !tbaa !11
  %283 = load ptr, ptr %23, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.complex, ptr %283, i32 0, i32 1
  %285 = load float, ptr %284, align 4, !tbaa !14
  %286 = load ptr, ptr %24, align 8, !tbaa !5
  %287 = load i64, ptr %35, align 8, !tbaa !9
  %288 = getelementptr inbounds %struct.complex, ptr %286, i64 %287
  %289 = getelementptr inbounds %struct.complex, ptr %288, i32 0, i32 1
  %290 = load float, ptr %289, align 4, !tbaa !14
  %291 = fmul float %285, %290
  %292 = fneg float %291
  %293 = call float @llvm.fmuladd.f32(float %277, float %282, float %292)
  %294 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %293, ptr %294, align 4, !tbaa !11
  %295 = load ptr, ptr %23, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.complex, ptr %295, i32 0, i32 0
  %297 = load float, ptr %296, align 4, !tbaa !11
  %298 = load ptr, ptr %24, align 8, !tbaa !5
  %299 = load i64, ptr %35, align 8, !tbaa !9
  %300 = getelementptr inbounds %struct.complex, ptr %298, i64 %299
  %301 = getelementptr inbounds %struct.complex, ptr %300, i32 0, i32 1
  %302 = load float, ptr %301, align 4, !tbaa !14
  %303 = load ptr, ptr %23, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.complex, ptr %303, i32 0, i32 1
  %305 = load float, ptr %304, align 4, !tbaa !14
  %306 = load ptr, ptr %24, align 8, !tbaa !5
  %307 = load i64, ptr %35, align 8, !tbaa !9
  %308 = getelementptr inbounds %struct.complex, ptr %306, i64 %307
  %309 = getelementptr inbounds %struct.complex, ptr %308, i32 0, i32 0
  %310 = load float, ptr %309, align 4, !tbaa !11
  %311 = fmul float %305, %310
  %312 = call float @llvm.fmuladd.f32(float %297, float %302, float %311)
  %313 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %312, ptr %313, align 4, !tbaa !14
  %314 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %315 = load float, ptr %314, align 4, !tbaa !11
  %316 = load ptr, ptr %24, align 8, !tbaa !5
  %317 = load i64, ptr %34, align 8, !tbaa !9
  %318 = getelementptr inbounds %struct.complex, ptr %316, i64 %317
  %319 = getelementptr inbounds %struct.complex, ptr %318, i32 0, i32 0
  store float %315, ptr %319, align 4, !tbaa !11
  %320 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %321 = load float, ptr %320, align 4, !tbaa !14
  %322 = load ptr, ptr %24, align 8, !tbaa !5
  %323 = load i64, ptr %34, align 8, !tbaa !9
  %324 = getelementptr inbounds %struct.complex, ptr %322, i64 %323
  %325 = getelementptr inbounds %struct.complex, ptr %324, i32 0, i32 1
  store float %321, ptr %325, align 4, !tbaa !14
  br label %326

326:                                              ; preds = %264
  %327 = load i64, ptr %43, align 8, !tbaa !9
  %328 = add nsw i64 %327, 1
  store i64 %328, ptr %43, align 8, !tbaa !9
  br label %260, !llvm.loop !18

329:                                              ; preds = %260
  br label %330

330:                                              ; preds = %329
  %331 = load i64, ptr %44, align 8, !tbaa !9
  %332 = add nsw i64 %331, 1
  store i64 %332, ptr %44, align 8, !tbaa !9
  br label %253, !llvm.loop !19

333:                                              ; preds = %253
  br label %334

334:                                              ; preds = %333, %249
  store i32 0, ptr %13, align 4
  store i32 1, ptr %51, align 4
  br label %2029

335:                                              ; preds = %199, %194
  %336 = load ptr, ptr %14, align 8, !tbaa !5
  %337 = call i64 @lsame_(ptr noundef %336, ptr noundef @.str)
  %338 = icmp ne i64 %337, 0
  br i1 %338, label %339, label %1346

339:                                              ; preds = %335
  %340 = load i64, ptr %50, align 8, !tbaa !9
  %341 = icmp ne i64 %340, 0
  br i1 %341, label %342, label %843

342:                                              ; preds = %339
  %343 = load ptr, ptr %17, align 8, !tbaa !5
  %344 = load i64, ptr %343, align 8, !tbaa !9
  store i64 %344, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %345

345:                                              ; preds = %839, %342
  %346 = load i64, ptr %44, align 8, !tbaa !9
  %347 = load i64, ptr %32, align 8, !tbaa !9
  %348 = icmp sle i64 %346, %347
  br i1 %348, label %349, label %842

349:                                              ; preds = %345
  %350 = load ptr, ptr %16, align 8, !tbaa !5
  %351 = load i64, ptr %350, align 8, !tbaa !9
  store i64 %351, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %352

352:                                              ; preds = %835, %349
  %353 = load i64, ptr %43, align 8, !tbaa !9
  %354 = load i64, ptr %33, align 8, !tbaa !9
  %355 = icmp sle i64 %353, %354
  br i1 %355, label %356, label %838

356:                                              ; preds = %352
  %357 = load i64, ptr %43, align 8, !tbaa !9
  %358 = load i64, ptr %44, align 8, !tbaa !9
  %359 = load i64, ptr %28, align 8, !tbaa !9
  %360 = mul nsw i64 %358, %359
  %361 = add nsw i64 %357, %360
  store i64 %361, ptr %34, align 8, !tbaa !9
  %362 = load ptr, ptr %18, align 8, !tbaa !5
  %363 = getelementptr inbounds %struct.complex, ptr %362, i32 0, i32 0
  %364 = load float, ptr %363, align 4, !tbaa !11
  %365 = load ptr, ptr %21, align 8, !tbaa !5
  %366 = load i64, ptr %34, align 8, !tbaa !9
  %367 = getelementptr inbounds %struct.complex, ptr %365, i64 %366
  %368 = getelementptr inbounds %struct.complex, ptr %367, i32 0, i32 0
  %369 = load float, ptr %368, align 4, !tbaa !11
  %370 = load ptr, ptr %18, align 8, !tbaa !5
  %371 = getelementptr inbounds %struct.complex, ptr %370, i32 0, i32 1
  %372 = load float, ptr %371, align 4, !tbaa !14
  %373 = load ptr, ptr %21, align 8, !tbaa !5
  %374 = load i64, ptr %34, align 8, !tbaa !9
  %375 = getelementptr inbounds %struct.complex, ptr %373, i64 %374
  %376 = getelementptr inbounds %struct.complex, ptr %375, i32 0, i32 1
  %377 = load float, ptr %376, align 4, !tbaa !14
  %378 = fmul float %372, %377
  %379 = fneg float %378
  %380 = call float @llvm.fmuladd.f32(float %364, float %369, float %379)
  %381 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %380, ptr %381, align 4, !tbaa !11
  %382 = load ptr, ptr %18, align 8, !tbaa !5
  %383 = getelementptr inbounds %struct.complex, ptr %382, i32 0, i32 0
  %384 = load float, ptr %383, align 4, !tbaa !11
  %385 = load ptr, ptr %21, align 8, !tbaa !5
  %386 = load i64, ptr %34, align 8, !tbaa !9
  %387 = getelementptr inbounds %struct.complex, ptr %385, i64 %386
  %388 = getelementptr inbounds %struct.complex, ptr %387, i32 0, i32 1
  %389 = load float, ptr %388, align 4, !tbaa !14
  %390 = load ptr, ptr %18, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.complex, ptr %390, i32 0, i32 1
  %392 = load float, ptr %391, align 4, !tbaa !14
  %393 = load ptr, ptr %21, align 8, !tbaa !5
  %394 = load i64, ptr %34, align 8, !tbaa !9
  %395 = getelementptr inbounds %struct.complex, ptr %393, i64 %394
  %396 = getelementptr inbounds %struct.complex, ptr %395, i32 0, i32 0
  %397 = load float, ptr %396, align 4, !tbaa !11
  %398 = fmul float %392, %397
  %399 = call float @llvm.fmuladd.f32(float %384, float %389, float %398)
  %400 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %399, ptr %400, align 4, !tbaa !14
  %401 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %402 = load float, ptr %401, align 4, !tbaa !11
  %403 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %402, ptr %403, align 4, !tbaa !11
  %404 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %405 = load float, ptr %404, align 4, !tbaa !14
  %406 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %405, ptr %406, align 4, !tbaa !14
  %407 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float 0.000000e+00, ptr %407, align 4, !tbaa !11
  %408 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float 0.000000e+00, ptr %408, align 4, !tbaa !14
  %409 = load i64, ptr %43, align 8, !tbaa !9
  %410 = sub nsw i64 %409, 1
  store i64 %410, ptr %34, align 8, !tbaa !9
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %411

411:                                              ; preds = %571, %356
  %412 = load i64, ptr %45, align 8, !tbaa !9
  %413 = load i64, ptr %34, align 8, !tbaa !9
  %414 = icmp sle i64 %412, %413
  br i1 %414, label %415, label %574

415:                                              ; preds = %411
  %416 = load i64, ptr %45, align 8, !tbaa !9
  %417 = load i64, ptr %44, align 8, !tbaa !9
  %418 = load i64, ptr %30, align 8, !tbaa !9
  %419 = mul nsw i64 %417, %418
  %420 = add nsw i64 %416, %419
  store i64 %420, ptr %35, align 8, !tbaa !9
  %421 = load i64, ptr %45, align 8, !tbaa !9
  %422 = load i64, ptr %44, align 8, !tbaa !9
  %423 = load i64, ptr %30, align 8, !tbaa !9
  %424 = mul nsw i64 %422, %423
  %425 = add nsw i64 %421, %424
  store i64 %425, ptr %36, align 8, !tbaa !9
  %426 = load i64, ptr %45, align 8, !tbaa !9
  %427 = load i64, ptr %43, align 8, !tbaa !9
  %428 = load i64, ptr %26, align 8, !tbaa !9
  %429 = mul nsw i64 %427, %428
  %430 = add nsw i64 %426, %429
  store i64 %430, ptr %37, align 8, !tbaa !9
  %431 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %432 = load float, ptr %431, align 4, !tbaa !11
  %433 = load ptr, ptr %19, align 8, !tbaa !5
  %434 = load i64, ptr %37, align 8, !tbaa !9
  %435 = getelementptr inbounds %struct.complex, ptr %433, i64 %434
  %436 = getelementptr inbounds %struct.complex, ptr %435, i32 0, i32 0
  %437 = load float, ptr %436, align 4, !tbaa !11
  %438 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %439 = load float, ptr %438, align 4, !tbaa !14
  %440 = load ptr, ptr %19, align 8, !tbaa !5
  %441 = load i64, ptr %37, align 8, !tbaa !9
  %442 = getelementptr inbounds %struct.complex, ptr %440, i64 %441
  %443 = getelementptr inbounds %struct.complex, ptr %442, i32 0, i32 1
  %444 = load float, ptr %443, align 4, !tbaa !14
  %445 = fmul float %439, %444
  %446 = fneg float %445
  %447 = call float @llvm.fmuladd.f32(float %432, float %437, float %446)
  %448 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %447, ptr %448, align 4, !tbaa !11
  %449 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %450 = load float, ptr %449, align 4, !tbaa !11
  %451 = load ptr, ptr %19, align 8, !tbaa !5
  %452 = load i64, ptr %37, align 8, !tbaa !9
  %453 = getelementptr inbounds %struct.complex, ptr %451, i64 %452
  %454 = getelementptr inbounds %struct.complex, ptr %453, i32 0, i32 1
  %455 = load float, ptr %454, align 4, !tbaa !14
  %456 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %457 = load float, ptr %456, align 4, !tbaa !14
  %458 = load ptr, ptr %19, align 8, !tbaa !5
  %459 = load i64, ptr %37, align 8, !tbaa !9
  %460 = getelementptr inbounds %struct.complex, ptr %458, i64 %459
  %461 = getelementptr inbounds %struct.complex, ptr %460, i32 0, i32 0
  %462 = load float, ptr %461, align 4, !tbaa !11
  %463 = fmul float %457, %462
  %464 = call float @llvm.fmuladd.f32(float %450, float %455, float %463)
  %465 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %464, ptr %465, align 4, !tbaa !14
  %466 = load ptr, ptr %24, align 8, !tbaa !5
  %467 = load i64, ptr %36, align 8, !tbaa !9
  %468 = getelementptr inbounds %struct.complex, ptr %466, i64 %467
  %469 = getelementptr inbounds %struct.complex, ptr %468, i32 0, i32 0
  %470 = load float, ptr %469, align 4, !tbaa !11
  %471 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %472 = load float, ptr %471, align 4, !tbaa !11
  %473 = fadd float %470, %472
  %474 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %473, ptr %474, align 4, !tbaa !11
  %475 = load ptr, ptr %24, align 8, !tbaa !5
  %476 = load i64, ptr %36, align 8, !tbaa !9
  %477 = getelementptr inbounds %struct.complex, ptr %475, i64 %476
  %478 = getelementptr inbounds %struct.complex, ptr %477, i32 0, i32 1
  %479 = load float, ptr %478, align 4, !tbaa !14
  %480 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %481 = load float, ptr %480, align 4, !tbaa !14
  %482 = fadd float %479, %481
  %483 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %482, ptr %483, align 4, !tbaa !14
  %484 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %485 = load float, ptr %484, align 4, !tbaa !11
  %486 = load ptr, ptr %24, align 8, !tbaa !5
  %487 = load i64, ptr %35, align 8, !tbaa !9
  %488 = getelementptr inbounds %struct.complex, ptr %486, i64 %487
  %489 = getelementptr inbounds %struct.complex, ptr %488, i32 0, i32 0
  store float %485, ptr %489, align 4, !tbaa !11
  %490 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %491 = load float, ptr %490, align 4, !tbaa !14
  %492 = load ptr, ptr %24, align 8, !tbaa !5
  %493 = load i64, ptr %35, align 8, !tbaa !9
  %494 = getelementptr inbounds %struct.complex, ptr %492, i64 %493
  %495 = getelementptr inbounds %struct.complex, ptr %494, i32 0, i32 1
  store float %491, ptr %495, align 4, !tbaa !14
  %496 = load i64, ptr %45, align 8, !tbaa !9
  %497 = load i64, ptr %44, align 8, !tbaa !9
  %498 = load i64, ptr %28, align 8, !tbaa !9
  %499 = mul nsw i64 %497, %498
  %500 = add nsw i64 %496, %499
  store i64 %500, ptr %35, align 8, !tbaa !9
  %501 = load i64, ptr %45, align 8, !tbaa !9
  %502 = load i64, ptr %43, align 8, !tbaa !9
  %503 = load i64, ptr %26, align 8, !tbaa !9
  %504 = mul nsw i64 %502, %503
  %505 = add nsw i64 %501, %504
  store i64 %505, ptr %36, align 8, !tbaa !9
  %506 = load ptr, ptr %21, align 8, !tbaa !5
  %507 = load i64, ptr %35, align 8, !tbaa !9
  %508 = getelementptr inbounds %struct.complex, ptr %506, i64 %507
  %509 = getelementptr inbounds %struct.complex, ptr %508, i32 0, i32 0
  %510 = load float, ptr %509, align 4, !tbaa !11
  %511 = load ptr, ptr %19, align 8, !tbaa !5
  %512 = load i64, ptr %36, align 8, !tbaa !9
  %513 = getelementptr inbounds %struct.complex, ptr %511, i64 %512
  %514 = getelementptr inbounds %struct.complex, ptr %513, i32 0, i32 0
  %515 = load float, ptr %514, align 4, !tbaa !11
  %516 = load ptr, ptr %21, align 8, !tbaa !5
  %517 = load i64, ptr %35, align 8, !tbaa !9
  %518 = getelementptr inbounds %struct.complex, ptr %516, i64 %517
  %519 = getelementptr inbounds %struct.complex, ptr %518, i32 0, i32 1
  %520 = load float, ptr %519, align 4, !tbaa !14
  %521 = load ptr, ptr %19, align 8, !tbaa !5
  %522 = load i64, ptr %36, align 8, !tbaa !9
  %523 = getelementptr inbounds %struct.complex, ptr %521, i64 %522
  %524 = getelementptr inbounds %struct.complex, ptr %523, i32 0, i32 1
  %525 = load float, ptr %524, align 4, !tbaa !14
  %526 = fmul float %520, %525
  %527 = fneg float %526
  %528 = call float @llvm.fmuladd.f32(float %510, float %515, float %527)
  %529 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %528, ptr %529, align 4, !tbaa !11
  %530 = load ptr, ptr %21, align 8, !tbaa !5
  %531 = load i64, ptr %35, align 8, !tbaa !9
  %532 = getelementptr inbounds %struct.complex, ptr %530, i64 %531
  %533 = getelementptr inbounds %struct.complex, ptr %532, i32 0, i32 0
  %534 = load float, ptr %533, align 4, !tbaa !11
  %535 = load ptr, ptr %19, align 8, !tbaa !5
  %536 = load i64, ptr %36, align 8, !tbaa !9
  %537 = getelementptr inbounds %struct.complex, ptr %535, i64 %536
  %538 = getelementptr inbounds %struct.complex, ptr %537, i32 0, i32 1
  %539 = load float, ptr %538, align 4, !tbaa !14
  %540 = load ptr, ptr %21, align 8, !tbaa !5
  %541 = load i64, ptr %35, align 8, !tbaa !9
  %542 = getelementptr inbounds %struct.complex, ptr %540, i64 %541
  %543 = getelementptr inbounds %struct.complex, ptr %542, i32 0, i32 1
  %544 = load float, ptr %543, align 4, !tbaa !14
  %545 = load ptr, ptr %19, align 8, !tbaa !5
  %546 = load i64, ptr %36, align 8, !tbaa !9
  %547 = getelementptr inbounds %struct.complex, ptr %545, i64 %546
  %548 = getelementptr inbounds %struct.complex, ptr %547, i32 0, i32 0
  %549 = load float, ptr %548, align 4, !tbaa !11
  %550 = fmul float %544, %549
  %551 = call float @llvm.fmuladd.f32(float %534, float %539, float %550)
  %552 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %551, ptr %552, align 4, !tbaa !14
  %553 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %554 = load float, ptr %553, align 4, !tbaa !11
  %555 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %556 = load float, ptr %555, align 4, !tbaa !11
  %557 = fadd float %554, %556
  %558 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %557, ptr %558, align 4, !tbaa !11
  %559 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %560 = load float, ptr %559, align 4, !tbaa !14
  %561 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %562 = load float, ptr %561, align 4, !tbaa !14
  %563 = fadd float %560, %562
  %564 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %563, ptr %564, align 4, !tbaa !14
  %565 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %566 = load float, ptr %565, align 4, !tbaa !11
  %567 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %566, ptr %567, align 4, !tbaa !11
  %568 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %569 = load float, ptr %568, align 4, !tbaa !14
  %570 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %569, ptr %570, align 4, !tbaa !14
  br label %571

571:                                              ; preds = %415
  %572 = load i64, ptr %45, align 8, !tbaa !9
  %573 = add nsw i64 %572, 1
  store i64 %573, ptr %45, align 8, !tbaa !9
  br label %411, !llvm.loop !20

574:                                              ; preds = %411
  %575 = load ptr, ptr %23, align 8, !tbaa !5
  %576 = getelementptr inbounds %struct.complex, ptr %575, i32 0, i32 0
  %577 = load float, ptr %576, align 4, !tbaa !11
  %578 = fcmp oeq float %577, 0.000000e+00
  br i1 %578, label %579, label %681

579:                                              ; preds = %574
  %580 = load ptr, ptr %23, align 8, !tbaa !5
  %581 = getelementptr inbounds %struct.complex, ptr %580, i32 0, i32 1
  %582 = load float, ptr %581, align 4, !tbaa !14
  %583 = fcmp oeq float %582, 0.000000e+00
  br i1 %583, label %584, label %681

584:                                              ; preds = %579
  %585 = load i64, ptr %43, align 8, !tbaa !9
  %586 = load i64, ptr %44, align 8, !tbaa !9
  %587 = load i64, ptr %30, align 8, !tbaa !9
  %588 = mul nsw i64 %586, %587
  %589 = add nsw i64 %585, %588
  store i64 %589, ptr %34, align 8, !tbaa !9
  %590 = load i64, ptr %43, align 8, !tbaa !9
  %591 = load i64, ptr %43, align 8, !tbaa !9
  %592 = load i64, ptr %26, align 8, !tbaa !9
  %593 = mul nsw i64 %591, %592
  %594 = add nsw i64 %590, %593
  store i64 %594, ptr %35, align 8, !tbaa !9
  %595 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %596 = load float, ptr %595, align 4, !tbaa !11
  %597 = load ptr, ptr %19, align 8, !tbaa !5
  %598 = load i64, ptr %35, align 8, !tbaa !9
  %599 = getelementptr inbounds %struct.complex, ptr %597, i64 %598
  %600 = getelementptr inbounds %struct.complex, ptr %599, i32 0, i32 0
  %601 = load float, ptr %600, align 4, !tbaa !11
  %602 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %603 = load float, ptr %602, align 4, !tbaa !14
  %604 = load ptr, ptr %19, align 8, !tbaa !5
  %605 = load i64, ptr %35, align 8, !tbaa !9
  %606 = getelementptr inbounds %struct.complex, ptr %604, i64 %605
  %607 = getelementptr inbounds %struct.complex, ptr %606, i32 0, i32 1
  %608 = load float, ptr %607, align 4, !tbaa !14
  %609 = fmul float %603, %608
  %610 = fneg float %609
  %611 = call float @llvm.fmuladd.f32(float %596, float %601, float %610)
  %612 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %611, ptr %612, align 4, !tbaa !11
  %613 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %614 = load float, ptr %613, align 4, !tbaa !11
  %615 = load ptr, ptr %19, align 8, !tbaa !5
  %616 = load i64, ptr %35, align 8, !tbaa !9
  %617 = getelementptr inbounds %struct.complex, ptr %615, i64 %616
  %618 = getelementptr inbounds %struct.complex, ptr %617, i32 0, i32 1
  %619 = load float, ptr %618, align 4, !tbaa !14
  %620 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %621 = load float, ptr %620, align 4, !tbaa !14
  %622 = load ptr, ptr %19, align 8, !tbaa !5
  %623 = load i64, ptr %35, align 8, !tbaa !9
  %624 = getelementptr inbounds %struct.complex, ptr %622, i64 %623
  %625 = getelementptr inbounds %struct.complex, ptr %624, i32 0, i32 0
  %626 = load float, ptr %625, align 4, !tbaa !11
  %627 = fmul float %621, %626
  %628 = call float @llvm.fmuladd.f32(float %614, float %619, float %627)
  %629 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %628, ptr %629, align 4, !tbaa !14
  %630 = load ptr, ptr %18, align 8, !tbaa !5
  %631 = getelementptr inbounds %struct.complex, ptr %630, i32 0, i32 0
  %632 = load float, ptr %631, align 4, !tbaa !11
  %633 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %634 = load float, ptr %633, align 4, !tbaa !11
  %635 = load ptr, ptr %18, align 8, !tbaa !5
  %636 = getelementptr inbounds %struct.complex, ptr %635, i32 0, i32 1
  %637 = load float, ptr %636, align 4, !tbaa !14
  %638 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %639 = load float, ptr %638, align 4, !tbaa !14
  %640 = fmul float %637, %639
  %641 = fneg float %640
  %642 = call float @llvm.fmuladd.f32(float %632, float %634, float %641)
  %643 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %642, ptr %643, align 4, !tbaa !11
  %644 = load ptr, ptr %18, align 8, !tbaa !5
  %645 = getelementptr inbounds %struct.complex, ptr %644, i32 0, i32 0
  %646 = load float, ptr %645, align 4, !tbaa !11
  %647 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %648 = load float, ptr %647, align 4, !tbaa !14
  %649 = load ptr, ptr %18, align 8, !tbaa !5
  %650 = getelementptr inbounds %struct.complex, ptr %649, i32 0, i32 1
  %651 = load float, ptr %650, align 4, !tbaa !14
  %652 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %653 = load float, ptr %652, align 4, !tbaa !11
  %654 = fmul float %651, %653
  %655 = call float @llvm.fmuladd.f32(float %646, float %648, float %654)
  %656 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %655, ptr %656, align 4, !tbaa !14
  %657 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %658 = load float, ptr %657, align 4, !tbaa !11
  %659 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %660 = load float, ptr %659, align 4, !tbaa !11
  %661 = fadd float %658, %660
  %662 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %661, ptr %662, align 4, !tbaa !11
  %663 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %664 = load float, ptr %663, align 4, !tbaa !14
  %665 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %666 = load float, ptr %665, align 4, !tbaa !14
  %667 = fadd float %664, %666
  %668 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %667, ptr %668, align 4, !tbaa !14
  %669 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %670 = load float, ptr %669, align 4, !tbaa !11
  %671 = load ptr, ptr %24, align 8, !tbaa !5
  %672 = load i64, ptr %34, align 8, !tbaa !9
  %673 = getelementptr inbounds %struct.complex, ptr %671, i64 %672
  %674 = getelementptr inbounds %struct.complex, ptr %673, i32 0, i32 0
  store float %670, ptr %674, align 4, !tbaa !11
  %675 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %676 = load float, ptr %675, align 4, !tbaa !14
  %677 = load ptr, ptr %24, align 8, !tbaa !5
  %678 = load i64, ptr %34, align 8, !tbaa !9
  %679 = getelementptr inbounds %struct.complex, ptr %677, i64 %678
  %680 = getelementptr inbounds %struct.complex, ptr %679, i32 0, i32 1
  store float %676, ptr %680, align 4, !tbaa !14
  br label %834

681:                                              ; preds = %579, %574
  %682 = load i64, ptr %43, align 8, !tbaa !9
  %683 = load i64, ptr %44, align 8, !tbaa !9
  %684 = load i64, ptr %30, align 8, !tbaa !9
  %685 = mul nsw i64 %683, %684
  %686 = add nsw i64 %682, %685
  store i64 %686, ptr %34, align 8, !tbaa !9
  %687 = load i64, ptr %43, align 8, !tbaa !9
  %688 = load i64, ptr %44, align 8, !tbaa !9
  %689 = load i64, ptr %30, align 8, !tbaa !9
  %690 = mul nsw i64 %688, %689
  %691 = add nsw i64 %687, %690
  store i64 %691, ptr %35, align 8, !tbaa !9
  %692 = load ptr, ptr %23, align 8, !tbaa !5
  %693 = getelementptr inbounds %struct.complex, ptr %692, i32 0, i32 0
  %694 = load float, ptr %693, align 4, !tbaa !11
  %695 = load ptr, ptr %24, align 8, !tbaa !5
  %696 = load i64, ptr %35, align 8, !tbaa !9
  %697 = getelementptr inbounds %struct.complex, ptr %695, i64 %696
  %698 = getelementptr inbounds %struct.complex, ptr %697, i32 0, i32 0
  %699 = load float, ptr %698, align 4, !tbaa !11
  %700 = load ptr, ptr %23, align 8, !tbaa !5
  %701 = getelementptr inbounds %struct.complex, ptr %700, i32 0, i32 1
  %702 = load float, ptr %701, align 4, !tbaa !14
  %703 = load ptr, ptr %24, align 8, !tbaa !5
  %704 = load i64, ptr %35, 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 %694, float %699, float %709)
  %711 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %710, ptr %711, align 4, !tbaa !11
  %712 = load ptr, ptr %23, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.complex, ptr %712, i32 0, i32 0
  %714 = load float, ptr %713, align 4, !tbaa !11
  %715 = load ptr, ptr %24, align 8, !tbaa !5
  %716 = load i64, ptr %35, align 8, !tbaa !9
  %717 = getelementptr inbounds %struct.complex, ptr %715, i64 %716
  %718 = getelementptr inbounds %struct.complex, ptr %717, i32 0, i32 1
  %719 = load float, ptr %718, align 4, !tbaa !14
  %720 = load ptr, ptr %23, align 8, !tbaa !5
  %721 = getelementptr inbounds %struct.complex, ptr %720, i32 0, i32 1
  %722 = load float, ptr %721, align 4, !tbaa !14
  %723 = load ptr, ptr %24, align 8, !tbaa !5
  %724 = load i64, ptr %35, align 8, !tbaa !9
  %725 = getelementptr inbounds %struct.complex, ptr %723, i64 %724
  %726 = getelementptr inbounds %struct.complex, ptr %725, i32 0, i32 0
  %727 = load float, ptr %726, align 4, !tbaa !11
  %728 = fmul float %722, %727
  %729 = call float @llvm.fmuladd.f32(float %714, float %719, float %728)
  %730 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %729, ptr %730, align 4, !tbaa !14
  %731 = load i64, ptr %43, align 8, !tbaa !9
  %732 = load i64, ptr %43, align 8, !tbaa !9
  %733 = load i64, ptr %26, align 8, !tbaa !9
  %734 = mul nsw i64 %732, %733
  %735 = add nsw i64 %731, %734
  store i64 %735, ptr %36, align 8, !tbaa !9
  %736 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %737 = load float, ptr %736, align 4, !tbaa !11
  %738 = load ptr, ptr %19, align 8, !tbaa !5
  %739 = load i64, ptr %36, align 8, !tbaa !9
  %740 = getelementptr inbounds %struct.complex, ptr %738, i64 %739
  %741 = getelementptr inbounds %struct.complex, ptr %740, i32 0, i32 0
  %742 = load float, ptr %741, align 4, !tbaa !11
  %743 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %744 = load float, ptr %743, align 4, !tbaa !14
  %745 = load ptr, ptr %19, align 8, !tbaa !5
  %746 = load i64, ptr %36, align 8, !tbaa !9
  %747 = getelementptr inbounds %struct.complex, ptr %745, i64 %746
  %748 = getelementptr inbounds %struct.complex, ptr %747, i32 0, i32 1
  %749 = load float, ptr %748, align 4, !tbaa !14
  %750 = fmul float %744, %749
  %751 = fneg float %750
  %752 = call float @llvm.fmuladd.f32(float %737, float %742, float %751)
  %753 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %752, ptr %753, align 4, !tbaa !11
  %754 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %755 = load float, ptr %754, align 4, !tbaa !11
  %756 = load ptr, ptr %19, align 8, !tbaa !5
  %757 = load i64, ptr %36, align 8, !tbaa !9
  %758 = getelementptr inbounds %struct.complex, ptr %756, i64 %757
  %759 = getelementptr inbounds %struct.complex, ptr %758, i32 0, i32 1
  %760 = load float, ptr %759, align 4, !tbaa !14
  %761 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %762 = load float, ptr %761, align 4, !tbaa !14
  %763 = load ptr, ptr %19, align 8, !tbaa !5
  %764 = load i64, ptr %36, align 8, !tbaa !9
  %765 = getelementptr inbounds %struct.complex, ptr %763, i64 %764
  %766 = getelementptr inbounds %struct.complex, ptr %765, i32 0, i32 0
  %767 = load float, ptr %766, align 4, !tbaa !11
  %768 = fmul float %762, %767
  %769 = call float @llvm.fmuladd.f32(float %755, float %760, float %768)
  %770 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %769, ptr %770, align 4, !tbaa !14
  %771 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %772 = load float, ptr %771, align 4, !tbaa !11
  %773 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %774 = load float, ptr %773, align 4, !tbaa !11
  %775 = fadd float %772, %774
  %776 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %775, ptr %776, align 4, !tbaa !11
  %777 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %778 = load float, ptr %777, align 4, !tbaa !14
  %779 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %780 = load float, ptr %779, align 4, !tbaa !14
  %781 = fadd float %778, %780
  %782 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %781, ptr %782, align 4, !tbaa !14
  %783 = load ptr, ptr %18, align 8, !tbaa !5
  %784 = getelementptr inbounds %struct.complex, ptr %783, i32 0, i32 0
  %785 = load float, ptr %784, align 4, !tbaa !11
  %786 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %787 = load float, ptr %786, align 4, !tbaa !11
  %788 = load ptr, ptr %18, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.complex, ptr %788, i32 0, i32 1
  %790 = load float, ptr %789, align 4, !tbaa !14
  %791 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %792 = load float, ptr %791, align 4, !tbaa !14
  %793 = fmul float %790, %792
  %794 = fneg float %793
  %795 = call float @llvm.fmuladd.f32(float %785, float %787, float %794)
  %796 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %795, ptr %796, align 4, !tbaa !11
  %797 = load ptr, ptr %18, align 8, !tbaa !5
  %798 = getelementptr inbounds %struct.complex, ptr %797, i32 0, i32 0
  %799 = load float, ptr %798, align 4, !tbaa !11
  %800 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %801 = load float, ptr %800, align 4, !tbaa !14
  %802 = load ptr, ptr %18, align 8, !tbaa !5
  %803 = getelementptr inbounds %struct.complex, ptr %802, i32 0, i32 1
  %804 = load float, ptr %803, align 4, !tbaa !14
  %805 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %806 = load float, ptr %805, align 4, !tbaa !11
  %807 = fmul float %804, %806
  %808 = call float @llvm.fmuladd.f32(float %799, float %801, float %807)
  %809 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %808, ptr %809, align 4, !tbaa !14
  %810 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %811 = load float, ptr %810, align 4, !tbaa !11
  %812 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %813 = load float, ptr %812, align 4, !tbaa !11
  %814 = fadd float %811, %813
  %815 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %814, ptr %815, align 4, !tbaa !11
  %816 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %817 = load float, ptr %816, align 4, !tbaa !14
  %818 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %819 = load float, ptr %818, align 4, !tbaa !14
  %820 = fadd float %817, %819
  %821 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %820, ptr %821, align 4, !tbaa !14
  %822 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %823 = load float, ptr %822, align 4, !tbaa !11
  %824 = load ptr, ptr %24, align 8, !tbaa !5
  %825 = load i64, ptr %34, align 8, !tbaa !9
  %826 = getelementptr inbounds %struct.complex, ptr %824, i64 %825
  %827 = getelementptr inbounds %struct.complex, ptr %826, i32 0, i32 0
  store float %823, ptr %827, align 4, !tbaa !11
  %828 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %829 = load float, ptr %828, align 4, !tbaa !14
  %830 = load ptr, ptr %24, align 8, !tbaa !5
  %831 = load i64, ptr %34, align 8, !tbaa !9
  %832 = getelementptr inbounds %struct.complex, ptr %830, i64 %831
  %833 = getelementptr inbounds %struct.complex, ptr %832, i32 0, i32 1
  store float %829, ptr %833, align 4, !tbaa !14
  br label %834

834:                                              ; preds = %681, %584
  br label %835

835:                                              ; preds = %834
  %836 = load i64, ptr %43, align 8, !tbaa !9
  %837 = add nsw i64 %836, 1
  store i64 %837, ptr %43, align 8, !tbaa !9
  br label %352, !llvm.loop !21

838:                                              ; preds = %352
  br label %839

839:                                              ; preds = %838
  %840 = load i64, ptr %44, align 8, !tbaa !9
  %841 = add nsw i64 %840, 1
  store i64 %841, ptr %44, align 8, !tbaa !9
  br label %345, !llvm.loop !22

842:                                              ; preds = %345
  br label %1345

843:                                              ; preds = %339
  %844 = load ptr, ptr %17, align 8, !tbaa !5
  %845 = load i64, ptr %844, align 8, !tbaa !9
  store i64 %845, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %846

846:                                              ; preds = %1341, %843
  %847 = load i64, ptr %44, align 8, !tbaa !9
  %848 = load i64, ptr %32, align 8, !tbaa !9
  %849 = icmp sle i64 %847, %848
  br i1 %849, label %850, label %1344

850:                                              ; preds = %846
  %851 = load ptr, ptr %16, align 8, !tbaa !5
  %852 = load i64, ptr %851, align 8, !tbaa !9
  store i64 %852, ptr %43, align 8, !tbaa !9
  br label %853

853:                                              ; preds = %1337, %850
  %854 = load i64, ptr %43, align 8, !tbaa !9
  %855 = icmp sge i64 %854, 1
  br i1 %855, label %856, label %1340

856:                                              ; preds = %853
  %857 = load i64, ptr %43, align 8, !tbaa !9
  %858 = load i64, ptr %44, align 8, !tbaa !9
  %859 = load i64, ptr %28, align 8, !tbaa !9
  %860 = mul nsw i64 %858, %859
  %861 = add nsw i64 %857, %860
  store i64 %861, ptr %33, align 8, !tbaa !9
  %862 = load ptr, ptr %18, align 8, !tbaa !5
  %863 = getelementptr inbounds %struct.complex, ptr %862, i32 0, i32 0
  %864 = load float, ptr %863, align 4, !tbaa !11
  %865 = load ptr, ptr %21, align 8, !tbaa !5
  %866 = load i64, ptr %33, align 8, !tbaa !9
  %867 = getelementptr inbounds %struct.complex, ptr %865, i64 %866
  %868 = getelementptr inbounds %struct.complex, ptr %867, i32 0, i32 0
  %869 = load float, ptr %868, align 4, !tbaa !11
  %870 = load ptr, ptr %18, align 8, !tbaa !5
  %871 = getelementptr inbounds %struct.complex, ptr %870, i32 0, i32 1
  %872 = load float, ptr %871, align 4, !tbaa !14
  %873 = load ptr, ptr %21, align 8, !tbaa !5
  %874 = load i64, ptr %33, align 8, !tbaa !9
  %875 = getelementptr inbounds %struct.complex, ptr %873, i64 %874
  %876 = getelementptr inbounds %struct.complex, ptr %875, i32 0, i32 1
  %877 = load float, ptr %876, align 4, !tbaa !14
  %878 = fmul float %872, %877
  %879 = fneg float %878
  %880 = call float @llvm.fmuladd.f32(float %864, float %869, float %879)
  %881 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %880, ptr %881, align 4, !tbaa !11
  %882 = load ptr, ptr %18, align 8, !tbaa !5
  %883 = getelementptr inbounds %struct.complex, ptr %882, i32 0, i32 0
  %884 = load float, ptr %883, align 4, !tbaa !11
  %885 = load ptr, ptr %21, align 8, !tbaa !5
  %886 = load i64, ptr %33, align 8, !tbaa !9
  %887 = getelementptr inbounds %struct.complex, ptr %885, i64 %886
  %888 = getelementptr inbounds %struct.complex, ptr %887, i32 0, i32 1
  %889 = load float, ptr %888, align 4, !tbaa !14
  %890 = load ptr, ptr %18, align 8, !tbaa !5
  %891 = getelementptr inbounds %struct.complex, ptr %890, i32 0, i32 1
  %892 = load float, ptr %891, align 4, !tbaa !14
  %893 = load ptr, ptr %21, align 8, !tbaa !5
  %894 = load i64, ptr %33, align 8, !tbaa !9
  %895 = getelementptr inbounds %struct.complex, ptr %893, i64 %894
  %896 = getelementptr inbounds %struct.complex, ptr %895, i32 0, i32 0
  %897 = load float, ptr %896, align 4, !tbaa !11
  %898 = fmul float %892, %897
  %899 = call float @llvm.fmuladd.f32(float %884, float %889, float %898)
  %900 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %899, ptr %900, align 4, !tbaa !14
  %901 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %902 = load float, ptr %901, align 4, !tbaa !11
  %903 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %902, ptr %903, align 4, !tbaa !11
  %904 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %905 = load float, ptr %904, align 4, !tbaa !14
  %906 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %905, ptr %906, align 4, !tbaa !14
  %907 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float 0.000000e+00, ptr %907, align 4, !tbaa !11
  %908 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float 0.000000e+00, ptr %908, align 4, !tbaa !14
  %909 = load ptr, ptr %16, align 8, !tbaa !5
  %910 = load i64, ptr %909, align 8, !tbaa !9
  store i64 %910, ptr %33, align 8, !tbaa !9
  %911 = load i64, ptr %43, align 8, !tbaa !9
  %912 = add nsw i64 %911, 1
  store i64 %912, ptr %45, align 8, !tbaa !9
  br label %913

913:                                              ; preds = %1073, %856
  %914 = load i64, ptr %45, align 8, !tbaa !9
  %915 = load i64, ptr %33, align 8, !tbaa !9
  %916 = icmp sle i64 %914, %915
  br i1 %916, label %917, label %1076

917:                                              ; preds = %913
  %918 = load i64, ptr %45, align 8, !tbaa !9
  %919 = load i64, ptr %44, align 8, !tbaa !9
  %920 = load i64, ptr %30, align 8, !tbaa !9
  %921 = mul nsw i64 %919, %920
  %922 = add nsw i64 %918, %921
  store i64 %922, ptr %34, align 8, !tbaa !9
  %923 = load i64, ptr %45, align 8, !tbaa !9
  %924 = load i64, ptr %44, align 8, !tbaa !9
  %925 = load i64, ptr %30, align 8, !tbaa !9
  %926 = mul nsw i64 %924, %925
  %927 = add nsw i64 %923, %926
  store i64 %927, ptr %35, align 8, !tbaa !9
  %928 = load i64, ptr %45, align 8, !tbaa !9
  %929 = load i64, ptr %43, align 8, !tbaa !9
  %930 = load i64, ptr %26, align 8, !tbaa !9
  %931 = mul nsw i64 %929, %930
  %932 = add nsw i64 %928, %931
  store i64 %932, ptr %36, align 8, !tbaa !9
  %933 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %934 = load float, ptr %933, align 4, !tbaa !11
  %935 = load ptr, ptr %19, align 8, !tbaa !5
  %936 = load i64, ptr %36, align 8, !tbaa !9
  %937 = getelementptr inbounds %struct.complex, ptr %935, i64 %936
  %938 = getelementptr inbounds %struct.complex, ptr %937, i32 0, i32 0
  %939 = load float, ptr %938, align 4, !tbaa !11
  %940 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %941 = load float, ptr %940, align 4, !tbaa !14
  %942 = load ptr, ptr %19, align 8, !tbaa !5
  %943 = load i64, ptr %36, align 8, !tbaa !9
  %944 = getelementptr inbounds %struct.complex, ptr %942, i64 %943
  %945 = getelementptr inbounds %struct.complex, ptr %944, i32 0, i32 1
  %946 = load float, ptr %945, align 4, !tbaa !14
  %947 = fmul float %941, %946
  %948 = fneg float %947
  %949 = call float @llvm.fmuladd.f32(float %934, float %939, float %948)
  %950 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %949, ptr %950, align 4, !tbaa !11
  %951 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %952 = load float, ptr %951, align 4, !tbaa !11
  %953 = load ptr, ptr %19, align 8, !tbaa !5
  %954 = load i64, ptr %36, align 8, !tbaa !9
  %955 = getelementptr inbounds %struct.complex, ptr %953, i64 %954
  %956 = getelementptr inbounds %struct.complex, ptr %955, i32 0, i32 1
  %957 = load float, ptr %956, align 4, !tbaa !14
  %958 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %959 = load float, ptr %958, align 4, !tbaa !14
  %960 = load ptr, ptr %19, align 8, !tbaa !5
  %961 = load i64, ptr %36, align 8, !tbaa !9
  %962 = getelementptr inbounds %struct.complex, ptr %960, i64 %961
  %963 = getelementptr inbounds %struct.complex, ptr %962, i32 0, i32 0
  %964 = load float, ptr %963, align 4, !tbaa !11
  %965 = fmul float %959, %964
  %966 = call float @llvm.fmuladd.f32(float %952, float %957, float %965)
  %967 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %966, ptr %967, align 4, !tbaa !14
  %968 = load ptr, ptr %24, align 8, !tbaa !5
  %969 = load i64, ptr %35, align 8, !tbaa !9
  %970 = getelementptr inbounds %struct.complex, ptr %968, i64 %969
  %971 = getelementptr inbounds %struct.complex, ptr %970, i32 0, i32 0
  %972 = load float, ptr %971, align 4, !tbaa !11
  %973 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %974 = load float, ptr %973, align 4, !tbaa !11
  %975 = fadd float %972, %974
  %976 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %975, ptr %976, align 4, !tbaa !11
  %977 = load ptr, ptr %24, align 8, !tbaa !5
  %978 = load i64, ptr %35, align 8, !tbaa !9
  %979 = getelementptr inbounds %struct.complex, ptr %977, i64 %978
  %980 = getelementptr inbounds %struct.complex, ptr %979, i32 0, i32 1
  %981 = load float, ptr %980, align 4, !tbaa !14
  %982 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %983 = load float, ptr %982, align 4, !tbaa !14
  %984 = fadd float %981, %983
  %985 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %984, ptr %985, align 4, !tbaa !14
  %986 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %987 = load float, ptr %986, align 4, !tbaa !11
  %988 = load ptr, ptr %24, align 8, !tbaa !5
  %989 = load i64, ptr %34, align 8, !tbaa !9
  %990 = getelementptr inbounds %struct.complex, ptr %988, i64 %989
  %991 = getelementptr inbounds %struct.complex, ptr %990, i32 0, i32 0
  store float %987, ptr %991, align 4, !tbaa !11
  %992 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %993 = load float, ptr %992, align 4, !tbaa !14
  %994 = load ptr, ptr %24, align 8, !tbaa !5
  %995 = load i64, ptr %34, align 8, !tbaa !9
  %996 = getelementptr inbounds %struct.complex, ptr %994, i64 %995
  %997 = getelementptr inbounds %struct.complex, ptr %996, i32 0, i32 1
  store float %993, ptr %997, align 4, !tbaa !14
  %998 = load i64, ptr %45, align 8, !tbaa !9
  %999 = load i64, ptr %44, align 8, !tbaa !9
  %1000 = load i64, ptr %28, align 8, !tbaa !9
  %1001 = mul nsw i64 %999, %1000
  %1002 = add nsw i64 %998, %1001
  store i64 %1002, ptr %34, align 8, !tbaa !9
  %1003 = load i64, ptr %45, align 8, !tbaa !9
  %1004 = load i64, ptr %43, align 8, !tbaa !9
  %1005 = load i64, ptr %26, align 8, !tbaa !9
  %1006 = mul nsw i64 %1004, %1005
  %1007 = add nsw i64 %1003, %1006
  store i64 %1007, ptr %35, align 8, !tbaa !9
  %1008 = load ptr, ptr %21, align 8, !tbaa !5
  %1009 = load i64, ptr %34, align 8, !tbaa !9
  %1010 = getelementptr inbounds %struct.complex, ptr %1008, i64 %1009
  %1011 = getelementptr inbounds %struct.complex, ptr %1010, i32 0, i32 0
  %1012 = load float, ptr %1011, align 4, !tbaa !11
  %1013 = load ptr, ptr %19, align 8, !tbaa !5
  %1014 = load i64, ptr %35, align 8, !tbaa !9
  %1015 = getelementptr inbounds %struct.complex, ptr %1013, i64 %1014
  %1016 = getelementptr inbounds %struct.complex, ptr %1015, i32 0, i32 0
  %1017 = load float, ptr %1016, align 4, !tbaa !11
  %1018 = load ptr, ptr %21, align 8, !tbaa !5
  %1019 = load i64, ptr %34, align 8, !tbaa !9
  %1020 = getelementptr inbounds %struct.complex, ptr %1018, i64 %1019
  %1021 = getelementptr inbounds %struct.complex, ptr %1020, i32 0, i32 1
  %1022 = load float, ptr %1021, align 4, !tbaa !14
  %1023 = load ptr, ptr %19, align 8, !tbaa !5
  %1024 = load i64, ptr %35, align 8, !tbaa !9
  %1025 = getelementptr inbounds %struct.complex, ptr %1023, i64 %1024
  %1026 = getelementptr inbounds %struct.complex, ptr %1025, i32 0, i32 1
  %1027 = load float, ptr %1026, align 4, !tbaa !14
  %1028 = fmul float %1022, %1027
  %1029 = fneg float %1028
  %1030 = call float @llvm.fmuladd.f32(float %1012, float %1017, float %1029)
  %1031 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1030, ptr %1031, align 4, !tbaa !11
  %1032 = load ptr, ptr %21, align 8, !tbaa !5
  %1033 = load i64, ptr %34, align 8, !tbaa !9
  %1034 = getelementptr inbounds %struct.complex, ptr %1032, i64 %1033
  %1035 = getelementptr inbounds %struct.complex, ptr %1034, i32 0, i32 0
  %1036 = load float, ptr %1035, align 4, !tbaa !11
  %1037 = load ptr, ptr %19, align 8, !tbaa !5
  %1038 = load i64, ptr %35, align 8, !tbaa !9
  %1039 = getelementptr inbounds %struct.complex, ptr %1037, i64 %1038
  %1040 = getelementptr inbounds %struct.complex, ptr %1039, i32 0, i32 1
  %1041 = load float, ptr %1040, align 4, !tbaa !14
  %1042 = load ptr, ptr %21, align 8, !tbaa !5
  %1043 = load i64, ptr %34, align 8, !tbaa !9
  %1044 = getelementptr inbounds %struct.complex, ptr %1042, i64 %1043
  %1045 = getelementptr inbounds %struct.complex, ptr %1044, i32 0, i32 1
  %1046 = load float, ptr %1045, align 4, !tbaa !14
  %1047 = load ptr, ptr %19, align 8, !tbaa !5
  %1048 = load i64, ptr %35, align 8, !tbaa !9
  %1049 = getelementptr inbounds %struct.complex, ptr %1047, i64 %1048
  %1050 = getelementptr inbounds %struct.complex, ptr %1049, i32 0, i32 0
  %1051 = load float, ptr %1050, align 4, !tbaa !11
  %1052 = fmul float %1046, %1051
  %1053 = call float @llvm.fmuladd.f32(float %1036, float %1041, float %1052)
  %1054 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1053, ptr %1054, align 4, !tbaa !14
  %1055 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1056 = load float, ptr %1055, align 4, !tbaa !11
  %1057 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1058 = load float, ptr %1057, align 4, !tbaa !11
  %1059 = fadd float %1056, %1058
  %1060 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1059, ptr %1060, align 4, !tbaa !11
  %1061 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1062 = load float, ptr %1061, align 4, !tbaa !14
  %1063 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1064 = load float, ptr %1063, align 4, !tbaa !14
  %1065 = fadd float %1062, %1064
  %1066 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1065, ptr %1066, align 4, !tbaa !14
  %1067 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1068 = load float, ptr %1067, align 4, !tbaa !11
  %1069 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %1068, ptr %1069, align 4, !tbaa !11
  %1070 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1071 = load float, ptr %1070, align 4, !tbaa !14
  %1072 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %1071, ptr %1072, align 4, !tbaa !14
  br label %1073

1073:                                             ; preds = %917
  %1074 = load i64, ptr %45, align 8, !tbaa !9
  %1075 = add nsw i64 %1074, 1
  store i64 %1075, ptr %45, align 8, !tbaa !9
  br label %913, !llvm.loop !23

1076:                                             ; preds = %913
  %1077 = load ptr, ptr %23, align 8, !tbaa !5
  %1078 = getelementptr inbounds %struct.complex, ptr %1077, i32 0, i32 0
  %1079 = load float, ptr %1078, align 4, !tbaa !11
  %1080 = fcmp oeq float %1079, 0.000000e+00
  br i1 %1080, label %1081, label %1183

1081:                                             ; preds = %1076
  %1082 = load ptr, ptr %23, align 8, !tbaa !5
  %1083 = getelementptr inbounds %struct.complex, ptr %1082, i32 0, i32 1
  %1084 = load float, ptr %1083, align 4, !tbaa !14
  %1085 = fcmp oeq float %1084, 0.000000e+00
  br i1 %1085, label %1086, label %1183

1086:                                             ; preds = %1081
  %1087 = load i64, ptr %43, align 8, !tbaa !9
  %1088 = load i64, ptr %44, align 8, !tbaa !9
  %1089 = load i64, ptr %30, align 8, !tbaa !9
  %1090 = mul nsw i64 %1088, %1089
  %1091 = add nsw i64 %1087, %1090
  store i64 %1091, ptr %33, align 8, !tbaa !9
  %1092 = load i64, ptr %43, align 8, !tbaa !9
  %1093 = load i64, ptr %43, align 8, !tbaa !9
  %1094 = load i64, ptr %26, align 8, !tbaa !9
  %1095 = mul nsw i64 %1093, %1094
  %1096 = add nsw i64 %1092, %1095
  store i64 %1096, ptr %34, align 8, !tbaa !9
  %1097 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1098 = load float, ptr %1097, align 4, !tbaa !11
  %1099 = load ptr, ptr %19, align 8, !tbaa !5
  %1100 = load i64, ptr %34, align 8, !tbaa !9
  %1101 = getelementptr inbounds %struct.complex, ptr %1099, i64 %1100
  %1102 = getelementptr inbounds %struct.complex, ptr %1101, i32 0, i32 0
  %1103 = load float, ptr %1102, align 4, !tbaa !11
  %1104 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1105 = load float, ptr %1104, align 4, !tbaa !14
  %1106 = load ptr, ptr %19, align 8, !tbaa !5
  %1107 = load i64, ptr %34, align 8, !tbaa !9
  %1108 = getelementptr inbounds %struct.complex, ptr %1106, i64 %1107
  %1109 = getelementptr inbounds %struct.complex, ptr %1108, i32 0, i32 1
  %1110 = load float, ptr %1109, align 4, !tbaa !14
  %1111 = fmul float %1105, %1110
  %1112 = fneg float %1111
  %1113 = call float @llvm.fmuladd.f32(float %1098, float %1103, float %1112)
  %1114 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1113, ptr %1114, align 4, !tbaa !11
  %1115 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1116 = load float, ptr %1115, align 4, !tbaa !11
  %1117 = load ptr, ptr %19, align 8, !tbaa !5
  %1118 = load i64, ptr %34, align 8, !tbaa !9
  %1119 = getelementptr inbounds %struct.complex, ptr %1117, i64 %1118
  %1120 = getelementptr inbounds %struct.complex, ptr %1119, i32 0, i32 1
  %1121 = load float, ptr %1120, align 4, !tbaa !14
  %1122 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1123 = load float, ptr %1122, align 4, !tbaa !14
  %1124 = load ptr, ptr %19, align 8, !tbaa !5
  %1125 = load i64, ptr %34, align 8, !tbaa !9
  %1126 = getelementptr inbounds %struct.complex, ptr %1124, i64 %1125
  %1127 = getelementptr inbounds %struct.complex, ptr %1126, i32 0, i32 0
  %1128 = load float, ptr %1127, align 4, !tbaa !11
  %1129 = fmul float %1123, %1128
  %1130 = call float @llvm.fmuladd.f32(float %1116, float %1121, float %1129)
  %1131 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1130, ptr %1131, align 4, !tbaa !14
  %1132 = load ptr, ptr %18, align 8, !tbaa !5
  %1133 = getelementptr inbounds %struct.complex, ptr %1132, i32 0, i32 0
  %1134 = load float, ptr %1133, align 4, !tbaa !11
  %1135 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1136 = load float, ptr %1135, align 4, !tbaa !11
  %1137 = load ptr, ptr %18, align 8, !tbaa !5
  %1138 = getelementptr inbounds %struct.complex, ptr %1137, i32 0, i32 1
  %1139 = load float, ptr %1138, align 4, !tbaa !14
  %1140 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1141 = load float, ptr %1140, align 4, !tbaa !14
  %1142 = fmul float %1139, %1141
  %1143 = fneg float %1142
  %1144 = call float @llvm.fmuladd.f32(float %1134, float %1136, float %1143)
  %1145 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1144, ptr %1145, align 4, !tbaa !11
  %1146 = load ptr, ptr %18, align 8, !tbaa !5
  %1147 = getelementptr inbounds %struct.complex, ptr %1146, i32 0, i32 0
  %1148 = load float, ptr %1147, align 4, !tbaa !11
  %1149 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1150 = load float, ptr %1149, align 4, !tbaa !14
  %1151 = load ptr, ptr %18, align 8, !tbaa !5
  %1152 = getelementptr inbounds %struct.complex, ptr %1151, i32 0, i32 1
  %1153 = load float, ptr %1152, align 4, !tbaa !14
  %1154 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1155 = load float, ptr %1154, align 4, !tbaa !11
  %1156 = fmul float %1153, %1155
  %1157 = call float @llvm.fmuladd.f32(float %1148, float %1150, float %1156)
  %1158 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1157, ptr %1158, align 4, !tbaa !14
  %1159 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1160 = load float, ptr %1159, align 4, !tbaa !11
  %1161 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1162 = load float, ptr %1161, align 4, !tbaa !11
  %1163 = fadd float %1160, %1162
  %1164 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1163, ptr %1164, align 4, !tbaa !11
  %1165 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1166 = load float, ptr %1165, align 4, !tbaa !14
  %1167 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1168 = load float, ptr %1167, align 4, !tbaa !14
  %1169 = fadd float %1166, %1168
  %1170 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1169, ptr %1170, align 4, !tbaa !14
  %1171 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1172 = load float, ptr %1171, align 4, !tbaa !11
  %1173 = load ptr, ptr %24, align 8, !tbaa !5
  %1174 = load i64, ptr %33, align 8, !tbaa !9
  %1175 = getelementptr inbounds %struct.complex, ptr %1173, i64 %1174
  %1176 = getelementptr inbounds %struct.complex, ptr %1175, i32 0, i32 0
  store float %1172, ptr %1176, align 4, !tbaa !11
  %1177 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1178 = load float, ptr %1177, align 4, !tbaa !14
  %1179 = load ptr, ptr %24, align 8, !tbaa !5
  %1180 = load i64, ptr %33, align 8, !tbaa !9
  %1181 = getelementptr inbounds %struct.complex, ptr %1179, i64 %1180
  %1182 = getelementptr inbounds %struct.complex, ptr %1181, i32 0, i32 1
  store float %1178, ptr %1182, align 4, !tbaa !14
  br label %1336

1183:                                             ; preds = %1081, %1076
  %1184 = load i64, ptr %43, align 8, !tbaa !9
  %1185 = load i64, ptr %44, align 8, !tbaa !9
  %1186 = load i64, ptr %30, align 8, !tbaa !9
  %1187 = mul nsw i64 %1185, %1186
  %1188 = add nsw i64 %1184, %1187
  store i64 %1188, ptr %33, align 8, !tbaa !9
  %1189 = load i64, ptr %43, align 8, !tbaa !9
  %1190 = load i64, ptr %44, align 8, !tbaa !9
  %1191 = load i64, ptr %30, align 8, !tbaa !9
  %1192 = mul nsw i64 %1190, %1191
  %1193 = add nsw i64 %1189, %1192
  store i64 %1193, ptr %34, align 8, !tbaa !9
  %1194 = load ptr, ptr %23, align 8, !tbaa !5
  %1195 = getelementptr inbounds %struct.complex, ptr %1194, i32 0, i32 0
  %1196 = load float, ptr %1195, align 4, !tbaa !11
  %1197 = load ptr, ptr %24, align 8, !tbaa !5
  %1198 = load i64, ptr %34, align 8, !tbaa !9
  %1199 = getelementptr inbounds %struct.complex, ptr %1197, i64 %1198
  %1200 = getelementptr inbounds %struct.complex, ptr %1199, i32 0, i32 0
  %1201 = load float, ptr %1200, align 4, !tbaa !11
  %1202 = load ptr, ptr %23, align 8, !tbaa !5
  %1203 = getelementptr inbounds %struct.complex, ptr %1202, i32 0, i32 1
  %1204 = load float, ptr %1203, align 4, !tbaa !14
  %1205 = load ptr, ptr %24, align 8, !tbaa !5
  %1206 = load i64, ptr %34, align 8, !tbaa !9
  %1207 = getelementptr inbounds %struct.complex, ptr %1205, i64 %1206
  %1208 = getelementptr inbounds %struct.complex, ptr %1207, i32 0, i32 1
  %1209 = load float, ptr %1208, align 4, !tbaa !14
  %1210 = fmul float %1204, %1209
  %1211 = fneg float %1210
  %1212 = call float @llvm.fmuladd.f32(float %1196, float %1201, float %1211)
  %1213 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1212, ptr %1213, align 4, !tbaa !11
  %1214 = load ptr, ptr %23, align 8, !tbaa !5
  %1215 = getelementptr inbounds %struct.complex, ptr %1214, i32 0, i32 0
  %1216 = load float, ptr %1215, align 4, !tbaa !11
  %1217 = load ptr, ptr %24, align 8, !tbaa !5
  %1218 = load i64, ptr %34, align 8, !tbaa !9
  %1219 = getelementptr inbounds %struct.complex, ptr %1217, i64 %1218
  %1220 = getelementptr inbounds %struct.complex, ptr %1219, i32 0, i32 1
  %1221 = load float, ptr %1220, align 4, !tbaa !14
  %1222 = load ptr, ptr %23, align 8, !tbaa !5
  %1223 = getelementptr inbounds %struct.complex, ptr %1222, i32 0, i32 1
  %1224 = load float, ptr %1223, align 4, !tbaa !14
  %1225 = load ptr, ptr %24, align 8, !tbaa !5
  %1226 = load i64, ptr %34, align 8, !tbaa !9
  %1227 = getelementptr inbounds %struct.complex, ptr %1225, i64 %1226
  %1228 = getelementptr inbounds %struct.complex, ptr %1227, i32 0, i32 0
  %1229 = load float, ptr %1228, align 4, !tbaa !11
  %1230 = fmul float %1224, %1229
  %1231 = call float @llvm.fmuladd.f32(float %1216, float %1221, float %1230)
  %1232 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1231, ptr %1232, align 4, !tbaa !14
  %1233 = load i64, ptr %43, align 8, !tbaa !9
  %1234 = load i64, ptr %43, align 8, !tbaa !9
  %1235 = load i64, ptr %26, align 8, !tbaa !9
  %1236 = mul nsw i64 %1234, %1235
  %1237 = add nsw i64 %1233, %1236
  store i64 %1237, ptr %35, align 8, !tbaa !9
  %1238 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1239 = load float, ptr %1238, align 4, !tbaa !11
  %1240 = load ptr, ptr %19, align 8, !tbaa !5
  %1241 = load i64, ptr %35, align 8, !tbaa !9
  %1242 = getelementptr inbounds %struct.complex, ptr %1240, i64 %1241
  %1243 = getelementptr inbounds %struct.complex, ptr %1242, i32 0, i32 0
  %1244 = load float, ptr %1243, align 4, !tbaa !11
  %1245 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1246 = load float, ptr %1245, align 4, !tbaa !14
  %1247 = load ptr, ptr %19, align 8, !tbaa !5
  %1248 = load i64, ptr %35, align 8, !tbaa !9
  %1249 = getelementptr inbounds %struct.complex, ptr %1247, i64 %1248
  %1250 = getelementptr inbounds %struct.complex, ptr %1249, i32 0, i32 1
  %1251 = load float, ptr %1250, align 4, !tbaa !14
  %1252 = fmul float %1246, %1251
  %1253 = fneg float %1252
  %1254 = call float @llvm.fmuladd.f32(float %1239, float %1244, float %1253)
  %1255 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %1254, ptr %1255, align 4, !tbaa !11
  %1256 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1257 = load float, ptr %1256, align 4, !tbaa !11
  %1258 = load ptr, ptr %19, align 8, !tbaa !5
  %1259 = load i64, ptr %35, align 8, !tbaa !9
  %1260 = getelementptr inbounds %struct.complex, ptr %1258, i64 %1259
  %1261 = getelementptr inbounds %struct.complex, ptr %1260, i32 0, i32 1
  %1262 = load float, ptr %1261, align 4, !tbaa !14
  %1263 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1264 = load float, ptr %1263, align 4, !tbaa !14
  %1265 = load ptr, ptr %19, align 8, !tbaa !5
  %1266 = load i64, ptr %35, align 8, !tbaa !9
  %1267 = getelementptr inbounds %struct.complex, ptr %1265, i64 %1266
  %1268 = getelementptr inbounds %struct.complex, ptr %1267, i32 0, i32 0
  %1269 = load float, ptr %1268, align 4, !tbaa !11
  %1270 = fmul float %1264, %1269
  %1271 = call float @llvm.fmuladd.f32(float %1257, float %1262, float %1270)
  %1272 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %1271, ptr %1272, align 4, !tbaa !14
  %1273 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1274 = load float, ptr %1273, align 4, !tbaa !11
  %1275 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %1276 = load float, ptr %1275, align 4, !tbaa !11
  %1277 = fadd float %1274, %1276
  %1278 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1277, ptr %1278, align 4, !tbaa !11
  %1279 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1280 = load float, ptr %1279, align 4, !tbaa !14
  %1281 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %1282 = load float, ptr %1281, align 4, !tbaa !14
  %1283 = fadd float %1280, %1282
  %1284 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1283, ptr %1284, align 4, !tbaa !14
  %1285 = load ptr, ptr %18, align 8, !tbaa !5
  %1286 = getelementptr inbounds %struct.complex, ptr %1285, i32 0, i32 0
  %1287 = load float, ptr %1286, align 4, !tbaa !11
  %1288 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1289 = load float, ptr %1288, align 4, !tbaa !11
  %1290 = load ptr, ptr %18, align 8, !tbaa !5
  %1291 = getelementptr inbounds %struct.complex, ptr %1290, i32 0, i32 1
  %1292 = load float, ptr %1291, align 4, !tbaa !14
  %1293 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1294 = load float, ptr %1293, align 4, !tbaa !14
  %1295 = fmul float %1292, %1294
  %1296 = fneg float %1295
  %1297 = call float @llvm.fmuladd.f32(float %1287, float %1289, float %1296)
  %1298 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %1297, ptr %1298, align 4, !tbaa !11
  %1299 = load ptr, ptr %18, align 8, !tbaa !5
  %1300 = getelementptr inbounds %struct.complex, ptr %1299, i32 0, i32 0
  %1301 = load float, ptr %1300, align 4, !tbaa !11
  %1302 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1303 = load float, ptr %1302, align 4, !tbaa !14
  %1304 = load ptr, ptr %18, align 8, !tbaa !5
  %1305 = getelementptr inbounds %struct.complex, ptr %1304, i32 0, i32 1
  %1306 = load float, ptr %1305, align 4, !tbaa !14
  %1307 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1308 = load float, ptr %1307, align 4, !tbaa !11
  %1309 = fmul float %1306, %1308
  %1310 = call float @llvm.fmuladd.f32(float %1301, float %1303, float %1309)
  %1311 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %1310, ptr %1311, align 4, !tbaa !14
  %1312 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1313 = load float, ptr %1312, align 4, !tbaa !11
  %1314 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %1315 = load float, ptr %1314, align 4, !tbaa !11
  %1316 = fadd float %1313, %1315
  %1317 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1316, ptr %1317, align 4, !tbaa !11
  %1318 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1319 = load float, ptr %1318, align 4, !tbaa !14
  %1320 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %1321 = load float, ptr %1320, align 4, !tbaa !14
  %1322 = fadd float %1319, %1321
  %1323 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1322, ptr %1323, align 4, !tbaa !14
  %1324 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1325 = load float, ptr %1324, align 4, !tbaa !11
  %1326 = load ptr, ptr %24, align 8, !tbaa !5
  %1327 = load i64, ptr %33, align 8, !tbaa !9
  %1328 = getelementptr inbounds %struct.complex, ptr %1326, i64 %1327
  %1329 = getelementptr inbounds %struct.complex, ptr %1328, i32 0, i32 0
  store float %1325, ptr %1329, align 4, !tbaa !11
  %1330 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1331 = load float, ptr %1330, align 4, !tbaa !14
  %1332 = load ptr, ptr %24, align 8, !tbaa !5
  %1333 = load i64, ptr %33, align 8, !tbaa !9
  %1334 = getelementptr inbounds %struct.complex, ptr %1332, i64 %1333
  %1335 = getelementptr inbounds %struct.complex, ptr %1334, i32 0, i32 1
  store float %1331, ptr %1335, align 4, !tbaa !14
  br label %1336

1336:                                             ; preds = %1183, %1086
  br label %1337

1337:                                             ; preds = %1336
  %1338 = load i64, ptr %43, align 8, !tbaa !9
  %1339 = add nsw i64 %1338, -1
  store i64 %1339, ptr %43, align 8, !tbaa !9
  br label %853, !llvm.loop !24

1340:                                             ; preds = %853
  br label %1341

1341:                                             ; preds = %1340
  %1342 = load i64, ptr %44, align 8, !tbaa !9
  %1343 = add nsw i64 %1342, 1
  store i64 %1343, ptr %44, align 8, !tbaa !9
  br label %846, !llvm.loop !25

1344:                                             ; preds = %846
  br label %1345

1345:                                             ; preds = %1344, %842
  br label %2028

1346:                                             ; preds = %335
  %1347 = load ptr, ptr %17, align 8, !tbaa !5
  %1348 = load i64, ptr %1347, align 8, !tbaa !9
  store i64 %1348, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %1349

1349:                                             ; preds = %2024, %1346
  %1350 = load i64, ptr %44, align 8, !tbaa !9
  %1351 = load i64, ptr %32, align 8, !tbaa !9
  %1352 = icmp sle i64 %1350, %1351
  br i1 %1352, label %1353, label %2027

1353:                                             ; preds = %1349
  %1354 = load i64, ptr %44, align 8, !tbaa !9
  %1355 = load i64, ptr %44, align 8, !tbaa !9
  %1356 = load i64, ptr %26, align 8, !tbaa !9
  %1357 = mul nsw i64 %1355, %1356
  %1358 = add nsw i64 %1354, %1357
  store i64 %1358, ptr %33, align 8, !tbaa !9
  %1359 = load ptr, ptr %18, align 8, !tbaa !5
  %1360 = getelementptr inbounds %struct.complex, ptr %1359, i32 0, i32 0
  %1361 = load float, ptr %1360, align 4, !tbaa !11
  %1362 = load ptr, ptr %19, align 8, !tbaa !5
  %1363 = load i64, ptr %33, align 8, !tbaa !9
  %1364 = getelementptr inbounds %struct.complex, ptr %1362, i64 %1363
  %1365 = getelementptr inbounds %struct.complex, ptr %1364, i32 0, i32 0
  %1366 = load float, ptr %1365, align 4, !tbaa !11
  %1367 = load ptr, ptr %18, align 8, !tbaa !5
  %1368 = getelementptr inbounds %struct.complex, ptr %1367, i32 0, i32 1
  %1369 = load float, ptr %1368, align 4, !tbaa !14
  %1370 = load ptr, ptr %19, align 8, !tbaa !5
  %1371 = load i64, ptr %33, align 8, !tbaa !9
  %1372 = getelementptr inbounds %struct.complex, ptr %1370, i64 %1371
  %1373 = getelementptr inbounds %struct.complex, ptr %1372, i32 0, i32 1
  %1374 = load float, ptr %1373, align 4, !tbaa !14
  %1375 = fmul float %1369, %1374
  %1376 = fneg float %1375
  %1377 = call float @llvm.fmuladd.f32(float %1361, float %1366, float %1376)
  %1378 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1377, ptr %1378, align 4, !tbaa !11
  %1379 = load ptr, ptr %18, align 8, !tbaa !5
  %1380 = getelementptr inbounds %struct.complex, ptr %1379, i32 0, i32 0
  %1381 = load float, ptr %1380, align 4, !tbaa !11
  %1382 = load ptr, ptr %19, align 8, !tbaa !5
  %1383 = load i64, ptr %33, align 8, !tbaa !9
  %1384 = getelementptr inbounds %struct.complex, ptr %1382, i64 %1383
  %1385 = getelementptr inbounds %struct.complex, ptr %1384, i32 0, i32 1
  %1386 = load float, ptr %1385, align 4, !tbaa !14
  %1387 = load ptr, ptr %18, align 8, !tbaa !5
  %1388 = getelementptr inbounds %struct.complex, ptr %1387, i32 0, i32 1
  %1389 = load float, ptr %1388, align 4, !tbaa !14
  %1390 = load ptr, ptr %19, align 8, !tbaa !5
  %1391 = load i64, ptr %33, align 8, !tbaa !9
  %1392 = getelementptr inbounds %struct.complex, ptr %1390, i64 %1391
  %1393 = getelementptr inbounds %struct.complex, ptr %1392, i32 0, i32 0
  %1394 = load float, ptr %1393, align 4, !tbaa !11
  %1395 = fmul float %1389, %1394
  %1396 = call float @llvm.fmuladd.f32(float %1381, float %1386, float %1395)
  %1397 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1396, ptr %1397, align 4, !tbaa !14
  %1398 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1399 = load float, ptr %1398, align 4, !tbaa !11
  %1400 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %1399, ptr %1400, align 4, !tbaa !11
  %1401 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1402 = load float, ptr %1401, align 4, !tbaa !14
  %1403 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %1402, ptr %1403, align 4, !tbaa !14
  %1404 = load ptr, ptr %23, align 8, !tbaa !5
  %1405 = getelementptr inbounds %struct.complex, ptr %1404, i32 0, i32 0
  %1406 = load float, ptr %1405, align 4, !tbaa !11
  %1407 = fcmp oeq float %1406, 0.000000e+00
  br i1 %1407, label %1408, label %1482

1408:                                             ; preds = %1353
  %1409 = load ptr, ptr %23, align 8, !tbaa !5
  %1410 = getelementptr inbounds %struct.complex, ptr %1409, i32 0, i32 1
  %1411 = load float, ptr %1410, align 4, !tbaa !14
  %1412 = fcmp oeq float %1411, 0.000000e+00
  br i1 %1412, label %1413, label %1482

1413:                                             ; preds = %1408
  %1414 = load ptr, ptr %16, align 8, !tbaa !5
  %1415 = load i64, ptr %1414, align 8, !tbaa !9
  store i64 %1415, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %1416

1416:                                             ; preds = %1478, %1413
  %1417 = load i64, ptr %43, align 8, !tbaa !9
  %1418 = load i64, ptr %33, align 8, !tbaa !9
  %1419 = icmp sle i64 %1417, %1418
  br i1 %1419, label %1420, label %1481

1420:                                             ; preds = %1416
  %1421 = load i64, ptr %43, align 8, !tbaa !9
  %1422 = load i64, ptr %44, align 8, !tbaa !9
  %1423 = load i64, ptr %30, align 8, !tbaa !9
  %1424 = mul nsw i64 %1422, %1423
  %1425 = add nsw i64 %1421, %1424
  store i64 %1425, ptr %34, align 8, !tbaa !9
  %1426 = load i64, ptr %43, align 8, !tbaa !9
  %1427 = load i64, ptr %44, align 8, !tbaa !9
  %1428 = load i64, ptr %28, align 8, !tbaa !9
  %1429 = mul nsw i64 %1427, %1428
  %1430 = add nsw i64 %1426, %1429
  store i64 %1430, ptr %35, align 8, !tbaa !9
  %1431 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1432 = load float, ptr %1431, align 4, !tbaa !11
  %1433 = load ptr, ptr %21, align 8, !tbaa !5
  %1434 = load i64, ptr %35, align 8, !tbaa !9
  %1435 = getelementptr inbounds %struct.complex, ptr %1433, i64 %1434
  %1436 = getelementptr inbounds %struct.complex, ptr %1435, i32 0, i32 0
  %1437 = load float, ptr %1436, align 4, !tbaa !11
  %1438 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1439 = load float, ptr %1438, align 4, !tbaa !14
  %1440 = load ptr, ptr %21, align 8, !tbaa !5
  %1441 = load i64, ptr %35, align 8, !tbaa !9
  %1442 = getelementptr inbounds %struct.complex, ptr %1440, i64 %1441
  %1443 = getelementptr inbounds %struct.complex, ptr %1442, i32 0, i32 1
  %1444 = load float, ptr %1443, align 4, !tbaa !14
  %1445 = fmul float %1439, %1444
  %1446 = fneg float %1445
  %1447 = call float @llvm.fmuladd.f32(float %1432, float %1437, float %1446)
  %1448 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1447, ptr %1448, align 4, !tbaa !11
  %1449 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1450 = load float, ptr %1449, align 4, !tbaa !11
  %1451 = load ptr, ptr %21, align 8, !tbaa !5
  %1452 = load i64, ptr %35, align 8, !tbaa !9
  %1453 = getelementptr inbounds %struct.complex, ptr %1451, i64 %1452
  %1454 = getelementptr inbounds %struct.complex, ptr %1453, i32 0, i32 1
  %1455 = load float, ptr %1454, align 4, !tbaa !14
  %1456 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1457 = load float, ptr %1456, align 4, !tbaa !14
  %1458 = load ptr, ptr %21, align 8, !tbaa !5
  %1459 = load i64, ptr %35, align 8, !tbaa !9
  %1460 = getelementptr inbounds %struct.complex, ptr %1458, i64 %1459
  %1461 = getelementptr inbounds %struct.complex, ptr %1460, i32 0, i32 0
  %1462 = load float, ptr %1461, align 4, !tbaa !11
  %1463 = fmul float %1457, %1462
  %1464 = call float @llvm.fmuladd.f32(float %1450, float %1455, float %1463)
  %1465 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1464, ptr %1465, align 4, !tbaa !14
  %1466 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1467 = load float, ptr %1466, align 4, !tbaa !11
  %1468 = load ptr, ptr %24, align 8, !tbaa !5
  %1469 = load i64, ptr %34, align 8, !tbaa !9
  %1470 = getelementptr inbounds %struct.complex, ptr %1468, i64 %1469
  %1471 = getelementptr inbounds %struct.complex, ptr %1470, i32 0, i32 0
  store float %1467, ptr %1471, align 4, !tbaa !11
  %1472 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1473 = load float, ptr %1472, align 4, !tbaa !14
  %1474 = load ptr, ptr %24, align 8, !tbaa !5
  %1475 = load i64, ptr %34, align 8, !tbaa !9
  %1476 = getelementptr inbounds %struct.complex, ptr %1474, i64 %1475
  %1477 = getelementptr inbounds %struct.complex, ptr %1476, i32 0, i32 1
  store float %1473, ptr %1477, align 4, !tbaa !14
  br label %1478

1478:                                             ; preds = %1420
  %1479 = load i64, ptr %43, align 8, !tbaa !9
  %1480 = add nsw i64 %1479, 1
  store i64 %1480, ptr %43, align 8, !tbaa !9
  br label %1416, !llvm.loop !26

1481:                                             ; preds = %1416
  br label %1607

1482:                                             ; preds = %1408, %1353
  %1483 = load ptr, ptr %16, align 8, !tbaa !5
  %1484 = load i64, ptr %1483, align 8, !tbaa !9
  store i64 %1484, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %1485

1485:                                             ; preds = %1603, %1482
  %1486 = load i64, ptr %43, align 8, !tbaa !9
  %1487 = load i64, ptr %33, align 8, !tbaa !9
  %1488 = icmp sle i64 %1486, %1487
  br i1 %1488, label %1489, label %1606

1489:                                             ; preds = %1485
  %1490 = load i64, ptr %43, align 8, !tbaa !9
  %1491 = load i64, ptr %44, align 8, !tbaa !9
  %1492 = load i64, ptr %30, align 8, !tbaa !9
  %1493 = mul nsw i64 %1491, %1492
  %1494 = add nsw i64 %1490, %1493
  store i64 %1494, ptr %34, align 8, !tbaa !9
  %1495 = load i64, ptr %43, align 8, !tbaa !9
  %1496 = load i64, ptr %44, align 8, !tbaa !9
  %1497 = load i64, ptr %30, align 8, !tbaa !9
  %1498 = mul nsw i64 %1496, %1497
  %1499 = add nsw i64 %1495, %1498
  store i64 %1499, ptr %35, align 8, !tbaa !9
  %1500 = load ptr, ptr %23, align 8, !tbaa !5
  %1501 = getelementptr inbounds %struct.complex, ptr %1500, i32 0, i32 0
  %1502 = load float, ptr %1501, align 4, !tbaa !11
  %1503 = load ptr, ptr %24, align 8, !tbaa !5
  %1504 = load i64, ptr %35, align 8, !tbaa !9
  %1505 = getelementptr inbounds %struct.complex, ptr %1503, i64 %1504
  %1506 = getelementptr inbounds %struct.complex, ptr %1505, i32 0, i32 0
  %1507 = load float, ptr %1506, align 4, !tbaa !11
  %1508 = load ptr, ptr %23, align 8, !tbaa !5
  %1509 = getelementptr inbounds %struct.complex, ptr %1508, i32 0, i32 1
  %1510 = load float, ptr %1509, align 4, !tbaa !14
  %1511 = load ptr, ptr %24, align 8, !tbaa !5
  %1512 = load i64, ptr %35, align 8, !tbaa !9
  %1513 = getelementptr inbounds %struct.complex, ptr %1511, i64 %1512
  %1514 = getelementptr inbounds %struct.complex, ptr %1513, i32 0, i32 1
  %1515 = load float, ptr %1514, align 4, !tbaa !14
  %1516 = fmul float %1510, %1515
  %1517 = fneg float %1516
  %1518 = call float @llvm.fmuladd.f32(float %1502, float %1507, float %1517)
  %1519 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1518, ptr %1519, align 4, !tbaa !11
  %1520 = load ptr, ptr %23, align 8, !tbaa !5
  %1521 = getelementptr inbounds %struct.complex, ptr %1520, i32 0, i32 0
  %1522 = load float, ptr %1521, align 4, !tbaa !11
  %1523 = load ptr, ptr %24, align 8, !tbaa !5
  %1524 = load i64, ptr %35, align 8, !tbaa !9
  %1525 = getelementptr inbounds %struct.complex, ptr %1523, i64 %1524
  %1526 = getelementptr inbounds %struct.complex, ptr %1525, i32 0, i32 1
  %1527 = load float, ptr %1526, align 4, !tbaa !14
  %1528 = load ptr, ptr %23, align 8, !tbaa !5
  %1529 = getelementptr inbounds %struct.complex, ptr %1528, i32 0, i32 1
  %1530 = load float, ptr %1529, align 4, !tbaa !14
  %1531 = load ptr, ptr %24, align 8, !tbaa !5
  %1532 = load i64, ptr %35, align 8, !tbaa !9
  %1533 = getelementptr inbounds %struct.complex, ptr %1531, i64 %1532
  %1534 = getelementptr inbounds %struct.complex, ptr %1533, i32 0, i32 0
  %1535 = load float, ptr %1534, align 4, !tbaa !11
  %1536 = fmul float %1530, %1535
  %1537 = call float @llvm.fmuladd.f32(float %1522, float %1527, float %1536)
  %1538 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1537, ptr %1538, align 4, !tbaa !14
  %1539 = load i64, ptr %43, align 8, !tbaa !9
  %1540 = load i64, ptr %44, align 8, !tbaa !9
  %1541 = load i64, ptr %28, align 8, !tbaa !9
  %1542 = mul nsw i64 %1540, %1541
  %1543 = add nsw i64 %1539, %1542
  store i64 %1543, ptr %36, align 8, !tbaa !9
  %1544 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1545 = load float, ptr %1544, align 4, !tbaa !11
  %1546 = load ptr, ptr %21, align 8, !tbaa !5
  %1547 = load i64, ptr %36, align 8, !tbaa !9
  %1548 = getelementptr inbounds %struct.complex, ptr %1546, i64 %1547
  %1549 = getelementptr inbounds %struct.complex, ptr %1548, i32 0, i32 0
  %1550 = load float, ptr %1549, align 4, !tbaa !11
  %1551 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1552 = load float, ptr %1551, align 4, !tbaa !14
  %1553 = load ptr, ptr %21, align 8, !tbaa !5
  %1554 = load i64, ptr %36, align 8, !tbaa !9
  %1555 = getelementptr inbounds %struct.complex, ptr %1553, i64 %1554
  %1556 = getelementptr inbounds %struct.complex, ptr %1555, i32 0, i32 1
  %1557 = load float, ptr %1556, align 4, !tbaa !14
  %1558 = fmul float %1552, %1557
  %1559 = fneg float %1558
  %1560 = call float @llvm.fmuladd.f32(float %1545, float %1550, float %1559)
  %1561 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1560, ptr %1561, align 4, !tbaa !11
  %1562 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1563 = load float, ptr %1562, align 4, !tbaa !11
  %1564 = load ptr, ptr %21, align 8, !tbaa !5
  %1565 = load i64, ptr %36, align 8, !tbaa !9
  %1566 = getelementptr inbounds %struct.complex, ptr %1564, i64 %1565
  %1567 = getelementptr inbounds %struct.complex, ptr %1566, i32 0, i32 1
  %1568 = load float, ptr %1567, align 4, !tbaa !14
  %1569 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1570 = load float, ptr %1569, align 4, !tbaa !14
  %1571 = load ptr, ptr %21, align 8, !tbaa !5
  %1572 = load i64, ptr %36, align 8, !tbaa !9
  %1573 = getelementptr inbounds %struct.complex, ptr %1571, i64 %1572
  %1574 = getelementptr inbounds %struct.complex, ptr %1573, i32 0, i32 0
  %1575 = load float, ptr %1574, align 4, !tbaa !11
  %1576 = fmul float %1570, %1575
  %1577 = call float @llvm.fmuladd.f32(float %1563, float %1568, float %1576)
  %1578 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1577, ptr %1578, align 4, !tbaa !14
  %1579 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1580 = load float, ptr %1579, align 4, !tbaa !11
  %1581 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1582 = load float, ptr %1581, align 4, !tbaa !11
  %1583 = fadd float %1580, %1582
  %1584 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1583, ptr %1584, align 4, !tbaa !11
  %1585 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1586 = load float, ptr %1585, align 4, !tbaa !14
  %1587 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1588 = load float, ptr %1587, align 4, !tbaa !14
  %1589 = fadd float %1586, %1588
  %1590 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1589, ptr %1590, align 4, !tbaa !14
  %1591 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1592 = load float, ptr %1591, align 4, !tbaa !11
  %1593 = load ptr, ptr %24, align 8, !tbaa !5
  %1594 = load i64, ptr %34, align 8, !tbaa !9
  %1595 = getelementptr inbounds %struct.complex, ptr %1593, i64 %1594
  %1596 = getelementptr inbounds %struct.complex, ptr %1595, i32 0, i32 0
  store float %1592, ptr %1596, align 4, !tbaa !11
  %1597 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1598 = load float, ptr %1597, align 4, !tbaa !14
  %1599 = load ptr, ptr %24, align 8, !tbaa !5
  %1600 = load i64, ptr %34, align 8, !tbaa !9
  %1601 = getelementptr inbounds %struct.complex, ptr %1599, i64 %1600
  %1602 = getelementptr inbounds %struct.complex, ptr %1601, i32 0, i32 1
  store float %1598, ptr %1602, align 4, !tbaa !14
  br label %1603

1603:                                             ; preds = %1489
  %1604 = load i64, ptr %43, align 8, !tbaa !9
  %1605 = add nsw i64 %1604, 1
  store i64 %1605, ptr %43, align 8, !tbaa !9
  br label %1485, !llvm.loop !27

1606:                                             ; preds = %1485
  br label %1607

1607:                                             ; preds = %1606, %1481
  %1608 = load i64, ptr %44, align 8, !tbaa !9
  %1609 = sub nsw i64 %1608, 1
  store i64 %1609, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %1610

1610:                                             ; preds = %1811, %1607
  %1611 = load i64, ptr %45, align 8, !tbaa !9
  %1612 = load i64, ptr %33, align 8, !tbaa !9
  %1613 = icmp sle i64 %1611, %1612
  br i1 %1613, label %1614, label %1814

1614:                                             ; preds = %1610
  %1615 = load i64, ptr %50, align 8, !tbaa !9
  %1616 = icmp ne i64 %1615, 0
  br i1 %1616, label %1617, label %1668

1617:                                             ; preds = %1614
  %1618 = load i64, ptr %45, align 8, !tbaa !9
  %1619 = load i64, ptr %44, align 8, !tbaa !9
  %1620 = load i64, ptr %26, align 8, !tbaa !9
  %1621 = mul nsw i64 %1619, %1620
  %1622 = add nsw i64 %1618, %1621
  store i64 %1622, ptr %34, align 8, !tbaa !9
  %1623 = load ptr, ptr %18, align 8, !tbaa !5
  %1624 = getelementptr inbounds %struct.complex, ptr %1623, i32 0, i32 0
  %1625 = load float, ptr %1624, align 4, !tbaa !11
  %1626 = load ptr, ptr %19, align 8, !tbaa !5
  %1627 = load i64, ptr %34, align 8, !tbaa !9
  %1628 = getelementptr inbounds %struct.complex, ptr %1626, i64 %1627
  %1629 = getelementptr inbounds %struct.complex, ptr %1628, i32 0, i32 0
  %1630 = load float, ptr %1629, align 4, !tbaa !11
  %1631 = load ptr, ptr %18, align 8, !tbaa !5
  %1632 = getelementptr inbounds %struct.complex, ptr %1631, i32 0, i32 1
  %1633 = load float, ptr %1632, align 4, !tbaa !14
  %1634 = load ptr, ptr %19, align 8, !tbaa !5
  %1635 = load i64, ptr %34, align 8, !tbaa !9
  %1636 = getelementptr inbounds %struct.complex, ptr %1634, i64 %1635
  %1637 = getelementptr inbounds %struct.complex, ptr %1636, i32 0, i32 1
  %1638 = load float, ptr %1637, align 4, !tbaa !14
  %1639 = fmul float %1633, %1638
  %1640 = fneg float %1639
  %1641 = call float @llvm.fmuladd.f32(float %1625, float %1630, float %1640)
  %1642 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1641, ptr %1642, align 4, !tbaa !11
  %1643 = load ptr, ptr %18, align 8, !tbaa !5
  %1644 = getelementptr inbounds %struct.complex, ptr %1643, i32 0, i32 0
  %1645 = load float, ptr %1644, align 4, !tbaa !11
  %1646 = load ptr, ptr %19, align 8, !tbaa !5
  %1647 = load i64, ptr %34, align 8, !tbaa !9
  %1648 = getelementptr inbounds %struct.complex, ptr %1646, i64 %1647
  %1649 = getelementptr inbounds %struct.complex, ptr %1648, i32 0, i32 1
  %1650 = load float, ptr %1649, align 4, !tbaa !14
  %1651 = load ptr, ptr %18, align 8, !tbaa !5
  %1652 = getelementptr inbounds %struct.complex, ptr %1651, i32 0, i32 1
  %1653 = load float, ptr %1652, align 4, !tbaa !14
  %1654 = load ptr, ptr %19, align 8, !tbaa !5
  %1655 = load i64, ptr %34, align 8, !tbaa !9
  %1656 = getelementptr inbounds %struct.complex, ptr %1654, i64 %1655
  %1657 = getelementptr inbounds %struct.complex, ptr %1656, i32 0, i32 0
  %1658 = load float, ptr %1657, align 4, !tbaa !11
  %1659 = fmul float %1653, %1658
  %1660 = call float @llvm.fmuladd.f32(float %1645, float %1650, float %1659)
  %1661 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1660, ptr %1661, align 4, !tbaa !14
  %1662 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1663 = load float, ptr %1662, align 4, !tbaa !11
  %1664 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %1663, ptr %1664, align 4, !tbaa !11
  %1665 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1666 = load float, ptr %1665, align 4, !tbaa !14
  %1667 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %1666, ptr %1667, align 4, !tbaa !14
  br label %1719

1668:                                             ; preds = %1614
  %1669 = load i64, ptr %44, align 8, !tbaa !9
  %1670 = load i64, ptr %45, align 8, !tbaa !9
  %1671 = load i64, ptr %26, align 8, !tbaa !9
  %1672 = mul nsw i64 %1670, %1671
  %1673 = add nsw i64 %1669, %1672
  store i64 %1673, ptr %34, align 8, !tbaa !9
  %1674 = load ptr, ptr %18, align 8, !tbaa !5
  %1675 = getelementptr inbounds %struct.complex, ptr %1674, i32 0, i32 0
  %1676 = load float, ptr %1675, align 4, !tbaa !11
  %1677 = load ptr, ptr %19, align 8, !tbaa !5
  %1678 = load i64, ptr %34, align 8, !tbaa !9
  %1679 = getelementptr inbounds %struct.complex, ptr %1677, i64 %1678
  %1680 = getelementptr inbounds %struct.complex, ptr %1679, i32 0, i32 0
  %1681 = load float, ptr %1680, align 4, !tbaa !11
  %1682 = load ptr, ptr %18, align 8, !tbaa !5
  %1683 = getelementptr inbounds %struct.complex, ptr %1682, i32 0, i32 1
  %1684 = load float, ptr %1683, align 4, !tbaa !14
  %1685 = load ptr, ptr %19, align 8, !tbaa !5
  %1686 = load i64, ptr %34, 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 = fmul float %1684, %1689
  %1691 = fneg float %1690
  %1692 = call float @llvm.fmuladd.f32(float %1676, float %1681, float %1691)
  %1693 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1692, ptr %1693, align 4, !tbaa !11
  %1694 = load ptr, ptr %18, align 8, !tbaa !5
  %1695 = getelementptr inbounds %struct.complex, ptr %1694, i32 0, i32 0
  %1696 = load float, ptr %1695, align 4, !tbaa !11
  %1697 = load ptr, ptr %19, align 8, !tbaa !5
  %1698 = load i64, ptr %34, align 8, !tbaa !9
  %1699 = getelementptr inbounds %struct.complex, ptr %1697, i64 %1698
  %1700 = getelementptr inbounds %struct.complex, ptr %1699, i32 0, i32 1
  %1701 = load float, ptr %1700, align 4, !tbaa !14
  %1702 = load ptr, ptr %18, align 8, !tbaa !5
  %1703 = getelementptr inbounds %struct.complex, ptr %1702, i32 0, i32 1
  %1704 = load float, ptr %1703, align 4, !tbaa !14
  %1705 = load ptr, ptr %19, align 8, !tbaa !5
  %1706 = load i64, ptr %34, align 8, !tbaa !9
  %1707 = getelementptr inbounds %struct.complex, ptr %1705, i64 %1706
  %1708 = getelementptr inbounds %struct.complex, ptr %1707, i32 0, i32 0
  %1709 = load float, ptr %1708, align 4, !tbaa !11
  %1710 = fmul float %1704, %1709
  %1711 = call float @llvm.fmuladd.f32(float %1696, float %1701, float %1710)
  %1712 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1711, ptr %1712, align 4, !tbaa !14
  %1713 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1714 = load float, ptr %1713, align 4, !tbaa !11
  %1715 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %1714, ptr %1715, align 4, !tbaa !11
  %1716 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1717 = load float, ptr %1716, align 4, !tbaa !14
  %1718 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %1717, ptr %1718, align 4, !tbaa !14
  br label %1719

1719:                                             ; preds = %1668, %1617
  %1720 = load ptr, ptr %16, align 8, !tbaa !5
  %1721 = load i64, ptr %1720, align 8, !tbaa !9
  store i64 %1721, ptr %34, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %1722

1722:                                             ; preds = %1807, %1719
  %1723 = load i64, ptr %43, align 8, !tbaa !9
  %1724 = load i64, ptr %34, align 8, !tbaa !9
  %1725 = icmp sle i64 %1723, %1724
  br i1 %1725, label %1726, label %1810

1726:                                             ; preds = %1722
  %1727 = load i64, ptr %43, align 8, !tbaa !9
  %1728 = load i64, ptr %44, align 8, !tbaa !9
  %1729 = load i64, ptr %30, align 8, !tbaa !9
  %1730 = mul nsw i64 %1728, %1729
  %1731 = add nsw i64 %1727, %1730
  store i64 %1731, ptr %35, align 8, !tbaa !9
  %1732 = load i64, ptr %43, align 8, !tbaa !9
  %1733 = load i64, ptr %44, align 8, !tbaa !9
  %1734 = load i64, ptr %30, align 8, !tbaa !9
  %1735 = mul nsw i64 %1733, %1734
  %1736 = add nsw i64 %1732, %1735
  store i64 %1736, ptr %36, align 8, !tbaa !9
  %1737 = load i64, ptr %43, align 8, !tbaa !9
  %1738 = load i64, ptr %45, align 8, !tbaa !9
  %1739 = load i64, ptr %28, align 8, !tbaa !9
  %1740 = mul nsw i64 %1738, %1739
  %1741 = add nsw i64 %1737, %1740
  store i64 %1741, ptr %37, align 8, !tbaa !9
  %1742 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1743 = load float, ptr %1742, align 4, !tbaa !11
  %1744 = load ptr, ptr %21, align 8, !tbaa !5
  %1745 = load i64, ptr %37, align 8, !tbaa !9
  %1746 = getelementptr inbounds %struct.complex, ptr %1744, i64 %1745
  %1747 = getelementptr inbounds %struct.complex, ptr %1746, i32 0, i32 0
  %1748 = load float, ptr %1747, align 4, !tbaa !11
  %1749 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1750 = load float, ptr %1749, align 4, !tbaa !14
  %1751 = load ptr, ptr %21, align 8, !tbaa !5
  %1752 = load i64, ptr %37, align 8, !tbaa !9
  %1753 = getelementptr inbounds %struct.complex, ptr %1751, i64 %1752
  %1754 = getelementptr inbounds %struct.complex, ptr %1753, i32 0, i32 1
  %1755 = load float, ptr %1754, align 4, !tbaa !14
  %1756 = fmul float %1750, %1755
  %1757 = fneg float %1756
  %1758 = call float @llvm.fmuladd.f32(float %1743, float %1748, float %1757)
  %1759 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1758, ptr %1759, align 4, !tbaa !11
  %1760 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1761 = load float, ptr %1760, align 4, !tbaa !11
  %1762 = load ptr, ptr %21, align 8, !tbaa !5
  %1763 = load i64, ptr %37, align 8, !tbaa !9
  %1764 = getelementptr inbounds %struct.complex, ptr %1762, i64 %1763
  %1765 = getelementptr inbounds %struct.complex, ptr %1764, i32 0, i32 1
  %1766 = load float, ptr %1765, align 4, !tbaa !14
  %1767 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1768 = load float, ptr %1767, align 4, !tbaa !14
  %1769 = load ptr, ptr %21, align 8, !tbaa !5
  %1770 = load i64, ptr %37, align 8, !tbaa !9
  %1771 = getelementptr inbounds %struct.complex, ptr %1769, i64 %1770
  %1772 = getelementptr inbounds %struct.complex, ptr %1771, i32 0, i32 0
  %1773 = load float, ptr %1772, align 4, !tbaa !11
  %1774 = fmul float %1768, %1773
  %1775 = call float @llvm.fmuladd.f32(float %1761, float %1766, float %1774)
  %1776 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1775, ptr %1776, align 4, !tbaa !14
  %1777 = load ptr, ptr %24, align 8, !tbaa !5
  %1778 = load i64, ptr %36, align 8, !tbaa !9
  %1779 = getelementptr inbounds %struct.complex, ptr %1777, i64 %1778
  %1780 = getelementptr inbounds %struct.complex, ptr %1779, i32 0, i32 0
  %1781 = load float, ptr %1780, align 4, !tbaa !11
  %1782 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1783 = load float, ptr %1782, align 4, !tbaa !11
  %1784 = fadd float %1781, %1783
  %1785 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1784, ptr %1785, align 4, !tbaa !11
  %1786 = load ptr, ptr %24, align 8, !tbaa !5
  %1787 = load i64, ptr %36, align 8, !tbaa !9
  %1788 = getelementptr inbounds %struct.complex, ptr %1786, i64 %1787
  %1789 = getelementptr inbounds %struct.complex, ptr %1788, i32 0, i32 1
  %1790 = load float, ptr %1789, align 4, !tbaa !14
  %1791 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1792 = load float, ptr %1791, align 4, !tbaa !14
  %1793 = fadd float %1790, %1792
  %1794 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1793, ptr %1794, align 4, !tbaa !14
  %1795 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1796 = load float, ptr %1795, align 4, !tbaa !11
  %1797 = load ptr, ptr %24, align 8, !tbaa !5
  %1798 = load i64, ptr %35, align 8, !tbaa !9
  %1799 = getelementptr inbounds %struct.complex, ptr %1797, i64 %1798
  %1800 = getelementptr inbounds %struct.complex, ptr %1799, i32 0, i32 0
  store float %1796, ptr %1800, align 4, !tbaa !11
  %1801 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1802 = load float, ptr %1801, align 4, !tbaa !14
  %1803 = load ptr, ptr %24, align 8, !tbaa !5
  %1804 = load i64, ptr %35, align 8, !tbaa !9
  %1805 = getelementptr inbounds %struct.complex, ptr %1803, i64 %1804
  %1806 = getelementptr inbounds %struct.complex, ptr %1805, i32 0, i32 1
  store float %1802, ptr %1806, align 4, !tbaa !14
  br label %1807

1807:                                             ; preds = %1726
  %1808 = load i64, ptr %43, align 8, !tbaa !9
  %1809 = add nsw i64 %1808, 1
  store i64 %1809, ptr %43, align 8, !tbaa !9
  br label %1722, !llvm.loop !28

1810:                                             ; preds = %1722
  br label %1811

1811:                                             ; preds = %1810
  %1812 = load i64, ptr %45, align 8, !tbaa !9
  %1813 = add nsw i64 %1812, 1
  store i64 %1813, ptr %45, align 8, !tbaa !9
  br label %1610, !llvm.loop !29

1814:                                             ; preds = %1610
  %1815 = load ptr, ptr %17, align 8, !tbaa !5
  %1816 = load i64, ptr %1815, align 8, !tbaa !9
  store i64 %1816, ptr %33, align 8, !tbaa !9
  %1817 = load i64, ptr %44, align 8, !tbaa !9
  %1818 = add nsw i64 %1817, 1
  store i64 %1818, ptr %45, align 8, !tbaa !9
  br label %1819

1819:                                             ; preds = %2020, %1814
  %1820 = load i64, ptr %45, align 8, !tbaa !9
  %1821 = load i64, ptr %33, align 8, !tbaa !9
  %1822 = icmp sle i64 %1820, %1821
  br i1 %1822, label %1823, label %2023

1823:                                             ; preds = %1819
  %1824 = load i64, ptr %50, align 8, !tbaa !9
  %1825 = icmp ne i64 %1824, 0
  br i1 %1825, label %1826, label %1877

1826:                                             ; preds = %1823
  %1827 = load i64, ptr %44, align 8, !tbaa !9
  %1828 = load i64, ptr %45, align 8, !tbaa !9
  %1829 = load i64, ptr %26, align 8, !tbaa !9
  %1830 = mul nsw i64 %1828, %1829
  %1831 = add nsw i64 %1827, %1830
  store i64 %1831, ptr %34, align 8, !tbaa !9
  %1832 = load ptr, ptr %18, align 8, !tbaa !5
  %1833 = getelementptr inbounds %struct.complex, ptr %1832, i32 0, i32 0
  %1834 = load float, ptr %1833, align 4, !tbaa !11
  %1835 = load ptr, ptr %19, align 8, !tbaa !5
  %1836 = load i64, ptr %34, align 8, !tbaa !9
  %1837 = getelementptr inbounds %struct.complex, ptr %1835, i64 %1836
  %1838 = getelementptr inbounds %struct.complex, ptr %1837, i32 0, i32 0
  %1839 = load float, ptr %1838, align 4, !tbaa !11
  %1840 = load ptr, ptr %18, align 8, !tbaa !5
  %1841 = getelementptr inbounds %struct.complex, ptr %1840, i32 0, i32 1
  %1842 = load float, ptr %1841, align 4, !tbaa !14
  %1843 = load ptr, ptr %19, align 8, !tbaa !5
  %1844 = load i64, ptr %34, align 8, !tbaa !9
  %1845 = getelementptr inbounds %struct.complex, ptr %1843, i64 %1844
  %1846 = getelementptr inbounds %struct.complex, ptr %1845, i32 0, i32 1
  %1847 = load float, ptr %1846, align 4, !tbaa !14
  %1848 = fmul float %1842, %1847
  %1849 = fneg float %1848
  %1850 = call float @llvm.fmuladd.f32(float %1834, float %1839, float %1849)
  %1851 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1850, ptr %1851, align 4, !tbaa !11
  %1852 = load ptr, ptr %18, align 8, !tbaa !5
  %1853 = getelementptr inbounds %struct.complex, ptr %1852, i32 0, i32 0
  %1854 = load float, ptr %1853, align 4, !tbaa !11
  %1855 = load ptr, ptr %19, align 8, !tbaa !5
  %1856 = load i64, ptr %34, 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 = load ptr, ptr %18, align 8, !tbaa !5
  %1861 = getelementptr inbounds %struct.complex, ptr %1860, i32 0, i32 1
  %1862 = load float, ptr %1861, align 4, !tbaa !14
  %1863 = load ptr, ptr %19, align 8, !tbaa !5
  %1864 = load i64, ptr %34, align 8, !tbaa !9
  %1865 = getelementptr inbounds %struct.complex, ptr %1863, i64 %1864
  %1866 = getelementptr inbounds %struct.complex, ptr %1865, i32 0, i32 0
  %1867 = load float, ptr %1866, align 4, !tbaa !11
  %1868 = fmul float %1862, %1867
  %1869 = call float @llvm.fmuladd.f32(float %1854, float %1859, float %1868)
  %1870 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1869, ptr %1870, align 4, !tbaa !14
  %1871 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1872 = load float, ptr %1871, align 4, !tbaa !11
  %1873 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %1872, ptr %1873, align 4, !tbaa !11
  %1874 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1875 = load float, ptr %1874, align 4, !tbaa !14
  %1876 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %1875, ptr %1876, align 4, !tbaa !14
  br label %1928

1877:                                             ; preds = %1823
  %1878 = load i64, ptr %45, align 8, !tbaa !9
  %1879 = load i64, ptr %44, align 8, !tbaa !9
  %1880 = load i64, ptr %26, align 8, !tbaa !9
  %1881 = mul nsw i64 %1879, %1880
  %1882 = add nsw i64 %1878, %1881
  store i64 %1882, ptr %34, align 8, !tbaa !9
  %1883 = load ptr, ptr %18, align 8, !tbaa !5
  %1884 = getelementptr inbounds %struct.complex, ptr %1883, i32 0, i32 0
  %1885 = load float, ptr %1884, align 4, !tbaa !11
  %1886 = load ptr, ptr %19, align 8, !tbaa !5
  %1887 = load i64, ptr %34, align 8, !tbaa !9
  %1888 = getelementptr inbounds %struct.complex, ptr %1886, i64 %1887
  %1889 = getelementptr inbounds %struct.complex, ptr %1888, i32 0, i32 0
  %1890 = load float, ptr %1889, align 4, !tbaa !11
  %1891 = load ptr, ptr %18, align 8, !tbaa !5
  %1892 = getelementptr inbounds %struct.complex, ptr %1891, i32 0, i32 1
  %1893 = load float, ptr %1892, align 4, !tbaa !14
  %1894 = load ptr, ptr %19, align 8, !tbaa !5
  %1895 = load i64, ptr %34, align 8, !tbaa !9
  %1896 = getelementptr inbounds %struct.complex, ptr %1894, i64 %1895
  %1897 = getelementptr inbounds %struct.complex, ptr %1896, i32 0, i32 1
  %1898 = load float, ptr %1897, align 4, !tbaa !14
  %1899 = fmul float %1893, %1898
  %1900 = fneg float %1899
  %1901 = call float @llvm.fmuladd.f32(float %1885, float %1890, float %1900)
  %1902 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1901, ptr %1902, align 4, !tbaa !11
  %1903 = load ptr, ptr %18, align 8, !tbaa !5
  %1904 = getelementptr inbounds %struct.complex, ptr %1903, i32 0, i32 0
  %1905 = load float, ptr %1904, align 4, !tbaa !11
  %1906 = load ptr, ptr %19, align 8, !tbaa !5
  %1907 = load i64, ptr %34, align 8, !tbaa !9
  %1908 = getelementptr inbounds %struct.complex, ptr %1906, i64 %1907
  %1909 = getelementptr inbounds %struct.complex, ptr %1908, i32 0, i32 1
  %1910 = load float, ptr %1909, align 4, !tbaa !14
  %1911 = load ptr, ptr %18, align 8, !tbaa !5
  %1912 = getelementptr inbounds %struct.complex, ptr %1911, i32 0, i32 1
  %1913 = load float, ptr %1912, align 4, !tbaa !14
  %1914 = load ptr, ptr %19, align 8, !tbaa !5
  %1915 = load i64, ptr %34, align 8, !tbaa !9
  %1916 = getelementptr inbounds %struct.complex, ptr %1914, i64 %1915
  %1917 = getelementptr inbounds %struct.complex, ptr %1916, i32 0, i32 0
  %1918 = load float, ptr %1917, align 4, !tbaa !11
  %1919 = fmul float %1913, %1918
  %1920 = call float @llvm.fmuladd.f32(float %1905, float %1910, float %1919)
  %1921 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %1920, ptr %1921, align 4, !tbaa !14
  %1922 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %1923 = load float, ptr %1922, align 4, !tbaa !11
  %1924 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  store float %1923, ptr %1924, align 4, !tbaa !11
  %1925 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %1926 = load float, ptr %1925, align 4, !tbaa !14
  %1927 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  store float %1926, ptr %1927, align 4, !tbaa !14
  br label %1928

1928:                                             ; preds = %1877, %1826
  %1929 = load ptr, ptr %16, align 8, !tbaa !5
  %1930 = load i64, ptr %1929, align 8, !tbaa !9
  store i64 %1930, ptr %34, align 8, !tbaa !9
  store i64 1, ptr %43, align 8, !tbaa !9
  br label %1931

1931:                                             ; preds = %2016, %1928
  %1932 = load i64, ptr %43, align 8, !tbaa !9
  %1933 = load i64, ptr %34, align 8, !tbaa !9
  %1934 = icmp sle i64 %1932, %1933
  br i1 %1934, label %1935, label %2019

1935:                                             ; preds = %1931
  %1936 = load i64, ptr %43, align 8, !tbaa !9
  %1937 = load i64, ptr %44, align 8, !tbaa !9
  %1938 = load i64, ptr %30, align 8, !tbaa !9
  %1939 = mul nsw i64 %1937, %1938
  %1940 = add nsw i64 %1936, %1939
  store i64 %1940, ptr %35, align 8, !tbaa !9
  %1941 = load i64, ptr %43, align 8, !tbaa !9
  %1942 = load i64, ptr %44, align 8, !tbaa !9
  %1943 = load i64, ptr %30, align 8, !tbaa !9
  %1944 = mul nsw i64 %1942, %1943
  %1945 = add nsw i64 %1941, %1944
  store i64 %1945, ptr %36, align 8, !tbaa !9
  %1946 = load i64, ptr %43, align 8, !tbaa !9
  %1947 = load i64, ptr %45, align 8, !tbaa !9
  %1948 = load i64, ptr %28, align 8, !tbaa !9
  %1949 = mul nsw i64 %1947, %1948
  %1950 = add nsw i64 %1946, %1949
  store i64 %1950, ptr %37, align 8, !tbaa !9
  %1951 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1952 = load float, ptr %1951, align 4, !tbaa !11
  %1953 = load ptr, ptr %21, align 8, !tbaa !5
  %1954 = load i64, ptr %37, align 8, !tbaa !9
  %1955 = getelementptr inbounds %struct.complex, ptr %1953, i64 %1954
  %1956 = getelementptr inbounds %struct.complex, ptr %1955, i32 0, i32 0
  %1957 = load float, ptr %1956, align 4, !tbaa !11
  %1958 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1959 = load float, ptr %1958, align 4, !tbaa !14
  %1960 = load ptr, ptr %21, align 8, !tbaa !5
  %1961 = load i64, ptr %37, 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 = fmul float %1959, %1964
  %1966 = fneg float %1965
  %1967 = call float @llvm.fmuladd.f32(float %1952, float %1957, float %1966)
  %1968 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1967, ptr %1968, align 4, !tbaa !11
  %1969 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 0
  %1970 = load float, ptr %1969, align 4, !tbaa !11
  %1971 = load ptr, ptr %21, align 8, !tbaa !5
  %1972 = load i64, ptr %37, align 8, !tbaa !9
  %1973 = getelementptr inbounds %struct.complex, ptr %1971, i64 %1972
  %1974 = getelementptr inbounds %struct.complex, ptr %1973, i32 0, i32 1
  %1975 = load float, ptr %1974, align 4, !tbaa !14
  %1976 = getelementptr inbounds %struct.complex, ptr %47, i32 0, i32 1
  %1977 = load float, ptr %1976, align 4, !tbaa !14
  %1978 = load ptr, ptr %21, align 8, !tbaa !5
  %1979 = load i64, ptr %37, align 8, !tbaa !9
  %1980 = getelementptr inbounds %struct.complex, ptr %1978, i64 %1979
  %1981 = getelementptr inbounds %struct.complex, ptr %1980, i32 0, i32 0
  %1982 = load float, ptr %1981, align 4, !tbaa !11
  %1983 = fmul float %1977, %1982
  %1984 = call float @llvm.fmuladd.f32(float %1970, float %1975, float %1983)
  %1985 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1984, ptr %1985, align 4, !tbaa !14
  %1986 = load ptr, ptr %24, align 8, !tbaa !5
  %1987 = load i64, ptr %36, align 8, !tbaa !9
  %1988 = getelementptr inbounds %struct.complex, ptr %1986, i64 %1987
  %1989 = getelementptr inbounds %struct.complex, ptr %1988, i32 0, i32 0
  %1990 = load float, ptr %1989, align 4, !tbaa !11
  %1991 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1992 = load float, ptr %1991, align 4, !tbaa !11
  %1993 = fadd float %1990, %1992
  %1994 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  store float %1993, ptr %1994, align 4, !tbaa !11
  %1995 = load ptr, ptr %24, align 8, !tbaa !5
  %1996 = load i64, ptr %36, align 8, !tbaa !9
  %1997 = getelementptr inbounds %struct.complex, ptr %1995, i64 %1996
  %1998 = getelementptr inbounds %struct.complex, ptr %1997, i32 0, i32 1
  %1999 = load float, ptr %1998, align 4, !tbaa !14
  %2000 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %2001 = load float, ptr %2000, align 4, !tbaa !14
  %2002 = fadd float %1999, %2001
  %2003 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  store float %2002, ptr %2003, align 4, !tbaa !14
  %2004 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 0
  %2005 = load float, ptr %2004, align 4, !tbaa !11
  %2006 = load ptr, ptr %24, align 8, !tbaa !5
  %2007 = load i64, ptr %35, align 8, !tbaa !9
  %2008 = getelementptr inbounds %struct.complex, ptr %2006, i64 %2007
  %2009 = getelementptr inbounds %struct.complex, ptr %2008, i32 0, i32 0
  store float %2005, ptr %2009, align 4, !tbaa !11
  %2010 = getelementptr inbounds %struct.complex, ptr %38, i32 0, i32 1
  %2011 = load float, ptr %2010, align 4, !tbaa !14
  %2012 = load ptr, ptr %24, align 8, !tbaa !5
  %2013 = load i64, ptr %35, align 8, !tbaa !9
  %2014 = getelementptr inbounds %struct.complex, ptr %2012, i64 %2013
  %2015 = getelementptr inbounds %struct.complex, ptr %2014, i32 0, i32 1
  store float %2011, ptr %2015, align 4, !tbaa !14
  br label %2016

2016:                                             ; preds = %1935
  %2017 = load i64, ptr %43, align 8, !tbaa !9
  %2018 = add nsw i64 %2017, 1
  store i64 %2018, ptr %43, align 8, !tbaa !9
  br label %1931, !llvm.loop !30

2019:                                             ; preds = %1931
  br label %2020

2020:                                             ; preds = %2019
  %2021 = load i64, ptr %45, align 8, !tbaa !9
  %2022 = add nsw i64 %2021, 1
  store i64 %2022, ptr %45, align 8, !tbaa !9
  br label %1819, !llvm.loop !31

2023:                                             ; preds = %1819
  br label %2024

2024:                                             ; preds = %2023
  %2025 = load i64, ptr %44, align 8, !tbaa !9
  %2026 = add nsw i64 %2025, 1
  store i64 %2026, ptr %44, align 8, !tbaa !9
  br label %1349, !llvm.loop !32

2027:                                             ; preds = %1349
  br label %2028

2028:                                             ; preds = %2027, %1345
  store i32 0, ptr %13, align 4
  store i32 1, ptr %51, align 4
  br label %2029

2029:                                             ; preds = %2028, %334, %193, %163
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 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
  %2030 = load i32, ptr %13, align 4
  ret i32 %2030
}

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

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

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

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

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

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

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

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


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

%struct.complex = type { float, float }

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

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

26:                                               ; preds = %12
  %27 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.2) #6
  %.not713 = icmp eq i64 %27, 0
  br i1 %.not713, label %28, label %29

28:                                               ; preds = %26
  store i64 1, ptr %13, align 8, !tbaa !5
  br label %.thread

29:                                               ; preds = %26, %12
  %.not714 = icmp eq i64 %24, 0
  br i1 %.not714, label %30, label %33

30:                                               ; preds = %29
  %31 = tail call i64 @lsame_(ptr noundef %1, ptr noundef nonnull @.str) #6
  %.not715 = icmp eq i64 %31, 0
  br i1 %.not715, label %32, label %33

32:                                               ; preds = %30
  store i64 2, ptr %13, align 8, !tbaa !5
  br label %.thread

33:                                               ; preds = %30, %29
  %34 = load i64, ptr %2, align 8, !tbaa !5
  %35 = icmp slt i64 %34, 0
  br i1 %35, label %36, label %37

36:                                               ; preds = %33
  store i64 3, ptr %13, align 8, !tbaa !5
  br label %.thread

37:                                               ; preds = %33
  %38 = load i64, ptr %3, align 8, !tbaa !5
  %39 = icmp slt i64 %38, 0
  br i1 %39, label %40, label %41

40:                                               ; preds = %37
  store i64 4, ptr %13, align 8, !tbaa !5
  br label %.thread

41:                                               ; preds = %37
  %42 = load i64, ptr %6, align 8, !tbaa !5
  %43 = tail call i64 @llvm.smax.i64(i64 %.0700, i64 1)
  %44 = icmp slt i64 %42, %43
  br i1 %44, label %45, label %46

45:                                               ; preds = %41
  store i64 7, ptr %13, align 8, !tbaa !5
  br label %.thread

46:                                               ; preds = %41
  %47 = load i64, ptr %8, align 8, !tbaa !5
  %spec.select = tail call i64 @llvm.umax.i64(i64 %34, i64 1)
  %48 = icmp slt i64 %47, %spec.select
  br i1 %48, label %49, label %50

49:                                               ; preds = %46
  store i64 9, ptr %13, align 8, !tbaa !5
  br label %.thread

50:                                               ; preds = %46
  %51 = load i64, ptr %11, align 8, !tbaa !5
  %52 = icmp slt i64 %51, %spec.select
  br i1 %52, label %53, label %55

53:                                               ; preds = %50
  store i64 12, ptr %13, align 8, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %28, %36, %45, %53, %49, %40, %32
  %54 = call i32 @xerbla_(ptr noundef nonnull @.str.3, ptr noundef nonnull %13) #6
  br label %.loopexit

55:                                               ; preds = %50
  %56 = icmp eq i64 %34, 0
  %57 = icmp eq i64 %38, 0
  %or.cond = or i1 %56, %57
  br i1 %or.cond, label %.loopexit, label %58

58:                                               ; preds = %55
  %59 = load float, ptr %4, align 4, !tbaa !9
  %60 = fcmp oeq float %59, 0.000000e+00
  br i1 %60, label %61, label %131

61:                                               ; preds = %58
  %62 = getelementptr inbounds i8, ptr %4, i64 4
  %63 = load float, ptr %62, align 4, !tbaa !12
  %64 = fcmp oeq float %63, 0.000000e+00
  br i1 %64, label %65, label %131

65:                                               ; preds = %61
  %66 = load float, ptr %9, align 4, !tbaa !9
  %67 = fcmp oeq float %66, 1.000000e+00
  br i1 %67, label %68, label %72

68:                                               ; preds = %65
  %69 = getelementptr inbounds i8, ptr %9, i64 4
  %70 = load float, ptr %69, align 4, !tbaa !12
  %71 = fcmp oeq float %70, 0.000000e+00
  br i1 %71, label %.loopexit, label %thread-pre-split

thread-pre-split:                                 ; preds = %68
  %.pr = load float, ptr %9, align 4, !tbaa !9
  br label %72

72:                                               ; preds = %thread-pre-split, %65
  %73 = phi float [ %.pr, %thread-pre-split ], [ %66, %65 ]
  %74 = fcmp oeq float %73, 0.000000e+00
  br i1 %74, label %75, label %.preheader742.preheader

75:                                               ; preds = %72
  %76 = getelementptr inbounds i8, ptr %9, i64 4
  %77 = load float, ptr %76, align 4, !tbaa !12
  %78 = fcmp oeq float %77, 0.000000e+00
  br i1 %78, label %.preheader.preheader, label %.preheader742.preheader

.preheader.preheader:                             ; preds = %75
  %79 = shl i64 %20, 3
  %80 = shl nuw i64 %34, 3
  %81 = add nsw i64 %38, -1
  %xtraiter1198 = and i64 %38, 7
  %82 = icmp ult i64 %81, 7
  br i1 %82, label %.loopexit.loopexit.unr-lcssa, label %.preheader.preheader.new

.preheader.preheader.new:                         ; preds = %.preheader.preheader
  %unroll_iter = and i64 %38, 9223372036854775800
  br label %.preheader

.preheader:                                       ; preds = %.preheader, %.preheader.preheader.new
  %indvar = phi i64 [ 0, %.preheader.preheader.new ], [ %indvar.next.7, %.preheader ]
  %niter = phi i64 [ 0, %.preheader.preheader.new ], [ %niter.next.7, %.preheader ]
  %83 = mul i64 %79, %indvar
  %scevgep = getelementptr i8, ptr %10, i64 %83
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next = or disjoint i64 %indvar, 1
  %84 = mul i64 %79, %indvar.next
  %scevgep.1 = getelementptr i8, ptr %10, i64 %84
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.1, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.1 = or disjoint i64 %indvar, 2
  %85 = mul i64 %79, %indvar.next.1
  %scevgep.2 = getelementptr i8, ptr %10, i64 %85
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.2, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.2 = or disjoint i64 %indvar, 3
  %86 = mul i64 %79, %indvar.next.2
  %scevgep.3 = getelementptr i8, ptr %10, i64 %86
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.3, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.3 = or disjoint i64 %indvar, 4
  %87 = mul i64 %79, %indvar.next.3
  %scevgep.4 = getelementptr i8, ptr %10, i64 %87
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.4, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.4 = or disjoint i64 %indvar, 5
  %88 = mul i64 %79, %indvar.next.4
  %scevgep.5 = getelementptr i8, ptr %10, i64 %88
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.5, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.5 = or disjoint i64 %indvar, 6
  %89 = mul i64 %79, %indvar.next.5
  %scevgep.6 = getelementptr i8, ptr %10, i64 %89
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.6, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.6 = or disjoint i64 %indvar, 7
  %90 = mul i64 %79, %indvar.next.6
  %scevgep.7 = getelementptr i8, ptr %10, i64 %90
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.7, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.7 = add nuw nsw i64 %indvar, 8
  %niter.next.7 = add i64 %niter, 8
  %niter.ncmp.7 = icmp eq i64 %niter.next.7, %unroll_iter
  br i1 %niter.ncmp.7, label %.loopexit.loopexit.unr-lcssa, label %.preheader, !llvm.loop !14

.preheader742.preheader:                          ; preds = %75, %72
  %91 = getelementptr i8, ptr %9, i64 4
  %92 = add nsw i64 %34, -1
  %93 = shl i64 %20, 3
  %94 = add nuw i64 %38, 2305843009213693951
  %95 = mul i64 %20, %94
  %96 = add i64 %95, %34
  %97 = shl i64 %96, 3
  %98 = getelementptr i8, ptr %10, i64 %97
  %scevgep1154 = getelementptr i8, ptr %98, i64 -4
  %scevgep1155 = getelementptr i8, ptr %10, i64 4
  %scevgep1156 = getelementptr i8, ptr %10, i64 %97
  %scevgep1157 = getelementptr i8, ptr %9, i64 8
  %min.iters.check1169 = icmp ult i64 %34, 8
  %mul.result1147 = shl i64 %92, 3
  %mul.result1151 = shl i64 %92, 3
  %mul.overflow1152 = icmp ugt i64 %92, 2305843009213693951
  %bound01158 = icmp ugt ptr %91, %10
  %bound11159 = icmp ugt ptr %scevgep1154, %9
  %found.conflict1160 = and i1 %bound01158, %bound11159
  %bound01162 = icmp ult ptr %scevgep1155, %scevgep1157
  %bound11163 = icmp ult ptr %91, %scevgep1156
  %found.conflict1164 = and i1 %bound01162, %bound11163
  %.mask = and i64 %20, 1152921504606846976
  %stride.check1165 = icmp ne i64 %.mask, 0
  %99 = or i1 %found.conflict1164, %stride.check1165
  %conflict.rdx1166 = or i1 %found.conflict1160, %99
  %n.vec1172 = and i64 %34, 4611686018427387900
  %ind.end1173 = or disjoint i64 %n.vec1172, 1
  %cmp.n1187 = icmp eq i64 %34, %n.vec1172
  br label %.preheader742

.preheader742:                                    ; preds = %.preheader742.preheader, %._crit_edge857
  %indvar1143 = phi i64 [ 0, %.preheader742.preheader ], [ %indvar.next1144, %._crit_edge857 ]
  %.1703861 = phi i64 [ 1, %.preheader742.preheader ], [ %130, %._crit_edge857 ]
  %100 = mul nsw i64 %.1703861, %20
  %invariant.gep858 = getelementptr %struct.complex, ptr %22, i64 %100
  br i1 %min.iters.check1169, label %scalar.ph1168.preheader, label %vector.scevcheck1142

vector.scevcheck1142:                             ; preds = %.preheader742
  %101 = mul i64 %93, %indvar1143
  %102 = or disjoint i64 %101, 4
  %scevgep1149 = getelementptr i8, ptr %10, i64 %102
  %scevgep1145 = getelementptr i8, ptr %10, i64 %101
  %103 = getelementptr i8, ptr %scevgep1145, i64 %mul.result1147
  %104 = icmp ult ptr %103, %scevgep1145
  %105 = getelementptr i8, ptr %scevgep1149, i64 %mul.result1151
  %106 = icmp ult ptr %105, %scevgep1149
  %107 = or i1 %106, %mul.overflow1152
  %108 = or i1 %104, %107
  %brmerge = select i1 %108, i1 true, i1 %conflict.rdx1166
  br i1 %brmerge, label %scalar.ph1168.preheader, label %vector.body1175

vector.body1175:                                  ; preds = %vector.scevcheck1142, %vector.body1175
  %index1176 = phi i64 [ %index.next1186, %vector.body1175 ], [ 0, %vector.scevcheck1142 ]
  %offset.idx1177 = or disjoint i64 %index1176, 1
  %109 = load float, ptr %9, align 4, !tbaa !9, !alias.scope !16
  %broadcast.splatinsert1183 = insertelement <4 x float> poison, float %109, i64 0
  %broadcast.splat1184 = shufflevector <4 x float> %broadcast.splatinsert1183, <4 x float> poison, <4 x i32> zeroinitializer
  %110 = getelementptr %struct.complex, ptr %invariant.gep858, i64 %offset.idx1177
  %wide.vec1178 = load <8 x float>, ptr %110, align 4, !tbaa !13
  %strided.vec1179 = shufflevector <8 x float> %wide.vec1178, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1180 = shufflevector <8 x float> %wide.vec1178, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %111 = load float, ptr %91, align 4, !tbaa !12, !alias.scope !19
  %broadcast.splatinsert1181 = insertelement <4 x float> poison, float %111, i64 0
  %broadcast.splat1182 = shufflevector <4 x float> %broadcast.splatinsert1181, <4 x float> poison, <4 x i32> zeroinitializer
  %112 = fneg <4 x float> %broadcast.splat1182
  %113 = fmul <4 x float> %strided.vec1180, %112
  %114 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1184, <4 x float> %strided.vec1179, <4 x float> %113)
  %115 = fmul <4 x float> %strided.vec1179, %broadcast.splat1182
  %116 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1184, <4 x float> %strided.vec1180, <4 x float> %115)
  %interleaved.vec1185 = shufflevector <4 x float> %114, <4 x float> %116, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1185, ptr %110, align 4, !tbaa !13
  %index.next1186 = add nuw i64 %index1176, 4
  %117 = icmp eq i64 %index.next1186, %n.vec1172
  br i1 %117, label %middle.block1167, label %vector.body1175, !llvm.loop !21

middle.block1167:                                 ; preds = %vector.body1175
  br i1 %cmp.n1187, label %._crit_edge857, label %scalar.ph1168.preheader

scalar.ph1168.preheader:                          ; preds = %vector.scevcheck1142, %middle.block1167, %.preheader742
  %.1707855.ph = phi i64 [ 1, %vector.scevcheck1142 ], [ 1, %.preheader742 ], [ %ind.end1173, %middle.block1167 ]
  br label %scalar.ph1168

scalar.ph1168:                                    ; preds = %scalar.ph1168.preheader, %scalar.ph1168
  %.1707855 = phi i64 [ %129, %scalar.ph1168 ], [ %.1707855.ph, %scalar.ph1168.preheader ]
  %118 = load float, ptr %9, align 4, !tbaa !9
  %gep859 = getelementptr %struct.complex, ptr %invariant.gep858, i64 %.1707855
  %119 = load float, ptr %91, align 4, !tbaa !12
  %120 = fneg float %119
  %121 = load <2 x float>, ptr %gep859, align 4, !tbaa !13
  %122 = insertelement <2 x float> poison, float %119, i64 0
  %123 = insertelement <2 x float> %122, float %120, i64 1
  %124 = fmul <2 x float> %121, %123
  %125 = shufflevector <2 x float> %124, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %126 = insertelement <2 x float> poison, float %118, i64 0
  %127 = shufflevector <2 x float> %126, <2 x float> poison, <2 x i32> zeroinitializer
  %128 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %127, <2 x float> %121, <2 x float> %125)
  store <2 x float> %128, ptr %gep859, align 4, !tbaa !13
  %129 = add nuw i64 %.1707855, 1
  %exitcond892.not = icmp eq i64 %.1707855, %34
  br i1 %exitcond892.not, label %._crit_edge857, label %scalar.ph1168, !llvm.loop !24

._crit_edge857:                                   ; preds = %scalar.ph1168, %middle.block1167
  %130 = add nuw i64 %.1703861, 1
  %exitcond893.not = icmp eq i64 %.1703861, %38
  %indvar.next1144 = add i64 %indvar1143, 1
  br i1 %exitcond893.not, label %.loopexit, label %.preheader742, !llvm.loop !25

131:                                              ; preds = %61, %58
  %132 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #6
  %.not717 = icmp eq i64 %132, 0
  %133 = load i64, ptr %3, align 8, !tbaa !5
  %.not718850 = icmp slt i64 %133, 1
  br i1 %.not717, label %350, label %134

134:                                              ; preds = %131
  br i1 %.not714, label %242, label %135

135:                                              ; preds = %134
  br i1 %.not718850, label %.loopexit, label %.lr.ph773

.lr.ph773:                                        ; preds = %135
  %136 = load i64, ptr %2, align 8, !tbaa !5
  %.not731759 = icmp slt i64 %136, 1
  %137 = getelementptr inbounds i8, ptr %4, i64 4
  %138 = getelementptr inbounds i8, ptr %9, i64 4
  %139 = add i64 %14, 1
  br i1 %.not731759, label %.loopexit, label %.lr.ph762

.lr.ph762:                                        ; preds = %.lr.ph773, %._crit_edge763
  %.2704771 = phi i64 [ %241, %._crit_edge763 ], [ 1, %.lr.ph773 ]
  %140 = mul nsw i64 %.2704771, %17
  %invariant.gep764 = getelementptr %struct.complex, ptr %19, i64 %140
  %141 = mul nsw i64 %.2704771, %20
  %invariant.gep757 = getelementptr %struct.complex, ptr %22, i64 %141
  br label %142

142:                                              ; preds = %.lr.ph762, %239
  %.2708760 = phi i64 [ 1, %.lr.ph762 ], [ %240, %239 ]
  %143 = load float, ptr %4, align 4, !tbaa !9
  %gep765 = getelementptr %struct.complex, ptr %invariant.gep764, i64 %.2708760
  %144 = load float, ptr %gep765, align 4, !tbaa !9
  %145 = load float, ptr %137, align 4, !tbaa !12
  %146 = getelementptr inbounds i8, ptr %gep765, i64 4
  %147 = load float, ptr %146, align 4, !tbaa !12
  %148 = fneg float %145
  %149 = fmul float %147, %148
  %150 = tail call float @llvm.fmuladd.f32(float %143, float %144, float %149)
  %151 = fmul float %144, %145
  %152 = tail call float @llvm.fmuladd.f32(float %143, float %147, float %151)
  %.not732.not750 = icmp ugt i64 %.2708760, 1
  br i1 %.not732.not750, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %142
  %153 = mul nsw i64 %.2708760, %14
  %invariant.gep755 = getelementptr %struct.complex, ptr %16, i64 %153
  %154 = fneg float %152
  %155 = insertelement <2 x float> poison, float %150, i64 0
  %156 = shufflevector <2 x float> %155, <2 x float> poison, <2 x i32> zeroinitializer
  %157 = insertelement <2 x float> poison, float %152, i64 0
  %158 = insertelement <2 x float> %157, float %154, i64 1
  br label %159

159:                                              ; preds = %.lr.ph, %159
  %.0701751 = phi i64 [ 1, %.lr.ph ], [ %180, %159 ]
  %160 = phi <2 x float> [ zeroinitializer, %.lr.ph ], [ %179, %159 ]
  %gep756 = getelementptr %struct.complex, ptr %invariant.gep755, i64 %.0701751
  %gep758 = getelementptr %struct.complex, ptr %invariant.gep757, i64 %.0701751
  %161 = load <2 x float>, ptr %gep756, align 4, !tbaa !13
  %162 = fmul <2 x float> %161, %158
  %163 = shufflevector <2 x float> %162, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %164 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %156, <2 x float> %161, <2 x float> %163)
  %165 = load <2 x float>, ptr %gep758, align 4, !tbaa !13
  %166 = fadd <2 x float> %165, %164
  store <2 x float> %166, ptr %gep758, align 4, !tbaa !13
  %gep = getelementptr %struct.complex, ptr %invariant.gep764, i64 %.0701751
  %167 = load float, ptr %gep, align 4, !tbaa !9
  %168 = getelementptr inbounds i8, ptr %gep, i64 4
  %169 = load float, ptr %168, align 4, !tbaa !12
  %170 = fneg float %169
  %171 = load <2 x float>, ptr %gep756, align 4, !tbaa !13
  %172 = insertelement <2 x float> poison, float %169, i64 0
  %173 = insertelement <2 x float> %172, float %170, i64 1
  %174 = fmul <2 x float> %171, %173
  %175 = shufflevector <2 x float> %174, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %176 = insertelement <2 x float> poison, float %167, i64 0
  %177 = shufflevector <2 x float> %176, <2 x float> poison, <2 x i32> zeroinitializer
  %178 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %177, <2 x float> %171, <2 x float> %175)
  %179 = fadd <2 x float> %160, %178
  %180 = add nuw nsw i64 %.0701751, 1
  %exitcond.not = icmp eq i64 %180, %.2708760
  br i1 %exitcond.not, label %._crit_edge, label %159, !llvm.loop !26

._crit_edge:                                      ; preds = %159, %142
  %181 = phi <2 x float> [ zeroinitializer, %142 ], [ %179, %159 ]
  %182 = load float, ptr %9, align 4, !tbaa !9
  %183 = fcmp oeq float %182, 0.000000e+00
  %.pre = load float, ptr %138, align 4, !tbaa !12
  br i1 %183, label %185, label %._crit_edge._crit_edge

._crit_edge._crit_edge:                           ; preds = %._crit_edge
  %184 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br label %208

185:                                              ; preds = %._crit_edge
  %186 = fcmp oeq float %.pre, 0.000000e+00
  %187 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br i1 %186, label %188, label %208

188:                                              ; preds = %185
  %189 = mul i64 %.2708760, %139
  %190 = getelementptr inbounds %struct.complex, ptr %16, i64 %189
  %191 = fneg float %152
  %gep769 = getelementptr %struct.complex, ptr %invariant.gep757, i64 %.2708760
  %192 = load <2 x float>, ptr %190, align 4, !tbaa !13
  %193 = insertelement <2 x float> poison, float %152, i64 0
  %194 = insertelement <2 x float> %193, float %191, i64 1
  %195 = fmul <2 x float> %192, %194
  %196 = shufflevector <2 x float> %195, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %197 = insertelement <2 x float> poison, float %150, i64 0
  %198 = shufflevector <2 x float> %197, <2 x float> poison, <2 x i32> zeroinitializer
  %199 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %198, <2 x float> %192, <2 x float> %196)
  %200 = shufflevector <2 x float> %187, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %201 = fneg <2 x float> %187
  %202 = shufflevector <2 x float> %200, <2 x float> %201, <2 x i32> <i32 0, i32 3>
  %203 = fmul <2 x float> %181, %202
  %204 = shufflevector <2 x float> %203, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %205 = shufflevector <2 x float> %187, <2 x float> poison, <2 x i32> zeroinitializer
  %206 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %205, <2 x float> %181, <2 x float> %204)
  %207 = fadd <2 x float> %199, %206
  store <2 x float> %207, ptr %gep769, align 4, !tbaa !13
  br label %239

208:                                              ; preds = %._crit_edge._crit_edge, %185
  %209 = phi <2 x float> [ %184, %._crit_edge._crit_edge ], [ %187, %185 ]
  %gep767 = getelementptr %struct.complex, ptr %invariant.gep757, i64 %.2708760
  %210 = fneg float %.pre
  %211 = mul i64 %.2708760, %139
  %212 = getelementptr inbounds %struct.complex, ptr %16, i64 %211
  %213 = fneg float %152
  %214 = load <2 x float>, ptr %gep767, align 4, !tbaa !13
  %215 = insertelement <2 x float> poison, float %.pre, i64 0
  %216 = insertelement <2 x float> %215, float %210, i64 1
  %217 = fmul <2 x float> %214, %216
  %218 = shufflevector <2 x float> %217, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %219 = insertelement <2 x float> poison, float %182, i64 0
  %220 = shufflevector <2 x float> %219, <2 x float> poison, <2 x i32> zeroinitializer
  %221 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %220, <2 x float> %214, <2 x float> %218)
  %222 = load <2 x float>, ptr %212, align 4, !tbaa !13
  %223 = insertelement <2 x float> poison, float %152, i64 0
  %224 = insertelement <2 x float> %223, float %213, i64 1
  %225 = fmul <2 x float> %222, %224
  %226 = shufflevector <2 x float> %225, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %227 = insertelement <2 x float> poison, float %150, i64 0
  %228 = shufflevector <2 x float> %227, <2 x float> poison, <2 x i32> zeroinitializer
  %229 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %228, <2 x float> %222, <2 x float> %226)
  %230 = fadd <2 x float> %221, %229
  %231 = shufflevector <2 x float> %209, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %232 = fneg <2 x float> %209
  %233 = shufflevector <2 x float> %231, <2 x float> %232, <2 x i32> <i32 0, i32 3>
  %234 = fmul <2 x float> %181, %233
  %235 = shufflevector <2 x float> %234, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %236 = shufflevector <2 x float> %209, <2 x float> poison, <2 x i32> zeroinitializer
  %237 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %236, <2 x float> %181, <2 x float> %235)
  %238 = fadd <2 x float> %230, %237
  store <2 x float> %238, ptr %gep767, align 4, !tbaa !13
  br label %239

239:                                              ; preds = %188, %208
  %240 = add nuw i64 %.2708760, 1
  %exitcond882.not = icmp eq i64 %.2708760, %136
  br i1 %exitcond882.not, label %._crit_edge763, label %142, !llvm.loop !27

._crit_edge763:                                   ; preds = %239
  %241 = add nuw i64 %.2704771, 1
  %exitcond883.not = icmp eq i64 %.2704771, %133
  br i1 %exitcond883.not, label %.loopexit, label %.lr.ph762, !llvm.loop !28

242:                                              ; preds = %134
  br i1 %.not718850, label %.loopexit, label %.lr.ph802

.lr.ph802:                                        ; preds = %242
  %243 = load i64, ptr %2, align 8, !tbaa !5
  %244 = icmp sgt i64 %243, 0
  %245 = getelementptr inbounds i8, ptr %4, i64 4
  %246 = getelementptr inbounds i8, ptr %9, i64 4
  %247 = add i64 %14, 1
  br i1 %244, label %.lr.ph791.us, label %.loopexit

.lr.ph791.us:                                     ; preds = %.lr.ph802, %._crit_edge792.us
  %.3705800.us = phi i64 [ %349, %._crit_edge792.us ], [ 1, %.lr.ph802 ]
  %248 = mul nsw i64 %.3705800.us, %17
  %invariant.gep793.us = getelementptr %struct.complex, ptr %19, i64 %248
  %249 = mul nsw i64 %.3705800.us, %20
  %invariant.gep787.us = getelementptr %struct.complex, ptr %22, i64 %249
  br label %250

250:                                              ; preds = %.lr.ph791.us, %319
  %.3709789.us = phi i64 [ %243, %.lr.ph791.us ], [ %320, %319 ]
  %251 = load float, ptr %4, align 4, !tbaa !9
  %gep794.us = getelementptr %struct.complex, ptr %invariant.gep793.us, i64 %.3709789.us
  %252 = load float, ptr %gep794.us, align 4, !tbaa !9
  %253 = load float, ptr %245, align 4, !tbaa !12
  %254 = getelementptr inbounds i8, ptr %gep794.us, i64 4
  %255 = load float, ptr %254, align 4, !tbaa !12
  %256 = fneg float %253
  %257 = fmul float %255, %256
  %258 = tail call float @llvm.fmuladd.f32(float %251, float %252, float %257)
  %259 = fmul float %252, %253
  %260 = tail call float @llvm.fmuladd.f32(float %251, float %255, float %259)
  %.not729.not776.us = icmp slt i64 %.3709789.us, %243
  br i1 %.not729.not776.us, label %.lr.ph781.us, label %._crit_edge782.us

._crit_edge782.us:                                ; preds = %322, %250
  %261 = phi <2 x float> [ zeroinitializer, %250 ], [ %342, %322 ]
  %262 = load float, ptr %9, align 4, !tbaa !9
  %263 = fcmp oeq float %262, 0.000000e+00
  %.pre899 = load float, ptr %246, align 4, !tbaa !12
  br i1 %263, label %265, label %._crit_edge782.us._crit_edge

._crit_edge782.us._crit_edge:                     ; preds = %._crit_edge782.us
  %264 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br label %268

265:                                              ; preds = %._crit_edge782.us
  %266 = fcmp oeq float %.pre899, 0.000000e+00
  %267 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br i1 %266, label %299, label %268

268:                                              ; preds = %._crit_edge782.us._crit_edge, %265
  %269 = phi <2 x float> [ %264, %._crit_edge782.us._crit_edge ], [ %267, %265 ]
  %gep796.us = getelementptr %struct.complex, ptr %invariant.gep787.us, i64 %.3709789.us
  %270 = fneg float %.pre899
  %271 = mul i64 %.3709789.us, %247
  %272 = getelementptr inbounds %struct.complex, ptr %16, i64 %271
  %273 = fneg float %260
  %274 = load <2 x float>, ptr %gep796.us, align 4, !tbaa !13
  %275 = insertelement <2 x float> poison, float %.pre899, i64 0
  %276 = insertelement <2 x float> %275, float %270, i64 1
  %277 = fmul <2 x float> %274, %276
  %278 = shufflevector <2 x float> %277, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %279 = insertelement <2 x float> poison, float %262, i64 0
  %280 = shufflevector <2 x float> %279, <2 x float> poison, <2 x i32> zeroinitializer
  %281 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %280, <2 x float> %274, <2 x float> %278)
  %282 = load <2 x float>, ptr %272, align 4, !tbaa !13
  %283 = insertelement <2 x float> poison, float %260, i64 0
  %284 = insertelement <2 x float> %283, float %273, i64 1
  %285 = fmul <2 x float> %282, %284
  %286 = shufflevector <2 x float> %285, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %287 = insertelement <2 x float> poison, float %258, i64 0
  %288 = shufflevector <2 x float> %287, <2 x float> poison, <2 x i32> zeroinitializer
  %289 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %288, <2 x float> %282, <2 x float> %286)
  %290 = fadd <2 x float> %281, %289
  %291 = shufflevector <2 x float> %269, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %292 = fneg <2 x float> %269
  %293 = shufflevector <2 x float> %291, <2 x float> %292, <2 x i32> <i32 0, i32 3>
  %294 = fmul <2 x float> %261, %293
  %295 = shufflevector <2 x float> %294, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %296 = shufflevector <2 x float> %269, <2 x float> poison, <2 x i32> zeroinitializer
  %297 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %296, <2 x float> %261, <2 x float> %295)
  %298 = fadd <2 x float> %290, %297
  store <2 x float> %298, ptr %gep796.us, align 4, !tbaa !13
  br label %319

299:                                              ; preds = %265
  %300 = mul i64 %.3709789.us, %247
  %301 = getelementptr inbounds %struct.complex, ptr %16, i64 %300
  %302 = fneg float %260
  %gep798.us = getelementptr %struct.complex, ptr %invariant.gep787.us, i64 %.3709789.us
  %303 = load <2 x float>, ptr %301, align 4, !tbaa !13
  %304 = insertelement <2 x float> poison, float %260, i64 0
  %305 = insertelement <2 x float> %304, float %302, i64 1
  %306 = fmul <2 x float> %303, %305
  %307 = shufflevector <2 x float> %306, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %308 = insertelement <2 x float> poison, float %258, i64 0
  %309 = shufflevector <2 x float> %308, <2 x float> poison, <2 x i32> zeroinitializer
  %310 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %309, <2 x float> %303, <2 x float> %307)
  %311 = shufflevector <2 x float> %267, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %312 = fneg <2 x float> %267
  %313 = shufflevector <2 x float> %311, <2 x float> %312, <2 x i32> <i32 0, i32 3>
  %314 = fmul <2 x float> %261, %313
  %315 = shufflevector <2 x float> %314, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %316 = shufflevector <2 x float> %267, <2 x float> poison, <2 x i32> zeroinitializer
  %317 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %316, <2 x float> %261, <2 x float> %315)
  %318 = fadd <2 x float> %310, %317
  store <2 x float> %318, ptr %gep798.us, align 4, !tbaa !13
  br label %319

319:                                              ; preds = %299, %268
  %320 = add nsw i64 %.3709789.us, -1
  %321 = icmp sgt i64 %.3709789.us, 1
  br i1 %321, label %250, label %._crit_edge792.us, !llvm.loop !29

322:                                              ; preds = %.lr.ph781.us, %322
  %.1.in777.us = phi i64 [ %.3709789.us, %.lr.ph781.us ], [ %.1.us, %322 ]
  %323 = phi <2 x float> [ zeroinitializer, %.lr.ph781.us ], [ %342, %322 ]
  %.1.us = add nuw nsw i64 %.1.in777.us, 1
  %gep786.us = getelementptr %struct.complex, ptr %invariant.gep785.us, i64 %.1.us
  %gep788.us = getelementptr %struct.complex, ptr %invariant.gep787.us, i64 %.1.us
  %324 = load <2 x float>, ptr %gep786.us, align 4, !tbaa !13
  %325 = fmul <2 x float> %324, %348
  %326 = shufflevector <2 x float> %325, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %327 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %346, <2 x float> %324, <2 x float> %326)
  %328 = load <2 x float>, ptr %gep788.us, align 4, !tbaa !13
  %329 = fadd <2 x float> %328, %327
  store <2 x float> %329, ptr %gep788.us, align 4, !tbaa !13
  %gep775.us = getelementptr %struct.complex, ptr %invariant.gep793.us, i64 %.1.us
  %330 = load float, ptr %gep775.us, align 4, !tbaa !9
  %331 = getelementptr inbounds i8, ptr %gep775.us, i64 4
  %332 = load float, ptr %331, align 4, !tbaa !12
  %333 = fneg float %332
  %334 = load <2 x float>, ptr %gep786.us, align 4, !tbaa !13
  %335 = insertelement <2 x float> poison, float %332, i64 0
  %336 = insertelement <2 x float> %335, float %333, i64 1
  %337 = fmul <2 x float> %334, %336
  %338 = shufflevector <2 x float> %337, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %339 = insertelement <2 x float> poison, float %330, i64 0
  %340 = shufflevector <2 x float> %339, <2 x float> poison, <2 x i32> zeroinitializer
  %341 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %340, <2 x float> %334, <2 x float> %338)
  %342 = fadd <2 x float> %323, %341
  %exitcond884.not = icmp eq i64 %.1.us, %243
  br i1 %exitcond884.not, label %._crit_edge782.us, label %322, !llvm.loop !30

.lr.ph781.us:                                     ; preds = %250
  %343 = mul nsw i64 %.3709789.us, %14
  %invariant.gep785.us = getelementptr %struct.complex, ptr %16, i64 %343
  %344 = fneg float %260
  %345 = insertelement <2 x float> poison, float %258, i64 0
  %346 = shufflevector <2 x float> %345, <2 x float> poison, <2 x i32> zeroinitializer
  %347 = insertelement <2 x float> poison, float %260, i64 0
  %348 = insertelement <2 x float> %347, float %344, i64 1
  br label %322

._crit_edge792.us:                                ; preds = %319
  %349 = add nuw i64 %.3705800.us, 1
  %exitcond885.not = icmp eq i64 %.3705800.us, %133
  br i1 %exitcond885.not, label %.loopexit, label %.lr.ph791.us, !llvm.loop !31

350:                                              ; preds = %131
  br i1 %.not718850, label %.loopexit, label %.lr.ph853

.lr.ph853:                                        ; preds = %350
  %351 = getelementptr inbounds i8, ptr %4, i64 4
  %352 = getelementptr i8, ptr %9, i64 4
  %353 = shl i64 %20, 3
  %354 = shl i64 %20, 3
  %355 = shl i64 %17, 3
  %356 = shl i64 %17, 3
  %357 = shl i64 %133, 3
  %358 = add i64 %357, -8
  %359 = mul i64 %17, %358
  %360 = getelementptr i8, ptr %7, i64 %359
  %scevgep961 = getelementptr i8, ptr %360, i64 -4
  %361 = or disjoint i64 %355, 4
  %scevgep966 = getelementptr i8, ptr %7, i64 %359
  %362 = shl i64 %20, 3
  %363 = shl i64 %20, 3
  %364 = shl i64 %17, 3
  %365 = shl i64 %17, 3
  %scevgep997 = getelementptr i8, ptr %7, i64 4
  %366 = shl i64 %20, 3
  %367 = shl i64 %17, 3
  %368 = shl i64 %20, 3
  %369 = shl i64 %20, 3
  %370 = shl i64 %17, 3
  %scevgep1094 = getelementptr i8, ptr %9, i64 8
  %invariant.gep = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1202 = getelementptr i8, ptr %7, i64 -4
  %invariant.gep1204 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1206 = getelementptr i8, ptr %7, i64 -4
  %invariant.gep1208 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1210 = getelementptr i8, ptr %7, i64 -4
  %371 = shl i64 %17, 3
  %invariant.gep1212 = getelementptr i8, ptr %10, i64 -4
  %372 = getelementptr i8, ptr %7, i64 %355
  %373 = getelementptr i8, ptr %7, i64 %361
  %stride.check1007 = icmp slt i64 %364, 0
  %stride.check971 = icmp slt i64 %355, 0
  br label %374

.loopexit744:                                     ; preds = %._crit_edge839, %._crit_edge834
  %exitcond891.not = icmp eq i64 %.4851, %133
  %indvar.next951 = add i64 %indvar950, 1
  br i1 %exitcond891.not, label %.loopexit, label %374, !llvm.loop !32

374:                                              ; preds = %.lr.ph853, %.loopexit744
  %indvar950 = phi i64 [ 0, %.lr.ph853 ], [ %indvar.next951, %.loopexit744 ]
  %.4851 = phi i64 [ 1, %.lr.ph853 ], [ %573, %.loopexit744 ]
  %375 = mul i64 %369, %indvar950
  %scevgep1086 = getelementptr i8, ptr %10, i64 %375
  %gep1201 = getelementptr i8, ptr %invariant.gep, i64 %375
  %376 = mul i64 %370, %indvar950
  %scevgep1089 = getelementptr i8, ptr %7, i64 %376
  %gep1203 = getelementptr i8, ptr %invariant.gep1202, i64 %376
  %377 = or disjoint i64 %375, 4
  %scevgep1092 = getelementptr i8, ptr %10, i64 %377
  %378 = or disjoint i64 %376, 4
  %scevgep1095 = getelementptr i8, ptr %7, i64 %378
  %379 = mul i64 %368, %indvar950
  %scevgep1077 = getelementptr i8, ptr %10, i64 %379
  %380 = or disjoint i64 %379, 4
  %scevgep1081 = getelementptr i8, ptr %10, i64 %380
  %381 = mul i64 %366, %indvar950
  %scevgep1036 = getelementptr i8, ptr %10, i64 %381
  %gep1205 = getelementptr i8, ptr %invariant.gep1204, i64 %381
  %382 = mul i64 %367, %indvar950
  %scevgep1039 = getelementptr i8, ptr %7, i64 %382
  %gep1207 = getelementptr i8, ptr %invariant.gep1206, i64 %382
  %383 = or disjoint i64 %381, 4
  %scevgep1042 = getelementptr i8, ptr %10, i64 %383
  %384 = or disjoint i64 %382, 4
  %scevgep1044 = getelementptr i8, ptr %7, i64 %384
  %385 = mul i64 %363, %indvar950
  %scevgep990 = getelementptr i8, ptr %10, i64 %385
  %gep1209 = getelementptr i8, ptr %invariant.gep1208, i64 %385
  %386 = mul i64 %365, %indvar950
  %reass.sub = sub i64 %386, %364
  %gep1211 = getelementptr i8, ptr %invariant.gep1210, i64 %reass.sub
  %387 = or disjoint i64 %385, 4
  %scevgep995 = getelementptr i8, ptr %10, i64 %387
  %388 = sub i64 %386, %371
  %scevgep998 = getelementptr i8, ptr %7, i64 %388
  %389 = mul i64 %362, %indvar950
  %scevgep981 = getelementptr i8, ptr %10, i64 %389
  %390 = or disjoint i64 %389, 4
  %scevgep985 = getelementptr i8, ptr %10, i64 %390
  %391 = mul i64 %354, %indvar950
  %scevgep957 = getelementptr i8, ptr %10, i64 %391
  %gep1213 = getelementptr i8, ptr %invariant.gep1212, i64 %391
  %392 = mul i64 %356, %indvar950
  %scevgep960 = getelementptr i8, ptr %372, i64 %392
  %393 = or disjoint i64 %391, 4
  %scevgep963 = getelementptr i8, ptr %10, i64 %393
  %scevgep965 = getelementptr i8, ptr %373, i64 %392
  %394 = mul i64 %353, %indvar950
  %scevgep952 = getelementptr i8, ptr %10, i64 %394
  %395 = or disjoint i64 %394, 4
  %scevgep953 = getelementptr i8, ptr %10, i64 %395
  %396 = mul nsw i64 %.4851, %14
  %397 = load float, ptr %4, align 4, !tbaa !9
  %398 = getelementptr %struct.complex, ptr %16, i64 %.4851
  %399 = getelementptr %struct.complex, ptr %398, i64 %396
  %400 = load float, ptr %399, align 4, !tbaa !9
  %401 = load float, ptr %351, align 4, !tbaa !12
  %402 = getelementptr inbounds i8, ptr %399, i64 4
  %403 = load float, ptr %402, align 4, !tbaa !12
  %404 = fneg float %401
  %405 = fmul float %403, %404
  %406 = tail call float @llvm.fmuladd.f32(float %397, float %400, float %405)
  %407 = fmul float %400, %401
  %408 = tail call float @llvm.fmuladd.f32(float %397, float %403, float %407)
  %409 = load float, ptr %9, align 4, !tbaa !9
  %410 = fcmp oeq float %409, 0.000000e+00
  br i1 %410, label %411, label %._crit_edge904

._crit_edge904:                                   ; preds = %374
  %.pre905 = load i64, ptr %2, align 8, !tbaa !5
  br label %454

411:                                              ; preds = %374
  %412 = load float, ptr %352, align 4, !tbaa !12
  %413 = fcmp oeq float %412, 0.000000e+00
  %.pre906 = load i64, ptr %2, align 8, !tbaa !5
  br i1 %413, label %414, label %454

414:                                              ; preds = %411
  %.not720811 = icmp slt i64 %.pre906, 1
  br i1 %.not720811, label %.loopexit745, label %.lr.ph814

.lr.ph814:                                        ; preds = %414
  %415 = mul nsw i64 %.4851, %20
  %416 = mul nsw i64 %.4851, %17
  %invariant.gep815 = getelementptr %struct.complex, ptr %19, i64 %416
  %417 = fneg float %408
  %invariant.gep817 = getelementptr %struct.complex, ptr %22, i64 %415
  %min.iters.check1055 = icmp ult i64 %.pre906, 4
  br i1 %min.iters.check1055, label %scalar.ph1054.preheader, label %vector.memcheck1035

vector.memcheck1035:                              ; preds = %.lr.ph814
  %418 = shl i64 %.pre906, 3
  %scevgep1038 = getelementptr i8, ptr %gep1205, i64 %418
  %scevgep1041 = getelementptr i8, ptr %gep1207, i64 %418
  %scevgep1043 = getelementptr i8, ptr %scevgep1036, i64 %418
  %scevgep1045 = getelementptr i8, ptr %scevgep1039, i64 %418
  %bound01046 = icmp ult ptr %scevgep1036, %scevgep1041
  %bound11047 = icmp ult ptr %scevgep1039, %scevgep1038
  %found.conflict1048 = and i1 %bound01046, %bound11047
  %bound01049 = icmp ult ptr %scevgep1042, %scevgep1045
  %bound11050 = icmp ult ptr %scevgep1044, %scevgep1043
  %found.conflict1051 = and i1 %bound01049, %bound11050
  %conflict.rdx1052 = or i1 %found.conflict1048, %found.conflict1051
  br i1 %conflict.rdx1052, label %scalar.ph1054.preheader, label %vector.ph1056

vector.ph1056:                                    ; preds = %vector.memcheck1035
  %n.vec1058 = and i64 %.pre906, 9223372036854775804
  %ind.end1059 = or disjoint i64 %n.vec1058, 1
  %broadcast.splatinsert1067 = insertelement <4 x float> poison, float %417, i64 0
  %broadcast.splat1068 = shufflevector <4 x float> %broadcast.splatinsert1067, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1069 = insertelement <4 x float> poison, float %406, i64 0
  %broadcast.splat1070 = shufflevector <4 x float> %broadcast.splatinsert1069, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1071 = insertelement <4 x float> poison, float %408, i64 0
  %broadcast.splat1072 = shufflevector <4 x float> %broadcast.splatinsert1071, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body1061

vector.body1061:                                  ; preds = %vector.body1061, %vector.ph1056
  %index1062 = phi i64 [ 0, %vector.ph1056 ], [ %index.next1074, %vector.body1061 ]
  %offset.idx1063 = or disjoint i64 %index1062, 1
  %419 = getelementptr %struct.complex, ptr %invariant.gep815, i64 %offset.idx1063
  %wide.vec1064 = load <8 x float>, ptr %419, align 4, !tbaa !13
  %strided.vec1065 = shufflevector <8 x float> %wide.vec1064, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1066 = shufflevector <8 x float> %wide.vec1064, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %420 = fmul <4 x float> %strided.vec1066, %broadcast.splat1068
  %421 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1070, <4 x float> %strided.vec1065, <4 x float> %420)
  %422 = fmul <4 x float> %broadcast.splat1072, %strided.vec1065
  %423 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1070, <4 x float> %strided.vec1066, <4 x float> %422)
  %424 = getelementptr %struct.complex, ptr %invariant.gep817, i64 %offset.idx1063
  %interleaved.vec1073 = shufflevector <4 x float> %421, <4 x float> %423, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1073, ptr %424, align 4, !tbaa !13
  %index.next1074 = add nuw i64 %index1062, 4
  %425 = icmp eq i64 %index.next1074, %n.vec1058
  br i1 %425, label %middle.block1053, label %vector.body1061, !llvm.loop !33

middle.block1053:                                 ; preds = %vector.body1061
  %cmp.n1075 = icmp eq i64 %.pre906, %n.vec1058
  br i1 %cmp.n1075, label %.loopexit745, label %scalar.ph1054.preheader

scalar.ph1054.preheader:                          ; preds = %middle.block1053, %vector.memcheck1035, %.lr.ph814
  %.4710812.ph = phi i64 [ 1, %vector.memcheck1035 ], [ 1, %.lr.ph814 ], [ %ind.end1059, %middle.block1053 ]
  %xtraiter = and i64 %.pre906, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph1054.prol.loopexit, label %scalar.ph1054.prol

scalar.ph1054.prol:                               ; preds = %scalar.ph1054.preheader
  %gep816.prol = getelementptr %struct.complex, ptr %invariant.gep815, i64 %.4710812.ph
  %gep818.prol = getelementptr %struct.complex, ptr %invariant.gep817, i64 %.4710812.ph
  %426 = load <2 x float>, ptr %gep816.prol, align 4, !tbaa !13
  %427 = insertelement <2 x float> poison, float %408, i64 0
  %428 = insertelement <2 x float> %427, float %417, i64 1
  %429 = fmul <2 x float> %426, %428
  %430 = shufflevector <2 x float> %429, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %431 = insertelement <2 x float> poison, float %406, i64 0
  %432 = shufflevector <2 x float> %431, <2 x float> poison, <2 x i32> zeroinitializer
  %433 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %432, <2 x float> %426, <2 x float> %430)
  store <2 x float> %433, ptr %gep818.prol, align 4, !tbaa !13
  %434 = add nuw i64 %.4710812.ph, 1
  br label %scalar.ph1054.prol.loopexit

scalar.ph1054.prol.loopexit:                      ; preds = %scalar.ph1054.prol, %scalar.ph1054.preheader
  %.4710812.unr = phi i64 [ %.4710812.ph, %scalar.ph1054.preheader ], [ %434, %scalar.ph1054.prol ]
  %435 = icmp eq i64 %.pre906, %.4710812.ph
  br i1 %435, label %.loopexit745, label %scalar.ph1054.preheader.new

scalar.ph1054.preheader.new:                      ; preds = %scalar.ph1054.prol.loopexit
  %436 = insertelement <2 x float> poison, float %408, i64 0
  %437 = insertelement <2 x float> %436, float %417, i64 1
  %438 = insertelement <2 x float> poison, float %406, i64 0
  %439 = shufflevector <2 x float> %438, <2 x float> poison, <2 x i32> zeroinitializer
  %440 = insertelement <2 x float> poison, float %408, i64 0
  %441 = insertelement <2 x float> %440, float %417, i64 1
  %442 = insertelement <2 x float> poison, float %406, i64 0
  %443 = shufflevector <2 x float> %442, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph1054

scalar.ph1054:                                    ; preds = %scalar.ph1054, %scalar.ph1054.preheader.new
  %.4710812 = phi i64 [ %.4710812.unr, %scalar.ph1054.preheader.new ], [ %453, %scalar.ph1054 ]
  %gep816 = getelementptr %struct.complex, ptr %invariant.gep815, i64 %.4710812
  %gep818 = getelementptr %struct.complex, ptr %invariant.gep817, i64 %.4710812
  %444 = load <2 x float>, ptr %gep816, align 4, !tbaa !13
  %445 = fmul <2 x float> %444, %437
  %446 = shufflevector <2 x float> %445, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %447 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %439, <2 x float> %444, <2 x float> %446)
  store <2 x float> %447, ptr %gep818, align 4, !tbaa !13
  %448 = add nuw i64 %.4710812, 1
  %gep816.1 = getelementptr %struct.complex, ptr %invariant.gep815, i64 %448
  %gep818.1 = getelementptr %struct.complex, ptr %invariant.gep817, i64 %448
  %449 = load <2 x float>, ptr %gep816.1, align 4, !tbaa !13
  %450 = fmul <2 x float> %449, %441
  %451 = shufflevector <2 x float> %450, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %452 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %443, <2 x float> %449, <2 x float> %451)
  store <2 x float> %452, ptr %gep818.1, align 4, !tbaa !13
  %453 = add nuw i64 %.4710812, 2
  %exitcond887.not.1 = icmp eq i64 %448, %.pre906
  br i1 %exitcond887.not.1, label %.loopexit745, label %scalar.ph1054, !llvm.loop !34

454:                                              ; preds = %._crit_edge904, %411
  %455 = phi i64 [ %.pre905, %._crit_edge904 ], [ %.pre906, %411 ]
  %.not719803 = icmp slt i64 %455, 1
  br i1 %.not719803, label %.loopexit745, label %.lr.ph806

.lr.ph806:                                        ; preds = %454
  %456 = mul nsw i64 %.4851, %20
  %invariant.gep807 = getelementptr %struct.complex, ptr %22, i64 %456
  %457 = mul nsw i64 %.4851, %17
  %invariant.gep809 = getelementptr %struct.complex, ptr %19, i64 %457
  %458 = fneg float %408
  %min.iters.check1114 = icmp ult i64 %455, 8
  br i1 %min.iters.check1114, label %scalar.ph1113.preheader, label %vector.scevcheck1076

vector.scevcheck1076:                             ; preds = %.lr.ph806
  %459 = add nsw i64 %455, -1
  %mul.result1079 = shl i64 %459, 3
  %460 = getelementptr i8, ptr %scevgep1077, i64 %mul.result1079
  %461 = icmp ult ptr %460, %scevgep1077
  %mul.result1083 = shl i64 %459, 3
  %mul.overflow1084 = icmp ugt i64 %459, 2305843009213693951
  %462 = getelementptr i8, ptr %scevgep1081, i64 %mul.result1083
  %463 = icmp ult ptr %462, %scevgep1081
  %464 = or i1 %463, %mul.overflow1084
  %465 = or i1 %461, %464
  br i1 %465, label %scalar.ph1113.preheader, label %vector.memcheck1085

vector.memcheck1085:                              ; preds = %vector.scevcheck1076
  %466 = shl i64 %455, 3
  %scevgep1088 = getelementptr i8, ptr %gep1201, i64 %466
  %scevgep1091 = getelementptr i8, ptr %gep1203, i64 %466
  %scevgep1093 = getelementptr i8, ptr %scevgep1086, i64 %466
  %scevgep1096 = getelementptr i8, ptr %scevgep1089, i64 %466
  %bound01097 = icmp ult ptr %scevgep1086, %352
  %bound11098 = icmp ugt ptr %scevgep1088, %9
  %found.conflict1099 = and i1 %bound01097, %bound11098
  %bound01100 = icmp ult ptr %scevgep1086, %scevgep1091
  %bound11101 = icmp ult ptr %scevgep1089, %scevgep1088
  %found.conflict1102 = and i1 %bound01100, %bound11101
  %conflict.rdx1103 = or i1 %found.conflict1099, %found.conflict1102
  %bound01104 = icmp ult ptr %scevgep1092, %scevgep1094
  %bound11105 = icmp ult ptr %352, %scevgep1093
  %found.conflict1106 = and i1 %bound01104, %bound11105
  %conflict.rdx1107 = or i1 %conflict.rdx1103, %found.conflict1106
  %bound01108 = icmp ult ptr %scevgep1092, %scevgep1096
  %bound11109 = icmp ult ptr %scevgep1095, %scevgep1093
  %found.conflict1110 = and i1 %bound01108, %bound11109
  %conflict.rdx1111 = or i1 %conflict.rdx1107, %found.conflict1110
  br i1 %conflict.rdx1111, label %scalar.ph1113.preheader, label %vector.ph1115

vector.ph1115:                                    ; preds = %vector.memcheck1085
  %n.vec1117 = and i64 %455, 4611686018427387900
  %ind.end1118 = or disjoint i64 %n.vec1117, 1
  %broadcast.splatinsert1133 = insertelement <4 x float> poison, float %458, i64 0
  %broadcast.splat1134 = shufflevector <4 x float> %broadcast.splatinsert1133, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1135 = insertelement <4 x float> poison, float %406, i64 0
  %broadcast.splat1136 = shufflevector <4 x float> %broadcast.splatinsert1135, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1137 = insertelement <4 x float> poison, float %408, i64 0
  %broadcast.splat1138 = shufflevector <4 x float> %broadcast.splatinsert1137, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body1120

vector.body1120:                                  ; preds = %vector.body1120, %vector.ph1115
  %index1121 = phi i64 [ 0, %vector.ph1115 ], [ %index.next1140, %vector.body1120 ]
  %offset.idx1122 = or disjoint i64 %index1121, 1
  %467 = load float, ptr %9, align 4, !tbaa !9, !alias.scope !35
  %broadcast.splatinsert1128 = insertelement <4 x float> poison, float %467, i64 0
  %broadcast.splat1129 = shufflevector <4 x float> %broadcast.splatinsert1128, <4 x float> poison, <4 x i32> zeroinitializer
  %468 = getelementptr %struct.complex, ptr %invariant.gep807, i64 %offset.idx1122
  %wide.vec1123 = load <8 x float>, ptr %468, align 4, !tbaa !13
  %strided.vec1124 = shufflevector <8 x float> %wide.vec1123, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1125 = shufflevector <8 x float> %wide.vec1123, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %469 = load float, ptr %352, align 4, !tbaa !12, !alias.scope !38
  %broadcast.splatinsert1126 = insertelement <4 x float> poison, float %469, i64 0
  %broadcast.splat1127 = shufflevector <4 x float> %broadcast.splatinsert1126, <4 x float> poison, <4 x i32> zeroinitializer
  %470 = fneg <4 x float> %broadcast.splat1127
  %471 = fmul <4 x float> %strided.vec1125, %470
  %472 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1129, <4 x float> %strided.vec1124, <4 x float> %471)
  %473 = fmul <4 x float> %strided.vec1124, %broadcast.splat1127
  %474 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1129, <4 x float> %strided.vec1125, <4 x float> %473)
  %475 = getelementptr %struct.complex, ptr %invariant.gep809, i64 %offset.idx1122
  %wide.vec1130 = load <8 x float>, ptr %475, align 4, !tbaa !13
  %strided.vec1131 = shufflevector <8 x float> %wide.vec1130, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1132 = shufflevector <8 x float> %wide.vec1130, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %476 = fmul <4 x float> %strided.vec1132, %broadcast.splat1134
  %477 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1136, <4 x float> %strided.vec1131, <4 x float> %476)
  %478 = fmul <4 x float> %broadcast.splat1138, %strided.vec1131
  %479 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1136, <4 x float> %strided.vec1132, <4 x float> %478)
  %480 = fadd <4 x float> %472, %477
  %481 = fadd <4 x float> %474, %479
  %interleaved.vec1139 = shufflevector <4 x float> %480, <4 x float> %481, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1139, ptr %468, align 4, !tbaa !13
  %index.next1140 = add nuw i64 %index1121, 4
  %482 = icmp eq i64 %index.next1140, %n.vec1117
  br i1 %482, label %middle.block1112, label %vector.body1120, !llvm.loop !40

middle.block1112:                                 ; preds = %vector.body1120
  %cmp.n1141 = icmp eq i64 %455, %n.vec1117
  br i1 %cmp.n1141, label %.loopexit745, label %scalar.ph1113.preheader

scalar.ph1113.preheader:                          ; preds = %middle.block1112, %vector.memcheck1085, %vector.scevcheck1076, %.lr.ph806
  %.5804.ph = phi i64 [ 1, %vector.memcheck1085 ], [ 1, %vector.scevcheck1076 ], [ 1, %.lr.ph806 ], [ %ind.end1118, %middle.block1112 ]
  %483 = insertelement <2 x float> poison, float %408, i64 0
  %484 = insertelement <2 x float> %483, float %458, i64 1
  %485 = insertelement <2 x float> poison, float %406, i64 0
  %486 = shufflevector <2 x float> %485, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph1113

scalar.ph1113:                                    ; preds = %scalar.ph1113.preheader, %scalar.ph1113
  %.5804 = phi i64 [ %503, %scalar.ph1113 ], [ %.5804.ph, %scalar.ph1113.preheader ]
  %487 = load float, ptr %9, align 4, !tbaa !9
  %gep808 = getelementptr %struct.complex, ptr %invariant.gep807, i64 %.5804
  %488 = load float, ptr %352, align 4, !tbaa !12
  %489 = fneg float %488
  %gep810 = getelementptr %struct.complex, ptr %invariant.gep809, i64 %.5804
  %490 = load <2 x float>, ptr %gep808, align 4, !tbaa !13
  %491 = insertelement <2 x float> poison, float %488, i64 0
  %492 = insertelement <2 x float> %491, float %489, i64 1
  %493 = fmul <2 x float> %490, %492
  %494 = shufflevector <2 x float> %493, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %495 = insertelement <2 x float> poison, float %487, i64 0
  %496 = shufflevector <2 x float> %495, <2 x float> poison, <2 x i32> zeroinitializer
  %497 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %496, <2 x float> %490, <2 x float> %494)
  %498 = load <2 x float>, ptr %gep810, align 4, !tbaa !13
  %499 = fmul <2 x float> %498, %484
  %500 = shufflevector <2 x float> %499, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %501 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %486, <2 x float> %498, <2 x float> %500)
  %502 = fadd <2 x float> %497, %501
  store <2 x float> %502, ptr %gep808, align 4, !tbaa !13
  %503 = add nuw i64 %.5804, 1
  %exitcond886.not = icmp eq i64 %.5804, %455
  br i1 %exitcond886.not, label %.loopexit745, label %scalar.ph1113, !llvm.loop !41

.loopexit745:                                     ; preds = %scalar.ph1113, %scalar.ph1054.prol.loopexit, %scalar.ph1054, %middle.block1112, %middle.block1053, %454, %414
  %504 = phi i64 [ %455, %454 ], [ %.pre906, %414 ], [ %.pre906, %middle.block1053 ], [ %455, %middle.block1112 ], [ %.pre906, %scalar.ph1054 ], [ %.pre906, %scalar.ph1054.prol.loopexit ], [ %455, %scalar.ph1113 ]
  %invariant.gep828 = getelementptr %struct.complex, ptr %16, i64 %396
  %.not721.not830 = icmp ugt i64 %.4851, 1
  br i1 %.not721.not830, label %.lr.ph833, label %._crit_edge834

.lr.ph833:                                        ; preds = %.loopexit745
  %.not726819 = icmp slt i64 %504, 1
  %505 = mul nsw i64 %.4851, %20
  %invariant.gep826 = getelementptr %struct.complex, ptr %22, i64 %505
  %506 = add i64 %504, -1
  %507 = shl i64 %504, 3
  %scevgep992 = getelementptr i8, ptr %gep1209, i64 %507
  %scevgep994 = getelementptr i8, ptr %gep1211, i64 %507
  %scevgep996 = getelementptr i8, ptr %scevgep990, i64 %507
  %scevgep999 = getelementptr i8, ptr %scevgep998, i64 %507
  %min.iters.check1011 = icmp ult i64 %504, 8
  %mul.result983 = shl i64 %506, 3
  %508 = getelementptr i8, ptr %scevgep981, i64 %mul.result983
  %509 = icmp ult ptr %508, %scevgep981
  %mul.result987 = shl i64 %506, 3
  %mul.overflow988 = icmp ugt i64 %506, 2305843009213693951
  %510 = getelementptr i8, ptr %scevgep985, i64 %mul.result987
  %511 = icmp ult ptr %510, %scevgep985
  %512 = or i1 %511, %mul.overflow988
  %513 = or i1 %509, %512
  %bound01000 = icmp ult ptr %scevgep990, %scevgep994
  %bound11001 = icmp ugt ptr %scevgep992, %7
  %found.conflict1002 = and i1 %bound01000, %bound11001
  %bound01004 = icmp ult ptr %scevgep995, %scevgep999
  %bound11005 = icmp ult ptr %scevgep997, %scevgep996
  %found.conflict1006 = and i1 %bound01004, %bound11005
  %514 = or i1 %found.conflict1006, %stride.check1007
  %conflict.rdx1008 = or i1 %found.conflict1002, %514
  %n.vec1014 = and i64 %504, 4611686018427387900
  %ind.end1015 = or disjoint i64 %n.vec1014, 1
  %cmp.n1034 = icmp eq i64 %504, %n.vec1014
  %xtraiter1194 = and i64 %504, 1
  %lcmp.mod1195.not = icmp eq i64 %xtraiter1194, 0
  br label %515

515:                                              ; preds = %.lr.ph833, %._crit_edge823
  %.2831 = phi i64 [ 1, %.lr.ph833 ], [ %572, %._crit_edge823 ]
  %516 = mul nsw i64 %.2831, %14
  %517 = getelementptr %struct.complex, ptr %398, i64 %516
  %gep829 = getelementptr %struct.complex, ptr %invariant.gep828, i64 %.2831
  %.sink928 = select i1 %.not714, ptr %517, ptr %gep829
  %.sink920 = load float, ptr %4, align 4, !tbaa !9
  %518 = load float, ptr %.sink928, align 4, !tbaa !9
  %519 = load float, ptr %351, align 4, !tbaa !12
  %520 = getelementptr inbounds i8, ptr %.sink928, i64 4
  %521 = load float, ptr %520, align 4, !tbaa !12
  %522 = fneg float %519
  %523 = fmul float %521, %522
  %524 = tail call float @llvm.fmuladd.f32(float %.sink920, float %518, float %523)
  %525 = fmul float %518, %519
  %526 = tail call float @llvm.fmuladd.f32(float %.sink920, float %521, float %525)
  br i1 %.not726819, label %._crit_edge823, label %.lr.ph822

.lr.ph822:                                        ; preds = %515
  %527 = mul nsw i64 %.2831, %17
  %invariant.gep824 = getelementptr %struct.complex, ptr %19, i64 %527
  %528 = fneg float %526
  %brmerge1214 = select i1 %min.iters.check1011, i1 true, i1 %513
  %brmerge1215 = select i1 %brmerge1214, i1 true, i1 %conflict.rdx1008
  br i1 %brmerge1215, label %scalar.ph1010.preheader, label %vector.ph1012

vector.ph1012:                                    ; preds = %.lr.ph822
  %broadcast.splatinsert1023 = insertelement <4 x float> poison, float %528, i64 0
  %broadcast.splat1024 = shufflevector <4 x float> %broadcast.splatinsert1023, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1025 = insertelement <4 x float> poison, float %524, i64 0
  %broadcast.splat1026 = shufflevector <4 x float> %broadcast.splatinsert1025, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1027 = insertelement <4 x float> poison, float %526, i64 0
  %broadcast.splat1028 = shufflevector <4 x float> %broadcast.splatinsert1027, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body1017

vector.body1017:                                  ; preds = %vector.body1017, %vector.ph1012
  %index1018 = phi i64 [ 0, %vector.ph1012 ], [ %index.next1033, %vector.body1017 ]
  %offset.idx1019 = or disjoint i64 %index1018, 1
  %529 = getelementptr %struct.complex, ptr %invariant.gep824, i64 %offset.idx1019
  %wide.vec1020 = load <8 x float>, ptr %529, align 4, !tbaa !13
  %strided.vec1021 = shufflevector <8 x float> %wide.vec1020, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1022 = shufflevector <8 x float> %wide.vec1020, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %530 = fmul <4 x float> %strided.vec1022, %broadcast.splat1024
  %531 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1026, <4 x float> %strided.vec1021, <4 x float> %530)
  %532 = fmul <4 x float> %broadcast.splat1028, %strided.vec1021
  %533 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1026, <4 x float> %strided.vec1022, <4 x float> %532)
  %534 = getelementptr %struct.complex, ptr %invariant.gep826, i64 %offset.idx1019
  %wide.vec1029 = load <8 x float>, ptr %534, align 4, !tbaa !13
  %strided.vec1030 = shufflevector <8 x float> %wide.vec1029, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1031 = shufflevector <8 x float> %wide.vec1029, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %535 = fadd <4 x float> %strided.vec1030, %531
  %536 = fadd <4 x float> %533, %strided.vec1031
  %interleaved.vec1032 = shufflevector <4 x float> %535, <4 x float> %536, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1032, ptr %534, align 4, !tbaa !13
  %index.next1033 = add nuw i64 %index1018, 4
  %537 = icmp eq i64 %index.next1033, %n.vec1014
  br i1 %537, label %middle.block1009, label %vector.body1017, !llvm.loop !42

middle.block1009:                                 ; preds = %vector.body1017
  br i1 %cmp.n1034, label %._crit_edge823, label %scalar.ph1010.preheader

scalar.ph1010.preheader:                          ; preds = %.lr.ph822, %middle.block1009
  %.6820.ph = phi i64 [ 1, %.lr.ph822 ], [ %ind.end1015, %middle.block1009 ]
  br i1 %lcmp.mod1195.not, label %scalar.ph1010.prol.loopexit, label %scalar.ph1010.prol

scalar.ph1010.prol:                               ; preds = %scalar.ph1010.preheader
  %gep825.prol = getelementptr %struct.complex, ptr %invariant.gep824, i64 %.6820.ph
  %gep827.prol = getelementptr %struct.complex, ptr %invariant.gep826, i64 %.6820.ph
  %538 = load <2 x float>, ptr %gep825.prol, align 4, !tbaa !13
  %539 = insertelement <2 x float> poison, float %526, i64 0
  %540 = insertelement <2 x float> %539, float %528, i64 1
  %541 = fmul <2 x float> %538, %540
  %542 = shufflevector <2 x float> %541, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %543 = insertelement <2 x float> poison, float %524, i64 0
  %544 = shufflevector <2 x float> %543, <2 x float> poison, <2 x i32> zeroinitializer
  %545 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %544, <2 x float> %538, <2 x float> %542)
  %546 = load <2 x float>, ptr %gep827.prol, align 4, !tbaa !13
  %547 = fadd <2 x float> %546, %545
  store <2 x float> %547, ptr %gep827.prol, align 4, !tbaa !13
  %548 = add nuw nsw i64 %.6820.ph, 1
  br label %scalar.ph1010.prol.loopexit

scalar.ph1010.prol.loopexit:                      ; preds = %scalar.ph1010.prol, %scalar.ph1010.preheader
  %.6820.unr = phi i64 [ %.6820.ph, %scalar.ph1010.preheader ], [ %548, %scalar.ph1010.prol ]
  %549 = icmp eq i64 %504, %.6820.ph
  br i1 %549, label %._crit_edge823, label %scalar.ph1010.preheader.new

scalar.ph1010.preheader.new:                      ; preds = %scalar.ph1010.prol.loopexit
  %550 = insertelement <2 x float> poison, float %526, i64 0
  %551 = insertelement <2 x float> %550, float %528, i64 1
  %552 = insertelement <2 x float> poison, float %524, i64 0
  %553 = shufflevector <2 x float> %552, <2 x float> poison, <2 x i32> zeroinitializer
  %554 = insertelement <2 x float> poison, float %526, i64 0
  %555 = insertelement <2 x float> %554, float %528, i64 1
  %556 = insertelement <2 x float> poison, float %524, i64 0
  %557 = shufflevector <2 x float> %556, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph1010

scalar.ph1010:                                    ; preds = %scalar.ph1010, %scalar.ph1010.preheader.new
  %.6820 = phi i64 [ %.6820.unr, %scalar.ph1010.preheader.new ], [ %571, %scalar.ph1010 ]
  %gep825 = getelementptr %struct.complex, ptr %invariant.gep824, i64 %.6820
  %gep827 = getelementptr %struct.complex, ptr %invariant.gep826, i64 %.6820
  %558 = load <2 x float>, ptr %gep825, align 4, !tbaa !13
  %559 = fmul <2 x float> %558, %551
  %560 = shufflevector <2 x float> %559, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %561 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %553, <2 x float> %558, <2 x float> %560)
  %562 = load <2 x float>, ptr %gep827, align 4, !tbaa !13
  %563 = fadd <2 x float> %562, %561
  store <2 x float> %563, ptr %gep827, align 4, !tbaa !13
  %564 = add nuw i64 %.6820, 1
  %gep825.1 = getelementptr %struct.complex, ptr %invariant.gep824, i64 %564
  %gep827.1 = getelementptr %struct.complex, ptr %invariant.gep826, i64 %564
  %565 = load <2 x float>, ptr %gep825.1, align 4, !tbaa !13
  %566 = fmul <2 x float> %565, %555
  %567 = shufflevector <2 x float> %566, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %568 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %557, <2 x float> %565, <2 x float> %567)
  %569 = load <2 x float>, ptr %gep827.1, align 4, !tbaa !13
  %570 = fadd <2 x float> %569, %568
  store <2 x float> %570, ptr %gep827.1, align 4, !tbaa !13
  %571 = add nuw i64 %.6820, 2
  %exitcond888.not.1 = icmp eq i64 %564, %504
  br i1 %exitcond888.not.1, label %._crit_edge823, label %scalar.ph1010, !llvm.loop !43

._crit_edge823:                                   ; preds = %scalar.ph1010.prol.loopexit, %scalar.ph1010, %middle.block1009, %515
  %572 = add nuw nsw i64 %.2831, 1
  %exitcond889.not = icmp eq i64 %572, %.4851
  br i1 %exitcond889.not, label %._crit_edge834, label %515, !llvm.loop !44

._crit_edge834:                                   ; preds = %._crit_edge823, %.loopexit745
  %573 = add nuw i64 %.4851, 1
  %.not722846.not = icmp slt i64 %.4851, %133
  br i1 %.not722846.not, label %.lr.ph849, label %.loopexit744

.lr.ph849:                                        ; preds = %._crit_edge834
  %.not724835 = icmp slt i64 %504, 1
  %574 = mul nsw i64 %.4851, %20
  %invariant.gep842 = getelementptr %struct.complex, ptr %22, i64 %574
  %575 = add i64 %504, -1
  %576 = shl i64 %504, 3
  %scevgep959 = getelementptr i8, ptr %gep1213, i64 %576
  %scevgep962 = getelementptr i8, ptr %scevgep961, i64 %576
  %scevgep964 = getelementptr i8, ptr %scevgep957, i64 %576
  %scevgep967 = getelementptr i8, ptr %scevgep966, i64 %576
  %min.iters.check = icmp ult i64 %504, 8
  %mul.result = shl i64 %575, 3
  %577 = getelementptr i8, ptr %scevgep952, i64 %mul.result
  %578 = icmp ult ptr %577, %scevgep952
  %mul.result955 = shl i64 %575, 3
  %mul.overflow956 = icmp ugt i64 %575, 2305843009213693951
  %579 = getelementptr i8, ptr %scevgep953, i64 %mul.result955
  %580 = icmp ult ptr %579, %scevgep953
  %581 = or i1 %580, %mul.overflow956
  %582 = or i1 %578, %581
  %bound0 = icmp ult ptr %scevgep957, %scevgep962
  %bound1 = icmp ult ptr %scevgep960, %scevgep959
  %found.conflict = and i1 %bound0, %bound1
  %bound0968 = icmp ult ptr %scevgep963, %scevgep967
  %bound1969 = icmp ult ptr %scevgep965, %scevgep964
  %found.conflict970 = and i1 %bound0968, %bound1969
  %583 = or i1 %found.conflict970, %stride.check971
  %conflict.rdx = or i1 %found.conflict, %583
  %n.vec = and i64 %504, 4611686018427387900
  %ind.end = or disjoint i64 %n.vec, 1
  %cmp.n = icmp eq i64 %504, %n.vec
  %xtraiter1196 = and i64 %504, 1
  %lcmp.mod1197.not = icmp eq i64 %xtraiter1196, 0
  br label %584

584:                                              ; preds = %.lr.ph849, %._crit_edge839
  %.3847 = phi i64 [ %573, %.lr.ph849 ], [ %641, %._crit_edge839 ]
  %gep845 = getelementptr %struct.complex, ptr %invariant.gep828, i64 %.3847
  %585 = mul nsw i64 %.3847, %14
  %586 = getelementptr %struct.complex, ptr %398, i64 %585
  %gep845.sink941 = select i1 %.not714, ptr %gep845, ptr %586
  %.sink934 = load float, ptr %4, align 4, !tbaa !9
  %587 = load float, ptr %gep845.sink941, align 4, !tbaa !9
  %588 = load float, ptr %351, align 4, !tbaa !12
  %589 = getelementptr inbounds i8, ptr %gep845.sink941, i64 4
  %590 = load float, ptr %589, align 4, !tbaa !12
  %591 = fneg float %588
  %592 = fmul float %590, %591
  %593 = tail call float @llvm.fmuladd.f32(float %.sink934, float %587, float %592)
  %594 = fmul float %587, %588
  %595 = tail call float @llvm.fmuladd.f32(float %.sink934, float %590, float %594)
  br i1 %.not724835, label %._crit_edge839, label %.lr.ph838

.lr.ph838:                                        ; preds = %584
  %596 = mul nsw i64 %.3847, %17
  %invariant.gep840 = getelementptr %struct.complex, ptr %19, i64 %596
  %597 = fneg float %595
  %brmerge1216 = select i1 %min.iters.check, i1 true, i1 %582
  %brmerge1217 = select i1 %brmerge1216, i1 true, i1 %conflict.rdx
  br i1 %brmerge1217, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph838
  %broadcast.splatinsert = insertelement <4 x float> poison, float %597, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert973 = insertelement <4 x float> poison, float %593, i64 0
  %broadcast.splat974 = shufflevector <4 x float> %broadcast.splatinsert973, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert975 = insertelement <4 x float> poison, float %595, i64 0
  %broadcast.splat976 = shufflevector <4 x float> %broadcast.splatinsert975, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %offset.idx = or disjoint i64 %index, 1
  %598 = getelementptr %struct.complex, ptr %invariant.gep840, i64 %offset.idx
  %wide.vec = load <8 x float>, ptr %598, align 4, !tbaa !13
  %strided.vec = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec972 = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %599 = fmul <4 x float> %strided.vec972, %broadcast.splat
  %600 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat974, <4 x float> %strided.vec, <4 x float> %599)
  %601 = fmul <4 x float> %broadcast.splat976, %strided.vec
  %602 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat974, <4 x float> %strided.vec972, <4 x float> %601)
  %603 = getelementptr %struct.complex, ptr %invariant.gep842, i64 %offset.idx
  %wide.vec977 = load <8 x float>, ptr %603, align 4, !tbaa !13
  %strided.vec978 = shufflevector <8 x float> %wide.vec977, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec979 = shufflevector <8 x float> %wide.vec977, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %604 = fadd <4 x float> %strided.vec978, %600
  %605 = fadd <4 x float> %602, %strided.vec979
  %interleaved.vec = shufflevector <4 x float> %604, <4 x float> %605, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec, ptr %603, align 4, !tbaa !13
  %index.next = add nuw i64 %index, 4
  %606 = icmp eq i64 %index.next, %n.vec
  br i1 %606, label %middle.block, label %vector.body, !llvm.loop !45

middle.block:                                     ; preds = %vector.body
  br i1 %cmp.n, label %._crit_edge839, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %.lr.ph838, %middle.block
  %.7836.ph = phi i64 [ 1, %.lr.ph838 ], [ %ind.end, %middle.block ]
  br i1 %lcmp.mod1197.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader
  %gep841.prol = getelementptr %struct.complex, ptr %invariant.gep840, i64 %.7836.ph
  %gep843.prol = getelementptr %struct.complex, ptr %invariant.gep842, i64 %.7836.ph
  %607 = load <2 x float>, ptr %gep841.prol, align 4, !tbaa !13
  %608 = insertelement <2 x float> poison, float %595, i64 0
  %609 = insertelement <2 x float> %608, float %597, i64 1
  %610 = fmul <2 x float> %607, %609
  %611 = shufflevector <2 x float> %610, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %612 = insertelement <2 x float> poison, float %593, i64 0
  %613 = shufflevector <2 x float> %612, <2 x float> poison, <2 x i32> zeroinitializer
  %614 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %613, <2 x float> %607, <2 x float> %611)
  %615 = load <2 x float>, ptr %gep843.prol, align 4, !tbaa !13
  %616 = fadd <2 x float> %615, %614
  store <2 x float> %616, ptr %gep843.prol, align 4, !tbaa !13
  %617 = add nuw nsw i64 %.7836.ph, 1
  br label %scalar.ph.prol.loopexit

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %scalar.ph.preheader
  %.7836.unr = phi i64 [ %.7836.ph, %scalar.ph.preheader ], [ %617, %scalar.ph.prol ]
  %618 = icmp eq i64 %504, %.7836.ph
  br i1 %618, label %._crit_edge839, label %scalar.ph.preheader.new

scalar.ph.preheader.new:                          ; preds = %scalar.ph.prol.loopexit
  %619 = insertelement <2 x float> poison, float %595, i64 0
  %620 = insertelement <2 x float> %619, float %597, i64 1
  %621 = insertelement <2 x float> poison, float %593, i64 0
  %622 = shufflevector <2 x float> %621, <2 x float> poison, <2 x i32> zeroinitializer
  %623 = insertelement <2 x float> poison, float %595, i64 0
  %624 = insertelement <2 x float> %623, float %597, i64 1
  %625 = insertelement <2 x float> poison, float %593, i64 0
  %626 = shufflevector <2 x float> %625, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph, %scalar.ph.preheader.new
  %.7836 = phi i64 [ %.7836.unr, %scalar.ph.preheader.new ], [ %640, %scalar.ph ]
  %gep841 = getelementptr %struct.complex, ptr %invariant.gep840, i64 %.7836
  %gep843 = getelementptr %struct.complex, ptr %invariant.gep842, i64 %.7836
  %627 = load <2 x float>, ptr %gep841, align 4, !tbaa !13
  %628 = fmul <2 x float> %627, %620
  %629 = shufflevector <2 x float> %628, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %630 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %622, <2 x float> %627, <2 x float> %629)
  %631 = load <2 x float>, ptr %gep843, align 4, !tbaa !13
  %632 = fadd <2 x float> %631, %630
  store <2 x float> %632, ptr %gep843, align 4, !tbaa !13
  %633 = add nuw i64 %.7836, 1
  %gep841.1 = getelementptr %struct.complex, ptr %invariant.gep840, i64 %633
  %gep843.1 = getelementptr %struct.complex, ptr %invariant.gep842, i64 %633
  %634 = load <2 x float>, ptr %gep841.1, align 4, !tbaa !13
  %635 = fmul <2 x float> %634, %624
  %636 = shufflevector <2 x float> %635, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %637 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %626, <2 x float> %634, <2 x float> %636)
  %638 = load <2 x float>, ptr %gep843.1, align 4, !tbaa !13
  %639 = fadd <2 x float> %638, %637
  store <2 x float> %639, ptr %gep843.1, align 4, !tbaa !13
  %640 = add nuw i64 %.7836, 2
  %exitcond890.not.1 = icmp eq i64 %633, %504
  br i1 %exitcond890.not.1, label %._crit_edge839, label %scalar.ph, !llvm.loop !46

._crit_edge839:                                   ; preds = %scalar.ph.prol.loopexit, %scalar.ph, %middle.block, %584
  %641 = add nuw nsw i64 %.3847, 1
  %.not722.not = icmp slt i64 %.3847, %133
  br i1 %.not722.not, label %584, label %.loopexit744, !llvm.loop !47

.loopexit.loopexit.unr-lcssa:                     ; preds = %.preheader, %.preheader.preheader
  %indvar.unr = phi i64 [ 0, %.preheader.preheader ], [ %indvar.next.7, %.preheader ]
  %lcmp.mod1199.not = icmp eq i64 %xtraiter1198, 0
  br i1 %lcmp.mod1199.not, label %.loopexit, label %.preheader.epil

.preheader.epil:                                  ; preds = %.loopexit.loopexit.unr-lcssa, %.preheader.epil
  %indvar.epil = phi i64 [ %indvar.next.epil, %.preheader.epil ], [ %indvar.unr, %.loopexit.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.preheader.epil ], [ 0, %.loopexit.loopexit.unr-lcssa ]
  %642 = mul i64 %79, %indvar.epil
  %scevgep.epil = getelementptr i8, ptr %10, i64 %642
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.epil, i8 0, i64 %80, i1 false), !tbaa !13
  %indvar.next.epil = add nuw nsw i64 %indvar.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter1198
  br i1 %epil.iter.cmp.not, label %.loopexit, label %.preheader.epil, !llvm.loop !48

.loopexit:                                        ; preds = %._crit_edge763, %._crit_edge792.us, %.loopexit744, %._crit_edge857, %.loopexit.loopexit.unr-lcssa, %.preheader.epil, %.lr.ph802, %.lr.ph773, %135, %242, %350, %55, %68, %.thread
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #6
  ret i32 0
}

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

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

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

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

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

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

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #5

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #6 = { 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 = !{!17}
!17 = distinct !{!17, !18}
!18 = distinct !{!18, !"LVerDomain"}
!19 = !{!20}
!20 = distinct !{!20, !18}
!21 = distinct !{!21, !15, !22, !23}
!22 = !{!"llvm.loop.isvectorized", i32 1}
!23 = !{!"llvm.loop.unroll.runtime.disable"}
!24 = distinct !{!24, !15, !22}
!25 = distinct !{!25, !15}
!26 = distinct !{!26, !15}
!27 = distinct !{!27, !15}
!28 = distinct !{!28, !15}
!29 = distinct !{!29, !15}
!30 = distinct !{!30, !15}
!31 = distinct !{!31, !15}
!32 = distinct !{!32, !15}
!33 = distinct !{!33, !15, !22, !23}
!34 = distinct !{!34, !15, !22}
!35 = !{!36}
!36 = distinct !{!36, !37}
!37 = distinct !{!37, !"LVerDomain"}
!38 = !{!39}
!39 = distinct !{!39, !37}
!40 = distinct !{!40, !15, !22, !23}
!41 = distinct !{!41, !15, !22}
!42 = distinct !{!42, !15, !22, !23}
!43 = distinct !{!43, !15, !22}
!44 = distinct !{!44, !15}
!45 = distinct !{!45, !15, !22, !23}
!46 = distinct !{!46, !15, !22}
!47 = distinct !{!47, !15}
!48 = distinct !{!48, !49}
!49 = !{!"llvm.loop.unroll.disable"}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass