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

; 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_chemm(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 float, 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 %struct.complex, align 4
  %44 = alloca i64, align 8
  %45 = alloca i64, align 8
  %46 = alloca i64, align 8
  %47 = alloca i64, align 8
  %48 = alloca %struct.complex, align 4
  %49 = alloca %struct.complex, align 4
  %50 = alloca i64, align 8
  %51 = alloca i64, align 8
  %52 = 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 4, 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
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #4
  %53 = load ptr, ptr %20, align 8, !tbaa !5
  %54 = load i64, ptr %53, align 8, !tbaa !9
  store i64 %54, ptr %26, align 8, !tbaa !9
  %55 = load i64, ptr %26, align 8, !tbaa !9
  %56 = add nsw i64 1, %55
  store i64 %56, ptr %27, align 8, !tbaa !9
  %57 = load i64, ptr %27, align 8, !tbaa !9
  %58 = load ptr, ptr %19, align 8, !tbaa !5
  %59 = sub i64 0, %57
  %60 = getelementptr inbounds %struct.complex, ptr %58, i64 %59
  store ptr %60, ptr %19, align 8, !tbaa !5
  %61 = load ptr, ptr %22, align 8, !tbaa !5
  %62 = load i64, ptr %61, align 8, !tbaa !9
  store i64 %62, ptr %28, align 8, !tbaa !9
  %63 = load i64, ptr %28, align 8, !tbaa !9
  %64 = add nsw i64 1, %63
  store i64 %64, ptr %29, align 8, !tbaa !9
  %65 = load i64, ptr %29, align 8, !tbaa !9
  %66 = load ptr, ptr %21, align 8, !tbaa !5
  %67 = sub i64 0, %65
  %68 = getelementptr inbounds %struct.complex, ptr %66, i64 %67
  store ptr %68, ptr %21, align 8, !tbaa !5
  %69 = load ptr, ptr %25, align 8, !tbaa !5
  %70 = load i64, ptr %69, align 8, !tbaa !9
  store i64 %70, ptr %30, align 8, !tbaa !9
  %71 = load i64, ptr %30, align 8, !tbaa !9
  %72 = add nsw i64 1, %71
  store i64 %72, ptr %31, align 8, !tbaa !9
  %73 = load i64, ptr %31, align 8, !tbaa !9
  %74 = load ptr, ptr %24, align 8, !tbaa !5
  %75 = sub i64 0, %73
  %76 = getelementptr inbounds %struct.complex, ptr %74, i64 %75
  store ptr %76, ptr %24, align 8, !tbaa !5
  %77 = load ptr, ptr %14, align 8, !tbaa !5
  %78 = call i64 @lsame_(ptr noundef %77, ptr noundef @.str)
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %80, label %83

80:                                               ; preds = %12
  %81 = load ptr, ptr %16, align 8, !tbaa !5
  %82 = load i64, ptr %81, align 8, !tbaa !9
  store i64 %82, ptr %50, align 8, !tbaa !9
  br label %86

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

86:                                               ; preds = %83, %80
  %87 = load ptr, ptr %15, align 8, !tbaa !5
  %88 = call i64 @lsame_(ptr noundef %87, ptr noundef @.str.1)
  store i64 %88, ptr %51, align 8, !tbaa !9
  store i64 0, ptr %47, align 8, !tbaa !9
  %89 = load ptr, ptr %14, align 8, !tbaa !5
  %90 = call i64 @lsame_(ptr noundef %89, ptr noundef @.str)
  %91 = icmp ne i64 %90, 0
  br i1 %91, label %97, label %92

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

96:                                               ; preds = %92
  store i64 1, ptr %47, align 8, !tbaa !9
  br label %161

97:                                               ; preds = %92, %86
  %98 = load i64, ptr %51, align 8, !tbaa !9
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %105, label %100

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

104:                                              ; preds = %100
  store i64 2, ptr %47, align 8, !tbaa !9
  br label %160

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

109:                                              ; preds = %105
  store i64 3, ptr %47, align 8, !tbaa !9
  br label %159

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

114:                                              ; preds = %110
  store i64 4, ptr %47, align 8, !tbaa !9
  br label %158

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

120:                                              ; preds = %115
  br label %123

121:                                              ; preds = %115
  %122 = load i64, ptr %50, align 8, !tbaa !9
  br label %123

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

126:                                              ; preds = %123
  store i64 7, ptr %47, align 8, !tbaa !9
  br label %157

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

133:                                              ; preds = %127
  br label %137

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

137:                                              ; preds = %134, %133
  %138 = phi i64 [ 1, %133 ], [ %136, %134 ]
  %139 = icmp slt i64 %129, %138
  br i1 %139, label %140, label %141

140:                                              ; preds = %137
  store i64 9, ptr %47, align 8, !tbaa !9
  br label %156

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

147:                                              ; preds = %141
  br label %151

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

151:                                              ; preds = %148, %147
  %152 = phi i64 [ 1, %147 ], [ %150, %148 ]
  %153 = icmp slt i64 %143, %152
  br i1 %153, label %154, label %155

154:                                              ; preds = %151
  store i64 12, ptr %47, align 8, !tbaa !9
  br label %155

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

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

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

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

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

160:                                              ; preds = %159, %104
  br label %161

161:                                              ; preds = %160, %96
  %162 = load i64, ptr %47, align 8, !tbaa !9
  %163 = icmp ne i64 %162, 0
  br i1 %163, label %164, label %166

164:                                              ; preds = %161
  %165 = call i32 @xerbla_(ptr noundef @.str.3, ptr noundef %47)
  store i32 0, ptr %13, align 4
  store i32 1, ptr %52, align 4
  br label %1888

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

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

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

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

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

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

194:                                              ; preds = %189, %170, %166
  store i32 0, ptr %13, align 4
  store i32 1, ptr %52, align 4
  br label %1888

195:                                              ; preds = %189, %184, %179, %174
  %196 = load ptr, ptr %18, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.complex, ptr %196, i32 0, i32 0
  %198 = load float, ptr %197, align 4, !tbaa !11
  %199 = fcmp oeq float %198, 0.000000e+00
  br i1 %199, label %200, label %336

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

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

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

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

218:                                              ; preds = %247, %215
  %219 = load i64, ptr %45, align 8, !tbaa !9
  %220 = load i64, ptr %32, align 8, !tbaa !9
  %221 = icmp sle i64 %219, %220
  br i1 %221, label %222, label %250

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

225:                                              ; preds = %243, %222
  %226 = load i64, ptr %44, align 8, !tbaa !9
  %227 = load i64, ptr %33, align 8, !tbaa !9
  %228 = icmp sle i64 %226, %227
  br i1 %228, label %229, label %246

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

243:                                              ; preds = %229
  %244 = load i64, ptr %44, align 8, !tbaa !9
  %245 = add nsw i64 %244, 1
  store i64 %245, ptr %44, align 8, !tbaa !9
  br label %225, !llvm.loop !15

246:                                              ; preds = %225
  br label %247

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

250:                                              ; preds = %218
  br label %335

251:                                              ; preds = %210, %205
  %252 = load ptr, ptr %17, align 8, !tbaa !5
  %253 = load i64, ptr %252, align 8, !tbaa !9
  store i64 %253, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %254

254:                                              ; preds = %331, %251
  %255 = load i64, ptr %45, align 8, !tbaa !9
  %256 = load i64, ptr %32, align 8, !tbaa !9
  %257 = icmp sle i64 %255, %256
  br i1 %257, label %258, label %334

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

261:                                              ; preds = %327, %258
  %262 = load i64, ptr %44, align 8, !tbaa !9
  %263 = load i64, ptr %33, align 8, !tbaa !9
  %264 = icmp sle i64 %262, %263
  br i1 %264, label %265, label %330

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

327:                                              ; preds = %265
  %328 = load i64, ptr %44, align 8, !tbaa !9
  %329 = add nsw i64 %328, 1
  store i64 %329, ptr %44, align 8, !tbaa !9
  br label %261, !llvm.loop !18

330:                                              ; preds = %261
  br label %331

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

334:                                              ; preds = %254
  br label %335

335:                                              ; preds = %334, %250
  store i32 0, ptr %13, align 4
  store i32 1, ptr %52, align 4
  br label %1888

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

340:                                              ; preds = %336
  %341 = load i64, ptr %51, align 8, !tbaa !9
  %342 = icmp ne i64 %341, 0
  br i1 %342, label %343, label %794

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

346:                                              ; preds = %790, %343
  %347 = load i64, ptr %45, align 8, !tbaa !9
  %348 = load i64, ptr %32, align 8, !tbaa !9
  %349 = icmp sle i64 %347, %348
  br i1 %349, label %350, label %793

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

353:                                              ; preds = %786, %350
  %354 = load i64, ptr %44, align 8, !tbaa !9
  %355 = load i64, ptr %33, align 8, !tbaa !9
  %356 = icmp sle i64 %354, %355
  br i1 %356, label %357, label %789

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

412:                                              ; preds = %562, %357
  %413 = load i64, ptr %46, align 8, !tbaa !9
  %414 = load i64, ptr %34, align 8, !tbaa !9
  %415 = icmp sle i64 %413, %414
  br i1 %415, label %416, label %565

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

562:                                              ; preds = %416
  %563 = load i64, ptr %46, align 8, !tbaa !9
  %564 = add nsw i64 %563, 1
  store i64 %564, ptr %46, align 8, !tbaa !9
  br label %412, !llvm.loop !20

565:                                              ; preds = %412
  %566 = load ptr, ptr %23, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.complex, ptr %566, i32 0, i32 0
  %568 = load float, ptr %567, align 4, !tbaa !11
  %569 = fcmp oeq float %568, 0.000000e+00
  br i1 %569, label %570, label %652

570:                                              ; preds = %565
  %571 = load ptr, ptr %23, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.complex, ptr %571, i32 0, i32 1
  %573 = load float, ptr %572, align 4, !tbaa !14
  %574 = fcmp oeq float %573, 0.000000e+00
  br i1 %574, label %575, label %652

575:                                              ; preds = %570
  %576 = load i64, ptr %44, align 8, !tbaa !9
  %577 = load i64, ptr %45, align 8, !tbaa !9
  %578 = load i64, ptr %30, align 8, !tbaa !9
  %579 = mul nsw i64 %577, %578
  %580 = add nsw i64 %576, %579
  store i64 %580, ptr %34, align 8, !tbaa !9
  %581 = load i64, ptr %44, align 8, !tbaa !9
  %582 = load i64, ptr %44, align 8, !tbaa !9
  %583 = load i64, ptr %26, align 8, !tbaa !9
  %584 = mul nsw i64 %582, %583
  %585 = add nsw i64 %581, %584
  store i64 %585, ptr %35, align 8, !tbaa !9
  %586 = load ptr, ptr %19, align 8, !tbaa !5
  %587 = load i64, ptr %35, align 8, !tbaa !9
  %588 = getelementptr inbounds %struct.complex, ptr %586, i64 %587
  %589 = getelementptr inbounds %struct.complex, ptr %588, i32 0, i32 0
  %590 = load float, ptr %589, align 4, !tbaa !11
  store float %590, ptr %38, align 4, !tbaa !21
  %591 = load float, ptr %38, align 4, !tbaa !21
  %592 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %593 = load float, ptr %592, align 4, !tbaa !11
  %594 = fmul float %591, %593
  %595 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %594, ptr %595, align 4, !tbaa !11
  %596 = load float, ptr %38, align 4, !tbaa !21
  %597 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %598 = load float, ptr %597, align 4, !tbaa !14
  %599 = fmul float %596, %598
  %600 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %599, ptr %600, align 4, !tbaa !14
  %601 = load ptr, ptr %18, align 8, !tbaa !5
  %602 = getelementptr inbounds %struct.complex, ptr %601, i32 0, i32 0
  %603 = load float, ptr %602, align 4, !tbaa !11
  %604 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %605 = load float, ptr %604, align 4, !tbaa !11
  %606 = load ptr, ptr %18, align 8, !tbaa !5
  %607 = getelementptr inbounds %struct.complex, ptr %606, i32 0, i32 1
  %608 = load float, ptr %607, align 4, !tbaa !14
  %609 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %610 = load float, ptr %609, align 4, !tbaa !14
  %611 = fmul float %608, %610
  %612 = fneg float %611
  %613 = call float @llvm.fmuladd.f32(float %603, float %605, float %612)
  %614 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %613, ptr %614, align 4, !tbaa !11
  %615 = load ptr, ptr %18, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.complex, ptr %615, i32 0, i32 0
  %617 = load float, ptr %616, align 4, !tbaa !11
  %618 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %619 = load float, ptr %618, align 4, !tbaa !14
  %620 = load ptr, ptr %18, align 8, !tbaa !5
  %621 = getelementptr inbounds %struct.complex, ptr %620, i32 0, i32 1
  %622 = load float, ptr %621, align 4, !tbaa !14
  %623 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %624 = load float, ptr %623, align 4, !tbaa !11
  %625 = fmul float %622, %624
  %626 = call float @llvm.fmuladd.f32(float %617, float %619, float %625)
  %627 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %626, ptr %627, align 4, !tbaa !14
  %628 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %629 = load float, ptr %628, align 4, !tbaa !11
  %630 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %631 = load float, ptr %630, align 4, !tbaa !11
  %632 = fadd float %629, %631
  %633 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %632, ptr %633, align 4, !tbaa !11
  %634 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %635 = load float, ptr %634, align 4, !tbaa !14
  %636 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %637 = load float, ptr %636, align 4, !tbaa !14
  %638 = fadd float %635, %637
  %639 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %638, ptr %639, align 4, !tbaa !14
  %640 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %641 = load float, ptr %640, align 4, !tbaa !11
  %642 = load ptr, ptr %24, align 8, !tbaa !5
  %643 = load i64, ptr %34, align 8, !tbaa !9
  %644 = getelementptr inbounds %struct.complex, ptr %642, i64 %643
  %645 = getelementptr inbounds %struct.complex, ptr %644, i32 0, i32 0
  store float %641, ptr %645, align 4, !tbaa !11
  %646 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %647 = load float, ptr %646, align 4, !tbaa !14
  %648 = load ptr, ptr %24, align 8, !tbaa !5
  %649 = load i64, ptr %34, align 8, !tbaa !9
  %650 = getelementptr inbounds %struct.complex, ptr %648, i64 %649
  %651 = getelementptr inbounds %struct.complex, ptr %650, i32 0, i32 1
  store float %647, ptr %651, align 4, !tbaa !14
  br label %785

652:                                              ; preds = %570, %565
  %653 = load i64, ptr %44, align 8, !tbaa !9
  %654 = load i64, ptr %45, align 8, !tbaa !9
  %655 = load i64, ptr %30, align 8, !tbaa !9
  %656 = mul nsw i64 %654, %655
  %657 = add nsw i64 %653, %656
  store i64 %657, ptr %34, align 8, !tbaa !9
  %658 = load i64, ptr %44, align 8, !tbaa !9
  %659 = load i64, ptr %45, align 8, !tbaa !9
  %660 = load i64, ptr %30, align 8, !tbaa !9
  %661 = mul nsw i64 %659, %660
  %662 = add nsw i64 %658, %661
  store i64 %662, ptr %35, align 8, !tbaa !9
  %663 = load ptr, ptr %23, align 8, !tbaa !5
  %664 = getelementptr inbounds %struct.complex, ptr %663, i32 0, i32 0
  %665 = load float, ptr %664, align 4, !tbaa !11
  %666 = load ptr, ptr %24, align 8, !tbaa !5
  %667 = load i64, ptr %35, align 8, !tbaa !9
  %668 = getelementptr inbounds %struct.complex, ptr %666, i64 %667
  %669 = getelementptr inbounds %struct.complex, ptr %668, i32 0, i32 0
  %670 = load float, ptr %669, align 4, !tbaa !11
  %671 = load ptr, ptr %23, align 8, !tbaa !5
  %672 = getelementptr inbounds %struct.complex, ptr %671, i32 0, i32 1
  %673 = load float, ptr %672, align 4, !tbaa !14
  %674 = load ptr, ptr %24, align 8, !tbaa !5
  %675 = load i64, ptr %35, align 8, !tbaa !9
  %676 = getelementptr inbounds %struct.complex, ptr %674, i64 %675
  %677 = getelementptr inbounds %struct.complex, ptr %676, i32 0, i32 1
  %678 = load float, ptr %677, align 4, !tbaa !14
  %679 = fmul float %673, %678
  %680 = fneg float %679
  %681 = call float @llvm.fmuladd.f32(float %665, float %670, float %680)
  %682 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %681, ptr %682, align 4, !tbaa !11
  %683 = load ptr, ptr %23, align 8, !tbaa !5
  %684 = getelementptr inbounds %struct.complex, ptr %683, i32 0, i32 0
  %685 = load float, ptr %684, align 4, !tbaa !11
  %686 = load ptr, ptr %24, align 8, !tbaa !5
  %687 = load i64, ptr %35, align 8, !tbaa !9
  %688 = getelementptr inbounds %struct.complex, ptr %686, i64 %687
  %689 = getelementptr inbounds %struct.complex, ptr %688, i32 0, i32 1
  %690 = load float, ptr %689, align 4, !tbaa !14
  %691 = load ptr, ptr %23, align 8, !tbaa !5
  %692 = getelementptr inbounds %struct.complex, ptr %691, i32 0, i32 1
  %693 = load float, ptr %692, align 4, !tbaa !14
  %694 = load ptr, ptr %24, align 8, !tbaa !5
  %695 = load i64, ptr %35, align 8, !tbaa !9
  %696 = getelementptr inbounds %struct.complex, ptr %694, i64 %695
  %697 = getelementptr inbounds %struct.complex, ptr %696, i32 0, i32 0
  %698 = load float, ptr %697, align 4, !tbaa !11
  %699 = fmul float %693, %698
  %700 = call float @llvm.fmuladd.f32(float %685, float %690, float %699)
  %701 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %700, ptr %701, align 4, !tbaa !14
  %702 = load i64, ptr %44, align 8, !tbaa !9
  %703 = load i64, ptr %44, align 8, !tbaa !9
  %704 = load i64, ptr %26, align 8, !tbaa !9
  %705 = mul nsw i64 %703, %704
  %706 = add nsw i64 %702, %705
  store i64 %706, ptr %36, align 8, !tbaa !9
  %707 = load ptr, ptr %19, align 8, !tbaa !5
  %708 = load i64, ptr %36, align 8, !tbaa !9
  %709 = getelementptr inbounds %struct.complex, ptr %707, i64 %708
  %710 = getelementptr inbounds %struct.complex, ptr %709, i32 0, i32 0
  %711 = load float, ptr %710, align 4, !tbaa !11
  store float %711, ptr %38, align 4, !tbaa !21
  %712 = load float, ptr %38, align 4, !tbaa !21
  %713 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %714 = load float, ptr %713, align 4, !tbaa !11
  %715 = fmul float %712, %714
  %716 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %715, ptr %716, align 4, !tbaa !11
  %717 = load float, ptr %38, align 4, !tbaa !21
  %718 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %719 = load float, ptr %718, align 4, !tbaa !14
  %720 = fmul float %717, %719
  %721 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %720, ptr %721, align 4, !tbaa !14
  %722 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %723 = load float, ptr %722, align 4, !tbaa !11
  %724 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %725 = load float, ptr %724, align 4, !tbaa !11
  %726 = fadd float %723, %725
  %727 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %726, ptr %727, align 4, !tbaa !11
  %728 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %729 = load float, ptr %728, align 4, !tbaa !14
  %730 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %731 = load float, ptr %730, align 4, !tbaa !14
  %732 = fadd float %729, %731
  %733 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %732, ptr %733, align 4, !tbaa !14
  %734 = load ptr, ptr %18, align 8, !tbaa !5
  %735 = getelementptr inbounds %struct.complex, ptr %734, i32 0, i32 0
  %736 = load float, ptr %735, align 4, !tbaa !11
  %737 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %738 = load float, ptr %737, align 4, !tbaa !11
  %739 = load ptr, ptr %18, align 8, !tbaa !5
  %740 = getelementptr inbounds %struct.complex, ptr %739, i32 0, i32 1
  %741 = load float, ptr %740, align 4, !tbaa !14
  %742 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %743 = load float, ptr %742, align 4, !tbaa !14
  %744 = fmul float %741, %743
  %745 = fneg float %744
  %746 = call float @llvm.fmuladd.f32(float %736, float %738, float %745)
  %747 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 0
  store float %746, ptr %747, align 4, !tbaa !11
  %748 = load ptr, ptr %18, align 8, !tbaa !5
  %749 = getelementptr inbounds %struct.complex, ptr %748, i32 0, i32 0
  %750 = load float, ptr %749, align 4, !tbaa !11
  %751 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %752 = load float, ptr %751, align 4, !tbaa !14
  %753 = load ptr, ptr %18, align 8, !tbaa !5
  %754 = getelementptr inbounds %struct.complex, ptr %753, i32 0, i32 1
  %755 = load float, ptr %754, align 4, !tbaa !14
  %756 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %757 = load float, ptr %756, align 4, !tbaa !11
  %758 = fmul float %755, %757
  %759 = call float @llvm.fmuladd.f32(float %750, float %752, float %758)
  %760 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 1
  store float %759, ptr %760, align 4, !tbaa !14
  %761 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %762 = load float, ptr %761, align 4, !tbaa !11
  %763 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 0
  %764 = load float, ptr %763, align 4, !tbaa !11
  %765 = fadd float %762, %764
  %766 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %765, ptr %766, align 4, !tbaa !11
  %767 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %768 = load float, ptr %767, align 4, !tbaa !14
  %769 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 1
  %770 = load float, ptr %769, align 4, !tbaa !14
  %771 = fadd float %768, %770
  %772 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %771, ptr %772, align 4, !tbaa !14
  %773 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %774 = load float, ptr %773, align 4, !tbaa !11
  %775 = load ptr, ptr %24, align 8, !tbaa !5
  %776 = load i64, ptr %34, align 8, !tbaa !9
  %777 = getelementptr inbounds %struct.complex, ptr %775, i64 %776
  %778 = getelementptr inbounds %struct.complex, ptr %777, i32 0, i32 0
  store float %774, ptr %778, align 4, !tbaa !11
  %779 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %780 = load float, ptr %779, align 4, !tbaa !14
  %781 = load ptr, ptr %24, align 8, !tbaa !5
  %782 = load i64, ptr %34, align 8, !tbaa !9
  %783 = getelementptr inbounds %struct.complex, ptr %781, i64 %782
  %784 = getelementptr inbounds %struct.complex, ptr %783, i32 0, i32 1
  store float %780, ptr %784, align 4, !tbaa !14
  br label %785

785:                                              ; preds = %652, %575
  br label %786

786:                                              ; preds = %785
  %787 = load i64, ptr %44, align 8, !tbaa !9
  %788 = add nsw i64 %787, 1
  store i64 %788, ptr %44, align 8, !tbaa !9
  br label %353, !llvm.loop !22

789:                                              ; preds = %353
  br label %790

790:                                              ; preds = %789
  %791 = load i64, ptr %45, align 8, !tbaa !9
  %792 = add nsw i64 %791, 1
  store i64 %792, ptr %45, align 8, !tbaa !9
  br label %346, !llvm.loop !23

793:                                              ; preds = %346
  br label %1246

794:                                              ; preds = %340
  %795 = load ptr, ptr %17, align 8, !tbaa !5
  %796 = load i64, ptr %795, align 8, !tbaa !9
  store i64 %796, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %797

797:                                              ; preds = %1242, %794
  %798 = load i64, ptr %45, align 8, !tbaa !9
  %799 = load i64, ptr %32, align 8, !tbaa !9
  %800 = icmp sle i64 %798, %799
  br i1 %800, label %801, label %1245

801:                                              ; preds = %797
  %802 = load ptr, ptr %16, align 8, !tbaa !5
  %803 = load i64, ptr %802, align 8, !tbaa !9
  store i64 %803, ptr %44, align 8, !tbaa !9
  br label %804

804:                                              ; preds = %1238, %801
  %805 = load i64, ptr %44, align 8, !tbaa !9
  %806 = icmp sge i64 %805, 1
  br i1 %806, label %807, label %1241

807:                                              ; preds = %804
  %808 = load i64, ptr %44, align 8, !tbaa !9
  %809 = load i64, ptr %45, align 8, !tbaa !9
  %810 = load i64, ptr %28, align 8, !tbaa !9
  %811 = mul nsw i64 %809, %810
  %812 = add nsw i64 %808, %811
  store i64 %812, ptr %33, align 8, !tbaa !9
  %813 = load ptr, ptr %18, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.complex, ptr %813, i32 0, i32 0
  %815 = load float, ptr %814, align 4, !tbaa !11
  %816 = load ptr, ptr %21, align 8, !tbaa !5
  %817 = load i64, ptr %33, align 8, !tbaa !9
  %818 = getelementptr inbounds %struct.complex, ptr %816, i64 %817
  %819 = getelementptr inbounds %struct.complex, ptr %818, i32 0, i32 0
  %820 = load float, ptr %819, align 4, !tbaa !11
  %821 = load ptr, ptr %18, align 8, !tbaa !5
  %822 = getelementptr inbounds %struct.complex, ptr %821, i32 0, i32 1
  %823 = load float, ptr %822, align 4, !tbaa !14
  %824 = load ptr, ptr %21, align 8, !tbaa !5
  %825 = load i64, ptr %33, align 8, !tbaa !9
  %826 = getelementptr inbounds %struct.complex, ptr %824, i64 %825
  %827 = getelementptr inbounds %struct.complex, ptr %826, i32 0, i32 1
  %828 = load float, ptr %827, align 4, !tbaa !14
  %829 = fmul float %823, %828
  %830 = fneg float %829
  %831 = call float @llvm.fmuladd.f32(float %815, float %820, float %830)
  %832 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %831, ptr %832, align 4, !tbaa !11
  %833 = load ptr, ptr %18, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct.complex, ptr %833, i32 0, i32 0
  %835 = load float, ptr %834, align 4, !tbaa !11
  %836 = load ptr, ptr %21, align 8, !tbaa !5
  %837 = load i64, ptr %33, align 8, !tbaa !9
  %838 = getelementptr inbounds %struct.complex, ptr %836, i64 %837
  %839 = getelementptr inbounds %struct.complex, ptr %838, i32 0, i32 1
  %840 = load float, ptr %839, align 4, !tbaa !14
  %841 = load ptr, ptr %18, align 8, !tbaa !5
  %842 = getelementptr inbounds %struct.complex, ptr %841, i32 0, i32 1
  %843 = load float, ptr %842, align 4, !tbaa !14
  %844 = load ptr, ptr %21, align 8, !tbaa !5
  %845 = load i64, ptr %33, align 8, !tbaa !9
  %846 = getelementptr inbounds %struct.complex, ptr %844, i64 %845
  %847 = getelementptr inbounds %struct.complex, ptr %846, i32 0, i32 0
  %848 = load float, ptr %847, align 4, !tbaa !11
  %849 = fmul float %843, %848
  %850 = call float @llvm.fmuladd.f32(float %835, float %840, float %849)
  %851 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %850, ptr %851, align 4, !tbaa !14
  %852 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %853 = load float, ptr %852, align 4, !tbaa !11
  %854 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %853, ptr %854, align 4, !tbaa !11
  %855 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %856 = load float, ptr %855, align 4, !tbaa !14
  %857 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %856, ptr %857, align 4, !tbaa !14
  %858 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  store float 0.000000e+00, ptr %858, align 4, !tbaa !11
  %859 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  store float 0.000000e+00, ptr %859, align 4, !tbaa !14
  %860 = load ptr, ptr %16, align 8, !tbaa !5
  %861 = load i64, ptr %860, align 8, !tbaa !9
  store i64 %861, ptr %33, align 8, !tbaa !9
  %862 = load i64, ptr %44, align 8, !tbaa !9
  %863 = add nsw i64 %862, 1
  store i64 %863, ptr %46, align 8, !tbaa !9
  br label %864

864:                                              ; preds = %1014, %807
  %865 = load i64, ptr %46, align 8, !tbaa !9
  %866 = load i64, ptr %33, align 8, !tbaa !9
  %867 = icmp sle i64 %865, %866
  br i1 %867, label %868, label %1017

868:                                              ; preds = %864
  %869 = load i64, ptr %46, align 8, !tbaa !9
  %870 = load i64, ptr %45, align 8, !tbaa !9
  %871 = load i64, ptr %30, align 8, !tbaa !9
  %872 = mul nsw i64 %870, %871
  %873 = add nsw i64 %869, %872
  store i64 %873, ptr %34, align 8, !tbaa !9
  %874 = load i64, ptr %46, align 8, !tbaa !9
  %875 = load i64, ptr %45, align 8, !tbaa !9
  %876 = load i64, ptr %30, align 8, !tbaa !9
  %877 = mul nsw i64 %875, %876
  %878 = add nsw i64 %874, %877
  store i64 %878, ptr %35, align 8, !tbaa !9
  %879 = load i64, ptr %46, align 8, !tbaa !9
  %880 = load i64, ptr %44, align 8, !tbaa !9
  %881 = load i64, ptr %26, align 8, !tbaa !9
  %882 = mul nsw i64 %880, %881
  %883 = add nsw i64 %879, %882
  store i64 %883, ptr %36, align 8, !tbaa !9
  %884 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %885 = load float, ptr %884, align 4, !tbaa !11
  %886 = load ptr, ptr %19, align 8, !tbaa !5
  %887 = load i64, ptr %36, align 8, !tbaa !9
  %888 = getelementptr inbounds %struct.complex, ptr %886, i64 %887
  %889 = getelementptr inbounds %struct.complex, ptr %888, i32 0, i32 0
  %890 = load float, ptr %889, align 4, !tbaa !11
  %891 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %892 = load float, ptr %891, align 4, !tbaa !14
  %893 = load ptr, ptr %19, align 8, !tbaa !5
  %894 = load i64, ptr %36, align 8, !tbaa !9
  %895 = getelementptr inbounds %struct.complex, ptr %893, i64 %894
  %896 = getelementptr inbounds %struct.complex, ptr %895, i32 0, i32 1
  %897 = load float, ptr %896, align 4, !tbaa !14
  %898 = fmul float %892, %897
  %899 = fneg float %898
  %900 = call float @llvm.fmuladd.f32(float %885, float %890, float %899)
  %901 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %900, ptr %901, align 4, !tbaa !11
  %902 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %903 = load float, ptr %902, align 4, !tbaa !11
  %904 = load ptr, ptr %19, align 8, !tbaa !5
  %905 = load i64, ptr %36, align 8, !tbaa !9
  %906 = getelementptr inbounds %struct.complex, ptr %904, i64 %905
  %907 = getelementptr inbounds %struct.complex, ptr %906, i32 0, i32 1
  %908 = load float, ptr %907, align 4, !tbaa !14
  %909 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %910 = load float, ptr %909, align 4, !tbaa !14
  %911 = load ptr, ptr %19, align 8, !tbaa !5
  %912 = load i64, ptr %36, align 8, !tbaa !9
  %913 = getelementptr inbounds %struct.complex, ptr %911, i64 %912
  %914 = getelementptr inbounds %struct.complex, ptr %913, i32 0, i32 0
  %915 = load float, ptr %914, align 4, !tbaa !11
  %916 = fmul float %910, %915
  %917 = call float @llvm.fmuladd.f32(float %903, float %908, float %916)
  %918 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %917, ptr %918, align 4, !tbaa !14
  %919 = load ptr, ptr %24, align 8, !tbaa !5
  %920 = load i64, ptr %35, align 8, !tbaa !9
  %921 = getelementptr inbounds %struct.complex, ptr %919, i64 %920
  %922 = getelementptr inbounds %struct.complex, ptr %921, i32 0, i32 0
  %923 = load float, ptr %922, align 4, !tbaa !11
  %924 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %925 = load float, ptr %924, align 4, !tbaa !11
  %926 = fadd float %923, %925
  %927 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %926, ptr %927, align 4, !tbaa !11
  %928 = load ptr, ptr %24, align 8, !tbaa !5
  %929 = load i64, ptr %35, align 8, !tbaa !9
  %930 = getelementptr inbounds %struct.complex, ptr %928, i64 %929
  %931 = getelementptr inbounds %struct.complex, ptr %930, i32 0, i32 1
  %932 = load float, ptr %931, align 4, !tbaa !14
  %933 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %934 = load float, ptr %933, align 4, !tbaa !14
  %935 = fadd float %932, %934
  %936 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %935, ptr %936, align 4, !tbaa !14
  %937 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %938 = load float, ptr %937, align 4, !tbaa !11
  %939 = load ptr, ptr %24, align 8, !tbaa !5
  %940 = load i64, ptr %34, align 8, !tbaa !9
  %941 = getelementptr inbounds %struct.complex, ptr %939, i64 %940
  %942 = getelementptr inbounds %struct.complex, ptr %941, i32 0, i32 0
  store float %938, ptr %942, align 4, !tbaa !11
  %943 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %944 = load float, ptr %943, align 4, !tbaa !14
  %945 = load ptr, ptr %24, align 8, !tbaa !5
  %946 = load i64, ptr %34, align 8, !tbaa !9
  %947 = getelementptr inbounds %struct.complex, ptr %945, i64 %946
  %948 = getelementptr inbounds %struct.complex, ptr %947, i32 0, i32 1
  store float %944, ptr %948, align 4, !tbaa !14
  %949 = load i64, ptr %46, align 8, !tbaa !9
  %950 = load i64, ptr %45, align 8, !tbaa !9
  %951 = load i64, ptr %28, align 8, !tbaa !9
  %952 = mul nsw i64 %950, %951
  %953 = add nsw i64 %949, %952
  store i64 %953, ptr %34, align 8, !tbaa !9
  %954 = load ptr, ptr %19, align 8, !tbaa !5
  %955 = load i64, ptr %46, align 8, !tbaa !9
  %956 = load i64, ptr %44, align 8, !tbaa !9
  %957 = load i64, ptr %26, align 8, !tbaa !9
  %958 = mul nsw i64 %956, %957
  %959 = add nsw i64 %955, %958
  %960 = getelementptr inbounds %struct.complex, ptr %954, i64 %959
  call void @r_cnjg(ptr noundef %41, ptr noundef %960)
  %961 = load ptr, ptr %21, align 8, !tbaa !5
  %962 = load i64, ptr %34, align 8, !tbaa !9
  %963 = getelementptr inbounds %struct.complex, ptr %961, i64 %962
  %964 = getelementptr inbounds %struct.complex, ptr %963, i32 0, i32 0
  %965 = load float, ptr %964, align 4, !tbaa !11
  %966 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %967 = load float, ptr %966, align 4, !tbaa !11
  %968 = load ptr, ptr %21, align 8, !tbaa !5
  %969 = load i64, ptr %34, align 8, !tbaa !9
  %970 = getelementptr inbounds %struct.complex, ptr %968, i64 %969
  %971 = getelementptr inbounds %struct.complex, ptr %970, i32 0, i32 1
  %972 = load float, ptr %971, align 4, !tbaa !14
  %973 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %974 = load float, ptr %973, align 4, !tbaa !14
  %975 = fmul float %972, %974
  %976 = fneg float %975
  %977 = call float @llvm.fmuladd.f32(float %965, float %967, float %976)
  %978 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %977, ptr %978, align 4, !tbaa !11
  %979 = load ptr, ptr %21, align 8, !tbaa !5
  %980 = load i64, ptr %34, align 8, !tbaa !9
  %981 = getelementptr inbounds %struct.complex, ptr %979, i64 %980
  %982 = getelementptr inbounds %struct.complex, ptr %981, i32 0, i32 0
  %983 = load float, ptr %982, align 4, !tbaa !11
  %984 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %985 = load float, ptr %984, align 4, !tbaa !14
  %986 = load ptr, ptr %21, align 8, !tbaa !5
  %987 = load i64, ptr %34, align 8, !tbaa !9
  %988 = getelementptr inbounds %struct.complex, ptr %986, i64 %987
  %989 = getelementptr inbounds %struct.complex, ptr %988, i32 0, i32 1
  %990 = load float, ptr %989, align 4, !tbaa !14
  %991 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %992 = load float, ptr %991, align 4, !tbaa !11
  %993 = fmul float %990, %992
  %994 = call float @llvm.fmuladd.f32(float %983, float %985, float %993)
  %995 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %994, ptr %995, align 4, !tbaa !14
  %996 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %997 = load float, ptr %996, align 4, !tbaa !11
  %998 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %999 = load float, ptr %998, align 4, !tbaa !11
  %1000 = fadd float %997, %999
  %1001 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1000, ptr %1001, align 4, !tbaa !11
  %1002 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %1003 = load float, ptr %1002, align 4, !tbaa !14
  %1004 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1005 = load float, ptr %1004, align 4, !tbaa !14
  %1006 = fadd float %1003, %1005
  %1007 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1006, ptr %1007, align 4, !tbaa !14
  %1008 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1009 = load float, ptr %1008, align 4, !tbaa !11
  %1010 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  store float %1009, ptr %1010, align 4, !tbaa !11
  %1011 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1012 = load float, ptr %1011, align 4, !tbaa !14
  %1013 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  store float %1012, ptr %1013, align 4, !tbaa !14
  br label %1014

1014:                                             ; preds = %868
  %1015 = load i64, ptr %46, align 8, !tbaa !9
  %1016 = add nsw i64 %1015, 1
  store i64 %1016, ptr %46, align 8, !tbaa !9
  br label %864, !llvm.loop !24

1017:                                             ; preds = %864
  %1018 = load ptr, ptr %23, align 8, !tbaa !5
  %1019 = getelementptr inbounds %struct.complex, ptr %1018, i32 0, i32 0
  %1020 = load float, ptr %1019, align 4, !tbaa !11
  %1021 = fcmp oeq float %1020, 0.000000e+00
  br i1 %1021, label %1022, label %1104

1022:                                             ; preds = %1017
  %1023 = load ptr, ptr %23, align 8, !tbaa !5
  %1024 = getelementptr inbounds %struct.complex, ptr %1023, i32 0, i32 1
  %1025 = load float, ptr %1024, align 4, !tbaa !14
  %1026 = fcmp oeq float %1025, 0.000000e+00
  br i1 %1026, label %1027, label %1104

1027:                                             ; preds = %1022
  %1028 = load i64, ptr %44, align 8, !tbaa !9
  %1029 = load i64, ptr %45, align 8, !tbaa !9
  %1030 = load i64, ptr %30, align 8, !tbaa !9
  %1031 = mul nsw i64 %1029, %1030
  %1032 = add nsw i64 %1028, %1031
  store i64 %1032, ptr %33, align 8, !tbaa !9
  %1033 = load i64, ptr %44, align 8, !tbaa !9
  %1034 = load i64, ptr %44, align 8, !tbaa !9
  %1035 = load i64, ptr %26, align 8, !tbaa !9
  %1036 = mul nsw i64 %1034, %1035
  %1037 = add nsw i64 %1033, %1036
  store i64 %1037, ptr %34, align 8, !tbaa !9
  %1038 = load ptr, ptr %19, align 8, !tbaa !5
  %1039 = load i64, ptr %34, align 8, !tbaa !9
  %1040 = getelementptr inbounds %struct.complex, ptr %1038, i64 %1039
  %1041 = getelementptr inbounds %struct.complex, ptr %1040, i32 0, i32 0
  %1042 = load float, ptr %1041, align 4, !tbaa !11
  store float %1042, ptr %38, align 4, !tbaa !21
  %1043 = load float, ptr %38, align 4, !tbaa !21
  %1044 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1045 = load float, ptr %1044, align 4, !tbaa !11
  %1046 = fmul float %1043, %1045
  %1047 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1046, ptr %1047, align 4, !tbaa !11
  %1048 = load float, ptr %38, align 4, !tbaa !21
  %1049 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1050 = load float, ptr %1049, align 4, !tbaa !14
  %1051 = fmul float %1048, %1050
  %1052 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1051, ptr %1052, align 4, !tbaa !14
  %1053 = load ptr, ptr %18, align 8, !tbaa !5
  %1054 = getelementptr inbounds %struct.complex, ptr %1053, i32 0, i32 0
  %1055 = load float, ptr %1054, align 4, !tbaa !11
  %1056 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %1057 = load float, ptr %1056, align 4, !tbaa !11
  %1058 = load ptr, ptr %18, align 8, !tbaa !5
  %1059 = getelementptr inbounds %struct.complex, ptr %1058, i32 0, i32 1
  %1060 = load float, ptr %1059, align 4, !tbaa !14
  %1061 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %1062 = load float, ptr %1061, align 4, !tbaa !14
  %1063 = fmul float %1060, %1062
  %1064 = fneg float %1063
  %1065 = call float @llvm.fmuladd.f32(float %1055, float %1057, float %1064)
  %1066 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %1065, ptr %1066, align 4, !tbaa !11
  %1067 = load ptr, ptr %18, align 8, !tbaa !5
  %1068 = getelementptr inbounds %struct.complex, ptr %1067, i32 0, i32 0
  %1069 = load float, ptr %1068, align 4, !tbaa !11
  %1070 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %1071 = load float, ptr %1070, align 4, !tbaa !14
  %1072 = load ptr, ptr %18, align 8, !tbaa !5
  %1073 = getelementptr inbounds %struct.complex, ptr %1072, i32 0, i32 1
  %1074 = load float, ptr %1073, align 4, !tbaa !14
  %1075 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %1076 = load float, ptr %1075, align 4, !tbaa !11
  %1077 = fmul float %1074, %1076
  %1078 = call float @llvm.fmuladd.f32(float %1069, float %1071, float %1077)
  %1079 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %1078, ptr %1079, align 4, !tbaa !14
  %1080 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1081 = load float, ptr %1080, align 4, !tbaa !11
  %1082 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %1083 = load float, ptr %1082, align 4, !tbaa !11
  %1084 = fadd float %1081, %1083
  %1085 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1084, ptr %1085, align 4, !tbaa !11
  %1086 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1087 = load float, ptr %1086, align 4, !tbaa !14
  %1088 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %1089 = load float, ptr %1088, align 4, !tbaa !14
  %1090 = fadd float %1087, %1089
  %1091 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1090, ptr %1091, align 4, !tbaa !14
  %1092 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1093 = load float, ptr %1092, align 4, !tbaa !11
  %1094 = load ptr, ptr %24, align 8, !tbaa !5
  %1095 = load i64, ptr %33, align 8, !tbaa !9
  %1096 = getelementptr inbounds %struct.complex, ptr %1094, i64 %1095
  %1097 = getelementptr inbounds %struct.complex, ptr %1096, i32 0, i32 0
  store float %1093, ptr %1097, align 4, !tbaa !11
  %1098 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1099 = load float, ptr %1098, align 4, !tbaa !14
  %1100 = load ptr, ptr %24, align 8, !tbaa !5
  %1101 = load i64, ptr %33, align 8, !tbaa !9
  %1102 = getelementptr inbounds %struct.complex, ptr %1100, i64 %1101
  %1103 = getelementptr inbounds %struct.complex, ptr %1102, i32 0, i32 1
  store float %1099, ptr %1103, align 4, !tbaa !14
  br label %1237

1104:                                             ; preds = %1022, %1017
  %1105 = load i64, ptr %44, align 8, !tbaa !9
  %1106 = load i64, ptr %45, align 8, !tbaa !9
  %1107 = load i64, ptr %30, align 8, !tbaa !9
  %1108 = mul nsw i64 %1106, %1107
  %1109 = add nsw i64 %1105, %1108
  store i64 %1109, ptr %33, align 8, !tbaa !9
  %1110 = load i64, ptr %44, align 8, !tbaa !9
  %1111 = load i64, ptr %45, align 8, !tbaa !9
  %1112 = load i64, ptr %30, align 8, !tbaa !9
  %1113 = mul nsw i64 %1111, %1112
  %1114 = add nsw i64 %1110, %1113
  store i64 %1114, ptr %34, align 8, !tbaa !9
  %1115 = load ptr, ptr %23, align 8, !tbaa !5
  %1116 = getelementptr inbounds %struct.complex, ptr %1115, i32 0, i32 0
  %1117 = load float, ptr %1116, align 4, !tbaa !11
  %1118 = load ptr, ptr %24, align 8, !tbaa !5
  %1119 = load i64, ptr %34, align 8, !tbaa !9
  %1120 = getelementptr inbounds %struct.complex, ptr %1118, i64 %1119
  %1121 = getelementptr inbounds %struct.complex, ptr %1120, i32 0, i32 0
  %1122 = load float, ptr %1121, align 4, !tbaa !11
  %1123 = load ptr, ptr %23, align 8, !tbaa !5
  %1124 = getelementptr inbounds %struct.complex, ptr %1123, i32 0, i32 1
  %1125 = load float, ptr %1124, align 4, !tbaa !14
  %1126 = load ptr, ptr %24, align 8, !tbaa !5
  %1127 = load i64, ptr %34, align 8, !tbaa !9
  %1128 = getelementptr inbounds %struct.complex, ptr %1126, i64 %1127
  %1129 = getelementptr inbounds %struct.complex, ptr %1128, i32 0, i32 1
  %1130 = load float, ptr %1129, align 4, !tbaa !14
  %1131 = fmul float %1125, %1130
  %1132 = fneg float %1131
  %1133 = call float @llvm.fmuladd.f32(float %1117, float %1122, float %1132)
  %1134 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %1133, ptr %1134, align 4, !tbaa !11
  %1135 = load ptr, ptr %23, align 8, !tbaa !5
  %1136 = getelementptr inbounds %struct.complex, ptr %1135, i32 0, i32 0
  %1137 = load float, ptr %1136, align 4, !tbaa !11
  %1138 = load ptr, ptr %24, align 8, !tbaa !5
  %1139 = load i64, ptr %34, align 8, !tbaa !9
  %1140 = getelementptr inbounds %struct.complex, ptr %1138, i64 %1139
  %1141 = getelementptr inbounds %struct.complex, ptr %1140, i32 0, i32 1
  %1142 = load float, ptr %1141, align 4, !tbaa !14
  %1143 = load ptr, ptr %23, align 8, !tbaa !5
  %1144 = getelementptr inbounds %struct.complex, ptr %1143, i32 0, i32 1
  %1145 = load float, ptr %1144, align 4, !tbaa !14
  %1146 = load ptr, ptr %24, align 8, !tbaa !5
  %1147 = load i64, ptr %34, align 8, !tbaa !9
  %1148 = getelementptr inbounds %struct.complex, ptr %1146, i64 %1147
  %1149 = getelementptr inbounds %struct.complex, ptr %1148, i32 0, i32 0
  %1150 = load float, ptr %1149, align 4, !tbaa !11
  %1151 = fmul float %1145, %1150
  %1152 = call float @llvm.fmuladd.f32(float %1137, float %1142, float %1151)
  %1153 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %1152, ptr %1153, align 4, !tbaa !14
  %1154 = load i64, ptr %44, align 8, !tbaa !9
  %1155 = load i64, ptr %44, align 8, !tbaa !9
  %1156 = load i64, ptr %26, align 8, !tbaa !9
  %1157 = mul nsw i64 %1155, %1156
  %1158 = add nsw i64 %1154, %1157
  store i64 %1158, ptr %35, align 8, !tbaa !9
  %1159 = load ptr, ptr %19, align 8, !tbaa !5
  %1160 = load i64, ptr %35, align 8, !tbaa !9
  %1161 = getelementptr inbounds %struct.complex, ptr %1159, i64 %1160
  %1162 = getelementptr inbounds %struct.complex, ptr %1161, i32 0, i32 0
  %1163 = load float, ptr %1162, align 4, !tbaa !11
  store float %1163, ptr %38, align 4, !tbaa !21
  %1164 = load float, ptr %38, align 4, !tbaa !21
  %1165 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1166 = load float, ptr %1165, align 4, !tbaa !11
  %1167 = fmul float %1164, %1166
  %1168 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  store float %1167, ptr %1168, align 4, !tbaa !11
  %1169 = load float, ptr %38, align 4, !tbaa !21
  %1170 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1171 = load float, ptr %1170, align 4, !tbaa !14
  %1172 = fmul float %1169, %1171
  %1173 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  store float %1172, ptr %1173, align 4, !tbaa !14
  %1174 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %1175 = load float, ptr %1174, align 4, !tbaa !11
  %1176 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 0
  %1177 = load float, ptr %1176, align 4, !tbaa !11
  %1178 = fadd float %1175, %1177
  %1179 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1178, ptr %1179, align 4, !tbaa !11
  %1180 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %1181 = load float, ptr %1180, align 4, !tbaa !14
  %1182 = getelementptr inbounds %struct.complex, ptr %42, i32 0, i32 1
  %1183 = load float, ptr %1182, align 4, !tbaa !14
  %1184 = fadd float %1181, %1183
  %1185 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1184, ptr %1185, align 4, !tbaa !14
  %1186 = load ptr, ptr %18, align 8, !tbaa !5
  %1187 = getelementptr inbounds %struct.complex, ptr %1186, i32 0, i32 0
  %1188 = load float, ptr %1187, align 4, !tbaa !11
  %1189 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %1190 = load float, ptr %1189, align 4, !tbaa !11
  %1191 = load ptr, ptr %18, align 8, !tbaa !5
  %1192 = getelementptr inbounds %struct.complex, ptr %1191, i32 0, i32 1
  %1193 = load float, ptr %1192, align 4, !tbaa !14
  %1194 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %1195 = load float, ptr %1194, align 4, !tbaa !14
  %1196 = fmul float %1193, %1195
  %1197 = fneg float %1196
  %1198 = call float @llvm.fmuladd.f32(float %1188, float %1190, float %1197)
  %1199 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 0
  store float %1198, ptr %1199, align 4, !tbaa !11
  %1200 = load ptr, ptr %18, align 8, !tbaa !5
  %1201 = getelementptr inbounds %struct.complex, ptr %1200, i32 0, i32 0
  %1202 = load float, ptr %1201, align 4, !tbaa !11
  %1203 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 1
  %1204 = load float, ptr %1203, align 4, !tbaa !14
  %1205 = load ptr, ptr %18, align 8, !tbaa !5
  %1206 = getelementptr inbounds %struct.complex, ptr %1205, i32 0, i32 1
  %1207 = load float, ptr %1206, align 4, !tbaa !14
  %1208 = getelementptr inbounds %struct.complex, ptr %49, i32 0, i32 0
  %1209 = load float, ptr %1208, align 4, !tbaa !11
  %1210 = fmul float %1207, %1209
  %1211 = call float @llvm.fmuladd.f32(float %1202, float %1204, float %1210)
  %1212 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 1
  store float %1211, ptr %1212, align 4, !tbaa !14
  %1213 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1214 = load float, ptr %1213, align 4, !tbaa !11
  %1215 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 0
  %1216 = load float, ptr %1215, align 4, !tbaa !11
  %1217 = fadd float %1214, %1216
  %1218 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1217, ptr %1218, align 4, !tbaa !11
  %1219 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1220 = load float, ptr %1219, align 4, !tbaa !14
  %1221 = getelementptr inbounds %struct.complex, ptr %43, i32 0, i32 1
  %1222 = load float, ptr %1221, align 4, !tbaa !14
  %1223 = fadd float %1220, %1222
  %1224 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1223, ptr %1224, align 4, !tbaa !14
  %1225 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1226 = load float, ptr %1225, align 4, !tbaa !11
  %1227 = load ptr, ptr %24, align 8, !tbaa !5
  %1228 = load i64, ptr %33, align 8, !tbaa !9
  %1229 = getelementptr inbounds %struct.complex, ptr %1227, i64 %1228
  %1230 = getelementptr inbounds %struct.complex, ptr %1229, i32 0, i32 0
  store float %1226, ptr %1230, align 4, !tbaa !11
  %1231 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1232 = load float, ptr %1231, align 4, !tbaa !14
  %1233 = load ptr, ptr %24, align 8, !tbaa !5
  %1234 = load i64, ptr %33, align 8, !tbaa !9
  %1235 = getelementptr inbounds %struct.complex, ptr %1233, i64 %1234
  %1236 = getelementptr inbounds %struct.complex, ptr %1235, i32 0, i32 1
  store float %1232, ptr %1236, align 4, !tbaa !14
  br label %1237

1237:                                             ; preds = %1104, %1027
  br label %1238

1238:                                             ; preds = %1237
  %1239 = load i64, ptr %44, align 8, !tbaa !9
  %1240 = add nsw i64 %1239, -1
  store i64 %1240, ptr %44, align 8, !tbaa !9
  br label %804, !llvm.loop !25

1241:                                             ; preds = %804
  br label %1242

1242:                                             ; preds = %1241
  %1243 = load i64, ptr %45, align 8, !tbaa !9
  %1244 = add nsw i64 %1243, 1
  store i64 %1244, ptr %45, align 8, !tbaa !9
  br label %797, !llvm.loop !26

1245:                                             ; preds = %797
  br label %1246

1246:                                             ; preds = %1245, %793
  br label %1887

1247:                                             ; preds = %336
  %1248 = load ptr, ptr %17, align 8, !tbaa !5
  %1249 = load i64, ptr %1248, align 8, !tbaa !9
  store i64 %1249, ptr %32, align 8, !tbaa !9
  store i64 1, ptr %45, align 8, !tbaa !9
  br label %1250

1250:                                             ; preds = %1883, %1247
  %1251 = load i64, ptr %45, align 8, !tbaa !9
  %1252 = load i64, ptr %32, align 8, !tbaa !9
  %1253 = icmp sle i64 %1251, %1252
  br i1 %1253, label %1254, label %1886

1254:                                             ; preds = %1250
  %1255 = load i64, ptr %45, align 8, !tbaa !9
  %1256 = load i64, ptr %45, align 8, !tbaa !9
  %1257 = load i64, ptr %26, align 8, !tbaa !9
  %1258 = mul nsw i64 %1256, %1257
  %1259 = add nsw i64 %1255, %1258
  store i64 %1259, ptr %33, align 8, !tbaa !9
  %1260 = load ptr, ptr %19, align 8, !tbaa !5
  %1261 = load i64, ptr %33, align 8, !tbaa !9
  %1262 = getelementptr inbounds %struct.complex, ptr %1260, i64 %1261
  %1263 = getelementptr inbounds %struct.complex, ptr %1262, i32 0, i32 0
  %1264 = load float, ptr %1263, align 4, !tbaa !11
  store float %1264, ptr %38, align 4, !tbaa !21
  %1265 = load float, ptr %38, align 4, !tbaa !21
  %1266 = load ptr, ptr %18, align 8, !tbaa !5
  %1267 = getelementptr inbounds %struct.complex, ptr %1266, i32 0, i32 0
  %1268 = load float, ptr %1267, align 4, !tbaa !11
  %1269 = fmul float %1265, %1268
  %1270 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1269, ptr %1270, align 4, !tbaa !11
  %1271 = load float, ptr %38, align 4, !tbaa !21
  %1272 = load ptr, ptr %18, align 8, !tbaa !5
  %1273 = getelementptr inbounds %struct.complex, ptr %1272, i32 0, i32 1
  %1274 = load float, ptr %1273, align 4, !tbaa !14
  %1275 = fmul float %1271, %1274
  %1276 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1275, ptr %1276, align 4, !tbaa !14
  %1277 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1278 = load float, ptr %1277, align 4, !tbaa !11
  %1279 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %1278, ptr %1279, align 4, !tbaa !11
  %1280 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1281 = load float, ptr %1280, align 4, !tbaa !14
  %1282 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %1281, ptr %1282, align 4, !tbaa !14
  %1283 = load ptr, ptr %23, align 8, !tbaa !5
  %1284 = getelementptr inbounds %struct.complex, ptr %1283, i32 0, i32 0
  %1285 = load float, ptr %1284, align 4, !tbaa !11
  %1286 = fcmp oeq float %1285, 0.000000e+00
  br i1 %1286, label %1287, label %1361

1287:                                             ; preds = %1254
  %1288 = load ptr, ptr %23, align 8, !tbaa !5
  %1289 = getelementptr inbounds %struct.complex, ptr %1288, i32 0, i32 1
  %1290 = load float, ptr %1289, align 4, !tbaa !14
  %1291 = fcmp oeq float %1290, 0.000000e+00
  br i1 %1291, label %1292, label %1361

1292:                                             ; preds = %1287
  %1293 = load ptr, ptr %16, align 8, !tbaa !5
  %1294 = load i64, ptr %1293, align 8, !tbaa !9
  store i64 %1294, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %1295

1295:                                             ; preds = %1357, %1292
  %1296 = load i64, ptr %44, align 8, !tbaa !9
  %1297 = load i64, ptr %33, align 8, !tbaa !9
  %1298 = icmp sle i64 %1296, %1297
  br i1 %1298, label %1299, label %1360

1299:                                             ; preds = %1295
  %1300 = load i64, ptr %44, align 8, !tbaa !9
  %1301 = load i64, ptr %45, align 8, !tbaa !9
  %1302 = load i64, ptr %30, align 8, !tbaa !9
  %1303 = mul nsw i64 %1301, %1302
  %1304 = add nsw i64 %1300, %1303
  store i64 %1304, ptr %34, align 8, !tbaa !9
  %1305 = load i64, ptr %44, align 8, !tbaa !9
  %1306 = load i64, ptr %45, align 8, !tbaa !9
  %1307 = load i64, ptr %28, align 8, !tbaa !9
  %1308 = mul nsw i64 %1306, %1307
  %1309 = add nsw i64 %1305, %1308
  store i64 %1309, ptr %35, align 8, !tbaa !9
  %1310 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1311 = load float, ptr %1310, align 4, !tbaa !11
  %1312 = load ptr, ptr %21, align 8, !tbaa !5
  %1313 = load i64, ptr %35, align 8, !tbaa !9
  %1314 = getelementptr inbounds %struct.complex, ptr %1312, i64 %1313
  %1315 = getelementptr inbounds %struct.complex, ptr %1314, i32 0, i32 0
  %1316 = load float, ptr %1315, align 4, !tbaa !11
  %1317 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1318 = load float, ptr %1317, align 4, !tbaa !14
  %1319 = load ptr, ptr %21, align 8, !tbaa !5
  %1320 = load i64, ptr %35, align 8, !tbaa !9
  %1321 = getelementptr inbounds %struct.complex, ptr %1319, i64 %1320
  %1322 = getelementptr inbounds %struct.complex, ptr %1321, i32 0, i32 1
  %1323 = load float, ptr %1322, align 4, !tbaa !14
  %1324 = fmul float %1318, %1323
  %1325 = fneg float %1324
  %1326 = call float @llvm.fmuladd.f32(float %1311, float %1316, float %1325)
  %1327 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1326, ptr %1327, align 4, !tbaa !11
  %1328 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1329 = load float, ptr %1328, align 4, !tbaa !11
  %1330 = load ptr, ptr %21, align 8, !tbaa !5
  %1331 = load i64, ptr %35, align 8, !tbaa !9
  %1332 = getelementptr inbounds %struct.complex, ptr %1330, i64 %1331
  %1333 = getelementptr inbounds %struct.complex, ptr %1332, i32 0, i32 1
  %1334 = load float, ptr %1333, align 4, !tbaa !14
  %1335 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1336 = load float, ptr %1335, align 4, !tbaa !14
  %1337 = load ptr, ptr %21, align 8, !tbaa !5
  %1338 = load i64, ptr %35, align 8, !tbaa !9
  %1339 = getelementptr inbounds %struct.complex, ptr %1337, i64 %1338
  %1340 = getelementptr inbounds %struct.complex, ptr %1339, i32 0, i32 0
  %1341 = load float, ptr %1340, align 4, !tbaa !11
  %1342 = fmul float %1336, %1341
  %1343 = call float @llvm.fmuladd.f32(float %1329, float %1334, float %1342)
  %1344 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1343, ptr %1344, align 4, !tbaa !14
  %1345 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1346 = load float, ptr %1345, align 4, !tbaa !11
  %1347 = load ptr, ptr %24, align 8, !tbaa !5
  %1348 = load i64, ptr %34, align 8, !tbaa !9
  %1349 = getelementptr inbounds %struct.complex, ptr %1347, i64 %1348
  %1350 = getelementptr inbounds %struct.complex, ptr %1349, i32 0, i32 0
  store float %1346, ptr %1350, align 4, !tbaa !11
  %1351 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1352 = load float, ptr %1351, align 4, !tbaa !14
  %1353 = load ptr, ptr %24, align 8, !tbaa !5
  %1354 = load i64, ptr %34, align 8, !tbaa !9
  %1355 = getelementptr inbounds %struct.complex, ptr %1353, i64 %1354
  %1356 = getelementptr inbounds %struct.complex, ptr %1355, i32 0, i32 1
  store float %1352, ptr %1356, align 4, !tbaa !14
  br label %1357

1357:                                             ; preds = %1299
  %1358 = load i64, ptr %44, align 8, !tbaa !9
  %1359 = add nsw i64 %1358, 1
  store i64 %1359, ptr %44, align 8, !tbaa !9
  br label %1295, !llvm.loop !27

1360:                                             ; preds = %1295
  br label %1486

1361:                                             ; preds = %1287, %1254
  %1362 = load ptr, ptr %16, align 8, !tbaa !5
  %1363 = load i64, ptr %1362, align 8, !tbaa !9
  store i64 %1363, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %1364

1364:                                             ; preds = %1482, %1361
  %1365 = load i64, ptr %44, align 8, !tbaa !9
  %1366 = load i64, ptr %33, align 8, !tbaa !9
  %1367 = icmp sle i64 %1365, %1366
  br i1 %1367, label %1368, label %1485

1368:                                             ; preds = %1364
  %1369 = load i64, ptr %44, align 8, !tbaa !9
  %1370 = load i64, ptr %45, align 8, !tbaa !9
  %1371 = load i64, ptr %30, align 8, !tbaa !9
  %1372 = mul nsw i64 %1370, %1371
  %1373 = add nsw i64 %1369, %1372
  store i64 %1373, ptr %34, align 8, !tbaa !9
  %1374 = load i64, ptr %44, align 8, !tbaa !9
  %1375 = load i64, ptr %45, align 8, !tbaa !9
  %1376 = load i64, ptr %30, align 8, !tbaa !9
  %1377 = mul nsw i64 %1375, %1376
  %1378 = add nsw i64 %1374, %1377
  store i64 %1378, ptr %35, align 8, !tbaa !9
  %1379 = load ptr, ptr %23, 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 %24, align 8, !tbaa !5
  %1383 = load i64, ptr %35, align 8, !tbaa !9
  %1384 = getelementptr inbounds %struct.complex, ptr %1382, i64 %1383
  %1385 = getelementptr inbounds %struct.complex, ptr %1384, i32 0, i32 0
  %1386 = load float, ptr %1385, align 4, !tbaa !11
  %1387 = load ptr, ptr %23, 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 %24, align 8, !tbaa !5
  %1391 = load i64, ptr %35, align 8, !tbaa !9
  %1392 = getelementptr inbounds %struct.complex, ptr %1390, i64 %1391
  %1393 = getelementptr inbounds %struct.complex, ptr %1392, i32 0, i32 1
  %1394 = load float, ptr %1393, align 4, !tbaa !14
  %1395 = fmul float %1389, %1394
  %1396 = fneg float %1395
  %1397 = call float @llvm.fmuladd.f32(float %1381, float %1386, float %1396)
  %1398 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1397, ptr %1398, align 4, !tbaa !11
  %1399 = load ptr, ptr %23, align 8, !tbaa !5
  %1400 = getelementptr inbounds %struct.complex, ptr %1399, i32 0, i32 0
  %1401 = load float, ptr %1400, align 4, !tbaa !11
  %1402 = load ptr, ptr %24, align 8, !tbaa !5
  %1403 = load i64, ptr %35, align 8, !tbaa !9
  %1404 = getelementptr inbounds %struct.complex, ptr %1402, i64 %1403
  %1405 = getelementptr inbounds %struct.complex, ptr %1404, i32 0, i32 1
  %1406 = load float, ptr %1405, align 4, !tbaa !14
  %1407 = load ptr, ptr %23, align 8, !tbaa !5
  %1408 = getelementptr inbounds %struct.complex, ptr %1407, i32 0, i32 1
  %1409 = load float, ptr %1408, align 4, !tbaa !14
  %1410 = load ptr, ptr %24, align 8, !tbaa !5
  %1411 = load i64, ptr %35, align 8, !tbaa !9
  %1412 = getelementptr inbounds %struct.complex, ptr %1410, i64 %1411
  %1413 = getelementptr inbounds %struct.complex, ptr %1412, i32 0, i32 0
  %1414 = load float, ptr %1413, align 4, !tbaa !11
  %1415 = fmul float %1409, %1414
  %1416 = call float @llvm.fmuladd.f32(float %1401, float %1406, float %1415)
  %1417 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1416, ptr %1417, align 4, !tbaa !14
  %1418 = load i64, ptr %44, align 8, !tbaa !9
  %1419 = load i64, ptr %45, align 8, !tbaa !9
  %1420 = load i64, ptr %28, align 8, !tbaa !9
  %1421 = mul nsw i64 %1419, %1420
  %1422 = add nsw i64 %1418, %1421
  store i64 %1422, ptr %36, align 8, !tbaa !9
  %1423 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1424 = load float, ptr %1423, align 4, !tbaa !11
  %1425 = load ptr, ptr %21, align 8, !tbaa !5
  %1426 = load i64, ptr %36, align 8, !tbaa !9
  %1427 = getelementptr inbounds %struct.complex, ptr %1425, i64 %1426
  %1428 = getelementptr inbounds %struct.complex, ptr %1427, i32 0, i32 0
  %1429 = load float, ptr %1428, align 4, !tbaa !11
  %1430 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1431 = load float, ptr %1430, align 4, !tbaa !14
  %1432 = load ptr, ptr %21, align 8, !tbaa !5
  %1433 = load i64, ptr %36, align 8, !tbaa !9
  %1434 = getelementptr inbounds %struct.complex, ptr %1432, i64 %1433
  %1435 = getelementptr inbounds %struct.complex, ptr %1434, i32 0, i32 1
  %1436 = load float, ptr %1435, align 4, !tbaa !14
  %1437 = fmul float %1431, %1436
  %1438 = fneg float %1437
  %1439 = call float @llvm.fmuladd.f32(float %1424, float %1429, float %1438)
  %1440 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  store float %1439, ptr %1440, align 4, !tbaa !11
  %1441 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1442 = load float, ptr %1441, align 4, !tbaa !11
  %1443 = load ptr, ptr %21, align 8, !tbaa !5
  %1444 = load i64, ptr %36, align 8, !tbaa !9
  %1445 = getelementptr inbounds %struct.complex, ptr %1443, i64 %1444
  %1446 = getelementptr inbounds %struct.complex, ptr %1445, i32 0, i32 1
  %1447 = load float, ptr %1446, align 4, !tbaa !14
  %1448 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1449 = load float, ptr %1448, align 4, !tbaa !14
  %1450 = load ptr, ptr %21, align 8, !tbaa !5
  %1451 = load i64, ptr %36, align 8, !tbaa !9
  %1452 = getelementptr inbounds %struct.complex, ptr %1450, i64 %1451
  %1453 = getelementptr inbounds %struct.complex, ptr %1452, i32 0, i32 0
  %1454 = load float, ptr %1453, align 4, !tbaa !11
  %1455 = fmul float %1449, %1454
  %1456 = call float @llvm.fmuladd.f32(float %1442, float %1447, float %1455)
  %1457 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  store float %1456, ptr %1457, align 4, !tbaa !14
  %1458 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1459 = load float, ptr %1458, align 4, !tbaa !11
  %1460 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 0
  %1461 = load float, ptr %1460, align 4, !tbaa !11
  %1462 = fadd float %1459, %1461
  %1463 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1462, ptr %1463, align 4, !tbaa !11
  %1464 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1465 = load float, ptr %1464, align 4, !tbaa !14
  %1466 = getelementptr inbounds %struct.complex, ptr %41, i32 0, i32 1
  %1467 = load float, ptr %1466, align 4, !tbaa !14
  %1468 = fadd float %1465, %1467
  %1469 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1468, ptr %1469, align 4, !tbaa !14
  %1470 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1471 = load float, ptr %1470, align 4, !tbaa !11
  %1472 = load ptr, ptr %24, align 8, !tbaa !5
  %1473 = load i64, ptr %34, align 8, !tbaa !9
  %1474 = getelementptr inbounds %struct.complex, ptr %1472, i64 %1473
  %1475 = getelementptr inbounds %struct.complex, ptr %1474, i32 0, i32 0
  store float %1471, ptr %1475, align 4, !tbaa !11
  %1476 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1477 = load float, ptr %1476, align 4, !tbaa !14
  %1478 = load ptr, ptr %24, align 8, !tbaa !5
  %1479 = load i64, ptr %34, align 8, !tbaa !9
  %1480 = getelementptr inbounds %struct.complex, ptr %1478, i64 %1479
  %1481 = getelementptr inbounds %struct.complex, ptr %1480, i32 0, i32 1
  store float %1477, ptr %1481, align 4, !tbaa !14
  br label %1482

1482:                                             ; preds = %1368
  %1483 = load i64, ptr %44, align 8, !tbaa !9
  %1484 = add nsw i64 %1483, 1
  store i64 %1484, ptr %44, align 8, !tbaa !9
  br label %1364, !llvm.loop !28

1485:                                             ; preds = %1364
  br label %1486

1486:                                             ; preds = %1485, %1360
  %1487 = load i64, ptr %45, align 8, !tbaa !9
  %1488 = sub nsw i64 %1487, 1
  store i64 %1488, ptr %33, align 8, !tbaa !9
  store i64 1, ptr %46, align 8, !tbaa !9
  br label %1489

1489:                                             ; preds = %1680, %1486
  %1490 = load i64, ptr %46, align 8, !tbaa !9
  %1491 = load i64, ptr %33, align 8, !tbaa !9
  %1492 = icmp sle i64 %1490, %1491
  br i1 %1492, label %1493, label %1683

1493:                                             ; preds = %1489
  %1494 = load i64, ptr %51, align 8, !tbaa !9
  %1495 = icmp ne i64 %1494, 0
  br i1 %1495, label %1496, label %1547

1496:                                             ; preds = %1493
  %1497 = load i64, ptr %46, align 8, !tbaa !9
  %1498 = load i64, ptr %45, align 8, !tbaa !9
  %1499 = load i64, ptr %26, align 8, !tbaa !9
  %1500 = mul nsw i64 %1498, %1499
  %1501 = add nsw i64 %1497, %1500
  store i64 %1501, ptr %34, align 8, !tbaa !9
  %1502 = load ptr, ptr %18, align 8, !tbaa !5
  %1503 = getelementptr inbounds %struct.complex, ptr %1502, i32 0, i32 0
  %1504 = load float, ptr %1503, align 4, !tbaa !11
  %1505 = load ptr, ptr %19, align 8, !tbaa !5
  %1506 = load i64, ptr %34, align 8, !tbaa !9
  %1507 = getelementptr inbounds %struct.complex, ptr %1505, i64 %1506
  %1508 = getelementptr inbounds %struct.complex, ptr %1507, i32 0, i32 0
  %1509 = load float, ptr %1508, align 4, !tbaa !11
  %1510 = load ptr, ptr %18, align 8, !tbaa !5
  %1511 = getelementptr inbounds %struct.complex, ptr %1510, i32 0, i32 1
  %1512 = load float, ptr %1511, align 4, !tbaa !14
  %1513 = load ptr, ptr %19, align 8, !tbaa !5
  %1514 = load i64, ptr %34, align 8, !tbaa !9
  %1515 = getelementptr inbounds %struct.complex, ptr %1513, i64 %1514
  %1516 = getelementptr inbounds %struct.complex, ptr %1515, i32 0, i32 1
  %1517 = load float, ptr %1516, align 4, !tbaa !14
  %1518 = fmul float %1512, %1517
  %1519 = fneg float %1518
  %1520 = call float @llvm.fmuladd.f32(float %1504, float %1509, float %1519)
  %1521 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1520, ptr %1521, align 4, !tbaa !11
  %1522 = load ptr, ptr %18, align 8, !tbaa !5
  %1523 = getelementptr inbounds %struct.complex, ptr %1522, i32 0, i32 0
  %1524 = load float, ptr %1523, align 4, !tbaa !11
  %1525 = load ptr, ptr %19, align 8, !tbaa !5
  %1526 = load i64, ptr %34, align 8, !tbaa !9
  %1527 = getelementptr inbounds %struct.complex, ptr %1525, i64 %1526
  %1528 = getelementptr inbounds %struct.complex, ptr %1527, i32 0, i32 1
  %1529 = load float, ptr %1528, align 4, !tbaa !14
  %1530 = load ptr, ptr %18, align 8, !tbaa !5
  %1531 = getelementptr inbounds %struct.complex, ptr %1530, i32 0, i32 1
  %1532 = load float, ptr %1531, align 4, !tbaa !14
  %1533 = load ptr, ptr %19, align 8, !tbaa !5
  %1534 = load i64, ptr %34, align 8, !tbaa !9
  %1535 = getelementptr inbounds %struct.complex, ptr %1533, i64 %1534
  %1536 = getelementptr inbounds %struct.complex, ptr %1535, i32 0, i32 0
  %1537 = load float, ptr %1536, align 4, !tbaa !11
  %1538 = fmul float %1532, %1537
  %1539 = call float @llvm.fmuladd.f32(float %1524, float %1529, float %1538)
  %1540 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1539, ptr %1540, align 4, !tbaa !14
  %1541 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1542 = load float, ptr %1541, align 4, !tbaa !11
  %1543 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %1542, ptr %1543, align 4, !tbaa !11
  %1544 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1545 = load float, ptr %1544, align 4, !tbaa !14
  %1546 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %1545, ptr %1546, align 4, !tbaa !14
  br label %1588

1547:                                             ; preds = %1493
  %1548 = load ptr, ptr %19, align 8, !tbaa !5
  %1549 = load i64, ptr %45, align 8, !tbaa !9
  %1550 = load i64, ptr %46, align 8, !tbaa !9
  %1551 = load i64, ptr %26, align 8, !tbaa !9
  %1552 = mul nsw i64 %1550, %1551
  %1553 = add nsw i64 %1549, %1552
  %1554 = getelementptr inbounds %struct.complex, ptr %1548, i64 %1553
  call void @r_cnjg(ptr noundef %40, ptr noundef %1554)
  %1555 = load ptr, ptr %18, align 8, !tbaa !5
  %1556 = getelementptr inbounds %struct.complex, ptr %1555, i32 0, i32 0
  %1557 = load float, ptr %1556, align 4, !tbaa !11
  %1558 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1559 = load float, ptr %1558, align 4, !tbaa !11
  %1560 = load ptr, ptr %18, align 8, !tbaa !5
  %1561 = getelementptr inbounds %struct.complex, ptr %1560, i32 0, i32 1
  %1562 = load float, ptr %1561, align 4, !tbaa !14
  %1563 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1564 = load float, ptr %1563, align 4, !tbaa !14
  %1565 = fmul float %1562, %1564
  %1566 = fneg float %1565
  %1567 = call float @llvm.fmuladd.f32(float %1557, float %1559, float %1566)
  %1568 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1567, ptr %1568, align 4, !tbaa !11
  %1569 = load ptr, ptr %18, align 8, !tbaa !5
  %1570 = getelementptr inbounds %struct.complex, ptr %1569, i32 0, i32 0
  %1571 = load float, ptr %1570, align 4, !tbaa !11
  %1572 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1573 = load float, ptr %1572, align 4, !tbaa !14
  %1574 = load ptr, ptr %18, align 8, !tbaa !5
  %1575 = getelementptr inbounds %struct.complex, ptr %1574, i32 0, i32 1
  %1576 = load float, ptr %1575, align 4, !tbaa !14
  %1577 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1578 = load float, ptr %1577, align 4, !tbaa !11
  %1579 = fmul float %1576, %1578
  %1580 = call float @llvm.fmuladd.f32(float %1571, float %1573, float %1579)
  %1581 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1580, ptr %1581, align 4, !tbaa !14
  %1582 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1583 = load float, ptr %1582, align 4, !tbaa !11
  %1584 = getelementptr inbounds %struct.complex, ptr %48, 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 %48, i32 0, i32 1
  store float %1586, ptr %1587, align 4, !tbaa !14
  br label %1588

1588:                                             ; preds = %1547, %1496
  %1589 = load ptr, ptr %16, align 8, !tbaa !5
  %1590 = load i64, ptr %1589, align 8, !tbaa !9
  store i64 %1590, ptr %34, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %1591

1591:                                             ; preds = %1676, %1588
  %1592 = load i64, ptr %44, align 8, !tbaa !9
  %1593 = load i64, ptr %34, align 8, !tbaa !9
  %1594 = icmp sle i64 %1592, %1593
  br i1 %1594, label %1595, label %1679

1595:                                             ; preds = %1591
  %1596 = load i64, ptr %44, align 8, !tbaa !9
  %1597 = load i64, ptr %45, align 8, !tbaa !9
  %1598 = load i64, ptr %30, align 8, !tbaa !9
  %1599 = mul nsw i64 %1597, %1598
  %1600 = add nsw i64 %1596, %1599
  store i64 %1600, ptr %35, align 8, !tbaa !9
  %1601 = load i64, ptr %44, align 8, !tbaa !9
  %1602 = load i64, ptr %45, align 8, !tbaa !9
  %1603 = load i64, ptr %30, align 8, !tbaa !9
  %1604 = mul nsw i64 %1602, %1603
  %1605 = add nsw i64 %1601, %1604
  store i64 %1605, ptr %36, align 8, !tbaa !9
  %1606 = load i64, ptr %44, align 8, !tbaa !9
  %1607 = load i64, ptr %46, align 8, !tbaa !9
  %1608 = load i64, ptr %28, align 8, !tbaa !9
  %1609 = mul nsw i64 %1607, %1608
  %1610 = add nsw i64 %1606, %1609
  store i64 %1610, ptr %37, align 8, !tbaa !9
  %1611 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1612 = load float, ptr %1611, align 4, !tbaa !11
  %1613 = load ptr, ptr %21, align 8, !tbaa !5
  %1614 = load i64, ptr %37, align 8, !tbaa !9
  %1615 = getelementptr inbounds %struct.complex, ptr %1613, i64 %1614
  %1616 = getelementptr inbounds %struct.complex, ptr %1615, i32 0, i32 0
  %1617 = load float, ptr %1616, align 4, !tbaa !11
  %1618 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1619 = load float, ptr %1618, align 4, !tbaa !14
  %1620 = load ptr, ptr %21, align 8, !tbaa !5
  %1621 = load i64, ptr %37, align 8, !tbaa !9
  %1622 = getelementptr inbounds %struct.complex, ptr %1620, i64 %1621
  %1623 = getelementptr inbounds %struct.complex, ptr %1622, i32 0, i32 1
  %1624 = load float, ptr %1623, align 4, !tbaa !14
  %1625 = fmul float %1619, %1624
  %1626 = fneg float %1625
  %1627 = call float @llvm.fmuladd.f32(float %1612, float %1617, float %1626)
  %1628 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1627, ptr %1628, align 4, !tbaa !11
  %1629 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1630 = load float, ptr %1629, align 4, !tbaa !11
  %1631 = load ptr, ptr %21, align 8, !tbaa !5
  %1632 = load i64, ptr %37, align 8, !tbaa !9
  %1633 = getelementptr inbounds %struct.complex, ptr %1631, i64 %1632
  %1634 = getelementptr inbounds %struct.complex, ptr %1633, i32 0, i32 1
  %1635 = load float, ptr %1634, align 4, !tbaa !14
  %1636 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1637 = load float, ptr %1636, align 4, !tbaa !14
  %1638 = load ptr, ptr %21, align 8, !tbaa !5
  %1639 = load i64, ptr %37, align 8, !tbaa !9
  %1640 = getelementptr inbounds %struct.complex, ptr %1638, i64 %1639
  %1641 = getelementptr inbounds %struct.complex, ptr %1640, i32 0, i32 0
  %1642 = load float, ptr %1641, align 4, !tbaa !11
  %1643 = fmul float %1637, %1642
  %1644 = call float @llvm.fmuladd.f32(float %1630, float %1635, float %1643)
  %1645 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1644, ptr %1645, align 4, !tbaa !14
  %1646 = load ptr, ptr %24, align 8, !tbaa !5
  %1647 = load i64, ptr %36, align 8, !tbaa !9
  %1648 = getelementptr inbounds %struct.complex, ptr %1646, i64 %1647
  %1649 = getelementptr inbounds %struct.complex, ptr %1648, i32 0, i32 0
  %1650 = load float, ptr %1649, align 4, !tbaa !11
  %1651 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1652 = load float, ptr %1651, align 4, !tbaa !11
  %1653 = fadd float %1650, %1652
  %1654 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1653, ptr %1654, align 4, !tbaa !11
  %1655 = load ptr, ptr %24, align 8, !tbaa !5
  %1656 = load i64, ptr %36, align 8, !tbaa !9
  %1657 = getelementptr inbounds %struct.complex, ptr %1655, i64 %1656
  %1658 = getelementptr inbounds %struct.complex, ptr %1657, i32 0, i32 1
  %1659 = load float, ptr %1658, align 4, !tbaa !14
  %1660 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1661 = load float, ptr %1660, align 4, !tbaa !14
  %1662 = fadd float %1659, %1661
  %1663 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1662, ptr %1663, align 4, !tbaa !14
  %1664 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1665 = load float, ptr %1664, align 4, !tbaa !11
  %1666 = load ptr, ptr %24, align 8, !tbaa !5
  %1667 = load i64, ptr %35, align 8, !tbaa !9
  %1668 = getelementptr inbounds %struct.complex, ptr %1666, i64 %1667
  %1669 = getelementptr inbounds %struct.complex, ptr %1668, i32 0, i32 0
  store float %1665, ptr %1669, align 4, !tbaa !11
  %1670 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1671 = load float, ptr %1670, align 4, !tbaa !14
  %1672 = load ptr, ptr %24, align 8, !tbaa !5
  %1673 = load i64, ptr %35, align 8, !tbaa !9
  %1674 = getelementptr inbounds %struct.complex, ptr %1672, i64 %1673
  %1675 = getelementptr inbounds %struct.complex, ptr %1674, i32 0, i32 1
  store float %1671, ptr %1675, align 4, !tbaa !14
  br label %1676

1676:                                             ; preds = %1595
  %1677 = load i64, ptr %44, align 8, !tbaa !9
  %1678 = add nsw i64 %1677, 1
  store i64 %1678, ptr %44, align 8, !tbaa !9
  br label %1591, !llvm.loop !29

1679:                                             ; preds = %1591
  br label %1680

1680:                                             ; preds = %1679
  %1681 = load i64, ptr %46, align 8, !tbaa !9
  %1682 = add nsw i64 %1681, 1
  store i64 %1682, ptr %46, align 8, !tbaa !9
  br label %1489, !llvm.loop !30

1683:                                             ; preds = %1489
  %1684 = load ptr, ptr %17, align 8, !tbaa !5
  %1685 = load i64, ptr %1684, align 8, !tbaa !9
  store i64 %1685, ptr %33, align 8, !tbaa !9
  %1686 = load i64, ptr %45, align 8, !tbaa !9
  %1687 = add nsw i64 %1686, 1
  store i64 %1687, ptr %46, align 8, !tbaa !9
  br label %1688

1688:                                             ; preds = %1879, %1683
  %1689 = load i64, ptr %46, align 8, !tbaa !9
  %1690 = load i64, ptr %33, align 8, !tbaa !9
  %1691 = icmp sle i64 %1689, %1690
  br i1 %1691, label %1692, label %1882

1692:                                             ; preds = %1688
  %1693 = load i64, ptr %51, align 8, !tbaa !9
  %1694 = icmp ne i64 %1693, 0
  br i1 %1694, label %1695, label %1736

1695:                                             ; preds = %1692
  %1696 = load ptr, ptr %19, align 8, !tbaa !5
  %1697 = load i64, ptr %45, align 8, !tbaa !9
  %1698 = load i64, ptr %46, align 8, !tbaa !9
  %1699 = load i64, ptr %26, align 8, !tbaa !9
  %1700 = mul nsw i64 %1698, %1699
  %1701 = add nsw i64 %1697, %1700
  %1702 = getelementptr inbounds %struct.complex, ptr %1696, i64 %1701
  call void @r_cnjg(ptr noundef %40, ptr noundef %1702)
  %1703 = load ptr, ptr %18, align 8, !tbaa !5
  %1704 = getelementptr inbounds %struct.complex, ptr %1703, i32 0, i32 0
  %1705 = load float, ptr %1704, align 4, !tbaa !11
  %1706 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1707 = load float, ptr %1706, align 4, !tbaa !11
  %1708 = load ptr, ptr %18, align 8, !tbaa !5
  %1709 = getelementptr inbounds %struct.complex, ptr %1708, i32 0, i32 1
  %1710 = load float, ptr %1709, align 4, !tbaa !14
  %1711 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1712 = load float, ptr %1711, align 4, !tbaa !14
  %1713 = fmul float %1710, %1712
  %1714 = fneg float %1713
  %1715 = call float @llvm.fmuladd.f32(float %1705, float %1707, float %1714)
  %1716 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1715, ptr %1716, align 4, !tbaa !11
  %1717 = load ptr, ptr %18, align 8, !tbaa !5
  %1718 = getelementptr inbounds %struct.complex, ptr %1717, i32 0, i32 0
  %1719 = load float, ptr %1718, align 4, !tbaa !11
  %1720 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1721 = load float, ptr %1720, align 4, !tbaa !14
  %1722 = load ptr, ptr %18, align 8, !tbaa !5
  %1723 = getelementptr inbounds %struct.complex, ptr %1722, i32 0, i32 1
  %1724 = load float, ptr %1723, align 4, !tbaa !14
  %1725 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1726 = load float, ptr %1725, align 4, !tbaa !11
  %1727 = fmul float %1724, %1726
  %1728 = call float @llvm.fmuladd.f32(float %1719, float %1721, float %1727)
  %1729 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1728, ptr %1729, align 4, !tbaa !14
  %1730 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1731 = load float, ptr %1730, align 4, !tbaa !11
  %1732 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %1731, ptr %1732, align 4, !tbaa !11
  %1733 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1734 = load float, ptr %1733, align 4, !tbaa !14
  %1735 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %1734, ptr %1735, align 4, !tbaa !14
  br label %1787

1736:                                             ; preds = %1692
  %1737 = load i64, ptr %46, align 8, !tbaa !9
  %1738 = load i64, ptr %45, align 8, !tbaa !9
  %1739 = load i64, ptr %26, align 8, !tbaa !9
  %1740 = mul nsw i64 %1738, %1739
  %1741 = add nsw i64 %1737, %1740
  store i64 %1741, ptr %34, align 8, !tbaa !9
  %1742 = load ptr, ptr %18, align 8, !tbaa !5
  %1743 = getelementptr inbounds %struct.complex, ptr %1742, i32 0, i32 0
  %1744 = load float, ptr %1743, align 4, !tbaa !11
  %1745 = load ptr, ptr %19, align 8, !tbaa !5
  %1746 = load i64, ptr %34, align 8, !tbaa !9
  %1747 = getelementptr inbounds %struct.complex, ptr %1745, i64 %1746
  %1748 = getelementptr inbounds %struct.complex, ptr %1747, i32 0, i32 0
  %1749 = load float, ptr %1748, align 4, !tbaa !11
  %1750 = load ptr, ptr %18, align 8, !tbaa !5
  %1751 = getelementptr inbounds %struct.complex, ptr %1750, i32 0, i32 1
  %1752 = load float, ptr %1751, align 4, !tbaa !14
  %1753 = load ptr, ptr %19, align 8, !tbaa !5
  %1754 = load i64, ptr %34, align 8, !tbaa !9
  %1755 = getelementptr inbounds %struct.complex, ptr %1753, i64 %1754
  %1756 = getelementptr inbounds %struct.complex, ptr %1755, i32 0, i32 1
  %1757 = load float, ptr %1756, align 4, !tbaa !14
  %1758 = fmul float %1752, %1757
  %1759 = fneg float %1758
  %1760 = call float @llvm.fmuladd.f32(float %1744, float %1749, float %1759)
  %1761 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1760, ptr %1761, align 4, !tbaa !11
  %1762 = load ptr, ptr %18, align 8, !tbaa !5
  %1763 = getelementptr inbounds %struct.complex, ptr %1762, i32 0, i32 0
  %1764 = load float, ptr %1763, align 4, !tbaa !11
  %1765 = load ptr, ptr %19, align 8, !tbaa !5
  %1766 = load i64, ptr %34, align 8, !tbaa !9
  %1767 = getelementptr inbounds %struct.complex, ptr %1765, i64 %1766
  %1768 = getelementptr inbounds %struct.complex, ptr %1767, i32 0, i32 1
  %1769 = load float, ptr %1768, align 4, !tbaa !14
  %1770 = load ptr, ptr %18, align 8, !tbaa !5
  %1771 = getelementptr inbounds %struct.complex, ptr %1770, i32 0, i32 1
  %1772 = load float, ptr %1771, align 4, !tbaa !14
  %1773 = load ptr, ptr %19, align 8, !tbaa !5
  %1774 = load i64, ptr %34, align 8, !tbaa !9
  %1775 = getelementptr inbounds %struct.complex, ptr %1773, i64 %1774
  %1776 = getelementptr inbounds %struct.complex, ptr %1775, i32 0, i32 0
  %1777 = load float, ptr %1776, align 4, !tbaa !11
  %1778 = fmul float %1772, %1777
  %1779 = call float @llvm.fmuladd.f32(float %1764, float %1769, float %1778)
  %1780 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1779, ptr %1780, align 4, !tbaa !14
  %1781 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1782 = load float, ptr %1781, align 4, !tbaa !11
  %1783 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  store float %1782, ptr %1783, align 4, !tbaa !11
  %1784 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1785 = load float, ptr %1784, align 4, !tbaa !14
  %1786 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  store float %1785, ptr %1786, align 4, !tbaa !14
  br label %1787

1787:                                             ; preds = %1736, %1695
  %1788 = load ptr, ptr %16, align 8, !tbaa !5
  %1789 = load i64, ptr %1788, align 8, !tbaa !9
  store i64 %1789, ptr %34, align 8, !tbaa !9
  store i64 1, ptr %44, align 8, !tbaa !9
  br label %1790

1790:                                             ; preds = %1875, %1787
  %1791 = load i64, ptr %44, align 8, !tbaa !9
  %1792 = load i64, ptr %34, align 8, !tbaa !9
  %1793 = icmp sle i64 %1791, %1792
  br i1 %1793, label %1794, label %1878

1794:                                             ; preds = %1790
  %1795 = load i64, ptr %44, align 8, !tbaa !9
  %1796 = load i64, ptr %45, align 8, !tbaa !9
  %1797 = load i64, ptr %30, align 8, !tbaa !9
  %1798 = mul nsw i64 %1796, %1797
  %1799 = add nsw i64 %1795, %1798
  store i64 %1799, ptr %35, align 8, !tbaa !9
  %1800 = load i64, ptr %44, align 8, !tbaa !9
  %1801 = load i64, ptr %45, align 8, !tbaa !9
  %1802 = load i64, ptr %30, align 8, !tbaa !9
  %1803 = mul nsw i64 %1801, %1802
  %1804 = add nsw i64 %1800, %1803
  store i64 %1804, ptr %36, align 8, !tbaa !9
  %1805 = load i64, ptr %44, align 8, !tbaa !9
  %1806 = load i64, ptr %46, align 8, !tbaa !9
  %1807 = load i64, ptr %28, align 8, !tbaa !9
  %1808 = mul nsw i64 %1806, %1807
  %1809 = add nsw i64 %1805, %1808
  store i64 %1809, ptr %37, align 8, !tbaa !9
  %1810 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1811 = load float, ptr %1810, align 4, !tbaa !11
  %1812 = load ptr, ptr %21, align 8, !tbaa !5
  %1813 = load i64, ptr %37, align 8, !tbaa !9
  %1814 = getelementptr inbounds %struct.complex, ptr %1812, i64 %1813
  %1815 = getelementptr inbounds %struct.complex, ptr %1814, i32 0, i32 0
  %1816 = load float, ptr %1815, align 4, !tbaa !11
  %1817 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1818 = load float, ptr %1817, align 4, !tbaa !14
  %1819 = load ptr, ptr %21, align 8, !tbaa !5
  %1820 = load i64, ptr %37, align 8, !tbaa !9
  %1821 = getelementptr inbounds %struct.complex, ptr %1819, i64 %1820
  %1822 = getelementptr inbounds %struct.complex, ptr %1821, i32 0, i32 1
  %1823 = load float, ptr %1822, align 4, !tbaa !14
  %1824 = fmul float %1818, %1823
  %1825 = fneg float %1824
  %1826 = call float @llvm.fmuladd.f32(float %1811, float %1816, float %1825)
  %1827 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  store float %1826, ptr %1827, align 4, !tbaa !11
  %1828 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 0
  %1829 = load float, ptr %1828, align 4, !tbaa !11
  %1830 = load ptr, ptr %21, align 8, !tbaa !5
  %1831 = load i64, ptr %37, align 8, !tbaa !9
  %1832 = getelementptr inbounds %struct.complex, ptr %1830, i64 %1831
  %1833 = getelementptr inbounds %struct.complex, ptr %1832, i32 0, i32 1
  %1834 = load float, ptr %1833, align 4, !tbaa !14
  %1835 = getelementptr inbounds %struct.complex, ptr %48, i32 0, i32 1
  %1836 = load float, ptr %1835, align 4, !tbaa !14
  %1837 = load ptr, ptr %21, align 8, !tbaa !5
  %1838 = load i64, ptr %37, align 8, !tbaa !9
  %1839 = getelementptr inbounds %struct.complex, ptr %1837, i64 %1838
  %1840 = getelementptr inbounds %struct.complex, ptr %1839, i32 0, i32 0
  %1841 = load float, ptr %1840, align 4, !tbaa !11
  %1842 = fmul float %1836, %1841
  %1843 = call float @llvm.fmuladd.f32(float %1829, float %1834, float %1842)
  %1844 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  store float %1843, ptr %1844, align 4, !tbaa !14
  %1845 = load ptr, ptr %24, align 8, !tbaa !5
  %1846 = load i64, ptr %36, align 8, !tbaa !9
  %1847 = getelementptr inbounds %struct.complex, ptr %1845, i64 %1846
  %1848 = getelementptr inbounds %struct.complex, ptr %1847, i32 0, i32 0
  %1849 = load float, ptr %1848, align 4, !tbaa !11
  %1850 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 0
  %1851 = load float, ptr %1850, align 4, !tbaa !11
  %1852 = fadd float %1849, %1851
  %1853 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  store float %1852, ptr %1853, align 4, !tbaa !11
  %1854 = load ptr, ptr %24, align 8, !tbaa !5
  %1855 = load i64, ptr %36, align 8, !tbaa !9
  %1856 = getelementptr inbounds %struct.complex, ptr %1854, i64 %1855
  %1857 = getelementptr inbounds %struct.complex, ptr %1856, i32 0, i32 1
  %1858 = load float, ptr %1857, align 4, !tbaa !14
  %1859 = getelementptr inbounds %struct.complex, ptr %40, i32 0, i32 1
  %1860 = load float, ptr %1859, align 4, !tbaa !14
  %1861 = fadd float %1858, %1860
  %1862 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  store float %1861, ptr %1862, align 4, !tbaa !14
  %1863 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 0
  %1864 = load float, ptr %1863, align 4, !tbaa !11
  %1865 = load ptr, ptr %24, align 8, !tbaa !5
  %1866 = load i64, ptr %35, align 8, !tbaa !9
  %1867 = getelementptr inbounds %struct.complex, ptr %1865, i64 %1866
  %1868 = getelementptr inbounds %struct.complex, ptr %1867, i32 0, i32 0
  store float %1864, ptr %1868, align 4, !tbaa !11
  %1869 = getelementptr inbounds %struct.complex, ptr %39, i32 0, i32 1
  %1870 = load float, ptr %1869, align 4, !tbaa !14
  %1871 = load ptr, ptr %24, align 8, !tbaa !5
  %1872 = load i64, ptr %35, align 8, !tbaa !9
  %1873 = getelementptr inbounds %struct.complex, ptr %1871, i64 %1872
  %1874 = getelementptr inbounds %struct.complex, ptr %1873, i32 0, i32 1
  store float %1870, ptr %1874, align 4, !tbaa !14
  br label %1875

1875:                                             ; preds = %1794
  %1876 = load i64, ptr %44, align 8, !tbaa !9
  %1877 = add nsw i64 %1876, 1
  store i64 %1877, ptr %44, align 8, !tbaa !9
  br label %1790, !llvm.loop !31

1878:                                             ; preds = %1790
  br label %1879

1879:                                             ; preds = %1878
  %1880 = load i64, ptr %46, align 8, !tbaa !9
  %1881 = add nsw i64 %1880, 1
  store i64 %1881, ptr %46, align 8, !tbaa !9
  br label %1688, !llvm.loop !32

1882:                                             ; preds = %1688
  br label %1883

1883:                                             ; preds = %1882
  %1884 = load i64, ptr %45, align 8, !tbaa !9
  %1885 = add nsw i64 %1884, 1
  store i64 %1885, ptr %45, align 8, !tbaa !9
  br label %1250, !llvm.loop !33

1886:                                             ; preds = %1250
  br label %1887

1887:                                             ; preds = %1886, %1246
  store i32 0, ptr %13, align 4
  store i32 1, ptr %52, align 4
  br label %1888

1888:                                             ; preds = %1887, %335, %194, %164
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #4
  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 4, 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
  %1889 = load i32, ptr %13, align 4
  ret i32 %1889
}

; 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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 = !{!13, !13, i64 0}
!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}
!33 = distinct !{!33, !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_chemm(ptr noundef %0, ptr noundef %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3, ptr nocapture noundef readonly %4, ptr noundef %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 %struct.complex, align 8
  %14 = alloca %struct.complex, align 8
  %15 = alloca i64, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %13) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %14) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %15) #5
  %16 = load i64, ptr %6, align 8, !tbaa !5
  %17 = xor i64 %16, -1
  %18 = getelementptr inbounds %struct.complex, ptr %5, i64 %17
  %19 = load i64, ptr %8, align 8, !tbaa !5
  %20 = xor i64 %19, -1
  %21 = getelementptr inbounds %struct.complex, ptr %7, i64 %20
  %22 = load i64, ptr %11, align 8, !tbaa !5
  %23 = xor i64 %22, -1
  %24 = getelementptr inbounds %struct.complex, ptr %10, i64 %23
  %25 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #5
  %.not = icmp eq i64 %25, 0
  %. = select i1 %.not, ptr %3, ptr %2
  %.0612 = load i64, ptr %., align 8, !tbaa !5
  %26 = tail call i64 @lsame_(ptr noundef %1, ptr noundef nonnull @.str.1) #5
  store i64 0, ptr %15, align 8, !tbaa !5
  %27 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #5
  %.not624 = icmp eq i64 %27, 0
  br i1 %.not624, label %28, label %31

28:                                               ; preds = %12
  %29 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str.2) #5
  %.not625 = icmp eq i64 %29, 0
  br i1 %.not625, label %30, label %31

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

31:                                               ; preds = %28, %12
  %.not626 = icmp eq i64 %26, 0
  br i1 %.not626, label %32, label %35

32:                                               ; preds = %31
  %33 = tail call i64 @lsame_(ptr noundef %1, ptr noundef nonnull @.str) #5
  %.not627 = icmp eq i64 %33, 0
  br i1 %.not627, label %34, label %35

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

35:                                               ; preds = %32, %31
  %36 = load i64, ptr %2, align 8, !tbaa !5
  %37 = icmp slt i64 %36, 0
  br i1 %37, label %38, label %39

38:                                               ; preds = %35
  store i64 3, ptr %15, align 8, !tbaa !5
  br label %.thread

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

42:                                               ; preds = %39
  store i64 4, ptr %15, align 8, !tbaa !5
  br label %.thread

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

47:                                               ; preds = %43
  store i64 7, ptr %15, align 8, !tbaa !5
  br label %.thread

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

51:                                               ; preds = %48
  store i64 9, ptr %15, align 8, !tbaa !5
  br label %.thread

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

55:                                               ; preds = %52
  store i64 12, ptr %15, align 8, !tbaa !5
  br label %.thread

.thread:                                          ; preds = %30, %38, %47, %55, %51, %42, %34
  %56 = call i32 @xerbla_(ptr noundef nonnull @.str.3, ptr noundef nonnull %15) #5
  br label %.loopexit

57:                                               ; preds = %52
  %58 = icmp eq i64 %36, 0
  %59 = icmp eq i64 %40, 0
  %or.cond = or i1 %58, %59
  br i1 %or.cond, label %.loopexit, label %60

60:                                               ; preds = %57
  %61 = load float, ptr %4, align 4, !tbaa !9
  %62 = fcmp oeq float %61, 0.000000e+00
  br i1 %62, label %63, label %133

63:                                               ; preds = %60
  %64 = getelementptr inbounds i8, ptr %4, i64 4
  %65 = load float, ptr %64, align 4, !tbaa !12
  %66 = fcmp oeq float %65, 0.000000e+00
  br i1 %66, label %67, label %133

67:                                               ; preds = %63
  %68 = load float, ptr %9, align 4, !tbaa !9
  %69 = fcmp oeq float %68, 1.000000e+00
  br i1 %69, label %70, label %74

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

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

74:                                               ; preds = %thread-pre-split, %67
  %75 = phi float [ %.pr, %thread-pre-split ], [ %68, %67 ]
  %76 = fcmp oeq float %75, 0.000000e+00
  br i1 %76, label %77, label %.preheader654.preheader

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

.preheader.preheader:                             ; preds = %77
  %81 = shl i64 %22, 3
  %82 = shl nuw i64 %36, 3
  %83 = add nsw i64 %40, -1
  %xtraiter1126 = and i64 %40, 7
  %84 = icmp ult i64 %83, 7
  br i1 %84, label %.loopexit.loopexit.unr-lcssa, label %.preheader.preheader.new

.preheader.preheader.new:                         ; preds = %.preheader.preheader
  %unroll_iter = and i64 %40, 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 ]
  %85 = mul i64 %81, %indvar
  %scevgep = getelementptr i8, ptr %10, i64 %85
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next = or disjoint i64 %indvar, 1
  %86 = mul i64 %81, %indvar.next
  %scevgep.1 = getelementptr i8, ptr %10, i64 %86
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.1, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.1 = or disjoint i64 %indvar, 2
  %87 = mul i64 %81, %indvar.next.1
  %scevgep.2 = getelementptr i8, ptr %10, i64 %87
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.2, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.2 = or disjoint i64 %indvar, 3
  %88 = mul i64 %81, %indvar.next.2
  %scevgep.3 = getelementptr i8, ptr %10, i64 %88
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.3, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.3 = or disjoint i64 %indvar, 4
  %89 = mul i64 %81, %indvar.next.3
  %scevgep.4 = getelementptr i8, ptr %10, i64 %89
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.4, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.4 = or disjoint i64 %indvar, 5
  %90 = mul i64 %81, %indvar.next.4
  %scevgep.5 = getelementptr i8, ptr %10, i64 %90
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.5, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.5 = or disjoint i64 %indvar, 6
  %91 = mul i64 %81, %indvar.next.5
  %scevgep.6 = getelementptr i8, ptr %10, i64 %91
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.6, i8 0, i64 %82, i1 false), !tbaa !13
  %indvar.next.6 = or disjoint i64 %indvar, 7
  %92 = mul i64 %81, %indvar.next.6
  %scevgep.7 = getelementptr i8, ptr %10, i64 %92
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.7, i8 0, i64 %82, 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

.preheader654.preheader:                          ; preds = %77, %74
  %93 = getelementptr i8, ptr %9, i64 4
  %94 = add nsw i64 %36, -1
  %95 = shl i64 %22, 3
  %96 = add nuw i64 %40, 2305843009213693951
  %97 = mul i64 %22, %96
  %98 = add i64 %97, %36
  %99 = shl i64 %98, 3
  %100 = getelementptr i8, ptr %10, i64 %99
  %scevgep1075 = getelementptr i8, ptr %100, i64 -4
  %scevgep1076 = getelementptr i8, ptr %10, i64 4
  %scevgep1077 = getelementptr i8, ptr %10, i64 %99
  %scevgep1078 = getelementptr i8, ptr %9, i64 8
  %min.iters.check1089 = icmp ult i64 %36, 8
  %mul.result1068 = shl i64 %94, 3
  %mul.result1072 = shl i64 %94, 3
  %mul.overflow1073 = icmp ugt i64 %94, 2305843009213693951
  %bound01079 = icmp ugt ptr %93, %10
  %bound11080 = icmp ugt ptr %scevgep1075, %9
  %found.conflict1081 = and i1 %bound01079, %bound11080
  %bound01082 = icmp ult ptr %scevgep1076, %scevgep1078
  %bound11083 = icmp ult ptr %93, %scevgep1077
  %found.conflict1084 = and i1 %bound01082, %bound11083
  %.mask = and i64 %22, 1152921504606846976
  %stride.check1085 = icmp ne i64 %.mask, 0
  %101 = or i1 %found.conflict1084, %stride.check1085
  %conflict.rdx1086 = or i1 %found.conflict1081, %101
  %n.vec1092 = and i64 %36, 4611686018427387900
  %ind.end1093 = or disjoint i64 %n.vec1092, 1
  %cmp.n1107 = icmp eq i64 %36, %n.vec1092
  br label %.preheader654

.preheader654:                                    ; preds = %.preheader654.preheader, %._crit_edge777
  %indvar1064 = phi i64 [ 0, %.preheader654.preheader ], [ %indvar.next1065, %._crit_edge777 ]
  %.1615781 = phi i64 [ 1, %.preheader654.preheader ], [ %132, %._crit_edge777 ]
  %102 = mul nsw i64 %.1615781, %22
  %invariant.gep778 = getelementptr %struct.complex, ptr %24, i64 %102
  br i1 %min.iters.check1089, label %scalar.ph1088.preheader, label %vector.scevcheck1063

vector.scevcheck1063:                             ; preds = %.preheader654
  %103 = mul i64 %95, %indvar1064
  %104 = or disjoint i64 %103, 4
  %scevgep1070 = getelementptr i8, ptr %10, i64 %104
  %scevgep1066 = getelementptr i8, ptr %10, i64 %103
  %105 = getelementptr i8, ptr %scevgep1066, i64 %mul.result1068
  %106 = icmp ult ptr %105, %scevgep1066
  %107 = getelementptr i8, ptr %scevgep1070, i64 %mul.result1072
  %108 = icmp ult ptr %107, %scevgep1070
  %109 = or i1 %108, %mul.overflow1073
  %110 = or i1 %106, %109
  %brmerge = select i1 %110, i1 true, i1 %conflict.rdx1086
  br i1 %brmerge, label %scalar.ph1088.preheader, label %vector.body1095

vector.body1095:                                  ; preds = %vector.scevcheck1063, %vector.body1095
  %index1096 = phi i64 [ %index.next1106, %vector.body1095 ], [ 0, %vector.scevcheck1063 ]
  %offset.idx1097 = or disjoint i64 %index1096, 1
  %111 = load float, ptr %9, align 4, !tbaa !9, !alias.scope !16
  %broadcast.splatinsert1103 = insertelement <4 x float> poison, float %111, i64 0
  %broadcast.splat1104 = shufflevector <4 x float> %broadcast.splatinsert1103, <4 x float> poison, <4 x i32> zeroinitializer
  %112 = getelementptr %struct.complex, ptr %invariant.gep778, i64 %offset.idx1097
  %wide.vec1098 = load <8 x float>, ptr %112, align 4, !tbaa !13
  %strided.vec1099 = shufflevector <8 x float> %wide.vec1098, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1100 = shufflevector <8 x float> %wide.vec1098, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %113 = load float, ptr %93, align 4, !tbaa !12, !alias.scope !19
  %broadcast.splatinsert1101 = insertelement <4 x float> poison, float %113, i64 0
  %broadcast.splat1102 = shufflevector <4 x float> %broadcast.splatinsert1101, <4 x float> poison, <4 x i32> zeroinitializer
  %114 = fneg <4 x float> %broadcast.splat1102
  %115 = fmul <4 x float> %strided.vec1100, %114
  %116 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1104, <4 x float> %strided.vec1099, <4 x float> %115)
  %117 = fmul <4 x float> %strided.vec1099, %broadcast.splat1102
  %118 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1104, <4 x float> %strided.vec1100, <4 x float> %117)
  %interleaved.vec1105 = shufflevector <4 x float> %116, <4 x float> %118, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1105, ptr %112, align 4, !tbaa !13
  %index.next1106 = add nuw i64 %index1096, 4
  %119 = icmp eq i64 %index.next1106, %n.vec1092
  br i1 %119, label %middle.block1087, label %vector.body1095, !llvm.loop !21

middle.block1087:                                 ; preds = %vector.body1095
  br i1 %cmp.n1107, label %._crit_edge777, label %scalar.ph1088.preheader

scalar.ph1088.preheader:                          ; preds = %vector.scevcheck1063, %middle.block1087, %.preheader654
  %.1619775.ph = phi i64 [ 1, %vector.scevcheck1063 ], [ 1, %.preheader654 ], [ %ind.end1093, %middle.block1087 ]
  br label %scalar.ph1088

scalar.ph1088:                                    ; preds = %scalar.ph1088.preheader, %scalar.ph1088
  %.1619775 = phi i64 [ %131, %scalar.ph1088 ], [ %.1619775.ph, %scalar.ph1088.preheader ]
  %120 = load float, ptr %9, align 4, !tbaa !9
  %gep779 = getelementptr %struct.complex, ptr %invariant.gep778, i64 %.1619775
  %121 = load float, ptr %93, align 4, !tbaa !12
  %122 = fneg float %121
  %123 = load <2 x float>, ptr %gep779, align 4, !tbaa !13
  %124 = insertelement <2 x float> poison, float %121, i64 0
  %125 = insertelement <2 x float> %124, float %122, i64 1
  %126 = fmul <2 x float> %123, %125
  %127 = shufflevector <2 x float> %126, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %128 = insertelement <2 x float> poison, float %120, i64 0
  %129 = shufflevector <2 x float> %128, <2 x float> poison, <2 x i32> zeroinitializer
  %130 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %129, <2 x float> %123, <2 x float> %127)
  store <2 x float> %130, ptr %gep779, align 4, !tbaa !13
  %131 = add nuw i64 %.1619775, 1
  %exitcond819.not = icmp eq i64 %.1619775, %36
  br i1 %exitcond819.not, label %._crit_edge777, label %scalar.ph1088, !llvm.loop !24

._crit_edge777:                                   ; preds = %scalar.ph1088, %middle.block1087
  %132 = add nuw i64 %.1615781, 1
  %exitcond820.not = icmp eq i64 %.1615781, %40
  %indvar.next1065 = add i64 %indvar1064, 1
  br i1 %exitcond820.not, label %.loopexit, label %.preheader654, !llvm.loop !25

133:                                              ; preds = %63, %60
  %134 = tail call i64 @lsame_(ptr noundef %0, ptr noundef nonnull @.str) #5
  %.not629 = icmp eq i64 %134, 0
  %135 = load i64, ptr %3, align 8, !tbaa !5
  %.not630770 = icmp slt i64 %135, 1
  br i1 %.not629, label %337, label %136

136:                                              ; preds = %133
  br i1 %.not626, label %236, label %137

137:                                              ; preds = %136
  br i1 %.not630770, label %.loopexit, label %.lr.ph685

.lr.ph685:                                        ; preds = %137
  %138 = getelementptr inbounds i8, ptr %4, i64 4
  %139 = getelementptr inbounds i8, ptr %9, i64 4
  %140 = add i64 %16, 1
  %141 = load i64, ptr %2, align 8, !tbaa !5
  %142 = icmp slt i64 %141, 1
  br i1 %142, label %.loopexit, label %.lr.ph685.split

.lr.ph685.splitthread-pre-split:                  ; preds = %._crit_edge675
  %143 = add nuw i64 %.2616683, 1
  %.pr837 = load i64, ptr %2, align 8, !tbaa !5
  br label %.lr.ph685.split

.lr.ph685.split:                                  ; preds = %.lr.ph685, %.lr.ph685.splitthread-pre-split
  %144 = phi i64 [ %.pr837, %.lr.ph685.splitthread-pre-split ], [ %141, %.lr.ph685 ]
  %.2616683 = phi i64 [ %143, %.lr.ph685.splitthread-pre-split ], [ 1, %.lr.ph685 ]
  %.not643671 = icmp slt i64 %144, 1
  br i1 %.not643671, label %._crit_edge675, label %.lr.ph674

.lr.ph674:                                        ; preds = %.lr.ph685.split
  %145 = mul nsw i64 %.2616683, %19
  %invariant.gep676 = getelementptr %struct.complex, ptr %21, i64 %145
  %146 = mul nsw i64 %.2616683, %22
  %invariant.gep669 = getelementptr %struct.complex, ptr %24, i64 %146
  br label %147

147:                                              ; preds = %.lr.ph674, %234
  %.2620672 = phi i64 [ 1, %.lr.ph674 ], [ %235, %234 ]
  %148 = load float, ptr %4, align 4, !tbaa !9
  %gep677 = getelementptr %struct.complex, ptr %invariant.gep676, i64 %.2620672
  %149 = load float, ptr %138, align 4, !tbaa !12
  %150 = fneg float %149
  %151 = load <2 x float>, ptr %gep677, align 4, !tbaa !13
  %152 = insertelement <2 x float> poison, float %149, i64 0
  %153 = insertelement <2 x float> %152, float %150, i64 1
  %154 = fmul <2 x float> %151, %153
  %155 = shufflevector <2 x float> %154, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %156 = insertelement <2 x float> poison, float %148, i64 0
  %157 = shufflevector <2 x float> %156, <2 x float> poison, <2 x i32> zeroinitializer
  %158 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %157, <2 x float> %151, <2 x float> %155)
  %.not644.not662 = icmp ugt i64 %.2620672, 1
  br i1 %.not644.not662, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %147
  %159 = mul nsw i64 %.2620672, %16
  %invariant.gep667 = getelementptr %struct.complex, ptr %18, i64 %159
  %160 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> zeroinitializer
  %161 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %162 = fneg <2 x float> %158
  %163 = shufflevector <2 x float> %161, <2 x float> %162, <2 x i32> <i32 0, i32 3>
  br label %164

164:                                              ; preds = %.lr.ph, %164
  %.0613663 = phi i64 [ 1, %.lr.ph ], [ %185, %164 ]
  %165 = phi <2 x float> [ zeroinitializer, %.lr.ph ], [ %184, %164 ]
  %gep668 = getelementptr %struct.complex, ptr %invariant.gep667, i64 %.0613663
  %gep670 = getelementptr %struct.complex, ptr %invariant.gep669, i64 %.0613663
  %166 = load <2 x float>, ptr %gep668, align 4, !tbaa !13
  %167 = fmul <2 x float> %166, %163
  %168 = shufflevector <2 x float> %167, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %169 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %160, <2 x float> %166, <2 x float> %168)
  %170 = load <2 x float>, ptr %gep670, align 4, !tbaa !13
  %171 = fadd <2 x float> %169, %170
  store <2 x float> %171, ptr %gep670, align 4, !tbaa !13
  call void @r_cnjg(ptr noundef nonnull %14, ptr noundef nonnull %gep668) #5
  %gep = getelementptr %struct.complex, ptr %invariant.gep676, i64 %.0613663
  %172 = load float, ptr %gep, align 4, !tbaa !9
  %173 = getelementptr inbounds i8, ptr %gep, i64 4
  %174 = load float, ptr %173, align 4, !tbaa !12
  %175 = fneg float %174
  %176 = load <2 x float>, ptr %14, align 8, !tbaa !13
  %177 = insertelement <2 x float> poison, float %174, i64 0
  %178 = insertelement <2 x float> %177, float %175, i64 1
  %179 = fmul <2 x float> %176, %178
  %180 = shufflevector <2 x float> %179, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %181 = insertelement <2 x float> poison, float %172, i64 0
  %182 = shufflevector <2 x float> %181, <2 x float> poison, <2 x i32> zeroinitializer
  %183 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %182, <2 x float> %176, <2 x float> %180)
  %184 = fadd <2 x float> %165, %183
  %185 = add nuw nsw i64 %.0613663, 1
  %exitcond.not = icmp eq i64 %185, %.2620672
  br i1 %exitcond.not, label %._crit_edge, label %164, !llvm.loop !26

._crit_edge:                                      ; preds = %164, %147
  %186 = phi <2 x float> [ zeroinitializer, %147 ], [ %184, %164 ]
  %187 = load float, ptr %9, align 4, !tbaa !9
  %188 = fcmp oeq float %187, 0.000000e+00
  %.pre = load float, ptr %139, align 4, !tbaa !12
  br i1 %188, label %190, label %._crit_edge._crit_edge

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

190:                                              ; preds = %._crit_edge
  %191 = fcmp oeq float %.pre, 0.000000e+00
  %192 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br i1 %191, label %193, label %208

193:                                              ; preds = %190
  %194 = mul i64 %.2620672, %140
  %195 = getelementptr inbounds %struct.complex, ptr %18, i64 %194
  %196 = load float, ptr %195, align 4, !tbaa !9
  %197 = shufflevector <2 x float> %192, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %198 = fneg <2 x float> %192
  %199 = shufflevector <2 x float> %197, <2 x float> %198, <2 x i32> <i32 0, i32 3>
  %200 = fmul <2 x float> %186, %199
  %201 = shufflevector <2 x float> %200, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %202 = shufflevector <2 x float> %192, <2 x float> poison, <2 x i32> zeroinitializer
  %203 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %202, <2 x float> %186, <2 x float> %201)
  store <2 x float> %203, ptr %14, align 8, !tbaa !13
  %gep681 = getelementptr %struct.complex, ptr %invariant.gep669, i64 %.2620672
  %204 = insertelement <2 x float> poison, float %196, i64 0
  %205 = shufflevector <2 x float> %204, <2 x float> poison, <2 x i32> zeroinitializer
  %206 = fmul <2 x float> %158, %205
  %207 = fadd <2 x float> %206, %203
  store <2 x float> %207, ptr %gep681, align 4, !tbaa !13
  br label %234

208:                                              ; preds = %._crit_edge._crit_edge, %190
  %209 = phi <2 x float> [ %189, %._crit_edge._crit_edge ], [ %192, %190 ]
  %gep679 = getelementptr %struct.complex, ptr %invariant.gep669, i64 %.2620672
  %210 = fneg float %.pre
  %211 = load <2 x float>, ptr %gep679, align 4, !tbaa !13
  %212 = insertelement <2 x float> poison, float %.pre, i64 0
  %213 = insertelement <2 x float> %212, float %210, i64 1
  %214 = fmul <2 x float> %211, %213
  %215 = shufflevector <2 x float> %214, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %216 = insertelement <2 x float> poison, float %187, i64 0
  %217 = shufflevector <2 x float> %216, <2 x float> poison, <2 x i32> zeroinitializer
  %218 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %217, <2 x float> %211, <2 x float> %215)
  store <2 x float> %218, ptr %14, align 8, !tbaa !13
  %219 = mul i64 %.2620672, %140
  %220 = getelementptr inbounds %struct.complex, ptr %18, i64 %219
  %221 = load float, ptr %220, align 4, !tbaa !9
  %222 = insertelement <2 x float> poison, float %221, i64 0
  %223 = shufflevector <2 x float> %222, <2 x float> poison, <2 x i32> zeroinitializer
  %224 = fmul <2 x float> %158, %223
  %225 = fadd <2 x float> %218, %224
  %226 = shufflevector <2 x float> %209, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %227 = fneg <2 x float> %209
  %228 = shufflevector <2 x float> %226, <2 x float> %227, <2 x i32> <i32 0, i32 3>
  %229 = fmul <2 x float> %186, %228
  %230 = shufflevector <2 x float> %229, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %231 = shufflevector <2 x float> %209, <2 x float> poison, <2 x i32> zeroinitializer
  %232 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %231, <2 x float> %186, <2 x float> %230)
  %233 = fadd <2 x float> %225, %232
  store <2 x float> %233, ptr %gep679, align 4, !tbaa !13
  br label %234

234:                                              ; preds = %193, %208
  %235 = add nuw i64 %.2620672, 1
  %exitcond810.not = icmp eq i64 %.2620672, %144
  br i1 %exitcond810.not, label %._crit_edge675, label %147, !llvm.loop !27

._crit_edge675:                                   ; preds = %234, %.lr.ph685.split
  %exitcond811.not = icmp eq i64 %.2616683, %135
  br i1 %exitcond811.not, label %.loopexit, label %.lr.ph685.splitthread-pre-split, !llvm.loop !28

236:                                              ; preds = %136
  br i1 %.not630770, label %.loopexit, label %.lr.ph714

.lr.ph714:                                        ; preds = %236
  %237 = getelementptr inbounds i8, ptr %4, i64 4
  %238 = getelementptr inbounds i8, ptr %9, i64 4
  %239 = add i64 %16, 1
  %240 = load i64, ptr %2, align 8, !tbaa !5
  %241 = icmp sgt i64 %240, 0
  br i1 %241, label %.lr.ph714.split, label %.loopexit

.lr.ph714.splitthread-pre-split:                  ; preds = %._crit_edge704
  %242 = add nuw i64 %.3617712, 1
  %.pr838 = load i64, ptr %2, align 8, !tbaa !5
  br label %.lr.ph714.split

.lr.ph714.split:                                  ; preds = %.lr.ph714, %.lr.ph714.splitthread-pre-split
  %243 = phi i64 [ %.pr838, %.lr.ph714.splitthread-pre-split ], [ %240, %.lr.ph714 ]
  %.3617712 = phi i64 [ %242, %.lr.ph714.splitthread-pre-split ], [ 1, %.lr.ph714 ]
  %244 = icmp sgt i64 %243, 0
  br i1 %244, label %.lr.ph703, label %._crit_edge704

.lr.ph703:                                        ; preds = %.lr.ph714.split
  %245 = mul nsw i64 %.3617712, %19
  %invariant.gep705 = getelementptr %struct.complex, ptr %21, i64 %245
  %246 = mul nsw i64 %.3617712, %22
  %invariant.gep699 = getelementptr %struct.complex, ptr %24, i64 %246
  br label %247

247:                                              ; preds = %.lr.ph703, %334
  %.3621701 = phi i64 [ %243, %.lr.ph703 ], [ %335, %334 ]
  %248 = load float, ptr %4, align 4, !tbaa !9
  %gep706 = getelementptr %struct.complex, ptr %invariant.gep705, i64 %.3621701
  %249 = load float, ptr %237, align 4, !tbaa !12
  %250 = fneg float %249
  %251 = load <2 x float>, ptr %gep706, align 4, !tbaa !13
  %252 = insertelement <2 x float> poison, float %249, i64 0
  %253 = insertelement <2 x float> %252, float %250, i64 1
  %254 = fmul <2 x float> %251, %253
  %255 = shufflevector <2 x float> %254, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %256 = insertelement <2 x float> poison, float %248, i64 0
  %257 = shufflevector <2 x float> %256, <2 x float> poison, <2 x i32> zeroinitializer
  %258 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %257, <2 x float> %251, <2 x float> %255)
  %259 = load i64, ptr %2, align 8, !tbaa !5
  %.not641.not688 = icmp slt i64 %.3621701, %259
  br i1 %.not641.not688, label %.lr.ph693, label %._crit_edge694

.lr.ph693:                                        ; preds = %247
  %260 = mul nsw i64 %.3621701, %16
  %invariant.gep697 = getelementptr %struct.complex, ptr %18, i64 %260
  %261 = shufflevector <2 x float> %258, <2 x float> poison, <2 x i32> zeroinitializer
  %262 = shufflevector <2 x float> %258, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %263 = fneg <2 x float> %258
  %264 = shufflevector <2 x float> %262, <2 x float> %263, <2 x i32> <i32 0, i32 3>
  br label %265

265:                                              ; preds = %.lr.ph693, %265
  %.1.in689 = phi i64 [ %.3621701, %.lr.ph693 ], [ %.1, %265 ]
  %266 = phi <2 x float> [ zeroinitializer, %.lr.ph693 ], [ %285, %265 ]
  %.1 = add nuw nsw i64 %.1.in689, 1
  %gep698 = getelementptr %struct.complex, ptr %invariant.gep697, i64 %.1
  %gep700 = getelementptr %struct.complex, ptr %invariant.gep699, i64 %.1
  %267 = load <2 x float>, ptr %gep698, align 4, !tbaa !13
  %268 = fmul <2 x float> %267, %264
  %269 = shufflevector <2 x float> %268, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %270 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %261, <2 x float> %267, <2 x float> %269)
  %271 = load <2 x float>, ptr %gep700, align 4, !tbaa !13
  %272 = fadd <2 x float> %270, %271
  store <2 x float> %272, ptr %gep700, align 4, !tbaa !13
  call void @r_cnjg(ptr noundef nonnull %14, ptr noundef nonnull %gep698) #5
  %gep687 = getelementptr %struct.complex, ptr %invariant.gep705, i64 %.1
  %273 = load float, ptr %gep687, align 4, !tbaa !9
  %274 = getelementptr inbounds i8, ptr %gep687, i64 4
  %275 = load float, ptr %274, align 4, !tbaa !12
  %276 = fneg float %275
  %277 = load <2 x float>, ptr %14, align 8, !tbaa !13
  %278 = insertelement <2 x float> poison, float %275, i64 0
  %279 = insertelement <2 x float> %278, float %276, i64 1
  %280 = fmul <2 x float> %277, %279
  %281 = shufflevector <2 x float> %280, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %282 = insertelement <2 x float> poison, float %273, i64 0
  %283 = shufflevector <2 x float> %282, <2 x float> poison, <2 x i32> zeroinitializer
  %284 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %283, <2 x float> %277, <2 x float> %281)
  %285 = fadd <2 x float> %266, %284
  %.not641.not = icmp slt i64 %.1, %259
  br i1 %.not641.not, label %265, label %._crit_edge694, !llvm.loop !30

._crit_edge694:                                   ; preds = %265, %247
  %286 = phi <2 x float> [ zeroinitializer, %247 ], [ %285, %265 ]
  %287 = load float, ptr %9, align 4, !tbaa !9
  %288 = fcmp oeq float %287, 0.000000e+00
  %.pre826 = load float, ptr %238, align 4, !tbaa !12
  br i1 %288, label %290, label %._crit_edge694._crit_edge

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

290:                                              ; preds = %._crit_edge694
  %291 = fcmp oeq float %.pre826, 0.000000e+00
  %292 = load <2 x float>, ptr %4, align 4, !tbaa !13
  br i1 %291, label %293, label %308

293:                                              ; preds = %290
  %294 = mul i64 %.3621701, %239
  %295 = getelementptr inbounds %struct.complex, ptr %18, i64 %294
  %296 = load float, ptr %295, align 4, !tbaa !9
  %297 = shufflevector <2 x float> %292, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %298 = fneg <2 x float> %292
  %299 = shufflevector <2 x float> %297, <2 x float> %298, <2 x i32> <i32 0, i32 3>
  %300 = fmul <2 x float> %286, %299
  %301 = shufflevector <2 x float> %300, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %302 = shufflevector <2 x float> %292, <2 x float> poison, <2 x i32> zeroinitializer
  %303 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %302, <2 x float> %286, <2 x float> %301)
  store <2 x float> %303, ptr %14, align 8, !tbaa !13
  %gep710 = getelementptr %struct.complex, ptr %invariant.gep699, i64 %.3621701
  %304 = insertelement <2 x float> poison, float %296, i64 0
  %305 = shufflevector <2 x float> %304, <2 x float> poison, <2 x i32> zeroinitializer
  %306 = fmul <2 x float> %258, %305
  %307 = fadd <2 x float> %306, %303
  store <2 x float> %307, ptr %gep710, align 4, !tbaa !13
  br label %334

308:                                              ; preds = %._crit_edge694._crit_edge, %290
  %309 = phi <2 x float> [ %289, %._crit_edge694._crit_edge ], [ %292, %290 ]
  %gep708 = getelementptr %struct.complex, ptr %invariant.gep699, i64 %.3621701
  %310 = fneg float %.pre826
  %311 = load <2 x float>, ptr %gep708, align 4, !tbaa !13
  %312 = insertelement <2 x float> poison, float %.pre826, i64 0
  %313 = insertelement <2 x float> %312, float %310, i64 1
  %314 = fmul <2 x float> %311, %313
  %315 = shufflevector <2 x float> %314, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %316 = insertelement <2 x float> poison, float %287, i64 0
  %317 = shufflevector <2 x float> %316, <2 x float> poison, <2 x i32> zeroinitializer
  %318 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %317, <2 x float> %311, <2 x float> %315)
  store <2 x float> %318, ptr %14, align 8, !tbaa !13
  %319 = mul i64 %.3621701, %239
  %320 = getelementptr inbounds %struct.complex, ptr %18, i64 %319
  %321 = load float, ptr %320, align 4, !tbaa !9
  %322 = insertelement <2 x float> poison, float %321, i64 0
  %323 = shufflevector <2 x float> %322, <2 x float> poison, <2 x i32> zeroinitializer
  %324 = fmul <2 x float> %258, %323
  %325 = fadd <2 x float> %318, %324
  %326 = shufflevector <2 x float> %309, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %327 = fneg <2 x float> %309
  %328 = shufflevector <2 x float> %326, <2 x float> %327, <2 x i32> <i32 0, i32 3>
  %329 = fmul <2 x float> %286, %328
  %330 = shufflevector <2 x float> %329, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %331 = shufflevector <2 x float> %309, <2 x float> poison, <2 x i32> zeroinitializer
  %332 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %331, <2 x float> %286, <2 x float> %330)
  %333 = fadd <2 x float> %325, %332
  store <2 x float> %333, ptr %gep708, align 4, !tbaa !13
  br label %334

334:                                              ; preds = %293, %308
  %335 = add nsw i64 %.3621701, -1
  %336 = icmp sgt i64 %.3621701, 1
  br i1 %336, label %247, label %._crit_edge704, !llvm.loop !31

._crit_edge704:                                   ; preds = %334, %.lr.ph714.split
  %exitcond812.not = icmp eq i64 %.3617712, %135
  br i1 %exitcond812.not, label %.loopexit, label %.lr.ph714.splitthread-pre-split, !llvm.loop !32

337:                                              ; preds = %133
  br i1 %.not630770, label %.loopexit, label %.lr.ph773

.lr.ph773:                                        ; preds = %337
  %338 = getelementptr inbounds i8, ptr %4, i64 4
  %339 = getelementptr i8, ptr %9, i64 4
  %340 = shl i64 %22, 3
  %341 = shl i64 %22, 3
  %342 = shl i64 %19, 3
  %343 = shl i64 %19, 3
  %344 = shl i64 %19, 3
  %345 = or disjoint i64 %342, 4
  %346 = shl i64 %22, 3
  %347 = shl i64 %22, 3
  %348 = shl i64 %19, 3
  %349 = shl i64 %22, 3
  %350 = shl i64 %19, 3
  %351 = shl i64 %22, 3
  %352 = shl i64 %22, 3
  %353 = shl i64 %19, 3
  %scevgep1015 = getelementptr i8, ptr %9, i64 8
  %invariant.gep1143 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1145 = getelementptr i8, ptr %7, i64 -4
  %invariant.gep1147 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1149 = getelementptr i8, ptr %7, i64 -4
  %invariant.gep1151 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep1153 = getelementptr i8, ptr %10, i64 -4
  %invariant.gep = getelementptr i8, ptr %7, i64 -4
  %354 = getelementptr i8, ptr %7, i64 %342
  %355 = getelementptr i8, ptr %7, i64 %342
  %356 = getelementptr i8, ptr %355, i64 -4
  %357 = getelementptr i8, ptr %7, i64 %345
  br label %358

.loopexit656:                                     ; preds = %625, %._crit_edge752
  %exitcond818.not = icmp eq i64 %.4771, %135
  %indvar.next872 = add i64 %indvar871, 1
  br i1 %exitcond818.not, label %.loopexit, label %358, !llvm.loop !33

358:                                              ; preds = %.lr.ph773, %.loopexit656
  %indvar871 = phi i64 [ 0, %.lr.ph773 ], [ %indvar.next872, %.loopexit656 ]
  %.4771 = phi i64 [ 1, %.lr.ph773 ], [ %556, %.loopexit656 ]
  %359 = mul i64 %352, %indvar871
  %scevgep1007 = getelementptr i8, ptr %10, i64 %359
  %gep1144 = getelementptr i8, ptr %invariant.gep1143, i64 %359
  %360 = mul i64 %353, %indvar871
  %scevgep1010 = getelementptr i8, ptr %7, i64 %360
  %gep1146 = getelementptr i8, ptr %invariant.gep1145, i64 %360
  %361 = or disjoint i64 %359, 4
  %scevgep1013 = getelementptr i8, ptr %10, i64 %361
  %362 = or disjoint i64 %360, 4
  %scevgep1016 = getelementptr i8, ptr %7, i64 %362
  %363 = mul i64 %351, %indvar871
  %scevgep998 = getelementptr i8, ptr %10, i64 %363
  %364 = or disjoint i64 %363, 4
  %scevgep1002 = getelementptr i8, ptr %10, i64 %364
  %365 = mul i64 %349, %indvar871
  %scevgep957 = getelementptr i8, ptr %10, i64 %365
  %gep1148 = getelementptr i8, ptr %invariant.gep1147, i64 %365
  %366 = mul i64 %350, %indvar871
  %scevgep960 = getelementptr i8, ptr %7, i64 %366
  %gep1150 = getelementptr i8, ptr %invariant.gep1149, i64 %366
  %367 = or disjoint i64 %365, 4
  %scevgep963 = getelementptr i8, ptr %10, i64 %367
  %368 = or disjoint i64 %366, 4
  %scevgep965 = getelementptr i8, ptr %7, i64 %368
  %369 = mul i64 %347, %indvar871
  %scevgep911 = getelementptr i8, ptr %10, i64 %369
  %gep1152 = getelementptr i8, ptr %invariant.gep1151, i64 %369
  %370 = or disjoint i64 %369, 4
  %scevgep919 = getelementptr i8, ptr %10, i64 %370
  %371 = mul i64 %346, %indvar871
  %scevgep902 = getelementptr i8, ptr %10, i64 %371
  %372 = or disjoint i64 %371, 4
  %scevgep906 = getelementptr i8, ptr %10, i64 %372
  %373 = mul i64 %341, %indvar871
  %scevgep878 = getelementptr i8, ptr %10, i64 %373
  %gep1154 = getelementptr i8, ptr %invariant.gep1153, i64 %373
  %374 = mul i64 %343, %indvar871
  %375 = or disjoint i64 %373, 4
  %scevgep886 = getelementptr i8, ptr %10, i64 %375
  %376 = mul i64 %340, %indvar871
  %scevgep873 = getelementptr i8, ptr %10, i64 %376
  %377 = or disjoint i64 %376, 4
  %scevgep874 = getelementptr i8, ptr %10, i64 %377
  %378 = mul nsw i64 %.4771, %16
  %379 = getelementptr %struct.complex, ptr %18, i64 %.4771
  %380 = getelementptr %struct.complex, ptr %379, i64 %378
  %381 = load float, ptr %380, align 4, !tbaa !9
  %382 = load float, ptr %4, align 4, !tbaa !9
  %383 = fmul float %381, %382
  %384 = load float, ptr %338, align 4, !tbaa !12
  %385 = fmul float %381, %384
  %386 = load float, ptr %9, align 4, !tbaa !9
  %387 = fcmp oeq float %386, 0.000000e+00
  br i1 %387, label %388, label %._crit_edge831

._crit_edge831:                                   ; preds = %358
  %.pre832 = load i64, ptr %2, align 8, !tbaa !5
  br label %431

388:                                              ; preds = %358
  %389 = load float, ptr %339, align 4, !tbaa !12
  %390 = fcmp oeq float %389, 0.000000e+00
  %.pre833 = load i64, ptr %2, align 8, !tbaa !5
  br i1 %390, label %391, label %431

391:                                              ; preds = %388
  %.not632727 = icmp slt i64 %.pre833, 1
  br i1 %.not632727, label %.loopexit657, label %.lr.ph730

.lr.ph730:                                        ; preds = %391
  %392 = mul nsw i64 %.4771, %22
  %393 = mul nsw i64 %.4771, %19
  %invariant.gep731 = getelementptr %struct.complex, ptr %21, i64 %393
  %394 = fneg float %385
  %invariant.gep733 = getelementptr %struct.complex, ptr %24, i64 %392
  %min.iters.check976 = icmp ult i64 %.pre833, 4
  br i1 %min.iters.check976, label %scalar.ph975.preheader, label %vector.memcheck956

vector.memcheck956:                               ; preds = %.lr.ph730
  %395 = shl i64 %.pre833, 3
  %scevgep959 = getelementptr i8, ptr %gep1148, i64 %395
  %scevgep962 = getelementptr i8, ptr %gep1150, i64 %395
  %scevgep964 = getelementptr i8, ptr %scevgep957, i64 %395
  %scevgep966 = getelementptr i8, ptr %scevgep960, i64 %395
  %bound0967 = icmp ult ptr %scevgep957, %scevgep962
  %bound1968 = icmp ult ptr %scevgep960, %scevgep959
  %found.conflict969 = and i1 %bound0967, %bound1968
  %bound0970 = icmp ult ptr %scevgep963, %scevgep966
  %bound1971 = icmp ult ptr %scevgep965, %scevgep964
  %found.conflict972 = and i1 %bound0970, %bound1971
  %conflict.rdx973 = or i1 %found.conflict969, %found.conflict972
  br i1 %conflict.rdx973, label %scalar.ph975.preheader, label %vector.ph977

vector.ph977:                                     ; preds = %vector.memcheck956
  %n.vec979 = and i64 %.pre833, 9223372036854775804
  %ind.end980 = or disjoint i64 %n.vec979, 1
  %broadcast.splatinsert988 = insertelement <4 x float> poison, float %394, i64 0
  %broadcast.splat989 = shufflevector <4 x float> %broadcast.splatinsert988, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert990 = insertelement <4 x float> poison, float %383, i64 0
  %broadcast.splat991 = shufflevector <4 x float> %broadcast.splatinsert990, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert992 = insertelement <4 x float> poison, float %385, i64 0
  %broadcast.splat993 = shufflevector <4 x float> %broadcast.splatinsert992, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body982

vector.body982:                                   ; preds = %vector.body982, %vector.ph977
  %index983 = phi i64 [ 0, %vector.ph977 ], [ %index.next995, %vector.body982 ]
  %offset.idx984 = or disjoint i64 %index983, 1
  %396 = getelementptr %struct.complex, ptr %invariant.gep731, i64 %offset.idx984
  %wide.vec985 = load <8 x float>, ptr %396, align 4, !tbaa !13
  %strided.vec986 = shufflevector <8 x float> %wide.vec985, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec987 = shufflevector <8 x float> %wide.vec985, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %397 = fmul <4 x float> %strided.vec987, %broadcast.splat989
  %398 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat991, <4 x float> %strided.vec986, <4 x float> %397)
  %399 = fmul <4 x float> %broadcast.splat993, %strided.vec986
  %400 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat991, <4 x float> %strided.vec987, <4 x float> %399)
  %401 = getelementptr %struct.complex, ptr %invariant.gep733, i64 %offset.idx984
  %interleaved.vec994 = shufflevector <4 x float> %398, <4 x float> %400, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec994, ptr %401, align 4, !tbaa !13
  %index.next995 = add nuw i64 %index983, 4
  %402 = icmp eq i64 %index.next995, %n.vec979
  br i1 %402, label %middle.block974, label %vector.body982, !llvm.loop !34

middle.block974:                                  ; preds = %vector.body982
  %cmp.n996 = icmp eq i64 %.pre833, %n.vec979
  br i1 %cmp.n996, label %.loopexit657, label %scalar.ph975.preheader

scalar.ph975.preheader:                           ; preds = %middle.block974, %vector.memcheck956, %.lr.ph730
  %.4622728.ph = phi i64 [ 1, %vector.memcheck956 ], [ 1, %.lr.ph730 ], [ %ind.end980, %middle.block974 ]
  %xtraiter = and i64 %.pre833, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph975.prol.loopexit, label %scalar.ph975.prol

scalar.ph975.prol:                                ; preds = %scalar.ph975.preheader
  %gep732.prol = getelementptr %struct.complex, ptr %invariant.gep731, i64 %.4622728.ph
  %gep734.prol = getelementptr %struct.complex, ptr %invariant.gep733, i64 %.4622728.ph
  %403 = load <2 x float>, ptr %gep732.prol, align 4, !tbaa !13
  %404 = insertelement <2 x float> poison, float %385, i64 0
  %405 = insertelement <2 x float> %404, float %394, i64 1
  %406 = fmul <2 x float> %403, %405
  %407 = shufflevector <2 x float> %406, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %408 = insertelement <2 x float> poison, float %383, i64 0
  %409 = shufflevector <2 x float> %408, <2 x float> poison, <2 x i32> zeroinitializer
  %410 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %409, <2 x float> %403, <2 x float> %407)
  store <2 x float> %410, ptr %gep734.prol, align 4, !tbaa !13
  %411 = add nuw i64 %.4622728.ph, 1
  br label %scalar.ph975.prol.loopexit

scalar.ph975.prol.loopexit:                       ; preds = %scalar.ph975.prol, %scalar.ph975.preheader
  %.4622728.unr = phi i64 [ %.4622728.ph, %scalar.ph975.preheader ], [ %411, %scalar.ph975.prol ]
  %412 = icmp eq i64 %.pre833, %.4622728.ph
  br i1 %412, label %.loopexit657, label %scalar.ph975.preheader.new

scalar.ph975.preheader.new:                       ; preds = %scalar.ph975.prol.loopexit
  %413 = insertelement <2 x float> poison, float %385, i64 0
  %414 = insertelement <2 x float> %413, float %394, i64 1
  %415 = insertelement <2 x float> poison, float %383, i64 0
  %416 = shufflevector <2 x float> %415, <2 x float> poison, <2 x i32> zeroinitializer
  %417 = insertelement <2 x float> poison, float %385, i64 0
  %418 = insertelement <2 x float> %417, float %394, i64 1
  %419 = insertelement <2 x float> poison, float %383, i64 0
  %420 = shufflevector <2 x float> %419, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph975

scalar.ph975:                                     ; preds = %scalar.ph975, %scalar.ph975.preheader.new
  %.4622728 = phi i64 [ %.4622728.unr, %scalar.ph975.preheader.new ], [ %430, %scalar.ph975 ]
  %gep732 = getelementptr %struct.complex, ptr %invariant.gep731, i64 %.4622728
  %gep734 = getelementptr %struct.complex, ptr %invariant.gep733, i64 %.4622728
  %421 = load <2 x float>, ptr %gep732, align 4, !tbaa !13
  %422 = fmul <2 x float> %421, %414
  %423 = shufflevector <2 x float> %422, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %424 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %416, <2 x float> %421, <2 x float> %423)
  store <2 x float> %424, ptr %gep734, align 4, !tbaa !13
  %425 = add nuw i64 %.4622728, 1
  %gep732.1 = getelementptr %struct.complex, ptr %invariant.gep731, i64 %425
  %gep734.1 = getelementptr %struct.complex, ptr %invariant.gep733, i64 %425
  %426 = load <2 x float>, ptr %gep732.1, align 4, !tbaa !13
  %427 = fmul <2 x float> %426, %418
  %428 = shufflevector <2 x float> %427, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %429 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %420, <2 x float> %426, <2 x float> %428)
  store <2 x float> %429, ptr %gep734.1, align 4, !tbaa !13
  %430 = add nuw i64 %.4622728, 2
  %exitcond814.not.1 = icmp eq i64 %425, %.pre833
  br i1 %exitcond814.not.1, label %.loopexit657, label %scalar.ph975, !llvm.loop !35

431:                                              ; preds = %._crit_edge831, %388
  %432 = phi i64 [ %.pre832, %._crit_edge831 ], [ %.pre833, %388 ]
  %.promoted = load float, ptr %14, align 8, !tbaa !9
  %.not631715 = icmp slt i64 %432, 1
  br i1 %.not631715, label %.loopexit658, label %.lr.ph718

.lr.ph718:                                        ; preds = %431
  %433 = mul nsw i64 %.4771, %22
  %invariant.gep720 = getelementptr %struct.complex, ptr %24, i64 %433
  %434 = mul nsw i64 %.4771, %19
  %invariant.gep722 = getelementptr %struct.complex, ptr %21, i64 %434
  %435 = fneg float %385
  %min.iters.check1035 = icmp ult i64 %432, 8
  br i1 %min.iters.check1035, label %scalar.ph1034.preheader, label %vector.scevcheck997

vector.scevcheck997:                              ; preds = %.lr.ph718
  %436 = add nsw i64 %432, -1
  %mul.result1000 = shl i64 %436, 3
  %437 = getelementptr i8, ptr %scevgep998, i64 %mul.result1000
  %438 = icmp ult ptr %437, %scevgep998
  %mul.result1004 = shl i64 %436, 3
  %mul.overflow1005 = icmp ugt i64 %436, 2305843009213693951
  %439 = getelementptr i8, ptr %scevgep1002, i64 %mul.result1004
  %440 = icmp ult ptr %439, %scevgep1002
  %441 = or i1 %440, %mul.overflow1005
  %442 = or i1 %438, %441
  br i1 %442, label %scalar.ph1034.preheader, label %vector.memcheck1006

vector.memcheck1006:                              ; preds = %vector.scevcheck997
  %443 = shl i64 %432, 3
  %scevgep1009 = getelementptr i8, ptr %gep1144, i64 %443
  %scevgep1012 = getelementptr i8, ptr %gep1146, i64 %443
  %scevgep1014 = getelementptr i8, ptr %scevgep1007, i64 %443
  %scevgep1017 = getelementptr i8, ptr %scevgep1010, i64 %443
  %bound01018 = icmp ult ptr %scevgep1007, %339
  %bound11019 = icmp ugt ptr %scevgep1009, %9
  %found.conflict1020 = and i1 %bound01018, %bound11019
  %bound01021 = icmp ult ptr %scevgep1007, %scevgep1012
  %bound11022 = icmp ult ptr %scevgep1010, %scevgep1009
  %found.conflict1023 = and i1 %bound01021, %bound11022
  %conflict.rdx1024 = or i1 %found.conflict1020, %found.conflict1023
  %bound01025 = icmp ult ptr %scevgep1013, %scevgep1015
  %bound11026 = icmp ult ptr %339, %scevgep1014
  %found.conflict1027 = and i1 %bound01025, %bound11026
  %conflict.rdx1028 = or i1 %conflict.rdx1024, %found.conflict1027
  %bound01029 = icmp ult ptr %scevgep1013, %scevgep1017
  %bound11030 = icmp ult ptr %scevgep1016, %scevgep1014
  %found.conflict1031 = and i1 %bound01029, %bound11030
  %conflict.rdx1032 = or i1 %conflict.rdx1028, %found.conflict1031
  br i1 %conflict.rdx1032, label %scalar.ph1034.preheader, label %vector.ph1036

vector.ph1036:                                    ; preds = %vector.memcheck1006
  %n.vec1038 = and i64 %432, 4611686018427387900
  %ind.end1039 = or disjoint i64 %n.vec1038, 1
  %broadcast.splatinsert1054 = insertelement <4 x float> poison, float %435, i64 0
  %broadcast.splat1055 = shufflevector <4 x float> %broadcast.splatinsert1054, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1056 = insertelement <4 x float> poison, float %383, i64 0
  %broadcast.splat1057 = shufflevector <4 x float> %broadcast.splatinsert1056, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splatinsert1058 = insertelement <4 x float> poison, float %385, i64 0
  %broadcast.splat1059 = shufflevector <4 x float> %broadcast.splatinsert1058, <4 x float> poison, <4 x i32> zeroinitializer
  br label %vector.body1041

vector.body1041:                                  ; preds = %vector.body1041, %vector.ph1036
  %index1042 = phi i64 [ 0, %vector.ph1036 ], [ %index.next1061, %vector.body1041 ]
  %offset.idx1043 = or disjoint i64 %index1042, 1
  %444 = load float, ptr %9, align 4, !tbaa !9, !alias.scope !36
  %broadcast.splatinsert1049 = insertelement <4 x float> poison, float %444, i64 0
  %broadcast.splat1050 = shufflevector <4 x float> %broadcast.splatinsert1049, <4 x float> poison, <4 x i32> zeroinitializer
  %445 = getelementptr %struct.complex, ptr %invariant.gep720, i64 %offset.idx1043
  %wide.vec1044 = load <8 x float>, ptr %445, align 4, !tbaa !13
  %strided.vec1045 = shufflevector <8 x float> %wide.vec1044, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1046 = shufflevector <8 x float> %wide.vec1044, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %446 = load float, ptr %339, align 4, !tbaa !12, !alias.scope !39
  %broadcast.splatinsert1047 = insertelement <4 x float> poison, float %446, i64 0
  %broadcast.splat1048 = shufflevector <4 x float> %broadcast.splatinsert1047, <4 x float> poison, <4 x i32> zeroinitializer
  %447 = fneg <4 x float> %broadcast.splat1048
  %448 = fmul <4 x float> %strided.vec1046, %447
  %449 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1050, <4 x float> %strided.vec1045, <4 x float> %448)
  %450 = fmul <4 x float> %strided.vec1045, %broadcast.splat1048
  %451 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1050, <4 x float> %strided.vec1046, <4 x float> %450)
  %452 = getelementptr %struct.complex, ptr %invariant.gep722, i64 %offset.idx1043
  %wide.vec1051 = load <8 x float>, ptr %452, align 4, !tbaa !13
  %strided.vec1052 = shufflevector <8 x float> %wide.vec1051, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec1053 = shufflevector <8 x float> %wide.vec1051, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %453 = fmul <4 x float> %strided.vec1053, %broadcast.splat1055
  %454 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1057, <4 x float> %strided.vec1052, <4 x float> %453)
  %455 = fmul <4 x float> %broadcast.splat1059, %strided.vec1052
  %456 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat1057, <4 x float> %strided.vec1053, <4 x float> %455)
  %457 = fadd <4 x float> %449, %454
  %458 = fadd <4 x float> %451, %456
  %interleaved.vec1060 = shufflevector <4 x float> %457, <4 x float> %458, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec1060, ptr %445, align 4, !tbaa !13
  %index.next1061 = add nuw i64 %index1042, 4
  %459 = icmp eq i64 %index.next1061, %n.vec1038
  br i1 %459, label %middle.block1033, label %vector.body1041, !llvm.loop !41

middle.block1033:                                 ; preds = %vector.body1041
  %460 = extractelement <4 x float> %454, i64 3
  %cmp.n1062 = icmp eq i64 %432, %n.vec1038
  %461 = shufflevector <4 x float> %449, <4 x float> %451, <2 x i32> <i32 3, i32 7>
  br i1 %cmp.n1062, label %..loopexit658_crit_edge, label %scalar.ph1034.preheader

scalar.ph1034.preheader:                          ; preds = %middle.block1033, %vector.memcheck1006, %vector.scevcheck997, %.lr.ph718
  %.5716.ph = phi i64 [ 1, %vector.memcheck1006 ], [ 1, %vector.scevcheck997 ], [ 1, %.lr.ph718 ], [ %ind.end1039, %middle.block1033 ]
  %462 = insertelement <2 x float> poison, float %385, i64 0
  %463 = insertelement <2 x float> %462, float %435, i64 1
  %464 = insertelement <2 x float> poison, float %383, i64 0
  %465 = shufflevector <2 x float> %464, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph1034

scalar.ph1034:                                    ; preds = %scalar.ph1034.preheader, %scalar.ph1034
  %.5716 = phi i64 [ %482, %scalar.ph1034 ], [ %.5716.ph, %scalar.ph1034.preheader ]
  %466 = load float, ptr %9, align 4, !tbaa !9
  %gep721 = getelementptr %struct.complex, ptr %invariant.gep720, i64 %.5716
  %467 = load float, ptr %339, align 4, !tbaa !12
  %468 = fneg float %467
  %469 = load <2 x float>, ptr %gep721, align 4, !tbaa !13
  %470 = insertelement <2 x float> poison, float %467, i64 0
  %471 = insertelement <2 x float> %470, float %468, i64 1
  %472 = fmul <2 x float> %469, %471
  %473 = shufflevector <2 x float> %472, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %474 = insertelement <2 x float> poison, float %466, i64 0
  %475 = shufflevector <2 x float> %474, <2 x float> poison, <2 x i32> zeroinitializer
  %476 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %475, <2 x float> %469, <2 x float> %473)
  %gep723 = getelementptr %struct.complex, ptr %invariant.gep722, i64 %.5716
  %477 = load <2 x float>, ptr %gep723, align 4, !tbaa !13
  %478 = fmul <2 x float> %477, %463
  %479 = shufflevector <2 x float> %478, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %480 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %465, <2 x float> %477, <2 x float> %479)
  %481 = fadd <2 x float> %476, %480
  store <2 x float> %481, ptr %gep721, align 4, !tbaa !13
  %482 = add nuw i64 %.5716, 1
  %exitcond813.not = icmp eq i64 %.5716, %432
  br i1 %exitcond813.not, label %..loopexit658_crit_edge.loopexit, label %scalar.ph1034, !llvm.loop !42

..loopexit658_crit_edge.loopexit:                 ; preds = %scalar.ph1034
  %483 = extractelement <2 x float> %480, i64 0
  br label %..loopexit658_crit_edge

..loopexit658_crit_edge:                          ; preds = %..loopexit658_crit_edge.loopexit, %middle.block1033
  %.lcssa859 = phi float [ %460, %middle.block1033 ], [ %483, %..loopexit658_crit_edge.loopexit ]
  %484 = phi <2 x float> [ %461, %middle.block1033 ], [ %476, %..loopexit658_crit_edge.loopexit ]
  store <2 x float> %484, ptr %13, align 8, !tbaa !13
  br label %.loopexit658

.loopexit658:                                     ; preds = %..loopexit658_crit_edge, %431
  %.lcssa = phi float [ %.lcssa859, %..loopexit658_crit_edge ], [ %.promoted, %431 ]
  store float %.lcssa, ptr %14, align 8, !tbaa !9
  br label %.loopexit657

.loopexit657:                                     ; preds = %scalar.ph975.prol.loopexit, %scalar.ph975, %middle.block974, %391, %.loopexit658
  %485 = phi i64 [ %.pre833, %391 ], [ %432, %.loopexit658 ], [ %.pre833, %middle.block974 ], [ %.pre833, %scalar.ph975 ], [ %.pre833, %scalar.ph975.prol.loopexit ]
  %invariant.gep746 = getelementptr %struct.complex, ptr %18, i64 %378
  %.not633.not748 = icmp ugt i64 %.4771, 1
  br i1 %.not633.not748, label %.lr.ph751, label %._crit_edge752

.lr.ph751:                                        ; preds = %.loopexit657
  %486 = mul nsw i64 %.4771, %22
  %invariant.gep742 = getelementptr %struct.complex, ptr %24, i64 %486
  br label %487

487:                                              ; preds = %.lr.ph751, %552
  %indvar914 = phi i64 [ 0, %.lr.ph751 ], [ %indvar.next915, %552 ]
  %488 = phi i64 [ %485, %.lr.ph751 ], [ %518, %552 ]
  %.2749 = phi i64 [ 1, %.lr.ph751 ], [ %553, %552 ]
  %489 = mul i64 %348, %indvar914
  %scevgep916 = getelementptr i8, ptr %7, i64 %489
  %gep1142 = getelementptr i8, ptr %invariant.gep, i64 %489
  %490 = or disjoint i64 %489, 4
  %scevgep921 = getelementptr i8, ptr %7, i64 %490
  br i1 %.not626, label %503, label %491

491:                                              ; preds = %487
  %492 = load float, ptr %4, align 4, !tbaa !9
  %gep747 = getelementptr %struct.complex, ptr %invariant.gep746, i64 %.2749
  %493 = load float, ptr %338, align 4, !tbaa !12
  %494 = fneg float %493
  %495 = load <2 x float>, ptr %gep747, align 4, !tbaa !13
  %496 = insertelement <2 x float> poison, float %493, i64 0
  %497 = insertelement <2 x float> %496, float %494, i64 1
  %498 = fmul <2 x float> %495, %497
  %499 = shufflevector <2 x float> %498, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %500 = insertelement <2 x float> poison, float %492, i64 0
  %501 = shufflevector <2 x float> %500, <2 x float> poison, <2 x i32> zeroinitializer
  %502 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %501, <2 x float> %495, <2 x float> %499)
  br label %517

503:                                              ; preds = %487
  %504 = mul nsw i64 %.2749, %16
  %505 = getelementptr %struct.complex, ptr %379, i64 %504
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef %505) #5
  %506 = load float, ptr %4, align 4, !tbaa !9
  %507 = load float, ptr %338, align 4, !tbaa !12
  %508 = fneg float %507
  %509 = load <2 x float>, ptr %13, align 8, !tbaa !13
  %510 = insertelement <2 x float> poison, float %507, i64 0
  %511 = insertelement <2 x float> %510, float %508, i64 1
  %512 = fmul <2 x float> %509, %511
  %513 = shufflevector <2 x float> %512, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %514 = insertelement <2 x float> poison, float %506, i64 0
  %515 = shufflevector <2 x float> %514, <2 x float> poison, <2 x i32> zeroinitializer
  %516 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %515, <2 x float> %509, <2 x float> %513)
  %.pre834 = load i64, ptr %2, align 8, !tbaa !5
  br label %517

517:                                              ; preds = %503, %491
  %518 = phi i64 [ %488, %491 ], [ %.pre834, %503 ]
  %519 = phi <2 x float> [ %502, %491 ], [ %516, %503 ]
  %.not638735 = icmp slt i64 %518, 1
  br i1 %.not638735, label %552, label %.lr.ph738

.lr.ph738:                                        ; preds = %517
  %520 = mul nsw i64 %.2749, %19
  %invariant.gep740 = getelementptr %struct.complex, ptr %21, i64 %520
  %521 = extractelement <2 x float> %519, i64 1
  %522 = fneg float %521
  %min.iters.check932 = icmp ult i64 %518, 8
  br i1 %min.iters.check932, label %scalar.ph931.preheader, label %vector.scevcheck901

vector.scevcheck901:                              ; preds = %.lr.ph738
  %523 = add nsw i64 %518, -1
  %mul.result904 = shl i64 %523, 3
  %524 = getelementptr i8, ptr %scevgep902, i64 %mul.result904
  %525 = icmp ult ptr %524, %scevgep902
  %mul.result908 = shl i64 %523, 3
  %mul.overflow909 = icmp ugt i64 %523, 2305843009213693951
  %526 = getelementptr i8, ptr %scevgep906, i64 %mul.result908
  %527 = icmp ult ptr %526, %scevgep906
  %528 = or i1 %527, %mul.overflow909
  %529 = or i1 %525, %528
  br i1 %529, label %scalar.ph931.preheader, label %vector.memcheck910

vector.memcheck910:                               ; preds = %vector.scevcheck901
  %530 = shl i64 %518, 3
  %scevgep913 = getelementptr i8, ptr %gep1152, i64 %530
  %scevgep918 = getelementptr i8, ptr %gep1142, i64 %530
  %scevgep920 = getelementptr i8, ptr %scevgep911, i64 %530
  %scevgep922 = getelementptr i8, ptr %scevgep916, i64 %530
  %bound0923 = icmp ult ptr %scevgep911, %scevgep918
  %bound1924 = icmp ult ptr %scevgep916, %scevgep913
  %found.conflict925 = and i1 %bound0923, %bound1924
  %bound0926 = icmp ult ptr %scevgep919, %scevgep922
  %bound1927 = icmp ult ptr %scevgep921, %scevgep920
  %found.conflict928 = and i1 %bound0926, %bound1927
  %conflict.rdx929 = or i1 %found.conflict925, %found.conflict928
  br i1 %conflict.rdx929, label %scalar.ph931.preheader, label %vector.ph933

vector.ph933:                                     ; preds = %vector.memcheck910
  %n.vec935 = and i64 %518, 4611686018427387900
  %ind.end936 = or disjoint i64 %n.vec935, 1
  %broadcast.splatinsert944 = insertelement <4 x float> poison, float %522, i64 0
  %broadcast.splat945 = shufflevector <4 x float> %broadcast.splatinsert944, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splat947 = shufflevector <2 x float> %519, <2 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splat949 = shufflevector <2 x float> %519, <2 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
  br label %vector.body938

vector.body938:                                   ; preds = %vector.body938, %vector.ph933
  %index939 = phi i64 [ 0, %vector.ph933 ], [ %index.next954, %vector.body938 ]
  %offset.idx940 = or disjoint i64 %index939, 1
  %531 = getelementptr %struct.complex, ptr %invariant.gep740, i64 %offset.idx940
  %wide.vec941 = load <8 x float>, ptr %531, align 4, !tbaa !13
  %strided.vec942 = shufflevector <8 x float> %wide.vec941, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec943 = shufflevector <8 x float> %wide.vec941, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %532 = fmul <4 x float> %strided.vec943, %broadcast.splat945
  %533 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat947, <4 x float> %strided.vec942, <4 x float> %532)
  %534 = fmul <4 x float> %broadcast.splat949, %strided.vec942
  %535 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat947, <4 x float> %strided.vec943, <4 x float> %534)
  %536 = getelementptr %struct.complex, ptr %invariant.gep742, i64 %offset.idx940
  %wide.vec950 = load <8 x float>, ptr %536, align 4, !tbaa !13
  %strided.vec951 = shufflevector <8 x float> %wide.vec950, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec952 = shufflevector <8 x float> %wide.vec950, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %537 = fadd <4 x float> %533, %strided.vec951
  %538 = fadd <4 x float> %535, %strided.vec952
  %interleaved.vec953 = shufflevector <4 x float> %537, <4 x float> %538, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
  store <8 x float> %interleaved.vec953, ptr %536, align 4, !tbaa !13
  %index.next954 = add nuw i64 %index939, 4
  %539 = icmp eq i64 %index.next954, %n.vec935
  br i1 %539, label %middle.block930, label %vector.body938, !llvm.loop !43

middle.block930:                                  ; preds = %vector.body938
  %cmp.n955 = icmp eq i64 %518, %n.vec935
  %540 = shufflevector <4 x float> %533, <4 x float> %535, <2 x i32> <i32 3, i32 7>
  br i1 %cmp.n955, label %._crit_edge739, label %scalar.ph931.preheader

scalar.ph931.preheader:                           ; preds = %middle.block930, %vector.memcheck910, %vector.scevcheck901, %.lr.ph738
  %.6736.ph = phi i64 [ 1, %vector.memcheck910 ], [ 1, %vector.scevcheck901 ], [ 1, %.lr.ph738 ], [ %ind.end936, %middle.block930 ]
  %541 = shufflevector <2 x float> %519, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %542 = insertelement <2 x float> %541, float %522, i64 1
  %543 = shufflevector <2 x float> %519, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph931

scalar.ph931:                                     ; preds = %scalar.ph931.preheader, %scalar.ph931
  %.6736 = phi i64 [ %550, %scalar.ph931 ], [ %.6736.ph, %scalar.ph931.preheader ]
  %gep741 = getelementptr %struct.complex, ptr %invariant.gep740, i64 %.6736
  %544 = load <2 x float>, ptr %gep741, align 4, !tbaa !13
  %545 = fmul <2 x float> %544, %542
  %546 = shufflevector <2 x float> %545, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %547 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %543, <2 x float> %544, <2 x float> %546)
  %gep743 = getelementptr %struct.complex, ptr %invariant.gep742, i64 %.6736
  %548 = load <2 x float>, ptr %gep743, align 4, !tbaa !13
  %549 = fadd <2 x float> %547, %548
  store <2 x float> %549, ptr %gep743, align 4, !tbaa !13
  %550 = add nuw i64 %.6736, 1
  %exitcond815.not = icmp eq i64 %.6736, %518
  br i1 %exitcond815.not, label %._crit_edge739, label %scalar.ph931, !llvm.loop !44

._crit_edge739:                                   ; preds = %scalar.ph931, %middle.block930
  %551 = phi <2 x float> [ %540, %middle.block930 ], [ %547, %scalar.ph931 ]
  store <2 x float> %551, ptr %13, align 8, !tbaa !13
  br label %552

552:                                              ; preds = %._crit_edge739, %517
  %553 = add nuw nsw i64 %.2749, 1
  %exitcond816.not = icmp eq i64 %553, %.4771
  %indvar.next915 = add i64 %indvar914, 1
  br i1 %exitcond816.not, label %._crit_edge752, label %487, !llvm.loop !45

._crit_edge752:                                   ; preds = %552, %.loopexit657
  %554 = phi i64 [ %485, %.loopexit657 ], [ %518, %552 ]
  %555 = load i64, ptr %3, align 8, !tbaa !5
  %556 = add nuw i64 %.4771, 1
  %.not634766.not = icmp slt i64 %.4771, %555
  br i1 %.not634766.not, label %.lr.ph769, label %.loopexit656

.lr.ph769:                                        ; preds = %._crit_edge752
  %557 = mul nsw i64 %.4771, %22
  %invariant.gep760 = getelementptr %struct.complex, ptr %24, i64 %557
  %558 = getelementptr i8, ptr %354, i64 %374
  %559 = getelementptr i8, ptr %356, i64 %374
  %560 = getelementptr i8, ptr %357, i64 %374
  br label %561

561:                                              ; preds = %.lr.ph769, %625
  %indvar881 = phi i64 [ 0, %.lr.ph769 ], [ %indvar.next882, %625 ]
  %562 = phi i64 [ %554, %.lr.ph769 ], [ %591, %625 ]
  %.3767 = phi i64 [ %556, %.lr.ph769 ], [ %626, %625 ]
  %563 = mul i64 %344, %indvar881
  %scevgep883 = getelementptr i8, ptr %558, i64 %563
  %scevgep884 = getelementptr i8, ptr %559, i64 %563
  %scevgep888 = getelementptr i8, ptr %560, i64 %563
  br i1 %.not626, label %578, label %564

564:                                              ; preds = %561
  %565 = mul nsw i64 %.3767, %16
  %566 = getelementptr %struct.complex, ptr %379, i64 %565
  call void @r_cnjg(ptr noundef nonnull %13, ptr noundef %566) #5
  %567 = load float, ptr %4, align 4, !tbaa !9
  %568 = load float, ptr %338, align 4, !tbaa !12
  %569 = fneg float %568
  %570 = load <2 x float>, ptr %13, align 8, !tbaa !13
  %571 = insertelement <2 x float> poison, float %568, i64 0
  %572 = insertelement <2 x float> %571, float %569, i64 1
  %573 = fmul <2 x float> %570, %572
  %574 = shufflevector <2 x float> %573, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %575 = insertelement <2 x float> poison, float %567, i64 0
  %576 = shufflevector <2 x float> %575, <2 x float> poison, <2 x i32> zeroinitializer
  %577 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %576, <2 x float> %570, <2 x float> %574)
  %.pre835 = load i64, ptr %2, align 8, !tbaa !5
  br label %590

578:                                              ; preds = %561
  %579 = load float, ptr %4, align 4, !tbaa !9
  %gep765 = getelementptr %struct.complex, ptr %invariant.gep746, i64 %.3767
  %580 = load float, ptr %338, align 4, !tbaa !12
  %581 = fneg float %580
  %582 = load <2 x float>, ptr %gep765, align 4, !tbaa !13
  %583 = insertelement <2 x float> poison, float %580, i64 0
  %584 = insertelement <2 x float> %583, float %581, i64 1
  %585 = fmul <2 x float> %582, %584
  %586 = shufflevector <2 x float> %585, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %587 = insertelement <2 x float> poison, float %579, i64 0
  %588 = shufflevector <2 x float> %587, <2 x float> poison, <2 x i32> zeroinitializer
  %589 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %588, <2 x float> %582, <2 x float> %586)
  br label %590

590:                                              ; preds = %578, %564
  %591 = phi i64 [ %.pre835, %564 ], [ %562, %578 ]
  %592 = phi <2 x float> [ %577, %564 ], [ %589, %578 ]
  %.not636753 = icmp slt i64 %591, 1
  br i1 %.not636753, label %625, label %.lr.ph756

.lr.ph756:                                        ; preds = %590
  %593 = mul nsw i64 %.3767, %19
  %invariant.gep758 = getelementptr %struct.complex, ptr %21, i64 %593
  %594 = extractelement <2 x float> %592, i64 1
  %595 = fneg float %594
  %min.iters.check = icmp ult i64 %591, 8
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.scevcheck

vector.scevcheck:                                 ; preds = %.lr.ph756
  %596 = add nsw i64 %591, -1
  %mul.result = shl i64 %596, 3
  %597 = getelementptr i8, ptr %scevgep873, i64 %mul.result
  %598 = icmp ult ptr %597, %scevgep873
  %mul.result876 = shl i64 %596, 3
  %mul.overflow877 = icmp ugt i64 %596, 2305843009213693951
  %599 = getelementptr i8, ptr %scevgep874, i64 %mul.result876
  %600 = icmp ult ptr %599, %scevgep874
  %601 = or i1 %600, %mul.overflow877
  %602 = or i1 %598, %601
  br i1 %602, label %scalar.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %vector.scevcheck
  %603 = shl i64 %591, 3
  %scevgep880 = getelementptr i8, ptr %gep1154, i64 %603
  %scevgep885 = getelementptr i8, ptr %scevgep884, i64 %603
  %scevgep887 = getelementptr i8, ptr %scevgep878, i64 %603
  %scevgep889 = getelementptr i8, ptr %scevgep883, i64 %603
  %bound0 = icmp ult ptr %scevgep878, %scevgep885
  %bound1 = icmp ult ptr %scevgep883, %scevgep880
  %found.conflict = and i1 %bound0, %bound1
  %bound0890 = icmp ult ptr %scevgep886, %scevgep889
  %bound1891 = icmp ult ptr %scevgep888, %scevgep887
  %found.conflict892 = and i1 %bound0890, %bound1891
  %conflict.rdx = or i1 %found.conflict, %found.conflict892
  br i1 %conflict.rdx, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %vector.memcheck
  %n.vec = and i64 %591, 4611686018427387900
  %ind.end = or disjoint i64 %n.vec, 1
  %broadcast.splatinsert = insertelement <4 x float> poison, float %595, i64 0
  %broadcast.splat = shufflevector <4 x float> %broadcast.splatinsert, <4 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splat895 = shufflevector <2 x float> %592, <2 x float> poison, <4 x i32> zeroinitializer
  %broadcast.splat897 = shufflevector <2 x float> %592, <2 x float> poison, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
  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
  %604 = getelementptr %struct.complex, ptr %invariant.gep758, i64 %offset.idx
  %wide.vec = load <8 x float>, ptr %604, 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.vec893 = shufflevector <8 x float> %wide.vec, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %605 = fmul <4 x float> %strided.vec893, %broadcast.splat
  %606 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat895, <4 x float> %strided.vec, <4 x float> %605)
  %607 = fmul <4 x float> %broadcast.splat897, %strided.vec
  %608 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %broadcast.splat895, <4 x float> %strided.vec893, <4 x float> %607)
  %609 = getelementptr %struct.complex, ptr %invariant.gep760, i64 %offset.idx
  %wide.vec898 = load <8 x float>, ptr %609, align 4, !tbaa !13
  %strided.vec899 = shufflevector <8 x float> %wide.vec898, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  %strided.vec900 = shufflevector <8 x float> %wide.vec898, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
  %610 = fadd <4 x float> %606, %strided.vec899
  %611 = fadd <4 x float> %608, %strided.vec900
  %interleaved.vec = shufflevector <4 x float> %610, <4 x float> %611, <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 %609, align 4, !tbaa !13
  %index.next = add nuw i64 %index, 4
  %612 = icmp eq i64 %index.next, %n.vec
  br i1 %612, label %middle.block, label %vector.body, !llvm.loop !46

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %591, %n.vec
  %613 = shufflevector <4 x float> %606, <4 x float> %608, <2 x i32> <i32 3, i32 7>
  br i1 %cmp.n, label %._crit_edge757, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %vector.memcheck, %vector.scevcheck, %.lr.ph756
  %.7754.ph = phi i64 [ 1, %vector.memcheck ], [ 1, %vector.scevcheck ], [ 1, %.lr.ph756 ], [ %ind.end, %middle.block ]
  %614 = shufflevector <2 x float> %592, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %615 = insertelement <2 x float> %614, float %595, i64 1
  %616 = shufflevector <2 x float> %592, <2 x float> poison, <2 x i32> zeroinitializer
  br label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %.7754 = phi i64 [ %623, %scalar.ph ], [ %.7754.ph, %scalar.ph.preheader ]
  %gep759 = getelementptr %struct.complex, ptr %invariant.gep758, i64 %.7754
  %617 = load <2 x float>, ptr %gep759, align 4, !tbaa !13
  %618 = fmul <2 x float> %617, %615
  %619 = shufflevector <2 x float> %618, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %620 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %616, <2 x float> %617, <2 x float> %619)
  %gep761 = getelementptr %struct.complex, ptr %invariant.gep760, i64 %.7754
  %621 = load <2 x float>, ptr %gep761, align 4, !tbaa !13
  %622 = fadd <2 x float> %620, %621
  store <2 x float> %622, ptr %gep761, align 4, !tbaa !13
  %623 = add nuw i64 %.7754, 1
  %exitcond817.not = icmp eq i64 %.7754, %591
  br i1 %exitcond817.not, label %._crit_edge757, label %scalar.ph, !llvm.loop !47

._crit_edge757:                                   ; preds = %scalar.ph, %middle.block
  %624 = phi <2 x float> [ %613, %middle.block ], [ %620, %scalar.ph ]
  store <2 x float> %624, ptr %13, align 8, !tbaa !13
  br label %625

625:                                              ; preds = %._crit_edge757, %590
  %626 = add nuw nsw i64 %.3767, 1
  %.not634.not = icmp slt i64 %.3767, %555
  %indvar.next882 = add i64 %indvar881, 1
  br i1 %.not634.not, label %561, label %.loopexit656, !llvm.loop !48

.loopexit.loopexit.unr-lcssa:                     ; preds = %.preheader, %.preheader.preheader
  %indvar.unr = phi i64 [ 0, %.preheader.preheader ], [ %indvar.next.7, %.preheader ]
  %lcmp.mod1127.not = icmp eq i64 %xtraiter1126, 0
  br i1 %lcmp.mod1127.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 ]
  %627 = mul i64 %81, %indvar.epil
  %scevgep.epil = getelementptr i8, ptr %10, i64 %627
  tail call void @llvm.memset.p0.i64(ptr align 4 %scevgep.epil, i8 0, i64 %82, 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, %xtraiter1126
  br i1 %epil.iter.cmp.not, label %.loopexit, label %.preheader.epil, !llvm.loop !49

.loopexit:                                        ; preds = %._crit_edge675, %._crit_edge704, %.loopexit656, %._crit_edge777, %.loopexit.loopexit.unr-lcssa, %.preheader.epil, %.lr.ph714, %.lr.ph685, %137, %236, %337, %57, %70, %.thread
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %14) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #5
  ret i32 0
}

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

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

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

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

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

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

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

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

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"long", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !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}
!29 = !{!"llvm.loop.unswitch.partial.disable"}
!30 = distinct !{!30, !15}
!31 = distinct !{!31, !15}
!32 = distinct !{!32, !15, !29}
!33 = distinct !{!33, !15}
!34 = distinct !{!34, !15, !22, !23}
!35 = distinct !{!35, !15, !22}
!36 = !{!37}
!37 = distinct !{!37, !38}
!38 = distinct !{!38, !"LVerDomain"}
!39 = !{!40}
!40 = distinct !{!40, !38}
!41 = distinct !{!41, !15, !22, !23}
!42 = distinct !{!42, !15, !22}
!43 = distinct !{!43, !15, !22, !23}
!44 = distinct !{!44, !15, !22}
!45 = distinct !{!45, !15}
!46 = distinct !{!46, !15, !22, !23}
!47 = distinct !{!47, !15, !22}
!48 = distinct !{!48, !15}
!49 = distinct !{!49, !50}
!50 = !{!"llvm.loop.unroll.disable"}


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